{`a{2}?`, `nrep{2,2 lit{a}}`},
	{`a{2,3}?`, `nrep{2,3 lit{a}}`},
	{`a{2,}?`, `nrep{2,-1 lit{a}}`},
	// Malformed { } are treated as literals.
	{`x{1001`, `str{x{1001}`},
	{`x{9876543210`, `str{x{9876543210}`},
	{`x{9876543210,`, `str{x{9876543210,}`},
	{`x{2,1`, `str{x{2,1}`},
	{`x{1,9876543210`, `str{x{1,9876543210}`},
	{``, `emp{}`},
	{`|`, `emp{}`}, // alt{emp{}emp{}} but got factored
	{`|x|`, `alt{emp{}lit{x}emp{}}`},

			expectedError: true,
		},
		{
			name:          "invalid port(out of range, positive port number)",
			hostport:      "cp.k8s.io:987654321",
			expectedError: true,
		},
		{
			name:          "invalid port(out of range, negative port number)",
			hostport:      "cp.k8s.io:-987654321",
			expectedError: true,
		},
		{
			name:          "invalid port(out of range, negative port number)",

		{"98765432100", 98765432100, true},
		{"9223372036854775807", 1<<63 - 1, true},

		// Good trivial suffix inputs.
		{"1B", 1, true},
		{"12345B", 12345, true},
		{"012345B", 12345, true},
		{"98765432100B", 98765432100, true},
		{"9223372036854775807B", 1<<63 - 1, true},

		// Good binary suffix inputs.
		{"1KiB", 1 << 10, true},
		{"05KiB", 5 << 10, true},
		{"1MiB", 1 << 20, true},
		{"10MiB", 10 << 20, true},

		}
	}
}

func TestMakeFloat64(t *testing.T) {
	var zero float64
	for _, arg := range []float64{
		-math.MaxFloat32,
		-10,
		-0.5,
		-zero,
		zero,
		1,
		10,
		123456789.87654321e-23,
		1e10,
		math.MaxFloat64,
	} {
		val := MakeFloat64(arg)
		if val.Kind() != Float {
			t.Errorf("%v: got kind = %d; want %d", arg, val.Kind(), Float)
		}

		// -0.0 is mapped to 0.0

		{"0.123456789abcdef", time.Time{}, false},
		{"foo", time.Time{}, false},
		{"\x00", time.Time{}, false},
		{"𝟵𝟴𝟳𝟲𝟱.𝟰𝟯𝟮𝟭𝟬", time.Time{}, false}, // Unicode numbers (U+1D7EC to U+1D7F5)
		{"98765﹒43210", time.Time{}, false}, // Unicode period (U+FE52)
	}

	for _, v := range vectors {
		ts, err := parsePAXTime(v.in)
		ok := (err == nil)
		if v.ok != ok {
			if v.ok {

  %cst = "tf.Const"() {value = dense<[32, 12, 12, 64]> : tensor<4xi32>} : () -> tensor<4xi32>
  %0 = "tf.RandomUniform"(%cst) {seed = 87654321 : i64, seed2 = 0 : i64} : (tensor<4xi32>) -> tensor<32x12x12x64xf32>
    // CHECK: return %17 : tensor<32x12x12x64xf32>
  func.return %0 : tensor<32x12x12x64xf32>
}

// CHECK-LABEL: slice_variable_start

            "+1.+2.+3.4",
            "1.2.3.4e0",
            "6:5:4:3:2:1:0", // too few parts
            "::7:6:5:4:3:2:1:0", // too many parts
            "7:6:5:4:3:2:1:0::", // too many parts
            "9:8:7:6:5:4:3::2:1", // too many parts
            "0:1:2:3::4:5:6:7", // :: must remove at least one 0.
            "3ffe:0:0:0:0:0:0:0:1", // too many parts (9 instead of 8)
            "3ffe::10000", // hextet exceeds 16 bits

      %outputs_4, %control_5 = tf_executor.island wraps "tf.RandomUniform"(%outputs_2) {device = "", seed = 87654321 : i64, seed2 = 0 : i64} : (tensor<1xi32>) -> tensor<*xf32>
      %outputs_6, %control_7 = tf_executor.island wraps "tf.AddV2"(%arg2, %outputs) {device = ""} : (tensor<i32>, tensor<i32>) -> tensor<*xi32>

		}
	}
}

type funNN func(z, x, y nat) nat
type argNN struct {
	z, x, y nat
}

var sumNN = []argNN{
	{},
	{nat{1}, nil, nat{1}},
	{nat{1111111110}, nat{123456789}, nat{987654321}},
	{nat{0, 0, 0, 1}, nil, nat{0, 0, 0, 1}},
	{nat{0, 0, 0, 1111111110}, nat{0, 0, 0, 123456789}, nat{0, 0, 0, 987654321}},
	{nat{0, 0, 0, 1}, nat{0, 0, _M}, nat{0, 0, 1}},
}

var prodNN = []argNN{
	{},