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)

// 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 {

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

package main

func f() {
exit:
	;
	goto exit
}


func main() {
exit:
	; // this should be legal (labels not properly scoped?)
	goto exit
}

/*
uetli:~/Source/go/test/bugs gri$ 6g bug076.go 
bug076.go:11: label redeclared: exit

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

package main

func main() {
	if true {
	} else {
	L1:
		goto L1
	}
	if true {
	} else {
		goto L2
	L2:
		main()
	}
}

/*
These should be legal according to the spec.
bug140.go:6: syntax error near L1
bug140.go:7: syntax error near L2

func main() {
L:
	for i := 0; i < 1; i++ {
	L1:
		for {
			break L
		}
		panic("BUG: not reached - break")
		if false {
			goto L1
		}
	}

L2:
	for i := 0; i < 1; i++ {
	L3:
		for {
			continue L2
		}
		panic("BUG: not reached - continue")
		if false {
			goto L3
		}
	}

					Valu("const3", OpConst32, intType, 3, nil),
					Goto("b5")),
				Bloc("b2",
					Valu("addr", OpAddr, boolType.PtrTo(), 0, nil, "sb"),
					Valu("cond", OpLoad, boolType, 0, nil, "addr", "start"),
					Valu("phi", OpPhi, intType, 0, nil, "const2", "const3"),
					If("cond", "b3", "b4")),
				Bloc("b3",
					Goto("b2")),
				Bloc("b4",
					Goto("b2")),
				Bloc("b5",
					Exit("start")))

		someglobal1++
	}
}

func standinacorner2(i int) {
	// contains an irreducible loop containing changes to memory
	if i != 0 {
		goto midloop
	}

loop:
	if someglobal2&1 != 0 {
		goto done
	}
	someglobal2++
midloop:
	someglobal2++
	goto loop

done:
	return
}

func standinacorner3() {
	for someglobal3&1 == 0 {
		if someglobal3&2 != 0 {
			for someglobal3&3 == 2 {