{-1*(1<<16) - 1, "00\x00", false},
		{537795476381659745, "0000000\x00", false},
		{537795476381659745, "\x80\x00\x00\x00\x07\x76\xa2\x22\xeb\x8a\x72\x61", true},
		{-615126028225187231, "0000000\x00", false},
		{-615126028225187231, "\xff\xff\xff\xff\xf7\x76\xa2\x22\xeb\x8a\x72\x61", true},
		{math.MaxInt64, "0000000\x00", false},
		{math.MaxInt64, "\x80\x00\x00\x00\x7f\xff\xff\xff\xff\xff\xff\xff", true},

00000c0 88 21 c4 00 00 14 00 eb ff 42 88 21 c4 00 00 14
00000d0 00 eb ff 42 88 21 c4 00 00 14 00 eb ff 42 88 21
00000e0 c4 00 00 00 00 ff ff 00 00 00 ff ff 00 34 00 cb
00000f0 ff 42 88 21 c4 00 00 00 00 ff ff 00 00 00 ff ff
0000100 00 34 00 cb ff 42 e8 21 5e 0f 00 00 00 ff ff 0a
0000110 f0 66 64 12 61 c0 15 dc e8 a0 48 bf 48 af 2a b3
0000120 20 c0 9b 95 0d c4 67 04 42 53 06 06 06 40 00 06

						sp >>>= 0;
						setInt64(sp + 8, (timeOrigin + performance.now()) * 1000000);
					},

					// func walltime() (sec int64, nsec int32)
					"runtime.walltime": (sp) => {
						sp >>>= 0;
						const msec = (new Date).getTime();
						setInt64(sp + 8, msec / 1000);
						this.mem.setInt32(sp + 16, (msec % 1000) * 1000000, true);
					},

					// func scheduleTimeoutEvent(delay int64) int32

		}
	}
}

func TestGrow(t *testing.T) {
	x := []byte{'x'}
	y := []byte{'y'}
	tmp := make([]byte, 72)
	for _, growLen := range []int{0, 100, 1000, 10000, 100000} {
		for _, startLen := range []int{0, 100, 1000, 10000, 100000} {
			xBytes := Repeat(x, startLen)

			buf := NewBuffer(xBytes)
			// If we read, this affects buf.off, which is good to test.
			readBytes, _ := buf.Read(tmp)

	{"$0x04", "$4"},
	{"$0x3FE", "$1022"},
	{"$0x7fffffe00000", "$140737486258176"},
	{"$0xfffffffffffff001", "$-4095"},
	{"$1", "$1"},
	{"$1.0", "$(1.0)"},
	{"$10", "$10"},
	{"$1000", "$1000"},
	{"$1000000", "$1000000"},
	{"$1000000000", "$1000000000"},
	{"$__tsan_func_enter(SB)", "$__tsan_func_enter(SB)"},
	{"$main(SB)", "$main(SB)"},
	{"$masks<>(SB)", "$masks<>(SB)"},
	{"$setg_gcc<>(SB)", "$setg_gcc<>(SB)"},

//	LMOVH addr ',' rreg
//	{
//		outcode(int($1), &$2, 0, &$4);
//	}
	MOVH	foo<>+3(SB), R2
	MOVH	(R20), R7	// 86870000
	MOVH	54(R11), R26	// 857a0036
	MOVH	-42(R3), R20	// 8474ffd6
	MOVHU	(R20), R7	// 96870000
	MOVHU	54(R11), R26	// 957a0036
	MOVHU	-42(R3), R20	// 9474ffd6

//	LMOVB addr ',' rreg
//	{
//		outcode(int($1), &$2, 0, &$4);
//	}
	MOVB	foo<>+3(SB), R2
	MOVB	(R4), R21	// 80950000

	FMOVD	F4, F5                 // 2854

	// RX (12-bit displacement) and RXY (20-bit displacement) instruction encoding (e.g. LD vs LDY)
	FMOVD	(R1), F0               // 68001000
	FMOVD	4095(R2), F13          // 68d02fff
	FMOVD	4096(R2), F15          // edf020000165
	FMOVS	4095(R2)(R3), F13      // 78d32fff
	FMOVS	4096(R2)(R4), F15      // edf420000164
	FMOVD	F0, 4095(R1)           // 60001fff

		}
	}()
	nestedCall(func() { panic("callback panic") })
	panic("nestedCall returned")
}

func testCallbackPanicLoop(t *testing.T) {
	// Make sure we don't blow out m->g0 stack.
	for i := 0; i < 100000; i++ {
		testCallbackPanic(t)
	}
}

func testCallbackPanicLocked(t *testing.T) {
	runtime.LockOSThread()
	defer runtime.UnlockOSThread()

	if !lockedOSThread() {

pkg syscall (netbsd-arm64-cgo), const RTM_REDIRECT ideal-int
pkg syscall (netbsd-arm64-cgo), const RTM_RESOLVE = 11
pkg syscall (netbsd-arm64-cgo), const RTM_RESOLVE ideal-int
pkg syscall (netbsd-arm64-cgo), const RTM_RTTUNIT = 1000000
pkg syscall (netbsd-arm64-cgo), const RTM_RTTUNIT ideal-int
pkg syscall (netbsd-arm64-cgo), const RTM_SETGATE = 18
pkg syscall (netbsd-arm64-cgo), const RTM_SETGATE ideal-int

	MOVB $0, R4                     // 38800000
	MOVBZ $0, R4                    // 38800000
	MOVH $0, R4                     // 38800000
	MOVHZ $0, R4                    // 38800000
	MOVW $0, R4                     // 38800000
	MOVWZ $0, R4                    // 38800000
	MOVD $0, R4                     // 38800000
	MOVD $0, R0                     // 38000000

	ADD $1, R3                      // 38630001