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")
	}

// Do not panic on conversion to anonymous interface, which
// is similar-looking interface types in different packages.

package main

import (
	"fmt"

	ssa1 "issue29612.dir/p1/ssa"
	ssa2 "issue29612.dir/p2/ssa"
)

func main() {
	v1 := &ssa1.T{}
	_ = v1

	v2 := &ssa2.T{}
	ssa2.Works(v2)
	ssa2.Panics(v2) // This call must not panic

	swt(v1, 1)
	swt(v2, 2)
}

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{})

	if autoffset != 0 {
		p.Pos = p.Pos.WithXlogue(src.PosPrologueEnd)
	}

	if cursym.Func().Text.From.Sym.Wrapper() {
		// if g._panic != nil && g._panic.argp == FP {
		//   g._panic.argp = bottom-of-frame
		// }
		//
		//	MOVQ g_panic(g), regEntryTmp0
		//	TESTQ regEntryTmp0, regEntryTmp0
		//	JNE checkargp
		// end:
		//	NOP
		//  ... rest of function ...
		// checkargp:

import (
	"fmt"
	"plugin"
	"unicode"
)

func main() {
	p, err := plugin.Open("issue62430.so")
	if err != nil {
		panic(err)
	}
	s, err := p.Lookup("F")
	if err != nil {
		panic(err)
	}

	f := s.(func(string) *unicode.RangeTable)
	if f("C") == nil {
		panic("unicode.Categories not properly initialized")
	} else {
		fmt.Println("unicode.Categories properly initialized")
	}

// The compiler was panicking on the wrong line number, where
// the panic was occurring in an inlined call.

package main

import (
	"runtime/debug"
	"strings"
)

type Wrapper struct {
	a []int
}

func (w Wrapper) Get(i int) int {
	return w.a[i]
}

func main() {
	defer func() {
		e := recover()
		if e == nil {
			panic("bounds check didn't fail")
		}
		stk := string(debug.Stack())

import (
	"./a"
	"fmt"
)

func main() {
	const want = 120

	if got := a.Fact(5); got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

	if got := a.Fact[int64](5); got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

	if got := a.Fact(5.0); got != want {
		panic(fmt.Sprintf("got %f, want %f", got, want))
	}

		panic(err)
	}

	targetListCase3 := NewTargetList(context.Background())
	if err := targetListCase3.Add(&ExampleTarget{TargetID{"3", "testcase"}, false, false}); err != nil {
		panic(err)
	}
	if err := targetListCase3.Add(&ExampleTarget{TargetID{"1", "webhook"}, false, false}); err != nil {
		panic(err)
	}

	testCases := []struct {

	os.Exit(1)
}

// Panic is equivalent to l.Print() followed by a call to panic().
func (l *Logger) Panic(v ...any) {
	s := fmt.Sprint(v...)
	l.Output(2, s)
	panic(s)
}

// Panicf is equivalent to l.Printf() followed by a call to panic().
func (l *Logger) Panicf(format string, v ...any) {
	s := fmt.Sprintf(format, v...)
	l.Output(2, s)
	panic(s)
}

func main() {
	s1 := S1{Eint{2}, "foo"}
	if got, want := s1.E.v, 2; got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}
	s2 := S2{Eint{3}, Ebool{true}, "foo"}
	if got, want := s2.Eint.v, 3; got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}
	var s3 S3
	s3.E = &Eint{4}
	if got, want := s3.E.v, 4; got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}