Data U `xml:"data"`
}

func main() {
	src := &A[string, int]{Name: "name", Data: 1}
	data, err := xml.Marshal(src)
	if err != nil {
		panic(err)
	}
	dst := &A[string, int]{}
	err = xml.Unmarshal(data, dst)
	if err != nil {
		panic(err)
	}
	if *src != *dst {
		panic(fmt.Sprintf("wanted %#v got %#v", src, dst))
	}

//go:registerparams
func F() (a int, b string, _ int, c S, d [2]int) {
	a, b, c, d = a0, b0, c0, d0
	defer func() { recover() }()
	panic("XXX")
	return
}

func main() {
	a1, b1, zero, c1, d1 := F()
	if a1 != a0 || b1 != b0 || c1 != c0 || d1 != d0 || zero != 0 { // unnamed result gets zero value
		panic("FAIL")
	}

package main

import "fmt"

func main() {
	// Just run test over and over again. This main func is just for
	// convenience; if test were the main func, we could also trigger
	// the panic just by running the program over and over again
	// (sometimes it takes 1 time, sometimes it takes ~4,000+).
	for iter := 0; ; iter++ {
		if iter%50 == 0 {

	q, err := curve.newPoint().ScalarBaseMult(s1)
	if err != nil {
		panic("crypto/elliptic: nistec rejected normalized scalar")
	}
	p, err := curve.pointFromAffine(Px, Py)
	if err != nil {
		panic("crypto/elliptic: CombinedMult was called on an invalid point")
	}
	s2 = curve.normalizeScalar(s2)
	p, err = p.ScalarMult(p, s2)
	if err != nil {
		panic("crypto/elliptic: nistec rejected normalized scalar")
	}

		if len(a) > 0 && len(b) > 0 {
			panic("these inputs caused a crash!")
		}
	})
}

func FuzzInt(f *testing.F) {
	f.Add(0)
	f.Fuzz(func(t *testing.T, a int) {
		if a != 0 {
			panic("this input caused a crash!")
		}
	})
}

func FuzzUint(f *testing.F) {
	f.Add(uint(0))
	f.Fuzz(func(t *testing.T, a uint) {
		if a != 0 {
			panic("this input caused a crash!")
		}
	})
}

const never = "function did"

func unreachable() {
	panic("control flow shouldn't reach here")
}

// Calls f and verifies that f always/never panics depending on signal.
func testPanic(signal string, f func()) {
	defer func() {
		s := never
		if recover() != nil {
			s = always // f panicked
		}
		if s != signal {
			panic(signal + " panic")
		}
	}()
	f()
}

	d := r - 1.292308
	if d < 0 {
		d = - d
	}
	if d > 1e-6 {
		println(r, "!= 1.292308")
		panic(0)
	}
	d = i + 0.1384615
	if d < 0 {
		d = - d
	}
	if d > 1e-6 {
		println(i, "!= -0.1384615")
		panic(0)
	}

	c := *(*complex128)(unsafe.Pointer(&c0))
	if c != c0 {
		println(c, "!=", c)
		panic(0)
	}

	var a interface{}
	switch c := reflect.ValueOf(a); c.Kind() {

	cc := make(chan chan int, 1)
	c := make(chan int, 1)
	cc <- c
	select {
	case <-cc <- 2:
	default:
		panic("nonblock")
	}
	if <-c != 2 {
		panic("bad receive")
	}
}

func sendprec() {
	c := make(chan bool, 1)
	c <- false || true // not a syntax error: same as c <- (false || true)
	if !<-c {
		panic("sent false")
	}

var a, b = foo() // foo is called once
var c, _ = bar() // bar is called twice
var _, _ = bal() // bal is called twice

func main() {
	if fooCount != 1 {
		panic("fooCount != 1")
	}
	if barCount != 1 {
		panic("barCount != 1")
	}
	if balCount != 1 {
		panic("balCount != 1")
	}

// pool is not available (for instance in a container which does not have a root
// certificate bundle). SetFallbackRoots will panic if roots is nil.
//
// SetFallbackRoots may only be called once, if called multiple times it will
// panic.
//
// The fallback behavior can be forced on all platforms, even when there is a
// system certificate pool, by setting GODEBUG=x509usefallbackroots=1 (note that