fmt.Printf("uint8(253)>>0 = %v, wanted 253\n", got)
		failed = true
	}
	if got := f1(0, 2, 1, 0, 0, 1, true); got != 255 {
		fmt.Printf("f1(...) = %v, wanted 255\n", got)
		failed = true
	}
	if got := f2(1); got != 242 {
		fmt.Printf("f2(...) = %v, wanted 242\n", got)
		failed = true
	}
	if got := f3(false, 0, 0); got != 254 {
		fmt.Printf("f3(...) = %v, wanted 254\n", got)
		failed = true
	}
	if failed {

				}
				wantNG(1)
			}
			wantNG(1)
			if end < 3 {
				stop()
				wantNG(0)
			}
			for range 2 {
				v, ok := next()
				if v != 0 || ok != false {
					t.Fatalf("next() = %d, %v, want %d, %v", v, ok, 0, false)
				}
				wantNG(0)
			}
			wantNG(0)

			stop()
			stop()
			stop()
			wantNG(0)
		})
	}
}

func TestPull2(t *testing.T) {

package version

import (
	"testing"

	"istio.io/istio/pkg/monitoring/monitortest"
)

func TestRecordComponentBuildTag(t *testing.T) {
	cases := []struct {
		name    string
		in      BuildInfo
		wantTag string
	}{
		{
			"record",
			BuildInfo{
				Version:       "VER",
				GitRevision:   "GITREV",
				GolangVersion: "GOLANGVER",
				BuildStatus:   "STATUS",
				GitTag:        "1.0.5-test",
			},

	if len(tab.baseList) != 1+len(tab.indexMap) { // indexMap omits nil
		t.Errorf("table length discrepancy: %d != 1+%d", len(tab.baseList), len(tab.indexMap))
	}

	const wantLen = 4
	if len(tab.baseList) != wantLen {
		t.Errorf("got table length %d; want %d", len(tab.baseList), wantLen)
	}

	if got := tab.XPos(NoPos); got != NoXPos {
		t.Errorf("XPos(NoPos): got %v; want %v", got, NoXPos)
	}

	defer func() {
		if globint1 != 1 {
			t.Fatalf("globint1:  wanted: 1, got %v", globint1)
		}
		if save1 != 5 {
			t.Fatalf("save1:  wanted: 5, got %v", save1)
		}
		if globint2 != 1 {
			t.Fatalf("globint2:  wanted: 1, got %v", globint2)
		}
		if save2 != 2 {
			t.Fatalf("save2:  wanted: 2, got %v", save2)
		}
		if save3 != 4 {
			t.Fatalf("save3:  wanted: 4, got %v", save3)
		}
		if globint3 != 1 {

	}
	if got := cvt7(3.5); got != 3 {
		t.Errorf("cvt7 got %d, wanted 3", got)
	}
	if got := cvt8(3.5); got != 3 {
		t.Errorf("cvt8 got %d, wanted 3", got)
	}
	if got := cvt9(3.5); got != 3 {
		t.Errorf("cvt9 got %d, wanted 3", got)
	}
	if got := cvt10(3.5); got != 3 {
		t.Errorf("cvt10 got %d, wanted 3", got)
	}
	if got := cvt11(3.5); got != 3 {
		t.Errorf("cvt11 got %d, wanted 3", got)

//go:noinline
func f8(x int32) bool {
	return byte(x&0xc0) == 64
}

//go:noinline
func f16(x int32) bool {
	return uint16(x&0x8040) == 64
}

func main() {
	if !f8(64) {
		panic("wanted true, got false")
	}
	if !f16(64) {
		panic("wanted true, got false")
	}

	if got, ok := gc(); ok {
		panic(fmt.Sprintf("got %v, %v, wanted -/false", got, ok))
	}
	gc2 := Combine2(g1, g2)
	if got, ok := gc2(); ok {
		panic(fmt.Sprintf("got %v, %v, wanted -/false", got, ok))
	}

	gc3 := Combine(g1, g3, _NewPair[int, string])
	if got, ok := gc3(); !ok || got.A != 3 || got.B != "y" {
		panic(fmt.Sprintf("got %v, %v, wanted {3, y}, true", got, ok))
	}
	gc4 := Combine2(g1, g3)

			t.Errorf("add_uint64 %d+%d = %d, wanted %d\n", v.a, v.b, got, v.add)
		}
		if got := sub_uint64_ssa(v.a, v.b); got != v.sub {
			t.Errorf("sub_uint64 %d-%d = %d, wanted %d\n", v.a, v.b, got, v.sub)
		}
		if v.b != 0 {
			if got := div_uint64_ssa(v.a, v.b); got != v.div {
				t.Errorf("div_uint64 %d/%d = %d, wanted %d\n", v.a, v.b, got, v.div)
			}

		}
		if v.b != 0 {

	}

	str := "BelowExactAbove"
	for i, test := range tests {
		if got := testInt64Index_ssa(str, test.i); got != test.b {
			t.Errorf("#%d got %d wanted %d", i, got, test.b)
		}
		if got := testInt64Slice_ssa(str, test.i, test.j); got != test.s {
			t.Errorf("#%d got %s wanted %s", i, got, test.s)
		}
	}
}

func testInt64IndexPanic(t *testing.T) {
	defer func() {
		if r := recover(); r != nil {