00000040  00 00 00 00 00 00 00 00  00 00 00 00 13 03 00 00  |................|
00000050  4f 00 2b 00 02 03 04 00  33 00 45 00 17 00 41 04  |O.+.....3.E...A.|
00000060  f0 2e aa 75 ea 32 f4 3c  ea b7 61 13 0f 22 8d 39  |...u.2.<..a..".9|
00000070  9e 0a 53 c8 d6 92 ea 5e  87 5b 46 d3 71 2d d1 df  |..S....^.[F.q-..|
00000080  fa 1e 9a 6a 0e b2 bc d7  91 6e 26 56 17 24 11 d8  |...j.....n&V.$..|

        rng.uniform(low=0.0, high=1.0, size=x_signature).astype('f4')
    )

    def data_gen() -> repr_dataset.RepresentativeDataset:
      for _ in range(100):
        yield {
            'x': ops.convert_to_tensor(
                np.random.uniform(low=0.0, high=1.0, size=x_signature).astype(
                    'f4'
                )
            ),
        }

	"\xE9", "%E9",
	"\xEA", "%EA",
	"\xEB", "%EB",
	"\xEC", "%EC",
	"\xED", "%ED",
	"\xEE", "%EE",
	"\xEF", "%EF",
	"\xF0", "%F0",
	"\xF1", "%F1",
	"\xF2", "%F2",
	"\xF3", "%F3",
	"\xF4", "%F4",
	"\xF5", "%F5",
	"\xF6", "%F6",
	"\xF7", "%F7",
	"\xF8", "%F8",
	"\xF9", "%F9",
	"\xFA", "%FA",
	"\xFB", "%FB",
	"\xFC", "%FC",
	"\xFD", "%FD",
	"\xFE", "%FE",
	"\xFF", "%FF",

		continue L2 /* ERROR "invalid continue label L2" */
		continue L3
		goto L1
		goto L2
		goto L3
	}
}

// Blank labels are never declared.

func f4() {
_:
_: // multiple blank labels are ok
	goto _ /* ERROR "label _ not declared" */
}

func f5() {
_:
	for {
		break _ /* ERROR "invalid break label _" */

    assertEscaping(e, "%EF%BF%BF", '\uffff'); // xxx-1111,x-111111,x-11,1111
    assertUnicodeEscaping(e, "%F0%90%80%80", '\uD800', '\uDC00');
    assertUnicodeEscaping(e, "%F4%8F%BF%BF", '\uDBFF', '\uDFFF');

    assertEquals("", e.escape(""));
    assertEquals("safestring", e.escape("safestring"));
    assertEquals("embedded%00null", e.escape("embedded\0null"));

	_, _ = m3a, m3b
}

// Declaration of parameters and results
func f0() {}
func f1(a /* ERROR "not a type" */) {}
func f2(a, b, c d /* ERROR "not a type" */) {}

func f3() int { return 0 }
func f4() a /* ERROR "not a type" */ { return 0 }
func f5() (a, b, c d /* ERROR "not a type" */) { return }

func f6(a, b, c int) complex128 { return 0 }

// Declaration of receivers
type T struct{}

00000080  03 03 00 01 01 17 03 03  00 17 e2 d2 17 5f 12 74  |............._.t|
00000090  c1 79 bc 63 27 63 e7 52  05 50 f5 13 16 ea 3e 9e  |.y.c'c.R.P....>.|
000000a0  19 17 03 03 02 6d dd 67  27 89 03 8e f4 db 9b 65  |.....m.g'......e|
000000b0  bc ff 5e 8a 9b a2 20 3c  4d ee b2 98 e3 52 94 b1  |..^... <M....R..|
000000c0  ab b2 6c 96 31 08 29 d8  f8 f3 a6 86 42 1e 82 42  |..l.1.).....B..B|

00000190  e3 63 b1 9c ea dd 47 0a  ca 63 9e 50 9d ca 57 12  |.c....G..c.P..W.|
000001a0  05 9b fc f1 26 a2 5e 18  9b 32 00 38 1f ce a6 58  |....&.^..2.8...X|
000001b0  58 0f 61 e2 44 c2 89 34  cc f4 fd 9a dc 1a 67 a6  |X.a.D..4......g.|
000001c0  e8 b1 fc 9f dc bd 0b 21  01 49 0d 9b e1 40 00 f6  |.......!.I...@..|
000001d0  33 1a 57 c5 84 c1 98 3d  7f 53 d3 4d 2e 04 5e 40  |3.W....=.S.M..^@|

        for range m2 /* ERRORx `cannot range over m2.*no core type` */ {}
}

// type inference checks

var _ = new /* ERROR "cannot infer T" */ ()

func f4[A, B, C any](A, B) C { panic(0) }

var _ = f4 /* ERROR "cannot infer C" */ (1, 2)
var _ = f4[int, float32, complex128](1, 2)

func f5[A, B, C any](A, []*B, struct{f []C}) int { panic(0) }

var _ = f5[int, float32, complex128](0, nil, struct{f []complex128}{})

000000d0  52 c7 c2 84 cb 48 81 a3  da bd a1 50 5c ec 5c a7  |R....H.....P\.\.|
000000e0  10 01 58 cc 03 c3 53 04  03 69 80 f4 ad 4d ce 72  |..X...S..i...M.r|
000000f0  26 4e 6c c7 2c 31 69 2b  fd 97 67 5e 7d e0 05 b3  |&Nl.,1i+..g^}...|
00000100  f4 40 64 a1 bd a3 fd a8  f9 7b 18 82 89 8f 25 f9  |.@d......{....%.|
00000110  ca ca c4 8f e4 90 7b 26  7a d5 b2 1e fa 05 db ad  |......{&z.......|