*   `tf.data.Dataset.zip` now supports Python-style zipping, i.e. `Dataset.zip(a, b, c)`.
    * `tf.data.Dataset.shuffle` now supports `tf.data.UNKNOWN_CARDINALITY` When doing a "full shuffle" using  `dataset = dataset.shuffle(dataset.cardinality())`. But remember, a "full shuffle" will load the full dataset into memory so that it can be shuffled, so make sure to only use this with small datasets or datasets of small objects (like filenames).

*   `tf.math`

          "handSize": {
            "default": 0,

          "handSize": {
            "default": 0,

		{"(*Rand).Int63n", Method, 0},
		{"(*Rand).Intn", Method, 0},
		{"(*Rand).NormFloat64", Method, 0},
		{"(*Rand).Perm", Method, 0},
		{"(*Rand).Read", Method, 6},
		{"(*Rand).Seed", Method, 0},
		{"(*Rand).Shuffle", Method, 10},
		{"(*Rand).Uint32", Method, 0},
		{"(*Rand).Uint64", Method, 8},
		{"(*Zipf).Uint64", Method, 0},
		{"ExpFloat64", Func, 0},
		{"Float32", Func, 0},
		{"Float64", Func, 0},

		// Note: we load C symbols before Go symbols, so we can scan from the start.
		for i < len(textp) && (ldr.SubSym(textp[i]) != 0 || ldr.AttrSubSymbol(textp[i])) {
			i++
		}
		textp = textp[i:]
		r.Shuffle(len(textp), func(i, j int) {
			textp[i], textp[j] = textp[j], textp[i]
		})
	}

	text := ctxt.xdefine("runtime.text", sym.STEXT, 0)
	etext := ctxt.xdefine("runtime.etext", sym.STEXT, 0)

		abc.Lookup("b"),
		xyz.Lookup("b"),
		uvw.Lookup("c"),
		gr.Lookup("φ"),
	}
	if len(data) != len(want) {
		t.Fatal("want and data must match")
	}
	if reflect.DeepEqual(data, want) {
		t.Fatal("data must be shuffled")
	}
	sort.Slice(data, func(i, j int) bool { return data[i].Less(data[j]) })
	if !reflect.DeepEqual(data, want) {
		t.Logf("want: %#v", want)
		t.Logf("data: %#v", data)
		t.Errorf("sorting failed")
	}

                    PluginTree.PluginSpec("flat-plugin.conflict", "IgnoredPlugin"),
                    PluginTree.PluginSpec("nested.plugin-a.conflict", "IgnoredPlugin")
                ).shuffled().asSequence()
            ),
            equalTo<Map<String, PluginTree>>(
                linkedMapOf(
                    flatPlugin.id to flatPlugin,
                    "nested" to PluginTree.PluginGroup(

	}

	// already sorted
	data.initB()
	SortStableFunc(data, intPairCmp)
	if !IsSortedFunc(data, intPairCmp) {
		t.Errorf("Stable shuffled sorted %d ints (order)", n)
	}
	if !data.inOrder(false) {
		t.Errorf("Stable shuffled sorted %d ints (stability)", n)
	}

	// sorted reversed
	for i := 0; i < len(data); i++ {
		data[i].a = len(data) - i
	}
	data.initB()

  int32_t num_values = op.num_inputs() / 2;

  // Stop propagation along the indices list
  for (int32_t i = 0; i < num_values; i++) {
    grad_outputs->push_back(NoGradient());
  }

  // DynamicStitch shuffles its data to the output (using items in
  // indices) so the gradient propagated to a given data input simply
  // selects the gradient for its output position.
  for (int32_t i = 0; i < num_values; i++) {

  // Pad spatial dimensions.
  %4 = "tf.Pad"(%3, %0) : (tensor<?x3x224x224xf32>, tensor<4x2xi32>) -> tensor<?x3x230x230xf32>

  // Shuffled paddings.
  // CHECK: %[[PADDINGS:.*]] = "tf.Const"(){{.*}}[0, 0], [3, 3], [3, 3], [0, 0]
  // NOFOLD: %[[PADDING:.*]] = "tf.Const"(){{.*}}[0, 0], [0, 0], [3, 3], [3, 3]