bad2 := "foo"

	p := syscall.Getpagesize()
	b, err := syscall.Mmap(-1, 0, p, syscall.PROT_READ|syscall.PROT_WRITE, syscall.MAP_ANON|syscall.MAP_PRIVATE)
	if err != nil {
		panic(err)
	}
	err = syscall.Mprotect(b, syscall.PROT_NONE)
	if err != nil {
		panic(err)
	}
	// write inaccessible pointers as the data fields of bad1 and bad2.
	(*reflect.StringHeader)(unsafe.Pointer(&bad1)).Data = uintptr(unsafe.Pointer(&b[0]))

		ir.OCALLMETH,
		ir.OCAP,
		ir.OCLEAR,
		ir.OCLOSE,
		ir.OCOMPLEX,
		ir.OCOPY,
		ir.ODELETE,
		ir.OIMAG,
		ir.OLEN,
		ir.OMAKE,
		ir.OMAX,
		ir.OMIN,
		ir.ONEW,
		ir.OPANIC,
		ir.OPRINT,
		ir.OPRINTLN,
		ir.OREAL,
		ir.ORECOVER,
		ir.ORECOVERFP,
		ir.ORECV,
		ir.OUNSAFEADD,
		ir.OUNSAFESLICE,
		ir.OUNSAFESLICEDATA,
		ir.OUNSAFESTRING,
		ir.OUNSAFESTRINGDATA:

// Requires 2 <= len(b) <= MaxLen.
func Index(a, b []byte) int {
	panic("unimplemented")
}

// IndexString returns the index of the first instance of b in a, or -1 if b is not present in a.
// Requires 2 <= len(b) <= MaxLen.
func IndexString(a, b string) int {
	panic("unimplemented")
}

// Cutover reports the number of failures of IndexByte we should tolerate

	return x + y
}

func main() {
	s := f(1) + f(2)
	if s != "aAbB" {
		println("BUG: bug221a: ", s)
		panic("fail")
	}
	s = g(f(3), f(4))
	if s != "cCdD" {
		println("BUG: bug221b: ", s)
		panic("fail")
	}
	s = f(5) + f(6) + f(7) + f(8) + f(9)
	if s != "eEfFgGhHiI" {
		println("BUG: bug221c: ", s)
		panic("fail")
	}

	v := ValueOf(slice)
	if v.Kind() != Slice {
		panic(&ValueError{Method: "Swapper", Kind: v.Kind()})
	}
	// Fast path for slices of size 0 and 1. Nothing to swap.
	switch v.Len() {
	case 0:
		return func(i, j int) { panic("reflect: slice index out of range") }
	case 1:
		return func(i, j int) {
			if i != 0 || j != 0 {
				panic("reflect: slice index out of range")
			}
		}
	}

func (s *fakeStmt) ColumnConverter(idx int) driver.ValueConverter {
	if s.panic == "ColumnConverter" {
		panic(s.panic)
	}
	if len(s.placeholderConverter) == 0 {
		return driver.DefaultParameterConverter
	}
	return s.placeholderConverter[idx]
}

func (s *fakeStmt) Close() error {
	if s.panic == "Close" {
		panic(s.panic)
	}
	if s.c == nil {
		panic("nil conn in fakeStmt.Close")
	}
	if s.c.db == nil {

		calls++
		panic("x")
	})
	testOncePanicX(t, &calls, func() { f() })
}

func TestOnceValuesPanic(t *testing.T) {
	calls := 0
	f := sync.OnceValues(func() (int, int) {
		calls++
		panic("x")
	})
	testOncePanicX(t, &calls, func() { f() })
}

func TestOnceFuncPanicNil(t *testing.T) {
	calls := 0
	f := sync.OnceFunc(func() {
		calls++
		panic(nil)
	})

		race.Acquire(unsafe.Pointer(&racer))
		if done {
			race.Release(unsafe.Pointer(&racer))
			return
		}
		yield := func(v1 V) bool {
			if done {
				return false
			}
			if !yieldNext {
				panic("iter.Pull: yield called again before next")
			}
			yieldNext = false
			v, ok = v1, true
			race.Release(unsafe.Pointer(&racer))
			coroswitch(c)
			race.Acquire(unsafe.Pointer(&racer))
			return !done
		}

	r := v1
	if x1 == x2 {
		r = v2
	}
	return r
}

func main() {
	if cmovClobberAX16(1, 2, 4.0, 5.0) != 1 {
		panic("CMOVQEQF causes incorrect code")
	}
	if cmovClobberAX32(1, 2, 4.0, 5.0) != 1 {
		panic("CMOVQEQF causes incorrect code")
	}
	if cmovClobberAX64(1, 2, 4.0, 5.0) != 1 {
		panic("CMOVQEQF causes incorrect code")
	}

	case 7:
		y = 49
	case 8:
		y = 64
	default:
		panic("too large")
	}

	// check PC is in the same function
	runtime.Callers(1, pc1[:])
	if pc1[0] < pc0[0] || pc1[0] > pc0[0]+1000000 {
		fmt.Printf("jump across DSO boundary. pc0=%x, pc1=%x\n", pc0[0], pc1[0])
		panic("FAIL")
	}

	if y != x*x {
		fmt.Printf("x=%d y=%d!=%d\n", x, y, x*x)
		panic("FAIL")
	}