// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

func Spin() {
l1:
	for true {
		goto l1
	l2:
		if true {
			goto l2
		}
	}

			Valu("arg2", OpArg, c.config.Types.Int64, 0, nil),
			Valu("arg3", OpArg, c.config.Types.Int64, 0, nil),
			Goto("b1")),
		Bloc("b1",
			Valu("cmp1", OpLess64, c.config.Types.Bool, 0, nil, "arg1", "arg2"),
			If("cmp1", "b2", "b3")),
		Bloc("b2",
			Valu("cmp2", OpLess64, c.config.Types.Bool, 0, nil, "arg2", "arg3"),
			Goto("b3")),
		Bloc("b3",
			Valu("phi2", OpPhi, c.config.Types.Bool, 0, nil, "cmp1", "cmp2"),

			Eq("v11", "b2", "b4"),
		),
		Bloc("b4",
			Goto("b3"),
		),
		Bloc("b3",
			Valu("v14", OpPhi, types.TypeMem, 0, nil, "v1", "v12"),
			Valu("sb", OpSB, c.config.Types.Uintptr, 0, nil),
			Valu("v16", OpARM64MOVDstore, types.TypeMem, 0, nil, "v8", "sb", "v14"),
			Exit("v16"),
		),
		Bloc("b2",
			Valu("v12", OpARM64CALLstatic, types.TypeMem, 0, AuxCallLSym("_"), "v1"),
			Goto("b3"),
		),
	)
	regalloc(f.f)

			g.threads[ev.Thread()] = struct{}{}
		}
	}

	st := ev.StateTransition()
	goID := st.Resource.Goroutine()

	// If we haven't seen this goroutine before, create a new
	// gState for it.
	gs, ok := g.gStates[goID]
	if !ok {
		gs = newGState[trace.ThreadID](goID)
		g.gStates[goID] = gs
	}
	// If we haven't already named this goroutine, try to name it.
	gs.augmentName(st.Stack)

package main

func main() {
L1:
L2:
	for i := 0; i < 10; i++ {
		print(i)
		break L2
	}

L3:
	;
L4:
	for i := 0; i < 10; i++ {
		print(i)
		break L4
	}
	goto L1
	goto L3
}

/*
bug137.go:9: break label is not defined: L2
bug137.go:15: break label is not defined: L4

	if v := try(); v == 42 || v == 1337 { // the two || are to trick findIndVar
		if n < 30 { // this aims to be the matched block
			if shouldInc() {
				n++
				goto loop
			}
			n = N(n) // try to prevent some block joining
			goto loop
		}
	}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

func main() {
	Foo: {
		return;
	}
	goto Foo;
}
/*
bug5.go:4: Foo undefined
bug5.go:4: fatal error: walktype: switch 1 unknown op GOTO l(4)

			return err
		}
		nestedErr = err.Err
		goto second
	}
	return fmt.Errorf("unexpected type on 1st nested level: %T", nestedErr)

second:
	if isPlatformError(nestedErr) {
		return nil
	}
	switch err := nestedErr.(type) {
	case *os.SyscallError:
		nestedErr = err.Err
		goto third
	case *fs.PathError: // for Plan 9
		nestedErr = err.Err
		goto third
	}
	switch nestedErr {
	case ErrClosed:

// license that can be found in the LICENSE file.

package main

import "fmt"

func main() {
	// invalid use of goto.
	// do whatever you like, just don't crash.
	i := 42
	a := []*int{&i, &i, &i, &i}
	x := a[0]
	goto start  // ERROR "jumps into block"
	z := 1
	_ = z
	for _, x = range a {	// GCCGO_ERROR "block"
	start:
		fmt.Sprint(*x)
	}

			var err error
			if len(tc.flag) > 0 {
				if err = cmd.Flags().Set(flagNameOutput, tc.flag); err != nil {
					goto error
				}
			}
			buf.Reset()
			if err = RunVersion(&buf, cmd); err != nil {
				goto error
			}
			if buf.String() == "" {
				err = errors.New("empty output")
				goto error
			}
			if tc.shouldBeValidYAML {
				err = yaml.Unmarshal(buf.Bytes(), &iface)
			} else if tc.shouldBeValidJSON {