00000150  88 7a 36 47 a5 08 0d 92  42 5b c2 81 c0 be 97 79  |.z6G....B[.....y|
00000160  98 40 fb 4f 6d 14 fd 2b  13 8b c2 a5 2e 67 d8 d4  |.@.Om..+.....g..|
00000170  09 9e d6 22 38 b7 4a 0b  74 73 2b c2 34 f1 d1 93  |..."8.J.ts+.4...|
00000180  e5 96 d9 74 7b f3 58 9f  6c 61 3c c0 b0 41 d4 d9  |...t{.X.la<..A..|
00000190  2b 2b 24 23 77 5b 1c 3b  bd 75 5d ce 20 54 cf a1  |++$#w[.;.u]. T..|

	b := int64(x)
	return a, b
}

var a, b, c float64

// Poison some floating point registers with non-zero high bits.
//
//go:noinline
func poison(x float64) {
	a = x - 123.45
	b = a * 1.2
	c = b + 3.4
}

func main() {
	poison(333.3)
	_, b := F(123)
	if b != 123 {
		panic("FAIL")
	}

func TestEdit(t *testing.T) {
	b := NewBuffer([]byte("0123456789"))
	b.Insert(8, ",7½,")
	b.Replace(9, 10, "the-end")
	b.Insert(10, "!")
	b.Insert(4, "3.14,")
	b.Insert(4, "π,")
	b.Insert(4, "3.15,")
	b.Replace(3, 4, "three,")
	want := "012three,3.14,π,3.15,4567,7½,8the-end!"

	s := b.String()
	if s != want {
		t.Errorf("b.String() = %q, want %q", s, want)
	}
	sb := b.Bytes()
	if string(sb) != want {

	SYS_BRK_        = 24
	SYS_REMOVE      = 25
	SYS_NOTIFY      = 28
	SYS_NOTED       = 29
	SYS_SEGATTACH   = 30
	SYS_SEGDETACH   = 31
	SYS_SEGFREE     = 32
	SYS_SEGFLUSH    = 33
	SYS_RENDEZVOUS  = 34
	SYS_UNMOUNT     = 35
	SYS_SEMACQUIRE  = 37
	SYS_SEMRELEASE  = 38
	SYS_SEEK        = 39
	SYS_FVERSION    = 40
	SYS_ERRSTR      = 41
	SYS_STAT        = 42
	SYS_FSTAT       = 43
	SYS_WSTAT       = 44

type Z struct {
}

type NZ struct {
	x, y int
}

//go:noinline
func f(x, y int) (Z, NZ, Z) {
	var z Z
	return z, NZ{x, y}, z
}

//go:noinline
func g() (Z, NZ, Z) {
	a, b, c := f(3, 4)
	return c, b, a
}

func main() {
	_, b, _ := g()
	fmt.Println(b.x + b.y)

	f("1", 2, 3.1, "4")
	f(1, 0.5, "hello", 4, 5) // ERROR "too many arguments|incompatible type"
	g(1, 0.5)                // ERROR "not enough arguments|incompatible type"
	g("1", 2, 3.1)
	g(1, 0.5, []int{3, 4}...) // ERROR "not enough arguments|incompatible type"
	g("1", 2, 3.1, "4", "5")
	g(1, 0.5, "hello", 4, []int{5, 6}...) // ERROR "too many arguments|truncated to integer"

-- expect --
FAILURE ".*expected a proc but didn't have one.*"
-- trace --
Trace Go1.22
EventBatch gen=1 m=0 time=0 size=34
GoCreateSyscall dt=1 new_g=4
ProcStatus dt=1 p=0 pstatus=2
ProcStart dt=1 p=0 p_seq=1
GoSyscallEndBlocked dt=1
GoStart dt=1 g=4 g_seq=1
GoSyscallBegin dt=1 p_seq=2 stack=0
GoDestroySyscall dt=1
GoCreateSyscall dt=1 new_g=4
GoSyscallEnd dt=1
GoSyscallBegin dt=1 p_seq=3 stack=0
GoDestroySyscall dt=1

00000100  45 88 7a 36 47 a5 08 0d  92 42 5b c2 81 c0 be 97  |E.z6G....B[.....|
00000110  79 98 40 fb 4f 6d 14 fd  2b 13 8b c2 a5 2e 67 d8  |y.@.Om..+.....g.|
00000120  d4 09 9e d6 22 38 b7 4a  0b 74 73 2b c2 34 f1 d1  |...."8.J.ts+.4..|
00000130  93 e5 96 d9 74 7b f3 58  9f 6c 61 3c c0 b0 41 d4  |....t{.X.la<..A.|
00000140  d9 2b 2b 24 23 77 5b 1c  3b bd 75 5d ce 20 54 cf  |.++$#w[.;.u]. T.|

                  .Attr("type", DT_INT8)
                  .Attr("T", DT_INT64)
                  .Input(FakeInput(DT_INT64))
                  .Finalize(&def));
  shape_inference::InferenceContext c(0, def, op_def, {S({3, 4})}, {}, {}, {});
  std::vector<shape_inference::ShapeHandle> input_shapes;
  TF_CHECK_OK(c.input("input", &input_shapes));
  ASSERT_EQ("[3,4]", c.DebugString(input_shapes[0]));
  TF_CHECK_OK(reg->shape_inference_fn(&c));

    ticker.advance(16);

    stopwatch.start();
    assertEquals(9, stopwatch.elapsed(NANOSECONDS));
    ticker.advance(25);
    assertEquals(34, stopwatch.elapsed(NANOSECONDS));

    stopwatch.stop();
    ticker.advance(36);
    assertEquals(34, stopwatch.elapsed(NANOSECONDS));
  }

  public void testElapsed_micros() {
    stopwatch.start();
    ticker.advance(999);