var i uint64
	var x int = 12345

	if y := x << (i&5); y != 12345<<0 {
		println("BUG bug344", y)
		return
	}
	
	i++
	if y := x << (i&5); y != 12345<<1 {
		println("BUG bug344a", y)
	}
	
	i = 70
	if y := x << i; y != 0 {
		println("BUG bug344b", y)
	}
	
	i = 1<<32
	if y := x << i; y != 0 {
		println("BUG bug344c", y)
	}
}
	

/*
typecheck [1008592b0]

func (c cplx128) Foo() {}

func main() {
	var c64 cplx128
	var c128 cplx64
	c64.Foo()
	c128.Foo()
}

/*
bug334.go:16: invalid receiver type cplx64
bug334.go:17: invalid receiver type cplx128
bug334.go:22: c64.Foo undefined (type cplx128 has no field or method Foo)
bug334.go:23: c128.Foo undefined (type cplx64 has no field or method Foo)

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

package main

const c = 1;

func main() {
	c := 0;
	_ = c;
}

/*
bug144.go:8: left side of := must be a name
bug144.go:8: operation LITERAL not allowed in assignment context
bug144.go:8: illegal types for operand: AS
	ideal
	int

		for i := 0;; i++ {
			pc, file, line, ok := runtime.Caller(i)
			if !ok {
				print("BUG: bug348: cannot find caller\n")
				return
			}
			if !strings.Contains(file, "bug348.go") || runtime.FuncForPC(pc).Name() != "main.f" {
				// walk past runtime frames
				continue
			}
			if line != 17 {
				print("BUG: bug348: panic at ", file, ":", line, " in ", runtime.FuncForPC(pc).Name(), "\n")
				return
			}
			recover()

		recover()
		for i := 0;; i++ {
			pc, file, line, ok := runtime.Caller(i)
			if !ok {
				print("BUG: bug347: cannot find caller\n")
				return
			}
			if !strings.Contains(file, "bug347.go") || runtime.FuncForPC(pc).Name() != "main.f" {
				// walk past runtime frames
				continue
			}
			if line != 22 {
				print("BUG: bug347: panic at ", file, ":", line, " in ", runtime.FuncForPC(pc).Name(), "\n")
			}
			return
		}
	}()

// Copyright 2010 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Caused a gccgo crash on compilation.
// bug304.go: In function ‘p.f’:
// bug304.go:15:2: internal compiler error: in copy_tree_r, at tree-inline.c:4114

package p
type S struct {
	v interface{}
}
func g(e interface{}) { }
func f(s S) {
	g(s.v.(*int))

       }
       return ret
}

func main() {
	x := getArgs(map[string]interface{}{"x":"y"}, "x")
	if x["x"] != "y" {
		println("BUG bug343", x)
	}
}
	

/*
typecheck [1008592b0]
.   INDREG a(1) l(15) x(24) tc(2) runtime.ret G0 string
bug343.go:15: internal compiler error: typecheck INDREG

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

// issue 2086
// was calling makeclosure twice on the closure

package bug354

type Inner struct {
	F func() error
}

type Outer struct {
	Inners []Inner
}

// calls makeclosure twice on same closure

Emmanuel Odeke <******@****.***> 1460323946 -0700

Russ Cox <******@****.***> 1329454199 -0500