case nil:
		return fmt.Sprint("nil ", xx)
	}
	panic("not reached")
}

func check(x interface{}, s string) {
	w := whatis(x)
	if w != s {
		fmt.Println("whatis", x, "=>", w, "!=", s)
		panic("fail")
	}

	w = whatis1(x)
	if w != s {
		fmt.Println("whatis1", x, "=>", w, "!=", s)
		panic("fail")
	}
}

func main() {
	check(1, "signed 1")
	check(uint(1), "unsigned 1")

import "fmt"

func main() {
	var i, k int
	var r string
outer:
	for k = 0; k < 2; k++ {
		r += fmt.Sprintln("outer loop top k", k)
		if k != 0 {
			panic("k not zero")
		} // inner loop breaks this one every time
		for i = 0; i < 2; i++ {
			if i != 0 {
				panic("i not zero")
			} // loop breaks every time
			r += fmt.Sprintln("inner loop top i", i)
			if true {
				r += "do break\n"
				break outer
			}
		}
	}

package math

const haveArchFloor = false

func archFloor(x float64) float64 {
	panic("not implemented")
}

const haveArchCeil = false

func archCeil(x float64) float64 {
	panic("not implemented")
}

const haveArchTrunc = false

func archTrunc(x float64) float64 {
	panic("not implemented")

}

func main() {

	var t T

	if v := real(t.cplx()); v != 1 {
		panic("not-inlined complex call failed")
	}
	_ = imag(t.cplx())

	_ = real(t.cplx2())
	if v := imag(t.cplx2()); v != 1 {
		panic("potentially inlined complex call failed")
	}

	var i I
	i = t
	if v := real(i.cplx()); v != 1 {
		panic("potentially inlined complex call failed")
	}
	_ = imag(i.cplx())

	return []byte{'a', 'b'}, '1', '2'
}

func main() {
	if c := complex(complexArgs()); c != 5+7i {
		panic(c)
	}

	if s := append(appendArgs()); len(s) != 2 || s[0] != "foo" || s[1] != "bar" {
		panic(s)
	}

	if b := append(appendMultiArgs()); len(b) != 4 || b[0] != 'a' || b[1] != 'b' || b[2] != '1' || b[3] != '2' {
		panic(b)
	}

func (c *aesCipherAsm) Encrypt(dst, src []byte) {
	boring.Unreachable()
	if len(src) < BlockSize {
		panic("crypto/aes: input not full block")
	}
	if len(dst) < BlockSize {
		panic("crypto/aes: output not full block")
	}
	if alias.InexactOverlap(dst[:BlockSize], src[:BlockSize]) {
		panic("crypto/aes: invalid buffer overlap")
	}
	encryptBlockAsm(int(c.l)/4-1, &c.enc[0], &dst[0], &src[0])
}

	header, err = dec.Decode("=?x-case?q?hello!?=")
	if err != nil {
		panic(err)
	}
	fmt.Println(header)
	// Output:
	// ¡Hola, señor!
	// HELLO!
}

func ExampleWordDecoder_DecodeHeader() {
	dec := new(mime.WordDecoder)
	header, err := dec.DecodeHeader("=?utf-8?q?=C3=89ric?= <******@****.***>, =?utf-8?q?Ana=C3=AFs?= <******@****.***>")
	if err != nil {
		panic(err)
	}
	fmt.Println(header)

			t.Fatalf("unlock of unlocked RWMutex did not panic")
		}
	}()
	mu := NewDRWMutex(ds, "test")
	mu.Unlock(context.Background())
}

// Borrowed from rwmutex_test.go
func TestUnlockPanic2(t *testing.T) {
	mu := NewDRWMutex(ds, "test-unlock-panic-2")
	defer func() {
		if recover() == nil {
			t.Fatalf("unlock of unlocked RWMutex did not panic")
		}

const D32 = ^0

func main() {
	if B32 != 0xFFFFFFFF {
		println("1<<32 - 1 is", B32, "should be", 0xFFFFFFFF)
		panic("fail")
	}
	if C32 != 0xFFFFFFFF {
		println("(-1) & ((1<<32) - 1) is", C32, "should be", 0xFFFFFFFF)
		panic("fail")
	}
	if D32 != -1 {
		println("^0 is", D32, "should be", -1)
		panic("fail")
	}

package main

func main() {
	n := foo()
	if n != 2 {
		println(n)
		panic("wrong return value")
	}
}

type terr struct{}

func foo() (val int) {
	val = 0
	defer func() {
		if x := recover(); x != nil {
			_ = x.(terr)
		}
	}()
	for {
		val = 2
		foo1()
	}
	panic("unreachable")
}

func foo1() {
	panic(terr{})