Imported Upstream version 1upstream/1

author: Ondřej Surý <ondrej@sury.org> 2012-04-06 15:14:11 +0200
committer: Ondřej Surý <ondrej@sury.org> 2012-04-06 15:14:11 +0200
commit: 505c19580e0f43fe5224431459cacb7c21edd93d (patch)
tree: 79e2634c253d60afc0cc0b2f510dc7dcbb48497b /test
parent: 1336a7c91e596c423a49d1194ea42d98bca0d958 (diff)
download: golang-505c19580e0f43fe5224431459cacb7c21edd93d.tar.gz
772 files changed, 11168 insertions, 3227 deletions
diff --git a/test/235.go b/test/235.go
index 03143a60d..6745dde41 100644
--- a/test/235.go
+++ b/test/235.go
@@ -1,9 +1,12 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Solve the 2,3,5 problem (print all numbers with 2, 3, or 5 as factor) using channels.
+// Test the solution, silently.
+
 package main
 
 type T chan uint64
diff --git a/test/alias.go b/test/alias.go
new file mode 100644
index 000000000..ec93a2d10
--- /dev/null
+++ b/test/alias.go
@@ -0,0 +1,33 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// Test that error messages say what the source file says
+// (uint8 vs byte, int32 vs. rune).
+// Does not compile.
+
+package main
+
+import (
+	"fmt"
+	"unicode/utf8"
+)
+
+func f(byte)  {}
+func g(uint8) {}
+
+func main() {
+	var x float64
+	f(x) // ERROR "byte"
+	g(x) // ERROR "uint8"
+
+	// Test across imports.
+
+	var ff fmt.Formatter
+	var fs fmt.State
+	ff.Format(fs, x) // ERROR "rune"
+
+	utf8.RuneStart(x) // ERROR "byte"
+}
diff --git a/test/alias1.go b/test/alias1.go
new file mode 100644
index 000000000..4219af8cd
--- /dev/null
+++ b/test/alias1.go
@@ -0,0 +1,54 @@
+// run
+
+// Copyright 2011 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.
+
+// Test that dynamic interface checks treat byte=uint8
+// and rune=int or rune=int32.
+
+package main
+
+func main() {
+	var x interface{}
+
+	x = byte(1)
+	switch x.(type) {
+	case uint8:
+		// ok
+	default:
+		println("byte != uint8")
+	}
+
+	x = uint8(2)
+	switch x.(type) {
+	case byte:
+		// ok
+	default:
+		println("uint8 != byte")
+	}
+
+	rune32 := false
+	x = rune(3)
+	switch x.(type) {
+	case int:
+		// ok
+	case int32:
+		// must be new code
+		rune32 = true
+	default:
+		println("rune != int and rune != int32")
+	}
+
+	if rune32 {
+		x = int32(4)
+	} else {
+		x = int(5)
+	}
+	switch x.(type) {
+	case rune:
+		// ok
+	default:
+		println("int (or int32) != rune")
+	}
+}
diff --git a/test/append.go b/test/append.go
index 96421c36b..3f6251ee5 100644
--- a/test/append.go
+++ b/test/append.go
@@ -1,10 +1,10 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // 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.
 
-// Semi-exhaustive test for append()
+// Semi-exhaustive test for the append predeclared function.
 
 package main
 
@@ -27,6 +27,7 @@ func main() {
 	}
 	verifyStruct()
 	verifyInterface()
+	verifyType()
 }
 
 
@@ -63,6 +64,11 @@ var tests = []struct {
 	{"byte i", append([]byte{0, 1, 2}, []byte{3}...), []byte{0, 1, 2, 3}},
 	{"byte j", append([]byte{0, 1, 2}, []byte{3, 4, 5}...), []byte{0, 1, 2, 3, 4, 5}},
 
+	{"bytestr a", append([]byte{}, "0"...), []byte("0")},
+	{"bytestr b", append([]byte{}, "0123"...), []byte("0123")},
+
+	{"bytestr c", append([]byte("012"), "3"...), []byte("0123")},
+	{"bytestr d", append([]byte("012"), "345"...), []byte("012345")},
 
 	{"int16 a", append([]int16{}), []int16{}},
 	{"int16 b", append([]int16{}, 0), []int16{0}},
@@ -225,3 +231,17 @@ func verifyInterface() {
 	verify("interface l", append(s), s)
 	verify("interface m", append(s, e...), r)
 }
+
+type T1 []int
+type T2 []int
+
+func verifyType() {
+	// The second argument to append has type []E where E is the
+	// element type of the first argument.  Test that the compiler
+	// accepts two slice types that meet that requirement but are
+	// not assignment compatible.  The return type of append is
+	// the type of the first argument.
+	t1 := T1{1}
+	t2 := T2{2}
+	verify("T1", append(t1, t2...), T1{1, 2})
+}
diff --git a/test/args.go b/test/args.go
index ba9a377a6..db624e9c2 100644
--- a/test/args.go
+++ b/test/args.go
@@ -4,6 +4,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// Test os.Args.
+
 package main
 
 import "os"
diff --git a/test/assign.go b/test/assign.go
index 59471388c..da0192f83 100644
--- a/test/assign.go
+++ b/test/assign.go
@@ -1,9 +1,12 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Verify simple assignment errors are caught by the compiler.
+// Does not compile.
+
 package main
 
 import "sync"
@@ -16,38 +19,38 @@ type T struct {
 func main() {
 	{
 		var x, y sync.Mutex
-		x = y	// ERROR "assignment.*Mutex"
+		x = y // ok
 		_ = x
 	}
 	{
 		var x, y T
-		x = y	// ERROR "assignment.*Mutex"
+		x = y // ok
 		_ = x
 	}
 	{
 		var x, y [2]sync.Mutex
-		x = y	// ERROR "assignment.*Mutex"
+		x = y // ok
 		_ = x
 	}
 	{
 		var x, y [2]T
-		x = y	// ERROR "assignment.*Mutex"
+		x = y // ok
 		_ = x
 	}
 	{
-		x := sync.Mutex{0, 0}	// ERROR "assignment.*Mutex"
+		x := sync.Mutex{0, 0} // ERROR "assignment.*Mutex"
 		_ = x
 	}
 	{
-		x := sync.Mutex{key: 0}	// ERROR "(unknown|assignment).*Mutex"
+		x := sync.Mutex{key: 0} // ERROR "(unknown|assignment).*Mutex"
 		_ = x
 	}
 	{
-		x := &sync.Mutex{}	// ok
-		var y sync.Mutex	// ok
-		y = *x	// ERROR "assignment.*Mutex"
-		*x = y	// ERROR "assignment.*Mutex"
+		x := &sync.Mutex{} // ok
+		var y sync.Mutex   // ok
+		y = *x             // ok
+		*x = y             // ok
 		_ = x
 		_ = y
-	}		
+	}
 }
diff --git a/test/assign1.go b/test/assign1.go
index 71e5b4064..b9e0325ce 100644
--- a/test/assign1.go
+++ b/test/assign1.go
@@ -1,9 +1,12 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Verify assignment rules are enforced by the compiler.
+// Does not compile.
+
 package main
 
 type (
diff --git a/test/bench/Makefile b/test/bench/Makefile
deleted file mode 100644
index 145fe0cea..000000000
--- a/test/bench/Makefile
+++ /dev/null
@@ -1,14 +0,0 @@
-# Copyright 2011 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.
-
-include ../../src/Make.inc
-
-all:
-	@echo "make clean or timing"
-
-timing:
-	./timing.sh
-
-clean:
-	rm -f [568].out *.[568]
diff --git a/test/garbage/Makefile b/test/bench/garbage/Makefile
index e83384382..98838453a 100644
--- a/test/garbage/Makefile
+++ b/test/bench/garbage/Makefile
@@ -2,26 +2,22 @@
 # Use of this source code is governed by a BSD-style
 # license that can be found in the LICENSE file.
 
-include ../../src/Make.inc
-
 ALL=\
 	parser\
 	peano\
 	tree\
+	tree2\
 
-all: $(addsuffix .out, $(ALL))
-
-%.$O: %.go stats.go
-	$(GC) $*.go stats.go
+all: $(ALL)
 
-%.out: %.$O
-	$(LD) -o $@ $*.$O
+%: %.go
+	go build $*.go stats.go
 
-%.bench: %.out
-	./$*.out
+%.bench: %
+	time ./$*
 
 bench: $(addsuffix .bench, $(ALL))
 
 clean:
-	rm -f *.[$(OS)] $(addsuffix .out, $(ALL))
+	rm -f $(ALL)
 
diff --git a/test/garbage/parser.go b/test/bench/garbage/parser.go
index 19a96bc63..d66281b6b 100644
--- a/test/garbage/parser.go
+++ b/test/bench/garbage/parser.go
@@ -12,27 +12,27 @@ import (
 	"go/ast"
 	"go/parser"
 	"go/token"
+	"log"
+	"net/http"
+	_ "net/http/pprof"
 	"os"
 	"path"
 	"runtime"
 	"strings"
 	"time"
-	"http"
-	_ "http/pprof"
-	"log"
 )
 
 var serve = flag.String("serve", "", "serve http on this address at end")
 
-func isGoFile(dir *os.FileInfo) bool {
-	return dir.IsRegular() &&
-		!strings.HasPrefix(dir.Name, ".") && // ignore .files
-		path.Ext(dir.Name) == ".go"
+func isGoFile(dir os.FileInfo) bool {
+	return !dir.IsDir() &&
+		!strings.HasPrefix(dir.Name(), ".") && // ignore .files
+		path.Ext(dir.Name()) == ".go"
 }
 
-func isPkgFile(dir *os.FileInfo) bool {
+func isPkgFile(dir os.FileInfo) bool {
 	return isGoFile(dir) &&
-		!strings.HasSuffix(dir.Name, "_test.go") // ignore test files
+		!strings.HasSuffix(dir.Name(), "_test.go") // ignore test files
 }
 
 func pkgName(filename string) string {
@@ -49,7 +49,7 @@ func parseDir(dirpath string) map[string]*ast.Package {
 	_, pkgname := path.Split(dirpath)
 
 	// filter function to select the desired .go files
-	filter := func(d *os.FileInfo) bool {
+	filter := func(d os.FileInfo) bool {
 		if isPkgFile(d) {
 			// Some directories contain main packages: Only accept
 			// files that belong to the expected package so that
@@ -57,7 +57,7 @@ func parseDir(dirpath string) map[string]*ast.Package {
 			// found" errors.
 			// Additionally, accept the special package name
 			// fakePkgName if we are looking at cmd documentation.
-			name := pkgName(dirpath + "/" + d.Name)
+			name := pkgName(dirpath + "/" + d.Name())
 			return name == pkgname
 		}
 		return false
@@ -66,18 +66,14 @@ func parseDir(dirpath string) map[string]*ast.Package {
 	// get package AST
 	pkgs, err := parser.ParseDir(token.NewFileSet(), dirpath, filter, parser.ParseComments)
 	if err != nil {
-		println("parse", dirpath, err.String())
+		println("parse", dirpath, err.Error())
 		panic("fail")
 	}
 	return pkgs
 }
 
 func main() {
-	runtime.GOMAXPROCS(4)
-	go func() {}()
-	go func() {}()
-	go func() {}()
-	st := &runtime.MemStats
+	st := new(runtime.MemStats)
 	packages = append(packages, packages...)
 	packages = append(packages, packages...)
 	n := flag.Int("n", 4, "iterations")
@@ -86,16 +82,19 @@ func main() {
 	flag.Parse()
 
 	var lastParsed []map[string]*ast.Package
-	var t0 int64
+	var t0 time.Time
+	var numGC uint32
+	var pauseTotalNs uint64
 	pkgroot := runtime.GOROOT() + "/src/pkg/"
 	for pass := 0; pass < 2; pass++ {
 		// Once the heap is grown to full size, reset counters.
 		// This hides the start-up pauses, which are much smaller
 		// than the normal pauses and would otherwise make
 		// the average look much better than it actually is.
-		st.NumGC = 0
-		st.PauseTotalNs = 0
-		t0 = time.Nanoseconds()
+		runtime.ReadMemStats(st)
+		numGC = st.NumGC
+		pauseTotalNs = st.PauseTotalNs
+		t0 = time.Now()
 
 		for i := 0; i < *n; i++ {
 			parsed := make([]map[string]*ast.Package, *p)
@@ -109,8 +108,11 @@ func main() {
 		runtime.GC()
 		runtime.GC()
 	}
-	t1 := time.Nanoseconds()
+	t1 := time.Now()
 
+	runtime.ReadMemStats(st)
+	st.NumGC -= numGC
+	st.PauseTotalNs -= pauseTotalNs
 	fmt.Printf("Alloc=%d/%d Heap=%d Mallocs=%d PauseTime=%.3f/%d = %.3f\n",
 		st.Alloc, st.TotalAlloc,
 		st.Sys,
@@ -124,7 +126,7 @@ func main() {
 		}
 	*/
 	// Standard gotest benchmark output, collected by build dashboard.
-	gcstats("BenchmarkParser", *n, t1-t0)
+	gcstats("BenchmarkParser", *n, t1.Sub(t0))
 
 	if *serve != "" {
 		log.Fatal(http.ListenAndServe(*serve, nil))
@@ -132,26 +134,21 @@ func main() {
 	}
 }
 
-
 var packages = []string{
 	"archive/tar",
-	"asn1",
-	"big",
+	"encoding/asn1",
+	"math/big",
 	"bufio",
 	"bytes",
-	"cmath",
+	"math/cmplx",
 	"compress/flate",
 	"compress/gzip",
 	"compress/zlib",
 	"container/heap",
 	"container/list",
 	"container/ring",
-	"container/vector",
 	"crypto/aes",
-	"crypto/block",
-	"crypto/blowfish",
 	"crypto/hmac",
-	"crypto/md4",
 	"crypto/md5",
 	"crypto/rand",
 	"crypto/rc4",
@@ -162,25 +159,17 @@ var packages = []string{
 	"crypto/subtle",
 	"crypto/tls",
 	"crypto/x509",
-	"crypto/xtea",
 	"debug/dwarf",
 	"debug/macho",
 	"debug/elf",
 	"debug/gosym",
-	"debug/proc",
-	"ebnf",
+	"exp/ebnf",
 	"encoding/ascii85",
 	"encoding/base64",
 	"encoding/binary",
-	"encoding/git85",
 	"encoding/hex",
 	"encoding/pem",
-	"exec",
-	"exp/datafmt",
-	"exp/draw",
-	"exp/eval",
-	"exp/iterable",
-	"expvar",
+	"os/exec",
 	"flag",
 	"fmt",
 	"go/ast",
@@ -189,49 +178,47 @@ var packages = []string{
 	"go/printer",
 	"go/scanner",
 	"go/token",
-	"gob",
+	"encoding/gob",
 	"hash",
 	"hash/adler32",
 	"hash/crc32",
 	"hash/crc64",
-	"http",
+	"net/http",
 	"image",
 	"image/jpeg",
 	"image/png",
 	"io",
 	"io/ioutil",
-	"json",
+	"encoding/json",
 	"log",
 	"math",
 	"mime",
 	"net",
 	"os",
-	"os/signal",
-	"patch",
+	"exp/signal",
 	"path",
-	"rand",
+	"math/rand",
 	"reflect",
 	"regexp",
-	"rpc",
+	"net/rpc",
 	"runtime",
-	"scanner",
+	"text/scanner",
 	"sort",
-	"smtp",
+	"net/smtp",
 	"strconv",
 	"strings",
 	"sync",
 	"syscall",
-	"syslog",
-	"tabwriter",
-	"template",
+	"log/syslog",
+	"text/tabwriter",
+	"text/template",
 	"testing",
 	"testing/iotest",
 	"testing/quick",
 	"testing/script",
 	"time",
 	"unicode",
-	"utf8",
-	"utf16",
-	"websocket",
-	"xml",
+	"unicode/utf8",
+	"unicode/utf16",
+	"encoding/xml",
 }
diff --git a/test/garbage/peano.go b/test/bench/garbage/peano.go
index b4d318561..6c7e52314 100644
--- a/test/garbage/peano.go
+++ b/test/bench/garbage/peano.go
@@ -1,4 +1,4 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -12,31 +12,25 @@ import (
 	"time"
 )
 
-
 type Number struct {
 	next *Number
 }
 
-
 // -------------------------------------
 // Peano primitives
 
 func zero() *Number { return nil }
 
-
 func is_zero(x *Number) bool { return x == nil }
 
-
 func add1(x *Number) *Number {
 	e := new(Number)
 	e.next = x
 	return e
 }
 
-
 func sub1(x *Number) *Number { return x.next }
 
-
 func add(x, y *Number) *Number {
 	if is_zero(y) {
 		return x
@@ -45,7 +39,6 @@ func add(x, y *Number) *Number {
 	return add(add1(x), sub1(y))
 }
 
-
 func mul(x, y *Number) *Number {
 	if is_zero(x) || is_zero(y) {
 		return zero()
@@ -54,7 +47,6 @@ func mul(x, y *Number) *Number {
 	return add(mul(x, sub1(y)), x)
 }
 
-
 func fact(n *Number) *Number {
 	if is_zero(n) {
 		return add1(zero())
@@ -63,7 +55,6 @@ func fact(n *Number) *Number {
 	return mul(fact(sub1(n)), n)
 }
 
-
 // -------------------------------------
 // Helpers to generate/count Peano integers
 
@@ -75,7 +66,6 @@ func gen(n int) *Number {
 	return zero()
 }
 
-
 func count(x *Number) int {
 	if is_zero(x) {
 		return 0
@@ -84,7 +74,6 @@ func count(x *Number) int {
 	return count(sub1(x)) + 1
 }
 
-
 func check(x *Number, expected int) {
 	var c = count(x)
 	if c != expected {
@@ -92,7 +81,6 @@ func check(x *Number, expected int) {
 	}
 }
 
-
 // -------------------------------------
 // Test basic functionality
 
@@ -117,19 +105,17 @@ func verify() {
 	check(fact(gen(5)), 120)
 }
 
-
 // -------------------------------------
 // Factorial
 
-
 func main() {
-	t0 := time.Nanoseconds()
+	t0 := time.Now()
 	verify()
 	for i := 0; i <= 9; i++ {
 		print(i, "! = ", count(fact(gen(i))), "\n")
 	}
 	runtime.GC()
-	t1 := time.Nanoseconds()
+	t1 := time.Now()
 
-	gcstats("BenchmarkPeano", 1, t1-t0)
+	gcstats("BenchmarkPeano", 1, t1.Sub(t0))
 }
diff --git a/test/garbage/stats.go b/test/bench/garbage/stats.go
index 474e6ad4a..cdcb32f9b 100644
--- a/test/garbage/stats.go
+++ b/test/bench/garbage/stats.go
@@ -8,12 +8,14 @@ import (
 	"fmt"
 	"runtime"
 	"sort"
+	"time"
 )
 
-func gcstats(name string, n int, t int64) {
-	st := &runtime.MemStats
+func gcstats(name string, n int, t time.Duration) {
+	st := new(runtime.MemStats)
+	runtime.ReadMemStats(st)
 	fmt.Printf("garbage.%sMem Alloc=%d/%d Heap=%d NextGC=%d Mallocs=%d\n", name, st.Alloc, st.TotalAlloc, st.Sys, st.NextGC, st.Mallocs)
-	fmt.Printf("garbage.%s %d %d ns/op\n", name, n, t/int64(n))
+	fmt.Printf("garbage.%s %d %d ns/op\n", name, n, t.Nanoseconds()/int64(n))
 	fmt.Printf("garbage.%sLastPause 1 %d ns/op\n", name, st.PauseNs[(st.NumGC-1)%uint32(len(st.PauseNs))])
 	fmt.Printf("garbage.%sPause %d %d ns/op\n", name, st.NumGC, int64(st.PauseTotalNs)/int64(st.NumGC))
 	nn := int(st.NumGC)
@@ -22,13 +24,14 @@ func gcstats(name string, n int, t int64) {
 	}
 	t1, t2, t3, t4, t5 := tukey5(st.PauseNs[0:nn])
 	fmt.Printf("garbage.%sPause5: %d %d %d %d %d\n", name, t1, t2, t3, t4, t5)
-	
-//	fmt.Printf("garbage.%sScan: %v\n", name, st.ScanDist)
+
+	//	fmt.Printf("garbage.%sScan: %v\n", name, st.ScanDist)
 }
 
 type T []uint64
-func (t T) Len() int { return len(t) }
-func (t T) Swap(i, j int) { t[i], t[j] = t[j], t[i] }
+
+func (t T) Len() int           { return len(t) }
+func (t T) Swap(i, j int)      { t[i], t[j] = t[j], t[i] }
 func (t T) Less(i, j int) bool { return t[i] < t[j] }
 
 func tukey5(raw []uint64) (lo, q1, q2, q3, hi uint64) {
diff --git a/test/garbage/tree.go b/test/bench/garbage/tree.go
index c5eae9760..0a3ec234d 100644
--- a/test/garbage/tree.go
+++ b/test/bench/garbage/tree.go
@@ -68,7 +68,7 @@ const minDepth = 4
 func main() {
 	flag.Parse()
 
-	t0 := time.Nanoseconds()
+	t0 := time.Now()
 
 	maxDepth := *n
 	if minDepth+2 > *n {
@@ -93,8 +93,8 @@ func main() {
 	}
 	fmt.Printf("long lived tree of depth %d\t check: %d\n", maxDepth, longLivedTree.itemCheck())
 
-	t1 := time.Nanoseconds()
+	t1 := time.Now()
 
 	// Standard gotest benchmark output, collected by build dashboard.
-	gcstats("BenchmarkTree", *n, t1-t0)
+	gcstats("BenchmarkTree", *n, t1.Sub(t0))
 }
diff --git a/test/bench/garbage/tree2.go b/test/bench/garbage/tree2.go
new file mode 100644
index 000000000..3db0a0ba3
--- /dev/null
+++ b/test/bench/garbage/tree2.go
@@ -0,0 +1,89 @@
+// Copyright 2012 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.
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"runtime"
+	"runtime/pprof"
+	"unsafe"
+)
+
+const BranchingFactor = 4
+
+type Object struct {
+	child [BranchingFactor]*Object
+}
+
+var (
+	cpus       = flag.Int("cpus", 1, "number of cpus to use")
+	heapsize   = flag.Int64("heapsize", 100*1024*1024, "size of the heap in bytes")
+	cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")
+
+	lastPauseNs uint64 = 0
+	lastFree    uint64 = 0
+	heap        *Object
+	calls       [20]int
+	numobjects  int64
+	memstats    runtime.MemStats
+)
+
+func buildHeap() {
+	objsize := int64(unsafe.Sizeof(Object{}))
+	heap, _ = buildTree(float64(objsize), float64(*heapsize), 0)
+	fmt.Printf("*** built heap: %.0f MB; (%d objects * %d bytes)\n",
+		float64(*heapsize)/1048576, numobjects, objsize)
+}
+
+func buildTree(objsize, size float64, depth int) (*Object, float64) {
+	calls[depth]++
+	x := &Object{}
+	numobjects++
+	subtreeSize := (size - objsize) / BranchingFactor
+	alloc := objsize
+	for i := 0; i < BranchingFactor && alloc < size; i++ {
+		c, n := buildTree(objsize, subtreeSize, depth+1)
+		x.child[i] = c
+		alloc += n
+	}
+	return x, alloc
+}
+
+func gc() {
+	runtime.GC()
+	runtime.ReadMemStats(&memstats)
+	pause := memstats.PauseTotalNs
+	inuse := memstats.Alloc
+	free := memstats.TotalAlloc - inuse
+	fmt.Printf("gc pause: %8.3f ms; collect: %8.0f MB; heapsize: %8.0f MB\n",
+		float64(pause-lastPauseNs)/1e6,
+		float64(free-lastFree)/1048576,
+		float64(inuse)/1048576)
+	lastPauseNs = pause
+	lastFree = free
+}
+
+func main() {
+	flag.Parse()
+	buildHeap()
+	runtime.GOMAXPROCS(*cpus)
+	runtime.ReadMemStats(&memstats)
+	lastPauseNs = memstats.PauseTotalNs
+	lastFree = memstats.TotalAlloc - memstats.Alloc
+	if *cpuprofile != "" {
+		f, err := os.Create(*cpuprofile)
+		if err != nil {
+			log.Fatal(err)
+		}
+		pprof.StartCPUProfile(f)
+		defer pprof.StopCPUProfile()
+	}
+	for i := 0; i < 10; i++ {
+		gc()
+	}
+}
diff --git a/test/bench/go1/binarytree_test.go b/test/bench/go1/binarytree_test.go
new file mode 100644
index 000000000..c64c4b881
--- /dev/null
+++ b/test/bench/go1/binarytree_test.go
@@ -0,0 +1,63 @@
+// Copyright 2011 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.
+
+// This benchmark, taken from the shootout, tests garbage collector
+// performance by generating and discarding large binary trees.
+
+package go1
+
+import "testing"
+
+type binaryNode struct {
+	item        int
+	left, right *binaryNode
+}
+
+func bottomUpTree(item, depth int) *binaryNode {
+	if depth <= 0 {
+		return &binaryNode{item: item}
+	}
+	return &binaryNode{item, bottomUpTree(2*item-1, depth-1), bottomUpTree(2*item, depth-1)}
+}
+
+func (n *binaryNode) itemCheck() int {
+	if n.left == nil {
+		return n.item
+	}
+	return n.item + n.left.itemCheck() - n.right.itemCheck()
+}
+
+const minDepth = 4
+
+func binarytree(n int) {
+	maxDepth := n
+	if minDepth+2 > n {
+		maxDepth = minDepth + 2
+	}
+	stretchDepth := maxDepth + 1
+
+	check := bottomUpTree(0, stretchDepth).itemCheck()
+	//fmt.Printf("stretch tree of depth %d\t check: %d\n", stretchDepth, check)
+
+	longLivedTree := bottomUpTree(0, maxDepth)
+
+	for depth := minDepth; depth <= maxDepth; depth += 2 {
+		iterations := 1 << uint(maxDepth-depth+minDepth)
+		check = 0
+
+		for i := 1; i <= iterations; i++ {
+			check += bottomUpTree(i, depth).itemCheck()
+			check += bottomUpTree(-i, depth).itemCheck()
+		}
+		//fmt.Printf("%d\t trees of depth %d\t check: %d\n", iterations*2, depth, check)
+	}
+	longLivedTree.itemCheck()
+	//fmt.Printf("long lived tree of depth %d\t check: %d\n", maxDepth, longLivedTree.itemCheck())
+}
+
+func BenchmarkBinaryTree17(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		binarytree(17)
+	}
+}
diff --git a/test/bench/go1/fannkuch_test.go b/test/bench/go1/fannkuch_test.go
new file mode 100644
index 000000000..ae45bfd88
--- /dev/null
+++ b/test/bench/go1/fannkuch_test.go
@@ -0,0 +1,84 @@
+// Copyright 2011 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.
+
+// This benchmark, taken from the shootout, tests array indexing
+// and array bounds elimination performance.
+
+package go1
+
+import "testing"
+
+func fannkuch(n int) int {
+	if n < 1 {
+		return 0
+	}
+
+	n1 := n - 1
+	perm := make([]int, n)
+	perm1 := make([]int, n)
+	count := make([]int, n)
+
+	for i := 0; i < n; i++ {
+		perm1[i] = i // initial (trivial) permutation
+	}
+
+	r := n
+	didpr := 0
+	flipsMax := 0
+	for {
+		if didpr < 30 {
+			didpr++
+		}
+		for ; r != 1; r-- {
+			count[r-1] = r
+		}
+
+		if perm1[0] != 0 && perm1[n1] != n1 {
+			flips := 0
+			for i := 1; i < n; i++ { // perm = perm1
+				perm[i] = perm1[i]
+			}
+			k := perm1[0] // cache perm[0] in k
+			for {         // k!=0 ==> k>0
+				for i, j := 1, k-1; i < j; i, j = i+1, j-1 {
+					perm[i], perm[j] = perm[j], perm[i]
+				}
+				flips++
+				// Now exchange k (caching perm[0]) and perm[k]... with care!
+				j := perm[k]
+				perm[k] = k
+				k = j
+				if k == 0 {
+					break
+				}
+			}
+			if flipsMax < flips {
+				flipsMax = flips
+			}
+		}
+
+		for ; r < n; r++ {
+			// rotate down perm[0..r] by one
+			perm0 := perm1[0]
+			for i := 0; i < r; i++ {
+				perm1[i] = perm1[i+1]
+			}
+			perm1[r] = perm0
+			count[r]--
+			if count[r] > 0 {
+				break
+			}
+		}
+		if r == n {
+			return flipsMax
+		}
+	}
+	return 0
+}
+
+func BenchmarkFannkuch11(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		fannkuch(11)
+	}
+}
diff --git a/test/bench/go1/fasta_test.go b/test/bench/go1/fasta_test.go
new file mode 100644
index 000000000..dcb2d1055
--- /dev/null
+++ b/test/bench/go1/fasta_test.go
@@ -0,0 +1,164 @@
+// Copyright 2011 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.
+
+package go1
+
+// Not a benchmark; input for revcomp.
+
+var fasta25m = fasta(25e6)
+
+func fasta(n int) []byte {
+	out := make(fastaBuffer, 0, 11*n)
+
+	iub := []fastaAcid{
+		{prob: 0.27, sym: 'a'},
+		{prob: 0.12, sym: 'c'},
+		{prob: 0.12, sym: 'g'},
+		{prob: 0.27, sym: 't'},
+		{prob: 0.02, sym: 'B'},
+		{prob: 0.02, sym: 'D'},
+		{prob: 0.02, sym: 'H'},
+		{prob: 0.02, sym: 'K'},
+		{prob: 0.02, sym: 'M'},
+		{prob: 0.02, sym: 'N'},
+		{prob: 0.02, sym: 'R'},
+		{prob: 0.02, sym: 'S'},
+		{prob: 0.02, sym: 'V'},
+		{prob: 0.02, sym: 'W'},
+		{prob: 0.02, sym: 'Y'},
+	}
+
+	homosapiens := []fastaAcid{
+		{prob: 0.3029549426680, sym: 'a'},
+		{prob: 0.1979883004921, sym: 'c'},
+		{prob: 0.1975473066391, sym: 'g'},
+		{prob: 0.3015094502008, sym: 't'},
+	}
+
+	alu := []byte(
+		"GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG" +
+			"GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA" +
+			"CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT" +
+			"ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA" +
+			"GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG" +
+			"AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC" +
+			"AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA")
+
+	out.WriteString(">ONE Homo sapiens alu\n")
+	fastaRepeat(&out, alu, 2*n)
+	out.WriteString(">TWO IUB ambiguity codes\n")
+	fastaRandom(&out, iub, 3*n)
+	out.WriteString(">THREE Homo sapiens frequency\n")
+	fastaRandom(&out, homosapiens, 5*n)
+	return out
+}
+
+type fastaBuffer []byte
+
+func (b *fastaBuffer) Flush() {
+	panic("flush")
+}
+
+func (b *fastaBuffer) WriteString(s string) {
+	p := b.NextWrite(len(s))
+	copy(p, s)
+}
+
+func (b *fastaBuffer) NextWrite(n int) []byte {
+	p := *b
+	if len(p)+n > cap(p) {
+		b.Flush()
+		p = *b
+	}
+	out := p[len(p) : len(p)+n]
+	*b = p[:len(p)+n]
+	return out
+}
+
+const fastaLine = 60
+
+func fastaRepeat(out *fastaBuffer, alu []byte, n int) {
+	buf := append(alu, alu...)
+	off := 0
+	for n > 0 {
+		m := n
+		if m > fastaLine {
+			m = fastaLine
+		}
+		buf1 := out.NextWrite(m + 1)
+		copy(buf1, buf[off:])
+		buf1[m] = '\n'
+		if off += m; off >= len(alu) {
+			off -= len(alu)
+		}
+		n -= m
+	}
+}
+
+const (
+	fastaLookupSize          = 4096
+	fastaLookupScale float64 = fastaLookupSize - 1
+)
+
+var fastaRand uint32 = 42
+
+type fastaAcid struct {
+	sym   byte
+	prob  float64
+	cprob float64
+	next  *fastaAcid
+}
+
+func fastaComputeLookup(acid []fastaAcid) *[fastaLookupSize]*fastaAcid {
+	var lookup [fastaLookupSize]*fastaAcid
+	var p float64
+	for i := range acid {
+		p += acid[i].prob
+		acid[i].cprob = p * fastaLookupScale
+		if i > 0 {
+			acid[i-1].next = &acid[i]
+		}
+	}
+	acid[len(acid)-1].cprob = 1.0 * fastaLookupScale
+
+	j := 0
+	for i := range lookup {
+		for acid[j].cprob < float64(i) {
+			j++
+		}
+		lookup[i] = &acid[j]
+	}
+
+	return &lookup
+}
+
+func fastaRandom(out *fastaBuffer, acid []fastaAcid, n int) {
+	const (
+		IM = 139968
+		IA = 3877
+		IC = 29573
+	)
+	lookup := fastaComputeLookup(acid)
+	for n > 0 {
+		m := n
+		if m > fastaLine {
+			m = fastaLine
+		}
+		buf := out.NextWrite(m + 1)
+		f := fastaLookupScale / IM
+		myrand := fastaRand
+		for i := 0; i < m; i++ {
+			myrand = (myrand*IA + IC) % IM
+			r := float64(int(myrand)) * f
+			a := lookup[int(r)]
+			for a.cprob < r {
+				a = a.next
+			}
+			buf[i] = a.sym
+		}
+		fastaRand = myrand
+		buf[m] = '\n'
+		n -= m
+	}
+}
diff --git a/test/bench/go1/gob_test.go b/test/bench/go1/gob_test.go
new file mode 100644
index 000000000..00eeed57a
--- /dev/null
+++ b/test/bench/go1/gob_test.go
@@ -0,0 +1,95 @@
+// Copyright 2011 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.
+
+// This benchmark tests gob encoding and decoding performance.
+
+package go1
+
+import (
+	"bytes"
+	"encoding/gob"
+	"encoding/json"
+	"io/ioutil"
+	"log"
+	"reflect"
+	"testing"
+)
+
+var (
+	gobbytes []byte
+	gobdata  *JSONResponse
+)
+
+func gobinit() {
+	// gobinit is called after json's init,
+	// because it uses jsondata.
+	gobdata = gobResponse(&jsondata)
+
+	var buf bytes.Buffer
+	if err := gob.NewEncoder(&buf).Encode(gobdata); err != nil {
+		panic(err)
+	}
+	gobbytes = buf.Bytes()
+
+	var r JSONResponse
+	if err := gob.NewDecoder(bytes.NewBuffer(gobbytes)).Decode(&r); err != nil {
+		panic(err)
+	}
+	if !reflect.DeepEqual(gobdata, &r) {
+		log.Printf("%v\n%v", jsondata, r)
+		b, _ := json.Marshal(&jsondata)
+		br, _ := json.Marshal(&r)
+		log.Printf("%s\n%s\n", b, br)
+		panic("gob: encode+decode lost data")
+	}
+}
+
+// gob turns [] into null, so make a copy of the data structure like that
+func gobResponse(r *JSONResponse) *JSONResponse {
+	return &JSONResponse{gobNode(r.Tree), r.Username}
+}
+
+func gobNode(n *JSONNode) *JSONNode {
+	n1 := new(JSONNode)
+	*n1 = *n
+	if len(n1.Kids) == 0 {
+		n1.Kids = nil
+	} else {
+		for i, k := range n1.Kids {
+			n1.Kids[i] = gobNode(k)
+		}
+	}
+	return n1
+}
+
+func gobdec() {
+	if gobbytes == nil {
+		panic("gobdata not initialized")
+	}
+	var r JSONResponse
+	if err := gob.NewDecoder(bytes.NewBuffer(gobbytes)).Decode(&r); err != nil {
+		panic(err)
+	}
+	_ = r
+}
+
+func gobenc() {
+	if err := gob.NewEncoder(ioutil.Discard).Encode(&gobdata); err != nil {
+		panic(err)
+	}
+}
+
+func BenchmarkGobDecode(b *testing.B) {
+	b.SetBytes(int64(len(gobbytes)))
+	for i := 0; i < b.N; i++ {
+		gobdec()
+	}
+}
+
+func BenchmarkGobEncode(b *testing.B) {
+	b.SetBytes(int64(len(gobbytes)))
+	for i := 0; i < b.N; i++ {
+		gobenc()
+	}
+}
diff --git a/test/bench/go1/gzip_test.go b/test/bench/go1/gzip_test.go
new file mode 100644
index 000000000..fe4c480eb
--- /dev/null
+++ b/test/bench/go1/gzip_test.go
@@ -0,0 +1,63 @@
+// Copyright 2011 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.
+
+// This benchmark tests gzip and gunzip performance.
+
+package go1
+
+import (
+	"bytes"
+	gz "compress/gzip"
+	"io"
+	"io/ioutil"
+	"testing"
+)
+
+var (
+	jsongunz = bytes.Repeat(jsonbytes, 10)
+	jsongz   []byte
+)
+
+func init() {
+	var buf bytes.Buffer
+	c := gz.NewWriter(&buf)
+	c.Write(jsongunz)
+	c.Close()
+	jsongz = buf.Bytes()
+}
+
+func gzip() {
+	c := gz.NewWriter(ioutil.Discard)
+	if _, err := c.Write(jsongunz); err != nil {
+		panic(err)
+	}
+	if err := c.Close(); err != nil {
+		panic(err)
+	}
+}
+
+func gunzip() {
+	r, err := gz.NewReader(bytes.NewBuffer(jsongz))
+	if err != nil {
+		panic(err)
+	}
+	if _, err := io.Copy(ioutil.Discard, r); err != nil {
+		panic(err)
+	}
+	r.Close()
+}
+
+func BenchmarkGzip(b *testing.B) {
+	b.SetBytes(int64(len(jsongunz)))
+	for i := 0; i < b.N; i++ {
+		gzip()
+	}
+}
+
+func BenchmarkGunzip(b *testing.B) {
+	b.SetBytes(int64(len(jsongunz)))
+	for i := 0; i < b.N; i++ {
+		gunzip()
+	}
+}
diff --git a/test/bench/go1/json_test.go b/test/bench/go1/json_test.go
new file mode 100644
index 000000000..5a3012167
--- /dev/null
+++ b/test/bench/go1/json_test.go
@@ -0,0 +1,84 @@
+// Copyright 2011 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.
+
+// This benchmark tests JSON encoding and decoding performance.
+
+package go1
+
+import (
+	"compress/bzip2"
+	"encoding/base64"
+	"encoding/json"
+	"io"
+	"io/ioutil"
+	"strings"
+	"testing"
+)
+
+var (
+	jsonbytes []byte
+	jsondata  JSONResponse
+)
+
+func init() {
+	var r io.Reader
+	r = strings.NewReader(jsonbz2_base64)
+	r = base64.NewDecoder(base64.StdEncoding, r)
+	r = bzip2.NewReader(r)
+	b, err := ioutil.ReadAll(r)
+	if err != nil {
+		panic(err)
+	}
+	jsonbytes = b
+
+	if err := json.Unmarshal(jsonbytes, &jsondata); err != nil {
+		panic(err)
+	}
+	gobinit()
+}
+
+type JSONResponse struct {
+	Tree     *JSONNode `json:"tree"`
+	Username string    `json:"username"`
+}
+
+type JSONNode struct {
+	Name     string      `json:"name"`
+	Kids     []*JSONNode `json:"kids"`
+	CLWeight float64     `json:"cl_weight"`
+	Touches  int         `json:"touches"`
+	MinT     int64       `json:"min_t"`
+	MaxT     int64       `json:"max_t"`
+	MeanT    int64       `json:"mean_t"`
+}
+
+func jsondec() {
+	var r JSONResponse
+	if err := json.Unmarshal(jsonbytes, &r); err != nil {
+		panic(err)
+	}
+	_ = r
+}
+
+func jsonenc() {
+	buf, err := json.Marshal(&jsondata)
+	if err != nil {
+		panic(err)
+	}
+	_ = buf
+}
+
+func BenchmarkJSONEncode(b *testing.B) {
+	b.SetBytes(int64(len(jsonbytes)))
+	for i := 0; i < b.N; i++ {
+		jsonenc()
+	}
+}
+
+func BenchmarkJSONDecode(b *testing.B) {
+	b.SetBytes(int64(len(jsonbytes)))
+	for i := 0; i < b.N; i++ {
+		jsondec()
+	}
+}
diff --git a/test/bench/go1/jsondata_test.go b/test/bench/go1/jsondata_test.go
new file mode 100644
index 000000000..7d42c9665
--- /dev/null
+++ b/test/bench/go1/jsondata_test.go
@@ -0,0 +1,1818 @@
+// Copyright 2011 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.
+
+// Input for JSON and other benchmarks.
+// This was generated by starting with a 2MB JSON file with actual data
+// about open source revision history, then compressing with bzip2 -9,
+// then encoding to base64 with openssl enc -e -base64.
+// The result is 125kB of source instead of 2MB.
+// We compile the data into the binary so that the benchmark is
+// a stand-alone binary that can be copied easily from machine to
+// machine.  json_test.go decodes this during init.
+
+package go1
+
+var jsonbz2_base64 = "QlpoOTFBWSZTWZ0H0LkG0bxfgFH8UAf/8D////q////6YSvJveAAAAAH3ddt7gAN" +
+	"FrKppN9gw0gA++fGB9xKkUpX0YWTENCgqzUW1tlsyMB2w9nnvNSigNyS+3cui5zA" +
+	"AAAAAAAAAI4kILu6ytuWTLBbaPXfc+A+PQEgNAG1ZMBYWnWwPoFrGjoBnYMumlUF" +
+	"UKA7NVBQgut30zzu8eM2tsoapJ7u41djLsxZarplSoJouxrdfHrHPSiqAGgkAD6D" +
+	"QfT0ABu7gG1qDtdVHVXp7vWuBoBk2wEOjKChQ5bvbh3riupXZycASbaiQEECRKib" +
+	"ZFJFtqWjR7bsGoaa1lIFPRoKVQKoJFyqbWr5OB1Aie2pobm1EJKqVBU1EE2lCg6a" +
+	"AUBV9hqL00q9btQ0J9hqu2zavWVdjI6aAusU22tNa+8m70GjRqarKRWtUDW2yFBI" +
+	"1kBrrqrxeX3AyB9AD0wAAAeZ6weqV1rVu8UVICgAAABeDn2cAAd9gAACI+7DvjHo" +
+	"j73u8X2dDXT2x6adeFOTNe7BvavozFezkV1xXtJzu8H0983QAHr5aPT42iem53fX" +
+	"23IDr7YejQNtVVZr24gGgB0VQffPXH18g9DoaDW8vt729h9bt72XsKth0ANxgodG" +
+	"iRxvYclAAAAAnpqRtgGvcbo9ABpy6aPQADRZ3aACjyox4NawKCqNdA6offa1WtPc" +
+	"fdjQUPvauprcLoPe2oaplp2w7cnOHdlF27xvPY1QU67vc8goBRttLYKaHXkPAAAA" +
+	"AAdyFFaYCVClAVSlCqVSilFUKEgoNT0CAQCBAk00g1T0jQNNPSbKADQxAJEBESIg" +
+	"Seomk9EB6mjQ0NNGgAAAAkEgkiGk0CR6U9CNNNNNPQRo0ANAaAAk9UpEQmoNNRqe" +
+	"U02o00AAADQABoACJEAlKamUCjZT9UGnqAAG1AGgAAAFRJCAQCBA0SYjTKbQmqea" +
+	"p6YU2o09Q9TT00nAlwPEuSelCeXl28B3IYIQHEwXUMSCvlAYS5LkrZn+XhHHAXZz" +
+	"FTJHAzrKZzYWC0pthA9SCmbkyVzoHbSUjhnAfBrYpwWYIB7GRjOjDQqokMbJENSO" +
+	"SBCN0WhaRhQWpVuoOLN0NPRed7eO5eW2lv5L+X/jf7EpJkEUNMJKZREogmkjMgZJ" +
+	"BiEEEliRIUKAoiaSEoDQZJBhKEZEQySQCAIIFNIMwCiSYRSYzKMkSSlI0xZMZKko" +
+	"RKlRtkmWJIrNNIBEJEYiJBhGMMkWYxRqUsmjKJMmCFJMaSmiyDSaEJtBIJpANKMN" +
+	"JEkpGQAYjLNETGUBRAlBKURgsC0wzKZhRmhiYIQZIsZCIIMiiNmFCCiSZNjI0khE" +
+	"AYSEUkjTMSZskZKRQWJoRNBI2IojZmMhTIkQEgyREEMoomDSiYxAZMECFCSKIkGg" +
+	"kIDIw2MNAlgyA0SmKWSSyIaRCSDDIkZmNGghgyAEoERokkWTA0xZBEQhmUSBGmaQ" +
+	"aQBFmRJMokwxIyRSWbAkbCUFlAhgUISJIRkySYhAxoUARCSaIJMkyiZJNBMyGRIh" +
+	"Y0komKImgMDI/038qLf/av/bWSNVEtmFRx/2aaDVmKkY0NkIRDGJEWoEGLf9g9MV" +
+	"UJWGSu0pWVpSOdWDVjQJGRSChGBGDGhNNMYYwjEsaFISGPT3TbFXk873Xq8vPa9b" +
+	"0dcco0UEPXIl/+em0IMHNYJaXBEsiKQh/7QwsC9gAauDvWtMEBWhGBIBAerIYlBU" +
+	"SzPasze15BfAyGrr284QNjGNEmaUphiMxEMwCZjAYRpMiZBMpEMkkQzIwTDu5zru" +
+	"Xd1xdQ6A6E7m7d03OLnXOxd3HBu50dl0JOhxS4HdHczuO647uuLu6650O67t3Duu" +
+	"3DucukzRKIMhsUjSQQxDIzQJgxohEkYTYkZsAxSDGCJJERhpEAygoZRESSEjMpFE" +
+	"0UpJlBkIYwoyQ7/2f9H/Py8roY3wEn8nr7+72ybZtybdqY06yp1tjGVmsmJvG48y" +
+	"89EXnvy9F6OvX0vpBSIEiSRAmgSASYSkCGBkyc5J63pgiRBNsJW2xjGmmNsf9v7R" +
+	"z1rueFmZcfXzw/zTGRYxsYm2NjbbfXD64GtivKx5t9eubzmsMTbf9rTfKRsYx7YR" +
+	"jHWL7OoAJpsFBJgyAEzSJiLHxfJKWQgSlJjGduRqRxDIoETG4wj+VgUjnMt5PXnm" +
+	"vEQwO7ojzu7lxu7uasg9T00zjrtcaG2RKIwyHx2vUcbjd0OXXvfNafFE3u3t7bu9" +
+	"TpJ1t6SKh9vi13hQUX4d307pPHt553zxxHMGb4KrbbvJGTCcNs3WmOyG2fg5vsuZ" +
+	"jMi+lacpNcvr0XeKDnafDcIvhyL7927rr7/Pzfj7qLVW5dFKIg8+fKpuxf+vfhB+" +
+	"73vWXz3qCPPfw32Mn4c/9mtONctW/fc1sYad9JYn/D1DlDPoyyc7D5bSi3ncMPNH" +
+	"bWmvm42eODHImqooiuXwn95XZlmKYKGK7KdA6lrgzZpEiUccypzKofPy4kbjq6Nh" +
+	"o/ou++j5g2i5alDG/G3Cb0yaOY3lH7wd83fLG1uQ0nDG18UHnnOOsy+Y4u2Nv5Hl" +
+	"jTCKmSJYyBhnB1Lbbafjgaat8zzctvDjPPy7e5IdyZHPSTxq/zkHjinrI5v0/nmG" +
+	"Pp+JUz4odkc9b4/cze19oRNOjG2wb+PkWtt4RRjbBsfupHPO3Mmgc18az57U+TM7" +
+	"gQsH90UPHJCZN4WsaY383qkbxxO20pI23JHbCr3ssnqkVFJG/lN5x6yQydwiaSA6" +
+	"rcgBoSxEDRKIuS1slJsq1MtS6koA5+jFGb17XFu0owrTZZSqsjrkmLVo2tSN44ac" +
+	"fvD3aWfOerth5lG/Jlkfp6bqUbOZs2FpVptDIwCuWVgqIgkgJMtDBFi+2FpRDhEI" +
+	"JAKJtPXloMoKGWpU0YvH9h2nx/hxra8/8UoaoWbia9EeoTlN7Bd5PNdcCDKemn+L" +
+	"cY2qMUXGibc0a33/wjqMN0s8PmTeeup76JA7aKr1nMbhIkn1aX4m5rTPH4aOBlTQ" +
+	"I35HXHwtJ9z1XuF9EQDwDnCS3S9W358a/E4pTeTSVvyKGWTK/n4Xp7V4dB64Ua3Q" +
+	"BIaDtzTsXpXV1k9E54ousxG/XtEhuaGmyCefTL/r3478anc78deNRjg9uchGVxVD" +
+	"Fq6cMZqIdp0ihq0xoIf1zldyBS011SFzq08qfSxV8u0cT70dZgp8ebjk800pU8m2" +
+	"s1kKdj+zvmBEEU+P0+FlzrhOf/ifG2tOsmrlp7B88bbCY9u1VFK7YavjSQ7xtE94" +
+	"3aiJb59/et60wn2vrgeV/jeNd+O/Wt/fp6dNf7iJA5QICcGyiKgpFEFQiCjEGEQC" +
+	"LBIioACSIqiCxSCqIxJIw1GQ0Ua1Vam2qYsmg1rVTbQlmjVbWbaGLbU1kWtlqWrN" +
+	"LVNNaaQICZqIhD/QiASyQCUEBKiRKRAJSUiASySKRAJSD/zAgJUghMIgEojKiCf+" +
+	"CIBP9wICfq+/889/0uxkuba/pJdybzbJvEsZ/CpEx89uGn3OONVtyYDHCGIxNyIx" +
+	"JsYgJYbH+I5RK73DuMZminldjp3e8QpDJju1QToo7pQFEpABpEV4CLQo2QicBAbo" +
+	"SEINjsMsDt9BO4nJzGstqAmgEJwhRyggJYoMJE0sJoa0zOdEgXdwiQssy4L3pzbM" +
+	"CwOaLEYFDBQKzaJCjFh2yhQOHbgLVMHXFUf7jhKTXPWsNDuEPXRHfJuLlKqls5Tx" +
+	"pCC1IgIHnTm5PeWkwwjobODcCdTCa0YoDvMlcZwvmQTkg8KC06oALrhzZqrQmQq6" +
+	"E28rdrSUxBeLkBshIKRh04g4LDdsmTCpNKSszbu9lHOoAwkmTDrOKCmSqExdOsOV" +
+	"D1XsAQpFVMukLCcGYGVFpAp4Bg0VnXFFjjdC8avBE6BepA3q6bOgot8LtHTiIlkb" +
+	"ARVEcldJoYt4Pimls9rpBzDNzeMwOdNAdSkWo4CrsTZ065yPaODXMCkcZCarR0LU" +
+	"voX1R3nDEsLtlyklMo3qrYHIguO1Ci7xRXFwJZjfTrtZfAyzUKhgJcLOIzeTvWjG" +
+	"zDE27OYME6dM3Z2kVeKcV1I4jKga0x3vCKlcUmkjRE1Zzsmxsq7L3zOnQ8wzeGDZ" +
+	"pQO0uN0NpZhcQSuVETbLL2zvKTzqjtBhwIXGaksi8rYKx2Wi6C1J3Ulb1dwqkjat" +
+	"FU6mO1F5Ii+bGnOMaOlc5EKekFDaQ9tjCU1yqcE66xRVh1ndLcBt7ThNI8LbowKP" +
+	"Md0AHRNhdYOJksYIQETYuK3ytX1UEkFHZLCghijoBdFzCgKJmlJSADdF5CnsMoIp" +
+	"pMjeqUgBrXACCcshXWsqyAgenB7IMoT6ZghKl5ljwkJTUVQuhTp3YIWgQCl8eBO7" +
+	"FTzwWGBEw8BDaLuSqMmM0wWE6QVsFIpRwmCRA128BCKpdaVunHbkyuScBsqeFjLJ" +
+	"qAw0WUUIhMN3S5Keua7Wynjnew31G8jecPcVIYxGw3trGziGoCdTHKPOEpO5732V" +
+	"4lnVA4VvKsc+R4OHHQz2JkHFdwSzeiDBUGBiQAJcznd7Z0oCmMykE5KjZuKCyKhd" +
+	"5nTSBBtu1sj6s2JCiZBgpYdOIM4luy6evBlYUYldUQQZKOoAiZL4d7fe003l07CD" +
+	"omKNzZgXiveIrzXjCZel4BcyY752rec3eRoT6jAGZAGEc3kkZQhLcVNCq+qVFSim" +
+	"BuCKZeQr5FF85WTJZzIXXwto0cB2CpntlWr0xWTfLt1yrDg8503VJAdH0uqes4bJ" +
+	"d5wsYFakMZlVS7lsEko6gj0LqyENh3rvG7qYJiQ9xoY33UthsUwRtEF6HUjtHWGA" +
+	"1q5N1HNgiI7rFa5QiEzuCDZ03KzKswfM7185zaRUkRyiUUssQSPAwlc6CAaa2KwB" +
+	"CwsOVTUrpamy4uS+mkF2pVMrpWpG7eYkYjcqSMY+pyDKhDILMmR5HGGc5ml4LJEa" +
+	"A2sxQOlwRDZ0WyiDjMTFnLRKRw6sK02ph9cZnMe8fZrmsJ0710vNY0uY4QFbSrzd" +
+	"WY7FvR2oW0ZI0zyUKMETaoJFAUTUyWuaSjAQt4DbxyqAYcj2ysQneAWKMQAWMoBB" +
+	"hIT0HPY5ne8L49gqYBFQhCXlCmzuzQImhRcjCApqiwAmbWJbzsY5reBB1xT5l5T1" +
+	"ybWy6V0tnJKrLM5WHNy+RpkM2cyZ5hebCcdg7aCc7IdY80lCFwSGCAXNmQXb2QRQ" +
+	"x7k3NRDGXELYQ1gsQhhUDum3ZE72ughHRdRDe5Te6qw1u1LB7lbNrJow7QT1uAV3" +
+	"LMgyxdGjCMORl8Gn2BQuwIUzm8BtHWJnZGBtieoICDTvKJbIMisQ2U1BCZoZlhQX" +
+	"ygQBW0jtgQdslCYNcrXVNnBA+zLTmqmqYeS9YapA12zNGgCPsUFmdoio3ByWaNXs" +
+	"7NrZuGMrSZWRJA0vOHdOWzMw8kjKrskdtyHLanDtiyJzpWVgjo+aaaAkqTKWLcdw" +
+	"xANHQyoZ1XdCK2biAxFgjnDMsxEk4wrWTKgmoae5DQbpESptb1u3Dbpe6qOAZBKa" +
+	"UBJKBZeiCwEJ0WgjFAInS4JGF6SCWBfA6F3ud3YtJTVontzKvsRDk5lipuE0+KVI" +
+	"KnHbGmhhDdShYAZ20BJi8hNs22nd3MxNWKTyqlNVdr1vFs1kiRRBRoZYJt1SAw2W" +
+	"IVY7gXmtBFNaclgFQFjwnNh/g2AZt0p2YbFHgZ1ZkUHIuCAEMTDITBEMBgx4Ecgg" +
+	"OwyuETQ7GUQsGRFZENlWXORDAZBg5I2Qg0CU0NEcuCVhf8E4pyCmHivNaJAP8Dg6" +
+	"HMU/BCCcRX/CAZi3FTsR+gqagg7gfXVQF3AFS45ig+iMnICOKROLlQG9QyjKyxqt" +
+	"rL7DL2NWEoOARpsJENtjCQigyaiVbD8RcRpvD0dJYxh4KmINWGAOAshCD2ihhCBU" +
+	"w7Rz2iEeFpgIN0kKqUcbsJC1I9OQR1ARqIJlDBA9OIaiEhhK4RqJxpaG4HNX26+L" +
+	"L2uVbzYr6uxSpDYDItapRNSDSPMC40zShplaragEHVTTzmCYzRWDaG4boqxNVpQe" +
+	"/U/8feVF+H1z3Iy2hnvDyeOt5n1QI23zarZHe9m7tUTEm75vIImeGztcNqf8/DK0" +
+	"7AS3hyuujbWlvld0RqQIdaW8VAyyAqKpJUEU5BBqICLiixEH2fZwoinThP1ruaww" +
+	"Wxs79RpIWIc1I6VkHrWTkb36HKsT8aCEdYQp8dyc8nHc5Tn1GZ9DqfXs+w6jU5vi" +
+	"5KOwjHVB4s9RJbGxesXpEnueovCTuXRSXfPMqMjxq9le4We74avJg7nrh8fkY4r3" +
+	"uTybuqrI5WCNRuBiLUVuMAR02HDRwNFmhVQC0wOxtAjoECQdIAuc+ZfaLo6O0IVM" +
+	"EV4FEtlx4W2FCCd0Phvqkylm+T5VSzgZCqK7UNZc+X11LEfD369NnPNn684h236W" +
+	"bTiIcgobiiYguzQoGj4YxXj++cs4Tz0qdHkwXXYuqOxh4RlKlgXcTb+ZT58LL54/" +
+	"X5UkWd6UwSUtKWg8ezAgn3LlVGy99KvHea5jdcQUuTpOwzdqe2VOu9t12gz7+79S" +
+	"tp9hZGnb9KZ0+UWVGOfa8PL8MePzZ2jpXPc6c8Sz56UZnuR7VyqryWOdve7uxH+f" +
+	"7i9zTaJuakt23DIbPPKW3WvwvI5hyr5WOMzSpMgcRs3ZkcLrNrzmzOP/kkQSPs/c" +
+	"fx/623+62xX7H7t/15ZmW2yT/C26fxC/1B/Nm/4vHf4Y/W83vZdxnDDNatLLf4zJ" +
+	"2SOOSTXtmh6bgfkM/aUg/9rYz+ROs5f0f7Np83tXE0ON27ynOf4eduzHucnkr/bP" +
+	"/xPo+Tm1N30cm7RXZ2cox/U5Js3cZ8ctGrXWkfP6/AuC4YHo+wmtGj+jDpRjOnhC" +
+	"Rui6MS/oi+aX3Nt6cccYzh37RNxmjpw854P83H24dWtaabtnmK/F6q09XRzP6HOT" +
+	"UEd6oETQUHmXUt2toYLMjFiMiAgDhaE2Dii0fPTcNGH7p5jf0kPg3fXkttKDMGej" +
+	"3IKP2KJOlt/R+CT7PcY3AZxsoa+WREFD5vk4TdXR6uRq+MzKxSvDrq2ak+c2275m" +
+	"d5ettnJp+4/Y+HV6qxudXLdedt6uSdTKGaMJP6jNbZZww68/M8PzplDqYusu8ZQB" +
+	"AFQUJ8y9CB2DjMriYXiyEoiFRoNAmCWWSMuP4EvGSYUfk7ut8CD78n+j+iqqihWU" +
+	"fmZb8RVjX9LiIokXhgfqc+hjbZR8xHTSG2NvltyeEkBoz+i+EBqwZMS3bqJsEaIa" +
+	"GhUYwpTgGQIwCHFSPHf9PH5soVQwNtyu3LdB4H7h7qHvPtJPgw2vhhBmwPscrZ9i" +
+	"B0ofZ8/K22LZTR+R6NBmMbWj+o8N5NK4btPxmPo3Yvl53M08zTwps2Ux8n29W7or" +
+	"ecnOTH4LDyKfk9eenmurrptb6EDAylMSyCFoPt68A+P2W2rxpvgRO7eOTE06p78T" +
+	"pM095szdT5dJNkqV9yvdk2KjRq7ZNv2M/zD1uISNH5LRt2dPbXxwgg+aSTdJarr4" +
+	"+t4IO5+isaqdYSfl2IOJ0ntA756tsBY3I66SOBHlU+0+8bWUbHdtxa1P2y83z5Pv" +
+	"NqJ29h6ymz5tztPN04yw5+OsUx767u+t4Wb68vvztvPsCb27OnbrgHffegij8Dbt" +
+	"R+cpqFnrpoO2jCj+dtrCBfwtFtxfNrZd9ZcQzVPa9qbeq8duMYmVfF+2cTONb3u2" +
+	"m+N7LwZwK24TMUPA/s1xS2PJ211vg1JfBUXQLO2tMacGtLJmttPE59YWnForCNrr" +
+	"vbv4+/xy7+NG7BfXbnqKVTuo0DMuFW6c/DBvb4i5+crr56qLSmCHWi131w0DRNem" +
+	"G8J8mWF6/BavOE5YJruAqh/e19oRd79a8j2xXHhVteYnEW9a1AvE2WHFHnr7Wf43" +
+	"p9q/GjSGtZb51XBDR5fZe/afXwzt1jTi0aTqd5pQ9xPS9+tflc68V3+R30RS3anM" +
+	"Z7/OYoK83au2vY962u/PmnmvWmcymeWxxPne1H49bc+va/KVHaqJxTgrqcN7zDZ2" +
+	"TweudXvavlknvqpsg6zC6+IavvB2enbrx754TjNRir97rpG62S7VPnth+nn9KvmF" +
+	"thTinXkTrfbYcr54eVPbFQRF11vTW9+CcB+4r3XRpMtsKWHnhn3dFDF7PYpQoLeU" +
+	"zh639UyDF5ouhQerfW+FKROlO2lJwm+UDcwvkjwQ51nx2aQ+iINt/lkDDTrmb2vr" +
+	"xryHii648Xu/tF6QHbUcIFxgYRp4+V7eaLG64b2su+ONNxKEDlYjMR1Fuhvauj8z" +
+	"eus/aeYa2iB/Va1tuuH2zjOvxxxonwsbYInfrnTPNs504yedSRkJR0jeaBvNr5mG" +
+	"nFr5TFHNub0FVE3034E+q7tfF5n54uuT4o+28bYpzjhtI6mfB4jbVMEd31VAR4vi" +
+	"GN8Tu4umaeq9qLGLNUsvpQu/8faJd34UW2pXhjvaq0NFmKDNZ7UjVrNM4aXvd5pS" +
+	"g7LW/5p7955Vtvf6tsMfFl9rs3VvkKnfvemaXnFPGd4je+Y3iU3nXv37xz8/Ot5b" +
+	"nc6a2J+dPSXnLYpvqfBk7ZifA8RiUeNNauSKONwZWKpMDsKhPt+f5X25+dAjco/6" +
+	"X52E/Ys3128FfCeI+sV1Ngs+8/j7+sqrWwKe/0ydfK2xlW+++7Sx8Nr09NQEOaq5" +
+	"Z21TVe+3euawND9LPk1eaTWOD2M1bXSfq32fH5WrqCSRodPHmm85a3Gq8/ldR8zn" +
+	"NtO6s/E5oRyyZ1pX09q7BTxk/n5j1O8Yr8nSj+qezJTO/bzuIo9vLwYbxnRYVVut" +
+	"OL7dQJYPFNnRyNDLjWmONtQBd1AxDZA39o0QEps8eiBrSOQO+M2yN/b3A0Mr9bVG" +
+	"5A42A3LcI0uBvqcxzal1tziFTfaXakSnUaaNpTxpS+3avWO1hvyyUtPUe+uu45yi" +
+	"4aeNNM2GnS0nrucvjF/OGhoOnW1aB+Lxnmzq3GyztaXeuQpomp1FUXt7Rffavj8e" +
+	"Jxqux8eyex3ftOU4rXxtxMYwPRqwXX3Rcbx8dn9s3YtPa1XrnZx3dqikI3E1b3fP" +
+	"b83aGWPme0CcoGvA1o2PWLs1K+ceH4fTFuVHzrGWGpHci+dabeFi0V6m3aE68H73" +
+	"Zw10nviGOyJI6DzqzFDysrN7Vt3elS/jFreqKx+UpRu/mfHbO2Jz7663zp9WvTov" +
+	"vvvi14Hr7KrTbRduDN4R+UTmqrtsy2L5ZVHyb3Y6t0R06bVXuuJsOJpv5TdGqPBn" +
+	"vjuRp2u8z2WyNdKcny5v9uOfk2vv7aaeetW8z7wtz15nB6WenehxSnftgbkj3tWd" +
+	"Mah+7rRbrONx6m49l1arhpoQIQzabRKaTwFVPoKPOmlsaT9tWeFUp8/XrDuFrtXT" +
+	"1Ap74Ub+kFY8KMkmQ4I7OOw17bYmTediZ0ZtqXZakoO7cey6d0rpPrCrpmfgHM/b" +
+	"a7hjUcJ7c3OM2GCCHLLJ9KNHOb1c199tbZc8EKX0o9vETvYazOKX1tnTN9u/0fij" +
+	"7WpVRTrmmb7c73x2zlpOsWq3PBNjMryyVim+k6qIHV8cZzrm1NNNtGG3WiU222+q" +
+	"WvilXLVPDTtuujYqnq92HkjtPrnhn8wfFVRtPKbMlam+ja2nZNWzVGx40FOJoI1m" +
+	"jzX8RMGuvpd/eu+lF81TFb00pDIz9nRKTd6RSnvt2s+s7+qqt/jhaRHwyffKQ/z0" +
+	"/tG3K+dUXivrmu3jC03fjSsNvPfd9sob+3xr8iPBlBljpK63v6fnbHtxKpDNFNx4" +
+	"fWXi+m1XLycVHAWwI7iooCKfX4XX8vjqgNOk/E9udJqie7fMu3gr4Snj7XtqUiPX" +
+	"k/dmGsfHvAp85erxqS/xs1bwlgkOcUNz9VxavzsJ6RvKmczE3Qfa3x8N7dfP19fV" +
+	"5zBafd0+t4Gv1r9dSf3T6+afWJ0nyP0YagjzqAokAsvA5HMvICycScGRH5DZSUA+" +
+	"4yHCgQfxOdfUK0SiI3A5uCNvta9mxHytvJydnbe2vh3ekY7Rp0aKfJeTkcPDZ8Nm" +
+	"PB3NTaen67W1s5nLDjLOzJpdra8zzbuJp5Pt6W7cnZU5vM2/Y6dMPz9e5Tcsdwed" +
+	"g3dJ1jb2DdpxJIz0Z0kNPqBsn92/s4FF+N/glGnYgij0wPhQuH0EH5P7jwhh/JyC" +
+	"zw+Z3IMdOXTp3K3ZOHCvyezHJs5atrTSjQcMZLMtxWHd4dXKNgxw4aZq3nzb+1vu" +
+	"cjpvN/b6mqqpFQxWMPRn6H4LFK8ID7PD0s4SMs9KL0KMPT9CxUqLPxoSUfQf0KPy" +
+	"Lhh9D1vz6H9jW/B0emjPs4eCR1R8HP7MbkZSDnGyW2fQzpoFHCz0g/k0/c8XzYzM" +
+	"Xg5v2dmmnecnavJvG6+L5VVNPmrir5NP/86vZ5HJ8Nnbq3mj04tjyV4Y9nm2eh0f" +
+	"qafNu7Pns6K05Gnm+zfa1ps3fD43tuO76Gt3pHDu2Z4fN0c3eclcM5W46KqvgrfL" +
+	"ZZ8Ozk5zj2t+GJ1OZux01LfBLof2MVLIb+iTTw/Qko8MWFEI2oiP1WGGjYyKLrbb" +
+	"fh6PuDD7yk3srttD0dPqECggsURwgcKHFYVt9Z+a1C4nm6Upa9L3uLtW7mx0YcK4" +
+	"Kx0dfZa/Ltw8n9hXZ89reu1qDcLLcHUQNwHtoWoGtuURwwrIGERCPzCr0EbZJDNy" +
+	"QYwp37N0hT9ZQ2foLh0PmQ4bKfLwekfRti0fBA/YfU4d3PrbbDZ6xtdCy8gjwLiJ" +
+	"ERJhI2+1B1WIF0FdF1DCwjKkl0UI4z0M6fVMf6venWbllsbtgcPvILqxNlq6efK2" +
+	"Sq6vRw6K51ebu01V9Z5ui4IUOJjUBhQUeqIhoDPBJAf0TLYPoToLip4WdGkzxt/Z" +
+	"762yzA4Qhhh4oHIv3KIDT5KmZlTKwtaWOeREM8623/B6elo8Q1JxiWAgQncQECgM" +
+	"LAiWAQRUxWNHd3dxdjkaybr2VslNjq7NlVT2j4cJ2ejho/Rk05YtfCzu1xat+Hdu" +
+	"91cvNxDspIbRFIVURFCyHQYewlUKLjAgdUHOqqFXQdDAGooOZKIyENwSUKq4sEFR" +
+	"yNRMUadp0PLpEZlE3GfqYaDKGQcHDf7nD8kmHDRh4fwWWYffjxw24caYWfk0mkeN" +
+	"D4SFGhHiVFbu2EkgtHFezxIqaWnaEdzJFsqSNEFKpZXphid250aNmnZo7ZMVlx7m" +
+	"zFVXDo03KvK3TTdqZZZ0j34LqeGyvh6K8ns4bdrequzHYrNt5jMmO7tq3Hk9GTU6" +
+	"GMOGnzTTgbO08zq5PJjdy74zObhx6M8nJu5Vc+Lbm9uVj1ezk3q17t3D0exwYMKB" +
+	"pTOURDWRGaXREECYuJhxzxhETUu8mXv9Vjp48d1lC0/f0WGgxkH1HjiPyUUeFBGO" +
+	"am8bm7o07t3Vu5lah4OzS3020qqBK4ICgQPb8h8fj69n+3hleET5+1Kk1maNSlav" +
+	"R9c8+++/Pnenwej1erxtb6HV2SCSSdrJHVYHikZUg1ZVkDtUEypDVQZTN8kDSwll" +
+	"keMwS78akNOMiJQQc3dihLlKj+oCG7aEM7oG4kZW1NVLsxIVjJxmQMVBiUTaWsgY" +
+	"DYxiQYyPuBXhdUKWrZb79D15ra7uMfLW1eW8dXOaiNhdxQslkuUzMFKgagC1Ehom" +
+	"iOOZC4AyO5qNxXMVogEhIpqSNRe4grNtR7emHctEhpNtsXLSm9xOTBmOSDYeNILY" +
+	"2DG2ibk3hUFnKtvTMXYBFsiI1xxoHjiBJg0ZhC2Vig602I1PKTNWvbUbYm/JAG0U" +
+	"aUsNNFafJHs1SpG5rY8UsGwe7VRhp+PJFmpjr15ahtvTFpqhuKWCg24WKj7kpybZ" +
+	"c6V5CsG96jMayx1GWUOgDVCIZKqhixI3lLuejpuwX0E8/UR6+vsvzdYqEqnmqYPr" +
+	"ynyiMGXW2W+XV42wNasYmujHR/B20ne7B8uftj52a23ykGf0r2Fya3xEEDcibiTQ" +
+	"0lZLgyC2ePfZkNiK8bqa+t/uN5kVHlxN3dckC7FJia9ve/Uugg2wm6UBkqXOGuys" +
+	"qBJmITKhYQIImk5o5EECZQKpHrRxXGOTi2LXQmqWh6LhdyTi01SqSQ3VOEDXmHyx" +
+	"eGS7oe6mzQZ5CDD00rOtqeKJjKBw+ee+cWoiUVDVLJ/FhK0iGh1VeKiES0TeYm9Y" +
+	"aEWwQmDQoQiRwvF1pOMzCkqwS5CmptDqzik403jShJgqi2UaBbWZmCIlgrKzuoHE" +
+	"I80UvVUMTR9bJIWy6iiIAxXukg2P4TDx8uds7uzmTTj2cu9+82j892bLO1fYjuV1" +
+	"nOX+0ET1+9s/q59/SSQJI/0pffnnpk32yWNNLZIyLEInER1S3+6lv+L1te04VnqI" +
+	"JI1eRIDos0ygqI/u84V/ySnvUfr5/o6avXhuP26/+dG413/yfDY/hOza/3m6353D" +
+	"FQf4gPLyckmNf0/Z+79v75+CaSQkY8In6aqSH03WX6Z0X9VQB/vFWq6C5csRuvBZ" +
+	"nX9ytV12MkIm7FR+DLJ9H6IBOuiLogQGQ/eRgyJJAx+aYLFFoFE+nXZEmdeEk51K" +
+	"K8zR4ejlk1Rjyd9OlGOU1IHRC4Twt1lj8fuDSl+toyn7KlPBdN9GfhbdlfyOpi2j" +
+	"7n1z3jf4hxzT5xvpenii/OQ9atPRJOV8YpWSsyBkCMSKpoqNVJ4qi6kbGS0oTp5U" +
+	"Ze+1/H5LYmU6Uu362dTHpJsyInEO5DvTRhC0noXDbUrY0aAqh/N252CZJLYxRLww" +
+	"eDIgJvhTpSsrEJ4SVDvd9S6BwlgfShNMd9KmGrWk3I52ZEqkIKJiiDZgpwVrTuGm" +
+	"0Uo/ZLXM3bFdFTPSQCOxHSpDGrWnDhd5Y05Lm5qtLILG02ERoixRXRkaboZjM9Fm" +
+	"XShtFC7OcoJwLVrbJ2vpmlco5wxxJm17X2pWtUowXbS88ViaVfl1mbDdKMZhHFFV" +
+	"CHEiCc2ed3C08Xm0T2nd6Uv1K0yITQlBsslUGWxQP4OXJVEfYPWUXA+kdcuh/+HP" +
+	"wWUH7diyuFPB1lyF6ZrDIprJE4SEZ7msK+k6P1h5hh3qskj4roZNzZTZjCbg2ePa" +
+	"UWtQoyUuGzm+j26e5Sjd6d8bPnh8J/3oPU17aMyljAcLyiBhr8j7ZOg/Q3IF/0Ta" +
+	"f6XwNY0RdbAzegLT47336Ne7qtUughSk2m77D7Kk/viknCAADCufnfnmfRa+PuZ8" +
+	"GbDsi+jRFrzw3ixPHSw07DIXufXiw4eHq9LyQfWZnFx+S0TQXRM1QT6QbNSZJj8m" +
+	"7UMbjp4V/ZPnp3lbJ4dvxkSfH+zJaG1+r41D+t7jCD0giVFEsaiSGe8yzuQcIPsg" +
+	"7JTIOFnT68Mlm/XtHO4/DVboellFEFwpf9tkkmQRHs6yXoRCkuKPxU4Z4SueGdIi" +
+	"CB3cE9RKuhrCdlwcyTChsiIXrJwrTvs9M61zkDIsOaTPnYckuRlvrVGxZx0zpzzt" +
+	"8L7s4WtdLbRACW2FaHvN2uU7i5n0qt00Kgy9iK7Jba3/3pNiLNMrM1XhIIBPZHET" +
+	"RypdGC5pZhk1rtje4i3zM6TWPeYQEE2ICad2RgNnBwoZOXY1T9NwigxKQAH9P9Hz" +
+	"7gx+I7Cg/gWYSkB3Ml8YRVoO+7qZcd04606nOv7+wkB9/5D9dwJKJD9w/pOUxtmf" +
+	"p+39YZxm/5BaSsnQxtYbRsXraiFwqdRNWIdK5L46DjXUSMMKSKJGX16puhl1MLFs" +
+	"NjnoaUBMXnCJ+Kus2EV8F1F0KGG54HeshTQt8laFCKcUvV0VSQaPOy1KydMvj2Ez" +
+	"AewDB4P7DzDchscafa/a6vq62dZRm3G2jIrBxhr3MevBrYhskfQQhIEa0BTQhzBU" +
+	"xFWQUuAIPIiFQc+2IfQGI/BwLEPA90bT/w9O6Hlgj+ABZZYIk4UKMgIv5BFETg9o" +
+	"QqCd/YV/CKsIEgWiK+Iqgr+QaKBHSWPIIpYAYOlqJTAzWgXcJAWQkSQfBkVzkTkt" +
+	"EBuCK4412dduYOlRLbTkd6BOG9mJ3lkOMIivftOjRKpUQ1n8N8AXRv85sESi9I3B" +
+	"wqNAL+SbEH87kA4Q0iLxfAXQzIiiJA+Dio0PfHBFET4KwoGEuhuF0X0+Od6iPDZB" +
+	"vqe2ZbNmwwwQNnblG4ZREfEADnQldENc+vyD2hPFPDVaTmO6ErcB2CSrJHawjBeT" +
+	"Lu1HHXecOXpfFifajXzf803to/li3IQraCMnXE7aNaF+UhNCJJ6bST1yCMSEkvrk" +
+	"EZsiJnq9YnIRyfoE3qs1+5g4qCjgAB/d3LXII3r+NecgG/A/EBhNc2cEhOijxJO0" +
+	"FJewHGBzK1YnNiLkAPBkUztU2GMpL0j31B6VEaAuiEtObw0ViA2Qo2CQrPgdgapv" +
+	"FCGKU5zwAX48rSmSGfCh0sBAp5Vw+mHYBmgyfBvQ2gE9Qiw2eCK950Urem/KrOD7" +
+	"tAApA2iLxtGRmFUGVZgNFMIQi7APICVtlUdVP5fqGLX9TEJBSYcWuJiEgyD+whr8" +
+	"Qt4j0BCvhFy3AUJAHpE2ATCfY/XP0YM68EHwJaHTWChL8gPdCT9IoJW04ShPtj4h" +
+	"rXUO1N+9eNBzh958PwJ3onum3eftLwTIIDagDw+o2Baej5qT77qlol7lfPlQODAr" +
+	"7Qiue8ErGKQIVtOQ+yuebQ9jz0QHR0XSF1f1oB0wm+nhBsV5Dgxx5TjC7ifRJgWQ" +
+	"JQKDKZ5QcF8aA+2FRB9siyFbQEtXEFsiyD1KeYp4vn1kdk65sBN3fx5t3nO/Y59A" +
+	"R189AT77u6pOAXgcINOFPg0rAnT4ODvDpDvB+Q6AjhNjrJ2a9VBRzOAGZ6eDgd4b" +
+	"NoM0UeBxPD5FreuGt6Dwo9RFdb8nAiAa2R1p49xif5Sm4cGGg5x+6ZreF2MUxiIK" +
+	"+gryR/PfnDI6Q9Gn57KlMJ5766E3pkiWtHqD0EedIKlAC3QaBfbl/j82SCLdu7yW" +
+	"v6Hmk/T9Y/qXglgiQ/aIREU3sfkhFsOhToBSbFaUQBrYeBo78wWrCIiT9D1wcVo4" +
+	"GjuBz3joxqZU7bQDFwmjB5e74MBLoK0PA4QkclbwijNF7qEEoFkFRROi0IZfN0sI" +
+	"zwihRtDz4T7ibJnxZdmKq4qOeIUAbh8KmERXb9nKQ+5QdzgDPcJjvxw6bZ3TBIWY" +
+	"SSeN4U3EZkhKxct8oIiTDi7lqOt3Kvi/tFCQEsImhN98ZBnWjLEBK6dw+FxgB1I+" +
+	"dDUAkMR8mm+NWReOPvBhDZjk4boMpjxoBGF5Lqkt7tL3kyTUNCK+PoZx3oUqB7h4" +
+	"5wEXO/lduTg4NfIqAh8ZfJSAcG/jGkuHA8qr7Ro13OwIJLia9u+yBZ0dicUAxwCA" +
+	"kEDreMjHsNGLghIQjFyrYc98oQaGSKediKrHfuebY7DkhSaKvv+X/oH7Ij+oKSLw" +
+	"2kgfoPv0+vpfWeMjRqQk6L7QtAATi0oNZJzgYxP1w4HgU8+oYPhFESAjAyvt302e" +
+	"CDaAWgGAh7Xub6oUY6dMeNnQh4yl+Nm1AA19panR4CYHnOGiidVdfdsdGvhv6Zx0" +
+	"jjJBqQawcqukBR4Ux34pXobqCIL3lHdgOad5nLqYjUZgE4QvtAltbhvPRFES+goc" +
+	"QfyAkiF/e4WiKYNUIFjKWJZA5fwJczRRibFGT6zCHofhgW8eydxvZ1UFHu97Toow" +
+	"8FguNJpiKoCc0GQAn4ceHt3K0i1feYVcihrJaNBCZJgh3FO6ENqkEW9eLD7vi6wf" +
+	"fT7OU2J7Zn4VPfXdnohaADg6HCzQSKlLKttUpsb9HGGYyM1kdbG3LRyKBaAlAEQi" +
+	"6K3SwEpXNuY3BAQX+wSMOhQK6JuJ9BbiQxBRmAuim0FUeeYULAUKioFQBh8aR3Mo" +
+	"71V1gxByA7oX2gGDQe8klFNQQNSjx5kWPD8XwbJrOHhrmPG1eVz2hyCeCzw70QRm" +
+	"PBaXfmHpq4d6Cj30CwL4FmzRhVE1Z3PXGd4oUT3RT2fXIk3Tn6hAxuw6R4ZKzAfB" +
+	"E2O4JIhAk0YDAlY3e4AHkEgAr74ycQwAnQW7rtlcpF6JZA7VNu66JrCcgjUCEFCE" +
+	"RpghIiGj2TWA7EMd0aiCjpcIQOLL43hkAKrIRD57bdINOGQ01LwiQc32iwDYCMaA" +
+	"kHwImA5vu3GtiupPVup02YPe4G+iICJJzomO2gryY5W3M5zx7DfU8YCDsEXiG6zV" +
+	"+xuOJIG8KOYoQjJHHsGD13J0uAvNmGVfCbv+KJrzyu7cZk07DszWZjii34Z5Oq4J" +
+	"YoGxovONSVdyqdDaiI5o1E9gZEO+MOknbKrd3vCGjWOSCrnI7Ux2qgrF1ozkJ12i" +
+	"qiB+Qq2iQl6eKyIKevnnG4vy6vIfKJt1EpCX9n+P6PQpAeBRKJQ1sOYCWlkXAgV6" +
+	"zM7YJl8sa21D2vb7geeO2SpmkzN+KTwlzt0iohA2AcDPLw1FWDBUJvFW9ggVk6Dx" +
+	"nW8ShTWwRlT1sHHJyMsXFDhNL6q7kI6WJJzpELbUQNVIhmsRVy0ajWqqiK9NrXLa" +
+	"rEhagikVJEOvbHSFh2axoim1j1bJkioWVpJnTIwotJdInhXvflf6SU/PPQX0bTPh" +
+	"CdsP29ywEL0SWUfTCD7EJL6ETkKMZq+XfvOV9/V1w3yP6vw8Bs00Num+z8M7mbcc" +
+	"Nyaf49zDIxUaQ2EvqlaeEBsxpWMXnJV3xw2Tk85CvjXKxcvj69eMUfMr8bW8bRbU" +
+	"onKyW5YZYTLbI2sO+23t750Nk8klcxbgYLeIcQe/QCQJFkWj+oMfqaThzaIrMI2P" +
+	"7OfFp/TvReP9gGjSGXxEeEVFAmDkEvv9VUZSkBPbMF8w/60D9GpeH1QCFw55QkLu" +
+	"z9IAXDqKnNMEC9ziBCmelf4wfDqr8bOBhgIc0RJII4qPuV5Nz9AAJ6ARU+oPi6hT" +
+	"+q8gwvYgoidW+M0fbI8rtLFtXO8iTUFlJvXeyFxmJtnkC7zuiaT8nGztzQSqBLOU" +
+	"ovW3gp+vzfBxm7PhlVblQM2bd+/Rh4dPRBvEDSXngueiAwyDAY7g52aB58+eG+XC" +
+	"rEW8lGS1QUeWOAT3cakjvwRHNevLrWRGxOBmTNeUHz5BNT4o+AkxZAgM8CgQuYt7" +
+	"U5ikqOco13h+zN5A3dAfUbWApJdeQtkMkEkG1iAUlofiG95daxu0Xul4UwF56lZ8" +
+	"3m8LyQBioWOMnxAZw8H19FHnTZSfCQ8UKukI6IKbgi2EROEVBFDkVQRmNCWiK5gK" +
+	"gjqIqofRAygkWCEQQOEBE3AUBUywFE+iCoPxHKo4qQYSR0uWSDgsC3LBC2FUgIbA" +
+	"gEIgr0IFBFEV2beEGgOV2VCEkasTeUI35YWoqjQQJBJsaVFsgnIIYIegAZiYinAC" +
+	"KCHIB8L9aSU2jqpgHDRm0jioEdaHayC8iYiN6RSgqyRLYbpYJZUhzsQdYEVBA3EU" +
+	"HoIwQQ3BFaiKBRPagNKp4YAbiYCICDIIOliTxeOOGnL2EcaOMNDMGJjKNGgchDj/" +
+	"BKwYSZqRlgLQR7nzcAWpLACURHNK7oqAsUjajiiYMTUESEVX6ICF+TFgwSIL3tKF" +
+	"+9aliQFdBBB/IK0AryCL37njuaj74l8yZNHN1lSjgfcTgmPsJRZVGcrSr8IEjldQ" +
+	"KtmKapHX0QlsIki0IuSRcABgN0Gs+4HbDqPIFBxJiVh3OSukGiQvd5nogLDQRteh" +
+	"2MyW2SI9oRhikH4T0jXdxNxJF2Xnskl3AVffHjA67x2y8y73Yo5mAE1DhsMmXJEc" +
+	"XQigaZcogCwOAJSmvkK59/AZt5r6CHoKYtZF6XRWBxO/0HFiG/lmwBS0IXvAvwXw" +
+	"uNK56cJCuiEUIhAnVsVC0oQ/LDomFtpZXfIu324pRnto5FdNUA7OBqemCvdxU76w" +
+	"rnterFGPG+6Q45tXnD6WRacT+nbNIk1JCPpi9vz6KPo0aWTYVCFR78pPNQgpwlQo" +
+	"7nZl96ldo0qhd6oAriD7PYX3YjYi6+KtyURx0Dh5o389ggNbU0B+KOiBJNO/YO34" +
+	"6a7wfKK5PBjVqgozX5yrvYe4b+g/eQESyAJYADkx6QeCQZ6hHDToVxoz61c19ymI" +
+	"QUB4ySSEGSTHhMs0Tr7Of7v5ZHrYzWRqmxy/D2PVnfrHr7nmk6vMiLt6Pfbbft76" +
+	"NqFfrnncwD0EdL8qWqmCRcAGdrsAgwQV6XyemW3csQRzF17hRM8sNaA5u41TovvJ" +
+	"lL6Jmj0Qdj3rXVUPYlIJEIbMcN6Qo+y6+Gy6V0pk2Gw6o2eXyfFnBOzAXCDYADzR" +
+	"CSnRaQYZ+hwQZ0h7sXXIQK0DQwbFchiJ7Akq/buuqEJT+FvwSPhCs1JX34emWkc1" +
+	"+0JlH7mgV6fdrze3n1BaU/HP0Ip6Az60FlmH0F+FDieRNSpsh3JnZieg899kMapx" +
+	"A2AgedvbfYhjt7fwdfgTf5O/lUCeRAZEpJHwvsvi+d3wMBEna+Z6+GGGgCoek/BW" +
+	"dQo/JYryYiLihedIULrmV2fAYIU15yOAfqwHuI8EwYI7aM8kO0X6aYygiiUvGaA5" +
+	"AqKrb3bLK3Bu/ws6awNQMldRV/OihvSGeGuLuQ5zhdKQyvBbunGHiqbSVBLCBBR3" +
+	"sJmkCunDAXHHd4eQxhEGRYdBzZu7UXXMiBb3M0jRVaMN1xw04qyJ8G6DCyAXnHwZ" +
+	"RDcJFX32jyXoosS3eitAOfuZFfqdLyQBCCB3aIfY2OMhjfbVA5gUvI4NI0ulOm0b" +
+	"1FDfrFHR10hZU+ODKMCViSStxuklLxyrOzBrvpkTD7nncH/YWN/xZ/cWB4MEWMjo" +
+	"uNq+pDjINyCJIMft7GzDNPmQMmfKO8C3BCupq3ah8aC+3PLydaANlYxbybhnNhxC" +
+	"RTyS5wfe8lJ5C60b3pGVdQBEF12XTIjMtk1B3sJLjW843JTV6tmmB3szzW8PCNWR" +
+	"3yd28o27CnITe6LTd1rriEPv+r+W/Lr2jtO7uzN3c4O+Tfc02jcUkrJR8QctADA0" +
+	"gXSiA676RwOkRHURdCHLXIqelq5LOSTVlo0mrcKsbgjhEjApzpaorkBLDgWikaMD" +
+	"WBmkEQLF3ZzJGd55Vbo6iJbSXTzOm0HEagBiaN6SrGSjgMe8kJ1BRvIDKb2rTVuv" +
+	"UjayCQnFgki2WkEJGRQCMRewEqK/x1GDBcgGSKNrCGtI59lyNKkdOrQ0UCJT/tYC" +
+	"QsXuKTErgmB/L7qWQAgjObGxtYRpoNAhObSe0Yb86I/8koc5eNsi+mHWzWtVmg20" +
+	"+QHoAlFmGJHkyHlQ13uGhptHj5jDJQi8LDIbkOBvKk72hX8sJ7ueW16GHGq4y9iI" +
+	"j3yMYtSIbDhrWwlmqZXVJRCqouUAUhKKoGCwqjpq43WTfM2qub+jk2T4GKHeyOVj" +
+	"tYdlk++2vs+/+x5NvlJOLPYmGRLWSHhDrPt8vLxjo69Xl+W2ESbJz6o+epO91qFW" +
+	"HfEcnfU/36UAcqgbZ7xi7DdKjmP6OdAd8+vBt/QtBnxhQ5Y55yjps21VoCjTyYLL" +
+	"1CSAQTQgB7K2FHCvBzdvNMXNbRQpcZKHabwUfuGc374PhwMYpCQXoDnJZi+6wEgi" +
+	"AiX71dMRdTfvYRIwt14Tk5HPrJ9sRIYwCUOkZlDd4TvtfPdgHxB1w21pzT08CJyh" +
+	"7Xc8oYd9ZaSpdBvqDRYUDhA4KO7b0HDw6Hwa7XttFLJvwUIDpRXAcDIRWHS+aUSz" +
+	"xocp5qowJUFyIVcKHx7WHevE5XHZxO+4peTzkklyu0YuiXbLEIJQUcsg9pabkI/h" +
+	"od3gISwZ4fwv1Xzc/OeFHgwtN7OIIX02fD0/FYKloiIWHTB7PYJwBsz1ERDlrZJE" +
+	"YDEhYassKO0HhjnoW2l4pHuKoFBPAi0IHcnEsMNIUlBMw4wqCkAz69wRdbCpCqYV" +
+	"IiZOnuCR9k4a5ZjWNKYUSxiFzpNQQUVwU0iIm9GbESmCr3RFQr1Uigjc4jisu4pJ" +
+	"puPoO5yOeZt1LgztDDSQtUkU+DXS9idDpAhOhoTBeU7AAikkj6CLUxCIImIIc+BM" +
+	"GVzqBtTlqMISI1Sc4AgyKiD4gcWAivyJqEowpHETkhIOIUiJAsq4g6inSDsxKRWg" +
+	"Yt+3owIGgQI7FgKRip6JhDOMYUVRT0TqgKJELhtSrt5BLVIqtKhEQLggZJ4QhiQR" +
+	"Gq0Cqrhtk6wQnTdrZdiQdLJbBMJNwoI5yOuHOpAbHCioJ0J6YhibSGY1HllCJmB4" +
+	"jcrMaFD0ewXkW4ejjFIZTGKo4JHcpSBBPtd0Qxs1vmR1w4jyA/Q8IHSlHwHq+Ee/" +
+	"WKYiGSG4HC6NiRUCLF32CGopcnwE7g8WC7D27ysTrEzHoRC9BQyGYAhkqhOQBwpF" +
+	"wUlY3keYQrRXorRFPA+GhTj5pDpAE7BLgAlbrkDpk7XdBkMCe7aC56ythMcLyB5M" +
+	"qB1IiizVK6jgSzmXFAgGIgqwIgA6EtEewNxEDMEKsvoUzTnlKA5iDnmtY0XrFdi7" +
+	"oO1avSIz4+XbDYhpYNbXls12lualldWW6Rmvp3XiSn4tr7H2DBIdge2UHx5TmHNI" +
+	"B0iD6NlFC9gO0A7Si+DLWvYUsE7DYKO6BRETeHLcg6SAFuaZ2hO+UAetihqZiOFA" +
+	"GI9nCa1gvgaJXoNNThLNEDOVQpTOKJxUxb7ouRUN5KMOSuV3bdQuokVEdMKFDQPm" +
+	"AmkMhmx1/f2bHBC8ijYJk50C6E0XqgwMJ6K9wOKaAATyGEoaSjjPogj2CyAOQRZk" +
+	"JxFQViYRM0i+Ei8gAZiihW1WUkg7JgoKGBijbIMenRopoooFjRhdB5EbkD0B3K05" +
+	"69Q6zqcbkOM1FpwnoGyJMqYsuqUojv8cZ1sKM4tO5+rCm9ZZJCE6fbttA7APREM1" +
+	"9CSIPRp816UCN9JJBPsHGQVvYZdivqFy+EDnwVAwp4cGED2KJDVUXA7yrAlwDiMK" +
+	"5xTOPCYrIplcSlucCUpqSpZoxggu32wzjnF2FlIidoAllPOFbJzD2SICWniGwEiA" +
+	"3QNDcV1ngXIKepNW41sRWLhvPSg1vwFIhjFd0VnVLBR9WMhksUIIoiX6b6aI6gwm" +
+	"eWGTazqFhRbYz6BwdaC+k9L6lESGVK0KgKYufORB0fYYzTnBemj4BH2gEaHaaIrv" +
+	"fxwDWvTnqdY6WgKUpgSoZrcEXkiQwPFhy9jFIQUORTJpUAFrhENwKQV1OLa5FQdh" +
+	"FEEkFVhFQCQVCRUlRhtibMFYg7DmjWQ0vBThVntDVh0KBEg8z0VFZ1dnlwvOxCyV" +
+	"yFg6KORRzKtb9eVaU6PsPpQ6vqCxMQymmlu1MoOofNGJrbSJqCnCG0ZkU3SmgEqj" +
+	"ljqxILxoC0NXXqMYPKZsTNGgseiQX1Um+tDnWCzEFM5KYaQwiK2hebBFtFvWbIKl" +
+	"A0gySQIKEVUFY1qkKQisEBDEYcpVOMqLjVHCwFV4coAKcGYVaniPIi0IDFCEO6py" +
+	"iK3Sb5QtwUTkeVRqSZvgtiPRiC9YmOGphARNmQ6kLF5Mm9RN5UknKirNlCkLBMDw" +
+	"LZGwouEWmYel0VvPJk0f9vqDgB1OMRmKZKIzWahOGd6NWRFAnCIXEL6B0Uc2fl5P" +
+	"sIeQC1FobsyuXXTiCpCs4yTW8WkdGVi02BNTSDmtnKPWeq9Y4twF4gEpDgiKRGKA" +
+	"rATvQoMREzE7FMRAK9ixd+aTuQoIDMYQZSoQTcKEAaDgwLsSRHUTmeBlwAjqJW12" +
+	"haMGnPdB7Rko8t7UYLQRAzDoHldEqn4zfIlR+ahTFDj40bkEs7N9ubb1r5Pkz4P7" +
+	"KmacMbzsQ60kjr28eWZT5fOlM3PVqKOMRxDR3mUfp54ZLqzcSJorg+9hoxMGzVzk" +
+	"E32DW2JtbU2qrPLpN5Xpxamjzu8wb1lW8jakUx6dIsLnCxQwpEzLzYbSCTWTEZrw" +
+	"p0sG2G5EvMnZyhFFF5tTkG1AZohFJveaYcvskKd5SozIJ5nClUEHKNtLZSLNdA29" +
+	"uDYo7sXxjC44bazLkkiHu8qrYzJnnJ2oQ08SqTZVlzXJN05fOLkVt9y4SAdhsUds" +
+	"ETItUioA4xSCJRd2ihTicgxYcOnBhN2OXCLbNOTBhkqTgh2g0U4XAdMYmaJDRnHR" +
+	"R4Lu3sBvFYojVUFkFCHnDpF0yh0wkgezuLUwW6maOnVNAne9DRbH+AAHETar2+Ft" +
+	"41Wuaum2jm5bd3WKQkCQUMg9FB/ynAQTMVeIB8oh6CKP0EAQxoFOUgEEvm7+N6n5" +
+	"WSrmuWdsdiR+nu8pv3szvUcbeXbM8Y2rYHrC4l+zyLjDfmIMYVsENPkK9m6v+lyT" +
+	"5D1f3aEZuONmS117lX6NWkjPZo21sYFwu55fns3WZHrU9bIXYmXLdyesJJhtZsyP" +
+	"8XuYeY2qPLzk8i2eMXprLlTUee8pZwCQX5F0LaW8MCu2YWI+FoVCAHBD2BOl9jQc" +
+	"oGoiISmkexUTRuFCkqlW4ITOGyomsKYHBjZrY5wncn7k8ejM3ET0XYlJU8VglCrh" +
+	"D1mEVbUgnLS6ENcMUAAwOwooznxlE7lPuAKOBPjKFlnYC6ADqLSrEfFWgZgi07lQ" +
+	"JqzHsmsUg1ZBbG7lW9a5qOWxHURNRDgomOIhVc+e4RuBqAVWjExp9ZXgMJ2l+KEV" +
+	"vOwwHQfplT6irimoKktr1mTvMn1AI6Nj8IOjnF6dHXSm3bQx3SNAEqFigcKwa6F/" +
+	"BubLQ9vcq85KsS6AydGpaE6qtgkARpz1BKuNSoGBOgBQ5A1kBa73YHOdtULNUiHq" +
+	"pDygDESZngsBXWfdQdUGGBnhtbsFzJEXO68eFC4N2M3gCnwhLjo2sgkKuQ/2GLWH" +
+	"g0I67776B8O/3enHovnD5QgD5SX19KJhml4fQjZ7+0Q5JZrA6YidgWYyY4jl8xSV" +
+	"sK0myHtg0AKidGTG7nAv1K6y5UVikEpJJeVcrzdb0hpFKVRzLlSn17KMaMkjCTLM" +
+	"QQ0FPTr0SQkXhEVoyWhvoQ9yPsIB3yDPeHXPwPw9rkIoDOGz49jxbEtALl682Rhs" +
+	"0JwxZeyKgGTMoB+YAhZz8Qa9iOMdcWRB55QGYQwryLwiXDkQLgYR9ATDOHVU8lId" +
+	"eOvOCO8PhtQKPJPaSS5gH9u2h8QPjqFhzWX1iUDkBGGRdQFORGvidcljOQQDzVBl" +
+	"TGG2UR07istKQkPDezFCw0PURkJVk1fFtUDEY3CtDUhqIFYmbk+TNC9bRLgC1B2Q" +
+	"hmoGNNdEXHTlVNGEVIJL1zKJJcvOiDo0nuITwMO7aogoMQulp1Uzxq+a5SU07uZm" +
+	"vE1CJnZZ70OyN16aWcbe7CfhB0W5dv9C6SR3sHAFMHzkGZVhljT9BtpAZFGb0IBh" +
+	"iANn4yVtUWWNjZlODZOyQgvvs4J4XQtR3HQo1zIKaCGoA3MHDeDBQRyGSIusq+Iu" +
+	"UOnPeNgBZsMVdUK/MA7M74eXN+cCMybrgKkJpI2AViGsH9t9NE2mTXEAH2u1lnrn" +
+	"3EhxUTGqz2uqtiqAhUVEQ7IFAI05ncwTfKHWxRzwOqtWiKznM7zWPbVzw4j5iIaD" +
+	"SHW84UBRM2Z3vmt3R7bnF9KAsRXK5MOIWdxy1IhO4yIpyYRjiTl6klPndDcCERED" +
+	"fIAlT9GeQO/FHYQ4IvbAcQGRxYyPYeZewWBoEX3dzOxpl0F2A6Xk4RptVObwVYvR" +
+	"JgUdJSoUBw0WAB93YAWGu4uiaiu2D0oQ6CQqYz2svjWxM5GLngT4hPu9PIny6IsR" +
+	"ZwrtKctQEYHDXdoRqg5oQ2uSsX4bCJ3NGGNxFpY9K9jfyTMPt60P9tHlUE941bvY" +
+	"0CWQSCsNUdyq41StOyY05v6ryYNfhWLruNAJjmG6yfUmfUshkQw5BAYqlskE4XZZ" +
+	"0rCcTJIRvQcxBsbodFNqdCpMhmSYhrWBxkg7XIf371jehCbUwexm4dGgVDsU5gmy" +
+	"ARYrMvjRHnRAjrEi0GYc5Y6OiwRdCNAUhDcJxjcBNIBhrUp2G6ndXbO7n1V1kivl" +
+	"8XxGjFDj0HsLjFztVYhL2gQARiRjzTgeTHDnuVV3Z6EWdEVx3o6ECjQ5rCJk6KO7" +
+	"JyyngW7FaBI8Q0m90Hkz6/HSOXw7wPcGEkM3MXsytQGxEqIOeR5s569+9oW4M1qt" +
+	"CS6KKEewSrVVQ9Z2x1nmgZsV5A2G0sh3RXUp64xy5NrrMXvw/jH9rrG9Vbajixah" +
+	"aXPO4PyEx5aentlmgg3UzPNcyQmn8jm7WpaxrIJeGcWmiyb2JVHMgUcgNYWQZ8qR" +
+	"l9nHMTRw3MikGYWca2t3QhhaYddzCOLk1SxmG3vec1U7jhzaLKrbNpl7cveuJ4GT" +
+	"VKmHNOGIKDJJCa1hZpVTd9ddzdqXynyK3LQF/1fvHvFwDEEAgG7s21nIU4+UAFqO" +
+	"BOzZXxvafGAJlsTLa0vUiRYNbsqb6jMCVwky24SylLvbtzhy4U047dzRIGiqxGqI" +
+	"kIjQID2qNEqudsyoALL7RxclL04W5tQJ5QDpK7RHXccMSIKzBREj6ROmSpdaVrt4" +
+	"adqfw1EQX0QzEHsCa660tktLxhOLIkn2OyUnq6l1++dxH9/n3L2c8+25+V4ffTlL" +
+	"WbIZ6mIoWFkymTGcEwjhh9wUdmPPecx/I04eIAX8Pfv3s8Jw7Rz+F57P356BfL1E" +
+	"2R485lDJBs/Jx45HbNb+1znkLrlQVg2n3Z3ePSJuR7bhMxd8mt5Ml7Cna2v47Av2" +
+	"ShobDchLus/dr8YRijOCfI/aoS1CEk62/SwaX0d+zqSS4TLcKBNHf3WDoO6NgvqD" +
+	"AcAR82hL32rdu4FRZaPc4BSzInYiK90PsiBLMdwBZzGeZDD4g5u3gUBylQUbarAR" +
+	"BUBIVnQqbgplEWh9veEZod7p4BlUkk5VEijGEoh0dAiX2FHNFOZcC5CaW4XLEDTI" +
+	"SgogmLJAKIqAY78+xmDgxem8eRwYA+e+7Gs7BLa59uFG8ZoVeVgy9USRkUkhykQ2" +
+	"gdhQBuNLAzEGQWz6uWiSqgkgPFhL1X2+0eYLcIcj3iZyxIJ5vmkDHss1UAY9Kwmu" +
+	"cUvi7vEKuyu0GwhCTA/yoyJyKgfHT7x1mgrpxkN4KkOQXU5C2Mg4GpNJatXYSKiD" +
+	"qMyBxJCb3pESGxB3ecBzpYGNW/OquelOkMMQhLMNvp2CszyQXClDLJFNasPABkrG" +
+	"Mqh3NC4P2iBrGm2BOkclnvhVhaRISz3tcWC4e3pxcma792AaxCl7oESlxfjoIKJ7" +
+	"a2FiDuAweHtnbwXS5c7GQzEPRFNwEFkCQFcwLhdUKEAz2x8RGVU4dMOHfKVIFIhm" +
+	"2iWtGuVMhENpjLWFciSZlotHBr+3aNL0JXa8XgqPAEd6EVpKnkMUG11O6XJWr5Yd" +
+	"e1Z9xlu5eR7mJ0wHvDupi0w9qHg0QgciAVh2IX6IXeOlrntOQTFZdBawzrREld3j" +
+	"PlFqXVGJkUYTNlohLiPDOszjjML0boQtWicWm1LQfEJgpwVZEwVAf1rpwKDiWeW2" +
+	"T44FofGx9X7FflnTv57B7RWfe+Ko/xh7BrfbW16MdhYNV5PvlOkBqBZnJhkCwWXb" +
+	"ALoENInGVVyEpJHrMH1FM5yhFxZi6xvmHQaSOdy8vvLlDQ0cip0Q10A0glmjphjg" +
+	"AtXhh5sC2DuE7wOi1ogHvNgoaKThOzB1lxriiGCeshTQvqL89HPQ+io6J1Omxss5" +
+	"Zv6kfi67wFWe2dNZFCyzJZwresuVNd9sV2RTnE5N7GjnjtGhDOLCGejhEM4VqEAY" +
+	"I4iKBkRFL4BZuzJlfc28UAYvBA0puE6ZecsRdO8V2w3M1t4YGKaBMQ9gzlCEQ22W" +
+	"BSqbwKaRdjkQHC4ixmWzxGIaJQxyRAxHr6FlXRHCtOM7Ur2KSG17m5xIKQuaUIjp" +
+	"KPU4oul3DGBPUe9XNE5SjJ7usYsvJroDQcDTaLFrKnCLS1aqHqo1vSGEySRhymq1" +
+	"0Ub2JdLjui5Cg0OgAyFwRzuTtrLIETnek84awMtCp9ESClI6GC70L6VcHG5I5VRM" +
+	"DxkDYaht0wnKaDRTpUruQQOhrJt5eU9zwnDZsQC8XLboLBCToaxiPIoixht299g1" +
+	"eAN4RdbBM3PFsKrg6ERTws9wPEE53AHu9HnSjwnUOBSNrBA70oCmilLYPe+DGDgh" +
+	"6AG94FT/EZfpoKj3EISVg8QpAngqM8vmA3SBJCvRSw6yhCJNdyVUolCjZPDeXsG9" +
+	"6bxkCEDL4kgQb0NHSghSvjbgTCRImOgQX9g5YQnK1JnCHQir06levMFKVYkHy0hY" +
+	"Iko0oj33Fl52C2vKsBIXYs0AwtC0BAVsqkEI2A51DCQ4czmzpfPFmm+b8ANnSoK6" +
+	"NuBO5JsE9wB54ZFkSd6awB68gOzx6BZkU0W41kPJp0tdlQoNWMl5ouXnVwAAOBQV" +
+	"QtmwACYSMN8JJSXDEpDDXCxMzIoc1vtUCyI83wsQowQmOdEQeu+6wUTUVTUZ6V0G" +
+	"BjiUxQLwwVYDEAdoXZoZo9PK2kLxhW04FenMCowg8QhwJC6ISvJoZdAMI4RxmXl9" +
+	"WGpq1m5QDogASIegEgDIpUXcDP6wOlBb2oB2J7FIYiZ3rGZXNIJf2atRcQbYVDkx" +
+	"Cz1D0GsdMvIO8NzFYSwtpbyZ1nGAWozaQYNERCAeNIRK/KCxiAvTnMSeKBcSoITt" +
+	"OIamG40xIsICd7QGYq7g5yMZSfYIBjSC8cIthVOmEmzl5cjRRQSFEKnIqSKUG2y0" +
+	"d4pDaUQkJ5CMiAKrdvrMLFEIFbQrfWW0hD7GB2FrFcwCpSROwIDjxYYPX3mjKzEA" +
+	"oiIESUYpR3ygcvabgvYb5JsUBDar6xA08yYdnJ3dmc8KkH6un9F+sESctLBFkQGm" +
+	"Ta0bPig+sM/K4rcNlicUhXGvkeO2yqSZ5oKmK7mzQnIIpTd6txohrPWxC+w7O7Xd" +
+	"9LQtO6uqZLhzsHZpRcxYOi1CFignFLhwDuxorIb1rsUMRBHkUkH9+wAqL2aiyPoA" +
+	"lLwUclJO0yK/pNNLRBkAgxgRJDowL+MDbn7aFmDs3Zum7TMmpl6eNnnKXjW+cIZL" +
+	"KTUDBhEK8ciqkQeV7o9nO+RdjYhyConjMQRTBWmeLu3GkKYbSDZ+NFythpRclB0u" +
+	"+MM9hIPy379/P5JvRp9K7Hh8rACxIThkR9bC/mjT79r7kMrZfL3DsQq9dPzd80jy" +
+	"omUQ0MGQccce3Fj7MWzP6VNxLUm/pBuxmmyioIE45y9suzCqg25nIpkvY49evNI1" +
+	"vdkD9EHHY32D6/Wt95wXiY14QGHv6Tupr4QlovqZsUxN/gppAOiLCJKKRQoB3Tq7" +
+	"wOD2KVRzt/RlCRyIOQHSOSr3uh4krxkmwT/BsrQ79YvUxmCBsaLPe3BE9rd44cRs" +
+	"EtHttA6UiBxgHNHMBs2t3WoqicOUCJ/pdOhWwXx0xzvjx3O0KVN84or1DOx3VbmY" +
+	"XBKjiLHHQ6cosigwdb8KKicNL3O90EPY3XkwoBs5FPf48Tw4m8Z4osEyHXmsb2fA" +
+	"Ok4HFRdQRcU7OGXaHlQhmiCfcEzj2hQNDNA6MRu4t68O2Z1CjKZpojvIZ6gSyZPH" +
+	"rL9rdnsgo9LEDXNXd1XbuepmStaOYiD4/r5zmElX0N6F0Tz3VCoRv4sIsFhYUIgI" +
+	"numbH4pN2G+IcL7ABCaNu1mNj6QkUIMAhtoR0MMPiEUwHvdwMF50hG8QYCTnhfkt" +
+	"UMX5FQVzDOdATVLQbTBOoetSGcCjNrjgN51GgITFdoNWnL64lJHbNklnJKcjAsED" +
+	"6LlEuu3zlPY6SEcibIy1pLUAd0IHMRZuIwhRlzAXsU1wRK4F5NYIkTsbgaGKAOrk" +
+	"3mDdrs9oHE5vbz3eO7IwqJxcJxDru7DPr5kZnfTpXLnLVEx7eQEex5Vc10EW/bNS" +
+	"/UN3fOWkQhgOwHG8e4Yi8HiGe47HhLNWwnMlMsrBHoa5VyAyXB8ny2xOvMcOHDgH" +
+	"b3EqkrzSChHUyZmLI+6hu7wISKUqFFKTFWDllLromzIiucDwBOQQ1kp6KGChwrGN" +
+	"IdiidKkg6IolNojcrO0BeJ7r7kxA8TUb1OsJ0DwXlDQCiVkWTKjwgEQoLqhDMXRo" +
+	"Qo9pGorE3XPYHlVcm/Fl0ZUNWuXAbPgxVowsObJtykwDZmd3Rs9kF7ovtgP9gQ+4" +
+	"ImoCUYDVbTqWeNIfHhQ3fcGSykKPKGvzG0gw0ZETg97odgi+CtWJvpYu2qwoTAIs" +
+	"E9R6CGlAcEl9tTTwETIhk6KNV2KAPhQLimtCFryG/Hiw3nYgO3u3TfEJHQuFVBHi" +
+	"QGsiLqgzs4bdm1MO8CUwBqvDVp0jQlTrbg64FHW97NcVIgioHQCAjzim4h2byc6c" +
+	"ANEWA7Wm3xWoYIRbEHeZqnzzDMAxmjmtCjoyJRko4E6qJSoabUiR5UHY4rwkhjGi" +
+	"57nGCJQGyYa6EIE1ZkbQuFKKxvM0KGlAUTD2PCxzTTr3sa2oAwP2Ie5M1JRb4eh8" +
+	"NazCTDn7w1nJjXI8EDCKsUADgQVYSIv0oS9b+UA6gPIs1SOiIhCIbAeri0sZgp2q" +
+	"Cjt1qVoBinB93WUFd3i+GNTr0BMoqCtDIo66aNKIkZtiCtBFYTxRAkbRGHW4E2Qa" +
+	"wGELRMBSlDORfaNHjJo8HetTIRdgB0R/fXAbO2dWJb6DfUEsipYiw5A0GnF8Ezhv" +
+	"GlTxeCaEA4SjJdyifLMm9GUIqQiABhBNrSrnBJZwcLnsUPG8AVmRARIaJRIAl2Aq" +
+	"vN8GsE1zgnAAG4OQm/dxkQHKoewTW3RsFeU7RIFDvSeKq6tmLIwK8gvYW2oipkRT" +
+	"wRjRc2uNOhMZYE5yw8o4PRldld0CRW1Do6zyeWGLAfbpCqPTGDSqcoJXE1eKBT20" +
+	"VES/Gir1g0EQCpg7m5ZtoK5GATGOZsXKcwCUdiYw78huOate6CDObwFxCKBgXHBB" +
+	"V6vNFaO1koc5AG7nTRtcl9SatzUT+2esG3qOOQchoqjI0MZiYEGiTyVZp67hPaez" +
+	"0Y0m6xKBzy6R5ZAO9vJiMqshjhrIky5HVSaeZ5qEyNVLWOJtWG+4jGMGDZuXubu+" +
+	"1BVxAySGWyePnaGc7uXgXUFUo7J3BHWdzfN0ndx97DRHhMuD3FIbtcmDu9FIUiHM" +
+	"wvJzV1rl7V3DAElvIjuzuAN5aVFegjAg8oRCh3gtOg4EUlSNQ+g+YCsNL0DFoWiB" +
+	"8GhSYOOE2b5zZHnFEUAwcmIWCMHBxMSoJhWMWrtE4EJmAmGLhxoTvSHCijrgpjFw" +
+	"YaJ00WnSJr+RmC5jFqtEbUiI3kQFaXgg7vKLYF/fBgwaV+EnRk9XQKQPOgkBdnA8" +
+	"kKDUtNQ28kWcA2LCiCujWK5nSsg+u2au4siUCIIuFgTFpAqiDAnZW7L63Tx5sg/t" +
+	"IR5eMo5HINaaOXDMrHyG8ytg+NvLtlHBkBo9kRnrKYt8/qyVqWjj5VEqVy3GpUqV" +
+	"hixKBqJGzkfhHgoFl/X1yrlEscB5vLEAKPAYyGQRirBKEZm6RZfA9cJGIMRHO5ca" +
+	"CEW/DnIynaC2XohJQkB3yhFrMFq3qxHJ4+QOtEUb2wG1dJBDDTr2sZrvJ4RcRMbT" +
+	"qH2Jdooaxt0NjDiScucKju2YzYaBBzvUkkz7Rs5QxX2gwjkdYD4UtQubOAigAFmX" +
+	"wNXZ4di59KNNkgtapzDO5Ze1RNDg3lGlzmLiBgSsl48e7xxrPEEVA8DigDOnCoWC" +
+	"NyRTfSavpnxLQ91Rqpqq7DJKoyD2FuCLkgrmASASJuqhEdivR0jzeV9CZNSuy7ox" +
+	"U34bo3ZBM43NBAmhDigDK71FQEKZjWNaenQQjAhUwtFmR3diUG9KvqSEILrtcrnK" +
+	"JYMYsRyZAMUMhxGC3SmHeUddC8aQDaajNAGHbXfMJnKQ3Io5u809jIeOAiCmGwEc" +
+	"SGxFf2Mh3Ck7Q8NmAQs8MQPGwLfoDFgfOCTl3U4o3sLxM3kkQktElpUOIQi8KGes" +
+	"JJoQV1lFdBdVKBU8i65cXjg3ziOG1RVyGUA5EA1Bz2PdlZvXiVd3sCFzpi7ZkuuA" +
+	"okzCH5e60sadzfeQCtFe9t3jHrFGwPRHJzHlWiIzEmgstR6IY+MDjh98XwynDQJ9" +
+	"BcV2odeecqlvFnFC/t9u3NHjnIqGa7bYikVnM+yf5vO/or7fvUJSIr379aG/2n64" +
+	"/p2BO0/o9sxrOt3vIpd9x5yvc+etFPveVHuePsUB3DIaidl4CxRx010k46whEN0I" +
+	"g9O0ug506JYDlFzQbuZEuMBAWvO6IBV8LQl756E4B76UHCsGLzEOHBSd+XvXk9WI" +
+	"YMbfg56ndwHELY0vRDPXRQ99d6bL5OdJIUUzbJDqWMfi11tQANmXKblIsgFamLRx" +
+	"GwxzOeJQdSQi75cWKugYgDTZ3sYwfDRyoBTFJzhNZdKia3kOBcotQFEQCbS2nCSC" +
+	"TtEiEuncq5ywL4jCuAjum3CYQzZnvAElVp2RRCOSGjCgOCgk5JdEY3YqtbGzSJKS" +
+	"UdKYzo16eoPENGLo0phETPJZ6OIkAK9m+kPCOQTXKwGmFeO3Qo9mYJjmt47wpZ4n" +
+	"OUCpkBXxs5+EADfPu0KwMIEgyIE6Rn15vJ9n2j32MTvEFNRG+O5FKG2lrAqyh+Tf" +
+	"Rzh4eWFJaDwsQTEaSEdaoYgZ1LlWfjUAeC8q2dWnJ0LQ8IrFg6vYcrdprGOfYLx4" +
+	"1uAB00NBrexzAOhxEV0hJgfdnNpAR2yetGXXTyUK7POeMFSwUcyK0k54TYZ3BFZc" +
+	"82vsHiaF0rspFEpTTqjrGMohOJwo131kTcrGNoxl7VJWqRTYNtAAJC7V+xyyGxzg" +
+	"D6IYN9WtIiQNBELyUK0RY7CBDsyDhV4eNdSOX7wMOkXgGQkRysCNmAEPpdYUaOma" +
+	"XGtvRVaKBTpnHMGXsHRzNvcHtrkV4qMS3LQYC7AFDRgeIQXw4+CQaigKJZLolFEe" +
+	"ynETG9VkDEWb3PCLQWZvtb1uyQ9OCb2ljqdYeYVQUVrlhSmZCCLoCzeq3qihdKlC" +
+	"FCVu9GdtanaDaeoee8Gh0XfV746AG0mFR3grOkNaEV4oAxcwugi+5mLavDgNyeab" +
+	"aPNUAdaRx6GueEE8UgBraaEPEBA90Hd0IoiYKzzLeyC+QP86S24oNGgPN7VEZLkc" +
+	"3KKB9yaO3suM7dsqIyXBAyaPJIVawzuyNy8Uis1TN6MwDW+Sc8Jp63uyww2NEo+W" +
+	"pXWbpGdzmc2qkqcY5CJNMqipmJnZ7lPXMBYk5A0CO8LEGgRCLCyFEGqDni6GFwh4" +
+	"ISrK96I0lzDiiuVYcpktYea5V0fSBQQ4HLSCYxVJEIpIEG1ivgPWGQ9zRCT5pzks" +
+	"lUdNyhMqyFLVbXZ+dbaAL5MolnGQ0f2Y0lbErTW9N9zvnf1PL7QhIQj5Qqg9+9Ze" +
+	"cP2k9FIfAnPPeCQEemCDu+PpovnNLGt2xn12fm+7k++eYUe5zI3I85qKYoJjmjnl" +
+	"nmGtQxhZ8OrjWLs29chu705lyXsj00pO0r01isVaNX6Hs8cRtAzPRBUpl8Xo2aUU" +
+	"RMFSH1bMAjgAzlpfCL5AHePjDzgQW5sEzApAHGDajlxaEJMRENKpBhNAm92ON0Jo" +
+	"cKOslyv1CmpWvaQTDp2e7sgwMWOxFETVedrRILOecthi4+kHbXO7UCGYShLGHMPL" +
+	"BFyJnklnbddyTMMgm68FBsVzHACN16/QBHAADr0hyZ57ivEsZjdscOB4MukOoq75" +
+	"3Sm6oznxvBWSoYDs0mM85hVF3AUJAQhIC+IAnAQ0nYeBojTtDDu9fb2ZgfOvvEtI" +
+	"Ir4U3SSAbviqYgJSp4BnTGwbatDG9A3mGF9hEO+hcZwvmsmKw4IUUYSm04b969eJ" +
+	"yhd9UFNe3iSa87znSZ8uMCA9unXVOthwgCtrI694ULz3RAeRPJ0dGGH4cQq8+E1k" +
+	"N2XKOIV8b7t0k3pInQ2SYhUaCSxLkRMIbumyj4sTVz8/OCjnFqV6iuYCrEQETZhg" +
+	"aTaO1M91eVU+0dN5lIKE0hY+6ZhdH8xPatSu9IGjiSBRxdlYhnVgx3DM3OmAAPUh" +
+	"oivOGZEA50UKDKlBGKmuKZHM7ZnaIrey9kZzbWmTBux5hLriaXv3sCjh3RSQN2Km" +
+	"seQirWUXffY2PUwR4ix73JkV2Xnrhe5wc7ATvBMNCGsQ9s1jt3XLtQAW0gIAsK7i" +
+	"GYMN4XZoBFGRARR6qCjNIi9RgC+TuutUGw5urUrW9IBs3WmZh5j0JAQtReBHKKCw" +
+	"Ao1BYPjdMlMyTuA3z3s5HrzxCD7DNUpI9NKK1QCbU3u6DYiKaA7sOUSYFvgSL2GV" +
+	"56raInCNge3z1vokDQ4oBA7DVZChDpWQ6HOcrY+5Qi5tmkDUUFPEQNwVKiIBqChg" +
+	"igm4JIiXEAJEBKiKBIihiUjIdguH3TxtEV8CLnCZZJXuZrns5yGzNcQqb5nRD8Kf" +
+	"Ejj1uLimHfFsXzlUZzvk7zxYPeGzkRdgYzYoe7Nc34mq1NfS0+Tpc572vBToIi+h" +
+	"NC8Ksk0wShGEgp3jOt0s2159erxfPx1eTb02DQXSuDB5AkTVTpTmMjNgcOdrKEzr" +
+	"tc4aYgDJqgdKhmhE3HZulPmAHB7632oFlcTlmCvKgosDR7ft7TOgZfTYJwR7AXuW" +
+	"/S8+gIFeKNjkv3u7oLzAyBFiIY4bJOh4OuYdqgOIWvESJAdRUwkRH0TBzeSHfdN6" +
+	"Bz4E9oSSCWPhUXvDkFmbZ2uSLokHIEKenMqeTFXgg3poKBEk9zF2SbQhJap4uGJJ" +
+	"FC6V1rXoCFhRw7YcnMjkezOEULe98ME6Ds0IYzERWbF33DHNcyL7qBnaeKKU8Wx9" +
+	"AYMaYwHMmO44OFPK1nebx24PdpQEPFOIOCGGRgnfbPFFecB7CSMybA7NNoCJdWkq" +
+	"A6uxgQHTSlzjN02jfYhsKEJKfK3grm8IX6/ZCr04RBTyJ2sbuCdybNeEICJ26MbJ" +
+	"jeDS6wgqPaR9ormfdmFDLWdBF0bbY2212EiKqJfXchQkdNNXrLktUifqXfCq84+8" +
+	"Z6VhYN5i5hktLGeDvDyUvWWAs27y4SHHMOtg0Rag4RHHJZJzJpVzqEypuBMu2xKI" +
+	"MQEgIgDMNB440aFxBiGgVIhdjaNkyK8RRKsepNlmwLGE3pI5dmBEqgxMdV0KaHO8" +
+	"HhyQ2xG2KGDGNoGzBt7biE+kQ6Bod7WXByC2xtI4zTaLsEoGd3XlmZdylWF1alnb" +
+	"M69mJMgnkxqru4Oogy+Ri7zgqVzMxct3GGZgXGSdkzJjhyAuE2PZ723DJwTyMnjh" +
+	"l3tHY5VDpUieCoJmSC8uhRWOsIvHrs3IcXRWXW5dAv7/778fUJpA9gUVtiDse9fX" +
+	"eLqjFjg9tC9YHmeTlFWicKAUpOimCqgEtGlSNGcpe3u66YHC5aNSJLww2kUhcBCo" +
+	"sQJBzkAYmK7l1EZTiK2JEzDnWILQWZzI5NHO5yHsQScKeLA3Y1UxANcWcBcAXTZC" +
+	"nG3WEshvETCEE/bPauJ2LcYYpkGUUtAj4AMoK/tv6dyS4In1VQtIbiS0kHqwagwE" +
+	"s2PM5itnuLiqWW680Rhkknpn2RxZA/NquFxL9qJ+MWTj/aqbZM1Eg28nmVVm5HKs" +
+	"lPLjlU2yZl+lLy2b+bKSNUYSElldBP7yb+gMMPeIR9GJowRgkgRoYVdqHQlwIDLQ" +
+	"aiI6H1XmnDYFAee304yulhRgMIl8rODvjPsYDh4FRB4lS0XTd85zYMBdO9uA1XQj" +
+	"EQiIrzFbmDjy+83gvNdxScSEU2bnSmgAjjhZ0eHKQtVyg3vI5fSCEKUQLGWCcN64" +
+	"SoBE1gka0aWw7IlYUoJeMdqQ5ytWEITjsqzKm8ZQESwE6E2CN4IIUSEnUYdM0vGl" +
+	"bHppfLXOIXBTSfWIgFSl6IChy+B0e4/JZIPYtHBc8xqqNyEaYZAWKNvfjpvJ6pXN" +
+	"iRCGxlbePrTJreU3HXYA2d8CBSRKa51BpHeF0vGi5yH3vMvA8hjcyHuijgTurUuj" +
+	"QcspGgZqbDJsCwLljxYqwh0UedgzggA1oQPI1qSzDKyyTLBusjazKdKbN8Mpiiht" +
+	"tahHCFFJFECD5lOaLBoYNnSA5Vo0uVRGun3s3jbMCD8MAOHpiyBtrvGjhr1I4Kam" +
+	"hC90hDDgrxsCgbMgmSDrjyPJSVi0W46roi+Blde3oaM85BCOMlkvxXOBKzLEV9tx" +
+	"jdKcCx5V102vHRvAEBovGic6QBeiErtETJWKgpIgxvYmMdZt+YQ8c1CsakICg2WZ" +
+	"YJ1wKg5NIYcsHI7TKYIG9UiK5Dh3nMiYQyjsFTApEA2cmsjhUIqrYHeoS28gi1UT" +
+	"O+eZXGRAHUG1Gwk33qXWInhbyo5dSTqBDuQtgRSK2UpGW9OB04oooTkj1I1XpEzE" +
+	"sEzSF8gCdoVyiYDkYCLfSn0SyX2hCQQsiaxSyGKpCEVn+T+7ACroi7X8aJopBWVZ" +
+	"ZWHIQaTx4SNUeLDFSxevebd+cHKoaR+Uldj4hZiyxAxiEJPs55pQEVzsqkE5E3EK" +
+	"C8Zrl12Z6ZyL3XJIIiYtC1Axc5KDSj612cHXeoDiFrcpuKKB6LCLGCsgEWAcjIYi" +
+	"7hqF7Haj4908uyiAKrcawQQ5bsgLte4FvgR3kPuHtlEgneUBi6RqG4DiDmJiBIgS" +
+	"VKzW6RQTsDZDRB7vFB/Npbn3thjxnOfz03l8o4iPr5vcTXayIrevu4elRUVaMYKB" +
+	"TVWh4hpU3OBfMUdpqaMvN5RfQRHEA5SRsCqgNvSaSWAjxg2Sce8tmpLwQTzaEJKY" +
+	"a7vw4DMq4BBwDCYqTySZ5Y4qUEBqrTyjRBdDSeJIR3x93G24dW0Fsfb52b53LqcB" +
+	"LxkrVu+jOgAOVeWKSAPYajZnWDo8DQrwVXMRLreCHM8HdKQ7MnILkIj3MoONh0TW" +
+	"CXGY8bOCBgAXDflHcvJbxkD4icpcbMiA0ObDPeZMm9qh4TsxeYSrNdsERNogpnNA" +
+	"iWcLBMk3AFNaaFs84CFDeDFXxodhl7a9MyVyMFFD0AIGiNGCvoSCLqpw0errcmtJ" +
+	"ZMaVMLAkEC6A0HNHB9bcXzSDliqUfebISAiIRkyhvuGM41wC0GZ9e14N0k1dvH2j" +
+	"IIzL0HDgOgo2Teq2QOrLViXLanCQRVQkcYimjkTcFagkgFwMQzjIhkESKoRYDARO" +
+	"OUM3MEMWezt6GgSuFhS2HQXOveJgcUGzsH1FZhnVaE8D1kRDjrF+riAwE0VbuVvu" +
+	"Wx0Vo0Ivo3snYbRflxgcfJwR3m0ICx85dsSDvT3cZ29Q4CWGBQLggyCKEiARitqr" +
+	"sNm0fTrW3Krxa102dakYpVhqwhVCrC2SGOlkRk1UlqBaSVYVJYN7ERi1FAbW+G3z" +
+	"51re5VjVbm5W5UlbmrUmM9t/6/T6vv9Po7vhq+xJDxqrZJCSN4A9ebXxyczXxmoN" +
+	"33VoVPS3BLDLLHbi5spPNZK0uCZvZgZzc23MBvtLdad1ruTZJGVJwaelJw113fR8" +
+	"rnExqR0PrSFjAyjjVUETBCGwkwwK3s287kNjE+yu0Hbm242i5VRLlk0STTSgxaFK" +
+	"RQ77zTcyWsiGy8yIrLiHHJjtG1A2Yw3W9UlzdFd2HcNCqkQgyani4Bu3NroVFnYL" +
+	"2HzDRFdvTmig2HcOnFxATrA0TnGma3YZz0ymbsQAYJGBFbqwZSEku3x21FBfCArF" +
+	"0wi6MyRrQQhzxXZCortLApgcocDruDxkuASSjkkCRHHVa1oVlDu7SymYTanF4+3W" +
+	"eROwxPvSBh9NNJ8ik1JAnwJivP2b/k6eXnnoQc+e3REtcmUhKCgg9oIgj3cO94cZ" +
+	"1/yZZPYXmLsEVzL9wyayYqdoLf7u7cMaiHlnOXVcjK1tFvlVLZVUn6CtS/Dc2MGy" +
+	"jQgfhC2Kdjr3P4oF82DpTA7dJI8fmoIQcC1skeRzKgLQfdKJKWsxDeDRAOkVD1Uj" +
+	"6REe5pkkFtcBVDyBmsYcJiDPKL4QYIAKg3pFBYsEheQysfqhKb7Z5Wjm10jpNiZp" +
+	"B5IyQBQMUV05k5WF025JblIlxOjYPTSQS14ht99a4g4RAIMEXBQ9VYdUOnAHboCb" +
+	"AM8xBqUidwUIqCaNuDndlLcheCQRzyDZsza6jpcC8J5t93uI52DOCUmxyBWG6xjU" +
+	"DfvcQN2R3loD2RQpUCyjb0Nnj8jM44gOI4HkYOhJNFBUaBwiiugHBtgmVWWcPJ2v" +
+	"AGlYg8pB1knDeEQyYzoFW+nZieSuAOXHdpQnYHIIvsnV62gW62oGOQSq0ZHQmkz6" +
+	"ve09eR6+As6PaDEAPBAjCRxHiizSKSWE3lI8fDOCDmGnmVpNbi8eUVoBcnjVYXJH" +
+	"Wy5Y+Ig8gsiDUDTA6xDbTXjDHGKyNg20+8AoKRpUzjVgeIneyymHNIhlOlRveBNb" +
+	"AyNu+YZy5q7JQKKSSPDgYkgOZ54N9vTDVhqc6UhuwvCADsV5z0KRpEITXj4+mgml" +
+	"oIZg4a71Zlm7m0gkdp4U3zAnK2iHrqjsxi8S8sDdGDo9ucdGhjq81Jfa1MiJSKcB" +
+	"A701FV6aw8Hp7V9EURNiZNADwG3dhrhp2xsMQdoNaPWpg17FE8O8dR1VHRzpUzs4" +
+	"oW8uITBTDYPLynlwZDIItG+CIpXe2AKuCI7Qs1rnC94AEyGbMuhIPF1HgmbONCmS" +
+	"5k7bSMjXhXQp1OCjmkAGTvLOmI0HOAt3YzBQRFgqFp2bepbOC2EIwJLOpBSCVEHI" +
+	"kdNxHOkAQs0VIpgJl4XMHMjEgid0t3FO8MJhYYXY8sERIghdxq3vQKeC72BkdCeG" +
+	"xRxAiGkDGK5LYsCK3AWW+AM5VQaWqrkJ3NiK8HR0Oyaird7M0013PrNY4oA67ZPe" +
+	"zuDTrV0oZMsRpR7ZipzQ1jzg4Ut53oN2DS2qHRF3Qms17VFoJ5zQGLHnTQ1WhcBQ" +
+	"uEUTQhQjEQUHI85hT5R2UYC3twsue/zOINAzYK9Mg24cwzR4rXfuB43f5g0wg+ma" +
+	"n54RRErdutOia0EPZPBoCriZ3WIjYiAiY9ycBy8PvV0fdNCtr1kSkUTFpWjZQ33A" +
+	"Gh0a7ep6g4nkWoASDIDjZq/BgHfve9jgEEhzWCeQR7Hli6A20uwCorkhnm7lK6hw" +
+	"1GyiXCVzPlIK80MpCjwRAoagLZOVxmZA+eBSGhCIL9tBXabrpw47c5zKNaAKO4sL" +
+	"7KvUaVGgeYA4XSjsTXG+b3fBFtoGLhoKvIHohI5zzHSwDMUyPCJ8Zjolsa6FJ1An" +
+	"5EizYQKcpor6HHhk6GdulzXbHMekayul6RlzuOIXQHGhtCOsOrdgh5yBUI4QD6cJ" +
+	"CNmU1QYJoXJADgxaZvbMMEEkHSPshs7OGaJOF613Nd0CBj2PIi+PXV5W90bvAECz" +
+	"SV7CKiJiGUeZErQbfUGQNmjhny5vomzEBFviHjwiiJ0o1E52tFzGaXbdCZ4hwwYE" +
+	"QPQQkQZFRB5oqVQlVfs5E1NSQq6LJmIhqJUJBkSTmKRwxxBG4hmGYgYhOlbgcIM3" +
+	"Qhnd3c1BbjEYvIhbZzEQRGBE2cgI5W4RhHpgCsRsjcdWFMN0olQDA5nd4AckRPbG" +
+	"2+i25y8WqkxW8Wupq+jB2ymQckBbjqGGJ2AtMuBuG4BrSNp5MsuWwgXbcCXcIAxo" +
+	"J5BTSW05do8jzcwVXNZNxgxuimapGRGRMeE3YqpoRFQVEB1gVMQgYxo7G7bmRDES" +
+	"u71hcZac1QBCRIHe0LZAbAbHxDwuLIhFlGQ311uRlODv9YkCQRH+Eh/r6Q/7bT83" +
+	"9x/Fr+4/N+xjJ/ef+if6dubx/+uT/af5yl/qO7x5v6rVWuWZlZjM5eZ/VustitjY" +
+	"3HC0dHExsx/qOenTOnMdJLi6X+gqTDD7MX/BpCpmFwf/C6fg79fommh7CkD5icKI" +
+	"rVSTX/Uh8fGFGKs+lPgrQH+bz8pu235HwdPyPCs0aP60bPSYwmirZ/oP34xfQ1wP" +
+	"pnDAX5KPS23/G6nZ/TKCJiCNS5oIRTN0GCKEmhG9kYgIrr/UH+fx/tEuBL+6UPJP" +
+	"b3bTrJphJ0Vu8PmOnIeyvm4J8dKtpVV7Nxk1Ldm7r2f9z6VbD/lVr/jIa0/ZP2/6" +
+	"fsPJ4euM7/l/w/Hbe2qPmk4Gye8+XFXSsxt8HE/hOObeMcPpNPb7slXdTm6OZ/v/" +
+	"5dVzU58rFtJ4e3yv9l6buQsjiD1R2Np9hTyeTt6+038W47SRy6PY06E+P3JOgWaQ" +
+	"hHAkkR/Xh/2ncXif2afyf4Svf5NvY3/UP3JXCqfaxkZRL/J3CPDzFxNGAzKcQTnd" +
+	"cHPayzzbvLxDd1UnVvMbTw9BywcPDfsc2zm/nyMfDmf932T7p87KrxgyeFftQ+tf" +
+	"Cfh7HZyeE2aj8Ld3bXw43xb83/u3I6WSftIeD/xbZE/8bwT5H1OjB9vDc2fr8Q+u" +
+	"397X9Gf+PSdnVOzpP8PP+c7z52c3SP5Gtkn9kn/w7H1cp+5o+HrPZPv7uTykTn4t" +
+	"qMW5ktlnN5X7r3/GJDMMmGVMJN7siu/yfnqffmvSXMu6ft6bOJlTaKqp/L3k/g2n" +
+	"c/7fv5SH4e7wSNdHTnGSe7brKd9m2+rfs+75c1sWpbaXqOkkpTo6LvZVDoKaaPJd" +
+	"rf6/wabfy//P+Ses/dNe1Wv4P05eaf0Xg/vluP7Okm/5eu4+LJMnvJ6vyfdiuNK0" +
+	"Wbn2ZOW7k/O5dVV1S0twqcn6SMKzp/2y3c5D8U7EssiWcxtqybtlfi2p2J1xcn7G" +
+	"nI/NwcrP+tfj8/scv7QZ8v3tjkfXsw7Hk28PhyNkcPY3e7To4dLZXs52SnOcp+0v" +
+	"BzIaa0rMZV/r4j+X7dHd5OqeK/l2Ng6ZCf3R4MsiMaozClqv621/Cfwfp/G2c4GO" +
+	"dLV9XSfLMq1YzWaxrDFXxLOJ3YfCa+Wpzeb8XWTm+JzP+IICf93/kNaqLaNrWSqi" +
+	"ttajRqjbapmqtpS2qxVk1bUlWpNqLRWpZqtJNKo1U0ttRsy20zVJqrG2wBY1sVoL" +
+	"FUWJs1ikLFTK0am2RVFYUrYNFpNtTCoNYjWpaFbG0TKLTDY1RrJSWwCVU1K0mkrG" +
+	"yUpUbZDVikMW0bZkYotZMmZGLRsY0KIViLGjRsUWxtRUzFiTQaisJEzIaWTNYIjU" +
+	"RhTZsyUWxsUUlY2oyRsm1G1k1MhLM2Q2gWRRMpDGE0zA0ktFBaZGyBETCCMgSEaj" +
+	"EWjaJKU2NqZFooxiokSIyMMUIWEaiMhQoIiiqQmIYEkRhFpEhYqSGCLFCKEMEEGT" +
+	"9mvzf2fuM6SFZC4Qd9fugRia8BBCIvlh/UPmUoYBieRgSMiPA/zM5kG80OwWXxVB" +
+	"kDKCgX+vVRm/7UQIDInnOZ/vuDq/4D8+p51Kq1Jw/kWTzvI4d9a7SyLfWstuvCsR" +
+	"8vO+Ve9WpNJv7s7+fuL8JV+dboUuDPzER7chJZ58smGb6bfHJ+/wytuIdr6d7a47" +
+	"bq+tvU9ubKTxSujpWpbkOGArKSYHFiSSfHgG2RPcG5lSlkRGbrdlTVFVeA1pC41W" +
+	"V8XE0QYWbMrorO7DWTBoBRpgyaqKdSFItuzQ+QpmRRpSUkgkAkgVhutQk5vCYVVC" +
+	"2pCBtTYcnZA1HRmQ5KEKUJCjE441UykKrp04rW12EaksMjEqCmiOKKAiIoVAjHHG" +
+	"4Oy2vMLFphr2skmltbAj2yHto+/C1qRSHQI0oYJy4xPAK0hBhkBkzKGIDKfqR5fu" +
+	"9Rb6jriPwFfrT57/BORRUS2uxaWe/23vw/VDRJUNDKbcoql9hR1STaoUKFJAhAE0" +
+	"AZZLjCTR5qxIgYLhyUQktqwQ0LakMUoDZaYvf1dL7/UTZGZSt/h0bF8bOrkShINm" +
+	"UC5JVQoULQdWFmExZOwxx6b/nrJEIzcATXe9RX4uAjQuZbT7+8dvCcTe970nE51j" +
+	"cmac2WktrRIBr8KKqmFiShChQWsTPnID4M0CSyZe7rltE0/bIvrM+YcPthAH85JJ" +
+	"219mY5mjPQZhiZDYZA1DzBlAjUcjXvLL8BABMGVQh/A/vPwUfqX/5kl6UGGJn8FC" +
+	"P2GG+QceVRTNvxzts75paBK7NzM7TzVVUzlIqqif8NJKRImR08cg2cHrQWxKYcNh" +
+	"OjnHzz+YPyaL9PWNrPR37fFaHr23fpcy+YYGWlsuQf4q7bXFjzjZ66t5DEnZsqLU" +
+	"ixYlKiy0ibZsjalZamaizKs1laSpmk2ratltZbWSta0bazUrFJs0ttalazaQUhKg" +
+	"lSUAqyQoWSKtotVYtSmoyW220arUsoo1tpLaNtMsmtaaYsVTbS2UtJgram22rCkS" +
+	"qQSxISyQS0FSSyM1KaS2laa0lhNFGhYWigRULZFiyykqoCxFBKRFSItCrIUWLKak" +
+	"ppY2WbY2tps1pm2ymqbabbLNiZojaZkrFMKZrKzaWVptZtppijZNM2SzKmmxsRab" +
+	"LZs2K1NVqWqEzMlJtmqVRjVNZWllSVLM0LNNZpalZokSlltLasJRUqopUpZIElIE" +
+	"lkqrYjVi0aSNqWmLKpslJtFRBbSbbMy1KoplRspaNlNUrNUaaak2mpVFTZVGxk2a" +
+	"GTSWmzaCpKbNJW2WqWqKMmNk1GkKUtk2ysrLNs2WwyrMqKpqZmmmKxtmqayKZlUk" +
+	"qNltKlRSm2StUtbLWxTNUqlspo1ZtltNKRIqGm0tlRtNmmalNGZYybMozNNKkxpI" +
+	"2i2ULJqUrGyyxJslNGpZmtNSsrNWZY222yttmrVNTbWZZMms2lllbKstpmrNMUmp" +
+	"KqUtptKyaplKbRSbJbLNplZtqM1KKbabU1ZSUAmUaxpZjUkhUmyZmxbRSltNsrMq" +
+	"qVbNtslSptEzVrMqaazNpmkqZsxExpJSk1itlWqay1KppYopMUkkkmbLNlMymsxS" +
+	"0TKlNjKbA1TLLLU0lTWalTNMilKmys2ZY2mqViUVKSyksmapVNqSJRqxZSyylMlS" +
+	"yLFSWRUliWKLJPR487tzxPbvpf6y887/zT6h9UmfSx2PLPXLE2t67TNb+d8616jt" +
+	"tPkeNmjOnd2bULjnN/5x19I3dES+7KaAHB8sg9OaIHogcFmowcPkd56v4UKiqJhg" +
+	"oAU9AHxYiJSboAuO2tYkauzYowUsXVGVlc0nYOpihEKtGCELstXcQR40ZwxcKms+" +
+	"7pFjCoGnlWDFSsNDI2M37zbDfLv3avdlnZZ+BC52UzTjZKLth+XpejoaOcVlvLIp" +
+	"Bt0bICZGx12W3MemDI+BEABpXP87P4rJiq/on3ucmKl3H2qkVoDOXeBVIHThRlRW" +
+	"oIeneSsFb5P81QBgJOLBARAX3nH8/r/f8w3ilqIGYIs2ETpWjUrVBz3ap+abPKWH" +
+	"pLM3ltPx/+N/Wbt1NbzHN6yn49NkVXLjHsi0YsxWYxt0mpP5liJ0D/BK861JPxVJ" +
+	"KrrKd1DEsjkf2fd+E1sqc+0G02nKaZP3/wWYV/JKhVSKU/9f2kP+Es6z7k/gUksW" +
+	"JYe1an/921pBsrUdXyfSH+6h3N4k/jE5ItS1VTkajSXnZgf5UtgpKk2jaxZibyd4" +
+	"83LeR6x6+RPw/T0lWWVLOy4k54wllqVWtTTUvHd5G6VXZwcLVpZCyOySqT/VUqI2" +
+	"a3OjB+BJ/c5vJ17xaYezrA2WTu8JipWJ34en5WSThOGGFkqslgxWw1Riyit2TjUk" +
+	"4m2SJs+3WFSYNQcR9lN+j4j1noP93VyHCfI7cNMSZzH2ZNRThulseIk/yU5KdXt9" +
+	"v7zmbk+gjtO690cSQSoFfmmeBxfI+vqGsirzNH5C+xTw2WGGHE0X+u176U0uLoPT" +
+	"OEn+qsbDvaA4s+lX8EqpJzPrH0sloeXR1c9OiqmXer0zgSe5ZrT6ScTDZPxHCbPN" +
+	"0R5uo6u07SaTyP+1LS2qfontI4sTqU/nOnq3gQE3PlZlmWZRJYUsqyJ2P6PJ+L5/" +
+	"D8Jssqnh8+u+2ca0nxwRAJ32knCcvhmYySY8DlHwPRZOyxVSqrmc5yn+vVN35FkO" +
+	"yvNZM/ORPMmjIkxNtLVRf1qQ3ksieqJL38h25PbeROj0cV6GFHWIPN2qxXorv7Oc" +
+	"ifauTZXzYwjFM+LPNWr/a58p5xuD9uXn6b8HdXj7TiR9vZIw7HVkmGI8569eqqvk" +
+	"P0vhi5cxU9euWvzV52lG6lLCSmYWK8coeiN0jxImMiT1bT9FffylTz7SRs5vwq1O" +
+	"E1BPxdk4PSI/RJu9WoSzsTH6v0nJ8nrzi+ITko3SqSvxOJ2nukqKkpNLHec/hfS3" +
+	"JEnzWJ39PoktklpWMyyPh/0Tc9E9Kdo5IemeY1NR+smI8T/dPNYrc5nXv9t9sHUa" +
+	"mQsqCq1PemmmTVTeR5UqqSopSlKWFOYaL87JVmxycMd8wy5fM2Yw/RXl8vbb5SVb" +
+	"u3zORyjjG3DhlMKM111l6sSk+BAMLpSjqdn8I5U+moXwXX5p0Z+Ev8Zh48/wLRnq" +
+	"sVOvKupu7tEKFfaNwYH8/Ci1xHTYAbREOEoEoBMbtSSnI7QnHvPpNvIrSaUlVwno" +
+	"cA2T6JPxOc9Hjj805OqKqKTKMtvz7PuSa/Ze7Y4TXj0keaMVJIBO6TUtNbu22/rK" +
+	"Ik20pV+zX62sR+LTYvA/nP8S/x/z/y/t/m/n/s/ozh/TTT0zNN8l832eeZrP1ft7" +
+	"l855ZP0+7P2fht+Mct5xlvGpyPw3YySSq45XU1bSyrab5ycrjjicbfT6o/FPun2h" +
+	"kqLVQZw1OrdGyq/AmFG8iUYmGjHDOy2YstLLBnKVZJvoZpv/dskjgWfX0jmmn+XT" +
+	"9EpEKhcAUlB/eYz+SbNu4qNSSEC7hItGyfhotsOAf9SwdHA8hOJqR/DyaGA0EVqI" +
+	"SKD6AWMbIK+iFwiWZNpCAwgFlSy1TRu/m2NnOmMXFK6UuExRVkRZMoar/6uXRP9P" +
+	"7ZP87LZwYx0FWaYU5vlVTqmnh1eev7szJOiq4leaII1cL9t51vM2+LzXlfVqKWyp" +
+	"WvCVPQwScjU2St+kOba054lwkpIqTJm2mrtWuoYNioqjXh9ZCcg4fauRyifOQnf6" +
+	"SGRSfxqdVrKlWU2qUzZplGsprUmLRsRajVG1FqI0mwhqNsVY0VqNYxgASIkzAhPb" +
+	"KKjCrJLVvcYYOJOH+vt9D6MOVhCbzFWO4yRsEfXvzBp0P+0m6q/l61TUNMPwDbP4" +
+	"A4ZborpXA29kUhELXpos8r3drnud3G50Si5VJtefj+9ZVvVRlXCz1Xg6KThMk4mm" +
+	"/BxViVUbKrUw0nSUxVm8OjGchs/DpN495AGe5+K5OvXzvbUNNMVStZlSc5ucwd3W" +
+	"l4u1dm3WlJobdG41bAbKyodIBU0lRgRgW0aw1kwVrIutSyFWNio1Fc3UKqqpRju5" +
+	"Aadp5fl5udRTjI1JPdwpAh5+pEn8lE/gwPC4SP7yQ/wfmhzK6WLcLLBfzaejXg5N" +
+	"ROtJbDGTLY1NWSMQ3kPP8tNlbsFLO0khJHEnOD8iIBLHY5E5Vaioqq6mHOzViRnO" +
+	"TJDV5noj3lYCpbB/UKCPiSPRFBjGEsHZXWOmMUqqoqjVmVmoGFKNXF5UqRqditja" +
+	"VqjRtTTJJCSNK2SIBLIlcoL93JoaGmSYppju7taVJZUVshVKnwaD0EH7hMmp/h+o" +
+	"Pbiejj/LCXLxi+sY57t+Gq/cILqWSklksgVasVYdKi3aLGlcq4fh/b/0JI17/hz9" +
+	"I5p2kpb6oqMezcw1GWkqUylkKqYsxkpUqrKj6ahmlf3ytR/QMwpaUHB8iNiv9K/z" +
+	"0K6HAP93CkfDPEO0tLILS0pZtCxDEo+smm6SnpFqPN8mB8k84m6eFkLPr2/b9vvq" +
+	"30sMxTJbKbV41vETNRjrYhAm0Kmypb2ozMJGlqo0oyt7s1+ZqRGE5GDhx9HdIoQm" +
+	"hH5pdOT8GMwPVn9cd2LOKocJYqpE2fJibmxMRhVjdipjJLKxv8lUwhE3F+9vM/Z+" +
+	"96zDku8juRY8ZkygVpQhCSGE5vWjeiSSO8ZFx43qYwI0q4xeFMojCEBoYwhDwpBe" +
+	"iHCkNkSihsIJhUNuES4aChQwWFNLDYrSqqVumBhK0xiN2qw02aBvWoQRkbNJJAkj" +
+	"HBk/f0jBi0Qj3trasZSWJAABGGhpyETY2mx2GGObpTObWrb351Vt6QURN7vvOMuZ" +
+	"MryvV8esvd69S9JGxrTRiEw0k5hoCqjCFy3INRaqNJwakaGEikSrNSYRWTRj019T" +
+	"4CORqY4ubfHfS36+r2c6tibQpT7uqxK5TMRXftJ83l0OEKb1aVXy8jZKtwphii1E" +
+	"32XPN122+997zbb3qg2rFWEspycmx5fi63iHJ04NMLBsItv9IBqEOmT9g+SGvcbp" +
+	"+/hdEfGRojRGhaIFKIYxkBlxKkgcNtjbaQ3UpIqYgYoKWc8GtGtpwV4rXQ74tWyW" +
+	"WrSqxFk4NRFSeaScu5yP8VExZEm6XE4chWxqNGXXVJkYnR2cdHk8WdGYy2vCmNjq" +
+	"ybrMN1FOOcToskqqI6hQJYpkEaNCNn6FTLldFQjIRVoB+utwbXmdbmWEDBprGCfA" +
+	"JCZRpKqRYfq2e+7Cq5cNSfueE8nT0BAAmYe3/Q5/hbbwssFCXp+OE9EkGFrg00fG" +
+	"yXabHiy3EqpTo/Z9bfo+ZtPrQAuNWcI9+eSwSa/nYd7oXFadmUYi1ukq/ac5AAQE" +
+	"7du1t6q7K4YbOHkbtuq8NNGMZw/VibN2MKnJyZJzVzbk8nnizzY8nI5Pu2KrwXrL" +
+	"dm6nQ57aXMY8TsVyIDC5bX0WfDw+jTpp6QuEj7W1TMvq8Zyu9vdXFD+nVQXfaj5R" +
+	"BRz2fkfnvWnhDIyYKVitWiZZUs64DB3WmYY2xUAXs0Cakm2Wq5otBR1e9IE4xR6I" +
+	"UQ1xETvEmN8IlSLEh0Um6u2FSoE1m8LDpW1Hm4TFaGovlKmdEOVumVxam7bCipxu" +
+	"T6y5i4+SRHYrzydyzSvjm0vMKixJqmXoTSKKjLRTRkxS7yrSDPFa3nQXLkJi0PGz" +
+	"Ue3b6kGdih7KjMMNAjQzQTDB/OKQ8KFuO0yGQmIsJJJLKKGQAQmMosKAsZY1R0kL" +
+	"PhQaaKZWN45u7TtPs7uvVu7uqsd2mxpMjs4adWm7k2YxhWGOTRjkw3YppSco2dSD" +
+	"nDT6F8LNCzhHRwSHThhZCw/JCkWC0Z4GlllmHQk0JGWItJaemBYmSUfC/CzGtdOZ" +
+	"glpafCCzTTeNljGYrTsbK77srM0abuHRsdXENonRVgs/PvuqzvZPJURUwfRVTFTL" +
+	"HP5c+u4dT7LGDtNFEMwhcRariKthqTD1vPM95zBVA62rlBLfaioIouD1obsxmY4/" +
+	"SLbB1fe/WE5wvNs4XW/dM+pCuTReSLHk06DGF0WkGUHXGlrLY4aDxn3fHt8HuzrJ" +
+	"2+aMDPlI78q6bHxj5uF2TCFwbZMGRZ9YDJhIWy5Kgdxy7a9+tDiflePrabvyHDj9" +
+	"YiBjKMXYZIRdTNJHAOT6taIRRhwL6k4WH8MdqdOHDZ5XET0kKmF2Bk/gCivPTwLD" +
+	"D6OnV3Btj6vA6NAoRYdIDZ/GwT5X5/HRth0F6JgMp8aAo/b8aP0dVD3bWzoGD9jA" +
+	"IdGjWJpqFEIwOEjh+nBfY8Pv9ThAfIA+v1W1zDh98+IKpRNs2Kmxah79W223bEUj" +
+	"8FgfYebzbUyGl4S8AJvIixBOhDSmA2GYKhWeUS6ADRDvpmoClc1nZxo2BcF8lMAq" +
+	"GbIksqALJKpZprIel0G/UM0/NROWO2EHdl8baxjfvVc1Dz9VKlRqHhPwoX/hRooL" +
+	"hYtcLETvFJPN1IgE2b15FDZI8kftKHm25vocSMiWe502fv/5wLI7POSTnpHiVNkn" +
+	"KN0f5ylSllDaC8/EnNMn8bMOXdHDBEkioNT/Kpjl5T/FSNstpVTGKjCyZJilljk0" +
+	"WCJtTbKttU1vQ16RREbZJVRVnrJY8VbpfQ4jCfGExUvOtzOch1jTc+c6fhbzdJ+T" +
+	"ZjocHhp7tOTg0hqFHEdpzHf3mFU3tGUGnq9aOgRXwlMPc4oqofnnzkevPke8ocXV" +
+	"cWn5KA/wBIoOBRh4tKPhq0owg6MZB0JF0/BAeEjICzw6dNpJCSLZwqAGV7MVmZlz" +
+	"FW3GuSbWrY1tbz6cEBX5/031t5Xq26tD0eeTKPanZz5maen48Hmfm+rh8R/tsevt" +
+	"95vOVW8muQ0/dwn6qkVSPxsTydUx6UtRVtlfoqMjse8kMZUj0SSye7/KVZXR81mz" +
+	"STUJXk04fITUm7Y+EeH1SIBLCfsshViYpJybG/429HOeflhiyJoizZZJqnHAaUfl" +
+	"IkvOJH3SKlVJFWbJPqT6ux9pskzdwrJy6NBxBPGkSiqK9nE/6yaHtOaOIlPR5ned" +
+	"BwjqrLOVGfdvOzy8zy6OTpB8JJ5O35aTvUnmpOHOTST7q5Tt4SqsKqrKU8ZMLO59" +
+	"VefKuttZmLKmGsVuzxJ4xtmOsbzj7jrHOnDaObg2tvZVLY2bG06W4xJ2PRXowWn6" +
+	"Q2qskgjIGgwGL/Z/7+qho/gPTXh36jmR1w9demMo4Y8k1PnrL5bLq5qtlHMrhcTx" +
+	"qkjHMqVQDGMFtMg0tkKYtmljaZTJIMj9NFIipt2BtNmmpK5MDFVUUwrJvjElbUrM" +
+	"i23kbNn7H7hCiP4ZebpITlFV4hhqmRLE7Z94lSPPmM6+HR5PY6k0ntVq21Nlhixw" +
+	"sJ52ZHpNNQajs6c9vfpv6ZntOE9LGPhh91dhtbjq2MjZvtil0zo6r+jL2H8eLj18" +
+	"yGzWRNcm9I5GokcOjGnDG7SaaFYxVOitW1Wmzf9NOstsnBXsVhrLaczNWymFZQmR" +
+	"BAR4hXFLIMn8tE0KNiGlQnWdm5TOjQdS2GXGiCBhAiR3+IuNtczrWRxLegSYOFQ8" +
+	"aNwQ5pS1bOmZvMuM2Titbss3zVUdd41y8iQI3cC+BYszD3iyYZAxufkk+P8nXHL9" +
+	"uAF6kyiw54eRvOBZOAlO2Jkks3WNzvOHZTF8wXjOnz157FNv8IdeqWn4QqxyMzjd" +
+	"ovNzuHBnGNqB8UypLJspmo/PZrnERR2PqVzauvfqDryP7Z+vQD7IISU+56T4JDTE" +
+	"q+pP9KlpI+PV4dT1ixJrec504hI0p0ainusxoch3Rf1aTnA9yf8ixfufD/nGTaR+" +
+	"r9Yxn56qBqi9vX5hPpZKpLI37GNPZmMfbbfbh2nCcj2D8Z5XfTA5tD/UrkhsSybh" +
+	"P3xy2n8vXr3+fHF+jbhrfffrgpMdwyKsEIABftZxWHn6eRPx3H4XyvkzMnSq9ves" +
+	"52gWBe8WN0R5UW63ukJQWFQ4oKhAJyCJnQEqDppQlchLgECaszI1WAe5g4MUFyh0" +
+	"anCQg4mSNdSo2xtqgYJ+eC6eYyu+bd9QOSufIb1aqsFPuqFWSpbKUpWlKojFKpSj" +
+	"ujZZcdbOTOI0xFWRNkIpGoH4pGFJpP3gr/zxFkAWoqElVYP4Gt/X38U271ZrEysV" +
+	"o23KuyJZatOZ0Kp4TXVYhqbvrZeRB/cPmRH1kRtuErUZW4UhQwwgBj0NR/V3kMY7" +
+	"EobIBcOQukBiqbEGpMmJiq+WZWm2LXZ6qn6+3RY7yG3Jww0zZ0a0T9xZo9U2SMjs" +
+	"PDENqfk7N482T5PLSV+d2a1f1eexrCMfZXsuIkyj/nLJDF6pYr8eHJ6TBVV87tmm" +
+	"a7bz+ky6PN897u1CATUrOcfrYT7WLUnZUkfzoytVKsFSxI3TkSuWTSN9Jpp5QZrw" +
+	"J9vP1+nTbT6eldk/oc3RMOhp4yJZ4IUQxBgmiHJjtlz2GvOHReN9+iGp4Jktksd2" +
+	"Fk4SV2/JatrxIFOH9wap6FtHEfVGhB1sDwiGOwtcvTAgVkF6fh/XVVVUQaOqOQog" +
+	"5PKIzrA2mJiXdzzLWRbIZCyUxgbN2zVNiK1HWZJuqUsH34W6Tk5MbyVmv9jI2aSL" +
+	"I2VKRQpzmQyE8pC1C1EUiox5RWwS9UwZLy63VpJNJfEm63WubJNNHJJO5+RurZhi" +
+	"qlWMUlah+7hqpN26aksmYnEl+2jDzy2sWVaxhxo0sy3GKzqg4dVFnqiH/Afo6ZOB" +
+	"w6/25A/kKKi+ipEIiyL9rIz61tdfOz5b9tOLlSqe0SxNVPNTFk/XTHSxksktjnfv" +
+	"TFaebEYVxUzjImU3vFMtuuFx2WDCnNvkJhZJpZDkrlXW3eZtcuKZcvAedJhwsO8s" +
+	"JvKWfGcuMmSVOdMuPtO5iTO25qE9ntOJ7c8nKZfwxh1UZJbaturhTFgc4VklKumu" +
+	"lWXlu5AcQCTBIkaKGFUrEV2UU/n8/HpxHWKqpiLFVxDTtu0ZLFI6kEKTsGEUPGDF" +
+	"OyKFmi9fCJPgqu54sCIJ6uD6eDlOsdVOSppKzATwfi2t4CPHgfLsRZAITsgfqQ3S" +
+	"VryjsJs6HWRGyuXSEjvQFceInojgi66B/Jn9YGev5OSROQPgpDM311czh5pv7QH1" +
+	"mjYdG88T0Y6lKoky/ahYfzsf2FLP37iw0iHVc4G1T+qGtRbbYqpbLVXmWjUYsWtd" +
+	"3blc3NcosbFotRq1lJaLZLMX+yeAaVGqxZhXrnN4O7p233eKV527HTl3dF67ngUT" +
+	"DIWkYklBhCDIYMo0DsbYvZpkT5KZKN0lGEqTdkzEsUySxKGyAtr23/mYGEIYA2ic" +
+	"NDzgWF6BTisD+sxSj0YjKCGUBhaU0dbAuSAVMAWdJKS0UVTIyJw03tpPFQtSP5Zb" +
+	"pmLpJw4T+ko4c5H5d37d2YZYsw/VekqVFiu6LIkAnOUupHbpVuhXVTePKxVB0bps" +
+	"xhwtW3SVTpJP4oliflH2jl+CLI6HIdidSOtEWxPwTYaOFsTDdMOO9lshLUSxbIu5" +
+	"uldYJIE/CVEfQGnw3KR8rEXXfhMiZYN1TKw6ox209eLH1yz6Qd55slpUwKmJGhpV" +
+	"YEWZi/Z/B+/mfovmdoZ+b+KH47xRdEr1MjJ+9ZGEk8zDzXfoia3VNrVu2HqivcwY" +
+	"3Cn7tM3ujFGxSqYs/dy22jfJLV3mNSTmx6I9vwKifsrmelJXD6zmOk4e/y1x5u6N" +
+	"kaNqieX17yTTwyGtH46H4Fak1c3Kk5z/ZZaK7PU4mLKJZX6ySfl593p1JU4nVzP4" +
+	"uonn80Sf8PxBATaSfrZLZLbUFOifY8b/OQOkPKRJYuHzE80n8kWiVZVKKsiPyj7f" +
+	"1czhH4I6GHur5ngfJsPHxaVDwbH4JEAnRdt8Mbc25sbc26WpK369rsq2Jk7ybJJ7" +
+	"nc7O76eHpxPLzn7OkGqH8mmR+h6xJVRVTckP3rP/RST+xYn6JzHM8ErZP8IJf7oK" +
+	"am6yrFq3COr+Gv1fkE1ZskzBUlfkrr8b8hzk8yxE2fNMfNrmi187J8z+Bmx2Wzuo" +
+	"upumHT834f0K/hL3SkSzQ2U85TkrZYbKMVKVsprfbMMsmUWyWP1W3DVjWss1MNMa" +
+	"H1WP6OTaGllrnZoiAS6ssfNp5sy3o6d+z1Phfsunc9WPbpmXPm3eqbeJ3nCllcoS" +
+	"R9y0sQeiKPWxdMHSL5yAm6DOmnZx9/de80IwLgMAwP8AgoIErJWSGzBhMaRbyCyG" +
+	"/KI3YnIr+zatN5zJm9iJx5FlEPllZszjniMMODP1NDhIdNGSUoDpyr2MFiNFAp7m" +
+	"dhmsM3rn7xcKDPsQKdNOmEcqRWE10Vn0f5jdKeQdD+sX9BD/gPSY95PtG5r5T0HY" +
+	"ruV86045uEMRVSihTsyZa8MesmkTJVlLKqkjBRhG+JG9NNZ4h9alqTnNfxllQNGA" +
+	"0GINwKMDY0ZDqh5V+GFsqw2G6lfuxMZjyPPPVzVO+/y341ul3m+NvxltY2IqNsRY" +
+	"1tTEiANRtZmKiypqJVJKtpSltTk/sPm7/O/dRNKm7YOQYxq6uWOcR7KE3fYnBOUc" +
+	"rZ8tbxGpQnw+T1h+E9UnrJ+6E4e77/fdEqziI7b4QxqWvgPVY2JuUihvCTzqWzax" +
+	"J8k0/ueZNn2cHv/723l7vkvl321HbIYegUM+f6eVz7iFR6+P17uMwF+AHuHwfOrG" +
+	"7J7tnlJLoqxiJZp7OkanzOMm8/JPR9k3N9px0iV2kiN/2MZWOp+Dmehw93hD9FiR" +
+	"9EvPnH5sfKX5VzOWREnZyUU+va6YuauVpl1jSzGGKqpqKIOVA2BEIIMpS3xoVbiJ" +
+	"DZ+4+ep9reEaqbrqJ9X9jOrrvJSr+/C3LCqZIomMTTGl5droWwvUnqT7fVasJ7Q3" +
+	"Vdshbp9jH8pBJ6bD2U+Cd/hZbX9ay6kU8KxTu8ttbZlm1Zpptjy1hjMVabYxkKUR" +
+	"gyjKMrbFpVVpilVWFxd4lsXb8MOW7fVipDJxhwVyRmzTVLLxkzco2dz5NnmsjnxG" +
+	"SQ0xLOUGItVGqYkjaPOd1ixXJ8pvAbHrxPhNAgJ168Kvepi5THZi1Orm5ld4ad8r" +
+	"162e8Lnx2rLKuWUXYSACKn+0Q+UPkiWkUT/jy4+mbc//nw1tlzru26a16nw/ipmj" +
+	"oukAwgMmggdSKdGbGU/Iprgvjn77Ct2WhTTOcy5KZMORZMZRWwQ6QquGZW1JTVlg" +
+	"QmM8osKKGDGMJIGMIBsiwhShSkqxMPy+3NPLDrbgVBbDqzyCBgWZKJrEQiRzR54q" +
+	"wia4gUepCJo2SzrcVXl3bH+sTOvr0qFHlmMYpGEQaiFZjEgQmdarIu7T2kdmRlAF" +
+	"SkKsnConJTZVYwmzOAdnDjWUlQbpLqEmzOttyWq429ehDBlMRRpyaUji5o2uW/LZ" +
+	"8wQgAFSMYB0Wdnuk9X8nH0naSH9JI+g9o2Gzu5nUVw9VrujeRN048OjNoP8LOjhS" +
+	"uG/rTtFPk8g307qhpyc48W4wop6dLpbpG62VarE1XE8iOyVK9ztXvOYw0JoSwJZJ" +
+	"Ftfft+V8JibSreNomUqaifeYC3fJ5fCnZQIMR8DDQUIxtbZGzGjKKNDyRspoqZqZ" +
+	"ossZ6UUDMFZKUgwYwsMaaYqaYrCr66wtypjY2abpVSX/mXeSNkaJPqgQhw2mmMjH" +
+	"EHymdzJLzYsvmuuvVbsqy6m7aYqyZnGoerqj3UePiyIVZIoqKthYOZ6vGFsYpWJz" +
+	"5ns4SY/yi4BSSyktv0dXbf1b1fl9fp9+36YjGvdRRMDFkx6Pp9wzFt1H2f0Y5CMb" +
+	"VjGyUszErxN3k9ks0S1Zk8IeitT1VrI3R37ye53Th502X+9254a+co8o7nMnWdCi" +
+	"wosHYmvktSVSyC6P4FSTb4evj8e+aNQ/gr3by2tmlU3bI5CjjaesCuuOTInFMxR6" +
+	"BGGiWW1NjQqsYxKUlU0qtak2QF9FdGkKOPTjiqoqd6H0PuA+KaOAwX65yfbt0Uu2" +
+	"t+9+OvxwswtdK+Z6T46z9ur6JavYqrVySsYUxinbay2mTZRVK1bWMy8Hm/TRaetZ" +
+	"W+L6HJ1GI7KbTEnokj3nzVNViyloqqryY4aU20msYtW5mTfBtWDH/fMFA6MUxGMR" +
+	"NFAuSNrZk1GrtLMg2RpFCqVUaUsYRZMiN2Nim9bnyPI1L5d7amo7nk142ZMm73SJ" +
+	"/eoPU902bpY5T5yQ6ffJkrLbKvs844reynK6fNsroOIGSOqTdhDZO0IlkpYiq6Oz" +
+	"Fkc0U/fPTYvU9bxWXZeLi5F902sZZU2ysGSmlVu0qcXTGyX5KS21VKrYw87pVnOc" +
+	"iN204sTwOM8R5cJLXpE8sT3gdCaTqejSJPFnanubqkqvQ5+EkEjrFki/syRPSKqx" +
+	"ixHNf1x69+Xp6t6l5LGF8d0xI7umlRgxkIYgsKQGahBGMdwkbbIclCjg2oW00iZA" +
+	"hDSVAoDGhqhIDTC4UGjDNVSwINaWT7/c+6B936RGV91beaH+tFpClUqVar6a57xS" +
+	"1YsdOxwxj98iTq3teHw5yT2NnV6Ms+s+NR8b24bKw/NWKKqqZhiqnM8QftpfQb+C" +
+	"Vs3lZLSSASqcfM7yVxGYledbnrN50XJBATYaCsBtFYJlZR2SKwb21+jqRiNFI0Sa" +
+	"rSjgiATZnWelW7O0mbziCfju7ylzo7WSqylsYp0JpjJU0qaMlJUUVhGilWTZudCx" +
+	"M+kc+l5uTSG84qLYv2ZJMli2qrILI2Tqln4cMqNhAj4gogAncslWOiwaV+BwnPnE" +
+	"jdp7E6UlqPtYJYV9Tg3WI95FkO6beZO8nlbeyYVc7od2tLylZPKLTp1I35t2iLsk" +
+	"ipSBQqtbUX19H2kWD8z2PyVPmh9rLUcrDSKQsTJIfukqY7Hl5DzdPLdUqq1+LJp5" +
+	"emzvHWPLN9YtWeh+2WzylkbFNlTCyVWKZpKyQ4YwqnWq3kKzCwje4lWdzTuDbTZx" +
+	"x4bJ8tzHGu7m3prWSakaVZncMwY02dcu7kznctvM5MknBXCmwVtKfU0xWphkowpi" +
+	"VsxiVW7I2rWqtRhwpcXDoaZN1MN6tYlKrh3GpWUlJLvXd43OuslSWQ0fVcxqeL+B" +
+	"Xv1rpQyBqdm7e1Ra8loulyubVzbXOGoNVpN1/mjcbxaAiUP6xnhT7z2IJaTCQVgt" +
+	"DpQcGFJgWSBTA5batqKV5l3ruu7XC3NyZRFeT486vWm68lRqMyRNpSzSpsi1KyzL" +
+	"GmTS2azSVMZqtq2bay1a0raVmmyq2yqikIVCwBSIqSpJJKsVBYgSKsBLSopRkS2t" +
+	"tKmrVKmA1rSpZU2JTWWSGtUtmsrMWKVLLVRCkSkEqQS0GpKlKZllNtK0WFGTNpZY" +
+	"2lmmZKZLbWbabW0ttZTSTFMklmzbbTaajUNZaVNKzWaipYqKmU2mMk2lilaVplhZ" +
+	"MykpmlSwamzZsrUtUJCNs2xE2zWbLJpmmmlSyzaYzNqWpssspZTaqtm1VbJlmm01" +
+	"kzUtDKks1LIK020pKUpNRlKTSlmUprKzRSmk1NTZZJrNhJIZMlSpNJDMktbNVDEs" +
+	"mpKFKVJtllm0ps2WzabGsbM2aQtmsJaMkNaVJmssNbZtbMprNYqWVKlaTUapJmGz" +
+	"RClCZhpmEmZpEympqWZmWbRs0SaY0lNTU2lqbLNtts1tsrNtKqSWmGWWW0tZrNiG" +
+	"Uy2ylLU2jJWUySmlNmpspWFKJrTVkE1lJmakWTZmUtpS0rKyqpVsilmsNrWWbLMq" +
+	"aVLFlNmazabZtNppoZJEkxlJIlplYbNUMaaVKhIUylmxaWkEslm2WoAZmYGmm02k" +
+	"mZ9vNcym/zYZ1m/E+UySfg39LUVVWb+0CAnu+IVnzkTYexs7ufDm0VjDZ7mmLPDC" +
+	"jvRkCK4NH4KYIPfTEsxAJVJTCY4MNNqKqTgrJkmjRkVkyN9MMuNskxW0mmjTSlSs" +
+	"RiUzxDKZmvWVXm9Y8a6VLqbbWXtSMLsZGTNoSqYkyYjI2VEskoLRRUbRRsbWkqSt" +
+	"Sau0WgopMsq6V0SZehQ82kyxbJsqq2k6xbaqqpy8chxElkKVybMPBqa1jIGLJqNa" +
+	"WSNnw5w5rJRVJ8pXQahwWUzyp0wnz/U0hIEiEYfzEVFZGtr8GqLFqNUUa0pVZVFV" +
+	"lLVsEy7VF1qILVeGEk2aS+WJki7F2pqD7InRyG/WjNbxTzY7E029eTdr/1ZJlhzx" +
+	"xZEk7TYxZI2Vk4yI8WLZEUcfOpyzjm2I50sicpFjzHRZKelYLMxipnrpolbK2wP3" +
+	"Gj5QrZ3mE7dW70dJN3aTWPvGzFnLOYscQkecNk/KdSbVattW/g8tatRJ9BbaVmTU" +
+	"cNkbE5NiRgCjqJjBFYYMQEpXT39BIxlLWwvLhFGpGWUqKViqxkcZkznhqQLSNrGQ" +
+	"hBUdGYxN2kbWNpAzdTVXSs46S3TNK5yd26mxXO7tXNdm0m6bRbSTJvK6rpKW2TFt" +
+	"vPLvJbNaSixoxKyEmNk0kWK0SdjZs2NohYnAsejhFowruXCQlUVFqVGpE0UGZIZE" +
+	"c3lktTo03a6N+EiflSdFScJJ0xKRxN5+ZDlCLZB9FWySZUtkhL9OWNS5Kx7HmGk3" +
+	"Zm+vn/kuSquatyCwYtGGhIxpQKVBh9sws7qnJ2thu+NtlbJbljpdXFmFp6I0cN3V" +
+	"hW7RqTNacWNJ80k/pbIVr82CR/iVzKp1fJPyjz7u0PGnOl53LbDvYakR0ZJD8qm5" +
+	"9mWLpEWRzhu+1n9OUKT1kn8VOh3p4lv5ZjCqf3P82pWjKmxUzVvxpOH8eDZPhDwf" +
+	"ii4JZZPcJ67Ts94+JJ8JN6n2RXJ/iPpDEN5uehqR3Yxju2bXbGDrRv6T0R5vdxJO" +
+	"R2mD+4dUjVjZFQf6RFZJ8rFskqu7VMy3EjDuzE2K5wH1nnG971lZjE1GMMpMLzVo" +
+	"tmMJoN2gv8yApnCpgihcVoiUFH+c9nnbz+momOTD2WTT5sRko0skZYttki1bLSVY" +
+	"mmMY0wqhWnGhdSllSSW9z4amEW8VfPq+6qyaeu2jZNvXtEl6ptryvUoxwqtXN1Fm" +
+	"Yqyc7Jqlsb2TXkulki/galjcAwqxIxJEkIZjxWvohjDLbjDg3VHCdKtlCUmTvHq1" +
+	"g1bKsb1nufaqpD0uQWNon9Cdrrb3LTMlSbUTSbK0ohajIvgjH+99Bt8p3n6qleSV" +
+	"ZE6o9h2eHZRzpwc3OYmK009E9R328jxMbJvFH6StQnM1NNmLDBWdD/DwdQc+bD7v" +
+	"Uoz8D4pQaY3jgmo4UpCiqrGzZpNbC5h/TXGpNqn1Vaok4ZPk4KphiwyWJy5ZHRwf" +
+	"oiZC34h6SrVlWif7FRHs1+Nuh+L5Hs6k7WWyNKyald2mpMaNp8+jr5z3H5HpDpU/" +
+	"yqPXPAk91O6UFo2PK2u5jy7lWy35Kw+iPIqfOySOpNDJ1k4nqsilXhkeZbW8c56z" +
+	"Rx1kbkR1nBpJ1VUPWotkR0rdsQsexSuL+5pk+Mk2l/i7Oi6XGwkvE5JyD6Ifc0l8" +
+	"iIBO6c0DixXt8Wk0H6+6WxFliWWWhO5P1UUsfx/o/JZJ9iprtPkmjEsfWdqnbtat" +
+	"q24OckqqqnQw+6k7EfBZHMentbUafUcOiqVVVYFUlFKKqejEY6Y+lfo+ubdLJdCu" +
+	"RFXLgVQwrGW3GIYJWGCYwwtWWlUskYxZ+emKaZHyQfWMWTUkP9FV7wTx+WRVUrZI" +
+	"0/KPlYWlUqaINRpIxmMlMfoeftr+7+JP2H69M/jD8xaKRKgSrdibLHI0VxjbdHGN" +
+	"jQd0aMDA0QIQWEpTRDGZrq3R00OH8GFjuAD9iwhU2MP6wiGD+jp0Ymd06Ksv5piO" +
+	"Uq1rMkwZkiw2SmZIUHD5pP5P1qcNmkgD9vum0hi+X4S/PJ3/mfi9rbspyye2Fk1Y" +
+	"tSqo+5O33q0nAeTHbg7lc2zBxS2K2xjL/dLmkWZGHQNxp9NkyrGxuvp9akHp3+A3" +
+	"ROSdXUb1air5yyvdI8km6PrIgEskaR1ceOmv5q4dpNp4dofKup3NzUTxsvxlZbZ/" +
+	"V7KshwsVcSqwxapT6487uYnOE9IdPT5DshyR8GTg8yZIxO7D2Xoe8wbPD2vkrki1" +
+	"J6oe6xXDYppjTbDezUkdjZXVjE75bVWXRUdldu05D4OvVbD8SxVZLZ009nJEkSTN" +
+	"7Y8kpPWH5pUvT49iIMA9AfIDJEZQpYI0oY5HlZOHxMMSe9WuihVMpamSnEH4RE9Z" +
+	"aWlkKsWrVSPdFT2zJGJOHBVlVUrpTJRywuMlV0T9myzARkClqiJX70kgpcYzsakR" +
+	"kiRXw/k/H9sfrouz/j/oVDN7/u1hxCRIRZULOfq+KvHsxm1M2jkhY7WeUc1j/ARD" +
+	"X9g55b0y0OAkCC5cP+IWkuBkJyInN3reK6uz5oJ3cmh5kk5SOROSWbV3cz6GtQbZ" +
+	"KFKWuNFtiyrDpfLMzGSYWFVpVVZYebEEsBqBXBsjMbarG2x/fZQ+jLYbHHqNwzdK" +
+	"EarMZjYxuuOPbI9sySN6HDIRKMbSRBlKUoJjSMbaV15eryvBqvJXDYi8l107GrKu" +
+	"rrePql/G999PfuvQQNubc1orFGJnz9/3e/n38NvhXHdrlX0hVyULe2vF4tSELMby" +
+	"nXaVdIyzVzptzbpG0kYyrYmUstRUilMV6qhiUaXUqU2t22sqVUgIrrtLQ1QdExSK" +
+	"lSKNIKNDYBCEhONtcvec081daISsVrnNwhsmVFh9UnkeSpU/Ucu0cHJG1Tws6MbG" +
+	"5/FVq2qhSlIpMbqkdPrfnJsRP5LJP3kl8j+YotqNDkj+2rYWxbJPER5OzzamSJYm" +
+	"ofxdXtOqPt84dU9J+/4gPBe8BUHiJMP6uXrNpwqwttVSaxGF+jEifCpFfxSkr9mc" +
+	"32c3S3Szbd2ZoiFIb5ZGYtnEkdJ+Try/CPL9Mi5mMdh+Ug/lZFsslk+ZJ6Es33Tm" +
+	"ZHKzR+qo+jHqk0bPR7vVXJrn+XaeaslpRZLB6fWTy0fm4NJO9fzVkjpKW2+cmMea" +
+	"KKivw3yNm0nsxo0qY/JPx9o926TeJg2Itr4mV3UibG6zyzGVVRZRZzUmJYrYjeJP" +
+	"tG57vdmClZ7rv1y8228aKmVl6+qvZfKRcLOG6ldOqd/Vu6vnzdTvHSaWdJCUkjhk" +
+	"kn7Gk+eiZHzRJjshqSwqyDyZ80X6SPqx722PQanWebyOhb9n7djstjZ4dY2OQxL8" +
+	"hdS7hgfQ+5CDkj7o7K4g5yNpyOpPqRywlpQRSDKSubGQjFYyaHIAwiqRam0sMSLC" +
+	"sJviL0yJ2OkeKEslhZYLLIdXuqTrJIqKaZP1acJCcH4eh1+kfB93b1WTnIpa+SDt" +
+	"JnSUSfEhNliaKTnK6bk2NUtOpwxwxVUbNmx5x8lIqppySP7fkeJPkfA/GZNlaB85" +
+	"U/xOGz7nG7VxLbFvOJRc267dY5TS32y82q967Sok5Aw3FStphVLMYoq5nJ05S7XG" +
+	"3bTWXLtislaIjwcKpUlVZ5bNl3MjhW/1ibOUVX6bGO9ltr3qNM4ZOuTmdlJHaTrd" +
+	"opbJmZI0WRqsr4Q/tfrZ3oi2RVBaIqi1MzEkmVJ0pnG2r43k6qGCL9Kkpczv4SeP" +
+	"sFeTIEBc3DtAZcH6XxGW7Yaw+DznoSqyrouIMcMHbjD/FBny/X179rvtjikQCcgQ" +
+	"E4HS222zVI+KD/aP1IS0pJSBYzn2USdPSTTu868arlGQodZ/tyxVyU5RrlBdEqjR" +
+	"+4KCHQDi6aQjlScf+T5kjee1Xoxo/SOOyTCd1xDlX+YN/MVvtOj2tXZXckMqqZHZ" +
+	"EKEQlkdnL7Jdydlgmev89uU78j5cSJ/l8dkmE7rhzD8qadHMH4jZj3nDGPdwajh7" +
+	"sMdnVu5ujXXl+T1/u4LOHgw0+z8FGBY2M89iIokYQvh0gpDsMgXC5N6MMVWqIDKF" +
+	"k7Bhi7LCa12ZnoYVi5gcGP9X5TyVn5jjpmK38e0H0yNy9sy6krJx2NyXEkufYjPY" +
+	"35HJdzHaIWeWpGch1C2GpaeIIyAyJiVK/Gotmvs6vH4XixysdNfO67ZuafPse3Xt" +
+	"czmeH1mHV6i2qvNHrsuyeFJj1OGjd4Zq4YLjGTExlUsVV/xcbG0nNuxlxTLllUUB" +
+	"hE0vYrX0AxuvoyLWYktLUDBX8H5cYsLkOfeXyz9A4QbZ7J00FTnG94VNve5NkYen" +
+	"LptnR61av5SHOPZVdEI2fk5/k3VxOX5PckzZv1ec8TchyRzOOqs5zOUkm0wWPJVW" +
+	"TC1sxMVVTWOfpWxnsx/JmyBRsFWNsiIqoVUFReZrK80s5jqpOqvOS43zEuyOx1cp" +
+	"0Y8OhOW7ME8lk6LCeFLjEsFSqpSyelXJhXAcdpsp0Y6/OqpWhUMVm2xjyTgU6nrw" +
+	"6yszFUttktLZVtnXi3kuDRtDz/sJ5OxXV22LVZKMYxihA2Q/Dq/NjZ+535t7PF0a" +
+	"3E6sM0t90PBzJHT5SRrz+MtSHquWXGSMc07ChTvJ7sjSm49U8JK0NlKrXIMbnnPC" +
+	"0qUqjU5Jxyt7ynN5e/kM7y2YxjGrVeTE5xqbVT8LiY6bpo+ZdRG82/fr1m22xZSB" +
+	"38PxIyNMShQiH6G9hXLOZK6w3N5+X72HFAxu5NSfRpW6afRXqo8VJGH9x5ObPuVJ" +
+	"QLAiFlH6/u/FbMJ3EnnDq7T0En449m8JHNPxcyzXSV7BCP9JENSIjTahAiKfMpQX" +
+	"fhvwg6xjTyfA09UakjGjZSMkcm0k69uDQkz5aTWCW2iz7hlcSciTjD3IoFZBYmNt" +
+	"odoFMMIkDWQjASGk0NA76DcIySAGLYwAZPQkVbS9raOCXx0N4NPJAcpTE24YEIYy" +
+	"g7CfLWmi2E1TDcjdkTMXE0qKsqvYI1Rc1zUWKjBt3dZMYLSc1V8teNrSwW867u67" +
+	"u3XWz3uiTDJ7uup6aktGEa9d1hTNubvV2q883d3IoqVnZHRyRZT547K2nlbs57pm" +
+	"7cLQoYwF2iZPBBH+5LQ7dYkkhI6u5sNK9nPxux2bnayrYrkTq+u7erJbBUNziMaP" +
+	"rppVcY3SxyySyySfFXkjZSuA61FVMKi5jFHB+UxNKWOqcRzfOSQki42nkQs97JyK" +
+	"5amm58SFk3LVSU0uj7SQfqwEfho1r92H6uG22K2lVz+Uf5sqP0dLN/GejmK0sxrP" +
+	"xz1m2/05yx4ONjCbJH9A+8QkhIqoJKiRIQWkkRKAK20HGfR9lFGh2vmzMyyCig/w" +
+	"mlAinByNccszHu826vNs08OjdXU3GzSpwG2/sZ6SHoyTSVw0slcGjSBnq4UMw08I" +
+	"tvw4uHqDA/w6OSCRnyIh/MH46rxmTFxdHacVc+uD3HvflqHvL7RI7e5edJqb4ZU4" +
+	"09uYztwe+W/IpAaOoyLcwQVPk3k69Fffn6zXZ3kION0cYOXDuS+3vzTOm/K7Mq6H" +
+	"OlZUd7Pxxdl9t69NorsK6eU6442+am88vu73UsgRoV5Z211tTDr33RPyM6/XfL5U" +
+	"EDhtlOMGIOhqVFDMLDExeDQGHON0fZdtpnTpZ6cD6JBkGJpUx0Y0WuppUjCvDGzH" +
+	"Jsmjd0VyNNnRZ1Y1MNHaMbOGzcp3VttssZwsk0gsTGWj6gLXG8FJpoGGjp6NmZZI" +
+	"mQYvcYoaIEFW2vkM2ui4SWaSMLtv6RnW2Q1A4FIHgMRpRK4eNjfwZ5oqGaaSMo5b" +
+	"dknhw4SbOELPGyXLyqGoGSSqSomY1HBBVkQqys9MCWL1YjTEvrT/lW/HvnSpG2HG" +
+	"W0YwPtoufZQEsPWkFdi4q6Bs3tkoppX5Eiaqo5JX1UtH2/gzrxnmXNzE5gfF8iGh" +
+	"wMagId9OeGfjPxGKTtKHVVJ7vT6eMIaVB+wH3n3+jxV4Svh6l0hS2vo/Hxp46W8T" +
+	"mStcsHMrio8lNypolKYqrT5AyFDChtZGHuINKBspBGKg7kJt6Bo8fNBswFHISJJt" +
+	"PcLdHk1+NWshZCgqnMZITrDX2VnDFGhCe+9um2kaWy3BLFDrBte5ISqMa3whRNX2" +
+	"hdsSnCgdmnJiwaaFmqxgEhoSkmS4W5nnc2pOkjMCi0Pn4WGjUumeTCfLJJ1jYrHx" +
+	"jaFRrCj5qXWxkTinm7fk9Hu2JvELPk8MMVKpWKtKq1iVVKKUxXlx31G9Tw/vO6Mb" +
+	"E80lYmSJp0FRrDJyLJ51U9ZI6GiLTUsTlnZqBqxHcOldSSip2iosJI2Ehx0kHxDZ" +
+	"/AZNzYUGDTXrMplachkVuS1tsiYIYyt2mzZDErJJWTTEalrQplZC7YM+li2SUoxV" +
+	"VZY0yZkycNIiDcCJMaGNe5kXBpN+8HIUgoKqYnY1JISR6tshCE6JhknVjg6cMhWn" +
+	"JNlbSdppsotV9zG202HYjiEnmTz+E7xXhSrLv5ZtdazVbW2hjEYNKDGEBkJ9/vy+" +
+	"vnrFURs1YvpvLuyE245w0VLL1kr7cOg/Ba/Qf0QM8JPxZLLOStL5KZ+faXr7LE9j" +
+	"17oH4+OiR8orIu4h/RAagtxGICYpOWtBCN8eXMu7rl485VKQmKi+aU6rwbyfLXpr" +
+	"161+qbettfqWN0pL88tJbgpKWur4a8ki2arIszGhZJVK03h6o84nieE+RSDA2EJn" +
+	"ygppzrRHjjDHHjQ3oAGNIa0QIJjBiGd8s3glSnsMZSEY1I4BqCBOrFtgXZ7YoGff" +
+	"5SOeYkWToVOR6a7/Dmyl7pPebOTUlLEYebR5Ikzr5O+azEJXRy731dGOXtcW5mTx" +
+	"HG7GnHVxIbSbnuyUslYdMltVhpO7tytjo3Cx2IyGZDKmmWOxCaYRisSq0VhSVpit" +
+	"JWkrS3VY0DcaigxKkRFVBNRkkg1UhOMurldw8knJjznZobpJOCnNMtmM9JI/gses" +
+	"Dl0es/T0c4b+aSO5yy8it57PtER7yQ49svq6K2KoqVhjFUqmm02P9rP+enbyTaJy" +
+	"k7zyB5VdEyRHyqE2jlT/N+4jPJHNVfOPajFtvo+bRIhxDIiAREIBEBHmAseJvCKp" +
+	"aWSr3OREAnaST8LJp9TClbcGN022eOxs0mObY5x+f0+u0ck5RKKUopJrgB87bebv" +
+	"yv5u7W3q/fvzQ+JGypskPUreRLIrmybatMsX0a/RksaxtIKIX8sn739qsebzOZiG" +
+	"by7s3vdaJR6Dj2macG0WSRT7SDN9KC4xmGSRgRYwaf7MbwGIOPrP6Rb8N/DY1I1H" +
+	"JIkrMaQbxJHdIbifDkh15l2d27BHRHVPKch+6RBzeUnBMtctc4pKUyuu2upJrlrq" +
+	"667pW6+1t+6Vk20JkkpYV59A5unxbofu3vn21Ey/s+HYx9zasPu1JNm5an1x85Hp" +
+	"GG1LFk0RAJ1kfSK+E9UPntJMsjrKWnc/YuFg5pe8Oyx5qIpZEbwKh7e7yTBhymws" +
+	"JtGzb8PDzkfvPfLZJ5yR/o9pH2H9KqdtVVX7VbbWI2Nmr22lllliKehVTXVI09Cd" +
+	"Z/Ou/e1aKs8lfvPiSD3/Bks8PeYcuVmGgTKW2WyVY/isZRxJN2T4vyfP0vRyfZZK" +
+	"rbaZNZsTidKX8ofEcnunxzNEJWu9xbuQ3w1er3T4Y3g7/gteJ4WVbTtmn85O7lJ/" +
+	"VEnkTJ9atqsYYYeujDUxIwoxR56sknNj7SbuGneRs8nq4fJO2cpuiWKioslVKlRS" +
+	"pJZ/ULtdlKi0b+Z81+yixKtJIPDdvJ+LvDu0SyY/h7/w/FiNs+mias1cSpOznIPK" +
+	"yrHt1CY942YTzH+yrZIoqhOEiZIT845d3T6Pps/6Ofl4bEm9vIZB/UJBbEtgRgyB" +
+	"QrgTP96/o80lj8FrpZ3WuiX6brraSSqxRuxjTFUbWarrGGKMDbBcSioFSqf3ZLaC" +
+	"XBlKqfB9CZLWcmutdlVXXxEzqHZVo2a5uZjrbE5X5CvSKi2WpbDaOR0OqaV2Vjxq" +
+	"myEND13YGGgTBqRBqAkgipVktsk1bJm28lu2ll5dkUpklpVLKkqjThs7SaJqeWRG" +
+	"VasWSxZLZu4aIgE5GtmzUkyWRexTG+WO1qi40I7X+GXLi6g1d5IU5Kydn5ZoeE4k" +
+	"iNK7HJJHZ32hk/RzVTRzKwrOelrcXxZCb6V8ambb6i+3z7g8vV7o2qRK3bNfx+d9" +
+	"az5ZypWyvNOJkq2zTDGW3I2kxsrRVg0qaU6NmxvJVssZPf5Ch3jJZiNskkJC5thW" +
+	"jziKca5yYTlK0RAJy2l5f1mHrY2Dc6OkI2TTTy2TGVsRATPxGssjZRlnpIg3iSRi" +
+	"xI5OR2SOZJPl5/ncvR8vln1Y/uaaeTGFSl5VO11Z1vnvja5W9Kw09ahkgtDDYyAY" +
+	"Qw/WRKMp5aFVusKrZpjSKdZ3v58tazxmJb6NXQlD2AabBtG1MLD6P6xKQChW0XsB" +
+	"77Y5z/JBkkMXpKgXiWquYcP3Pv6+I4oBI7HediIrxI/Ei95EsFOQPxkk78pP8rbI" +
+	"tJ+v+lu6eiHk6+Kqz+L5PSR4npITj7fgsgl+q1VWGLPweJJjUnC/Grtc/J2G01ZT" +
+	"LW5ObQ+bnkr8xJ/5P/vSSP+C1jG1YK0Y1sao1qoiqxtFbG1bFRtUa1sVo1trGrG1" +
+	"RZKNo0UFSilTNtRtGjYIEClGbbBQhUJBpCDY1o0bFbGCxY1MoNG2zTaLUEKzFBMN" +
+	"tUbFY2iqKIjEUlZKixqNsW0UY22i2g0agirFbYrFtJiNJbSao1sWMUUUUbWNslpL" +
+	"WNjajFopFMhJGxRRttjbBtYNtoo0YrRqAKKLUkmqi2sSVY2oNFaNotsVoyQVaNGo" +
+	"o2ooqxaNUUbFQoYQ1o1WLUG2xVgybYtGtFRgmVk1iqZFQlJrG1sbWTajRaLFaTUU" +
+	"VRtSW0bVFWxasFWIsVosatiqii1GLaNaNGpINqg2jVoihmxFti2DGqiqNFrFslti" +
+	"qMZJm2sYTbGLaiKiNYrRRGsbWLbQWoi0WNGo21irG2RMpRo1GK2Koo1ii1i22C1i" +
+	"1RqA2o2jbRRjWi1jatG0lUBWzNUWo2xpRTRVG1G1Ftii2pLWTahQqKi1otitJqNU" +
+	"lGjJNKqI0Rq2i2yaxjbRqMUVYjQaKwVRtFjWiCyFiKsRbUWiosmsaiqjY22iqLQb" +
+	"X5/99f4p/uUf0tf5/9K/qseg/3/8O3Ejr31kY1gc5A1pvXCxCkNiwvOQZYLITeUx" +
+	"5CNobGwqJ5o3bWtQ2oqajkZRrRj1prYW5TG2RkzhxibIud1zezbDrRBn8s2xsbHZ" +
+	"Ilaaujw873Rttris4cJCx42DgiHZM67LEm5mczQU0zdbGxtvENm4RY8axrs0rvvB" +
+	"2Lmhu9ZH1rnXlfnhQMwstTWMgZ24VXZJdzdKmphdlKOvHF5Ypc1co3WpPG5UchDH" +
+	"HthGXu6jHcIFa8oQrWt53ErY2jQyDFGQGaaj15BbvaLTDPKU2xY9Mj2zrW2Hba2J" +
+	"jEwZb1mshmPWcZdXPGGDOQ4hqWsZbxqyLQ6ysx+Pu9UmOHJEyavWvHjbPPnsX1XI" +
+	"iq+W3w8Tu+Ry16Js2+QVNGKUjZLWwXGBxtiE2hFTSXGBGkBjMu6xtIYNFQM1yBbp" +
+	"9u0ksTStorHkolJ3E5XN5tOFjhjhwmVcOxEtLHxyyr7N9lk1DJaN0qwpiCBpBAPG" +
+	"3V0ccPvd0Avs82rSKmAnj7RQAdYSdYbzJjI4URnJfO3TT4xQ26ahpseRDUtS+MKb" +
+	"aVjQ9wg3lnedmecmuQV2y44ptKaHyuZcF1u1JXKJlu6pRPSTudsbp5qixXfWcnpx" +
+	"PboouIu6q3vjI6ci2PuVosvF0bH3kaaLyFWNsiaLGxxWqGnvHH4d8MyQpjfcyGZA" +
+	"6+PHVbTd22SxshNhjBvMiBiocsG2M5zFRj1yyQh5C7vZX53zDy85X19hw6XAhSc4" +
+	"4HRB2w2Jzqalk90qqeRM9JrLjIlc2+tvhMyT2eUuq4MdumMqyCenJRHTk1OZudfS" +
+	"+VfKOcyA5HHezeQrJxq2piOM5vIJjY0fYvMt9eOLt3WsvDtG97S85zOs8DAjs7dX" +
+	"vmFFxB5l4hvFFWKjG6TIUmyWmMme3cQzNyatha2CUx7UUluGUDYW7GzYGPvUZVUN" +
+	"2QruGNDbQ2NtNsoEDGs5S4Sw7tuXObFDTJmQpdzuUSm7gDGi7IElwyNbNWUW5apw" +
+	"r1xMC2oS5tUYZA2cHGiAzve7XardJ2IuYysvZR0Ku5Ck+2RL65bzSHlFlxDxNMK5" +
+	"TWUzcfeFomjrOXGkuCogWNpZb5Tmyes2YdxqRBmU6GoIV0TPJNojDDaqLiTC92lI" +
+	"44VORRdd7f/n2zez072fHsVc0lJBrBTJO0dTCCHBnnJ7l4TDb0xvuQrWjqhowcNm" +
+	"KETZaeWn2MKO9JNMjipkZF31GWlSxcYpJydb5hSnINMGPuEOnRLL4UV1hvIPGKBl" +
+	"ZvS4ydl0W3uRzvMAxgqY2gIYc5EjKevtHG5vkRZfTi704pm64VOlm9mnddnhX1d8" +
+	"i11nlLfO43hvIUvkhnaDTed1UYzb4SQy8iOZJY0OXGtwdkbrl6UMLqQoOxj6wqcm" +
+	"67PRzUcwOOdgLJgvlpWuyLe1MNGlSR9cdZItEm9xaWRy5l21raQcOMenbGPjUtId" +
+	"5L5rfXWQr2NbGd5BXI6+tVcA2rcJgTsa6HJhyR9JZrTaSuTN7tG94c7fN54bJ5gK" +
+	"AteSmybgHEB3lSGHTGcmecrPGjWNw+WA2uNR0erioM73usN6veTkgxmQtzC+7W1C" +
+	"52SQlmXcODt80oUQQutphmedzHoa0Pb5uGiUik1kXE7ZGybH16ydOZNOpe5Sgesh" +
+	"jsIhgWSTnObvd7JYyX1O5WwQQTtFWii2tYujUsWbw0ezmrTNw5aVPbIMBpLsctzL" +
+	"3e82boiMG5yOnOmm8fMsldyWw025uHyFFYaQ8uhZTsWKiNp8JA35OM6ztkc5IRzb" +
+	"yi5eshOO7RfQUENxDrF3qvnKutTq2OI2Axlgzi73va5to5kVtHbQ7Y32Dd1k3HCj" +
+	"LIPSN73VuOclVLYXpmseBJzbNvLSDWByI7kReScm2jiac6ztXZGkbaiCAyO2QzIX" +
+	"Td7J06xss3ieAXL4jMoKMHsszhnY2tu+PYncmERURzYjb7rVmXU5FSXuzzzvke8r" +
+	"flq8UMwGzmKayKZkWIVa8gdUzJzlgqDkEC5XJt6MpysuebzMk5crS96OkqQR3Dkz" +
+	"ElgmcLoCwfLTbkIR3GXy81m+S4PlrND69sIGpuN6O4g2ktmwgkuHKu9wyznIiYqH" +
+	"xh287t87BEPFkERt85JvWK2OrjtJEX2u3Obs84debd0rw7zdeXMFzOZDJ3NvLmvO" +
+	"W98l52eec8Ovx3URCkNEx+BY1uglDVhy3y0UPJcKyiDZjGbewQ+bM3Edm6FJOvzz" +
+	"azuclkGaGMcYNlfJEmxcZb4M0d5vObBOO3PN5hD0onSZ5O7GGzFbRbOZzlE2Rhka" +
+	"wphx0zrlixjRccimW65Ok1uZQ8tkA7rSLGbUGzJIZew32hAFkPnNVhE9MqWiOw47" +
+	"zozjty6kNk1N83UI0ZAZmzwzHu5NUqQyQow0vktdqtUDtNuQOWVDBrlBzZMzs4tf" +
+	"bbgLjvOVlw1POknTok9nX1y1i108eGb3lqIbyXdFm5ZQ1N1rdRtQsbwYcJmHBeXW" +
+	"2qMDeacg55NcqOxlx5mVneeFYjRYeJ0ckbFCkO9HPGh6Uz0YirAec3cAaT2SN9TI" +
+	"dhI4eu6xRjeuwlnHtcd9I6I7mnNQujxohaKtvuAQd6d17CIoMjnTcYTJ0gzDnLog" +
+	"y87zLa4RIWrjb3QJV4OaRG3hmhxMjBaozkkzdTcUbRtJzGncsju30dDubirvs7xZ" +
+	"JuXdqYd7zsWQFdt5eUcWbvOEb3hdO1zObnI7UeWd7m7t8zw5eWdMmpq9lvkl1O2s" +
+	"33XNPfK3sTSyZwcbL7OVx6ZFd7y47nYjGcfOl5WUbFK6jGO85fdlu+Oj//MUFZJl" +
+	"NZf1tARwa8BV+AQDgQB3/wP+ffir////pgsXwAAAAAAAAAAAADkAFvAB9CgCqKvh" +
+	"wIIRClJBQGt931KcB7ue29fOM4xl8OCCgCOsAD4gAMCCqAgigO4wANPNs0ABQWrw" +
+	"W94D7vhh57CBAWsPbK21bY1p2NSlc29vnvroj5VJCRUilcbPtq+nc7762bq+rYxo" +
+	"GIRFFTW+199fPB8oqqVSlUqJfA6522q9YIUQr2e0dTolBEUApKpKdxdyiq9PcxXp" +
+	"pT7XA1zw2DoUqJQtbhzOqiUFUEnrTwsJplFOzKlPLNubxmlvLabHh70vPbs9VSlU" +
+	"C2aInZnWUtKa6kV06iV7xWDfctwDvZfbVSHSMzex1T1Xu3dbtgdcgV00eRqTtivM" +
+	"xlkDWp3c5VXc0tLhitmrNiVChF12zldtJ3W27okKoCs8t8djvZ9jdAPWi0r3HoNJ" +
+	"bs1XKl3dVs7jAPbHmZ03gFeUl02d2aYcR6bmqg6173G4GXhqegQBAgTQSUPUEGEP" +
+	"UZGTAA1PCCSJVT9owqPVMeqfiQAIxGJkYAEmkSIQjRRphCT1GTygAPU9TTTEACT1" +
+	"SkiFPIj1MSaNAAAAAAAApSICIoiTMqepgUaeyoaaAaMgBiBUSIIIgRoEJkmqaek2" +
+	"po0BkZAPU+d9mfOtn2399/UaZITRTREBAJMILEUSZiSKkYAEmGm0IokQKAYlDGAS" +
+	"ykCCmWJBQBpkaKQLBIiZhJpSzJEhDTRCEkUETEKMxQRSIxiaGQREwxpZEg0KYgAa" +
+	"EkAGJGE0ilIIhQZFLKTCMSQMkBYoRIUkFIkmkQMZhGYyJkQwIUUkTQwJslEQk0IA" +
+	"pAEEkJCIRQLAGUhJM0NCzNDKbFlk0QYEaSCihZRNABJhCZRFKJFkxIKRmDJEZZSi" +
+	"mhJRNkEjGUIIIGFMpgaQMaSRjJEYTCYoGlEQpmzGZLISlRlCGEIIyYMaZKkpiCNI" +
+	"jIURTTTGkmkaGUWKRNiEM1ERkZEjIyMxIQJRjBkKTBJiUyzM0BhkLMYkJEwQBQGh" +
+	"pGWTRjKIE0SYCUjDSIhmGkyEZlMZjCAYYkpimEBMZlEghCUskyWQyUZiGYJlEmSz" +
+	"MmKRiQMLMxTTBlJoiJphJImIigzIpSYzFIo2MUASSpKIRJiaBiFAGGmgIUlEgSMm" +
+	"BGIZqYzQIwIpIljMJIKSZE0FmAxg2IjIaNLAaEhIsCyTEgyGYokNMEzTMUiNiMNg" +
+	"jRMMYSSQQhMghBgAGCEoEY0SkZlCiRhRQSiZEQgKMGQFIkkGIySy0CZQEqIshpMx" +
+	"jGSUUKGSQogUJJAMg0YhCooUJTKEgJoUopZCiYLEUsIkGESLIajJokJjEQJgDSli" +
+	"QhGIaADEBsWJJAYmkoDQjIJNCNGUEwGZIEkqYjAsbMbGjBAZkgkBKRjQGUQQTKZg" +
+	"ymhiQIhECNhhmMyEMgjBMYCJTZBEhSMpk0zGlEyZSjGFFRQpIykkjFCoJoxhpIQS" +
+	"JoRZIZMRmiLJEMwSJgibCaJghRAEyggkQySTISQBSIJJMyjWKAQSQKQYKLDSDRFg" +
+	"gaYDJhkRBqJiSBkSyBmQJhFNBESMWJkmpEwkjEQxQomI0wJiRijNKCQQNNhaYhlk" +
+	"whhLKEYJKExEESAzLCSURhIAQIJEpiQklAmZ/txdd3XdcOzl3Oc4ca53bsdc53c7" +
+	"k7runOugoiVLVlto221GpSpUtitttttEqtCirbVttrWLW0VsraQEkhMxSAMkmAyS" +
+	"CjDSRDJCCJBly6RMJSkkEJIMhCAo0wEkgYIkQzrd2YCBRMZSmJTCjKhmJIEiTDJM" +
+	"0SUsIxIEkkRTRMyEhJCSBIBsKBMmAohgwmJIkkCQaYkkCGSJkxCMCTruhzdNjaVq" +
+	"NGI1qqn/H/D+f92/9N7/nf+x/T/BM7+j/3Df5s4H91tC/+oosD+/gYNHpnVNy5J2" +
+	"alEaZU/66SB3/PXf/7//et/nu+/f9KKr9VSKdhIptIjKzARQZZiqimGUFLMlVWMj" +
+	"MSUU2oif8IKKYIhlVIpkBgFFMIYCimSU/8VUimSiVoFFMUof/mCin/KqkU/1/2/7" +
+	"ipn+uSn/P/jZ/qZLjiqHKWmltwNK6udN0mKLpTbnFbHSxf6h/6WePKShwUl1VbdK" +
+	"GyqU5ooa/vt32BeA5cSpdlPaWguWZVUxZht422i4WJpNsWzjjnNrttYxBLESWBXA" +
+	"to5UMFuThmsrEMqjbDpYOmG3M9440VM3kpxzZ0ZLjiqHSXODDEyJisUWWKaaZVEW" +
+	"drHTWsbg1ZFVRmRGCMFFhITKNXhUhsLAnAXFVTa2xYZviazvp7z20VOkudsVqq3j" +
+	"OeGtvWOVhDnvvuoOynI6VhVKbaPHLclddm+VRwsd9tpyhwG6KG0tNMuNM0w1YZC1" +
+	"SUMAuLhnLQOupddA65UOXPDKoZRXMpLJUsrlyDY2utozHDrg6uimKZS0WgtDKos4" +
+	"KnPMppbMLnNIaySc5TMHGbaxTuqd6qpHacO527Xh33/xUTIdWeKTmjbsg0PYKnmC" +
+	"1lVSd88uqKGOW10E52BMkmKtkyldBFsScY1nFJZktZQvRzSd5S0O9PG43nhMOVRs" +
+	"OXHDbwU5iQ1kkWZEeZGOqNqS6xHOJZZIhTExGkq6rcObBbGrBOaqc8OmmJTzI751" +
+	"Vi7Tx0LbY0JUgoOEmzhjjnptxIKus546uBtXLO4JkyYP+eAcAAHOD6fr9j9V+RH2" +
+	"S/L/QXTV3dz8SL/T8qH5noZQLPqGwlvR6dhx2TVtfs9W4cn6VF1Rfst5hq6EbM2q" +
+	"dokF7YlT+AevC278qkbLKawmh4pJzRaPv9leNe26uHhSuwBuLK+a3xCu7uCt8ICc" +
+	"hqAubTDuymwW6zBsaun77TDCZizuwBP7lwSttmpSykZaG/3IVw50MThjdLpDuH0k" +
+	"DTDN0e2mvqqKkAmVy9EDwysGysaREKB2NormNHUwj0vgO6IiGsJpEuyQETJyWsUL" +
+	"zZWvlFrieCawpUQgzlKTRwiZJXKyzbD3ulpxiGZ3uqqknBCteytK6wxraGufXo4j" +
+	"6Ql84X68MHo9PTm7GxF43W97OVuPemu2nSInel9rnXmRB4ZmN2FaIWPHWBY1gskI" +
+	"XduCgbTFmxaE5YSihkBIUBZk43EhJxOAqFTkTEgZg/58BOXSVo8zbqfJfApfLFzo" +
+	"w/f/d25jXyxD+I/OeU0dcx/x/aRkaa7TXU9oVlOfGYMm7+LW4ifNnrp1XifHFxMu" +
+	"5IbmiCprTZzImVSR0Qa8znKbkRuKQuyr1cokqPHOIDMit4yc4kkbdortTU60qgIp" +
+	"BnSrVsKMeuZ4NPFFXo3ratpwLFLGtrbRUbc6dxjlHMt30iALUHtqu5g6R2+W8fwX" +
+	"w/9tjnDISkwpFIFITGooZI4IpEG2wm2m2Gk22+NttNFNpstJJJJL4r7Fo9BaHfpy" +
+	"dVdT9v6/JXtG67C17waENSlYvNK2F2WomFGFDQgRHIUKMGMIWE4Qp1LPYVOJ3ajX" +
+	"ij0R2SiUikUutMpXscLDown53VRa5NdNBc3ojNNaETWjiHFD0SSCCSSSCDKT2PSI" +
+	"aiwTiy0mbTO6iKbZNVIZ/GZuWsmDvZ2jyAcoTPVEi8HyYNj0fsH+BpVN61a8JAiY" +
+	"SJvPsFnwgTI1HXbhbNF1FnpCTeho7rSi2EUjT83q/Cmc4nETmio0AIuw3CbLSbKx" +
+	"plU6HxSnZ2X76jMxwG6zEfg/GT47sv4GvUeZiImjSpzqWhp1koVUQmYgZfQYMrIw" +
+	"zgqXzPClmVSyPgXckhxZXzdVcKyu4Qi0aa7hpB4IJs6THDITGdymCiiMCFZjbbD1" +
+	"Zs2RDWNrUlQ/P8x6SH7v7Pz/8fq/1tn9U3lWuTf1JnUUMBZ0zXwlfGtzjVdDGdNw" +
+	"/Wb/TcYvZhOV0yvddt9942XK1inv3hKPY1yG22ftVJYGIHecMa1WHrVRdWNFu82a" +
+	"cxAgPKsqap3SvCX1k9lfXPem9N6bX0uaUbPfM+K4StqpjulMkJsnYV74vTdMY1Ed" +
+	"oFSIZ4/h6sOvXBROO5iA46Ydg4cPQkTnMmYnMTmTOZL0JQOVaKsWLsGxYqhdCCQM" +
+	"UGxBBBEJ7+U3578j0euaooSZ6QPtSOwWKBXnFoZlecqTfq1/RtQ4OItiMpbHqNXS" +
+	"LBpu9xQ9UiKIOt8lmoPPrrV81xoI5KWxvXhM3vY8pR7qqK4YLstYwxOVYstg0KRO" +
+	"i1fLX6rgTrxlmqlbrkE9LEGeIed9k26rGnWed6Nh06p11O87aBEwmLoD3HcEEAkE" +
+	"GRBBBBBEkFZVQUUkTHdrccRvm2/fthj1pS2KWAbKGFox0dOmXvOlr51nWKGJum43" +
+	"BBBIJBq/KsYn0ippp9W01W5ZRjbTSfDNkM7isVOp5Wk82WrJNLTsbRZZzsMYDiQS" +
+	"QQGRB573Pe988yZmZmaB0HgHcz7ZHJKFgkEgyIkiSS9eHnk2SvPDryK1aqqqmtW4" +
+	"PSycD/w8sflE+v8v83/dyIplqpb1llszKa0Kl8tWXbMGzMy8XWnF0X937o/wO4fq" +
+	"0+r7tk9qe2FJ6z3CkozLYqzEKiqUFDKGP7kqsHaWq1aDYcCQokp/eU+vt7uZp4fD" +
+	"vw29FcKUSuratW2rX7I00/UcnqCIfPyP4ftqCVUyNaqZi2P7Lo2/nvtw1Ntxu2Ov" +
+	"M1cLOMOjTdl/Jw/jqwjhrHX7ljvTS0Ng9YWklWliFUpZUiCjOKclNiKmjWdFMjuo" +
+	"dSAo96JmslmGgyCeUmmjEtITqi4DqWXTg4318osVuX2Vfa63aYJNvvZpHIUVXXbr" +
+	"pPMYqxKrXRvoXCGuFnXhSb4SVZtAm6ojtvuIBkdOcqdgEZ6lcZZFN1kPKhJJhRBr" +
+	"WEQyIWkl1hnFU3uys63k4eJJlSIMlKqoErDI6G4EEUnpZfaOrlixLp9DvOUpB4Ta" +
+	"n2/ZW/q+fvPhH07t9H4MT16XESiARMKUE/rVVU3KNwDooJ7dlAzgnD7EhScMIYxZ" +
+	"/mOidHDestpVUIAEgC0t7/m9fLzzvPVb1fK+s+Y+f0Pon6xzJ9vzOD8R9GeLf1T5" +
+	"3aq222kVRIqwftW1VyfHRO+89MPe5zaktbKQr49+/jZmajwxNu3Zk7fVWkSWG+K2" +
+	"a1xZlKFOw5BlJpDTgyzEORiGVhmzt4tctufPV1DsnIxdsV3SbUdlXBrTgwnt41HJ" +
+	"0263X9faPss1y+iNSMUfp/X6ff7/6/TW98cccp1bYjhzq/3uXPJj5bT8/7W+nhNo" +
+	"/69v1+jGyfY/aaf9UV6T6SQPl1Bq30rH6H4yV69J/bdqqKoSHon4AEpmUtPAez+t" +
+	"92Y5lOj2CJ7CYdkZxf0D3R/XfsuFMS/C43Nv5T9sfMZV4L/G9pvd03/3mq9yzlm2" +
+	"xVJVkOV0LvETLzsJRx4cqu6dXdXXuPQcCHb7ePRk7He904sDcwdra7Nt9q7VFY9l" +
+	"7jUQJW14xnuJPn7/TMw/3fPn4+Pj6o/Cx3cXKtqlrD9PRbmYZme3mP9E/y7G36I/" +
+	"LH+Z9Pht8Afun7v7tJGbXiaeU0eH+Gn5fst6/K+NqmUrWijbu3DZSH3hD6nZ+o9S" +
+	"qiIxVVjIQnk5/AzMrhcclKH4STg5bfDDGO33aTpJ0rlQeHwTE4GVRAlhOxMpdgNv" +
+	"3ajAlCIVM6Qe6uKg9yOwUV9eRvl2dAWQKng+meXZoWhDqzCyCFDwHzqlW653rPFy" +
+	"aXH00S9/SI7ZIaPaDOu/U2err6Wt0/RGxFCJ/FfXywJ+Z0NuUscckrzN2LlS+4To" +
+	"ymv403aBj+06Tl0T6Xne5mhKZXrsbvOuKiXR7e6HiOm9CknWsik7Lmvsvrn08oTa" +
+	"aD3VS6R5uebW2codGHht9KN5dWRYyrvSKCuOIvhyuzboi48y0eX0b1ZEk7XR2mzQ" +
+	"lIxgob6yp54pmGTlmwZ30l56vdry8vuvXD4hdHdkDKTAhgiUo5KUmzxNmilIqOOR" +
+	"j4IT356J9N4UeHHbOSSOyBPJ7lSGRJEjG2PX7P+mxdE4E9kZhSbrNHt+LR6oxuXC" +
+	"xtS3UxPlEzA5XpdlqQj4iqskZZ3pmdTpI2hJsTma3b8RF/EoYxU2m5oFB5TT0rss" +
+	"2w8zlr3Bw9jYwgtNtPCzmmpqJwmZzfsew9o+/u+NCiXjuaEvhdu9cDRPzPZbreMo" +
+	"pkxCrlWTi29L4pZEMIlfLbK+xSL0Zqy7IjaLss0ZGYsGcMGrgagM+zilXFMbIldU" +
+	"QarxUPisyxhSqeew68PlX96+Vn81ovsttNN7r2tOwJnj1OGZ6GmypFEL/OURjEXj" +
+	"xamLJXj4pVTillprNqvk5OqCY8vVrvLm3qoKGDgxzLgEkqry6tOg257kmNzyTdlj" +
+	"Q8tAmWAyU3697unetmwupGywUXVcTN9MqL1479u2I2tsRZbvyj68/LNRM01plhvS" +
+	"bN5NcjrrccL8Htyj+BCrHefe9PVPN5zrUH+1Pb6rXdo22uWWd/EfwZZbUr34gOaZ" +
+	"1MdLqLC9RP7u6RSO3a3RxXP8X0wBLkn9FRxLMv9CJEbYsiOpgpUSoa5GSlIQU0ym" +
+	"1JJSRLorCY+OqjQVlihaqBciZcOS7lgmERMS0iZQTN2xVFERDdrxbKJtzCzbbXC5" +
+	"bTm3j1zMs1uqI3AHShpYzQRbTYKYrZRILVpDLWCCHKKFK04Pz6l9+B8QwVBx3HZ3" +
+	"pHj9L3wPqk8LV2RT9q1kZcelVkMztswvhMxRjp826SggOKFASfzLUZH+Trbl452C" +
+	"rv71T9Wht51YV3hXG4QPJdqV3uZz13mwrzVZnjVLbVn+YVe62EzchMqtzShLkKPE" +
+	"dMnTiMTvOqRJbzVhxDI1dd1rQhiTqmcLOhwiEgTPFVyLB/BYxVVJ0qTbe0X+E2NJ" +
+	"5FQil9Im2yK4hAhROqTbaIFD7Kzyqk3ny25Hm6dGXKvdrsl+j9LTNJyMbczUREDG" +
+	"XgVzlti/gxxcK9lmrQmuXy00nPZ1ZnYMCOztzV44ehTr4++n1Tt21RvA1/+natOd" +
+	"+etlwD45o3FOGbqiF43Vsp2VA9kWCP6ERX78Jds3aZdJHuSiVaYad/n73gTnNOq8" +
+	"bUvQV1ck9/tFEv8o/X7P+1ZhaugDmvV+7UkaQ/vHB7fX5WVgRokFFMNzV0S7rpL5" +
+	"fPt5HpdvXdsa8XNCJ3dO64RjAXp5PJc5siQE7p10k7q5MlxQkHbwYYb37js+uXMr" +
+	"XQD53nebkY+JEQ3Kr6j5LcbHtxRKez7rjvN74ZI/binYF32Tatmu8Be6TXLsrqtU" +
+	"SyjpPtDkefbc/yap8EMZR59eNbE1KJt1yzjkr8IrBj8d5+WZHW1FCToyAsXOUEXr" +
+	"Wtq1r5tZb+GoluBz2+U8FT3va2RkKc6WR3ZeNn4iq1okKrUThD2MqptNGqiTJ4M2" +
+	"f9u45+/nwFAQyTz4I8lDKWkdQxJJEruEVFU6mHlMh/SyVffytduOEYY+qcVewuWR" +
+	"7sCx2jKWaQSEq05Vh2otTsmLP8nxVuGAJlL6CQ0fXzP22Mn0O/dc+RzxqdnXq/N3" +
+	"KIZUKGEwHCFgyKwJcqXSyY9+KkWLMIVwWZW84+AK/Bz5wnaLI44LmU90x/EkyBYo" +
+	"YS1EJA9jWfE+/5tRUV1ipCoof2zsjgKQ8vpHUIwQU4hNNSOW4tYulfaqfz6P4wYH" +
+	"GDM4DID3+NqN1ONUA/PfuPMRXS88tk7zKq/wt5RmaVy9WAxsjPw3pHVUomq01Y27" +
+	"q1V1m7Yd2KfWl+O5Zq7729d9zZ0l0p3fEcrJ5YgfbvWje7O3f3xZrowIWRkq4O+T" +
+	"FRyxJpiWo4lFPH3WrGdl4cvrRgQWOs7e+Rm7Fg5SGPs7K8wII3++tGhUMYuglST7" +
+	"5KtdoyntNOHVVlYkvFyJtG6k2rcPNYnRazDvM0jtv9e0GxHtPw9lbsVHo999iMnW" +
+	"ySQyREBBJkSLp6BsnvG/p9faVUKlPzdQ/ZVIRVFqLwVZA3bCzzChJo/VG3vBX5SF" +
+	"rWK1RZmzbONI5WDQJSoSvFrWQPYWLVWpk4wJi851alamk1f8QZvBepyqUITCUW1M" +
+	"PO3E+bYpbGJWorqrG+spHFPy6ovW+piPxPDpvMK9cLBMXT02D897907tO7q6Tqpw" +
+	"mu19VLVj5w68m9aLxrh5pRd60Z1Y7OPlnWyT67h8VWsGO4nUUKiC8Pu5yxhCT898" +
+	"xuvPfY+fhoRK5T5qvf5+ore9q8fDLTyk2u/mia2vXGhbTXwjpwro94vOKUYpdrNK" +
+	"/ilIKJN59XedxQPPGvYqUmlTpq88kgneW7DHmiG23HMo7Zsh04+H7xMdo7xOJJtY" +
+	"eizcYZdt7XbKVK6OL4vQLe/M+3jq86SgU5889oFKfPVuxF3wlFrkIun9efjz79d+" +
+	"wYeN/C+u3m1rd0jFGq9X89KmLLXN2C5Po/veZd64ndf3MKIxsceKwWTeL7MD3i1L" +
+	"FVj6xz2pzr8QKCFNCFKpIp+xTH6JnyBsNsPitQloYgqd1l5g4jhq6cPDUvHlmwrI" +
+	"oOhRQkOJcJfIaDs0KhNWaJJhi4g5WXdYcDKbkpiy7o20IRRpRFyOFooQ42GI3+Su" +
+	"oMuUwozR5RSK47UcIoQsIwhhRiAXHRoVM/c+S9/l9R47JC+j+m/Feaff6jz8TUQc" +
+	"fBu36cbfXyrsgqiUIyVfLNwCKvgnlBRwKKm+brfbFcOClV8LfTPJElZDw+Yw7n3R" +
+	"/39I96pWacn74akmCfZk9N7Hnbmfnm+G9N9IIVf233Vjv2K+dmOqXTgm/cpSxjx5" +
+	"NoTM+aO9xtTisCE1pRXSdT2doOxqKdUb7MQGth/hkgx+xCAlvCV3TRG0Ce6IyQW7" +
+	"O5ROkRaOiwj2YN2coi/fFuizw675bLOfJnWg2VO7rRIEXexnFH3XUPPfxRcRGzXs" +
+	"xpAtbS7eu63smcY2W+6RTU1psvDNdHE51pxd+N1FlWJbYbvu4qRoHx0s6pEIRV8N" +
+	"xbCsclUVRe1t0Tr9/qt689+zMRbOMBXqvBVD8KyFEO9HimPzqLzwaL5e+3ZBPN5Y" +
+	"7c/Kfp4kQCKdTjmOa/v154+n3TBe7/D3+v6r+/voinkqWoitVotACCo664ufF4Po" +
+	"3J6cfruz8fcQTLL13Kd1yNXLle7zzhNiNjuuwY3dvT6en4e/3/ffT7fX3eKmQXX0" +
+	"/wDQj59+yNfHDLb2ngE11HTs1D00z1Rmnx+dfhwbhbzuLp0qd0QHMBspKuzzC3ON" +
+	"dfyL9+3rQfBoYPjz4zsDVN+WG7vLnXx9Tr2sSvtE8MUa1li7Bpqrgl9mbKWWkUrS" +
+	"xt51NbR1yPPlQlNbX2vpMO6OipAZVCnOzMdCcdMd8ANNA3fU9nxFkfotXt+qp9oP" +
+	"k+AQUQa8iUvJUoSVIGwuzKjMpmM+3+Z0JJ9oAjV234RfrNBxtZMos3vCkrhlcmZX" +
+	"JZqK1aqYUg1pqK4fwfD1WX0eSASEKQ/xP5j5X1rQTbnv3OI8ip3bm/IdSENUwIVV" +
+	"CBlkpUlnZ2REw9p9/blysnsiOzjy+3xKhFfg6Y9VKDt267q3dT8u8J9NhYJotAkH" +
+	"UBPU1WdVV2dPq97X2saP9b/I78+d+hJa9dsO8Dq7uuiXBGuVPDdiDl5sgMgCCkTR" +
+	"ucudbu90qcSryhxzaniH091sPgD3KHqWgJEDwpMCgIuFF5DDtnI77sGMf+eGrB8U" +
+	"CUkTW1qLEWR7RSwstGmUIlsNwAQgEqgykQQLO1knr6u1ttq21Hb6I+XSd9/RPL0/" +
+	"pE9I8J/gr8OkY248frxb8ffHG2a4zitLxY9lPyn2k/bD85+59xlp+/KfS6jzTDGV" +
+	"KlCSXUKDuGBA2GxzjS7K6hA7uoAgSlLYS2qL/6jhPn+y2y2u3o2Tt0/s8v7+lrl/" +
+	"tPT9O/Fvbfdk0V+HtoX6P4/h5fh/Zzr65P+z5dyH9HPb4K1fuqT5PuQMhcP2210T" +
+	"TD6Tx8InpqHwj333mVmPK+Lfw/Zy/VOHTmPh/Y4e230Y6cunLw2flSdvb90NP4n7" +
+	"P7x+yfRP3enyjwH7P7Pb7p+s+0w6WTLFVJtJ7fRw+3jh93hw0r/PVq20NKhwUT+m" +
+	"nppNp/lXTSUy24lK/p9p+x+7bhT5Y/39es1H9J9h/LTt/Ha6djhODEY0qtFflRyn" +
+	"0FY5fsE/Dp0+HL/Lb9lnh6YcP0Ym32Y/Rwp+H3k/Kf3z7vTy8I+K+yj22wqny+Ps" +
+	"dv3/tbwj0m1dOmO2g8Kfo4emjSqXi3tw+KtNzhy7Y8PwY/U/sn9o/l8PSD+utZcW" +
+	"37Ph7krkPur4qw0fu31nGszW2itKPy7n5Y+v8W+vzZf2Onp4K8qjB+bb8v8tOH1H" +
+	"B8o/l+O9+G0tG1pa21taN/eU7knnyMCjBUlf4T4Nvg4a8W9DpG34af0dOXz/L8Bt" +
+	"/Lo8d/GXPh9HDFcPhj+ngr92if2dHMPk+xw0x+XptPtbdPTbXxbFcOvGltuZktu3" +
+	"B29JpHD9/l+75T24fcjp/93tG58fLFy/Nc1mOE2PTw+O7a/KsP1dPKz1Ielp65m3" +
+	"Lly5mZmOW2qiqrJOg0SUOpO/Ym4AUdn91ovgujOz4FB0MBZWJO4mPoNtb+7266rf" +
+	"z9zM1txqittGlEv4/jbbCTioBO/q3CKi49u7fnvTo05uxVVX8Y0CiogUNx5JLet3" +
+	"YPFu7NOEC+62c7AwsFCz2reusG9vMFWax1VlAwU1dUyIEhit6aC7Du7M7VdNstC1" +
+	"lXlm7XRkSLM0jajTZqNBA9IW4mqEa7U3XwsODHDZVYjuyTqypLVdoZbqcyjdlRjo" +
+	"dkyjWpGBmkajVWlJ1DzMPPfJIIJJJJPAQDIGiiFDI221bW79r+Dx4685zOUWtrbb" +
+	"fyOzogfCvL38Olr2TVKbaW0vvu6QF5fnnbMxw4f2Y/dynRyqptyw2Smnj++v21rW" +
+	"uHL/Sh6afEfd+rg7tq21/aO38mnw4SfDyY9KYm/9rcSPu/X7Jy8DtpVNp/s39X6P" +
+	"xVjyn28Mf2culqrID0/Z9WNK9+LbXseXB+yp9IezTttsnsw0m2J9HPXrTWa1mZcr" +
+	"Y5Fj9fX8f16/rtx/W/7ccT29K9P8fS2fRp+r4CerERJEebBr/HVX8Y2yv6ZK4N87" +
+	"Oc3/UFSf54kQJDPt4hEQISiNsJ19vv6d5ePOXnLnKlVRMqnKJRN8HOc4eHnBzoIH" +
+	"MpAZ5mOq2Kzf1XTznObSPHfYLFdt2e53f+MGA8zED54z4hfEg7rRJfbXkeq33bpR" +
+	"ebgJAwUvLQPVZKKFSSDRYI4wwgQCBcqqHmqrcrro/+ISKcn/1pVyxUc+791ve+Gi" +
+	"7f91U5/UtURLrEFwxif/K7mLJLLBmTJklllMbAuMlEryqfWitYksSyFR0c9WGSW2" +
+	"NMjKZLbGmSTzVb7Jbba9lttvnPje29ykZaxopllRLYrTpUlc4iY8qqyI5d705MZv" +
+	"u1ZllGstGZYT7z6Z6plQwqduumGQywMcHwrK86pav3RTHhW18XfjLFYyWbjorjna" +
+	"TttpVOBUpg27Ou7MrMMyszLdHBzymitUJ4Tz0dVMpiyXRJDbskep0BN7JGO8mdHV" +
+	"Pd1TStUzfsg4eXuWE9PVt2juEFWDZr24eiXW5DE7KjZzEOuNZG7I2ocWRlLYLVvF" +
+	"GIucZOLIbpOKjLLUtRat4sjIGnHJoJtX59aGaxoZtSn3kjr/BfvvEueqYoavHjKx" +
+	"lfTkQc9PwqlPyjh+1Tjaztea0tZo/XVFD512U2EDj9tVTpSLeu7zGstZacdMaS3H" +
+	"LvcS+9fHUcNsArlVO3L8To+YZW3QdvX46+4ZlyqnDs2vzrkqcOL7lnnrnu8/OY54" +
+	"O1Vp+VBoMO5sxa7ODUmwnEJvqyTdRq22yZN7KutPTVelXigrJvTW7bYeEeJUxwNk" +
+	"NlWq21IcSHn3w6MTx68cHTacUEfeN4zPFzT3uFY7X3XTNafe0tNeKqbVU8s+c5mt" +
+	"7E7erU+HTx2Su+OmvhpwPmcIeHwW7qx29oNMLvh0fHz44pNODegO6ZMEIgYczrCT" +
+	"WdKk8MDFGSiuOOdBzS1zZzVoqio5kOTtbKzi7aNMZgoHKdbV9Dlq7N0h523x9+6i" +
+	"49cdHhy5L3Kdee8uTrlo5JI8MkRs0xx3Jy2Vtbxbho8Fzs+RYy555fVjxRvjk17q" +
+	"u+TeMhUNSCJxOGSaXOJIampROLhmaO2zc6CyY2kbd7PgiY9Mkmm76s3Tx7yp8fnf" +
+	"E1+NlrW6nhoz1fPXb3ymeTtuRGa89uIgybYSRnch0uU2n5K6nymfCrxsnUc7yc9N" +
+	"gY+UCpqeMhw3YTjNExOOB6OpwmBt07D27E2yOkgo92SedsjGFb5T4cKHWuV2M8cF" +
+	"8zMy4FsuJXHLaRIdimuHBprXH3TZTtjDi8eLZ0dKHf427eFdKGF72HenvID6MMOn" +
+	"bCLWNsgpUEoZZG/vyoPxPnHd+D3Y+H3rpjqclZUisODjFbL69xIOG+QclTpogxxw" +
+	"qNO9m2ni+V9vD2uz1tpoxtt5t1PjrlVPhy7WwKnZHuC3ruTKRLY2yUlqGlKqWkiW" +
+	"y9iHnhPZO0rN94N2brW8hut0yR51BrPKXs7JGxb5AnRiZTl2Xq1hpiXy8iczq1p0" +
+	"4OUvW9g8WPrtcenxbXL58ic8LgbnL1I0m4MeNSM4zVJrWW9uI3DW3tqHzluUwxR9" +
+	"+s0Vc0hpweORY4VOtNXbALUCyXLqNFcCR7xxw8jTkStO873DPfY017vHfEhE5xAu" +
+	"lh+U9Pt+W9++O/u05zeb4c7pzjRaWurtlU91y/Pj38bnSo+8PfvF8I5SNJ62aL20" +
+	"QZtJUXrrTO3rYPXw+NeuFWmevi1C41Gt1m2DMqHmySGsXd4XEMFkBpCUlZSTWAUm" +
+	"a5gWmZLEQcLCwtjR0rZplkWrZuMqsNpWrMyvBJ5/Gff5lT3FTnKql0x9H4PU/DTX" +
+	"OxAXime7qULq7DqoaFW7tVaVWymOAghDdEltpIwwyIooHivfPjSHoqKy0NCBIRpB" +
+	"IGQK8fXhPBpMTMhc4OCJWMuxlIYammJ2sgEEXEs8oDopthFpLOUlVTJVAqKGFoiu" +
+	"fFmCKtsq1oM33uOW59vV16cDSvt7p7+u80IySXnVy5lF3Mz5ZLDu9ZrDzoUPrekc" +
+	"9Ie3XnPlekWLviZo7sWzm9WT4r4vmvd4+Mn1zI9eadvv8/FYv0fllb9OdHfmF98c" +
+	"xiihhSVRBRSemqq32pgz4bzMD6OjNYamHHHp0WsLbYyKxZ3mLD52kY91zW6fPB9d" +
+	"GObcd2fPPjX0d4du7bA4tvfmSzb6t9NouC2GU+LHHGJNXK4s3xiY6MfbxT4Z83cZ" +
+	"UuZDLGk0mY/Z/iHrRxSY3S1SG9mvzS+bvxc44Th6JqNHLLC4ZR+p+NfpU+sMTeHg" +
+	"a67ZI7LO0gsjRa278NqHpyOH+PRsdMcqF5x65vjp0KeJjqR4dknzo+Zsle+oZmSN" +
+	"f8ttztuTWnh+4V2fpXP02u7ttibExiUsNhbdfPzh1+rQ09U+enFtXS5qQkjjxMd8" +
+	"MkkY56cYwqZcb6vi222vU9cyYersXMh7cOOI2Y7Viz6BNspac/J9fjp3RQw/gqpU" +
+	"1kIPpx1mbn6DEJI5wLjKElOj3z3XAvFr+HD+fSn8rhs166dJp1CBw82PeVw26dIv" +
+	"7MUi/KQbLXXHt4nPh0fSOYs35zI1WtZGrbfqaOvlNp6VywnitCl7G/RjngwTGOXw" +
+	"v3ThnnFFDb8PHJ2lL1vMzxiXS7Hci9P169PULTtp8MorSZB25VNA4Pw6X609+3Vz" +
+	"WTVcyRy2dbt8H177mEWSRvh8M+vSerjnx/SZfuZ0beIXSUuzna/Om+czLbbbVfTz" +
+	"54naAdd+pE26qa+jh4iOkG3g+U1FmjxmGX6Gj40+jLEntyrIn7/D+T8fy1+Pjjup" +
+	"Bc3CtbNuXO2tRdulIu21ItGsL9ccDt6aEtrxfwXjqcDx58HqqhesQkkFR5Hw5s+Y" +
+	"95rjxZ49Zxzzzs55zny5Y/Trf42ninShp2tC5MykPXPDq/HSuOcy/Hrg+uXOZjhw" +
+	"qpi7evQ+G3aueLbIW2pPLBOXPB2k0qeWcvH8dPX3537NGVVjFVhhjKxliVkqkjay" +
+	"ptqZq2S1WktJVZNtVJa0VtCm2mzbZsiNNZVVSy2ti1tS2Sq3md9hy4638z5PHNMz" +
+	"Ix3IfMkD8jgU/hevg0z6O9vrhfx2u0pdXi4ooddn1WwLTt3u0dtfx13/DwegMQYQ" +
+	"wdp85zgwAfA3hJq69eh7Lu7zLGHl5V6eivCu1elHunTwnjRy61p714uThUcOOcz8" +
+	"O1cqxabWOunLt5Rw9iSJHt3F3y3WWZdtujHhx50iRPHtKachw2vnz8eK369x98Ov" +
+	"hw2vztQt4JRlnK9QFCycOHEpchMB0Ym5SeIlIUMnPFcafA3klDSwWSTX9VVFP3k/" +
+	"KQ0+nzF4rj5wtvArh604+dqCN3Qjz0VcqypVmrlXVlSVcqyiSeckRld1JlJlRlJB" +
+	"zmlk1LS0RqoTfWN3vzzprfXjY+ZUWT9c+ednqsvvSSJCkAXphQSFpCgXIwRJFQeP" +
+	"HfxpU2Op7pg4ZhX80D8P0HcE+tvtafe0PslS2h6bEUphB+Trt9zcMySlFfrXx8s6" +
+	"aKGUneDdfjQ99/yYfX7l9meCDI/bvJDJAQgdu6SzNW3eZlBQykZoKrwo37d0TaW2" +
+	"0DnfHOPJfg278PvnXg+re/l0U+vfj83QmJIyIhDN53JH5Px9XhPr2/DXcY+NzGJO" +
+	"6t1p8J77+GH2+xfbwXyN7S7ySU8e36ZcY2cmX9ZqJVTbyyJ9LNd2Hy9pFJjOJx48" +
+	"YJh9fxDDVU7nuPtjdzVxq4025elJxy5kTGLIXu3JDla90qnLmi/u/hOXSqnQu+mf" +
+	"lpHZt8sRqH7saHSSEQXU251XwY4dOFRt18lS6cUnTgWreu+m18JO/RkmYWb9Oofm" +
+	"aH1PPXk244ZeFEhws+fI7cknaR6D4fDdfBuITwr5+BweumnDtjA5GjvZpuOHS0si" +
+	"Djw9vK9vVXw3M4takTts7RicqcARg31RQ03CvXwCPOWh+DxPrrPL04oI3S1HWXPL" +
+	"V28NsefHEu5KGKEqe8NJPYLCCHQMJCQ7PR5y21rbPLh6zyKm7rpxn60/GG3l6l0b" +
+	"Mqm2VCL8CsOWG2Qe5VVUemVS2xUlz8FNVTjEzB3gTsxNJ2NL8fkcfOEhUaCuYPW1" +
+	"wuNRLHrVBHPnUBbfGqqnLbx2unVlEqcfFU674T6+c8eHON8cbcPxnVY79dPSQXrj" +
+	"j02ctOXInljHDTacJEg5ZB5GNDvHrWNOquSOU5GHgGIrXB8Q3PTh49XFuZnMke3D" +
+	"Pi349tnTc2x78ZbabfvzMff1Q00qpoqlPdKqaqUObw73hT5rm2u3Djb92qrt3QRw" +
+	"acoV3xS8qpNypaaM8CBy9599F75+N8/OM7xre29w+OXpOnjtyeGSEgrypPNCAvLz" +
+	"gjvv0nE4N8L06x27SNPjUeRJEjXk3zlzOGsVtiMq9O5Hkcp2VPh8K+XJ7XZx9Zvt" +
+	"531nPHGb550jpsrvKpnZ7X182tPp4nB2m23Dj50a+PuHwWvHvJzCvWfD1elNOsfN" +
+	"SEgw75bTbwkkc52410eGuLbzmZkZvvVmtPrz195lSMXTdO+GvWa25VN0UMpetNG+" +
+	"NwU07IY+Tmk5PCX1drtxw6VwlEnsyq9FxYhCRtIhPTOT09a7ZutZpiLA6pDtYY3V" +
+	"5igfFU4zU4brTy7ejat64Qejh0SJHTSTZ3u3h212EB3mgeekTleTDmSOOVnfrh6P" +
+	"Y8ntJJ7Pr2KTqnMOYbga2JznETGW1bGqmrY4zLwt8niQD18xElWURb94FyqjnAZ3" +
+	"z6YJ1iOcC2nMPuqLNVQhSiLLqoyCroXV+YwVxq9cddcOZJtS0iqScZGJbLQOBQXO" +
+	"HE9q+9mbo5znrM8crxzyCVKhGIK9qoKpR4L0FF29epznKxmhKoosQGVDU2h3Ay47" +
+	"SFIJE+nw88FX5l03vzu+JfbrzePF0kBSZvDVsr5KaIWZmJzqUoIpQrMhASe/z86c" +
+	"6HyL3ZqezLvn2w0+aVZ7vTMRFUZPLRe7Rk+Uox4XrFfp8/Xz18+/jybiRw7VvURT" +
+	"5MeVT3Td4+Ma5xHFTVt3xxqcror7cx5cZbWPo78+Fcp3j1jCSRIxTy4+XByxM192" +
+	"To8aO6enDlp8Tpwnp5LwvE56l2zffqYlRPPQ4gQywiSLYYacvPXtw/DHocyrt2j0" +
+	"e/enNm57m0qsB8YrRH1Lrhwgi85HTIViqnpHjX5odbWnqdJNpywNzy5F55CTpz3b" +
+	"Offvji3GWujD788zPCvnTt/r5SH4mbMvVznmrtcufVxUd3tFD8H+XCVA9+aArHR5" +
+	"t2MPNpfFspyylwe0mEjs5oJOvfjxfnnNXNbdJPJ5YcaYgXzEbNNe/DNpS95PXWbX" +
+	"Lj5me++lriwkeI4ck6bca2nHauuzfPTyrxRXIm23TPacNjajfNUa97T754q3c0rP" +
+	"IE5Nere/DaZzyBPTHL667M6YMUiwUw84c4W+5rlfVR6zxCzaeKly9x9x6DhaooPI" +
+	"1CNpPHVtq129Z3bpzpOM14nhw8c8mvgVGdYiu3n1jtni6FPTxEt8uOLVAnqxzGvU" +
+	"4XXlc09EDkrS68VHEuLovfh0kKjn16nx2624KnuSnHXYVkIprh8uKrXkxp5Z3aqc" +
+	"aeE59GkSJ0a8drt6aX+06Y9W1WYqdPi+di9Pw6evm8zGnrTzvvv+GSuG79/XDiov" +
+	"H0qepaxPYPTbhXBj1xR4w6Tg6NcOybV4+Om+3X41ItLvfGlU341TWO2R7tSuZO+O" +
+	"3asyajzIENvnh5J4Xw8OuDlfBN8GUCx4420ZVU52z250coXTppy6fELl7Rjpy+nP" +
+	"x28cG3ng7sNCRkisEe3Ltzt62dtbszTgXpLw27ePvRw+vlFcKR0ekbTaMSHDJB5e" +
+	"nZ8vLbTt78dG25fCwkJ//etW1scxPdFsVVsi0tFqS177RsuXJMklSkhrEjSwORa5" +
+	"3WlxTnZfjFJJ8qqYtJkGIYaQX+CRXd/3dKH8uAJ8Y9cu+OcSSPAL6Gs336Z468Zz" +
+	"vNxQRIyXt3dm7s0SAwKIJ5wEk8AwcCHFznBwg8o1kzNO72t3vAPY+sfngZ9dFb0o" +
+	"+X4H6XmWneYezTTiKIZ4CUUD4QEQCdPGmwTwkyTaXmJ2d+i8PAPAvDjERepd2Z2U" +
+	"tFeZqfopOh7VAjAeQ8BPpenxxACAkEQhEExObQ9XlR+e37Iw1mN+ICD34z4TEzKK" +
+	"dyQ5oUQnsRgHH1l1ker09IZ4KIqyrFUOLmqZbKLYUGaGAgOcGgdbwVvRho1lbYNU" +
+	"cdPj1zU4ogY7l1TxfNNPT+zP92ta1Xu6TpY6QeISM9/hrny59kjOErh+Ht2BPj57" +
+	"6L5BzgoCDQAx6HNqd9+Dyvbt27Lq3osAuFDt/Zv5zu78vxMXPz5rDDqp1z+Pi2nh" +
+	"zxuQkFAnqvWm2HD09db9dvJvpZ775mY/Nd5n5du34vVU6F+N+jTb5SesToqJfaen" +
+	"DXwdO+bu81I8knny2dLk+lPtFD493Hx70x8+ZnD/LrkygIFr4AcZGrTDQcMwVWSB" +
+	"UIKC4cStoBZZEzt+9tptwYhbUixKXVLSo3XvhOmipnoTQ+XBJCdfHJ8r47yZmPlN" +
+	"tp88W+HnzreZnj2dX2cPfT3zCQm3ifI8tvCeDfBNnl0nnzDynndrPNObjUhIM70k" +
+	"+Phvzu5niebfbE8NY1HHuJBzqbt41px6TjT2wnuOfnskTlZwenlVTqj+HnLFtEu3" +
+	"oQOnRi96VHqH1D1c+g/IZ9nQp1cZlfv1606UPjEUVw/C6dh+Pz4Dro+bIdOl2OTP" +
+	"vLTZ5+7/XSX29Bv0PSCdHY28GJ5eY3ddXvTet3d8H187Yn31vrt8fNKu1D4+cOuX" +
+	"InT13p65ql8fJv74217Pm/vXbqk3NtnkqrqnTkK7wpfdhA+r975xmcNIp7Twznji" +
+	"evTlp74w9peduGxXiNdczaymNYnPSSSSFdH57db5cA+GzcQeEkOBjPVentzlrtHQ" +
+	"fBtWJ18UIb3yjguww+BUcg8J5eHbljZU09Ja1euOjrmjp59ooZ2hzKN2Qay4mLA1" +
+	"pTOLMipVkiB0k7w4rISoDm5vGxYTTI8ymFxmtm+OGuNY5ZPbcqyxJP8qLkqcrsuN" +
+	"XvVCjgr1Q3zy6o5T0ZznGJlVeY1Td52qu2m5V2aq1GXbu10ddY3rOrpy0u3G0gaI" +
+	"oCqoGaZwMADnKp1up7vrdzvSOe91CCUrW9pWJcngyfSVtIngw8zxCUFzpAJs+tb5" +
+	"Zsn1j4Dp7628zYe6Rgm2wa9FYc1vkPNMB5NQ8Ic3l160dXv1c6zek8W9yRs1O1TS" +
+	"z1rN1EhwklOMD2NGX6ryTXTqgq+B6Y+TGD0AgzsO3XvudNp0bcBy7fASeOUcunRo" +
+	"167Ew2GNnFZG/O7eEsenI5SHrvvWZ2addPjD+TtfXdODuwvq5huPLaODCtE0ntOn" +
+	"L4e8t7dJ5M07bNC1FSRtpsdzzppPfI7dxw1640x8bjJekxsa5Y8VNtjEcBtCWwcl" +
+	"ZTbCJcD8HrfbHN5KHTo4Fp819fe92ONY4erddMSl2w76PG6tcHtZwrlPXKVGjFac" +
+	"1j+rOTbp5jOXJwuP10ofsoU9Td33dv3n1t2cqdfj9Pvyqk2efPmZ48XTl0KlODvM" +
+	"5h0nx+MfdEOnxtt86WaVU/eucz4+eu3ZVKY+v3r850xVTdadrjormihyN/evHXTl" +
+	"OFR1cY65NTCcRp8FenYLLIlUW8sJOnpScPWt7tZIJtsSOmHB33atvt8eF2+HHiQg" +
+	"NCRxrt5ejjpt8Lh0U4HvntHLtejv64WuYovx4cvjudsIfUUV5bOXl6xXKF8KXjpP" +
+	"vQ+fOmXao1fF8OImWnu/i1atr4deV54zS60z0kRUkUeKm8HijJ0r4pFq7Fh+ZW0p" +
+	"aNBfXr10NlfrR0278/Td06Kxn1/HSm+H8Kqdssebvr9V00fgPx9owrAzk/h42KL1" +
+	"67fvfB4VPiUIfGBcH0P4etPoVyKa5fXxT68OOsAuVItPWj1w165dPPO3Prp1euH7" +
+	"9fds6coXoqU5gR9Lj1cVXDfOfUFnHKJcn73553ve94fphI76boE5x5eZtBy+Ht3z" +
+	"2NsO2PGCnbwrDt+Pq4KodNhA28Ozw9e3Tlac0vVRrljGXXjK74Z2eHlKbXHRrpJ2" +
+	"M2gxJI5S8WzbWJB5fOzzK0ngIDK6THQVqb+66e221x72x9UW+rxDexdJ8d+/O9Zr" +
+	"M1mXw8jyxjie+j29RJENvabZofCnhWL1wD3ljj4BcQ54OO0GkHSQe/IN7t4HfjuD" +
+	"tPHLp3KlkOazq8sUy9Y3tjOLJlCzMmaWi4d78Kd+VQ0sVjFFisKSwqlNNSpaCyMY" +
+	"JhUqbN41WLJEmRFsshFLI70wpzxVDVJQOGVDMCz+Yz50FeeCnxee+p0OKhjnr5nP" +
+	"et8cb4wgYO5ud9c665eXro2ZltpaqQ2VAWc7xIg8F9WbmVmuss1wH46NPSq6o+75" +
+	"r6ndGvN2auHmEkDx6GEenCEQjUVKH6S7o7nqeTy/VH1TrvmVfi24LBBw8xYwSNpE" +
+	"8sJnV1c5fbaj7DwBMORMfPLNZvLOcobrd4s2vvkgcp4VXw0SckHZ8PbX4yw2pF80" +
+	"01SGzT3e1kxTTTd04UOGN4uYNHi8W+3ItR+t5UkOHvho7WGOo9fXnnm5jU28kkcn" +
+	"h8ar34DKQz8PS+0UNLpvX12vxVVT4FixZRLGVTCKg7d6NpMKY20fHFHbPHAd9cW8" +
+	"W3B6uvHn1lut71682+3b0eekCcIhIfPBfemlNvtyBHAV/OuTYkcsZ7vxb3PCthAc" +
+	"J5Tp8ErwsxlI0n3rzjvR4rr5meB17QHbhSBLIyHa1ZzsIKrDw6gTDhlwJiwFxV7C" +
+	"TiTvjH4uOQLhBYpFs7g9iZz1eObpyecFTp09Ydve/h67KmyAMb5631VNtmzEgiaH" +
+	"voEEA9jOcHBB6Y5jttTflN4ntsbyJB2kkiqnekzu324+Oz6u+mggPLyZ359BJ5B0" +
+	"H75vv+O98cccbcv12976z0kU9dPnSF745HyYQ33cpPXoOXLOhUp0DfHblUbbed8u" +
+	"lr64ejy5Ydw69Z2I9N+ed8a3ve9zh58tTm3kTpI2VpN8Mb84XPTbiYlSnHxsVKd7" +
+	"5NOQ9jvhPHro9jznCFWeydPNaNzME08nR6LWss1Ouel7em2Jvht075zNukuFDuk1" +
+	"adIWgfePGTgVKdrr4ziPTO8PPDtjuAh51atsnp486Ws04OcX3GrzMsVSx9Po989d" +
+	"4u9uULJywb+G3r10Y9F054GPrm4+L04ZJJkqxvxw8zVtr078cZmaVPNF8eWOnzjt" +
+	"m+Dzp6MOXKqbXT5aKmzzblVTg1w8Fy8+g7bfFrpVSnXPW1fHbb1XDGGpmJERNfAa" +
+	"YbUdLIY1MzGDJvWaVJua1NSM8i0YiLdVbblrW5bVtO8YJSMqFKEhgmDmWUhjLJDM" +
+	"DKMoiZY0CluHGm7ksuQolpmExItaAGFEt1JhFAmUBNrbKCiJTAyJZtArEMXRREHC" +
+	"ZTHBRGRExxlmSkstEbmFe7IABXoWWFGHTOoGks2lkVQKlwsertIkulaYxU1YkYar" +
+	"IugRakIpIA20qUYZmFcabhmNazfPjwNMIdbaUG3czeq/mv+/sp9452V9fRjeX3nA" +
+	"+uetKRd6dGlzfHRVjgAwXV1frY5IFJFDJHyc4IKXOHll1l7lpW8epW5ML2nMCWfF" +
+	"zdoNoJaHyyw0D1bEtW98yTVcnh6l4fNM870OjJT1pY+N9aOlHSOoPVAjvfOy6XY2" +
+	"YjllLzgBwOAG54zy9JMd5d5Q8hgek7RpQ8GnkrxxqqbKdNcHfWnS55Ncmdbrjhq8" +
+	"o7ZUGlvWBfCumh2vHI1+9s962fXxMfAcquYF86TrDOPl1vW8b/pXKecTuBeH0U+L" +
+	"2fGp45XJw718Z9c+sP5PnLvB4ymlt2KlHLXaTto+Lz741xvN7za4jqJInjts1qe5" +
+	"S8qL8mlDH49Q5+dZrXjzpsqcd5m9LldKpvtv4EDZ8DPrN/Putb32490+paWvg7pO" +
+	"vrlKWmnnI72+pedYn31Y0duGm3a9uBOGOHp0h1SV29OedcZxres3mbt32npptw7E" +
+	"xetpdUUOnblLt5m2eaqlyh4KfAeqHL66aztyzHfh69Zol/TfR5kRkieuPNq2+3lo" +
+	"JODHljhPalUp+OsY+bVGsXp3+KNK9OtuXLOAJqZoZPU24tuyRwnGurXKohrzvvvN" +
+	"a1ts2nXKnipqQDwxOu8bJI6ZfCCZCNw6XfbiBozK29Oz5zmLqvm1x9cipT7Klty8" +
+	"pOF329uON9fPvbr1pzeMpPe+Hr3sIHq4+uc3mZ3PLvZO09OHTzESDs426htwdn3f" +
+	"VRW3ZttTnnnM+rHbw7G+GlU7XPMqrzx1qcbOsdvGePMYn1vf33e97bkXTF7M1573" +
+	"x3nTpy0frx3VKHxzqqHTh4ED3htxzp0rR7w7XpnFbjBaMsMAti2WdMGWWphmA3IG" +
+	"ILJKMBLTKBQMAVWSsjIorJMWW8bZqzbphIxqPLNyrUqhpj+j5VOekvjvVUYBwAAa" +
+	"KM8rSbnby5mMvMGZKspWru7uiVau7t3V3cu7uqaSIWAE8B4eAc8bruXXY8ta9Ryl" +
+	"s10jpy+y++675d2EUSCjzzqZO093qYXV3T5vii7tdBPVdZIj3ygmbS4u+tw9U5gd" +
+	"efWVrXZ6tawSHPWTXMsxnk4iq+i56tphw8+ToZ4O5ATgW0MkEcLw296lNsfrDk50" +
+	"J1jPLRV90fWN0hz8XrpcPBenvXi8edeZs4mllq+utW458+TOnpnKJE+E9OPI7Lq6" +
+	"OG1pjRt3w5fVc9jp+Ncu5Uh7FTth7vi3HHbwktHIvTl5d+3CHhU0LhwySh1NMXTX" +
+	"faqcvPWZmV6OkmSyxFrWcJrWi1kksrvvgqr6xW9zj1ymeq4dcNajmbSDkR2mTlry" +
+	"5AnE7fgk9Tk978Fs2pXhPvjltkl3AXoF93yfjrr84+98655556eaKe/TcvX8+tDp" +
+	"+Pi1RQ8fdUu2pvFdMbdPAQGNN8ivU7S9Ryc166k8yJc5IdVFdb88+uu+/zeZveuG" +
+	"j1wuL35UllCnrTCt7IYcNxThFFbQtqjNZgXr60baY2hffWp4+ubvM/NIWzW5Uj1D" +
+	"p8eU+ZTg3naukLoZzl+a1n3vGta8samSFp7nvlKVuVxKevXTjTg2duJ3SfNK066b" +
+	"lwcPF5xw2+0cZJzrx68c3veNZrGOHXbTSSRwPSDE242fCWz4vTsVKYqOF4bx775p" +
+	"0xeOddrOpVXqcPaqqOW22WtV88c4xmZY7dL6ei956V67bbVtWu+nzM5fLQ6pS9sJ" +
+	"RXrzSp0cNSpHqF1oswXg7xoeipTO2OO3gSMFkwqyWwWmzzmd5mSrkIb9W0R4V052" +
+	"4SQ8m/L07yCFN+NEinDh32PHfHDzfDTYp2pF9vXXneZ84x6vcPRzRtDb1rS9KNoj" +
+	"G3tt8trVSm4nKzy3R6xxhOMVR5krVhMyjGXOrVEkqjaow3ghlCSpZNWBcVaxL3Fc" +
+	"Y9ZJpkrnJzlzh3m8wze+XP8uV2KlNuHovYPm99afPmu8VUqUJ47l3jmZl5eHCqbb" +
+	"HO7xlEBFcBA5Jb3t32Zl9tPvd2smGycKE9uyfDQQPDS8Ltb4qBF9a8qnudmpDwX4" +
+	"+wdtdWPrzp5ZJ51IafAcnZAsPkypcqpRFBAcxIYWs3vTR50fEtvnqdcUo/dUXwei" +
+	"bTydGiJ4PFIOWjex8NM77ddunuIT3rfm5Wc23BHly1Kmmj152czh1j2qUpWYqJEq" +
+	"vL10rcCedpLOreZEjlnPpzu3bt2Pe9pIbbhG5VdskX49R4c9PrbZr3tVMdOn17de" +
+	"nw+aNedrTuVI+Pjo67O359n1jijiSSJ9jstJAwAWh6D6ObOekTEOeh3nAr2g7ynr" +
+	"8xXTOMYFcwj5xiIpx8cwczh8LfyjzhSPBt74x6zvdzHlySLo8nCSRsk0eS6TRbxm" +
+	"Z3wnmxmnHMkNhygxjtJKwkU83mOviqqNjty5d4e44KmUaw855t7i6cPI8nbp5Sqj" +
+	"jbpFk2djdy3yk88pG+mJSHbOXfhw58IK24kkSC+DzcXXnNW612O4HXcPOwd+O0Fl" +
+	"8PvuZjsCx5376uzwIG+WIPHLtDGueXTEg7dMzfR0JnnGHYm9idAqLLCyKsqxZVXx" +
+	"lbdLKpppSUky2SmfGld42pFyh9d+861rCugePr6r6xOggdtdPr4hx457uTlQ/lju" +
+	"vcrnltjnbtqu9rUk6cL7e+9cX1mt71d5mJrs2PD2zySR16d72kTx67dPB2rKOy76" +
+	"78XpyWhUp8dXq0t/AX04768zWa18ejz5cuUnls27TZy4O2rxRtxcg11S6cfNoYO+" +
+	"+madlcs6drb67VY8K3zSk4YqtLvupO/Da6JNXUsg3mJLapKtWFixTMIxiMYqYxW1" +
+	"DMkpmVKMqXrbSzMt9/sqIqP+t/93+I/0n5Sn7T+QT8zf0X7f+TD+B4CttqUP4hlE" +
+	"RRRTARIfupD+YUw/Q0KfxO/YVFVv5cOFw/8J24f+hMf6Mf+DF/3MXL//P7Nv+9/D" +
+	"R8PD7NE/L5Y0/73/Q5TalV9v/fbLbfTY6Wd/hbKsn7vhvhcttfh9p/Rx9F7ThpoO" +
+	"zo/of+imn7jnrLbavsef4r/UcA+RPuf3Q+f9UqkU/8ap/+MFIjMqlZkqslsVZsrV" +
+	"JUlRZLa2yy2qaRaWWqRTKzaZooGCAwg+x/nV+FYg+fi2+gz8s/Z89W73ufUfZfMZ" +
+	"rG5jSeX2+tXiLy5tM25ZFqjVUHVXHVO7t3Rjfk7WWV5Xd3zfCC7d74/Bsvzb8BBp" +
+	"uu3U3zvXOnzxjyszB3F1Lpzy88Auvjt8OJfX88hg8tvPa23zrze8IBCEkACBACSe" +
+	"svoy46IiKqqiKiKrmbpczNUAkJJCTVerLbqur773rXpy1c6c7tea+Z7XygAnXQEQ" +
+	"RJmCo+i1VHsgGMnt6oTG4h52C6u8SvLrMP/waB4Bwc2A8sBaDwhBB/o7aeobMefe" +
+	"uPi73vZt7rVet2rb0T0fQ/9rykNCbO/hd3LcnNv0nxbJpOOM9dbX3aauDKzP4RVk" +
+	"8gGChiP3tin+2Ko0zGvv8rm997r3xV1pt67QJwiEFqEG2tbkdFH93DBwDjIPBfPi" +
+	"1V5aFeIAHWiKoxX7fYcN7XsJzs2YByCqCB9JkFUVQVTA6PRvzz5effmf8/OC9PMp" +
+	"C+ZtzACFV1K3GMDvG5p00Ri2rRwdRGfGJGZluZmRrhVWSvlPXhbVm0jUeerZfHWX" +
+	"OyPb4dvG7fq7d2YuV64ePXrvx6mb41zvjnrfDiqrwFcQ9VbJCMKmIWYsyFKsKZAp" +
+	"mGYZYsykKYZSrJYGZBVZVDChZKsAxJMKFRiFQZVKxBZKLJJhJTbbapSlmzRec3cV" +
+	"XShD4BDzmq1wkRIYPpUFVy20DjqcYA1wAOHwq+O9r3vWre0sCbAG9xdKyeSrfivb" +
+	"QO34ZArRrbCmGhJ6LPbla+t+POc5nw7qzbdSzdq7p0eJSUbVXZtq6NOrQouWy7TR" +
+	"Es2HZNRu1Stu7Ysi26gMq7VS751zzvXPF5506HQJCRi6HLltz9uN8Xm7zDLmXMwz" +
+	"p7a33LluY0zKuVZCe1T/O/Vl8LrrrqrrpOIUG2dJip/z1f+mv/K98HqwOlWunXPV" +
+	"64nVSTpZbdoyVil8PHTcq/c4iSP+Kkth+WA/sxSm2JD/tMfEf8rSNT+n1kfxMmZY" +
+	"y5UmMVMVJ8ZbwcyYSf/ThUxkMMoOz+R2qaP6HTarlv9RaiqxhI8PDkHT+8nW3ZOm" +
+	"t1jbpR/acHDtXbA6Tww1EzKi2KTySO7N2ZTCkq7jYh702RpxAodJwef/IaXmsXK/" +
+	"lMbLbeD/FpyuGQfEv6LSrGVZhmSxSSgoikttRbLU9uW0NrwxmKrwfsj9zZ07ekki" +
+	"Ej2irVcqtMxjTEjVXdf6P9p/KOcsyr/syrMkfUEhI+3yT4fG7atVVren4qxU6V/T" +
+	"taOFf5Mj/xYPqwPYq8bLlYHT7x9X86t2frOsP+5UnmbJUjANvKTCvZwkj4T2/Xbt" +
+	"J9f3uJLlxpGGJJwQ+9LUNxUfu/pLKj7vl9RwfBGH822fqJ8ukk8mkR2V7eCdNCih" +
+	"4rqR/FLZ4nb6xyNCn1IfeRyyRO0OnsT1CDQ+jZX2q4iaXcThcJadGG5K+NMY2w4X" +
+	"V16pdJLb4bb6ykpDJjVVSiyDx2/Ppatf7fHfqTzbxrUmrdbU+rGg1FD5mI/V8tSf" +
+	"V8o1D9E2nlH/Sfrsr/yHD/OP4SeoUU/V+sYwlSp/5mPQ/3D64aVkKRGlSewWP9VC" +
+	"GFgUGZCQwsROn6CqH9BPpvLYlK20kmjUqRVZgh9aaGzdo/4oxbVDFP9/xGOTxP+x" +
+	"g6H8uhV0ykMME8OXjcocLSqeqxYyhl2P6/5Hp5nNLf8IonRUqUNjY/DbO5llxWJF" +
+	"SKUSsy3EiYhPJ+cGHd98MzE64M+DAkD4YiKRisRkTDMpmR+sxk9icopWw4WnC1/0" +
+	"5aVMf79WMpaf9tje5Pm9MTeot7xUVJUoSR1ibG8TG+mE9pDBpFKsllWe3HKtI8x6" +
+	"SfEmFttpJpEsCWDSlS/NdtwJ44ls8MVRi1bmLU08xzI4bQf8lyf3o/X58cfuZXke" +
+	"jA9K/Wkv/oCpOX8AoptO3imxpWsWZVKaPlFYOn5ekY1bMWGWYopWjCWGKaLTIGkP" +
+	"wFSZp1BRTc+o1ds/D/mY0uThaKlVSilOHlj2XFcG5JxLZUjayIhAAACEhJTX703r" +
+	"bKxG0kYoRihhijZMYwxZWGEbWSBqVDlZMpZTZStskllbfWleql5taVJKGgnkxRrC" +
+	"VSqptInylG2SrIwx+wwoppFCiU2sGh/NQbbQhTFWSmMltqpy9NIxK+lX6Y+UYTIb" +
+	"ZDzMDN6G/c8HjdYsVEVWSZxbtU0dN3q1u3bFRfC4kqOpVSPLo0pZSIiQOFnZ0d4q" +
+	"sQkz4Qqa1DlekfEJApicdLA4a9OMxhyvFegkCmuM2yHU5NScI25iY4U24jHLltts" +
+	"7StNCk4frJzwu0Y6VjDDFk5RppNKqlRASOcpVq3MyVYiVt25mTCT+oTRDRPR2CKq" +
+	"KWrVqlUrlqaNSrjDopxKbp6upXldb1PU9s4hJGJA1VbLTiRJ7eok2sM+UHLbthMQ" +
+	"UFfLLbZVqqyVK+p1Equ3tpthzYl7KWLEMTEq4Ll3YoV5stLbid+m7alklmvcxMyY" +
+	"aGFGVGL1wYwx7R6xjFy7cn0pouDotHyZkzo/hptTZOkPyO1emWMxhjZLl04IdDYK" +
+	"mkh1kK4y2TMxcjHDmvtbZMWE+zDHXCnuD8yQLIjg4UlcKxjHr9gopzYxfuda1rEs" +
+	"eHCK6OCQ6xT4Pju3n5/X9kkiEj6cN+/vl+uaZ5gYN/g5JlAUHSDiUhoOAhwMFMVB" +
+	"c3DDHMN3DFulS0xrgWmW4W5cMuZhWta1rW21tbbRzrJVtBe+ulvYM/s8dPjcuY66" +
+	"qqqisgnSPat2gVwbVEysKVgXdk1QJsk8RJCBD2v8tenlrnM3edFeqa8Zu7mq1raU" +
+	"mEZP6xTGt6zMkdvq9uZwdp7PTR2nSvKidMcnTDZCbRQfLpsjVtrN222z1LI9jbbS" +
+	"Yde7dtk6DgycBMmW9OTcaTFMfB8NtuYiTvVscobNGKRo6Wb4zDniY3e2mSmsjJQJ" +
+	"4EQ2vqQkRVGM8qYh3v0q2rPteqmFz2k1KQNMUOrLk2hBsGYs7NRoFGZ5rKHrKVFW" +
+	"Up3oJ4GS+bM2pvedTh2+z59qcemFaIM+lnMKY/XLM2leOJtTiZEVfbeon1+vwZOB" +
+	"hQgviaCMyAjYhRqyLmywXa6sJtAjY0ekbBVdHErI5ucHJgQ4jsRIimS+VhHvLz2P" +
+	"o9PoKp4fLy9uDHljDyKyG7cVtjlTlwPJ2wD56Xk02ttipijbGTs6TRK6R26babRK" +
+	"3K25I5U6OTolR0fLt24J9HaeVeHM4svhpuNNlYp5eDRNLKaWrGQiqmZbs0Tlo8Bp" +
+	"tppto4ThGn0cT6OnAeX+R8K25e3KOzaUpVttKUnlUhZWFTasOmERzfpmb6O47lt3" +
+	"Whna6EmiB7nAKT0eA/sERTa2uhyCini85zJ/DpU/B/+m3fJ/wH9Y9AkiPcclOX2Y" +
+	"n/g2elK/4y2ikYKwUzMZcuJVFe362bbaGluwykCmE8ysyzLFrmryuvj1Xz/S9/AA" +
+	"AF15cn4TbNPgsRs7cOFV/dG3g0p+7T5dL60/tdkgpyzk/3v8imkP80cFiv6KUxX9" +
+	"LGz9Vfy9n0NI+HBMGjFPGRfU20/oK/wT+7+V6CiR4ktktkvJP6O5j9KtpUGP1T4k" +
+	"kf+7GZWMJ/d/NKP8Ksq/q7hRyh+q/vOT/iN1f/NGJt/f9yWf5H9z+wKWITjGZjP2" +
+	"GmInSyTkRo2qVStSThT8HxX8MximI2dIqo04dIbQvxbWO2MVGkVTxHSI0R/h0eev" +
+	"LpWSyT2p9GP8P1y2m2c1q8325VIvE485eDI9AlOHKGBw4JhDiv5HUmnSO00Q40Je" +
+	"rcSSy5GXLGVUp2n0eDpFE6T4Y/r+er5YqJai+n4MphhmLSwD8QKQoGSRJ/o+6YvW" +
+	"aSVmfLS2qpnMM9WmHTRzMJxy0qHVaVETOYZ1ScEwOJ9g0NPAmjGk0rStNtsbQ5MG" +
+	"2BivKYNI9Fvbiqv8b+qqdv6PL9GI+O0lco7fpI4cEi8XLlw2kn5YnpWFTwgTabky" +
+	"liH7Ax+fy+323r5BIEhez17ddXMxVVQFUOdlCkEiQJigNAR9MV9a+Xx16vk7dzgH" +
+	"lDoGcCQ74xnfnz3rzzvXO4dlaYNK5NOUkh4fqSweoaJidvSK2eXFtkPPEfCh9Gkm" +
+	"XRyk9PzmZVzMqjDGleXlHlJE5ZMZSrZt/Vu5MHK/2HZNP2ivmSPQ/6qw/Hu3mR+n" +
+	"CmQgJH8fUlH/NlVMZjKHCWNsfyX3+p/53h/1MZA1UFrEx/2ManCu/BiYs5NIwfyV" +
+	"9hsjSn/V9nhY5PhjI7Ullm1JVllLfJtZNrGVSVH0hBWtW0eniUKWCpQplb1tteSG" +
+	"W0qTK02llaKdJIwk+rhGI29xHeDU7WszdtKrDKsoRP1Geg1MyhiYmBApJgHZ+sFf" +
+	"yDkcXDK/ydg+VJSP5sSdLVsKtSHjkwmzZhbIuvbvTXnHN1BiMYylZk7k/LKCYDYH" +
+	"X13JBDq8YZURZWoixpkaIyJuN7+dTwztXv57+nThHDDHBkYhVKpPSK0UGMMYTbsK" +
+	"VqDzx4I8qh0+G90AAla9VKVWaW0s7IZmGGCsGJhhSnC6DSPacu07EkRI5jWcLUjw" +
+	"/d2+p5LbfLw/ft4tspaVjDMYWjCpQqLBUhDSjgT+k9T8hNA7KVTkkn2GnDBRs4gq" +
+	"HgJXCnB8vaJ5e0/l/WLbZbFLFUpVRJECIT7iSv69sHJkTAi1mJkzExpMsxUqaYaU" +
+	"miWTRpNtI5UcttEXFPVdQaiwV/wNOFTaFSaL45y+41lrMYcvR0CijhslcNI/0x5X" +
+	"Yo0kXy7cq/RMSNtOU8qn+U1IPp+mXMmZbhJ0PZ5BISOpVSySG3jR/pLeKmXKxwbv" +
+	"w08D+N6WzGTJkSeyhTax4Km0mkp+2qVI0rFU2n8SvhDnkx7T+ba3mQuaiT5PhZj/" +
+	"BPIPTKvh1If7V05H+Z/nVSKcn+SK/2dX9F/Uvj+tYktW6Y9SJs9U8H2+uGZNORKn" +
+	"w6+2/Cqtq2vpfTblsuXEmsGzllqypVLFYDCVIQ9J3NuEfwGnxGlfyMeYjQf6WRG+" +
+	"x+JPz9kl/QyP6sMY0xZf5xV/I/U5f+p6o7h0sRjp934eHA9K9T3ZcSNLGkno0CQk" +
+	"YVp8JT0vFuFfq7kInwp9TyTE+k95/GX6qj9zhqP1y390T8OTsAJxZv0pBjS09ndu" +
+	"/queeVeI9GunPNTJtIrybqni5552x0a9g4GMHRBAAhHYgg4OGOTGIx0md24x2cp1" +
+	"ws56tnBhyqW7W22GlI2+w+z4NJHpLENNvsSMmLVcLMVj9GSBNLTXNtfwxi4U4bKw" +
+	"MhtuWyY+2mWYp5ttKqpA6paj8vKRxEawvhY0NIfgfiH9z+yajt60n97P+eZ9rS0x" +
+	"W0+VV/0sP8sevxzxZkupTbH8sPl/D6tcrSqnhp05PlHCOok2cFqHB+kTvuQ+xWMY" +
+	"xjkg4SNqTWUt19K/fat9iuFW5XN8JyNMVvGVP7r82PqvjL7jtfwP8yYr+QqSfsJ/" +
+	"jvt2zClUVYzM/e1n9tRN7Zd5buwMVVKqRKoVR2YxVWrU0/hHBU0sekk5eWPDSfeZ" +
+	"dQOaqRT0r4rFtLHeZaEkiKs8vN+vcjw/CGRlxRVkq1SPDFexPt0FOvhPFuY6Tbab" +
+	"lve6MycQ4l0tzYO2m5eZhoWcZUOk7NTTLtwdLblt25Jy6YaTDpixoPYKKYtMSx4V" +
+	"/I+Nn+ZdTDBNJM+LfQOkttkfVOk7faSBw+y2ei5ZhaxgYP9nmnNi2FstI8cfri5j" +
+	"4bHPFumZbbbybHMpMg5WROgw+Q29S8lhiiGULhSjSdtjNpsyIlsyhYqxbcJrYw+o" +
+	"k8CH6HRjSvDSMVFQqqko0xiIclqrGrAw0hpi/ouV/i2foVy/oK1INsn/LKzEnZt0" +
+	"0/TfY/WWsZMkwqJFKpVKpSGE5kJD5cnT5T6BPRj2k+rIH3fSdvy2kEdD9W0T4tsh" +
+	"+40PbR+xRPpJN8azaR9OJJrfGcJHGHBw2OTGMmHPduPz+ryTH3/TGTMY0bTThPa/" +
+	"xbhjyxUTFkr8JJwYmivf1xmZJq2ySlSoJPBIfK/rASBSF+cM/nZk213bMmBX5laT" +
+	"Tg0VqrbakxFiRzCeLg1rQx4xf2Vq/pUjo01d0k/Vy7frMy3JIUqSKj8lG44ZP1xk" +
+	"y5bcTEsHL9YMZLGF+0n1bjZ+MHj6OXau8pg6GVof9Cv/Y9BbWvn632UMYJoMElJr" +
+	"W1JQhbfu5MliIQxxyxlFWYJJSo/lsdkj/9Utg244/f72xHsUqlRVMGPuJWipOBhj" +
+	"qEkxqGNgop68j+4/mhRTtlWMEwwuUKKdDCxGGldP8X8NFUz85NW01rD7NpifMq2W" +
+	"o7dpQsUxivU9S0/zYuHDin8gytmwSEj4WYqVwrKqFn2kfvYWyx06X1X93T+Vj5iv" +
+	"X+C0fH6nAMNqMKFVXg8nuEYKKk2Rtat7V7zXsSJCUSSRT1tPuvGtNOFnGGB1Pnt/" +
+	"MW1VDT4EQ56UUWLFFBZqjHB69cXANNLJbE0k2zdlNHR0OU056txtowmLOO1WSsa6" +
+	"mpA1B7TlxdF+0uvItZVay3b0whrGdccXinUpEidgaTHSdubVUqqtqqabViKw14Em" +
+	"JmDeVXXLyvKySljtLGMq1t/wTEMgWhujLDJRJgxkJlQy5UMlB40srBFeLlq7bpq9" +
+	"ptq0rbSxohSrCmSRMyzLLLMSFMMqVksswFVkqTKplkqwklGCsCyqplQsWLGMZZmT" +
+	"JwN3COMLWLVtt2fFUij5Hs/SR03sfZ5nglZWZjJSqn822RTBpyxvWHlVKjTbGVtS" +
+	"KqskrbRpKaRWKlUqSk4VwY4cYMNTGkW1bk5Mk2jbg0RUmojT0wxxKQVYhbbLZbFB" +
+	"oqok2slvxSlrqul/g7aXHwxix/68Toof7qkpOaD4wC2yq1EwXZiapV6/hsyJvBiy" +
+	"EnDHppUrseSqqll+rGDc5R6WrvWH+G9by3kboLdJKq9H7sVW0OfMc6vWl01qZLMZ" +
+	"GXXa6QEItcit7KxXTeedbF5N5WV5LJkt1ZLKLEMplYlj+iTA1EdNMJwtIUTETRhJ" +
+	"/Shi7iTFIxhiMSWYFgxhilFclagZLPw+zk+h+o0bMSmKxOFfTOrm2TbWXbWV6uG2" +
+	"zX+jEamLH9lX+6Yr/YLxH1w5c28qRqX++P6v9czJ/Bpq0wP7uyQ7eB+Vf7n/N/A4" +
+	"I+n6Oyqaf8ybStl8Wgvg5aMWKcsqRmLCpH+JHY7+o/ZUcf8bQ0syoa0yWdpVOGka" +
+	"ZNpjvIUVJ+ZH6qhX3fZFanSyHdkYpGWGxtjGKcNMNKwlSpDgp8KdD2cj9bMv9zY2" +
+	"4SHDkmkf2xkDCf6LKQfCpoFaOJ9BoH5TDi2/9rCRhPqSKlR9EcmpFLro0rH4U5fo" +
+	"dOMs3lzLMZaKYNommiU6RuIh0nD/kT7lH58Cz8XLMuKhGo2V06T/Rhf9p9apP5P0" +
+	"/xq2rWqv1erT/PLMqx/K0O2Dg/csyqf8VH92myX+Z8BRTxbZHaYmgsP/J9QmCR+7" +
+	"y/0+qv0fCnyiPJSHCaH4SEiYfT7Hsxa06QsXGmMqTClIxIpRFUn8jGqv7oxG3iH0" +
+	"WUiCZpN8b6/n1+1fkq7ffeV5XQXGJARn3MyZKRCosJhcTJSYUEP9MYaSlQxKRSo4" +
+	"T/usWhVI0Ps/HwzGMyRhR1q2WLastVljMZmYxjw3K6VX+qMduROGGFymqf4nekcJ" +
+	"jClisYLIPl8mk0rZwHtB+viyyk+VPL1HuRApl/cZMDw+MZfZt7Tx7LCpLZS/LK6S" +
+	"W2SkqS0scvTSTnLcGk28PRKVpMSUr4PizlmNNE8YGrZq/51JSfi7Ts2T+5Tuf5cL" +
+	"UaX6LUnQaR5PlE+ZyTiUqVaOZTHx9XDIqqOjpwldJmO7TbfS5VtUwninQ/6Jhf1N" +
+	"p/3sSnS7Y/q9Btj4/60tF5xmT9MwRXPy8PM4fiKUOh/FVVREYiiQhAhEa3qu3nv2" +
+	"d7+q9S8O8rb0Bs06WlE0arExG4ZViJk4YG2Gl1NmRsyoMpaZV7PclFEkhkSN7T1+" +
+	"jx5uV62pGsk5ajBRIogIzWpucxals3vLLZmGWmKYUqcpZRpGE2OC4rasjHDE4E3a" +
+	"VkxkzLZJSckySoFD8JNDSmOGxNtM2uJgwFUYSjFFUqlFGExq2zQorAowoxy2rlV/" +
+	"wdJPWk8RjHBV2lsFjhYX+gysyZkxh0f3RhVg/4UcJ6TuScH1VPy29yH5DloLCqpU" +
+	"qInySSwxRKrl+50K0qqo24TykjydiqiUngn5KlPjr2zMmZmZlXDMt/QmnwPDD7q8" +
+	"JHcLH4WjVHYxiwsKx8JjVH90Yz02rRwptHkY4fT6Ksmn8HZHweLk7kPRGKpyh/eq" +
+	"bPRt8Jw9H0f9riJN29Ik05PjeYzM7a+qenD4QbH4OfJwfZMB9ytJtyhXEiMJiVNH" +
+	"cUPwV4H6o7H3fBXSflFn+Sn3kdp9U/HhSqjtSP/YlJJT9D1KWFG1D7Gn2HR9iD60" +
+	"4ZhiiTUjaPujNmxMUhRQMUxVYpiKFSJkVJXJrRuOpD+nmZJ/LmR07HlWk3VZMyK/" +
+	"m/D6vP7Ztqy2BISPUCQkdu9bzXnqeuj9E79X9hjUSttuMzBuJcLcpmDmXFzLmW0a" +
+	"Nra22stGjRo3xd71/j7CrbuqNuCV+Pn7RiTiM9JJIEgAeHxJdEfM80MFtPnBMxsr" +
+	"AgcxJUHBQgNneHDhd46b0pvHTJccMlKYUIk+5RcOXp7Ryfl0Nnc0n5iTGzpiTkxo" +
+	"FCf/H09mHBodkFJS2Z2cs427TqZEjg2XKgms0uWP9EwnyRTKCH4BWvY2oHETm/gw" +
+	"zIiIJE4SQGl2Ck88xdoqynSIaAsnIZAHItqcqEkc5usa5371h9/ghm6wvaD++Ev8" +
+	"O9O1aUzFPwkL4FbXvIfOvp571rp7GmKUGlYdK/70n+m237Stjy2V0w2w6YfZFPh9" +
+	"Hg06PAx0ppwTTGGySp/LydK8/p8z7d2Zmabu+zmXHZJtVDh9axBEEQczHKc39VaV" +
+	"T4x8bLS/TE/iYRwjwdM0rY+rUH8HTgw/pHI4Jporpt5nzbKmLJH82WyJNK5mnJ4D" +
+	"eABtlKSyi0srSV+jHaGkaf0oL5Xqr49f2cO3KPHdVlOlxT2Lbotv5H7Pq5pfnuZz" +
+	"/dmMfvq7Hqnxosaf5U5j9bbH6/WKPbcO7bK+EPh5IfmR4cj2lOqW0RIh+qOFlpQ4" +
+	"QPJP14ba1ay0a5WMszhMV5f9J609T6PlI9nB/Z+ltJpZfELlyFYfUpiTUrTJy1Ra" +
+	"mlkyy1arGFKjH1SmRptiNFKlHlOxTypVNuJAVJ4ErlpVbYWdnGukOx25SUDvhmkJ" +
+	"SKvuGWZYZZExglQqFSfb9gSRHe26lLJVfZjBJ/oiPHr3rq/pJEQkegQkCw6m6pxf" +
+	"vmXePsQvn9xLQI6KSRQIAG3bEGfh7NUKcK53UPq8OHUkcacJyvTMdOk6aVZtbeXD" +
+	"JrDQwQRBjBWHXQ31cy5mBlRZ6IYlcEmEU04Y4cGEw43ZacPubU5VthDlicPuw5tq" +
+	"27YxgrGOOrbLbUDHk2YqK5Y+iuHLp5DT4+JNH2/Z8HtbEa9pifS5hRZbRbRJLmJk" +
+	"tJK4MBO+IfGu7xq/hYNWnTpGnT2zPJAB7pIdsgDnjwae+mHsZcy3KXSR8U8MMHx3" +
+	"67L6cwtaVLbW0oONWeD2UwAhlkYAd9PyGVl2b951gXi5PVcb8QkPLMTq0gBWTz4K" +
+	"b75X2bmGXKOkz4+PNebXzvhX0lvnW92FLBBb7Y5NtIVito4Viq+U3q3G5KxpPY05" +
+	"fL8uNtqqVHwkaYHg7TTw5Y28GPVWo6bO3c2dGOmk5G3CG38p48S6HjlsNF2N5UG3" +
+	"rhMMNpgtTb7iCOst5UUraeXaRgqdGFNmIlmjFNDbT2JT0+HDbb6fWUsvKq43XF85" +
+	"mSaaDRzytq8wj6ofRCj5SpbawpLGJ941qyZFjLKFSaYxiaJLLaQhJJAkhvLrtqoC" +
+	"ttttq21FiQaI9vwrDxA5e0qy21HycDgaRwSPs8Q8LbbbaEEqJAA+29r5V87e9va2" +
+	"19Eb4CSiIivrXz3xYwYxlsMdqma+mXMuMrKWCsMVUFYvUsRaVppRgxw1JXOMb3mL" +
+	"yozTBtdtNjDDApBMAoSHCRowphkwjDBucNtDaRKMMYKomhyNY0ck0nxv7WzTGIgK" +
+	"aWfqbVi/VMlGxYTH9BkkfLWrfruDbbbdSUqaY2JUcG9pYR+O0/p+5jB/JZUMKxWI" +
+	"qpUVIKVEVQxZMcum5tZISSZskAD4W+H59LNJklKlfGlrqabJQptdXKqVKsqlUqOA" +
+	"aRSiVP6PeBAlSQJCTLBC22236NPq6ejHcSd2rZE7YfVPKyfUT4b7fr8WyefXfb6N" +
+	"MyWzwG2mEp4bur6pan33d8BXGubpOl5ed4jcsltUaNEoRiM8GkA0MS2li5l+V2vw" +
+	"4XIm74fHps8HR/jS/q+HQ8pSv0K84J8+flIn1SJ6+UsU+C0c9Aop1HStKsYGMDKx" +
+	"VVbVX8PI4Q6YTdhxS2Nirbpbf9Rt6er8OQx00quK/pxvKLQgCMAPno3LmmAsuG5c" +
+	"3ARCCJ9nkfLTE07UWQ+xE4dfZtP3VPs7YjtMjphyP+UhGz0R9z8FYVLWVdq/Htqr" +
+	"8qLbe2t9wr6vumCB9f/1f4sdo/2GBgKKf9A+qrofyy5yaOmGMYh/zf7gpXixGz8L" +
+	"+5/xfK/0YL8tv7GR+gqTsvxJ9Ht9VkkLIxYsKqMPDNH2Sv8q0SrVcBPlIf3fwNJ/" +
+	"tUtJJygp7lJ+qPdeOJP8PnGm0/cbR/Cu1iq/DodIqyKlElfh9ROO50qsVPQ/KWck" +
+	"mmleZE/KwjD935YnpOIH6pJJkrJ2Ojg/KkmBVi22RUNKkxWowxU7iMnlaqlgNpJ8" +
+	"pj7iYnkVUWTvh03PCvJ5UwWAO+/U+8rwtQ/m/pYcu7dSLkkqlUIKb4AdxPxWQX6d" +
+	"K8cR/srlNn5QkJHSlU6YlWNKsqyjRa1ZMrLLMYBj6NRJ0TlhNqV6ntwbHC0tcGIM" +
+	"SikWx6q/J86IAjICaXDPuClJRcO8kmItQriaGCUlFzXDGSLiFQTqmfrNOzl03Ole" +
+	"IMWrYKKbCrtOGYDoM00bf+1W6hV/xyoRH9H1kIxEKqEqwhOh0fbf3XzNt1ZIaQ/Z" +
+	"Tcp8CVPCpx/rV4xb9LJRO2FfAhRPU75RFAhEnDwrLCvgVkHFpWj6sNJo0rweXtOp" +
+	"yT+x5Tl0wTwqLD3pVXSJ+5+RtPl5TqEhVD+w7piTk2lwGKf1bfq5W39Vr75V8q/9" +
+	"/wWTBGo2g0WqS2itFWqKtY1WosWrRVYrUaxWiqxasa220FtqxFVbQaNUaotGxFsb" +
+	"axtbSaLbG2tYrRrVGoitRVEa2iitFFbRqi2xWxVtitrFaqNrRbGrVFWsVtrFqoBZ" +
+	"kqzAMyJmCrMpSsxarGraooi2o1WxaqxYkirFkFgSQP+X9/8v5ZP6G0/tc4bk13k3" +
+	"JrvDkTm8Quc3Qw/xo2mMqVokQel047gDu6KK9vXSItvS8kwSVIXbC5SCkWVJiFZg" +
+	"hUtoVKxalLbdMKjlWErKlStSeOmTUeNgu7o2dzriub3bxvGBNRCbu64Y4kT37cPB" +
+	"IVhFJFkUhs5l65OBc/xyiJn9pvMTp04GA55Yats2p3krH/20yE1IIqJ4GE72HU7u" +
+	"YYM8Ubq87w0emUBOg4KzHejc5vnlBVjwWj2JDp78uxUmIZjGSSXv2+C+Vk2buCu5" +
+	"waLzxxtCqTeYuYkzGRiwWkxWMbuiWxbDiVZW3Hey4sc9aW7DLDfXXvBO8UcMOrE6" +
+	"ZHKIJJkSMuZM51ZhDeUpVpMillJZpvURzSaUu8TxmWyQ4sN1HLGJuVCyo1rGYzbr" +
+	"G6nipyrXO7Z7vS43pcWFeb5bU4saY8yVux4640jFLmIWjVTaVtUu6xHFmprC7jGK" +
+	"0oY3kblGmTI1k3ubEQo4klMaSc87iGrnc67p0dLLSaMM8WbgykoqxHuhUIiSVgcN" +
+	"s4ReusZ2W9pwcOl7l6OFfAh11ZNRZnWh576MW2q1bFKxVnLe+3xhp5sO/llybe2u" +
+	"6vZwQiJ63JuaKKNCGBLFFoua715rvMY1dJZyLBbrOZ5XV5qeIKQWC7JDCltJRnjc" +
+	"MWVKILJ3QpiLVSjwUMweGw6NEzJrF1i1Fr4tLGZjFiWmbSyagjBTJHzlDjD4ecQ6" +
+	"82snBkEBIfIt4B0kgWTyUekmpzCiQ5yh1wM4G8SeOG+NNwKdjDrIdZ3nnxc5azJS" +
+	"gWIWMigBFTrbdrcC3d1FulyStyYtcJGJReZlFmTVNTS4yPGPG6m4mU4UpUnHfhrr" +
+	"wWZWNdRvxxpo63XA16Gk8d9EE0Xhw0MmKiDFJNWV25mGqnfPHiSZDmy0tLVotC9m" +
+	"E3s7B8efHiO2NasFiqCyLUrMVTLjOkidBUijvl11NMuFdid4Pnq556pj0CZeWiKi" +
+	"RE4EFhe7nIB0MWSoVFVEKlEgdTKChKRIxmMBSnnMiG9dA90RI90p4oXnQyoVOzwO" +
+	"XmFFm7kU1EJfOeLl7pwCnXR2AkONIgVXEixG8HO3zk2uUXZ4KDRPGOMQcFigu6MB" +
+	"AynwUr5tMSp4Zm3S97lkYwrKbmYdS7N0thbaW8cMcuPGm2iNlkxeVSsrDdwwNvjm" +
+	"OMsQWV0bYCzEe/EuduWNOYe4t4neTnLWQ7yaysyt7Nq5jW3w84tro7rFbxrm3ROc" +
+	"yItTKia31oMVVVzMmKibuKkZYOb3Z3UnBYN1JxUtiasqwcnVw0qRd45sTvWJOrIZ" +
+	"cp3W8pbyud6rMm8TWW/KOlHvrjW2vNJMEmW6wk8+aSBDqHZe3wLGK4+WYxQYao+a" +
+	"FMLu3Zia4DJiYsHLW8vWVSaquNQVVUQ7dSGGWs7cgmMXdseVDzwzwgEvmRsCB5fB" +
+	"QVQXq0Zj5wJrB6UFaTgUTjAXmHe6AjIdsFIpFIYZ5zPJpMFN97axjrOebjescSIe" +
+	"OlxIjJYuYzMCWWMVihKxiTtW+9a1edTMrhldTnO8F0E1nhOr4yVONeDjTro3vk4e" +
+	"VFXbfM/6MUFZJlNZZ+RMiADvEl+AAvwQB3/wP//fyr////pgQg94DwHe94+e89AU" +
+	"H2NBDuwvr6eX3b72JJyiefd58+Vd8GQIqkiC6wJSbBm5uQAAAKq7u5JKoSaaqQKQ" +
+	"l21VBRUlVJEKkqkqklKlVSiCooVFg+BcYAA+7T5I+gBL4hzdzp5AMgOtGq4ADa13" +
+	"bYpbuB97AXvu0OR1329gffKPus6EiQIGhBMJE8hNE02U9Q0NDQGhp+qYgkgCIklT" +
+	"0IaaZADQAAAAAAaeiIiUn6JqJgaI2hNGAA0Bk9QAmgk9VJJEyZJ6npNlNNBoZoTC" +
+	"NDaTRkD1BiBEiAiKRKekw0mIBpo0aMTQZMjI00YIkiARpomQhkE1EfqnqNA02oAA" +
+	"Bo53OJuRwkNrkuMUJOhNQiCKMocWFChEEQrUGVTGgg0sMW2bqgkJBgahUxttdb03" +
+	"1poJEQAhSSeqS4RwucrgpgGDRopQUVIkNExkDQSGATIZGCmTCKIkUjZJZESZSaMx" +
+	"BmaRQQFlNGJKRIQihnBz6Pqb1dXa7ucrjgmcuCGgbYNpgK8AKEFIr8o4gKQFwMGj" +
+	"vveHmstx7CuEmmgYnRQhB3iu/mzlcrWdLQASIoDpmY0D1WpCxNppg6VoTStS8btY" +
+	"ssBpPUaC7k8vu+aXzwycRqJj4XNyCaEL8W6PxaWpQ2NtCG2kMTE6TpoDCHUaLpoa" +
+	"W1Dm0upHlZaDritXaTgmhQQNtsojjagMpMIthjtQ0xZUttPCv+T0I+nD/mkZQ8ZD" +
+	"zjB4ZdHI+/AJQaEvDFvWEt9eecKhyJv73XRVYff5934ryHcPuxRvk/OTX8AQBAXI" +
+	"YIooDEBEg2yTSZqtrWliJNFtWstQg22mzaljNU2WpmzNipNtVbdVtq9Gq1bKqplA" +
+	"FijAQQWAEEEFi/vVAFgAq0IILEWRBPH+qAgv4VAEvYexHwNTvPzKQKnq9pQt7ith" +
+	"SFQE3KoT92BcQS5rF1INoi0BQOEBIieUUBAgVIw0feYQlJIxilA5IyloT2iIDEdI" +
+	"qoG946hlU0gdFhujgx6GOFTZJSSpDwQuVTcllZOqH4ZyZC0BlmkC4cCwsYRI2uGk" +
+	"ouXauJiysgW2UY5iFJOlmzOCGH4iZGZYXJxDLdJ5I+okgLjdFcGyxGcTuXzC2QNL" +
+	"MmgZDlHJwpxaWwzw0jjTdXZYSK7Qr5tMVE1KLGpqexpkXBFICAcNsKQUZzMFIgVm" +
+	"knN2YKiGSuBbRzatIQgm+KaQZAS8uDHTnWrudlkM5iRrvStxKFwKKVWkrxS0Gc5b" +
+	"46jB4beDQDNZhiAYwuRpE1mlIxJctXj6hyy5cxgiVA40kzeEpxsaUJjkvd5gjFhh" +
+	"XMuSAhJw0YIxgxczl8mAJ0klHCWrkkchWY7a9j4Nu7SQ0sThJQxDvI40wEU4mYE8" +
+	"5vWPNKDdBTZq8WAka53apCRSSNpCqgUBIEqkKIRCCLDdFlqlxAohLqDOd5oy51ju" +
+	"LwUEYBLpqiqzTi6CEFgheJY6jhnYUa1qiwwzdN4qAkZJTTMxtG2YbaURoLQYUs8E" +
+	"LNMt81O4S4MhIrqC8Y2RJqiBikskgX1Ls0fwJ4OCaGBlINkgmKE6hXECwCkyUOuw" +
+	"dQqIBJJNGXYw2m6AgaYHhuJJJCxy4jkmrBKJZbYWNXa3ElQyVBKsZAmKeWFLmqL/" +
+	"aqWV6VDzrw/jTfYq6/bw8pT5+4NHZ5DpJIDo3mpeN6SJGMka7izeeoko43C2Epfp" +
+	"g4TpoXY3puxOTFNpHLlJkTMJ/cig8exbJ4wXM1wqI/cnSPX4zRN3hNeGDNBlDPCc" +
+	"RjKdSlEXMcLYVo5zrESzdhn5oQgF7Vy7d/xXre3+0a929Re2659oOIpGmnWprpit" +
+	"uWOpOh/bvzdU3UXeNVH5d/XiT9umGfzpTP5/9FU8nQ2l+WGPykDtzW8+x9V9eEZL" +
+	"xXZrntkuw70ekWyrvMhHrucZm9KfynpN9pZTE+0MTHTPffeZ6Ne/Z488WceGj41e" +
+	"xPJ4/IOaZmtZu7us13BA3KgkZGgZhXkEnmKKSCdMrtunVFC2hCzVzNmb4pa9MrfR" +
+	"5L368R+A5cTbzcuFIBItqqa9ZJWrv440HQdtONRRNMqQLRvCoXjJsHsNjp3oqjTU" +
+	"nuUk+tSSqY06SBeONJjOPZlitBWP2Y/a4myrWhja8Y48ITl3w70cPAUvOLu3N73x" +
+	"oNCWxRXKJMZBOcsIiYNsbb6IqgA1MYWCyzFLX46tyDIsrZmBdV11KBpmbcG2jSmW" +
+	"klZqbJwQmXHcfS+kqBbvzhoFYwQVevOaUWDtMkiQ4OL3wfiGhdLDJF2oWKWCGRKi" +
+	"hQlR9vBWB8QPr7h+/XlnwgBkZ6IHoruquvYHPb3d2c9Vu1qFs4DoTfPOZy5eaTfG" +
+	"EbeW2TVkZWcjbLyy5fXm3YKb4ufb/wb81JfR8qaTCaWBkN5OAgOisFhTR2+eXXkc" +
+	"3pGtx5da9R7O60uzr4vD1ctQeFni4kxCBF61C2yR4amYWm6emxGhMsrBSNygglLJ" +
+	"ju41nhlzS1oTvHIJ3iKAtp6aslyLp2Xz4u2mDjOOFZxL3c45xPx8u1djCMsttzHL" +
+	"vlwW7OA48Dxvhzz0vTvl3lSnfgXC1bTvQOQPN9u0GMqUZDiUu+0SqNTncw4JrOJd" +
+	"C5ae2h229JhHJcsamPYtGY2nqSYKK7ZkCWcOaeo6wnA5uE6UmOicOKSlx01thtO2" +
+	"U5RWOvTw6+Fysmd8Kd83F6zpjTvnstmbnM78jhR6FmzlfenLa9NuMaGgsxrWUpGv" +
+	"xczOq5bXKtNQPDHEHk5QkHLA7Ei3HDC6vuGTk25mxRUpKKkrlGpasCNz44/k+3tD" +
+	"wDe5wjgdDHrPy8gsg2W5zWGfiMkjEJmgQcnm7BcPMOgmPy6pIvZOyXeDh5m5rpxh" +
+	"u2O72A7GexroWfc4Pg/Hs7+FoQ8r9jIQtaxoXODg+TR8z0PRzeAOoeeRuMi7hdOS" +
+	"81h4GqNyguIRmNhQKnFMJWaZLQzV+urXgFRWKiY8ZIxJo6GynpoUkgAnNj57hPkk" +
+	"CiIEgKoYhUZF/EFX75QYsoLiXAfylQHsFzFbiMlVTCoUCVRu0SOlVOuaqN2WvP1c" +
+	"77nObXJxriiMINSQogBTFkqqmEoC2VXvQXneIkUdJiMdJihT4fO2rWLdy1y9kXJW" +
+	"wjNZBRy2pfGS/8Lwdy9Cmq8fh9iYjz/X4mvTlzXpX65f5J38LH6DNGfi2efIIvIZ" +
+	"10n5NE1kN59vlWXnOfKiq7ER8fWpiWWAkhS+t+LrfbL2atTnX7FlB6UvlXavrdWX" +
+	"HX4WKTvtWbyZlXdbue7pYypbJ5UnERU0llbaJ5ZvPfC98s8bTLO12ZXNItLa866P" +
+	"2611pp3tR1vrwgjnvvzhWTmUw9oSQv1dZnBnZnRGfK8QzR5ObplZCCc5ujfT9R6v" +
+	"JL1s8iD5lDfnIokmLJsX6RI1PafLCcKs/Tg4AkOMBDBIQit/raxnAKMUBAZBr9yq" +
+	"s1/QXIbVpWgIAgmEILgYvh0yWOUmv3jAUfKBfkdBqK0fOeYVyHCSZHQ6VMFk2HIr" +
+	"sD0RNdD7WUaPgRyIZcjoUkiB+YRfCWIeIcpVQPm6Q1BfgQaJofhQUEMgZOGDeJA9" +
+	"IPcCCRV4AUgAYPdw6IdQASI4FnXKQHmcg2w6ALxIMpE3ZaAxxeCoTJ0HTJEbxQOz" +
+	"vOl4O5xZ05zeiMkPQD3Jg7lQsvJS7KCkLTfpQmQlEPQs76EiGVGr9s8U7Q7yKUh6" +
+	"XQJAgcEPOW6rmfKxk0kYB6NnWeroUq8BmBHowHKGqH4gESifAlozD0+eQ0j4kT02" +
+	"LZ4WaPDW2w+IYtHZeImTcCWCRQLWBxyHfijRhjIpsF6jmAN08BB4SheIvMCQv3O9" +
+	"IBxhPz0SkvgHt3FCKbZGAMBDgJArIhI9BSIY8gc5jHmj+E+p9S/UAPryP36WOYnx" +
+	"34Ii7m5qkMm9mPRFNHfnTkYoj0GQr4OOeHrNeCzAYlhhc5B9Dx8dhsYr6Q8qgkWn" +
+	"ZzILYoTDz4BIKReoEWCYEF+GtaVpIuJ9O+zUiaxtJE68pepgbqZg0bMuPgcmlPnY" +
+	"g6RPUYjuCge0Uj8+CFpsWlfLghvvAgHOAUAaHOuBCwTEJ1iNdj0An37bTZlzLF7r" +
+	"i8nzHeJWS8Y6zJjrLCcqH4JHhRMidIZSkw8EIub4C6LDowDzJO0NYq0kILgV0Xug" +
+	"kCCZveXnig8iigRgdCLAPCpCoaA8AMX+M94icjIEiHwoKCEQhEX3HtmPnzHMo4T8" +
+	"NPcs2WZJYUlDwPX7E5AKIDuKSJ5wxZlKKsPwLwU8KDrAPQyZ+Jla9ISK/IHBC8hL" +
+	"AJi8KMiPQXfpqpK+sINQSQJGgioXVwYxvvIhV0sJEIsZpIely4rWA1B7CQPyZJLQ" +
+	"OahcYOxhvMPiDui49WezMfDbrdT686aJ+EQ2kJErap94yg2ISh+eqqB0QQPpBERM" +
+	"BBR+wkAAH2CA+KJEV+wAFcxBkBfIpkCZ2gULsgCIciHoB1hJQ9gIEguUgoVulKgg" +
+	"ntUcGAJr0oJHR6UMgdYB4JHEEfADtXgvEGyLL8+ama2oQMkPuYKfH8tziwAEEz7M" +
+	"qXYXsAoQHsjwQYik4/RunvQcfeEFs6nFYUjPo+WPguYCD9BY7j7j/PYGCWLpEvWu" +
+	"7/IZokD080Zk5wSD1AVqPRbsHEFBSr0sXtjlDoV5UI6IgNFeEvHffv4n0LiGvfQ5" +
+	"KFaH4Gqpz0Mxh9UDG/SNxy6H6DRQBcV+sBle8GiGx3QAXgqTMlrqSTAkr2SSQEFV" +
+	"9QEYOxHymNgdkGXw8Y+fRsHrgXw0GR09kMpCq5MlDiZDzgGOLxJuHDgRqQOet5Kp" +
+	"ezggkS1jSF0MO0JZ2yqQKSLF7UIgkEZK5OM/HYXOHJeOW9vBr8HHbkuWPxox6fms" +
+	"GumVzMqBnqecSQsuBDogwNRVQM9eBnKY0b2gZRHesEG2rOE4hkmdWB6V5y1KgqA1" +
+	"BGhikPMUQmrL7akye+mkvllmGuOkpMekkiTCSRACmrhLIlulAF9N5rthlpQ/XQkp" +
+	"01zssYOxeeIYRSTWbG2KBe2SOKBXQ5DU55aOtIvBbCk+zYig+CBkc6wH3bQOiaPv" +
+	"iscLEZjILNSSmX9OdgQXgna+HtgT0K4DwhmvgWOYSV0NSQuh8OHmg/ExtAoX4Pob" +
+	"q+dVHoXJ7hVNiGlVA2bGEGEH1bRIRBDhCQDs2oQtWIbppQHsVDJEQ2qoEALIiIJh" +
+	"iA5Ibr489zs18KLdIk2wVcpFRBx6+tiaCCj5EMxEzMCxQyTxJ8gAo5ZcS4gmZqKG" +
+	"0IlJiAbs+AEAgERPIieEQN50HzB2KnFiLFTJR7Q0qNQ4QXyCtKqBvJY82LSiEDtD" +
+	"SMDyDTVAlMx1KR0pMIRUiJ7YF7xSGDGU8MEIMgEjhWgojVGuXwHA5gtwUckHgZqo" +
+	"ezI2FDLsfUAQ3ZjoWaTPcjarhqjpVVrhZIQ6SsgnCohVS0itMJYhS0GK7o0K+ky5" +
+	"Y7gH3tCGO3xVQLLkMHlUMsfgQTLECRQxOLscliplNO4omhGOIJICZNgKF+kPDnyh" +
+	"3ErwNoatDOLWiFE0bhwyOBJEYDfGHjaG8xFtMBoWYA6HNgFycuim5Q7p2qoGrMrZ" +
+	"iV9I6DYoCVwCNjaBmh9VIACEQL8wi1kyAWKD09rwynBSL7BDbiUwABZHykpFUzkw" +
+	"tIaZSwCn04GkNoQOlasfSOXAYa64AHCJyMVG81eg8guTY5JtM+Empxh2Tu34PTsv" +
+	"KYzszJQ7oZY4pJ7Ci6JrOjEozq8F0gbgliwihrt8mJA2tda3aqkAfanxBmq2ZHU5" +
+	"0MvBycGZje43sNn5CYiGYNwJBIRNj/EqmR34YYffKj41OKr74Ihj1OnAC82B5rJS" +
+	"xuPCk5SnOICrQbAWFCMDZEMllsNkyUZkhMzrWJAiQm+4YC0K62MK0mlrmIc8DWIE" +
+	"FjI4sXzhL8vpkYEZwSigrGArDcBGj0gGFAr4FqGFQ1SOjTvH0TulJ1XWHAIDBQFU" +
+	"2BL7SBXa+99dSAvxCgIPnOIVhPMmTqqgYRFDUUEsUuxDfjmwMpaAek0+O9i+KyRp" +
+	"AG8DGE3qEdlsT9H5BPmUugch5YLMiAwTAkdnj7Y3zvRe4V3q41uohGNQNXT1Czcw" +
+	"ZOHoCYis+EOsTzziYOV5ZAwqoHrl2ATKFHnpRssDzmLdSlJDg7CCwocglqhuE+Eo" +
+	"jpsHOFogASPtXBwKZ802h3flM1s1tZA8sM4cPDnAT6uS6umbSt9nww6rDoI6wdYP" +
+	"ABwCkD4MpyWUDjtRIBzdU79HbBiX3vcZZGYTeQOlZsLH/hj78oFxFCAR3XQLAaGA" +
+	"dDiPltBD5eyxp0sa6DUCQ9yB3omnTqYzNOQ7dGkZocqlwqH9pIRCGyUGWBqQyCxy" +
+	"ehq7n/X63fbu3lvZivHbt2xc3MNMke2l6Uc4OiBRsMViTMcmSUZzTiouB0cMzMDc" +
+	"MhAn5DyXqlkdoH6TOX/ia/RnX2fHg6KQTF18xSwHCgLERnIs7MqnDBCuu5uA3wgA" +
+	"RixX8J05hR8PDApxlQIJmGtpRVjPTQ4WhDIBRyoZ5o1kdEjBho15A6uhLHeFCwXL" +
+	"+9soCWWtfZsFJSQSLh/i4cADpq1VAz4GFTiJjhUbKosgl7B751ekmAW8qEBkjrpJ" +
+	"Tsj2D0AkIBD0X4qoEMX0AA0zQzao5o5TTzd5LNDKrnPfRfO1p44OgI4xIzjnvqR2" +
+	"Kz5Gwg+DJUL4dAjsyge+pYSePvEmKovgUXXilLjBfO4fT3oTYGwHVC0J2gKaO2qo" +
+	"GfZ3ymu7AqTWofKKHc998pr01xD2hKFgCFCO1eIWDjYeGgvGgWPaFTjzJlNzf2GX" +
+	"XyGuBywpbCI9aM6UO+tOtaQSqpWu2BesY5kXgwTFHTUPCg+y8oeXVwQ7yjsYrMak" +
+	"XS4XXDAJlUBAhUGk7oKAYdKTLFPcGom1CBxTjSRRsoYbfcOs9iE2BKVx8w4aN9z7" +
+	"7xds1BTpEnKyEY4TEIk3XeTS9hcaRANIX4k22qCDj84dwRJjo5YkxitJJAO9xXTk" +
+	"OFA/MS7JYZDxNviHhoYrl0bDxFvhTQwSQimhAnQFiYoaaHrMgkYrCOGBtDa5Bmne" +
+	"OFKwdG8DmOpCyvhqGYNRcB69KAlJSFA5hCUHKDE4GFcRwyRmEbfPPpveJJIDaQgw" +
+	"rWJ/P78yCMO9svE7GZpvnPSWaCtoEgL2jLabbxBVKIsbSY3YtJJ+NjNh8b8AilDw" +
+	"UPusGoZAu82EYImSRSk5GnwVIKWpSvFeBQnOAdAMuTV9DgEQgQgvrro7JHSHZZfM" +
+	"JCKmTtQFOCceAYcT265PCAg2SE+XhMkKlPgHB9+HTOoLI8s4BJuk9F7wqDCjRw6y" +
+	"D8yVeukRZ7qrFZYrAMMmhmgFDKEdZztkqFY4HuEkfuhz9pTsXzFtqqB5Tv5gsZ8h" +
+	"mh8x8wAfZSHNyDX0vZDTySL94fOjqfD0KHsVflvrWX5ow8Q0QhFVMbcpmX80Ezgf" +
+	"HYjMuA8wLy42E7Sz3rziuCIB2DsghxkkRy0Bzp6FVAA8MKcFvSjqknlxdHAT0wDn" +
+	"07kBQcd9oLK7tKmnZYnZZrh6DrhvciJ0ss6vdzXdwMQKJMWT7tXSHPByoD9hWNqM" +
+	"OwE85ypXmQLQwbXSkJWY6qxCwo6HFcFLCAk6bCVHFyYQc5H6Ezm+mNHD03wkk6j7" +
+	"m480R07W+QkhCKSnJVvGUvBBlRzDZDeeaNvGwHd0PT2wTy2HnkWtuMhkklgK66LZ" +
+	"BC6hKMJnOxOpo4YaB5V7rgiiWQXGCiJrYk4Y59qslhcA8/XJNJQLb+5tUzHJCBgj" +
+	"Qx3GrzzHn6xmZ9A0PtV9dbezpCHExoEDwlrH8dllA4YEY1mhsA0dIPPsj4Mi73vz" +
+	"nrsvJLs5YqABDfroHBg+ShQ0IgOs44NI4F8CIIsVXHQ6z3KS4MOhdxigYOImz2UG" +
+	"gJAuBhpsgLrldXnhNQ4jLCUyTxyhrIrwuyYrqo6MJzQ2Wl3AdDzKOb3Cydryz5Do" +
+	"pHBHMKBNdAOAdXJhYMgMb2s9Fp70MSClw9KpTbdzhHAuMGAtobHQJ2SURvgbbhyt" +
+	"BecsuXl+2jKigzt7goBTjmpC8RowanZdxJOhWjwhwrm99FSiJ2OgLLnm8pnjT1Fc" +
+	"CXCc0JaZijcmjpDACeVTrZneXxGRA+184I985kcHQIQIEFMgWfO635rg0SZSO/at" +
+	"HtcUKa3TZ8OJoImYsgRoKAhiZKIBUsG7yTOFlDFncMU9EG4CMLUKMxbiCaMDYdhs" +
+	"JSKdyLFJCQmviCCLgGuUz81ptojXx2oe4d2iHnAkVSdhzcfH2K2UnIQ9u0F30MHB" +
+	"OBY0UHMYYjgCQTAWMbwXTZQXaOgnfjckJ+BO475Zyfo8/R0NlEMBq8c94sZJiNrn" +
+	"yJ8OoMIDQPjt9uJK8Rk5aFDYbJfWSynwRhgIbQoB0+IsZPFGy4yADzZLYokaBywD" +
+	"CRmTeH5tmhDzPmA2rD32gaqneqHMNqA3FgsMePDM9KB69ebN4HOAhc26eoGFI1QJ" +
+	"m898wsO5qZxBxcWUgvtw5Q8AMEOOJJ8HEEk6B45ZyIoFaB5KW8FLb/M4KYSZIP/T" +
+	"y/DoMk5Ami3wPAH8EyWhTaUsFlQ+g6AEFdgHlJWNLpOCvdk3q+hWdqbTJWRS1dey" +
+	"wOAQwQUmsxpFozUQbFTRcPzhmHw0BxsEHFHdI2kUHjDkRPSGAp3SUo8BEdPPPTw4" +
+	"44KbQ4SZsIKdYe3WCo1EtM7zKTu1VAoZ7hPFDfU88SlCY2aHVSnVAOBA5wzuGlcH" +
+	"Rs8STcvGCu0xIzUFjkwcvlheRAzgRbJkzf/N0YjQwJYrJ16VzC1gueMTW4Rt5rYT" +
+	"IRNwYQYtHOtSD6ShBHOQzP37jm+TT/gvnq0DgyDuezyZv7FGKF8j4kpFLwakHPsy" +
+	"LSDphCyxQLl7xgnr+Pl8wbTsF8dx04kwB75wFRLdNRIBmhw2pH3UCbB9EgE9z5eI" +
+	"BPN3vYxzTZ4nEgVR4qoGQtM+BuGwlgV1WoHG4EaoNASMhGBgXYFRVYIXlASg6LSg" +
+	"GqeHmiyAsDilBBOqQsS4Og5rap1miKqAdUA6AdYTWmgTRQWeULDLBzlSEcEEDJbB" +
+	"4nTaBTC2glnEXi2haNhLoJcdgCNAkhcqbCc44gFrBrre1RE7eydRrtb9wdNITgOo" +
+	"j4QWulZiLl9z7V6DbnFmgcimAjOFhQs7UI75C551aKdXmUEHKSvEOCldH1YzE3wo" +
+	"E42BxwHl9Xk7YSa0g1vV9CriIWOztgqD6DgKN3AvOkS3ODdnTdtll+abk1SRIIGv" +
+	"fALBUOBR7ZFBZ4BUpBnSQ4hFHFEZ473Y3P+zY7O60Rs1LaWqHHIcwa8txlB4jJJE" +
+	"w5YZFHWAZUEtKyoIGdMwDYlA+A9mFgSZbOw4M6OOSmPkMl1OYzvpRASmvvXmUjTp" +
+	"8joGG1lR1cQpEEugzJBUyZnlygzInkeR9IZ+wHyATZQgPmd1ZmIUecB8pAzd6P0t" +
+	"AUK45zvDzCusNxdKPDohseJeeAI6ZvadwEcFQCRCgsXNcDfG6wqIm732cGQgwkIA" +
+	"SKEgydIjIZQ4a2thurU6wysrTQQglytZnEFtKoQOjdqfOmiDah274ym7EDxm9s9L" +
+	"CegGgMopkIt4LQ1Xtb9yBS7B2LUpK7hUpgHQVCXmwmbMOQqGHhGVvfpgEjVDoew6" +
+	"qNbwaB5vajnexW8pSBC73poOsSDMENqjGDoVUvvCS9M4jdfRrEmuQYwM5KDSHMK3" +
+	"B64lqG9DhQ0JoNQHlDlAPccRKnfODi2TDOoYNSZAcBzrUAVglyHGRUI0bMziEWOU" +
+	"JYnAOUMt6Rku3X2Za5l+nJIHiJXNq4xzccGdzaqu4qJJiDRBAN2TBKurol+bv9SB" +
+	"CSAX8+8Hl/r7sZnxy9PYe6Z7cvs98YtZ/SwPrgMD9OXynBh/XzxwXwdWFeXp/iVD" +
+	"kMgNriWpJDP1n5azCg6/xxxEvwpxkfhIP9s+2nQ/fn4vF9+jJ+ngfdWL4CPb5czf" +
+	"UQwvVtZEuz7Om9iWrwP/ePX0KAP0+V9inRoSgybccCP6dPd+K+f24YnQ9YpYUGst" +
+	"TKKFMYQdT2HL0fr+fbVW3qvv1NLVbRWSUrVJUxgSVjWktRaoqKNrFWmUUVMjUUmp" +
+	"li0zKazDabQ0YKDYxZMGg1BpRpYUwpQCMhoC8nsJe4+Dy3Xr8S8ifkOz/vaP7ETx" +
+	"FiYoqdkOeLbBtH+bHadmz2QGsccbGX7OU2D+LhZDxGPjMsOyV+DZO9PSeDPkEcZO" +
+	"SS8UzBJ+ecnUZhlZ9ZyM/ad22YYrjBcAz/3V2B8/JiuT7ED9kw+rGGSGmqTbJiMm" +
+	"LSysmTaS0aks2bSzWlZtg1EpSSYlNkqItCalNFstNttqaprSmpS0pqU1LNFgKpZV" +
+	"srWWrM0lJM1bEW0qbEmiLVtRGZUbSprWbNaLUqaks021KtbS2RlllbMsywtspLGj" +
+	"SaVEzMYk2NmzWptlrJWmSoRZSsptlZZLRGTaNKm2LJmmyUmSWRk0WpqlUZJJiWlp" +
+	"tkjGjUy01TaUkrKzSlLTMzAbNg2KlpJMl63e7/d+ENF1fgGLHuf56NGdqOvg7hSN" +
+	"iHHED5NKzQnm2yaAQJTIxieFJM3ij3X3qh5AHBhk2riuNRvBd1dJNK/o55W5e1NX" +
+	"ks/nngBUDz7INtUfFdK0JrgNgbjAdgkJGRczQCngL6Zh4BT2UW6xEWOCC4FzQuaj" +
+	"OxoBErUsV1z6K8cAICwJGRj6fB5iCC6h8QhiZB9qLr5NFyCenPzIPnc0WwotMInx" +
+	"4sAoHfMU5HgU6hhRBkppj/FgHNLt0ubr4APQXPI06DXqSSyDZid8zuPuLwXKN4cj" +
+	"jq/w8zETQQQXn+w0DiEJEiKh7fzQ5LMfgQXmXrdtA+sBzTIigGxVCwsOYhmJycnC" +
+	"CGplhE8/sdAhQXcsIRJFJISEJE8flHQO6cgR0ZCoE/TcCd+BBP7orIml5zlZgw9K" +
+	"QKKpGkiwgESxpnXK9pYwUAa89ij5sPoUYZjQ0lyAcxQc/xtRzIOJISJHL7Ny0JDw" +
+	"BwZa4MDUFR8D5CCCwzTyVsZejnQapAVGYICC5dDXtXOsmZXMO7mFWN7P56mEGIAc" +
+	"JHHBsharUAUcAp9UrviBIAxJ08i+RBO3Ah2QAgiK4kThwo8sDCf0aftxqENQKMTv" +
+	"TZBCNMVoDJwdi4fVhYNQyMy4KjH6SlEAvexZaMCmxViqK0e1JpDA33Zg0xuGQl9E" +
+	"hiQvQ2FHNA6XqGDe6CB3obIHAhBD+L/2H7JweCnNu3h8F/bQAgQghowH1UAW3ICg" +
+	"LRMWh9MD3nL6B5zvW/rtbABAW7j9J/ubhTjE1Dh6fjPlrh4F1mHx9l6oKaKdL9MC" +
+	"Czogscg9WEHR1P1lXLtPyv2av6+Uc38L73W4ynzSHQzT7n4a9fw9G0pHvHQQT3Ww" +
+	"CpsYtnkcGJdhEoMqdwTQQQWf8H7l+Sm0erEmuPTqAC3f/RC5LqgrQdfyPN+J3eTy" +
+	"V4GlQVzdO0KeqEArm/KUORmgILgIYcAUkDE9WuptiUObqmYfnmExHY8cNvsWx4o2" +
+	"QtFrwFybGSaII/YzOu4hsM00VwmYOAJQ3KQY+rag56UiZKVHIpnxryUn41uF8d2K" +
+	"fszLbyzAkMTuQc1BJQQHPuhBBej0s+yiFTpnRcrVGp26/SPoGgGLAjmBAhpnAPYi" +
+	"hGHgg8hN+hAh0NObgHp2R/M6Jo+S9Uw80pUFedRU1bYFRVog6sTPEHADwMAG0oUe" +
+	"ZTzCfk4pmd1M7BJIMNGsaaugBm+bdBpLDSNwIBiBVKx5dQgre1pCrhP2FD5vX9bb" +
+	"a28/PP14155vN5a8GIiRRgLCSaKIJMBu9u1u/IdZNWhKp6tcoZGbueNNIlSQLYOV" +
+	"guF/I1QEFvm6liJuQ/g648tjVjId/WMg6iEQnkcuhltYdGxoELryIDySIMiK9wD4" +
+	"MbBiPihigLkeo0OhARBcol9jMSNhf2ITsgILYNseps5hodZnnUYfDxJFi4UQzXNx" +
+	"EsQsWIsPUhf4XvqFHwQ+WPfTBIHct1LIZYv2+juqALF8D9dhxOkM18bdDBT3QEFx" +
+	"IIWRNxv+UV8R+J/0R2XJbrEIOYHU+pkgRzsDEdIZEebTO4gQJeqofJbdkqra4esL" +
+	"roGjHL6Gsy4rZI+PElgZlHIH1++YJmDEhF6psaR1U3IWVmpF3VwE9oiTMpi8Nzz+" +
+	"aHRDUDwW+WIdt3zPNOewJzPCB9E6jmCYHFX8LoITudMz7/N1SyV8kTcL0XLh4A7N" +
+	"JzfBgyjFkYbKgC8xPTQ2NEVHr3NX3I8oB8QLJn4JCrIRrrR5SSiELOBCqIlECSOq" +
+	"AgtNF/5UYIUAbvmgBgPL1xIT9UkTRqqrX53ixpCNGKHEwP1PwJh+ma3ptrBwODbq" +
+	"SORcDEiR6PVwOxokOUEsjBbkzcaucQzU4IBkiIQDSXJdCotjbIzzDs8lfNscXA3I" +
+	"EjvBoCBmX1Xq+IE6m5+HREB7xUkefMhRTIUUVEoGUY2sxAvjsdB3GZnYoMTuuOZk" +
+	"0IILqZh+sKgLQ1ULBUF4SYf1u+nDkki7SjNoBQWIGv3PuY3TIDM1QtuJ3SNep/DE" +
+	"5GEdQMHhYWdISJCEh+RRD7S+bd8OK+sbha0qU3NES7e5JJCEsxa4lA5ucJdrboo7" +
+	"v42uXj7XKXZXimppWTWQJDU2Uks0imZSWU2bLZWUpEzCgmWQzZKmlstNa2pqlKaa" +
+	"aU0pppMDbLLVlqzSSa2lTEtKzZJmtWpNSkylFpqsptkZrNNSzS1S2bNoqllIpMmS" +
+	"lmYDKLKzVm1LKVNkglKVKmyy0EstNixZmkjEiWms2xGFpVEWVNNKkSaWUpmMKLNQ" +
+	"l1leHUD7BQQf0nxooh+rfDYdYFRbCkgUOlBI6EukdLgodLEh6iosAIZUDGcFIBnT" +
+	"5PfxeXIybIEK3a2JhwXN4a5XZyCUN1QHKuKm53cudZGkYw+CUhgAg4jiFUxQcoWX" +
+	"ZiDnC1kcAxisjx4FhBuB1RLpkW/L1JdQMQyPlqBhAGDxWuoWKaLLctSBSGSu4x/U" +
+	"+UGMFxxCH7+CQBDUTBsMAfQX99QooSAcCZEiD6vqNtZoMtphkjx94b82mEcdDU6C" +
+	"GIfhpBNHRGdiSEhKQ5wXmRP0FuHscjHIQQXE+/JA9QIe5u/rPZ7iGp3RjqDlESQZ" +
+	"JCQm/LYfclj52MSyQjrCotj6Nhs9YNtpjG0eYiFHs4e+RkLZGv6lQVs25H8UcydI" +
+	"dBwSSJWZ2GkMV5JBvs3IEHqRvh5VCbiosL1RQbNSevAFkgodQSGXyDwMAKI48pbY" +
+	"nKYY5o3AkxfgcNu/2TS8/z4OpVwpwYLoslFDS0dpbVLklyLktcy0qrt1rkkVDQKa" +
+	"U5mIfn7qbHUwB+pUzzDYgdOwHNMsQqIeAQgWJ7CdQLne/Uch/L74GbnkIeSHVY7B" +
+	"6HzdzDBZDLh9FDDd7l51/E5mJCBgdFYeAu3YglszcA0yVJwA+V7zU+xXQdNIJq0w" +
+	"kfMItgm3gj2uGRgGUX4BpO2ZVeDftfXE9vP1ve16wzwEEF4VAF3VrV67Ndd89m7O" +
+	"GA6EokveXN9MfaQsQ3ZZKcK50mcwJlSsZTgk98c5KYw84IzEZbkvNTsNqzPLKyHo" +
+	"Px0sFlfMO5q7Gy/RLjgGa3WwaF0oI5J5CEBrzAuFdT9Mc82Cdw1XLYdAocXnucxw" +
+	"MDq4Gb5ImDg/Y1aNUuciSSLGs30w7o64wiPJkCOJGESEZEDZGBLmOHlrwGGQG1zj" +
+	"MtuCoxq7RpQlgtQ/YQ5xHKBJJHiia0FHVsRLGQe6Aj+2KgIUQACACiJEFxCraZaP" +
+	"BqeGpHqJ2lIlZ0RymyqrLMZVKEz6wYDwNnVwEvXcGMYxgkEpwJK03QsQ0IAGhJqy" +
+	"CBkmqpjC2e6t4I+Zf0JUTC8cgiBBIMOpm5aNIYWCqlcG2GZjNkLK8i6B/LSEtoDR" +
+	"RIJtyOGwPFu5CEb0Y2d1QVrHSAerk2mlwOR0esAyQ5waYkWyRMAgkNlX1WA43hGO" +
+	"YdDY3OWXJQzDIuXC51atcCh9k/jjTxk4r31uGHUMNV7DyEEFu9aoidiNHFzHFW3k" +
+	"pl23DYUqswRQLrmUK++C6OIeCEEGO4Oxqcy5rvYfEQIEszhUi+UBMa/NHV+bZCGB" +
+	"BmDsfjN+oGAKjwgfAOjBz3eAT0JSBhgZHiXA7HejAOj31UJ0cC5soXLOxcOBUy41" +
+	"LJM6Q8Jwpx4F2KjgcPvn3BRaXEe2Z4vPu2/yeP+aH5JvaiC4fKQAcndicHNDcD9b" +
+	"ShgrZAQXSGTpCSlPzKD5gwnhsz+p8ujoewiFBY3pKLSeXXMDRxzJq44NJzlzG7rV" +
+	"oWrj1/nLbhdUFc+SIUCENGZwNenyhKIbAqfWTOCRY+YUj3gzmpUR68AgUjUPy+0G" +
+	"2hIxUaJCNpMRpoFYjY0WIzNmFoMaNFtEYklpFixGtGxg0UUVJoKiwYNaTRqTKQRU" +
+	"G1Bo221i1VFhYBqNjRFIKqgpJIRS7/L9Xk8v315svJO9OR4u/ONn5FGPE3fMqdtS" +
+	"xkZBu7kta5NbuU8MxyZMYMgmsNmMhnKfGmtyIG2LzBpqWYIbdmCYi0lYLJxwCFFa" +
+	"zJE6zEudHD27ZzbOeSgpk/HnkQbT7twqaaJXNvUzMuUt1hyhU7ceZcph42+VTlXU" +
+	"cZ9UZZJyYojLjaeJHfJU1UZUEmBfLumu8yW5skuyE9uh2BmVxJZi6KxaXBNwSolw" +
+	"BqBcQLj3ucNZIYZLYtirLu3brW6UYgZgZJiDIGiwpsgg7g1AITkgM6FHITxDDnGt" +
+	"4SDHzZbL5s8fec5PCq5DOzDRdWS+0h5Y2INZak1D29cpVyb2aVrV3Wlt7rQhLa3e" +
+	"m3ZwPNcXywE2Qesk1XN24HvZ2Xa6nlm8Pf/xdyRThQkO1NjuAA=="
diff --git a/test/bench/go1/revcomp_test.go b/test/bench/go1/revcomp_test.go
new file mode 100644
index 000000000..9256164d7
--- /dev/null
+++ b/test/bench/go1/revcomp_test.go
@@ -0,0 +1,85 @@
+// Copyright 2011 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.
+
+// This benchmark, taken from the shootout, tests array indexing
+// and array bounds elimination performance.
+
+package go1
+
+import (
+	"bufio"
+	"bytes"
+	"io/ioutil"
+	"testing"
+)
+
+var revCompTable = [256]uint8{
+	'A': 'T', 'a': 'T',
+	'C': 'G', 'c': 'G',
+	'G': 'C', 'g': 'C',
+	'T': 'A', 't': 'A',
+	'U': 'A', 'u': 'A',
+	'M': 'K', 'm': 'K',
+	'R': 'Y', 'r': 'Y',
+	'W': 'W', 'w': 'W',
+	'S': 'S', 's': 'S',
+	'Y': 'R', 'y': 'R',
+	'K': 'M', 'k': 'M',
+	'V': 'B', 'v': 'B',
+	'H': 'D', 'h': 'D',
+	'D': 'H', 'd': 'H',
+	'B': 'V', 'b': 'V',
+	'N': 'N', 'n': 'N',
+}
+
+func revcomp(data []byte) {
+	in := bufio.NewReader(bytes.NewBuffer(data))
+	out := ioutil.Discard
+	buf := make([]byte, 1024*1024)
+	line, err := in.ReadSlice('\n')
+	for err == nil {
+		out.Write(line)
+
+		// Accumulate reversed complement in buf[w:]
+		nchar := 0
+		w := len(buf)
+		for {
+			line, err = in.ReadSlice('\n')
+			if err != nil || line[0] == '>' {
+				break
+			}
+			line = line[0 : len(line)-1]
+			nchar += len(line)
+			if len(line)+nchar/60+128 >= w {
+				nbuf := make([]byte, len(buf)*5)
+				copy(nbuf[len(nbuf)-len(buf):], buf)
+				w += len(nbuf) - len(buf)
+				buf = nbuf
+			}
+
+			// This loop is the bottleneck.
+			for _, c := range line {
+				w--
+				buf[w] = revCompTable[c]
+			}
+		}
+
+		// Copy down to beginning of buffer, inserting newlines.
+		// The loop left room for the newlines and 128 bytes of padding.
+		i := 0
+		for j := w; j < len(buf); j += 60 {
+			n := copy(buf[i:i+60], buf[j:])
+			buf[i+n] = '\n'
+			i += n + 1
+		}
+		out.Write(buf[0:i])
+	}
+}
+
+func BenchmarkRevcomp25M(b *testing.B) {
+	b.SetBytes(int64(len(fasta25m)))
+	for i := 0; i < b.N; i++ {
+		revcomp(fasta25m)
+	}
+}
diff --git a/test/bench/go1/template_test.go b/test/bench/go1/template_test.go
new file mode 100644
index 000000000..db4839a48
--- /dev/null
+++ b/test/bench/go1/template_test.go
@@ -0,0 +1,76 @@
+// Copyright 2011 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.
+
+// This benchmark tests text/template throughput,
+// converting a large data structure with a simple template.
+
+package go1
+
+import (
+	"bytes"
+	"io/ioutil"
+	"strings"
+	"testing"
+	"text/template"
+)
+
+// After removing \t and \n this generates identical output to
+// json.Marshal, making it easy to test for correctness.
+const tmplText = `
+{
+	"tree":{{template "node" .Tree}},
+	"username":"{{.Username}}"
+}
+{{define "node"}}
+{
+	"name":"{{.Name}}",
+	"kids":[
+	{{range $i, $k := .Kids}}
+		{{if $i}}
+			,
+		{{end}}
+		{{template "node" $k}}
+	{{end}}
+	],
+	"cl_weight":{{.CLWeight}},
+	"touches":{{.Touches}},
+	"min_t":{{.MinT}},
+	"max_t":{{.MaxT}},
+	"mean_t":{{.MeanT}}
+}
+{{end}}
+`
+
+func stripTabNL(r rune) rune {
+	if r == '\t' || r == '\n' {
+		return -1
+	}
+	return r
+}
+
+var tmpl = template.Must(template.New("main").Parse(strings.Map(stripTabNL, tmplText)))
+
+func init() {
+	var buf bytes.Buffer
+	if err := tmpl.Execute(&buf, &jsondata); err != nil {
+		panic(err)
+	}
+	if !bytes.Equal(buf.Bytes(), jsonbytes) {
+		println(buf.Len(), len(jsonbytes))
+		panic("wrong output")
+	}
+}
+
+func tmplexec() {
+	if err := tmpl.Execute(ioutil.Discard, &jsondata); err != nil {
+		panic(err)
+	}
+}
+
+func BenchmarkTemplate(b *testing.B) {
+	b.SetBytes(int64(len(jsonbytes)))
+	for i := 0; i < b.N; i++ {
+		tmplexec()
+	}
+}
diff --git a/test/bench/binary-tree-freelist.go b/test/bench/shootout/binary-tree-freelist.go
index 071a4e06e..071a4e06e 100644
--- a/test/bench/binary-tree-freelist.go
+++ b/test/bench/shootout/binary-tree-freelist.go
diff --git a/test/bench/binary-tree-freelist.txt b/test/bench/shootout/binary-tree-freelist.txt
index f8286dd88..f8286dd88 100644
--- a/test/bench/binary-tree-freelist.txt
+++ b/test/bench/shootout/binary-tree-freelist.txt
diff --git a/test/bench/binary-tree.c b/test/bench/shootout/binary-tree.c
index 1b4070406..1b4070406 100644
--- a/test/bench/binary-tree.c
+++ b/test/bench/shootout/binary-tree.c
diff --git a/test/bench/binary-tree.go b/test/bench/shootout/binary-tree.go
index 9f867d11a..9f867d11a 100644
--- a/test/bench/binary-tree.go
+++ b/test/bench/shootout/binary-tree.go
diff --git a/test/bench/binary-tree.txt b/test/bench/shootout/binary-tree.txt
index f8286dd88..f8286dd88 100644
--- a/test/bench/binary-tree.txt
+++ b/test/bench/shootout/binary-tree.txt
diff --git a/test/bench/chameneosredux.c b/test/bench/shootout/chameneosredux.c
index ed78c31d7..ed78c31d7 100644
--- a/test/bench/chameneosredux.c
+++ b/test/bench/shootout/chameneosredux.c
diff --git a/test/bench/chameneosredux.go b/test/bench/shootout/chameneosredux.go
index 2cb144004..339579862 100644
--- a/test/bench/chameneosredux.go
+++ b/test/bench/shootout/chameneosredux.go
@@ -49,20 +49,20 @@ const (
 )
 
 var complement = [...]int{
-	red | red<<2: red,
-	red | yellow<<2: blue,
-	red | blue<<2: yellow,
-	yellow | red<<2: blue,
+	red | red<<2:       red,
+	red | yellow<<2:    blue,
+	red | blue<<2:      yellow,
+	yellow | red<<2:    blue,
 	yellow | yellow<<2: yellow,
-	yellow | blue<<2: red,
-	blue | red<<2: yellow,
-	blue | yellow<<2: red,
-	blue | blue<<2: blue,
+	yellow | blue<<2:   red,
+	blue | red<<2:      yellow,
+	blue | yellow<<2:   red,
+	blue | blue<<2:     blue,
 }
 
 var colname = [...]string{
-	blue: "blue",
-	red: "red",
+	blue:   "blue",
+	red:    "red",
 	yellow: "yellow",
 }
 
diff --git a/test/bench/chameneosredux.txt b/test/bench/shootout/chameneosredux.txt
index 6016d59a8..6016d59a8 100644
--- a/test/bench/chameneosredux.txt
+++ b/test/bench/shootout/chameneosredux.txt
diff --git a/test/bench/fannkuch-parallel.go b/test/bench/shootout/fannkuch-parallel.go
index 7e9b98d50..7e9b98d50 100644
--- a/test/bench/fannkuch-parallel.go
+++ b/test/bench/shootout/fannkuch-parallel.go
diff --git a/test/bench/fannkuch-parallel.txt b/test/bench/shootout/fannkuch-parallel.txt
index e66f779ea..e66f779ea 100644
--- a/test/bench/fannkuch-parallel.txt
+++ b/test/bench/shootout/fannkuch-parallel.txt
diff --git a/test/bench/fannkuch.c b/test/bench/shootout/fannkuch.c
index e576b5441..e576b5441 100644
--- a/test/bench/fannkuch.c
+++ b/test/bench/shootout/fannkuch.c
diff --git a/test/bench/fannkuch.go b/test/bench/shootout/fannkuch.go
index b554c77b1..b554c77b1 100644
--- a/test/bench/fannkuch.go
+++ b/test/bench/shootout/fannkuch.go
diff --git a/test/bench/fannkuch.txt b/test/bench/shootout/fannkuch.txt
index e66f779ea..e66f779ea 100644
--- a/test/bench/fannkuch.txt
+++ b/test/bench/shootout/fannkuch.txt
diff --git a/test/bench/fasta-1000.out b/test/bench/shootout/fasta-1000.out
index f1caba0d6..f1caba0d6 100644
--- a/test/bench/fasta-1000.out
+++ b/test/bench/shootout/fasta-1000.out
diff --git a/test/bench/fasta.c b/test/bench/shootout/fasta.c
index 64c1c5205..64c1c5205 100644
--- a/test/bench/fasta.c
+++ b/test/bench/shootout/fasta.c
diff --git a/test/bench/fasta.go b/test/bench/shootout/fasta.go
index d13edd5dc..17ff5dae5 100644
--- a/test/bench/fasta.go
+++ b/test/bench/shootout/fasta.go
@@ -70,7 +70,7 @@ const (
 	IA = 3877
 	IC = 29573
 
-	LookupSize  = 4096
+	LookupSize          = 4096
 	LookupScale float64 = LookupSize - 1
 )
 
@@ -178,7 +178,6 @@ func main() {
 	Random(homosapiens, 5**n)
 }
 
-
 type buffer []byte
 
 func (b *buffer) Flush() {
diff --git a/test/bench/fasta.txt b/test/bench/shootout/fasta.txt
index f1caba0d6..f1caba0d6 100644
--- a/test/bench/fasta.txt
+++ b/test/bench/shootout/fasta.txt
diff --git a/test/bench/k-nucleotide-parallel.go b/test/bench/shootout/k-nucleotide-parallel.go
index 96c80d8f0..96c80d8f0 100644
--- a/test/bench/k-nucleotide-parallel.go
+++ b/test/bench/shootout/k-nucleotide-parallel.go
diff --git a/test/bench/k-nucleotide-parallel.txt b/test/bench/shootout/k-nucleotide-parallel.txt
index 84169b8ec..84169b8ec 100644
--- a/test/bench/k-nucleotide-parallel.txt
+++ b/test/bench/shootout/k-nucleotide-parallel.txt
diff --git a/test/bench/k-nucleotide.c b/test/bench/shootout/k-nucleotide.c
index 3bace391c..3bace391c 100644
--- a/test/bench/k-nucleotide.c
+++ b/test/bench/shootout/k-nucleotide.c
diff --git a/test/bench/k-nucleotide.go b/test/bench/shootout/k-nucleotide.go
index fdc98ed47..fdc98ed47 100644
--- a/test/bench/k-nucleotide.go
+++ b/test/bench/shootout/k-nucleotide.go
diff --git a/test/bench/k-nucleotide.txt b/test/bench/shootout/k-nucleotide.txt
index 84169b8ec..84169b8ec 100644
--- a/test/bench/k-nucleotide.txt
+++ b/test/bench/shootout/k-nucleotide.txt
diff --git a/test/bench/mandelbrot.c b/test/bench/shootout/mandelbrot.c
index c177c088c..c177c088c 100644
--- a/test/bench/mandelbrot.c
+++ b/test/bench/shootout/mandelbrot.c
diff --git a/test/bench/mandelbrot.go b/test/bench/shootout/mandelbrot.go
index 1f9fbfd3d..1f9fbfd3d 100644
--- a/test/bench/mandelbrot.go
+++ b/test/bench/shootout/mandelbrot.go
diff --git a/test/bench/mandelbrot.txt b/test/bench/shootout/mandelbrot.txt
index 2f7bbbc6b..2f7bbbc6b 100644
--- a/test/bench/mandelbrot.txt
+++ b/test/bench/shootout/mandelbrot.txt
diff --git a/test/bench/meteor-contest.c b/test/bench/shootout/meteor-contest.c
index 19c43402c..19c43402c 100644
--- a/test/bench/meteor-contest.c
+++ b/test/bench/shootout/meteor-contest.c
diff --git a/test/bench/meteor-contest.go b/test/bench/shootout/meteor-contest.go
index 6660810eb..34a4e23f9 100644
--- a/test/bench/meteor-contest.go
+++ b/test/bench/shootout/meteor-contest.go
@@ -43,7 +43,6 @@ import (
 
 var max_solutions = flag.Int("n", 2100, "maximum number of solutions")
 
-
 func boolInt(b bool) int8 {
 	if b {
 		return 1
@@ -115,7 +114,6 @@ var piece_def = [10][4]int8{
 	[4]int8{E, E, E, SW},
 }
 
-
 /* To minimize the amount of work done in the recursive solve function below,
  * I'm going to allocate enough space for all legal rotations of each piece
  * at each position on the board. That's 10 pieces x 50 board positions x
@@ -138,7 +136,6 @@ func rotate(dir int8) int8 { return (dir + 2) % PIVOT }
 /* Returns the direction flipped on the horizontal axis */
 func flip(dir int8) int8 { return (PIVOT - dir) % PIVOT }
 
-
 /* Returns the new cell index from the specified cell in the
  * specified direction.  The index is only valid if the
  * starting cell and direction have been checked by the
@@ -322,7 +319,6 @@ func record_piece(piece int, minimum int8, first_empty int8, piece_mask uint64)
 	piece_counts[piece][minimum]++
 }
 
-
 /* Fill the entire board going cell by cell.  If any cells are "trapped"
  * they will be left alone.
  */
@@ -351,7 +347,6 @@ func fill_contiguous_space(board []int8, index int8) {
 	}
 }
 
-
 /* To thin the number of pieces, I calculate if any of them trap any empty
  * cells at the edges.  There are only a handful of exceptions where the
  * the board can be solved with the trapped cells.  For example:  piece 8 can
@@ -382,7 +377,6 @@ func has_island(cell []int8, piece int) bool {
 	return true
 }
 
-
 /* Calculate all six rotations of the specified piece at the specified index.
  * We calculate only half of piece 3's rotations.  This is because any solution
  * found has an identical solution rotated 180 degrees.  Thus we can reduce the
@@ -417,7 +411,6 @@ func calc_pieces() {
 	}
 }
 
-
 /* Calculate all 32 possible states for a 5-bit row and all rows that will
  * create islands that follow any of the 32 possible rows.  These pre-
  * calculated 5-bit rows will be used to find islands in a partially solved
@@ -530,7 +523,6 @@ func calc_rows() {
 	}
 }
 
-
 /* Calculate islands while solving the board.
  */
 func boardHasIslands(cell int8) int8 {
@@ -545,7 +537,6 @@ func boardHasIslands(cell int8) int8 {
 	return bad_even_triple[current_triple]
 }
 
-
 /* The recursive solve algorithm.  Try to place each permutation in the upper-
  * leftmost empty cell.  Mark off available pieces as it goes along.
  * Because the board is a bit mask, the piece number and bit mask must be saved
diff --git a/test/bench/meteor-contest.txt b/test/bench/shootout/meteor-contest.txt
index 38d9783d6..38d9783d6 100644
--- a/test/bench/meteor-contest.txt
+++ b/test/bench/shootout/meteor-contest.txt
diff --git a/test/bench/nbody.c b/test/bench/shootout/nbody.c
index 3b95b0592..3b95b0592 100644
--- a/test/bench/nbody.c
+++ b/test/bench/shootout/nbody.c
diff --git a/test/bench/nbody.go b/test/bench/shootout/nbody.go
index e9f4517e8..988f3ba9c 100644
--- a/test/bench/nbody.go
+++ b/test/bench/shootout/nbody.go
@@ -125,39 +125,39 @@ func (sys System) advance(dt float64) {
 
 var (
 	jupiter = Body{
-		x: 4.84143144246472090e+00,
-		y: -1.16032004402742839e+00,
-		z: -1.03622044471123109e-01,
-		vx: 1.66007664274403694e-03 * daysPerYear,
-		vy: 7.69901118419740425e-03 * daysPerYear,
-		vz: -6.90460016972063023e-05 * daysPerYear,
+		x:    4.84143144246472090e+00,
+		y:    -1.16032004402742839e+00,
+		z:    -1.03622044471123109e-01,
+		vx:   1.66007664274403694e-03 * daysPerYear,
+		vy:   7.69901118419740425e-03 * daysPerYear,
+		vz:   -6.90460016972063023e-05 * daysPerYear,
 		mass: 9.54791938424326609e-04 * solarMass,
 	}
 	saturn = Body{
-		x: 8.34336671824457987e+00,
-		y: 4.12479856412430479e+00,
-		z: -4.03523417114321381e-01,
-		vx: -2.76742510726862411e-03 * daysPerYear,
-		vy: 4.99852801234917238e-03 * daysPerYear,
-		vz: 2.30417297573763929e-05 * daysPerYear,
+		x:    8.34336671824457987e+00,
+		y:    4.12479856412430479e+00,
+		z:    -4.03523417114321381e-01,
+		vx:   -2.76742510726862411e-03 * daysPerYear,
+		vy:   4.99852801234917238e-03 * daysPerYear,
+		vz:   2.30417297573763929e-05 * daysPerYear,
 		mass: 2.85885980666130812e-04 * solarMass,
 	}
 	uranus = Body{
-		x: 1.28943695621391310e+01,
-		y: -1.51111514016986312e+01,
-		z: -2.23307578892655734e-01,
-		vx: 2.96460137564761618e-03 * daysPerYear,
-		vy: 2.37847173959480950e-03 * daysPerYear,
-		vz: -2.96589568540237556e-05 * daysPerYear,
+		x:    1.28943695621391310e+01,
+		y:    -1.51111514016986312e+01,
+		z:    -2.23307578892655734e-01,
+		vx:   2.96460137564761618e-03 * daysPerYear,
+		vy:   2.37847173959480950e-03 * daysPerYear,
+		vz:   -2.96589568540237556e-05 * daysPerYear,
 		mass: 4.36624404335156298e-05 * solarMass,
 	}
 	neptune = Body{
-		x: 1.53796971148509165e+01,
-		y: -2.59193146099879641e+01,
-		z: 1.79258772950371181e-01,
-		vx: 2.68067772490389322e-03 * daysPerYear,
-		vy: 1.62824170038242295e-03 * daysPerYear,
-		vz: -9.51592254519715870e-05 * daysPerYear,
+		x:    1.53796971148509165e+01,
+		y:    -2.59193146099879641e+01,
+		z:    1.79258772950371181e-01,
+		vx:   2.68067772490389322e-03 * daysPerYear,
+		vy:   1.62824170038242295e-03 * daysPerYear,
+		vz:   -9.51592254519715870e-05 * daysPerYear,
 		mass: 5.15138902046611451e-05 * solarMass,
 	}
 	sun = Body{
diff --git a/test/bench/nbody.txt b/test/bench/shootout/nbody.txt
index 1731557ce..1731557ce 100644
--- a/test/bench/nbody.txt
+++ b/test/bench/shootout/nbody.txt
diff --git a/test/bench/pidigits.c b/test/bench/shootout/pidigits.c
index c064da0dd..c064da0dd 100644
--- a/test/bench/pidigits.c
+++ b/test/bench/shootout/pidigits.c
diff --git a/test/bench/pidigits.go b/test/bench/shootout/pidigits.go
index e59312177..a0f21a91d 100644
--- a/test/bench/pidigits.go
+++ b/test/bench/shootout/pidigits.go
@@ -38,9 +38,9 @@ POSSIBILITY OF SUCH DAMAGE.
 package main
 
 import (
-	"big"
 	"flag"
 	"fmt"
+	"math/big"
 )
 
 var n = flag.Int("n", 27, "number of digits")
diff --git a/test/bench/pidigits.txt b/test/bench/shootout/pidigits.txt
index ad946a9e8..ad946a9e8 100644
--- a/test/bench/pidigits.txt
+++ b/test/bench/shootout/pidigits.txt
diff --git a/test/bench/regex-dna-parallel.go b/test/bench/shootout/regex-dna-parallel.go
index 1335e4d34..9c6d42101 100644
--- a/test/bench/regex-dna-parallel.go
+++ b/test/bench/shootout/regex-dna-parallel.go
@@ -39,8 +39,8 @@ import (
 	"fmt"
 	"io/ioutil"
 	"os"
-	"runtime"
 	"regexp"
+	"runtime"
 )
 
 var variants = []string{
diff --git a/test/bench/regex-dna-parallel.txt b/test/bench/shootout/regex-dna-parallel.txt
index e23e71fd6..e23e71fd6 100644
--- a/test/bench/regex-dna-parallel.txt
+++ b/test/bench/shootout/regex-dna-parallel.txt
diff --git a/test/bench/regex-dna.c b/test/bench/shootout/regex-dna.c
index 134f8215c..134f8215c 100644
--- a/test/bench/regex-dna.c
+++ b/test/bench/shootout/regex-dna.c
diff --git a/test/bench/regex-dna.go b/test/bench/shootout/regex-dna.go
index 042d7f283..042d7f283 100644
--- a/test/bench/regex-dna.go
+++ b/test/bench/shootout/regex-dna.go
diff --git a/test/bench/regex-dna.txt b/test/bench/shootout/regex-dna.txt
index e23e71fd6..e23e71fd6 100644
--- a/test/bench/regex-dna.txt
+++ b/test/bench/shootout/regex-dna.txt
diff --git a/test/bench/reverse-complement.c b/test/bench/shootout/reverse-complement.c
index b34c84696..b34c84696 100644
--- a/test/bench/reverse-complement.c
+++ b/test/bench/shootout/reverse-complement.c
diff --git a/test/bench/reverse-complement.go b/test/bench/shootout/reverse-complement.go
index baa30ffcc..baa30ffcc 100644
--- a/test/bench/reverse-complement.go
+++ b/test/bench/shootout/reverse-complement.go
diff --git a/test/bench/reverse-complement.txt b/test/bench/shootout/reverse-complement.txt
index 14d792ade..14d792ade 100644
--- a/test/bench/reverse-complement.txt
+++ b/test/bench/shootout/reverse-complement.txt
diff --git a/test/bench/spectral-norm-parallel.go b/test/bench/shootout/spectral-norm-parallel.go
index 2706f39ec..2706f39ec 100644
--- a/test/bench/spectral-norm-parallel.go
+++ b/test/bench/shootout/spectral-norm-parallel.go
diff --git a/test/bench/spectral-norm.c b/test/bench/shootout/spectral-norm.c
index 832eb3d21..832eb3d21 100644
--- a/test/bench/spectral-norm.c
+++ b/test/bench/shootout/spectral-norm.c
diff --git a/test/bench/spectral-norm.go b/test/bench/shootout/spectral-norm.go
index 6667f3e04..6667f3e04 100644
--- a/test/bench/spectral-norm.go
+++ b/test/bench/shootout/spectral-norm.go
diff --git a/test/bench/spectral-norm.txt b/test/bench/shootout/spectral-norm.txt
index b9885983e..b9885983e 100644
--- a/test/bench/spectral-norm.txt
+++ b/test/bench/shootout/spectral-norm.txt
diff --git a/test/bench/threadring.c b/test/bench/shootout/threadring.c
index 2c4fb7751..2c4fb7751 100644
--- a/test/bench/threadring.c
+++ b/test/bench/shootout/threadring.c
diff --git a/test/bench/threadring.go b/test/bench/shootout/threadring.go
index 031908a20..e76dd0b45 100644
--- a/test/bench/threadring.go
+++ b/test/bench/shootout/threadring.go
@@ -52,7 +52,7 @@ func f(i int, in <-chan int, out chan<- int) {
 			fmt.Printf("%d\n", i)
 			os.Exit(0)
 		}
-		out <- n-1
+		out <- n - 1
 	}
 }
 
diff --git a/test/bench/threadring.txt b/test/bench/shootout/threadring.txt
index f9aaa4d56..f9aaa4d56 100644
--- a/test/bench/threadring.txt
+++ b/test/bench/shootout/threadring.txt
diff --git a/test/bench/timing.log b/test/bench/shootout/timing.log
index 2541a766b..2541a766b 100644
--- a/test/bench/timing.log
+++ b/test/bench/shootout/timing.log
diff --git a/test/bench/timing.sh b/test/bench/shootout/timing.sh
index 473c9b312..dd3e664f4 100755
--- a/test/bench/timing.sh
+++ b/test/bench/shootout/timing.sh
@@ -5,7 +5,11 @@
 
 set -e
 
-eval $(gomake --no-print-directory -f ../../src/Make.inc go-env)
+eval $(go tool dist env)
+O=$GOCHAR
+GC="go tool ${O}g"
+LD="go tool ${O}l"
+
 PATH=.:$PATH
 
 havegccgo=false
diff --git a/test/bigalg.go b/test/bigalg.go
index 902ba8410..55a15c30a 100644
--- a/test/bigalg.go
+++ b/test/bigalg.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test the internal "algorithms" for objects larger than a word: hashing, equality etc.
+
 package main
 
 type T struct {
diff --git a/test/bigmap.go b/test/bigmap.go
index 843a15174..37e049846 100644
--- a/test/bigmap.go
+++ b/test/bigmap.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test behavior of maps with large elements.
+
 package main
 
 func seq(x, y int) [1000]byte {
diff --git a/test/blank.go b/test/blank.go
index 681a5e77c..961ed153b 100644
--- a/test/blank.go
+++ b/test/blank.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test behavior of the blank identifier (_).
+
 package main
 
 import _ "fmt"
@@ -101,6 +103,46 @@ func main() {
 	}
 
 	h(a, b)
+	
+	m()
+}
+
+type I interface {
+	M(_ int, y int)
+}
+
+type TI struct{}
+
+func (TI) M(x int, y int) {
+	if x != y {
+		println("invalid M call:", x, y)
+		panic("bad M")
+	}
+}
+
+var fp = func(_ int, y int) {}
+
+func init() {
+	fp = fp1
+}
+
+func fp1(x, y int) {
+	if x != y {
+		println("invalid fp1 call:", x, y)
+		panic("bad fp1")
+	}
+}
+
+
+func m() {
+	var i I
+	
+	i = TI{}
+	i.M(1, 1)
+	i.M(2, 2)
+	
+	fp(1, 1)
+	fp(2, 2)
 }
 
 // useless but legal
@@ -120,3 +162,4 @@ func _() {
 func ff() {
 	var _ int = 1
 }
+
diff --git a/test/blank1.go b/test/blank1.go
index 5bc1efce5..c6e038a0d 100644
--- a/test/blank1.go
+++ b/test/blank1.go
@@ -1,12 +1,16 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Test that incorrect uses of the blank identifer are caught.
+// Does not compile.
+
 package _	// ERROR "invalid package name _"
 
 func main() {
 	_()	// ERROR "cannot use _ as value"
 	x := _+1	// ERROR "cannot use _ as value"
+	_ = x
 }
diff --git a/test/bugs/bug395.go b/test/bugs/bug395.go
new file mode 100644
index 000000000..adf74497c
--- /dev/null
+++ b/test/bugs/bug395.go
@@ -0,0 +1,22 @@
+// echo bug395 is broken  # takes 90+ seconds to break
+// # $G $D/$F.go || echo bug395
+
+// Copyright 2011 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.
+
+// Issue 1909
+// Would OOM due to exponential recursion on Foo's expanded methodset in nodefmt
+package test
+
+type Foo interface {
+	Bar() interface {
+		Foo
+	}
+	Baz() interface {
+		Foo
+	}
+	Bug() interface {
+		Foo
+	}
+}
diff --git a/test/chan/doubleselect.go b/test/chan/doubleselect.go
index 3c7412ed6..ac559302d 100644
--- a/test/chan/doubleselect.go
+++ b/test/chan/doubleselect.go
@@ -1,11 +1,12 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
-// This test is designed to flush out the case where two cases of a select can
+// Test the situation in which two cases of a select can
 // both end up running. See http://codereview.appspot.com/180068.
+
 package main
 
 import (
@@ -82,5 +83,4 @@ func main() {
 	// However, the result of the bug linked to at the top is that we'll
 	// end up panicking with: "throw: bad g->status in ready".
 	recver(cmux)
-	print("PASS\n")
 }
diff --git a/test/chan/fifo.go b/test/chan/fifo.go
index 0dddfcaa0..70d20b31f 100644
--- a/test/chan/fifo.go
+++ b/test/chan/fifo.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
-// Verify that unbuffered channels act as pure fifos.
+// Test that unbuffered channels act as pure fifos.
 
 package main
 
diff --git a/test/chan/goroutines.go b/test/chan/goroutines.go
index d8f8803df..6ffae7df6 100644
--- a/test/chan/goroutines.go
+++ b/test/chan/goroutines.go
@@ -1,11 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
-// make a lot of goroutines, threaded together.
-// tear them down cleanly.
+// Torture test for goroutines.
+// Make a lot of goroutines, threaded together, and tear them down cleanly.
 
 package main
 
@@ -21,7 +21,7 @@ func f(left, right chan int) {
 func main() {
 	var n = 10000
 	if len(os.Args) > 1 {
-		var err os.Error
+		var err error
 		n, err = strconv.Atoi(os.Args[1])
 		if err != nil {
 			print("bad arg\n")
diff --git a/test/chan/nonblock.go b/test/chan/nonblock.go
index 33afb3291..7e3c0c74d 100644
--- a/test/chan/nonblock.go
+++ b/test/chan/nonblock.go
@@ -1,11 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
-// Verify channel operations that test for blocking
-// Use several sizes and types of operands
+// Test channel operations that test for blocking.
+// Use several sizes and types of operands.
 
 package main
 
@@ -279,5 +279,4 @@ func main() {
 			<-sync
 		}
 	}
-	print("PASS\n")
 }
diff --git a/test/chan/perm.go b/test/chan/perm.go
index 038ff94e3..7e152c5eb 100644
--- a/test/chan/perm.go
+++ b/test/chan/perm.go
@@ -1,9 +1,13 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Test various correct and incorrect permutations of send-only,
+// receive-only, and bidirectional channels.
+// Does not compile.
+
 package main
 
 var (
@@ -48,4 +52,11 @@ func main() {
 	case x := <-cs: // ERROR "receive"
 		_ = x
 	}
+
+	for _ = range cs {// ERROR "receive"
+	}
+
+	close(c)
+	close(cs)
+	close(cr)  // ERROR "receive"
 }
diff --git a/test/chan/powser1.go b/test/chan/powser1.go
index dc4ff5325..6bf2a9111 100644
--- a/test/chan/powser1.go
+++ b/test/chan/powser1.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test concurrency primitives: power series.
+
 // Power series package
 // A power series is a channel, along which flow rational
 // coefficients.  A denominator of zero signifies the end.
diff --git a/test/chan/powser2.go b/test/chan/powser2.go
index bc329270d..33abd5c53 100644
--- a/test/chan/powser2.go
+++ b/test/chan/powser2.go
@@ -1,18 +1,21 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test concurrency primitives: power series.
+
+// Like powser1.go but uses channels of interfaces.
+// Has not been cleaned up as much as powser1.go, to keep
+// it distinct and therefore a different test.
+
 // Power series package
 // A power series is a channel, along which flow rational
 // coefficients.  A denominator of zero signifies the end.
 // Original code in Newsqueak by Doug McIlroy.
 // See Squinting at Power Series by Doug McIlroy,
 //   http://www.cs.bell-labs.com/who/rsc/thread/squint.pdf
-// Like powser1.go but uses channels of interfaces.
-// Has not been cleaned up as much as powser1.go, to keep
-// it distinct and therefore a different test.
 
 package main
 
diff --git a/test/chan/select.go b/test/chan/select.go
index be4eb3f42..38fa7e1e3 100644
--- a/test/chan/select.go
+++ b/test/chan/select.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test simple select.
+
 package main
 
 var counter uint
diff --git a/test/chan/select2.go b/test/chan/select2.go
index e24c51ed1..40bc357b5 100644
--- a/test/chan/select2.go
+++ b/test/chan/select2.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // 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.
 
+// Test that selects do not consume undue memory.
+
 package main
 
 import "runtime"
@@ -35,14 +37,17 @@ func main() {
 	go sender(c, 100000)
 	receiver(c, dummy, 100000)
 	runtime.GC()
-	runtime.MemStats.Alloc = 0
+	memstats := new(runtime.MemStats)
+	runtime.ReadMemStats(memstats)
+	alloc := memstats.Alloc
 
 	// second time shouldn't increase footprint by much
 	go sender(c, 100000)
 	receiver(c, dummy, 100000)
 	runtime.GC()
+	runtime.ReadMemStats(memstats)
 
-	if runtime.MemStats.Alloc > 1e5 {
-		println("BUG: too much memory for 100,000 selects:", runtime.MemStats.Alloc)
+	if memstats.Alloc-alloc > 1e5 {
+		println("BUG: too much memory for 100,000 selects:", memstats.Alloc-alloc)
 	}
 }
diff --git a/test/chan/select3.go b/test/chan/select3.go
index d919de3e0..847d8ed37 100644
--- a/test/chan/select3.go
+++ b/test/chan/select3.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // 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.
 
-// Tests verifying the semantics of the select statement
+// Test the semantics of the select statement
 // for basic empty/non-empty cases.
 
 package main
@@ -197,13 +197,13 @@ func main() {
 	})
 	testBlock(never, func() {
 		select {
-		case x := <-closedch:
+		case x := (<-closedch):
 			_ = x
 		}
 	})
 	testBlock(never, func() {
 		select {
-		case x, ok := <-closedch:
+		case x, ok := (<-closedch):
 			_, _ = x, ok
 		}
 	})
diff --git a/test/chan/select4.go b/test/chan/select4.go
index 46618ac88..500364038 100644
--- a/test/chan/select4.go
+++ b/test/chan/select4.go
@@ -1,4 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
+
+// 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
+
+// Test that a select statement proceeds when a value is ready.
 
 package main
 
diff --git a/test/chan/select5.go b/test/chan/select5.go
index 607182167..13cde1afe 100644
--- a/test/chan/select5.go
+++ b/test/chan/select5.go
@@ -7,7 +7,10 @@
 // license that can be found in the LICENSE file.
 
 // Generate test of channel operations and simple selects.
-// Only doing one real send or receive at a time, but phrased
+// The output of this program is compiled and run to do the
+// actual test.
+
+// Each test does only one real send or receive at a time, but phrased
 // in various ways that the compiler may or may not rewrite
 // into simpler expressions.
 
@@ -18,7 +21,7 @@ import (
 	"fmt"
 	"io"
 	"os"
-	"template"
+	"text/template"
 )
 
 func main() {
diff --git a/test/chan/select6.go b/test/chan/select6.go
index 2ba6810ac..af470a0d0 100644
--- a/test/chan/select6.go
+++ b/test/chan/select6.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2011 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.
 
-// Issue 2075
+// Test for select: Issue 2075
 // A bug in select corrupts channel queues of failed cases
 // if there are multiple waiters on those channels and the
 // select is the last in the queue. If further waits are made
diff --git a/test/chan/select7.go b/test/chan/select7.go
new file mode 100644
index 000000000..20456a9d6
--- /dev/null
+++ b/test/chan/select7.go
@@ -0,0 +1,68 @@
+// run
+
+// Copyright 2011 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.
+
+// Test select when discarding a value.
+
+package main
+
+import "runtime"
+
+func recv1(c <-chan int) {
+	<-c
+}
+
+func recv2(c <-chan int) {
+	select {
+	case <-c:
+	}
+}
+
+func recv3(c <-chan int) {
+	c2 := make(chan int)
+	select {
+	case <-c:
+	case <-c2:
+	}
+}
+
+func send1(recv func(<-chan int)) {
+	c := make(chan int)
+	go recv(c)
+	runtime.Gosched()
+	c <- 1
+}
+
+func send2(recv func(<-chan int)) {
+	c := make(chan int)
+	go recv(c)
+	runtime.Gosched()
+	select {
+	case c <- 1:
+	}
+}
+
+func send3(recv func(<-chan int)) {
+	c := make(chan int)
+	go recv(c)
+	runtime.Gosched()
+	c2 := make(chan int)
+	select {
+	case c <- 1:
+	case c2 <- 1:
+	}
+}
+
+func main() {
+	send1(recv1)
+	send2(recv1)
+	send3(recv1)
+	send1(recv2)
+	send2(recv2)
+	send3(recv2)
+	send1(recv3)
+	send2(recv3)
+	send3(recv3)
+}
diff --git a/test/chan/sendstmt.go b/test/chan/sendstmt.go
index ee6f765cf..a92c4f63a 100644
--- a/test/chan/sendstmt.go
+++ b/test/chan/sendstmt.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/chan/sieve1.go b/test/chan/sieve1.go
index 55076c925..acc310f6c 100644
--- a/test/chan/sieve1.go
+++ b/test/chan/sieve1.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test concurrency primitives: classical inefficient concurrent prime sieve.
+
 // Generate primes up to 100 using channels, checking the results.
 // This sieve consists of a linear chain of divisibility filters,
 // equivalent to trial-dividing each n by all primes p ≤ n.
diff --git a/test/chan/sieve2.go b/test/chan/sieve2.go
index 7f2ed9157..09e5c527b 100644
--- a/test/chan/sieve2.go
+++ b/test/chan/sieve2.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test concurrency primitives: prime sieve of Eratosthenes.
+
 // Generate primes up to 100 using channels, checking the results.
 // This sieve is Eratosthenesque and only considers odd candidates.
 // See discussion at <http://blog.onideas.ws/eratosthenes.go>.
@@ -13,7 +15,6 @@ package main
 import (
 	"container/heap"
 	"container/ring"
-	"container/vector"
 )
 
 // Return a chan of odd numbers, starting from 5.
@@ -47,13 +48,28 @@ type PeekCh struct {
 	ch   chan int
 }
 
-// Heap of PeekCh, sorting by head values.
-type PeekChHeap struct {
-	*vector.Vector
-}
+// Heap of PeekCh, sorting by head values, satisfies Heap interface.
+type PeekChHeap []*PeekCh
 
 func (h *PeekChHeap) Less(i, j int) bool {
-	return h.At(i).(*PeekCh).head < h.At(j).(*PeekCh).head
+	return (*h)[i].head < (*h)[j].head
+}
+
+func (h *PeekChHeap) Swap(i, j int) {
+	(*h)[i], (*h)[j] = (*h)[j], (*h)[i]
+}
+
+func (h *PeekChHeap) Len() int {
+	return len(*h)
+}
+
+func (h *PeekChHeap) Pop() (v interface{}) {
+	*h, v = (*h)[:h.Len()-1], (*h)[h.Len()-1]
+	return
+}
+
+func (h *PeekChHeap) Push(v interface{}) {
+	*h = append(*h, v.(*PeekCh))
 }
 
 // Return a channel to serve as a sending proxy to 'out'.
@@ -108,26 +124,26 @@ func Sieve() chan int {
 
 	// Merge channels of multiples of 'primes' into 'composites'.
 	go func() {
-		h := &PeekChHeap{new(vector.Vector)}
+		var h PeekChHeap
 		min := 15
 		for {
 			m := multiples(<-primes)
 			head := <-m
 			for min < head {
 				composites <- min
-				minchan := heap.Pop(h).(*PeekCh)
+				minchan := heap.Pop(&h).(*PeekCh)
 				min = minchan.head
 				minchan.head = <-minchan.ch
-				heap.Push(h, minchan)
+				heap.Push(&h, minchan)
 			}
 			for min == head {
-				minchan := heap.Pop(h).(*PeekCh)
+				minchan := heap.Pop(&h).(*PeekCh)
 				min = minchan.head
 				minchan.head = <-minchan.ch
-				heap.Push(h, minchan)
+				heap.Push(&h, minchan)
 			}
 			composites <- head
-			heap.Push(h, &PeekCh{<-m, m})
+			heap.Push(&h, &PeekCh{<-m, m})
 		}
 	}()
 
diff --git a/test/chan/zerosize.go b/test/chan/zerosize.go
index 617c9dab3..50aca857c 100644
--- a/test/chan/zerosize.go
+++ b/test/chan/zerosize.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2011 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.
 
-// Making channels of a zero-sized type should not panic.
+// Test making channels of a zero-sized type.
 
 package main
 
diff --git a/test/chancap.go b/test/chancap.go
index 3f3789fbc..b3e40233f 100644
--- a/test/chancap.go
+++ b/test/chancap.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test the cap predeclared function applied to channels.
+
 package main
 
 func main() {
diff --git a/test/char_lit.go b/test/char_lit.go
index 99be77a57..836c3c1a2 100644
--- a/test/char_lit.go
+++ b/test/char_lit.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A &&./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test character literal syntax.
+
 package main
 
 import "os"
diff --git a/test/char_lit1.go b/test/char_lit1.go
index dc5385291..489744b6e 100644
--- a/test/char_lit1.go
+++ b/test/char_lit1.go
@@ -1,9 +1,12 @@
-// errchk $G -e $F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Verify that illegal character literals are detected.
+// Does not compile.
+
 package main
 
 const (
diff --git a/test/closedchan.go b/test/closedchan.go
index 95314b334..043a92d38 100644
--- a/test/closedchan.go
+++ b/test/closedchan.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -11,6 +11,10 @@
 
 package main
 
+import "os"
+
+var failed bool
+
 type Chan interface {
 	Send(int)
 	Nbsend(int) bool
@@ -225,19 +229,23 @@ func test1(c Chan) {
 		// recv a close signal (a zero value)
 		if x := c.Recv(); x != 0 {
 			println("test1: recv on closed:", x, c.Impl())
+			failed = true
 		}
 		if x, ok := c.Recv2(); x != 0 || ok {
 			println("test1: recv2 on closed:", x, ok, c.Impl())
+			failed = true
 		}
 
 		// should work with select: received a value without blocking, so selected == true.
 		x, selected := c.Nbrecv()
 		if x != 0 || !selected {
 			println("test1: recv on closed nb:", x, selected, c.Impl())
+			failed = true
 		}
 		x, ok, selected := c.Nbrecv2()
 		if x != 0 || ok || !selected {
 			println("test1: recv2 on closed nb:", x, ok, selected, c.Impl())
+			failed = true
 		}
 	}
 
@@ -247,12 +255,14 @@ func test1(c Chan) {
 	// the value should have been discarded.
 	if x := c.Recv(); x != 0 {
 		println("test1: recv on closed got non-zero after send on closed:", x, c.Impl())
+		failed = true
 	}
 
 	// similarly Send.
 	shouldPanic(func() { c.Send(2) })
 	if x := c.Recv(); x != 0 {
 		println("test1: recv on closed got non-zero after send on closed:", x, c.Impl())
+		failed = true
 	}
 }
 
@@ -260,6 +270,7 @@ func testasync1(c Chan) {
 	// should be able to get the last value via Recv
 	if x := c.Recv(); x != 1 {
 		println("testasync1: Recv did not get 1:", x, c.Impl())
+		failed = true
 	}
 
 	test1(c)
@@ -269,6 +280,7 @@ func testasync2(c Chan) {
 	// should be able to get the last value via Recv2
 	if x, ok := c.Recv2(); x != 1 || !ok {
 		println("testasync1: Recv did not get 1, true:", x, ok, c.Impl())
+		failed = true
 	}
 
 	test1(c)
@@ -278,6 +290,7 @@ func testasync3(c Chan) {
 	// should be able to get the last value via Nbrecv
 	if x, selected := c.Nbrecv(); x != 1 || !selected {
 		println("testasync2: Nbrecv did not get 1, true:", x, selected, c.Impl())
+		failed = true
 	}
 
 	test1(c)
@@ -287,6 +300,7 @@ func testasync4(c Chan) {
 	// should be able to get the last value via Nbrecv2
 	if x, ok, selected := c.Nbrecv2(); x != 1 || !ok || !selected {
 		println("testasync2: Nbrecv did not get 1, true, true:", x, ok, selected, c.Impl())
+		failed = true
 	}
 	test1(c)
 }
@@ -327,4 +341,19 @@ func main() {
 			testclosed(mk(closedasync()))
 		}
 	}
+	
+	var ch chan int	
+	shouldPanic(func() {
+		close(ch)
+	})
+	
+	ch = make(chan int)
+	close(ch)
+	shouldPanic(func() {
+		close(ch)
+	})
+
+	if failed {
+		os.Exit(1)
+	}
 }
diff --git a/test/closure.go b/test/closure.go
index 3033c02ed..ae38900ba 100644
--- a/test/closure.go
+++ b/test/closure.go
@@ -1,11 +1,15 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test the behavior of closures.
+
 package main
 
+import "runtime"
+
 var c = make(chan int)
 
 func check(a []int) {
@@ -76,8 +80,9 @@ func h() {
 
 func newfunc() func(int) int { return func(x int) int { return x } }
 
-
 func main() {
+	var fail bool
+
 	go f()
 	check([]int{1, 4, 5, 4})
 
@@ -89,17 +94,27 @@ func main() {
 	go h()
 	check([]int{100, 200, 101, 201, 500, 101, 201, 500})
 
+	memstats := new(runtime.MemStats)
+	runtime.ReadMemStats(memstats)
+	n0 := memstats.Mallocs
+
 	x, y := newfunc(), newfunc()
-	if x == y {
-		println("newfunc returned same func")
-		panic("fail")
-	}
 	if x(1) != 1 || y(2) != 2 {
 		println("newfunc returned broken funcs")
-		panic("fail")
+		fail = true
+	}
+
+	runtime.ReadMemStats(memstats)
+	if n0 != memstats.Mallocs {
+		println("newfunc allocated unexpectedly")
+		fail = true
 	}
 
 	ff(1)
+
+	if fail {
+		panic("fail")
+	}
 }
 
 func ff(x int) {
diff --git a/test/cmp.go b/test/cmp.go
new file mode 100644
index 000000000..a56ca6ead
--- /dev/null
+++ b/test/cmp.go
@@ -0,0 +1,421 @@
+// run
+
+// Copyright 2009 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.
+
+// Test equality and inequality operations.
+
+package main
+
+import "unsafe"
+
+var global bool
+func use(b bool) { global = b }
+
+func stringptr(s string) uintptr { return *(*uintptr)(unsafe.Pointer(&s)) }
+
+func isfalse(b bool) {
+	if b {
+		// stack will explain where
+		panic("wanted false, got true")
+	}
+}
+
+func istrue(b bool) {
+	if !b {
+		// stack will explain where
+		panic("wanted true, got false")
+	}
+}
+
+type T *int
+
+func main() {
+	var a []int
+	var b map[string]int
+
+	var c string = "hello"
+	var d string = "hel" // try to get different pointer
+	d = d + "lo"
+	if stringptr(c) == stringptr(d) {
+		panic("compiler too smart -- got same string")
+	}
+
+	var e = make(chan int)
+
+	var ia interface{} = a
+	var ib interface{} = b
+	var ic interface{} = c
+	var id interface{} = d
+	var ie interface{} = e
+
+	// these comparisons are okay because
+	// string compare is okay and the others
+	// are comparisons where the types differ.
+	isfalse(ia == ib)
+	isfalse(ia == ic)
+	isfalse(ia == id)
+	isfalse(ib == ic)
+	isfalse(ib == id)
+	istrue(ic == id)
+	istrue(ie == ie)
+
+	istrue(ia != ib)
+	istrue(ia != ic)
+	istrue(ia != id)
+	istrue(ib != ic)
+	istrue(ib != id)
+	isfalse(ic != id)
+	isfalse(ie != ie)
+
+	// these are not okay, because there is no comparison on slices or maps.
+	//isfalse(a == ib)
+	//isfalse(a == ic)
+	//isfalse(a == id)
+	//isfalse(b == ic)
+	//isfalse(b == id)
+
+	istrue(c == id)
+	istrue(e == ie)
+
+	//isfalse(ia == b)
+	isfalse(ia == c)
+	isfalse(ia == d)
+	isfalse(ib == c)
+	isfalse(ib == d)
+	istrue(ic == d)
+	istrue(ie == e)
+
+	//istrue(a != ib)
+	//istrue(a != ic)
+	//istrue(a != id)
+	//istrue(b != ic)
+	//istrue(b != id)
+	isfalse(c != id)
+	isfalse(e != ie)
+
+	//istrue(ia != b)
+	istrue(ia != c)
+	istrue(ia != d)
+	istrue(ib != c)
+	istrue(ib != d)
+	isfalse(ic != d)
+	isfalse(ie != e)
+
+	// 6g used to let this go through as true.
+	var g uint64 = 123
+	var h int64 = 123
+	var ig interface{} = g
+	var ih interface{} = h
+	isfalse(ig == ih)
+	istrue(ig != ih)
+
+	// map of interface should use == on interface values,
+	// not memory.
+	var m = make(map[interface{}]int)
+	m[ic] = 1
+	m[id] = 2
+	if m[c] != 2 {
+		println("m[c] = ", m[c])
+		panic("bad m[c]")
+	}
+
+	// non-interface comparisons
+	{
+		c := make(chan int)
+		c1 := (<-chan int)(c)
+		c2 := (chan<- int)(c)
+		istrue(c == c1)
+		istrue(c == c2)
+		istrue(c1 == c)
+		istrue(c2 == c)
+
+		isfalse(c != c1)
+		isfalse(c != c2)
+		isfalse(c1 != c)
+		isfalse(c2 != c)
+
+		d := make(chan int)
+		isfalse(c == d)
+		isfalse(d == c)
+		isfalse(d == c1)
+		isfalse(d == c2)
+		isfalse(c1 == d)
+		isfalse(c2 == d)
+
+		istrue(c != d)
+		istrue(d != c)
+		istrue(d != c1)
+		istrue(d != c2)
+		istrue(c1 != d)
+		istrue(c2 != d)
+	}
+
+	// named types vs not
+	{
+		var x = new(int)
+		var y T
+		var z T = x
+
+		isfalse(x == y)
+		istrue(x == z)
+		isfalse(y == z)
+
+		isfalse(y == x)
+		istrue(z == x)
+		isfalse(z == y)
+
+		istrue(x != y)
+		isfalse(x != z)
+		istrue(y != z)
+
+		istrue(y != x)
+		isfalse(z != x)
+		istrue(z != y)
+	}
+
+	// structs
+	{
+		var x = struct {
+			x int
+			y string
+		}{1, "hi"}
+		var y = struct {
+			x int
+			y string
+		}{2, "bye"}
+		var z = struct {
+			x int
+			y string
+		}{1, "hi"}
+
+		isfalse(x == y)
+		isfalse(y == x)
+		isfalse(y == z)
+		isfalse(z == y)
+		istrue(x == z)
+		istrue(z == x)
+
+		istrue(x != y)
+		istrue(y != x)
+		istrue(y != z)
+		istrue(z != y)
+		isfalse(x != z)
+		isfalse(z != x)
+
+		var m = make(map[struct {
+			x int
+			y string
+		}]int)
+		m[x] = 10
+		m[y] = 20
+		m[z] = 30
+		istrue(m[x] == 30)
+		istrue(m[y] == 20)
+		istrue(m[z] == 30)
+		istrue(m[x] != 10)
+		isfalse(m[x] != 30)
+		isfalse(m[y] != 20)
+		isfalse(m[z] != 30)
+		isfalse(m[x] == 10)
+
+		var m1 = make(map[struct {
+			x int
+			y string
+		}]struct {
+			x int
+			y string
+		})
+		m1[x] = x
+		m1[y] = y
+		m1[z] = z
+		istrue(m1[x] == z)
+		istrue(m1[y] == y)
+		istrue(m1[z] == z)
+		istrue(m1[x] == x)
+		isfalse(m1[x] != z)
+		isfalse(m1[y] != y)
+		isfalse(m1[z] != z)
+		isfalse(m1[x] != x)
+
+		var ix, iy, iz interface{} = x, y, z
+
+		isfalse(ix == iy)
+		isfalse(iy == ix)
+		isfalse(iy == iz)
+		isfalse(iz == iy)
+		istrue(ix == iz)
+		istrue(iz == ix)
+
+		isfalse(x == iy)
+		isfalse(y == ix)
+		isfalse(y == iz)
+		isfalse(z == iy)
+		istrue(x == iz)
+		istrue(z == ix)
+
+		isfalse(ix == y)
+		isfalse(iy == x)
+		isfalse(iy == z)
+		isfalse(iz == y)
+		istrue(ix == z)
+		istrue(iz == x)
+
+		istrue(ix != iy)
+		istrue(iy != ix)
+		istrue(iy != iz)
+		istrue(iz != iy)
+		isfalse(ix != iz)
+		isfalse(iz != ix)
+
+		istrue(x != iy)
+		istrue(y != ix)
+		istrue(y != iz)
+		istrue(z != iy)
+		isfalse(x != iz)
+		isfalse(z != ix)
+
+		istrue(ix != y)
+		istrue(iy != x)
+		istrue(iy != z)
+		istrue(iz != y)
+		isfalse(ix != z)
+		isfalse(iz != x)
+	}
+	
+	// structs with _ fields
+	{
+		var x = struct {
+			x int
+			_ []int
+			y float64
+			_ float64
+			z int
+		}{
+			x: 1, y: 2, z: 3,
+		}
+		var ix interface{} = x
+		
+		istrue(x == x)
+		istrue(x == ix)
+		istrue(ix == x)
+		istrue(ix == ix)
+	}
+
+	// arrays
+	{
+		var x = [2]string{"1", "hi"}
+		var y = [2]string{"2", "bye"}
+		var z = [2]string{"1", "hi"}
+
+		isfalse(x == y)
+		isfalse(y == x)
+		isfalse(y == z)
+		isfalse(z == y)
+		istrue(x == z)
+		istrue(z == x)
+
+		istrue(x != y)
+		istrue(y != x)
+		istrue(y != z)
+		istrue(z != y)
+		isfalse(x != z)
+		isfalse(z != x)
+
+		var m = make(map[[2]string]int)
+		m[x] = 10
+		m[y] = 20
+		m[z] = 30
+		istrue(m[x] == 30)
+		istrue(m[y] == 20)
+		istrue(m[z] == 30)
+		isfalse(m[x] != 30)
+		isfalse(m[y] != 20)
+		isfalse(m[z] != 30)
+
+		var ix, iy, iz interface{} = x, y, z
+
+		isfalse(ix == iy)
+		isfalse(iy == ix)
+		isfalse(iy == iz)
+		isfalse(iz == iy)
+		istrue(ix == iz)
+		istrue(iz == ix)
+
+		isfalse(x == iy)
+		isfalse(y == ix)
+		isfalse(y == iz)
+		isfalse(z == iy)
+		istrue(x == iz)
+		istrue(z == ix)
+
+		isfalse(ix == y)
+		isfalse(iy == x)
+		isfalse(iy == z)
+		isfalse(iz == y)
+		istrue(ix == z)
+		istrue(iz == x)
+
+		istrue(ix != iy)
+		istrue(iy != ix)
+		istrue(iy != iz)
+		istrue(iz != iy)
+		isfalse(ix != iz)
+		isfalse(iz != ix)
+
+		istrue(x != iy)
+		istrue(y != ix)
+		istrue(y != iz)
+		istrue(z != iy)
+		isfalse(x != iz)
+		isfalse(z != ix)
+
+		istrue(ix != y)
+		istrue(iy != x)
+		istrue(iy != z)
+		istrue(iz != y)
+		isfalse(ix != z)
+		isfalse(iz != x)
+	}
+
+	shouldPanic(p1)
+	shouldPanic(p2)
+	shouldPanic(p3)
+	shouldPanic(p4)
+}
+
+func p1() {
+	var a []int
+	var ia interface{} = a
+	use(ia == ia)
+}
+
+func p2() {
+	var b []int
+	var ib interface{} = b
+	use(ib == ib)
+}
+
+func p3() {
+	var a []int
+	var ia interface{} = a
+	var m = make(map[interface{}]int)
+	m[ia] = 1
+}
+
+func p4() {
+	var b []int
+	var ib interface{} = b
+	var m = make(map[interface{}]int)
+	m[ib] = 1
+}
+
+func shouldPanic(f func()) {
+	defer func() {
+		if recover() == nil {
+			panic("function should panic")
+		}
+	}()
+	f()
+}
diff --git a/test/cmp1.go b/test/cmp1.go
deleted file mode 100644
index 698544c58..000000000
--- a/test/cmp1.go
+++ /dev/null
@@ -1,130 +0,0 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
-
-// Copyright 2009 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.
-
-package main
-
-import "unsafe"
-
-func use(bool) {}
-
-func stringptr(s string) uintptr { return *(*uintptr)(unsafe.Pointer(&s)) }
-
-func isfalse(b bool) {
-	if b {
-		// stack will explain where
-		panic("wanted false, got true")
-	}
-}
-
-func istrue(b bool) {
-	if !b {
-		// stack will explain where
-		panic("wanted true, got false")
-	}
-}
-
-type T *int
-
-func main() {
-	var a []int
-	var b map[string]int
-
-	var c string = "hello"
-	var d string = "hel" // try to get different pointer
-	d = d + "lo"
-	if stringptr(c) == stringptr(d) {
-		panic("compiler too smart -- got same string")
-	}
-
-	var e = make(chan int)
-
-	var ia interface{} = a
-	var ib interface{} = b
-	var ic interface{} = c
-	var id interface{} = d
-	var ie interface{} = e
-
-	// these comparisons are okay because
-	// string compare is okay and the others
-	// are comparisons where the types differ.
-	isfalse(ia == ib)
-	isfalse(ia == ic)
-	isfalse(ia == id)
-	isfalse(ib == ic)
-	isfalse(ib == id)
-	istrue(ic == id)
-	istrue(ie == ie)
-	
-	// these are okay because one side of the
-	// comparison need only be assignable to the other.
-	isfalse(a == ib)
-	isfalse(a == ic)
-	isfalse(a == id)
-	isfalse(b == ic)
-	isfalse(b == id)
-	istrue(c == id)
-	istrue(e == ie)
-
-	isfalse(ia == b)
-	isfalse(ia == c)
-	isfalse(ia == d)
-	isfalse(ib == c)
-	isfalse(ib == d)
-	istrue(ic == d)
-	istrue(ie == e)
-
-	// 6g used to let this go through as true.
-	var g uint64 = 123
-	var h int64 = 123
-	var ig interface{} = g
-	var ih interface{} = h
-	isfalse(ig == ih)
-
-	// map of interface should use == on interface values,
-	// not memory.
-	// TODO: should m[c], m[d] be valid here?
-	var m = make(map[interface{}]int)
-	m[ic] = 1
-	m[id] = 2
-	if m[ic] != 2 {
-		println("m[ic] = ", m[ic])
-		panic("bad m[ic]")
-	}
-	
-	// non-interface comparisons
-	{
-		c := make(chan int)
-		c1 := (<-chan int)(c)
-		c2 := (chan<- int)(c)
-		istrue(c == c1)
-		istrue(c == c2)
-		istrue(c1 == c)
-		istrue(c2 == c)
-		
-		d := make(chan int)
-		isfalse(c == d)
-		isfalse(d == c)
-		isfalse(d == c1)
-		isfalse(d == c2)
-		isfalse(c1 == d)
-		isfalse(c2 == d)
-	}
-
-	// named types vs not
-	{
-		var x = new(int)
-		var y T
-		var z T = x
-		
-		isfalse(x == y)
-		istrue(x == z)
-		isfalse(y == z)
-
-		isfalse(y == x)
-		istrue(z == x)
-		isfalse(z == y)
-	}
-}
diff --git a/test/cmp2.go b/test/cmp2.go
deleted file mode 100644
index f6f124f2e..000000000
--- a/test/cmp2.go
+++ /dev/null
@@ -1,15 +0,0 @@
-// $G $D/$F.go && $L $F.$A && ! ./$A.out
-
-// Copyright 2009 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.
-
-package main
-
-func use(bool) { }
-
-func main() {
-	var a []int
-	var ia interface{} = a
-	use(ia == ia)
-}
diff --git a/test/cmp3.go b/test/cmp3.go
deleted file mode 100644
index dd90bfb03..000000000
--- a/test/cmp3.go
+++ /dev/null
@@ -1,15 +0,0 @@
-// $G $D/$F.go && $L $F.$A && ! ./$A.out
-
-// Copyright 2009 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.
-
-package main
-
-func use(bool) { }
-
-func main() {
-	var b []int
-	var ib interface{} = b
-	use(ib == ib)
-}
diff --git a/test/cmp4.go b/test/cmp4.go
deleted file mode 100644
index 3f9b2c0b8..000000000
--- a/test/cmp4.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// $G $D/$F.go && $L $F.$A && ! ./$A.out
-
-// Copyright 2009 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.
-
-package main
-
-func main() {
-	var a []int
-	var ia interface{} = a
-	var m = make(map[interface{}] int)
-	m[ia] = 1
-}
diff --git a/test/cmp5.go b/test/cmp5.go
deleted file mode 100644
index 3a7d733f0..000000000
--- a/test/cmp5.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// $G $D/$F.go && $L $F.$A && ! ./$A.out
-
-// Copyright 2009 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.
-
-package main
-
-func main() {
-	var b []int
-	var ib interface{} = b
-	var m = make(map[interface{}] int)
-	m[ib] = 1
-}
diff --git a/test/cmp6.go b/test/cmp6.go
index b3ea8ffeb..7d99aae18 100644
--- a/test/cmp6.go
+++ b/test/cmp6.go
@@ -1,9 +1,12 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // 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.
 
+// Verify that incorrect comparisons are detected.
+// Does not compile.
+
 package main
 
 func use(bool) {}
@@ -11,22 +14,26 @@ func use(bool) {}
 type T1 *int
 type T2 *int
 
-type T3 struct {}
+type T3 struct{ z []int }
 
 var t3 T3
 
+type T4 struct { _ []int; a float64 }
+
+var t4 T4
+
 func main() {
 	// Arguments to comparison must be
 	// assignable one to the other (or vice versa)
 	// so chan int can be compared against
 	// directional channels but channel of different
 	// direction cannot be compared against each other.
-	var c1 chan <-int
+	var c1 chan<- int
 	var c2 <-chan int
 	var c3 chan int
-	
-	use(c1 == c2)	// ERROR "invalid operation|incompatible"
-	use(c2 == c1)	// ERROR "invalid operation|incompatible"
+
+	use(c1 == c2) // ERROR "invalid operation|incompatible"
+	use(c2 == c1) // ERROR "invalid operation|incompatible"
 	use(c1 == c3)
 	use(c2 == c2)
 	use(c3 == c1)
@@ -36,14 +43,33 @@ func main() {
 	var p1 T1
 	var p2 T2
 	var p3 *int
-	
-	use(p1 == p2)	// ERROR "invalid operation|incompatible"
-	use(p2 == p1)	// ERROR "invalid operation|incompatible"
+
+	use(p1 == p2) // ERROR "invalid operation|incompatible"
+	use(p2 == p1) // ERROR "invalid operation|incompatible"
 	use(p1 == p3)
 	use(p2 == p2)
 	use(p3 == p1)
 	use(p3 == p2)
-	
+
 	// Comparison of structs should have a good message
-	use(t3 == t3)	// ERROR "struct|expected"
+	use(t3 == t3) // ERROR "struct|expected"
+	use(t4 == t4) // ok; the []int is a blank field
+
+	// Slices, functions, and maps too.
+	var x []int
+	var f func()
+	var m map[int]int
+	use(x == x) // ERROR "slice can only be compared to nil"
+	use(f == f) // ERROR "func can only be compared to nil"
+	use(m == m) // ERROR "map can only be compared to nil"
+
+	// Comparison with interface that cannot return true
+	// (would panic).
+	var i interface{}
+	use(i == x) // ERROR "invalid operation"
+	use(x == i) // ERROR "invalid operation"
+	use(i == f) // ERROR "invalid operation"
+	use(f == i) // ERROR "invalid operation"
+	use(i == m) // ERROR "invalid operation"
+	use(m == i) // ERROR "invalid operation"
 }
diff --git a/test/cmplx.go b/test/cmplx.go
index d5a77d684..248672e7d 100644
--- a/test/cmplx.go
+++ b/test/cmplx.go
@@ -1,9 +1,12 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // 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.
 
+// Verify that incorrect invocations of the complex predeclared function are detected.
+// Does not compile.
+
 package main
 
 var (
diff --git a/test/cmplxdivide.c b/test/cmplxdivide.c
index b340f04d8..12dc4f1c0 100644
--- a/test/cmplxdivide.c
+++ b/test/cmplxdivide.c
@@ -51,6 +51,7 @@ main(void)
 	int i, j, k, l;
 	double complex n, d, q;
 	
+	printf("// skip\n");
 	printf("// # generated by cmplxdivide.c\n");
 	printf("\n");
 	printf("package main\n");
diff --git a/test/cmplxdivide.go b/test/cmplxdivide.go
index 6a67b175d..92a98356d 100644
--- a/test/cmplxdivide.go
+++ b/test/cmplxdivide.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go $D/cmplxdivide1.go && $L $D/$F.$A && ./$A.out
+// run cmplxdivide1.go
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -9,14 +9,14 @@
 package main
 
 import (
-	"cmath"
 	"fmt"
 	"math"
+	"math/cmplx"
 )
 
-type Test struct{
-	f, g	complex128
-	out	complex128
+type Test struct {
+	f, g complex128
+	out  complex128
 }
 
 var nan = math.NaN()
@@ -25,9 +25,9 @@ var negzero = math.Copysign(0, -1)
 
 func calike(a, b complex128) bool {
 	switch {
-	case cmath.IsInf(a) && cmath.IsInf(b):
+	case cmplx.IsInf(a) && cmplx.IsInf(b):
 		return true
-	case cmath.IsNaN(a) && cmath.IsNaN(b):
+	case cmplx.IsNaN(a) && cmplx.IsNaN(b):
 		return true
 	}
 	return a == b
@@ -36,7 +36,7 @@ func calike(a, b complex128) bool {
 func main() {
 	bad := false
 	for _, t := range tests {
-		x := t.f/t.g
+		x := t.f / t.g
 		if !calike(x, t.out) {
 			if !bad {
 				fmt.Printf("BUG\n")
diff --git a/test/cmplxdivide1.go b/test/cmplxdivide1.go
index 6a1dee9fe..e9031dd15 100644
--- a/test/cmplxdivide1.go
+++ b/test/cmplxdivide1.go
@@ -1,3 +1,4 @@
+// skip
 // # generated by cmplxdivide.c
 
 package main
diff --git a/test/complit.go b/test/complit.go
index f5f7aca9d..649be6d4d 100644
--- a/test/complit.go
+++ b/test/complit.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test composite literals.
+
 package main
 
 type T struct {
@@ -31,6 +33,18 @@ func eq(a []*R) {
 	}
 }
 
+func teq(t *T, n int) {
+	for i := 0; i < n; i++ {
+		if t == nil || t.i != i {
+			panic("bad")
+		}
+		t = t.next
+	}
+	if t != nil {
+		panic("bad")
+	}
+}
+
 type P struct {
 	a, b int
 }
@@ -46,6 +60,9 @@ func main() {
 	var tp *T
 	tp = &T{0, 7.2, "hi", &t}
 
+	tl := &T{i: 0, next: &T{i: 1, next: &T{i: 2, next: &T{i: 3, next: &T{i: 4}}}}}
+	teq(tl, 5)
+
 	a1 := []int{1, 2, 3}
 	if len(a1) != 3 {
 		panic("a1")
@@ -93,6 +110,7 @@ func main() {
 	}
 
 	eq([]*R{itor(0), itor(1), itor(2), itor(3), itor(4), itor(5)})
+	eq([]*R{{0}, {1}, {2}, {3}, {4}, {5}})
 
 	p1 := NewP(1, 2)
 	p2 := NewP(1, 2)
diff --git a/test/complit1.go b/test/complit1.go
new file mode 100644
index 000000000..521401d73
--- /dev/null
+++ b/test/complit1.go
@@ -0,0 +1,42 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// Verify that illegal composite literals are detected.
+// Does not compile.
+
+package main
+
+var m map[int][3]int
+
+func f() [3]int
+
+func fp() *[3]int
+
+var mp map[int]*[3]int
+
+var (
+	_ = [3]int{1, 2, 3}[:] // ERROR "slice of unaddressable value"
+	_ = m[0][:]            // ERROR "slice of unaddressable value"
+	_ = f()[:]             // ERROR "slice of unaddressable value"
+
+	// these are okay because they are slicing a pointer to an array
+	_ = (&[3]int{1, 2, 3})[:]
+	_ = mp[0][:]
+	_ = fp()[:]
+)
+
+type T struct {
+	i    int
+	f    float64
+	s    string
+	next *T
+}
+
+var (
+	_ = &T{0, 0, "", nil}               // ok
+	_ = &T{i: 0, f: 0, s: "", next: {}} // ERROR "missing type in composite literal|omit types within composite literal"
+	_ = &T{0, 0, "", {}}                // ERROR "missing type in composite literal|omit types within composite literal"
+)
diff --git a/test/compos.go b/test/compos.go
index 70f90f379..de688b39b 100644
--- a/test/compos.go
+++ b/test/compos.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: compos
+// run
 
 // Copyright 2009 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.
 
+// Test that returning &T{} from a function causes an allocation.
+
 package main
 
 type T struct {
diff --git a/test/const.go b/test/const.go
index a55e13a40..80fbfaf3e 100644
--- a/test/const.go
+++ b/test/const.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test simple boolean and numeric constants.
+
 package main
 
 const (
diff --git a/test/const1.go b/test/const1.go
index 67f36e4fd..bc399c01c 100644
--- a/test/const1.go
+++ b/test/const1.go
@@ -1,9 +1,12 @@
-// errchk $G -e $F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Verify overflow is detected when using numeric constants.
+// Does not compile.
+
 package main
 
 type I interface{}
@@ -13,11 +16,11 @@ const (
 	Int8   int8  = 101
 	Minus1 int8  = -1
 	Uint8  uint8 = 102
-	Const  = 103
+	Const        = 103
 
 	Float32    float32 = 104.5
 	Float64    float64 = 105.5
-	ConstFloat = 106.5
+	ConstFloat         = 106.5
 	Big        float64 = 1e300
 
 	String = "abc"
@@ -35,32 +38,35 @@ var (
 	a8 = Int8 * Const / 100      // ERROR "overflow"
 	a9 = Int8 * (Const / 100)    // OK
 
-	b1   = Uint8 * Uint8                                 // ERROR "overflow"
-	b2   = Uint8 * -1                                    // ERROR "overflow"
-	b3   = Uint8 - Uint8                                 // OK
-	b4   = Uint8 - Uint8 - Uint8                         // ERROR "overflow"
-	b5   = uint8(^0)                                     // ERROR "overflow"
-	b6   = ^uint8(0)                                     // OK
-	b7   = uint8(Minus1)                                 // ERROR "overflow"
-	b8   = uint8(int8(-1))                               // ERROR "overflow"
-	b8a  = uint8(-1)                                     // ERROR "overflow"
-	b9   byte                    = (1 << 10) >> 8        // OK
-	b10  byte                    = (1 << 10)             // ERROR "overflow"
-	b11  byte                    = (byte(1) << 10) >> 8  // ERROR "overflow"
-	b12  byte                    = 1000                  // ERROR "overflow"
-	b13  byte                    = byte(1000)            // ERROR "overflow"
-	b14  byte                    = byte(100) * byte(100) // ERROR "overflow"
-	b15  byte                    = byte(100) * 100       // ERROR "overflow"
-	b16  byte                    = byte(0) * 1000        // ERROR "overflow"
-	b16a byte                    = 0 * 1000              // OK
-	b17  byte                    = byte(0) * byte(1000)  // ERROR "overflow"
-	b18  byte                    = Uint8 / 0             // ERROR "division by zero"
+	b1        = Uint8 * Uint8         // ERROR "overflow"
+	b2        = Uint8 * -1            // ERROR "overflow"
+	b3        = Uint8 - Uint8         // OK
+	b4        = Uint8 - Uint8 - Uint8 // ERROR "overflow"
+	b5        = uint8(^0)             // ERROR "overflow"
+	b5a       = int64(^0)             // OK
+	b6        = ^uint8(0)             // OK
+	b6a       = ^int64(0)             // OK
+	b7        = uint8(Minus1)         // ERROR "overflow"
+	b8        = uint8(int8(-1))       // ERROR "overflow"
+	b8a       = uint8(-1)             // ERROR "overflow"
+	b9   byte = (1 << 10) >> 8        // OK
+	b10  byte = (1 << 10)             // ERROR "overflow"
+	b11  byte = (byte(1) << 10) >> 8  // ERROR "overflow"
+	b12  byte = 1000                  // ERROR "overflow"
+	b13  byte = byte(1000)            // ERROR "overflow"
+	b14  byte = byte(100) * byte(100) // ERROR "overflow"
+	b15  byte = byte(100) * 100       // ERROR "overflow"
+	b16  byte = byte(0) * 1000        // ERROR "overflow"
+	b16a byte = 0 * 1000              // OK
+	b17  byte = byte(0) * byte(1000)  // ERROR "overflow"
+	b18  byte = Uint8 / 0             // ERROR "division by zero"
 
-	c1 float64     = Big
-	c2 float64     = Big * Big          // ERROR "overflow"
-	c3 float64     = float64(Big) * Big // ERROR "overflow"
-	c4 = Big * Big                      // ERROR "overflow"
-	c5 = Big / 0                        // ERROR "division by zero"
+	c1 float64 = Big
+	c2 float64 = Big * Big          // ERROR "overflow"
+	c3 float64 = float64(Big) * Big // ERROR "overflow"
+	c4         = Big * Big          // ERROR "overflow"
+	c5         = Big / 0            // ERROR "division by zero"
+	c6         = 1000 % 1e3         // ERROR "floating-point % operation"
 )
 
 func f(int)
diff --git a/test/const2.go b/test/const2.go
index bea1b9912..97d3d4c7d 100644
--- a/test/const2.go
+++ b/test/const2.go
@@ -1,12 +1,21 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Verify that large integer constant expressions cause overflow.
+// Does not compile.
+
 package main
 
 const (
 	A int = 1
 	B byte;	// ERROR "type without expr|expected .=."
 )
+
+const LargeA = 1000000000000000000
+const LargeB = LargeA * LargeA * LargeA
+const LargeC = LargeB * LargeB * LargeB // ERROR "constant multiplication overflow"
+
+const AlsoLargeA = LargeA << 400 << 400 >> 400 >> 400 // ERROR "constant shift overflow"
diff --git a/test/const3.go b/test/const3.go
index 9bba6ced0..3f4e3d1ae 100644
--- a/test/const3.go
+++ b/test/const3.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test typed integer constants.
+
 package main
 
 import "fmt"
diff --git a/test/const4.go b/test/const4.go
new file mode 100644
index 000000000..677fcefa7
--- /dev/null
+++ b/test/const4.go
@@ -0,0 +1,77 @@
+// run
+
+// Copyright 2011 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.
+
+// Test len constants and non-constants, http://golang.org/issue/3244.
+
+package main
+
+var b struct {
+	a[10]int
+}
+
+var m map[string][20]int
+
+var s [][30]int
+
+const (
+	n1 = len(b.a)
+	n2 = len(m[""])
+	n3 = len(s[10])
+)
+
+// Non-constants (see also const5.go).
+var (
+	n4 = len(f())
+	n5 = len(<-c)
+	n6 = cap(g())
+	n7 = cap(<-c1)
+)
+
+var calledF = false
+
+func f() *[40]int {
+	calledF = true
+	return nil
+}
+
+var c = func() chan *[50]int {
+	c := make(chan *[50]int, 2)
+	c <- nil
+	c <- new([50]int)
+	return c
+}()
+
+var calledG = false
+
+func g() *[60]int {
+	calledG = true
+	return nil
+}
+
+var c1 = func() chan *[70]int {
+	c := make(chan *[70]int, 2)
+	c <- nil
+	c <- new([70]int)
+	return c
+}()
+
+func main() {
+	if n1 != 10 || n2 != 20 || n3 != 30 || n4 != 40 || n5 != 50 || n6 != 60 || n7 != 70 {
+		println("BUG:", n1, n2, n3, n4, n5, n6, n7)
+	}
+	if !calledF {
+		println("BUG: did not call f")
+	}
+	if <-c == nil {
+		println("BUG: did not receive from c")
+	}
+	if !calledG {
+		println("BUG: did not call g")
+	}
+	if <-c1 == nil {
+		println("BUG: did not receive from c1")
+	}
+}
diff --git a/test/const5.go b/test/const5.go
new file mode 100644
index 000000000..8e0385e9a
--- /dev/null
+++ b/test/const5.go
@@ -0,0 +1,33 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// Test that len non-constants are not constants, http://golang.org/issue/3244.
+
+package p
+
+var b struct {
+	a[10]int
+}
+
+var m map[string][20]int
+
+var s [][30]int
+
+func f() *[40]int
+var c chan *[50]int
+
+const (
+	n1 = len(b.a)
+	n2 = len(m[""])
+	n3 = len(s[10])
+
+	n4 = len(f())  // ERROR "must be constant"
+	n5 = len(<-c) // ERROR "must be constant"
+
+	n6 = cap(f())  // ERROR "must be constant"
+	n7 = cap(<-c) // ERROR "must be constant"
+)
+
diff --git a/test/convert.go b/test/convert.go
index 0a75663d0..7280edf33 100644
--- a/test/convert.go
+++ b/test/convert.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test types of constant expressions, using reflect.
+
 package main
 
 import "reflect"
diff --git a/test/convert1.go b/test/convert1.go
new file mode 100644
index 000000000..0f417a338
--- /dev/null
+++ b/test/convert1.go
@@ -0,0 +1,99 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// Verify that illegal conversions involving strings are detected.
+// Does not compile.
+
+package main
+
+type Tbyte []byte
+type Trune []rune
+type Tint64 []int64
+type Tstring string
+
+func main() {
+	s := "hello"
+	sb := []byte("hello")
+	sr := []rune("hello")
+	si := []int64{'h', 'e', 'l', 'l', 'o'}
+
+	ts := Tstring(s)
+	tsb := Tbyte(sb)
+	tsr := Trune(sr)
+	tsi := Tint64(si)
+
+	_ = string(s)
+	_ = []byte(s)
+	_ = []rune(s)
+	_ = []int64(s) // ERROR "cannot convert.*\[\]int64|invalid type conversion"
+	_ = Tstring(s)
+	_ = Tbyte(s)
+	_ = Trune(s)
+	_ = Tint64(s) // ERROR "cannot convert.*Tint64|invalid type conversion"
+
+	_ = string(sb)
+	_ = []byte(sb)
+	_ = []rune(sb)  // ERROR "cannot convert.*\[\]rune|invalid type conversion"
+	_ = []int64(sb) // ERROR "cannot convert.*\[\]int64|invalid type conversion"
+	_ = Tstring(sb)
+	_ = Tbyte(sb)
+	_ = Trune(sb)  // ERROR "cannot convert.*Trune|invalid type conversion"
+	_ = Tint64(sb) // ERROR "cannot convert.*Tint64|invalid type conversion"
+
+	_ = string(sr)
+	_ = []byte(sr) // ERROR "cannot convert.*\[\]byte|invalid type conversion"
+	_ = []rune(sr)
+	_ = []int64(sr) // ERROR "cannot convert.*\[\]int64|invalid type conversion"
+	_ = Tstring(sr)
+	_ = Tbyte(sr) // ERROR "cannot convert.*Tbyte|invalid type conversion"
+	_ = Trune(sr)
+	_ = Tint64(sr) // ERROR "cannot convert.*Tint64|invalid type conversion"
+
+	_ = string(si) // ERROR "cannot convert.* string|invalid type conversion"
+	_ = []byte(si) // ERROR "cannot convert.*\[\]byte|invalid type conversion"
+	_ = []rune(si) // ERROR "cannot convert.*\[\]rune|invalid type conversion"
+	_ = []int64(si)
+	_ = Tstring(si) // ERROR "cannot convert.*Tstring|invalid type conversion"
+	_ = Tbyte(si)   // ERROR "cannot convert.*Tbyte|invalid type conversion"
+	_ = Trune(si)   // ERROR "cannot convert.*Trune|invalid type conversion"
+	_ = Tint64(si)
+
+	_ = string(ts)
+	_ = []byte(ts)
+	_ = []rune(ts)
+	_ = []int64(ts) // ERROR "cannot convert.*\[\]int64|invalid type conversion"
+	_ = Tstring(ts)
+	_ = Tbyte(ts)
+	_ = Trune(ts)
+	_ = Tint64(ts) // ERROR "cannot convert.*Tint64|invalid type conversion"
+
+	_ = string(tsb)
+	_ = []byte(tsb)
+	_ = []rune(tsb)  // ERROR "cannot convert.*\[\]rune|invalid type conversion"
+	_ = []int64(tsb) // ERROR "cannot convert.*\[\]int64|invalid type conversion"
+	_ = Tstring(tsb)
+	_ = Tbyte(tsb)
+	_ = Trune(tsb)  // ERROR "cannot convert.*Trune|invalid type conversion"
+	_ = Tint64(tsb) // ERROR "cannot convert.*Tint64|invalid type conversion"
+
+	_ = string(tsr)
+	_ = []byte(tsr) // ERROR "cannot convert.*\[\]byte|invalid type conversion"
+	_ = []rune(tsr)
+	_ = []int64(tsr) // ERROR "cannot convert.*\[\]int64|invalid type conversion"
+	_ = Tstring(tsr)
+	_ = Tbyte(tsr) // ERROR "cannot convert.*Tbyte|invalid type conversion"
+	_ = Trune(tsr)
+	_ = Tint64(tsr) // ERROR "cannot convert.*Tint64|invalid type conversion"
+
+	_ = string(tsi) // ERROR "cannot convert.* string|invalid type conversion"
+	_ = []byte(tsi) // ERROR "cannot convert.*\[\]byte|invalid type conversion"
+	_ = []rune(tsi) // ERROR "cannot convert.*\[\]rune|invalid type conversion"
+	_ = []int64(tsi)
+	_ = Tstring(tsi) // ERROR "cannot convert.*Tstring|invalid type conversion"
+	_ = Tbyte(tsi)   // ERROR "cannot convert.*Tbyte|invalid type conversion"
+	_ = Trune(tsi)   // ERROR "cannot convert.*Trune|invalid type conversion"
+	_ = Tint64(tsi)
+}
diff --git a/test/convert3.go b/test/convert3.go
index be68c95b3..143aff04f 100644
--- a/test/convert3.go
+++ b/test/convert3.go
@@ -1,9 +1,12 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Verify allowed and disallowed conversions.
+// Does not compile.
+
 package main
 
 // everything here is legal except the ERROR line
diff --git a/test/convlit.go b/test/convlit.go
index 90ac5490c..8a6145d2a 100644
--- a/test/convlit.go
+++ b/test/convlit.go
@@ -1,14 +1,15 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Verify that illegal assignments with both explicit and implicit conversions of literals are detected.
+// Does not compile.
+
 package main
 
-// explicit conversion of constants is work in progress.
-// the ERRORs in this block are debatable, but they're what
-// the language spec says for now.
+// explicit conversion of constants
 var x1 = string(1)
 var x2 string = string(1)
 var x3 = int(1.5)     // ERROR "convert|truncate"
@@ -36,7 +37,7 @@ var good3 int = 1e9
 var good4 float64 = 1e20
 
 // explicit conversion of string is okay
-var _ = []int("abc")
+var _ = []rune("abc")
 var _ = []byte("abc")
 
 // implicit is not
@@ -47,20 +48,20 @@ var _ []byte = "abc" // ERROR "cannot use|incompatible|invalid"
 type Tstring string
 
 var ss Tstring = "abc"
-var _ = []int(ss)
+var _ = []rune(ss)
 var _ = []byte(ss)
 
 // implicit is still not
-var _ []int = ss  // ERROR "cannot use|incompatible|invalid"
+var _ []rune = ss // ERROR "cannot use|incompatible|invalid"
 var _ []byte = ss // ERROR "cannot use|incompatible|invalid"
 
-// named slice is not
-type Tint []int
+// named slice is now ok
+type Trune []rune
 type Tbyte []byte
 
-var _ = Tint("abc")  // ERROR "convert|incompatible|invalid"
-var _ = Tbyte("abc") // ERROR "convert|incompatible|invalid"
+var _ = Trune("abc") // ok
+var _ = Tbyte("abc") // ok
 
 // implicit is still not
-var _ Tint = "abc"  // ERROR "cannot use|incompatible|invalid"
+var _ Trune = "abc" // ERROR "cannot use|incompatible|invalid"
 var _ Tbyte = "abc" // ERROR "cannot use|incompatible|invalid"
diff --git a/test/convlit1.go b/test/convlit1.go
index 1e6673cb6..c06bd7443 100644
--- a/test/convlit1.go
+++ b/test/convlit1.go
@@ -1,9 +1,12 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Verify that illegal uses of composite literals are detected.
+// Does not compile.
+
 package main
 
 var a = []int { "a" };	// ERROR "conver|incompatible|cannot"
diff --git a/test/copy.go b/test/copy.go
index 0b5bddbed..65ffb6ff8 100644
--- a/test/copy.go
+++ b/test/copy.go
@@ -1,10 +1,10 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
-// Semi-exhaustive test for copy()
+// Semi-exhaustive test for the copy predeclared function.
 
 package main
 
diff --git a/test/crlf.go b/test/crlf.go
new file mode 100644
index 000000000..292b63bf4
--- /dev/null
+++ b/test/crlf.go
@@ -0,0 +1,52 @@
+// $G $D/$F.go && $L $F.$A && ./$A.out >tmp.go &&
+// $G tmp.go && $L tmp.$A && ./$A.out
+// rm -f tmp.go
+
+// Copyright 2011 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.
+
+// Test source files and strings containing \r and \r\n.
+
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	prog = strings.Replace(prog, "BQ", "`", -1)
+	prog = strings.Replace(prog, "CR", "\r", -1)
+	fmt.Print(prog)
+}
+
+var prog = `
+package main
+CR
+
+import "fmt"
+
+var CR s = "hello\n" + CR
+	" world"CR
+
+var t = BQhelloCR
+ worldBQ
+
+var u = BQhCReCRlCRlCRoCR
+ worldBQ
+
+var golden = "hello\n world"
+
+func main() {
+	if s != golden {
+		fmt.Printf("s=%q, want %q", s, golden)
+	}
+	if t != golden {
+		fmt.Printf("t=%q, want %q", t, golden)
+	}
+	if u != golden {
+		fmt.Printf("u=%q, want %q", u, golden)
+	}
+}
+`
diff --git a/test/ddd.go b/test/ddd.go
index b95d6e883..01768b89f 100644
--- a/test/ddd.go
+++ b/test/ddd.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // 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.
 
+// Test variadic functions and calls (dot-dot-dot).
+
 package main
 
 func sum(args ...int) int {
@@ -58,6 +60,10 @@ type U struct {
 	*T
 }
 
+type I interface {
+	Sum(...int) int
+}
+
 func main() {
 	if x := sum(1, 2, 3); x != 6 {
 		println("sum 6", x)
@@ -205,7 +211,14 @@ func main() {
 		println("i(=u).Sum", x)
 		panic("fail")
 	}
-	/* TODO(rsc): Enable once nested method expressions work.
+	var s struct {
+		I
+	}
+	s.I = &u
+	if x := s.Sum(2, 3, 5, 8); x != 18 {
+		println("s{&u}.Sum", x)
+		panic("fail")
+	}
 	if x := (*U).Sum(&U{}, 1, 3, 5, 2); x != 11 {
 		println("(*U).Sum", x)
 		panic("fail")
@@ -214,5 +227,4 @@ func main() {
 		println("U.Sum", x)
 		panic("fail")
 	}
-	*/
 }
diff --git a/test/ddd1.go b/test/ddd1.go
index 83e32de7b..1e070093c 100644
--- a/test/ddd1.go
+++ b/test/ddd1.go
@@ -1,9 +1,12 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // 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.
 
+// Verify that illegal uses of ... are detected.
+// Does not compile.
+
 package main
 
 import "unsafe"
@@ -15,8 +18,8 @@ var (
 	_ = sum()
 	_ = sum(1.0, 2.0)
 	_ = sum(1.5)      // ERROR "integer"
-	_ = sum("hello")  // ERROR "string.*as type int|incompatible"
-	_ = sum([]int{1}) // ERROR "slice literal.*as type int|incompatible"
+	_ = sum("hello")  // ERROR ".hello. .type string. as type int|incompatible"
+	_ = sum([]int{1}) // ERROR "\[\]int literal.*as type int|incompatible"
 )
 
 type T []T
diff --git a/test/ddd2.go b/test/ddd2.go
index a06af0c06..a141a39c7 100644
--- a/test/ddd2.go
+++ b/test/ddd2.go
@@ -1,9 +1,11 @@
-// true
+// skip
 
 // 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.
 
+// This file is compiled and then imported by ddd3.go.
+
 package ddd
 
 func Sum(args ...int) int {
diff --git a/test/ddd3.go b/test/ddd3.go
index 5d5ebdf0f..82fce3149 100644
--- a/test/ddd3.go
+++ b/test/ddd3.go
@@ -4,6 +4,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// Test that variadic functions work across package boundaries.
+
 package main
 
 import "./ddd2"
diff --git a/test/decl.go b/test/decl.go
index 95b6346c3..6f84245f1 100644
--- a/test/decl.go
+++ b/test/decl.go
@@ -1,10 +1,10 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
-// Correct short declarations and redeclarations.
+// Test correct short declarations and redeclarations.
 
 package main
 
diff --git a/test/declbad.go b/test/declbad.go
index 09f1dfb57..32d68e7ea 100644
--- a/test/declbad.go
+++ b/test/declbad.go
@@ -1,10 +1,11 @@
-// errchk $G -e $F.go
+// errorcheck
 
 // Copyright 2009 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.
 
-// Incorrect short declarations and redeclarations.
+// Test that incorrect short declarations and redeclarations are detected.
+// Does not compile.
 
 package main
 
diff --git a/test/defer.go b/test/defer.go
index bef8fbe26..2f67d3560 100644
--- a/test/defer.go
+++ b/test/defer.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test defer.
+
 package main
 
 import "fmt"
diff --git a/test/deferprint.go b/test/deferprint.go
index f1e75266f..72c98b19f 100644
--- a/test/deferprint.go
+++ b/test/deferprint.go
@@ -1,14 +1,17 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// cmpout
 
 // 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.
 
+// Test that we can defer the predeclared functions print and println.
+
 package main
 
 func main() {
 	defer println(42, true, false, true, 1.5, "world", (chan int)(nil), []int(nil), (map[string]int)(nil), (func())(nil), byte(255))
 	defer println(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20)
-//	defer panic("dead")
+	// Disabled so the test doesn't crash but left here for reference.
+	// defer panic("dead")
 	defer print("printing: ")
 }
diff --git a/test/deferprint.out b/test/deferprint.out
new file mode 100644
index 000000000..a71cfcebd
--- /dev/null
+++ b/test/deferprint.out
@@ -0,0 +1,2 @@
+printing: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
+42 true false true +1.500000e+000 world 0x0 [0/0]0x0 0x0 0x0 255
diff --git a/test/divide.go b/test/divide.go
index 5c0f45059..c91a33e9d 100644
--- a/test/divide.go
+++ b/test/divide.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2011 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.
 
-// divide corner cases
+// Test divide corner cases.
 
 package main
 
diff --git a/test/dwarf/linedirectives.go b/test/dwarf/linedirectives.go
index 68434f0ab..cc4ffb000 100755..100644
--- a/test/dwarf/linedirectives.go
+++ b/test/dwarf/linedirectives.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/empty.go b/test/empty.go
index fa10d6931..92a79a4e0 100644
--- a/test/empty.go
+++ b/test/empty.go
@@ -1,9 +1,12 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2009 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.
 
+// Test that top-level parenthesized declarations can be empty.
+// Compiles but does not run.
+
 package P
 
 import ( )
diff --git a/test/env.go b/test/env.go
index 28113bcb0..972374679 100644
--- a/test/env.go
+++ b/test/env.go
@@ -1,9 +1,12 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test that the Go environment variables are present and accessible through
+// package os and package runtime.
+
 package main
 
 import (
@@ -12,18 +15,14 @@ import (
 )
 
 func main() {
-	ga, e0 := os.Getenverror("GOARCH")
-	if e0 != nil {
-		print("$GOARCH: ", e0.String(), "\n")
-		os.Exit(1)
-	}
+	ga := os.Getenv("GOARCH")
 	if ga != runtime.GOARCH {
 		print("$GOARCH=", ga, "!= runtime.GOARCH=", runtime.GOARCH, "\n")
 		os.Exit(1)
 	}
-	xxx, e1 := os.Getenverror("DOES_NOT_EXIST")
-	if e1 != os.ENOENV {
-		print("$DOES_NOT_EXIST=", xxx, "; err = ", e1.String(), "\n")
+	xxx := os.Getenv("DOES_NOT_EXIST")
+	if xxx != "" {
+		print("$DOES_NOT_EXIST=", xxx, "\n")
 		os.Exit(1)
 	}
 }
diff --git a/test/eof.go b/test/eof.go
index 81f9fd028..06c779046 100644
--- a/test/eof.go
+++ b/test/eof.go
@@ -1,9 +1,12 @@
-// $G $D/$F.go
+// compile
 
 // 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.
 
+// Test a source file does not need a final newline.
+// Compiles but does not run.
+
 // No newline at the end of this file.
 
 package main
 \ No newline at end of file
diff --git a/test/eof1.go b/test/eof1.go
index c39a3cfdb..2105b8908 100644
--- a/test/eof1.go
+++ b/test/eof1.go
@@ -1,9 +1,12 @@
-// $G $D/$F.go
+// compile
 
 // 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.
 
-package main
+// Test that a comment ending a source file does not need a final newline.
+// Compiles but does not run.
+
+package eof1
 
 // No newline at the end of this comment.
 \ No newline at end of file
diff --git a/test/escape.go b/test/escape.go
index d4d844704..e487bb895 100644
--- a/test/escape.go
+++ b/test/escape.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -6,8 +6,8 @@
 
 package main
 
-// check for correct heap-moving of escaped variables.
-// it is hard to check for the allocations, but it is easy
+// Test for correct heap-moving of escaped variables.
+// It is hard to check for the allocations, but it is easy
 // to check that if you call the function twice at the
 // same stack level, the pointers returned should be
 // different.
diff --git a/test/escape2.go b/test/escape2.go
new file mode 100644
index 000000000..624ea80b5
--- /dev/null
+++ b/test/escape2.go
@@ -0,0 +1,1067 @@
+// errchk -0 $G -m -l $D/$F.go
+
+// 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.
+
+// Test, using compiler diagnostic flags, that the escape analysis is working.
+// Compiles but does not run.  Inlining is disabled.
+
+package foo
+
+import (
+	"fmt"
+	"unsafe"
+)
+
+var gxx *int
+
+func foo1(x int) { // ERROR "moved to heap: x"
+	gxx = &x // ERROR "&x escapes to heap"
+}
+
+func foo2(yy *int) { // ERROR "leaking param: yy"
+	gxx = yy
+}
+
+func foo3(x int) *int { // ERROR "moved to heap: x"
+	return &x // ERROR "&x escapes to heap"
+}
+
+type T *T
+
+func foo3b(t T) { // ERROR "leaking param: t"
+	*t = t
+}
+
+// xx isn't going anywhere, so use of yy is ok
+func foo4(xx, yy *int) { // ERROR "xx does not escape" "yy does not escape"
+	xx = yy
+}
+
+// xx isn't going anywhere, so taking address of yy is ok
+func foo5(xx **int, yy *int) { // ERROR "xx does not escape" "yy does not escape"
+	xx = &yy // ERROR "&yy does not escape"
+}
+
+func foo6(xx **int, yy *int) { // ERROR "xx does not escape" "leaking param: yy"
+	*xx = yy
+}
+
+func foo7(xx **int, yy *int) { // ERROR "xx does not escape" "yy does not escape"
+	**xx = *yy
+}
+
+func foo8(xx, yy *int) int { // ERROR "xx does not escape" "yy does not escape"
+	xx = yy
+	return *xx
+}
+
+func foo9(xx, yy *int) *int { // ERROR "leaking param: xx" "leaking param: yy"
+	xx = yy
+	return xx
+}
+
+func foo10(xx, yy *int) { // ERROR "xx does not escape" "yy does not escape"
+	*xx = *yy
+}
+
+func foo11() int {
+	x, y := 0, 42
+	xx := &x // ERROR "&x does not escape"
+	yy := &y // ERROR "&y does not escape"
+	*xx = *yy
+	return x
+}
+
+var xxx **int
+
+func foo12(yyy **int) { // ERROR "leaking param: yyy"
+	xxx = yyy
+}
+
+func foo13(yyy **int) { // ERROR "yyy does not escape"
+	*xxx = *yyy
+}
+
+func foo14(yyy **int) { // ERROR "yyy does not escape"
+	**xxx = **yyy
+}
+
+func foo15(yy *int) { // ERROR "moved to heap: yy"
+	xxx = &yy // ERROR "&yy escapes to heap"
+}
+
+func foo16(yy *int) { // ERROR "leaking param: yy"
+	*xxx = yy
+}
+
+func foo17(yy *int) { // ERROR "yy does not escape"
+	**xxx = *yy
+}
+
+func foo18(y int) { // ERROR "moved to heap: "y"
+	*xxx = &y // ERROR "&y escapes to heap"
+}
+
+func foo19(y int) {
+	**xxx = y
+}
+
+type Bar struct {
+	i  int
+	ii *int
+}
+
+func NewBar() *Bar {
+	return &Bar{42, nil} // ERROR "&Bar literal escapes to heap"
+}
+
+func NewBarp(x *int) *Bar { // ERROR "leaking param: x"
+	return &Bar{42, x} // ERROR "&Bar literal escapes to heap"
+}
+
+func NewBarp2(x *int) *Bar { // ERROR "x does not escape"
+	return &Bar{*x, nil} // ERROR "&Bar literal escapes to heap"
+}
+
+func (b *Bar) NoLeak() int { // ERROR "b does not escape"
+	return *(b.ii)
+}
+
+func (b *Bar) Leak() *int { // ERROR "leaking param: b"
+	return &b.i // ERROR "&b.i escapes to heap"
+}
+
+func (b *Bar) AlsoNoLeak() *int { // ERROR "b does not escape"
+	return b.ii
+}
+
+func (b Bar) AlsoLeak() *int { // ERROR "leaking param: b"
+	return b.ii
+}
+
+func (b Bar) LeaksToo() *int { // ERROR "leaking param: b"
+	v := 0	// ERROR "moved to heap: v"
+	b.ii = &v // ERROR "&v escapes"
+	return b.ii
+}
+
+func (b *Bar) LeaksABit() *int { // ERROR "b does not escape"
+	v := 0	// ERROR "moved to heap: v"
+	b.ii = &v // ERROR "&v escapes"
+	return b.ii
+}
+
+func (b Bar) StillNoLeak() int { // ERROR "b does not escape"
+	v := 0
+	b.ii = &v // ERROR "&v does not escape"
+	return b.i
+}
+
+func goLeak(b *Bar) { // ERROR "leaking param: b"
+	go b.NoLeak()
+}
+
+type Bar2 struct {
+	i  [12]int
+	ii []int
+}
+
+func NewBar2() *Bar2 {
+	return &Bar2{[12]int{42}, nil} // ERROR "&Bar2 literal escapes to heap"
+}
+
+func (b *Bar2) NoLeak() int { // ERROR "b does not escape"
+	return b.i[0]
+}
+
+func (b *Bar2) Leak() []int { // ERROR "leaking param: b"
+	return b.i[:] // ERROR "b.i escapes to heap"
+}
+
+func (b *Bar2) AlsoNoLeak() []int { // ERROR "b does not escape"
+	return b.ii[0:1]
+}
+
+func (b Bar2) AgainNoLeak() [12]int { // ERROR "b does not escape"
+	return b.i
+}
+
+func (b *Bar2) LeakSelf() { // ERROR "leaking param: b"
+	b.ii = b.i[0:4] // ERROR "b.i escapes to heap"
+}
+
+func (b *Bar2) LeakSelf2() { // ERROR "leaking param: b"
+	var buf []int
+	buf = b.i[0:] // ERROR "b.i escapes to heap"
+	b.ii = buf
+}
+
+func foo21() func() int {
+	x := 42             // ERROR "moved to heap: x"
+	return func() int { // ERROR "func literal escapes to heap"
+		return x // ERROR "&x escapes to heap"
+	}
+}
+
+func foo22() int {
+	x := 42
+	return func() int { // ERROR "func literal does not escape"
+		return x
+	}()
+}
+
+func foo23(x int) func() int { // ERROR "moved to heap: x"
+	return func() int { // ERROR "func literal escapes to heap"
+		return x // ERROR "&x escapes to heap"
+	}
+}
+
+func foo23a(x int) func() int { // ERROR "moved to heap: x"
+	f := func() int { // ERROR "func literal escapes to heap"
+		return x // ERROR "&x escapes to heap"
+	}
+	return f
+}
+
+func foo23b(x int) *(func() int) { // ERROR "moved to heap: x"
+	f := func() int { return x } // ERROR "moved to heap: f" "func literal escapes to heap" "&x escapes to heap"
+	return &f                    // ERROR "&f escapes to heap"
+}
+
+func foo24(x int) int {
+	return func() int { // ERROR "func literal does not escape"
+		return x
+	}()
+}
+
+var x *int
+
+func fooleak(xx *int) int { // ERROR "leaking param: xx"
+	x = xx
+	return *x
+}
+
+func foonoleak(xx *int) int { // ERROR "xx does not escape"
+	return *x + *xx
+}
+
+func foo31(x int) int { // ERROR "moved to heap: x"
+	return fooleak(&x) // ERROR "&x escapes to heap"
+}
+
+func foo32(x int) int {
+	return foonoleak(&x) // ERROR "&x does not escape"
+}
+
+type Foo struct {
+	xx *int
+	x  int
+}
+
+var F Foo
+var pf *Foo
+
+func (f *Foo) fooleak() { // ERROR "leaking param: f"
+	pf = f
+}
+
+func (f *Foo) foonoleak() { // ERROR "f does not escape"
+	F.x = f.x
+}
+
+func (f *Foo) Leak() { // ERROR "leaking param: f"
+	f.fooleak()
+}
+
+func (f *Foo) NoLeak() { // ERROR "f does not escape"
+	f.foonoleak()
+}
+
+func foo41(x int) { // ERROR "moved to heap: x"
+	F.xx = &x // ERROR "&x escapes to heap"
+}
+
+func (f *Foo) foo42(x int) { // ERROR "f does not escape" "moved to heap: x"
+	f.xx = &x // ERROR "&x escapes to heap"
+}
+
+func foo43(f *Foo, x int) { // ERROR "f does not escape" "moved to heap: x"
+	f.xx = &x // ERROR "&x escapes to heap"
+}
+
+func foo44(yy *int) { // ERROR "leaking param: yy"
+	F.xx = yy
+}
+
+func (f *Foo) foo45() { // ERROR "f does not escape"
+	F.x = f.x
+}
+
+func (f *Foo) foo46() { // ERROR "f does not escape"
+	F.xx = f.xx
+}
+
+func (f *Foo) foo47() { // ERROR "leaking param: f"
+	f.xx = &f.x // ERROR "&f.x escapes to heap"
+}
+
+var ptrSlice []*int
+
+func foo50(i *int) { // ERROR "leaking param: i"
+	ptrSlice[0] = i
+}
+
+var ptrMap map[*int]*int
+
+func foo51(i *int) { // ERROR "leaking param: i"
+	ptrMap[i] = i
+}
+
+func indaddr1(x int) *int { // ERROR "moved to heap: x"
+	return &x // ERROR "&x escapes to heap"
+}
+
+func indaddr2(x *int) *int { // ERROR "leaking param: x"
+	return *&x // ERROR "&x does not escape"
+}
+
+func indaddr3(x *int32) *int { // ERROR "leaking param: x"
+	return *(**int)(unsafe.Pointer(&x)) // ERROR "&x does not escape"
+}
+
+// From package math:
+
+func Float32bits(f float32) uint32 {
+	return *(*uint32)(unsafe.Pointer(&f)) // ERROR "&f does not escape"
+}
+
+func Float32frombits(b uint32) float32 {
+	return *(*float32)(unsafe.Pointer(&b)) // ERROR "&b does not escape"
+}
+
+func Float64bits(f float64) uint64 {
+	return *(*uint64)(unsafe.Pointer(&f)) // ERROR "&f does not escape"
+}
+
+func Float64frombits(b uint64) float64 {
+	return *(*float64)(unsafe.Pointer(&b)) // ERROR "&b does not escape"
+}
+
+// contrast with
+func float64bitsptr(f float64) *uint64 { // ERROR "moved to heap: f"
+	return (*uint64)(unsafe.Pointer(&f)) // ERROR "&f escapes to heap"
+}
+
+func float64ptrbitsptr(f *float64) *uint64 { // ERROR "leaking param: f"
+	return (*uint64)(unsafe.Pointer(f))
+}
+
+func typesw(i interface{}) *int { // ERROR "leaking param: i"
+	switch val := i.(type) {
+	case *int:
+		return val
+	case *int8:
+		v := int(*val) // ERROR "moved to heap: v"
+		return &v      // ERROR "&v escapes to heap"
+	}
+	return nil
+}
+
+func exprsw(i *int) *int { // ERROR "leaking param: i"
+	switch j := i; *j + 110 {
+	case 12:
+		return j
+	case 42:
+		return nil
+	}
+	return nil
+
+}
+
+// assigning to an array element is like assigning to the array
+func foo60(i *int) *int { // ERROR "leaking param: i"
+	var a [12]*int
+	a[0] = i
+	return a[1]
+}
+
+func foo60a(i *int) *int { // ERROR "i does not escape"
+	var a [12]*int
+	a[0] = i
+	return nil
+}
+
+// assigning to a struct field  is like assigning to the struct
+func foo61(i *int) *int { // ERROR "leaking param: i"
+	type S struct {
+		a, b *int
+	}
+	var s S
+	s.a = i
+	return s.b
+}
+
+func foo61a(i *int) *int { // ERROR "i does not escape"
+	type S struct {
+		a, b *int
+	}
+	var s S
+	s.a = i
+	return nil
+}
+
+// assigning to a struct field is like assigning to the struct but
+// here this subtlety is lost, since s.a counts as an assignment to a
+// track-losing dereference.
+func foo62(i *int) *int { // ERROR "leaking param: i"
+	type S struct {
+		a, b *int
+	}
+	s := new(S) // ERROR "new[(]S[)] does not escape"
+	s.a = i
+	return nil // s.b
+}
+
+type M interface {
+	M()
+}
+
+func foo63(m M) { // ERROR "m does not escape"
+}
+
+func foo64(m M) { // ERROR "leaking param: m"
+	m.M()
+}
+
+func foo64b(m M) { // ERROR "leaking param: m"
+	defer m.M()
+}
+
+type MV int
+
+func (MV) M() {}
+
+func foo65() {
+	var mv MV
+	foo63(&mv) // ERROR "&mv does not escape"
+}
+
+func foo66() {
+	var mv MV  // ERROR "moved to heap: mv"
+	foo64(&mv) // ERROR "&mv escapes to heap"
+}
+
+func foo67() {
+	var mv MV
+	foo63(mv)
+}
+
+func foo68() {
+	var mv MV
+	foo64(mv) // escapes but it's an int so irrelevant
+}
+
+func foo69(m M) { // ERROR "leaking param: m"
+	foo64(m)
+}
+
+func foo70(mv1 *MV, m M) { // ERROR "leaking param: mv1" "leaking param: m"
+	m = mv1
+	foo64(m)
+}
+
+func foo71(x *int) []*int { // ERROR "leaking param: x"
+	var y []*int
+	y = append(y, x)
+	return y
+}
+
+func foo71a(x int) []*int { // ERROR "moved to heap: x"
+	var y []*int
+	y = append(y, &x) // ERROR "&x escapes to heap"
+	return y
+}
+
+func foo72() {
+	var x int
+	var y [1]*int
+	y[0] = &x // ERROR "&x does not escape"
+}
+
+func foo72aa() [10]*int {
+	var x int // ERROR "moved to heap: x"
+	var y [10]*int
+	y[0] = &x // ERROR "&x escapes to heap"
+	return y
+}
+
+func foo72a() {
+	var y [10]*int
+	for i := 0; i < 10; i++ {
+		// escapes its scope
+		x := i    // ERROR "moved to heap: x"
+		y[i] = &x // ERROR "&x escapes to heap"
+	}
+	return
+}
+
+func foo72b() [10]*int {
+	var y [10]*int
+	for i := 0; i < 10; i++ {
+		x := i    // ERROR "moved to heap: x"
+		y[i] = &x // ERROR "&x escapes to heap"
+	}
+	return y
+}
+
+// issue 2145
+func foo73() {
+	s := []int{3, 2, 1} // ERROR "\[\]int literal does not escape"
+	for _, v := range s {
+		vv := v // ERROR "moved to heap: vv"
+		// actually just escapes its scope
+		defer func() { // ERROR "func literal escapes to heap"
+			println(vv) // ERROR "&vv escapes to heap"
+		}()
+	}
+}
+
+func foo74() {
+	s := []int{3, 2, 1} // ERROR "\[\]int literal does not escape"
+	for _, v := range s {
+		vv := v // ERROR "moved to heap: vv"
+		// actually just escapes its scope
+		fn := func() { // ERROR "func literal escapes to heap"
+			println(vv) // ERROR "&vv escapes to heap"
+		}
+		defer fn()
+	}
+}
+
+func myprint(y *int, x ...interface{}) *int { // ERROR "x does not escape" "leaking param: y"
+	return y
+}
+
+func myprint1(y *int, x ...interface{}) *interface{} { // ERROR "y does not escape" "leaking param: x"
+	return &x[0] // ERROR "&x.0. escapes to heap"
+}
+
+func foo75(z *int) { // ERROR "leaking param: z"
+	myprint(z, 1, 2, 3) // ERROR "[.][.][.] argument does not escape"
+}
+
+func foo75a(z *int) { // ERROR "z does not escape"
+	myprint1(z, 1, 2, 3) // ERROR "[.][.][.] argument escapes to heap"
+}
+
+func foo76(z *int) { // ERROR "leaking param: z"
+	myprint(nil, z) // ERROR "[.][.][.] argument does not escape"
+}
+
+func foo76a(z *int) { // ERROR "leaking param: z"
+	myprint1(nil, z) // ERROR "[.][.][.] argument escapes to heap"
+}
+
+func foo76b() {
+	myprint(nil, 1, 2, 3) // ERROR "[.][.][.] argument does not escape"
+}
+
+func foo76c() {
+	myprint1(nil, 1, 2, 3) // ERROR "[.][.][.] argument escapes to heap"
+}
+
+func foo76d() {
+	defer myprint(nil, 1, 2, 3) // ERROR "[.][.][.] argument does not escape"
+}
+
+func foo76e() {
+	defer myprint1(nil, 1, 2, 3) // ERROR "[.][.][.] argument escapes to heap"
+}
+
+func foo76f() {
+	for {
+		// TODO: This one really only escapes its scope, but we don't distinguish yet.
+		defer myprint(nil, 1, 2, 3) // ERROR "[.][.][.] argument escapes to heap"
+	}
+}
+
+func foo76g() {
+	for {
+		defer myprint1(nil, 1, 2, 3) // ERROR "[.][.][.] argument escapes to heap"
+	}
+}
+
+func foo77(z []interface{}) { // ERROR "z does not escape"
+	myprint(nil, z...) // z does not escape
+}
+
+func foo77a(z []interface{}) { // ERROR "leaking param: z"
+	myprint1(nil, z...)
+}
+
+func foo78(z int) *int { // ERROR "moved to heap: z"
+	return &z // ERROR "&z escapes to heap"
+}
+
+func foo78a(z int) *int { // ERROR "moved to heap: z"
+	y := &z   // ERROR "&z escapes to heap"
+	x := &y   // ERROR "&y does not escape"
+	return *x // really return y
+}
+
+func foo79() *int {
+	return new(int) // ERROR "new[(]int[)] escapes to heap"
+}
+
+func foo80() *int {
+	var z *int
+	for {
+		// Really just escapes its scope but we don't distinguish
+		z = new(int) // ERROR "new[(]int[)] escapes to heap"
+	}
+	_ = z
+	return nil
+}
+
+func foo81() *int {
+	for {
+		z := new(int) // ERROR "new[(]int[)] does not escape"
+		_ = z
+	}
+	return nil
+}
+
+type Fooer interface {
+	Foo()
+}
+
+type LimitedFooer struct {
+	Fooer
+	N int64
+}
+
+func LimitFooer(r Fooer, n int64) Fooer { // ERROR "leaking param: r"
+	return &LimitedFooer{r, n} // ERROR "&LimitedFooer literal escapes to heap"
+}
+
+func foo90(x *int) map[*int]*int { // ERROR "leaking param: x"
+	return map[*int]*int{nil: x} // ERROR "map\[\*int\]\*int literal escapes to heap"
+}
+
+func foo91(x *int) map[*int]*int { // ERROR "leaking param: x"
+	return map[*int]*int{x: nil} // ERROR "map\[\*int\]\*int literal escapes to heap"
+}
+
+func foo92(x *int) [2]*int { // ERROR "leaking param: x"
+	return [2]*int{x, nil}
+}
+
+// does not leak c
+func foo93(c chan *int) *int { // ERROR "c does not escape"
+	for v := range c {
+		return v
+	}
+	return nil
+}
+
+// does not leak m
+func foo94(m map[*int]*int, b bool) *int { // ERROR "m does not escape"
+	for k, v := range m {
+		if b {
+			return k
+		}
+		return v
+	}
+	return nil
+}
+
+// does leak x
+func foo95(m map[*int]*int, x *int) { // ERROR "m does not escape" "leaking param: x"
+	m[x] = x
+}
+
+// does not leak m
+func foo96(m []*int) *int { // ERROR "m does not escape"
+	return m[0]
+}
+
+// does leak m
+func foo97(m [1]*int) *int { // ERROR "leaking param: m"
+	return m[0]
+}
+
+// does not leak m
+func foo98(m map[int]*int) *int { // ERROR "m does not escape"
+	return m[0]
+}
+
+// does leak m
+func foo99(m *[1]*int) []*int { // ERROR "leaking param: m"
+	return m[:]
+}
+
+// does not leak m
+func foo100(m []*int) *int { // ERROR "m does not escape"
+	for _, v := range m {
+		return v
+	}
+	return nil
+}
+
+// does leak m
+func foo101(m [1]*int) *int { // ERROR "leaking param: m"
+	for _, v := range m {
+		return v
+	}
+	return nil
+}
+
+// does not leak m
+func foo101a(m [1]*int) *int { // ERROR "m does not escape"
+	for i := range m { // ERROR "moved to heap: i"
+		return &i // ERROR "&i escapes to heap"
+	}
+	return nil
+}
+
+// does leak x
+func foo102(m []*int, x *int) { // ERROR "m does not escape" "leaking param: x"
+	m[0] = x
+}
+
+// does not leak x
+func foo103(m [1]*int, x *int) { // ERROR "m does not escape" "x does not escape"
+	m[0] = x
+}
+
+var y []*int
+
+// does not leak x
+func foo104(x []*int) { // ERROR "x does not escape"
+	copy(y, x)
+}
+
+// does not leak x
+func foo105(x []*int) { // ERROR "x does not escape"
+	_ = append(y, x...)
+}
+
+// does leak x
+func foo106(x *int) { // ERROR "leaking param: x"
+	_ = append(y, x)
+}
+
+func foo107(x *int) map[*int]*int { // ERROR "leaking param: x"
+	return map[*int]*int{x: nil} // ERROR "map.* literal escapes to heap"
+}
+
+func foo108(x *int) map[*int]*int { // ERROR "leaking param: x"
+	return map[*int]*int{nil: x} // ERROR "map.* literal escapes to heap"
+}
+
+func foo109(x *int) *int { // ERROR "leaking param: x"
+	m := map[*int]*int{x: nil} // ERROR "map.* literal does not escape"
+	for k, _ := range m {
+		return k
+	}
+	return nil
+}
+
+func foo110(x *int) *int { // ERROR "leaking param: x"
+	m := map[*int]*int{nil: x} // ERROR "map.* literal does not escape"
+	return m[nil]
+}
+
+func foo111(x *int) *int { // ERROR "leaking param: x"
+	m := []*int{x} // ERROR "\[\]\*int literal does not escape"
+	return m[0]
+}
+
+func foo112(x *int) *int { // ERROR "leaking param: x"
+	m := [1]*int{x}
+	return m[0]
+}
+
+func foo113(x *int) *int { // ERROR "leaking param: x"
+	m := Bar{ii: x}
+	return m.ii
+}
+
+func foo114(x *int) *int { // ERROR "leaking param: x"
+	m := &Bar{ii: x} // ERROR "&Bar literal does not escape"
+	return m.ii
+}
+
+func foo115(x *int) *int { // ERROR "leaking param: x"
+	return (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(x)) + 1))
+}
+
+func foo116(b bool) *int {
+	if b {
+		x := 1    // ERROR "moved to heap: x"
+		return &x // ERROR "&x escapes to heap"
+	} else {
+		y := 1    // ERROR "moved to heap: y"
+		return &y // ERROR "&y escapes to heap"
+	}
+	return nil
+}
+
+func foo117(unknown func(interface{})) { // ERROR "unknown does not escape"
+	x := 1      // ERROR "moved to heap: x"
+	unknown(&x) // ERROR "&x escapes to heap"
+}
+
+func foo118(unknown func(*int)) { // ERROR "unknown does not escape"
+	x := 1      // ERROR "moved to heap: x"
+	unknown(&x) // ERROR "&x escapes to heap"
+}
+
+func external(*int)
+
+func foo119(x *int) { // ERROR "leaking param: x"
+	external(x)
+}
+
+func foo120() {
+	// formerly exponential time analysis
+L1:
+L2:
+L3:
+L4:
+L5:
+L6:
+L7:
+L8:
+L9:
+L10:
+L11:
+L12:
+L13:
+L14:
+L15:
+L16:
+L17:
+L18:
+L19:
+L20:
+L21:
+L22:
+L23:
+L24:
+L25:
+L26:
+L27:
+L28:
+L29:
+L30:
+L31:
+L32:
+L33:
+L34:
+L35:
+L36:
+L37:
+L38:
+L39:
+L40:
+L41:
+L42:
+L43:
+L44:
+L45:
+L46:
+L47:
+L48:
+L49:
+L50:
+L51:
+L52:
+L53:
+L54:
+L55:
+L56:
+L57:
+L58:
+L59:
+L60:
+L61:
+L62:
+L63:
+L64:
+L65:
+L66:
+L67:
+L68:
+L69:
+L70:
+L71:
+L72:
+L73:
+L74:
+L75:
+L76:
+L77:
+L78:
+L79:
+L80:
+L81:
+L82:
+L83:
+L84:
+L85:
+L86:
+L87:
+L88:
+L89:
+L90:
+L91:
+L92:
+L93:
+L94:
+L95:
+L96:
+L97:
+L98:
+L99:
+L100:
+	// use the labels to silence compiler errors
+	goto L1
+	goto L2
+	goto L3
+	goto L4
+	goto L5
+	goto L6
+	goto L7
+	goto L8
+	goto L9
+	goto L10
+	goto L11
+	goto L12
+	goto L13
+	goto L14
+	goto L15
+	goto L16
+	goto L17
+	goto L18
+	goto L19
+	goto L20
+	goto L21
+	goto L22
+	goto L23
+	goto L24
+	goto L25
+	goto L26
+	goto L27
+	goto L28
+	goto L29
+	goto L30
+	goto L31
+	goto L32
+	goto L33
+	goto L34
+	goto L35
+	goto L36
+	goto L37
+	goto L38
+	goto L39
+	goto L40
+	goto L41
+	goto L42
+	goto L43
+	goto L44
+	goto L45
+	goto L46
+	goto L47
+	goto L48
+	goto L49
+	goto L50
+	goto L51
+	goto L52
+	goto L53
+	goto L54
+	goto L55
+	goto L56
+	goto L57
+	goto L58
+	goto L59
+	goto L60
+	goto L61
+	goto L62
+	goto L63
+	goto L64
+	goto L65
+	goto L66
+	goto L67
+	goto L68
+	goto L69
+	goto L70
+	goto L71
+	goto L72
+	goto L73
+	goto L74
+	goto L75
+	goto L76
+	goto L77
+	goto L78
+	goto L79
+	goto L80
+	goto L81
+	goto L82
+	goto L83
+	goto L84
+	goto L85
+	goto L86
+	goto L87
+	goto L88
+	goto L89
+	goto L90
+	goto L91
+	goto L92
+	goto L93
+	goto L94
+	goto L95
+	goto L96
+	goto L97
+	goto L98
+	goto L99
+	goto L100
+}
+
+func foo121() {
+	for i := 0; i < 10; i++ {
+		defer myprint(nil, i) // ERROR "[.][.][.] argument escapes to heap"
+		go myprint(nil, i)    // ERROR "[.][.][.] argument escapes to heap"
+	}
+}
+
+// same as foo121 but check across import
+func foo121b() {
+	for i := 0; i < 10; i++ {
+		defer fmt.Printf("%d", i) // ERROR "[.][.][.] argument escapes to heap"
+		go fmt.Printf("%d", i)    // ERROR "[.][.][.] argument escapes to heap"
+	}
+}
+
+// a harmless forward jump
+func foo122() {
+	var i *int
+
+	goto L1
+L1:
+	i = new(int) // ERROR "does not escape"
+	_ = i
+}
+
+// a backward jump, increases loopdepth
+func foo123() {
+	var i *int
+
+L1:
+	i = new(int) // ERROR "escapes"
+
+	goto L1
+	_ = i
+}
diff --git a/test/escape3.go b/test/escape3.go
new file mode 100644
index 000000000..4c1989151
--- /dev/null
+++ b/test/escape3.go
@@ -0,0 +1,36 @@
+// run
+
+// Copyright 2011 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.
+
+// Test the run-time behavior of escape analysis-related optimizations.
+
+package main
+
+func main() {
+	test1()
+}
+
+func test1() {
+	check1(0)
+	check1(1)
+	check1(2)
+}
+
+type T1 struct {
+	X, Y, Z int
+}
+
+func f() int {
+	return 1
+}
+
+func check1(pass int) T1 {
+	v := []T1{{X: f(), Z: f()}}
+	if v[0].Y != 0 {
+		panic("nonzero init")
+	}
+	v[0].Y = pass
+	return v[0]
+}
diff --git a/test/escape4.go b/test/escape4.go
new file mode 100644
index 000000000..887570896
--- /dev/null
+++ b/test/escape4.go
@@ -0,0 +1,39 @@
+// errchk -0 $G -m $D/$F.go
+
+// 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.
+
+// Test, using compiler diagnostic flags, that the escape analysis is working.
+// Compiles but does not run.  Inlining is enabled.
+
+package foo
+
+var p *int
+
+func alloc(x int) *int { // ERROR "can inline alloc" "moved to heap: x"
+	return &x // ERROR "&x escapes to heap"
+}
+
+var f func()
+
+func f1() {
+	p = alloc(2) // ERROR "inlining call to alloc" "&x escapes to heap" "moved to heap: x"
+
+	// Escape analysis used to miss inlined code in closures.
+
+	func() { // ERROR "func literal does not escape"
+		p = alloc(3) // ERROR "inlining call to alloc" "&x escapes to heap" "moved to heap: x"
+	}()
+
+	f = func() { // ERROR "func literal escapes to heap"
+		p = alloc(3) // ERROR "inlining call to alloc" "&x escapes to heap" "moved to heap: x"
+	}
+	f()
+}
+
+func f2() {} // ERROR "can inline f2"
+
+// No inline for panic, recover.
+func f3() { panic(1) }
+func f4() { recover() }
diff --git a/test/fixedbugs/bug000.go b/test/fixedbugs/bug000.go
index ccb24e8e9..9104a57aa 100644
--- a/test/fixedbugs/bug000.go
+++ b/test/fixedbugs/bug000.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug002.go b/test/fixedbugs/bug002.go
index 230841974..3493426d3 100644
--- a/test/fixedbugs/bug002.go
+++ b/test/fixedbugs/bug002.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug003.go b/test/fixedbugs/bug003.go
index e45975be4..7165d9d20 100644
--- a/test/fixedbugs/bug003.go
+++ b/test/fixedbugs/bug003.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug004.go b/test/fixedbugs/bug004.go
index 20f467a5f..fb207e9bc 100644
--- a/test/fixedbugs/bug004.go
+++ b/test/fixedbugs/bug004.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug005.go b/test/fixedbugs/bug005.go
index 3bd2fe815..3798f8321 100644
--- a/test/fixedbugs/bug005.go
+++ b/test/fixedbugs/bug005.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug006.go b/test/fixedbugs/bug006.go
index 43b5dfb12..6761682b3 100644
--- a/test/fixedbugs/bug006.go
+++ b/test/fixedbugs/bug006.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug007.go b/test/fixedbugs/bug007.go
index d65f6da45..3d9fcb9e0 100644
--- a/test/fixedbugs/bug007.go
+++ b/test/fixedbugs/bug007.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug008.go b/test/fixedbugs/bug008.go
index 2baead11e..48f74a52d 100644
--- a/test/fixedbugs/bug008.go
+++ b/test/fixedbugs/bug008.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug009.go b/test/fixedbugs/bug009.go
index ef8263bb2..0467b297a 100644
--- a/test/fixedbugs/bug009.go
+++ b/test/fixedbugs/bug009.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug010.go b/test/fixedbugs/bug010.go
index 7d96988d4..f54b1d54a 100644
--- a/test/fixedbugs/bug010.go
+++ b/test/fixedbugs/bug010.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug011.go b/test/fixedbugs/bug011.go
index ce627472c..519c3585f 100644
--- a/test/fixedbugs/bug011.go
+++ b/test/fixedbugs/bug011.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug012.go b/test/fixedbugs/bug012.go
index ffd5b5570..38efb6d97 100644
--- a/test/fixedbugs/bug012.go
+++ b/test/fixedbugs/bug012.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug013.go b/test/fixedbugs/bug013.go
index 4b106775c..045786bf7 100644
--- a/test/fixedbugs/bug013.go
+++ b/test/fixedbugs/bug013.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug014.go b/test/fixedbugs/bug014.go
index dac2ce517..a20f0310e 100644
--- a/test/fixedbugs/bug014.go
+++ b/test/fixedbugs/bug014.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -11,4 +11,5 @@ func main() {
 	var c01 uint8 = '\07';  // ERROR "oct|char"
 	var cx0 uint8 = '\x0';  // ERROR "hex|char"
 	var cx1 uint8 = '\x';  // ERROR "hex|char"
+	_, _, _, _ = c00, c01, cx0, cx1
 }
diff --git a/test/fixedbugs/bug015.go b/test/fixedbugs/bug015.go
index 9178f626f..d3a9f22ed 100644
--- a/test/fixedbugs/bug015.go
+++ b/test/fixedbugs/bug015.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug016.go b/test/fixedbugs/bug016.go
index 4fbfd48fd..18fac78f3 100644
--- a/test/fixedbugs/bug016.go
+++ b/test/fixedbugs/bug016.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug017.go b/test/fixedbugs/bug017.go
index fdc986d9d..2f5960d10 100644
--- a/test/fixedbugs/bug017.go
+++ b/test/fixedbugs/bug017.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug020.go b/test/fixedbugs/bug020.go
index 896bf5707..cde3f8679 100644
--- a/test/fixedbugs/bug020.go
+++ b/test/fixedbugs/bug020.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug021.go b/test/fixedbugs/bug021.go
index 201fa5f03..bf936e875 100644
--- a/test/fixedbugs/bug021.go
+++ b/test/fixedbugs/bug021.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug022.go b/test/fixedbugs/bug022.go
index f94a58569..65a8bfe9a 100644
--- a/test/fixedbugs/bug022.go
+++ b/test/fixedbugs/bug022.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug023.go b/test/fixedbugs/bug023.go
index b3d3d4a3c..9b211cd54 100644
--- a/test/fixedbugs/bug023.go
+++ b/test/fixedbugs/bug023.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug024.go b/test/fixedbugs/bug024.go
index c7b17b7c0..2e235b7b4 100644
--- a/test/fixedbugs/bug024.go
+++ b/test/fixedbugs/bug024.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug026.go b/test/fixedbugs/bug026.go
index eacea3745..bfd03cc95 100644
--- a/test/fixedbugs/bug026.go
+++ b/test/fixedbugs/bug026.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug027.go b/test/fixedbugs/bug027.go
index acc295d51..874b47e7a 100644
--- a/test/fixedbugs/bug027.go
+++ b/test/fixedbugs/bug027.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -6,53 +6,76 @@
 
 package main
 
+import "fmt"
+
 type Element interface {
 }
 
 type Vector struct {
-	nelem int;
-	elem []Element;
+	nelem int
+	elem  []Element
 }
 
 func New() *Vector {
-	v := new(Vector);
-	v.nelem = 0;
-	v.elem = make([]Element, 10);
-	return v;
+	v := new(Vector)
+	v.nelem = 0
+	v.elem = make([]Element, 10)
+	return v
 }
 
 func (v *Vector) At(i int) Element {
-	return v.elem[i];
+	return v.elem[i]
 }
 
 func (v *Vector) Insert(e Element) {
-	v.elem[v.nelem] = e;
-	v.nelem++;
+	v.elem[v.nelem] = e
+	v.nelem++
 }
 
 func main() {
-	type I struct { val int; };
-	i0 := new(I); i0.val = 0;
-	i1 := new(I); i1.val = 11;
-	i2 := new(I); i2.val = 222;
-	i3 := new(I); i3.val = 3333;
-	i4 := new(I); i4.val = 44444;
-	v := New();
-	print("hi\n");
-	v.Insert(i4);
-	v.Insert(i3);
-	v.Insert(i2);
-	v.Insert(i1);
-	v.Insert(i0);
+	type I struct{ val int }
+	i0 := new(I)
+	i0.val = 0
+	i1 := new(I)
+	i1.val = 11
+	i2 := new(I)
+	i2.val = 222
+	i3 := new(I)
+	i3.val = 3333
+	i4 := new(I)
+	i4.val = 44444
+	v := New()
+	r := "hi\n"
+	v.Insert(i4)
+	v.Insert(i3)
+	v.Insert(i2)
+	v.Insert(i1)
+	v.Insert(i0)
 	for i := 0; i < v.nelem; i++ {
-		var x *I;
-		x = v.At(i).(*I);
-		print(i, " ", x.val, "\n");  // prints correct list
+		var x *I
+		x = v.At(i).(*I)
+		r += fmt.Sprintln(i, x.val) // prints correct list
 	}
 	for i := 0; i < v.nelem; i++ {
-		print(i, " ", v.At(i).(*I).val, "\n");
+		r += fmt.Sprintln(i, v.At(i).(*I).val)
+	}
+	expect := `hi
+0 44444
+1 3333
+2 222
+3 11
+4 0
+0 44444
+1 3333
+2 222
+3 11
+4 0
+`
+	if r != expect {
+		panic(r)
 	}
 }
+
 /*
 bug027.go:50: illegal types for operand
 	(<Element>I{}) CONV (<I>{})
diff --git a/test/fixedbugs/bug028.go b/test/fixedbugs/bug028.go
index 0488ad2cb..2edf5a910 100644
--- a/test/fixedbugs/bug028.go
+++ b/test/fixedbugs/bug028.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug030.go b/test/fixedbugs/bug030.go
index 7efde9b44..ffd29e057 100644
--- a/test/fixedbugs/bug030.go
+++ b/test/fixedbugs/bug030.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug031.go b/test/fixedbugs/bug031.go
index acb4741e9..529e5ce84 100644
--- a/test/fixedbugs/bug031.go
+++ b/test/fixedbugs/bug031.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug035.go b/test/fixedbugs/bug035.go
index bd2a633f2..ae41a1795 100644
--- a/test/fixedbugs/bug035.go
+++ b/test/fixedbugs/bug035.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug036.go b/test/fixedbugs/bug036.go
deleted file mode 100644
index cc20516ce..000000000
--- a/test/fixedbugs/bug036.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// ! $G $D/$F.go >/dev/null
-// # ignoring error messages...
-
-// Copyright 2009 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.
-
-package main
-
-func main() {
-	s := float(0);
-	s := float(0);  // BUG redeclaration
-}
diff --git a/test/fixedbugs/bug037.go b/test/fixedbugs/bug037.go
index ff7d28710..f17fb3fd7 100644
--- a/test/fixedbugs/bug037.go
+++ b/test/fixedbugs/bug037.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug038.go b/test/fixedbugs/bug038.go
deleted file mode 100644
index 7585376a3..000000000
--- a/test/fixedbugs/bug038.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// ! $G $D/$F.go >/dev/null
-// # ignoring error messages...
-
-// Copyright 2009 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.
-
-package main
-
-func main() {
-	var z [3]byte;
-	z := new([3]byte);  // BUG redeclaration
-}
diff --git a/test/fixedbugs/bug039.go b/test/fixedbugs/bug039.go
index 7ac02ceeb..d34f5e62e 100644
--- a/test/fixedbugs/bug039.go
+++ b/test/fixedbugs/bug039.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug040.go b/test/fixedbugs/bug040.go
index 912316cb6..007f47f9f 100644
--- a/test/fixedbugs/bug040.go
+++ b/test/fixedbugs/bug040.go
@@ -1,5 +1,4 @@
-// ! $G $D/$F.go >/dev/null
-// # ignoring error messages...
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -7,5 +6,6 @@
 
 package main
 
-func main (x, x int) {  // BUG redeclaration error
+func f (x,		// GCCGO_ERROR "previous"
+	x int) {	// ERROR "redeclared|redefinition" "duplicate"
 }
diff --git a/test/fixedbugs/bug045.go b/test/fixedbugs/bug045.go
index 94888c40e..c66a2411a 100644
--- a/test/fixedbugs/bug045.go
+++ b/test/fixedbugs/bug045.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug046.go b/test/fixedbugs/bug046.go
index 8a9b79707..219e91d53 100644
--- a/test/fixedbugs/bug046.go
+++ b/test/fixedbugs/bug046.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug047.go b/test/fixedbugs/bug047.go
index 5a776abce..7619ae73c 100644
--- a/test/fixedbugs/bug047.go
+++ b/test/fixedbugs/bug047.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug048.go b/test/fixedbugs/bug048.go
index b9fee7899..48ad751e2 100644
--- a/test/fixedbugs/bug048.go
+++ b/test/fixedbugs/bug048.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug049.go b/test/fixedbugs/bug049.go
index 8fd67ccd5..51990f2df 100644
--- a/test/fixedbugs/bug049.go
+++ b/test/fixedbugs/bug049.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug050.go b/test/fixedbugs/bug050.go
index 585c44623..aba68b1dc 100644
--- a/test/fixedbugs/bug050.go
+++ b/test/fixedbugs/bug050.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug051.go b/test/fixedbugs/bug051.go
index dd1662306..c4ba2eff6 100644
--- a/test/fixedbugs/bug051.go
+++ b/test/fixedbugs/bug051.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug052.go b/test/fixedbugs/bug052.go
index d2c1b5061..440a00ebe 100644
--- a/test/fixedbugs/bug052.go
+++ b/test/fixedbugs/bug052.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug053.go b/test/fixedbugs/bug053.go
index c981403ed..00625fd7c 100644
--- a/test/fixedbugs/bug053.go
+++ b/test/fixedbugs/bug053.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug054.go b/test/fixedbugs/bug054.go
index c8a2272c2..01590585c 100644
--- a/test/fixedbugs/bug054.go
+++ b/test/fixedbugs/bug054.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug055.go b/test/fixedbugs/bug055.go
index 861739610..c3073cc1e 100644
--- a/test/fixedbugs/bug055.go
+++ b/test/fixedbugs/bug055.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug056.go b/test/fixedbugs/bug056.go
index 050a4a5c5..13eac2920 100644
--- a/test/fixedbugs/bug056.go
+++ b/test/fixedbugs/bug056.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug057.go b/test/fixedbugs/bug057.go
index d5d0f1d62..19b8651a5 100644
--- a/test/fixedbugs/bug057.go
+++ b/test/fixedbugs/bug057.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug058.go b/test/fixedbugs/bug058.go
index e2b4a241a..2b97dbf7c 100644
--- a/test/fixedbugs/bug058.go
+++ b/test/fixedbugs/bug058.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug059.go b/test/fixedbugs/bug059.go
index 6a77367d6..6f64b9e0b 100644
--- a/test/fixedbugs/bug059.go
+++ b/test/fixedbugs/bug059.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug060.go b/test/fixedbugs/bug060.go
index 82778b838..826072905 100644
--- a/test/fixedbugs/bug060.go
+++ b/test/fixedbugs/bug060.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug061.go b/test/fixedbugs/bug061.go
index aedcf70fe..ae99b186d 100644
--- a/test/fixedbugs/bug061.go
+++ b/test/fixedbugs/bug061.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug062.go b/test/fixedbugs/bug062.go
index 8ee5c84cb..1cc500365 100644
--- a/test/fixedbugs/bug062.go
+++ b/test/fixedbugs/bug062.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug063.go b/test/fixedbugs/bug063.go
index 543e0b726..a3ae3f096 100644
--- a/test/fixedbugs/bug063.go
+++ b/test/fixedbugs/bug063.go
@@ -1,8 +1,8 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2009 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.
 
-package main
+package bug063
 const c = 0 ^ 0
diff --git a/test/fixedbugs/bug064.go b/test/fixedbugs/bug064.go
index 92d215423..d8b3bea9a 100644
--- a/test/fixedbugs/bug064.go
+++ b/test/fixedbugs/bug064.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: compilation should succeed
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug065.go b/test/fixedbugs/bug065.go
index a5d1beddd..a1e3b08bb 100644
--- a/test/fixedbugs/bug065.go
+++ b/test/fixedbugs/bug065.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug066.go b/test/fixedbugs/bug066.go
index 2fa5048f1..db3d7f860 100644
--- a/test/fixedbugs/bug066.go
+++ b/test/fixedbugs/bug066.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2009 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.
 
-package main
+package bug066
 
 type Scope struct {
 	entries map[string] *Object;
diff --git a/test/fixedbugs/bug067.go b/test/fixedbugs/bug067.go
index b812f0116..aaeefb0ba 100644
--- a/test/fixedbugs/bug067.go
+++ b/test/fixedbugs/bug067.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -10,6 +10,6 @@ var c chan int
 
 func main() {
 	c = make(chan int);
-	go func() { print("ok\n"); c <- 0 } ();
+	go func() { c <- 0 } ();
 	<-c
 }
diff --git a/test/fixedbugs/bug068.go b/test/fixedbugs/bug068.go
index a7cf4239c..2cb10ab3a 100644
--- a/test/fixedbugs/bug068.go
+++ b/test/fixedbugs/bug068.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug069.go b/test/fixedbugs/bug069.go
index 9038387ac..7b07b773d 100644
--- a/test/fixedbugs/bug069.go
+++ b/test/fixedbugs/bug069.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug070.go b/test/fixedbugs/bug070.go
index 6afdd467d..3f3ffcf61 100644
--- a/test/fixedbugs/bug070.go
+++ b/test/fixedbugs/bug070.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -6,20 +6,35 @@
 
 package main
 
+import "fmt"
+
 func main() {
-	var i, k int;
-	outer:
-	for k=0; k<2; k++ {
-		print("outer loop top k ", k, "\n");
-		if k != 0 { panic("k not zero") }  // inner loop breaks this one every time
-		for i=0; i<2; i++ {
-			if i != 0 { panic("i not zero") }  // loop breaks every time
-			print("inner loop top i ", i, "\n");
+	var i, k int
+	var r string
+outer:
+	for k = 0; k < 2; k++ {
+		r += fmt.Sprintln("outer loop top k", k)
+		if k != 0 {
+			panic("k not zero")
+		} // inner loop breaks this one every time
+		for i = 0; i < 2; i++ {
+			if i != 0 {
+				panic("i not zero")
+			} // loop breaks every time
+			r += fmt.Sprintln("inner loop top i", i)
 			if true {
-				print("do break\n");
-				break outer;
+				r += "do break\n"
+				break outer
 			}
 		}
 	}
-	print("broke\n");
+	r += "broke\n"
+	expect := `outer loop top k 0
+inner loop top i 0
+do break
+broke
+`
+	if r != expect {
+		panic(r)
+	}
 }
diff --git a/test/fixedbugs/bug071.go b/test/fixedbugs/bug071.go
index a5003ffb9..ec38f7a97 100644
--- a/test/fixedbugs/bug071.go
+++ b/test/fixedbugs/bug071.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go || echo BUG: compiler crashes
+// compile
 
 // Copyright 2009 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.
 
-package main
+package bug071
 
 type rat struct  {
 	den  int;
diff --git a/test/fixedbugs/bug072.go b/test/fixedbugs/bug072.go
index efe5626db..05ad93dac 100644
--- a/test/fixedbugs/bug072.go
+++ b/test/fixedbugs/bug072.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug073.go b/test/fixedbugs/bug073.go
index 99e7cd19e..49b47ae46 100644
--- a/test/fixedbugs/bug073.go
+++ b/test/fixedbugs/bug073.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug074.go b/test/fixedbugs/bug074.go
index 7b6d14e7e..fb789cb4c 100644
--- a/test/fixedbugs/bug074.go
+++ b/test/fixedbugs/bug074.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug075.go b/test/fixedbugs/bug075.go
index 7aed13089..d0b7d14e7 100644
--- a/test/fixedbugs/bug075.go
+++ b/test/fixedbugs/bug075.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug076.go b/test/fixedbugs/bug076.go
index 2ca518d76..60aaa9760 100644
--- a/test/fixedbugs/bug076.go
+++ b/test/fixedbugs/bug076.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A
+// build
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug077.go b/test/fixedbugs/bug077.go
index 2cbf96d98..80581a8a3 100644
--- a/test/fixedbugs/bug077.go
+++ b/test/fixedbugs/bug077.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug078.go b/test/fixedbugs/bug078.go
index ddd3faeba..1041b858c 100644
--- a/test/fixedbugs/bug078.go
+++ b/test/fixedbugs/bug078.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug080.go b/test/fixedbugs/bug080.go
index bae16cdb2..32b2c53b9 100644
--- a/test/fixedbugs/bug080.go
+++ b/test/fixedbugs/bug080.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: fails incorrectly
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug081.go b/test/fixedbugs/bug081.go
index 026ce8002..c25d28837 100644
--- a/test/fixedbugs/bug081.go
+++ b/test/fixedbugs/bug081.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug082.go b/test/fixedbugs/bug082.go
index 8353ec200..e184ef193 100644
--- a/test/fixedbugs/bug082.go
+++ b/test/fixedbugs/bug082.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug084.go b/test/fixedbugs/bug084.go
index c1054e550..700a67433 100644
--- a/test/fixedbugs/bug084.go
+++ b/test/fixedbugs/bug084.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug085.go b/test/fixedbugs/bug085.go
index 02be71753..93ae7e0a4 100644
--- a/test/fixedbugs/bug085.go
+++ b/test/fixedbugs/bug085.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug086.go b/test/fixedbugs/bug086.go
index f96472fbb..fc69e0e3f 100644
--- a/test/fixedbugs/bug086.go
+++ b/test/fixedbugs/bug086.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug087.go b/test/fixedbugs/bug087.go
index 4af8d976f..67e7210cd 100644
--- a/test/fixedbugs/bug087.go
+++ b/test/fixedbugs/bug087.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: fails incorrectly
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug089.go b/test/fixedbugs/bug089.go
index fd3dff3ec..e88f17bab 100644
--- a/test/fixedbugs/bug089.go
+++ b/test/fixedbugs/bug089.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug090.go b/test/fixedbugs/bug090.go
index 8318ab9c0..320bd57f5 100644
--- a/test/fixedbugs/bug090.go
+++ b/test/fixedbugs/bug090.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug091.go b/test/fixedbugs/bug091.go
index c2ede7153..dbb1287a1 100644
--- a/test/fixedbugs/bug091.go
+++ b/test/fixedbugs/bug091.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug092.go b/test/fixedbugs/bug092.go
index 8f05c478f..8027d941e 100644
--- a/test/fixedbugs/bug092.go
+++ b/test/fixedbugs/bug092.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug093.go b/test/fixedbugs/bug093.go
index f80eee01f..acd94466f 100644
--- a/test/fixedbugs/bug093.go
+++ b/test/fixedbugs/bug093.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: fails incorrectly
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -10,7 +10,6 @@ type S struct {
 }
 
 func (p *S) M() {
-	print("M\n");
 }
 
 type I interface {
diff --git a/test/fixedbugs/bug094.go b/test/fixedbugs/bug094.go
index 2953eb28d..3ef11da3d 100644
--- a/test/fixedbugs/bug094.go
+++ b/test/fixedbugs/bug094.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: fails incorrectly
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug096.go b/test/fixedbugs/bug096.go
index 9be687a7b..411ba74e0 100644
--- a/test/fixedbugs/bug096.go
+++ b/test/fixedbugs/bug096.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug097.go b/test/fixedbugs/bug097.go
index ec3c21543..a067e0f57 100644
--- a/test/fixedbugs/bug097.go
+++ b/test/fixedbugs/bug097.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG wrong result
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug098.go b/test/fixedbugs/bug098.go
index 1dad4d502..eb4ee4de0 100644
--- a/test/fixedbugs/bug098.go
+++ b/test/fixedbugs/bug098.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug099.go b/test/fixedbugs/bug099.go
index f76f0e873..03a5c454b 100644
--- a/test/fixedbugs/bug099.go
+++ b/test/fixedbugs/bug099.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG should not crash
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug101.go b/test/fixedbugs/bug101.go
index 92487deaa..82e496a8a 100644
--- a/test/fixedbugs/bug101.go
+++ b/test/fixedbugs/bug101.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug102.go b/test/fixedbugs/bug102.go
index 1d97eb4a8..f1c2324b7 100644
--- a/test/fixedbugs/bug102.go
+++ b/test/fixedbugs/bug102.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: should not crash
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug103.go b/test/fixedbugs/bug103.go
index b789be1c4..1cb710e36 100644
--- a/test/fixedbugs/bug103.go
+++ b/test/fixedbugs/bug103.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug104.go b/test/fixedbugs/bug104.go
index dd4bb5834..f0c19a8aa 100644
--- a/test/fixedbugs/bug104.go
+++ b/test/fixedbugs/bug104.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug107.go b/test/fixedbugs/bug107.go
index d0b062a65..dcd8e9d11 100644
--- a/test/fixedbugs/bug107.go
+++ b/test/fixedbugs/bug107.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -6,7 +6,7 @@
 
 package main
 import os "os"
-type _ os.Error
+type _ os.FileInfo
 func f() (os int) {
 	 // In the next line "os" should refer to the result variable, not
 	 // to the package.
diff --git a/test/fixedbugs/bug108.go b/test/fixedbugs/bug108.go
index 5c7649f08..9f2a27ebd 100644
--- a/test/fixedbugs/bug108.go
+++ b/test/fixedbugs/bug108.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -7,4 +7,5 @@
 package main
 func f() {
 	v := 1 << 1025;		// ERROR "overflow|stupid shift"
+	_ = v
 }
diff --git a/test/fixedbugs/bug109.go b/test/fixedbugs/bug109.go
index 766657723..556dc34dd 100644
--- a/test/fixedbugs/bug109.go
+++ b/test/fixedbugs/bug109.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go || echo BUG: should compile
+// compile
 
 // Copyright 2009 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.
 
-package main
+package bug109
 
 func f(a float64) float64 {
 	e := 1.0
diff --git a/test/fixedbugs/bug110.go b/test/fixedbugs/bug110.go
index 4e43d1c01..5528ba3f1 100644
--- a/test/fixedbugs/bug110.go
+++ b/test/fixedbugs/bug110.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A || echo BUG: const bug
+// build
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug111.go b/test/fixedbugs/bug111.go
index e72b343ae..d977bd54f 100644
--- a/test/fixedbugs/bug111.go
+++ b/test/fixedbugs/bug111.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG should compile and run
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug112.go b/test/fixedbugs/bug112.go
index 3c932843c..e2ed5c0d4 100644
--- a/test/fixedbugs/bug112.go
+++ b/test/fixedbugs/bug112.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug113.go b/test/fixedbugs/bug113.go
index 4fd322d53..a1e61cb36 100644
--- a/test/fixedbugs/bug113.go
+++ b/test/fixedbugs/bug113.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && (! ./$A.out || echo BUG: should not succeed)
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -21,8 +21,24 @@ func main() {
 	if foo2(v2) != 1 {
 		panic(2)
 	}
+	
+	shouldPanic(p1)
+}
+
+func p1() {
+	var i I
+	i = 1
 	var v3 = i.(int32) // This type conversion should fail at runtime.
 	if foo2(v3) != 1 {
 		panic(3)
 	}
 }
+
+func shouldPanic(f func()) {
+	defer func() {
+		if recover() == nil {
+			panic("function should panic")
+		}
+	}()
+	f()
+}
diff --git a/test/fixedbugs/bug114.go b/test/fixedbugs/bug114.go
index 974b7cf26..99e66a2dd 100644
--- a/test/fixedbugs/bug114.go
+++ b/test/fixedbugs/bug114.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && (./$A.out || echo BUG: bug114 failed)
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug115.go b/test/fixedbugs/bug115.go
index 16b22d707..7cc3dc40a 100644
--- a/test/fixedbugs/bug115.go
+++ b/test/fixedbugs/bug115.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: bug115 should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug116.go b/test/fixedbugs/bug116.go
index 42ca80343..5d8e52031 100644
--- a/test/fixedbugs/bug116.go
+++ b/test/fixedbugs/bug116.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug116
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug117.go b/test/fixedbugs/bug117.go
index ad89ebf52..038826cbc 100644
--- a/test/fixedbugs/bug117.go
+++ b/test/fixedbugs/bug117.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug118.go b/test/fixedbugs/bug118.go
index 1271f5b0c..198b8ff28 100644
--- a/test/fixedbugs/bug118.go
+++ b/test/fixedbugs/bug118.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go || echo BUG should compile
+// compile
 
 // Copyright 2009 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.
 
-package main
+package bug118
 
 func Send(c chan int) int {
 	select {
diff --git a/test/fixedbugs/bug119.go b/test/fixedbugs/bug119.go
index 750507891..6f2514c24 100644
--- a/test/fixedbugs/bug119.go
+++ b/test/fixedbugs/bug119.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: should not fail
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug120.go b/test/fixedbugs/bug120.go
index 2a71957d8..58355e53d 100644
--- a/test/fixedbugs/bug120.go
+++ b/test/fixedbugs/bug120.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug120
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -41,16 +41,16 @@ func main() {
 	ok := true
 	for i := 0; i < len(tests); i++ {
 		t := tests[i]
-		v := strconv.Ftoa64(t.f, 'g', -1)
+		v := strconv.FormatFloat(t.f, 'g', -1, 64)
 		if v != t.out {
 			println("Bad float64 const:", t.in, "want", t.out, "got", v)
-			x, err := strconv.Atof64(t.out)
+			x, err := strconv.ParseFloat(t.out, 64)
 			if err != nil {
 				println("bug120: strconv.Atof64", t.out)
 				panic("fail")
 			}
-			println("\twant exact:", strconv.Ftoa64(x, 'g', 1000))
-			println("\tgot exact: ", strconv.Ftoa64(t.f, 'g', 1000))
+			println("\twant exact:", strconv.FormatFloat(x, 'g', 1000, 64))
+			println("\tgot exact: ", strconv.FormatFloat(t.f, 'g', 1000, 64))
 			ok = false
 		}
 	}
diff --git a/test/fixedbugs/bug121.go b/test/fixedbugs/bug121.go
index 15c8451da..5adf9827f 100644
--- a/test/fixedbugs/bug121.go
+++ b/test/fixedbugs/bug121.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug122.go b/test/fixedbugs/bug122.go
index 72bf38a83..fb4eb9f3a 100644
--- a/test/fixedbugs/bug122.go
+++ b/test/fixedbugs/bug122.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug123.go b/test/fixedbugs/bug123.go
index bdac67417..f38551a91 100644
--- a/test/fixedbugs/bug123.go
+++ b/test/fixedbugs/bug123.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug126.go b/test/fixedbugs/bug126.go
index a8d56e122..f5d976341 100644
--- a/test/fixedbugs/bug126.go
+++ b/test/fixedbugs/bug126.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug127.go b/test/fixedbugs/bug127.go
index 25b48114d..f8ea99470 100644
--- a/test/fixedbugs/bug127.go
+++ b/test/fixedbugs/bug127.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug128.go b/test/fixedbugs/bug128.go
index 3fd647c00..e8cbea079 100644
--- a/test/fixedbugs/bug128.go
+++ b/test/fixedbugs/bug128.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: should compile
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug129.go b/test/fixedbugs/bug129.go
index d1e2d8b56..157ce78ff 100644
--- a/test/fixedbugs/bug129.go
+++ b/test/fixedbugs/bug129.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG129
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug130.go b/test/fixedbugs/bug130.go
index 855c7072b..16b029af3 100644
--- a/test/fixedbugs/bug130.go
+++ b/test/fixedbugs/bug130.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: should run
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug131.go b/test/fixedbugs/bug131.go
index e5d4ca07d..0ebbd2606 100644
--- a/test/fixedbugs/bug131.go
+++ b/test/fixedbugs/bug131.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug132.go b/test/fixedbugs/bug132.go
index bab8996f1..e334566c7 100644
--- a/test/fixedbugs/bug132.go
+++ b/test/fixedbugs/bug132.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug135.go b/test/fixedbugs/bug135.go
index 470135ed4..34d234e22 100644
--- a/test/fixedbugs/bug135.go
+++ b/test/fixedbugs/bug135.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug136.go b/test/fixedbugs/bug136.go
index 7491b65d8..bea9bac08 100644
--- a/test/fixedbugs/bug136.go
+++ b/test/fixedbugs/bug136.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug137.go b/test/fixedbugs/bug137.go
index 9d43f431b..48368177a 100644
--- a/test/fixedbugs/bug137.go
+++ b/test/fixedbugs/bug137.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug139.go b/test/fixedbugs/bug139.go
index 2bdbef1c0..095e5c93c 100644
--- a/test/fixedbugs/bug139.go
+++ b/test/fixedbugs/bug139.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug140.go b/test/fixedbugs/bug140.go
index 441c57a48..8caf1d7d9 100644
--- a/test/fixedbugs/bug140.go
+++ b/test/fixedbugs/bug140.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug141.go b/test/fixedbugs/bug141.go
index 756ba308d..81ba6f1b5 100644
--- a/test/fixedbugs/bug141.go
+++ b/test/fixedbugs/bug141.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: should run
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -20,7 +20,7 @@ type Getter interface {
 
 func f1(p Empty) {
 	switch x := p.(type) {
-	default: println("failed to match interface"); os.Exit(1);
+	default: println("failed to match interface", x); os.Exit(1);
 	case Getter: break;
 	}
 
diff --git a/test/fixedbugs/bug142.go b/test/fixedbugs/bug142.go
index e54458baf..e28d889a9 100644
--- a/test/fixedbugs/bug142.go
+++ b/test/fixedbugs/bug142.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug142
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug143.go b/test/fixedbugs/bug143.go
index 2f575fcfe..a43e40667 100644
--- a/test/fixedbugs/bug143.go
+++ b/test/fixedbugs/bug143.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug144.go b/test/fixedbugs/bug144.go
index bab9a4402..9f8ec7667 100644
--- a/test/fixedbugs/bug144.go
+++ b/test/fixedbugs/bug144.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug145.go b/test/fixedbugs/bug145.go
index c59bcebd6..602fe7426 100644
--- a/test/fixedbugs/bug145.go
+++ b/test/fixedbugs/bug145.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug146.go b/test/fixedbugs/bug146.go
index 16324c741..e29f910ba 100644
--- a/test/fixedbugs/bug146.go
+++ b/test/fixedbugs/bug146.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug147.go b/test/fixedbugs/bug147.go
index a16630b87..e8b3d2439 100644
--- a/test/fixedbugs/bug147.go
+++ b/test/fixedbugs/bug147.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug147
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug148.go b/test/fixedbugs/bug148.go
index daedff105..b67870b12 100644
--- a/test/fixedbugs/bug148.go
+++ b/test/fixedbugs/bug148.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ! ./$A.out || echo BUG: should crash
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -8,6 +8,8 @@ package main
 
 type T struct {a, b int};
 
+func println(x, y int) { }
+
 func f(x interface{}) interface{} {
 	type T struct {a, b int};
 
@@ -24,16 +26,29 @@ func main() {
 	inner_T := f(nil);
 	f(inner_T);
 
+	shouldPanic(p1)
+}
+
+func p1() {
 	outer_T := T{5, 7};
 	f(outer_T);
 }
 
+func shouldPanic(f func()) {
+	defer func() {
+		if recover() == nil {
+			panic("function should panic")
+		}
+	}()
+	f()
+}
+
 /*
 This prints:
 
 2 3
 5 7
 
-but it should crash: The type assertion on line 14 should fail
+but it should crash: The type assertion on line 18 should fail
 for the 2nd call to f with outer_T.
 */
diff --git a/test/fixedbugs/bug149.go b/test/fixedbugs/bug149.go
index a40403b7d..78b687e97 100644
--- a/test/fixedbugs/bug149.go
+++ b/test/fixedbugs/bug149.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug150.go b/test/fixedbugs/bug150.go
index fc25444b6..b565ef73d 100644
--- a/test/fixedbugs/bug150.go
+++ b/test/fixedbugs/bug150.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go || echo BUG: bug150 
+// compile
 
 // Copyright 2009 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.
 
-package main
+package bug150
 
 type T int
 func (t T) M()
diff --git a/test/fixedbugs/bug151.go b/test/fixedbugs/bug151.go
index 46546dfe1..d9f5e021c 100644
--- a/test/fixedbugs/bug151.go
+++ b/test/fixedbugs/bug151.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go || echo BUG: bug151
+// compile
 
 // Copyright 2009 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.
 
-package main
+package bug151
 
 type S string
 
diff --git a/test/fixedbugs/bug1515.go b/test/fixedbugs/bug1515.go
index 740252516..a4baccda7 100644
--- a/test/fixedbugs/bug1515.go
+++ b/test/fixedbugs/bug1515.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug152.go b/test/fixedbugs/bug152.go
index 30c3cac91..45b9b3d53 100644
--- a/test/fixedbugs/bug152.go
+++ b/test/fixedbugs/bug152.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug154.go b/test/fixedbugs/bug154.go
index 4371cc5ce..a2cfd4acc 100644
--- a/test/fixedbugs/bug154.go
+++ b/test/fixedbugs/bug154.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: should not panic
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug155.go b/test/fixedbugs/bug155.go
index 312c8e6a9..8872e978d 100644
--- a/test/fixedbugs/bug155.go
+++ b/test/fixedbugs/bug155.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A || echo BUG: bug155
+// build
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug156.go b/test/fixedbugs/bug156.go
index 0b77a72d9..f26658729 100644
--- a/test/fixedbugs/bug156.go
+++ b/test/fixedbugs/bug156.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: bug156
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug157.go b/test/fixedbugs/bug157.go
index 9bf68f7a4..1072d7df4 100644
--- a/test/fixedbugs/bug157.go
+++ b/test/fixedbugs/bug157.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug158.go b/test/fixedbugs/bug158.go
index cdf3195fe..496d7e0db 100644
--- a/test/fixedbugs/bug158.go
+++ b/test/fixedbugs/bug158.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug159.go b/test/fixedbugs/bug159.go
index 1aa64433a..92d534563 100644
--- a/test/fixedbugs/bug159.go
+++ b/test/fixedbugs/bug159.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug159
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug161.go b/test/fixedbugs/bug161.go
index e5f25f746..aab58ee89 100644
--- a/test/fixedbugs/bug161.go
+++ b/test/fixedbugs/bug161.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug163.go b/test/fixedbugs/bug163.go
index 919298e6f..d69f6bef0 100644
--- a/test/fixedbugs/bug163.go
+++ b/test/fixedbugs/bug163.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug164.go b/test/fixedbugs/bug164.go
index 746f631ae..888b495ee 100644
--- a/test/fixedbugs/bug164.go
+++ b/test/fixedbugs/bug164.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug165.go b/test/fixedbugs/bug165.go
index 8ce67a46d..f8d50af13 100644
--- a/test/fixedbugs/bug165.go
+++ b/test/fixedbugs/bug165.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug167.go b/test/fixedbugs/bug167.go
index 33eb3cb1a..3a50e6ff0 100644
--- a/test/fixedbugs/bug167.go
+++ b/test/fixedbugs/bug167.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A || echo BUG: bug167
+// build
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug168.go b/test/fixedbugs/bug168.go
index e25eb56b0..53301fa81 100644
--- a/test/fixedbugs/bug168.go
+++ b/test/fixedbugs/bug168.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug168
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug169.go b/test/fixedbugs/bug169.go
index c42727f38..f63c2f3e1 100644
--- a/test/fixedbugs/bug169.go
+++ b/test/fixedbugs/bug169.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug170.go b/test/fixedbugs/bug170.go
index e7f1c5120..11ff5ff3c 100644
--- a/test/fixedbugs/bug170.go
+++ b/test/fixedbugs/bug170.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug171.go b/test/fixedbugs/bug171.go
index 5357b2adc..49bbb3b89 100644
--- a/test/fixedbugs/bug171.go
+++ b/test/fixedbugs/bug171.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug172.go b/test/fixedbugs/bug172.go
index 1837a1158..4dbe7930f 100644
--- a/test/fixedbugs/bug172.go
+++ b/test/fixedbugs/bug172.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug173.go b/test/fixedbugs/bug173.go
index 898b8400b..6479bb253 100644
--- a/test/fixedbugs/bug173.go
+++ b/test/fixedbugs/bug173.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: bug173
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug174.go b/test/fixedbugs/bug174.go
index 7ff865513..448f63086 100644
--- a/test/fixedbugs/bug174.go
+++ b/test/fixedbugs/bug174.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: bug174
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug175.go b/test/fixedbugs/bug175.go
index a8f6e3ca4..5fca4b22b 100644
--- a/test/fixedbugs/bug175.go
+++ b/test/fixedbugs/bug175.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -10,5 +10,5 @@ func f() (int, bool) { return 0, true }
 
 func main() {
 	x, y := f(), 2;	// ERROR "multi"
+	_, _ = x, y
 }
-
diff --git a/test/fixedbugs/bug176.go b/test/fixedbugs/bug176.go
index 5820df308..82f8dba0a 100644
--- a/test/fixedbugs/bug176.go
+++ b/test/fixedbugs/bug176.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug177.go b/test/fixedbugs/bug177.go
index a120ad0ab..9f2c1ea52 100644
--- a/test/fixedbugs/bug177.go
+++ b/test/fixedbugs/bug177.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug178.go b/test/fixedbugs/bug178.go
index a7ff09dae..2bae5a1c5 100644
--- a/test/fixedbugs/bug178.go
+++ b/test/fixedbugs/bug178.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug179.go b/test/fixedbugs/bug179.go
index 3347613d8..dea82fe0a 100644
--- a/test/fixedbugs/bug179.go
+++ b/test/fixedbugs/bug179.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug180.go b/test/fixedbugs/bug180.go
index 96823fb3a..cfdcfab26 100644
--- a/test/fixedbugs/bug180.go
+++ b/test/fixedbugs/bug180.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug181.go b/test/fixedbugs/bug181.go
index f87bc9d4e..4827e9cf0 100644
--- a/test/fixedbugs/bug181.go
+++ b/test/fixedbugs/bug181.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug182.go b/test/fixedbugs/bug182.go
index 81df2ca13..e02dc59f8 100644
--- a/test/fixedbugs/bug182.go
+++ b/test/fixedbugs/bug182.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug183.go b/test/fixedbugs/bug183.go
index 7fd6e4942..dc9f5356e 100644
--- a/test/fixedbugs/bug183.go
+++ b/test/fixedbugs/bug183.go
@@ -1,4 +1,4 @@
-//errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug184.go b/test/fixedbugs/bug184.go
index 3cc984535..c084ea5cf 100644
--- a/test/fixedbugs/bug184.go
+++ b/test/fixedbugs/bug184.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug185.go b/test/fixedbugs/bug185.go
index acae174f4..890900600 100644
--- a/test/fixedbugs/bug185.go
+++ b/test/fixedbugs/bug185.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug186.go b/test/fixedbugs/bug186.go
index dde794a5d..5aefd7e5c 100644
--- a/test/fixedbugs/bug186.go
+++ b/test/fixedbugs/bug186.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug187.go b/test/fixedbugs/bug187.go
index 66aa5f024..5c3c2bb1e 100644
--- a/test/fixedbugs/bug187.go
+++ b/test/fixedbugs/bug187.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug188.go b/test/fixedbugs/bug188.go
index e1cbce05d..550614789 100644
--- a/test/fixedbugs/bug188.go
+++ b/test/fixedbugs/bug188.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug189.go b/test/fixedbugs/bug189.go
index ce338305c..9e412c66d 100644
--- a/test/fixedbugs/bug189.go
+++ b/test/fixedbugs/bug189.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug190.go b/test/fixedbugs/bug190.go
index da0bfde0f..bb2d81cbb 100644
--- a/test/fixedbugs/bug190.go
+++ b/test/fixedbugs/bug190.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug192.go b/test/fixedbugs/bug192.go
index 282ed30d3..679aaed1f 100644
--- a/test/fixedbugs/bug192.go
+++ b/test/fixedbugs/bug192.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug193.go b/test/fixedbugs/bug193.go
index 5ef02b1c1..64e06da89 100644
--- a/test/fixedbugs/bug193.go
+++ b/test/fixedbugs/bug193.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug194.go b/test/fixedbugs/bug194.go
index dcd633dde..297652903 100644
--- a/test/fixedbugs/bug194.go
+++ b/test/fixedbugs/bug194.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG should compile and run
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug195.go b/test/fixedbugs/bug195.go
index 65ab02a03..85367cb88 100644
--- a/test/fixedbugs/bug195.go
+++ b/test/fixedbugs/bug195.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -23,5 +23,5 @@ type I5 interface {
 }
 
 type I6 interface {
-	I5	// GC_ERROR "interface"
+	I5	// ERROR "interface"
 }
diff --git a/test/fixedbugs/bug196.go b/test/fixedbugs/bug196.go
index ea8ab0dc1..5255de189 100644
--- a/test/fixedbugs/bug196.go
+++ b/test/fixedbugs/bug196.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug196
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug197.go b/test/fixedbugs/bug197.go
index c205c5bca..4a9f103ea 100644
--- a/test/fixedbugs/bug197.go
+++ b/test/fixedbugs/bug197.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug198.go b/test/fixedbugs/bug198.go
index ea71fad58..73bb64688 100644
--- a/test/fixedbugs/bug198.go
+++ b/test/fixedbugs/bug198.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug199.go b/test/fixedbugs/bug199.go
index 71226290f..f69f23b59 100644
--- a/test/fixedbugs/bug199.go
+++ b/test/fixedbugs/bug199.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug200.go b/test/fixedbugs/bug200.go
index 123f68728..da628faf5 100644
--- a/test/fixedbugs/bug200.go
+++ b/test/fixedbugs/bug200.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -12,7 +12,7 @@ func main() {
 	// and worse, compiled the wrong code
 	// for one of them.
 	var x interface{};
-	switch v := x.(type) {
+	switch x.(type) {
 	case func(int):
 	case func(f int):	// ERROR "duplicate"
 	}
diff --git a/test/fixedbugs/bug201.go b/test/fixedbugs/bug201.go
index f7db62fc9..59248231a 100644
--- a/test/fixedbugs/bug201.go
+++ b/test/fixedbugs/bug201.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug202.go b/test/fixedbugs/bug202.go
index 2fc91b520..49871e3e0 100644
--- a/test/fixedbugs/bug202.go
+++ b/test/fixedbugs/bug202.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG should run
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug203.go b/test/fixedbugs/bug203.go
index bf86ee912..2fb084bd6 100644
--- a/test/fixedbugs/bug203.go
+++ b/test/fixedbugs/bug203.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug204.go b/test/fixedbugs/bug204.go
index d4534c27c..8810a5f92 100644
--- a/test/fixedbugs/bug204.go
+++ b/test/fixedbugs/bug204.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -7,18 +7,18 @@
 package main
 
 func main() {
-	nchar := 0;
-	a := []int { '日', '本', '語', 0xFFFD };
+	nchar := 0
+	a := []rune{'日', '本', '語', 0xFFFD}
 	for _, char := range "日本語\xc0" {
 		if nchar >= len(a) {
-			println("BUG");
-			break;
+			println("BUG")
+			break
 		}
 		if char != a[nchar] {
-			println("expected", a[nchar], "got", char);
-			println("BUG");
-			break;
+			println("expected", a[nchar], "got", char)
+			println("BUG")
+			break
 		}
-		nchar++;
+		nchar++
 	}
 }
diff --git a/test/fixedbugs/bug205.go b/test/fixedbugs/bug205.go
index e12be72f9..de17cb698 100644
--- a/test/fixedbugs/bug205.go
+++ b/test/fixedbugs/bug205.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug207.go b/test/fixedbugs/bug207.go
index 5810d6690..50923df1c 100644
--- a/test/fixedbugs/bug207.go
+++ b/test/fixedbugs/bug207.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug208.go b/test/fixedbugs/bug208.go
index 13b040084..09ec0afbe 100644
--- a/test/fixedbugs/bug208.go
+++ b/test/fixedbugs/bug208.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug209.go b/test/fixedbugs/bug209.go
index ae6f10f60..52faf1fb9 100644
--- a/test/fixedbugs/bug209.go
+++ b/test/fixedbugs/bug209.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug211.go b/test/fixedbugs/bug211.go
index 69aeeeeac..b15047927 100644
--- a/test/fixedbugs/bug211.go
+++ b/test/fixedbugs/bug211.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug212.go b/test/fixedbugs/bug212.go
index 51df9b8ae..4e58b91ec 100644
--- a/test/fixedbugs/bug212.go
+++ b/test/fixedbugs/bug212.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug213.go b/test/fixedbugs/bug213.go
index 07d9f9029..7f4786b52 100644
--- a/test/fixedbugs/bug213.go
+++ b/test/fixedbugs/bug213.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -7,7 +7,7 @@
 package main
 func main() {
 	var v interface{} = 0;
-	switch x := v.(type) {
+	switch v.(type) {
 	case int:
 		fallthrough;		// ERROR "fallthrough"
 	default:
diff --git a/test/fixedbugs/bug214.go b/test/fixedbugs/bug214.go
index 502e69826..5420058c4 100644
--- a/test/fixedbugs/bug214.go
+++ b/test/fixedbugs/bug214.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: bug214
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug215.go b/test/fixedbugs/bug215.go
index 8f7fb2d3c..08ed662c6 100644
--- a/test/fixedbugs/bug215.go
+++ b/test/fixedbugs/bug215.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug216.go b/test/fixedbugs/bug216.go
index 76f85464a..c83a522bf 100644
--- a/test/fixedbugs/bug216.go
+++ b/test/fixedbugs/bug216.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: bug216
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug217.go b/test/fixedbugs/bug217.go
index 98334c4ce..ec93c25d9 100644
--- a/test/fixedbugs/bug217.go
+++ b/test/fixedbugs/bug217.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug218.go b/test/fixedbugs/bug218.go
index b2c9ede75..0e008db17 100644
--- a/test/fixedbugs/bug218.go
+++ b/test/fixedbugs/bug218.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: bug218
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug219.go b/test/fixedbugs/bug219.go
index 966d3fcf3..290c691ea 100644
--- a/test/fixedbugs/bug219.go
+++ b/test/fixedbugs/bug219.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go || echo BUG: bug219
+// compile
 
 // Copyright 2009 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.
 
-package main
+package bug219
 
 func f(func()) int { return 0 }
 
diff --git a/test/fixedbugs/bug220.go b/test/fixedbugs/bug220.go
deleted file mode 100644
index ff027ddc2..000000000
--- a/test/fixedbugs/bug220.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// $G $D/$F.go || echo BUG: bug220
-
-// Copyright 2009 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.
-
-package main
-
-func main() {
-	m := make(map[int]map[uint]float64)
-
-	m[0] = make(map[uint]float64), false // 6g used to reject this
-	m[1] = nil
-}
diff --git a/test/fixedbugs/bug221.go b/test/fixedbugs/bug221.go
index b64583114..86fda2035 100644
--- a/test/fixedbugs/bug221.go
+++ b/test/fixedbugs/bug221.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug222.dir/chanbug.go b/test/fixedbugs/bug222.dir/chanbug.go
index 9194927b5..16920246e 100644
--- a/test/fixedbugs/bug222.dir/chanbug.go
+++ b/test/fixedbugs/bug222.dir/chanbug.go
@@ -1,3 +1,7 @@
+// Copyright 2009 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
+
 package chanbug
 var C chan<- (chan int)
 var D chan<- func()
diff --git a/test/fixedbugs/bug222.dir/chanbug2.go b/test/fixedbugs/bug222.dir/chanbug2.go
index 73e16678e..109581dc3 100644
--- a/test/fixedbugs/bug222.dir/chanbug2.go
+++ b/test/fixedbugs/bug222.dir/chanbug2.go
@@ -1,2 +1,6 @@
+// Copyright 2009 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
+
 package Bar
 import _ "chanbug"
diff --git a/test/fixedbugs/bug223.go b/test/fixedbugs/bug223.go
index 80f9cae81..eccf574a1 100644
--- a/test/fixedbugs/bug223.go
+++ b/test/fixedbugs/bug223.go
@@ -1,4 +1,4 @@
-// (! $G $D/$F.go) | grep 'initialization loop' >/dev/null || echo BUG: bug223
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -18,4 +18,4 @@ func f() {
 	}
 }
 
-var m = map[string]F{"f": f}
+var m = map[string]F{"f": f} // ERROR "initialization loop"
diff --git a/test/fixedbugs/bug224.go b/test/fixedbugs/bug224.go
index 11ee57ecf..d2fd67cf3 100644
--- a/test/fixedbugs/bug224.go
+++ b/test/fixedbugs/bug224.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug225.go b/test/fixedbugs/bug225.go
index 8acf66c4e..1bda9ab4b 100644
--- a/test/fixedbugs/bug225.go
+++ b/test/fixedbugs/bug225.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug226.dir/x.go b/test/fixedbugs/bug226.dir/x.go
deleted file mode 100644
index 64d7a29e7..000000000
--- a/test/fixedbugs/bug226.dir/x.go
+++ /dev/null
@@ -1,9 +0,0 @@
-// Copyright 2009 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.
-
-package x
-
-type T struct { x, Y int }
-
-func (t T) M()
diff --git a/test/fixedbugs/bug226.dir/y.go b/test/fixedbugs/bug226.dir/y.go
deleted file mode 100644
index c66d592b7..000000000
--- a/test/fixedbugs/bug226.dir/y.go
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2009 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.
-
-package y
-
-import "./x"
-
-func f() {
-	ok := new(x.T);
-	var ok1 x.T;
-	ok2 := &ok1;
-	ok3 := &x.T{};
-	ok4 := &x.T{Y:2};
-	_ = x.T{};
-	_ = x.T{Y:2};
-	
-	ok1.M();
-	bad1 := *ok;	// ERROR "assignment.*T"
-	bad2 := ok1;	// ERROR "assignment.*T"
-	*ok4 = ok1;	// ERROR "assignment.*T"
-	*ok4 = *ok2;	// ERROR "assignment.*T"
-	ok1 = *ok4;	// ERROR "assignment.*T"
-	_ = bad1;
-	_ = bad2;
-	_ = ok4;
-	_ = ok3;
-	_ = ok2;
-	_ = ok1;
-	_ = ok;
-}
diff --git a/test/fixedbugs/bug226.go b/test/fixedbugs/bug226.go
deleted file mode 100644
index 5457a64bc..000000000
--- a/test/fixedbugs/bug226.go
+++ /dev/null
@@ -1,7 +0,0 @@
-// $G $D/$F.dir/x.go && errchk $G $D/$F.dir/y.go
-
-// Copyright 2009 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.
-
-ignored
diff --git a/test/fixedbugs/bug227.go b/test/fixedbugs/bug227.go
index a60866044..ea8d02d10 100644
--- a/test/fixedbugs/bug227.go
+++ b/test/fixedbugs/bug227.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug228.go b/test/fixedbugs/bug228.go
index da335dbc0..3d23609dd 100644
--- a/test/fixedbugs/bug228.go
+++ b/test/fixedbugs/bug228.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug229.go b/test/fixedbugs/bug229.go
index 6c9de9ba9..19776881d 100644
--- a/test/fixedbugs/bug229.go
+++ b/test/fixedbugs/bug229.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -12,9 +12,9 @@ func main() {
 	var t testing.T
 	
 	// make sure error mentions that
-	// ch is unexported, not just "ch not found".
+	// name is unexported, not just "name not found".
 
-	t.ch = nil	// ERROR "unexported"
+	t.name = nil	// ERROR "unexported"
 	
 	println(testing.anyLowercaseName("asdf"))	// ERROR "unexported" "undefined: testing.anyLowercaseName"
 }
diff --git a/test/fixedbugs/bug230.go b/test/fixedbugs/bug230.go
index c7ad1a366..210acc430 100644
--- a/test/fixedbugs/bug230.go
+++ b/test/fixedbugs/bug230.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug231.go b/test/fixedbugs/bug231.go
index 9500e582b..a9d409b7d 100644
--- a/test/fixedbugs/bug231.go
+++ b/test/fixedbugs/bug231.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug232.go b/test/fixedbugs/bug232.go
index 99bd02ff6..d18727e90 100644
--- a/test/fixedbugs/bug232.go
+++ b/test/fixedbugs/bug232.go
@@ -1,8 +1,8 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2009 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.
 
-package main
+package bug232
 type I interface { X(...int) }
diff --git a/test/fixedbugs/bug233.go b/test/fixedbugs/bug233.go
index 31bb673eb..63f8ee2e9 100644
--- a/test/fixedbugs/bug233.go
+++ b/test/fixedbugs/bug233.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2009 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.
 
-package main
+package bug233
 import p "fmt"
 var _ = p.Print
 var fmt = 10
diff --git a/test/fixedbugs/bug234.go b/test/fixedbugs/bug234.go
index 562109a05..9f503f04a 100644
--- a/test/fixedbugs/bug234.go
+++ b/test/fixedbugs/bug234.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug235.go b/test/fixedbugs/bug235.go
index 8cecd9d04..d12d9e736 100644
--- a/test/fixedbugs/bug235.go
+++ b/test/fixedbugs/bug235.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -6,7 +6,7 @@
 
 // used to crash the compiler
 
-package main
+package bug235
 
 type T struct {
 	x [4]byte
diff --git a/test/fixedbugs/bug236.go b/test/fixedbugs/bug236.go
index 895f82a23..6c245565f 100644
--- a/test/fixedbugs/bug236.go
+++ b/test/fixedbugs/bug236.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug237.go b/test/fixedbugs/bug237.go
index 55cc86ace..58996cadc 100644
--- a/test/fixedbugs/bug237.go
+++ b/test/fixedbugs/bug237.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug238.go b/test/fixedbugs/bug238.go
index 4d5a905f0..cc47189e1 100644
--- a/test/fixedbugs/bug238.go
+++ b/test/fixedbugs/bug238.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug239.go b/test/fixedbugs/bug239.go
index 32c3d7e1c..e4902527d 100644
--- a/test/fixedbugs/bug239.go
+++ b/test/fixedbugs/bug239.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: bug239
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug240.go b/test/fixedbugs/bug240.go
index 6cba9c8b1..478b5b2ea 100644
--- a/test/fixedbugs/bug240.go
+++ b/test/fixedbugs/bug240.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug241.go b/test/fixedbugs/bug241.go
index 172b3742e..1f4440147 100644
--- a/test/fixedbugs/bug241.go
+++ b/test/fixedbugs/bug241.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug242.go b/test/fixedbugs/bug242.go
index 839dccd37..4791ae485 100644
--- a/test/fixedbugs/bug242.go
+++ b/test/fixedbugs/bug242.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: tuple evaluation order
+// run
 
 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -93,7 +93,8 @@ func main() {
 
 	m[13] = 'B'
 	//  13        14
-	m[gint()] = gbyte(), false
+	delete(m, gint())
+	gbyte()
 	if _, present := m[13]; present {
 		println("bad map removal")
 		panic("fail")
diff --git a/test/fixedbugs/bug243.go b/test/fixedbugs/bug243.go
index 95514cfd6..4870c3614 100644
--- a/test/fixedbugs/bug243.go
+++ b/test/fixedbugs/bug243.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -6,7 +6,7 @@
 
 package main
 
-import "os"
+import "errors"
 
 // Issue 481: closures and var declarations
 // with multiple variables assigned from one
@@ -22,7 +22,7 @@ func main() {
 		}
 	}()
 
-	var conn, _ = Dial("tcp", "", listen.Addr().String())
+	var conn, _ = Dial("tcp", "", listen.Addr().Error())
 	_ = conn
 }
 
@@ -37,8 +37,8 @@ func Listen(x, y string) (T, string) {
 	return global, y
 }
 
-func (t T) Addr() os.Error {
-	return os.NewError("stringer")
+func (t T) Addr() error {
+	return errors.New("stringer")
 }
 
 func (t T) Accept() (int, string) {
diff --git a/test/fixedbugs/bug244.go b/test/fixedbugs/bug244.go
index 915c3fcd0..29bf0d58b 100644
--- a/test/fixedbugs/bug244.go
+++ b/test/fixedbugs/bug244.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug245.go b/test/fixedbugs/bug245.go
index 6e5a8b344..c607a6dc3 100644
--- a/test/fixedbugs/bug245.go
+++ b/test/fixedbugs/bug245.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: bug245
+// compile
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug246.go b/test/fixedbugs/bug246.go
index 12041eb1d..e506f8c0d 100644
--- a/test/fixedbugs/bug246.go
+++ b/test/fixedbugs/bug246.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug246
+// run
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug247.go b/test/fixedbugs/bug247.go
index 2f56b88d4..b6851e1bc 100644
--- a/test/fixedbugs/bug247.go
+++ b/test/fixedbugs/bug247.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug247
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug248.dir/bug0.go b/test/fixedbugs/bug248.dir/bug0.go
index 7fc7401c5..78433f504 100644
--- a/test/fixedbugs/bug248.dir/bug0.go
+++ b/test/fixedbugs/bug248.dir/bug0.go
@@ -1,3 +1,7 @@
+// 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
+
 package p
 
 type T struct {
diff --git a/test/fixedbugs/bug248.dir/bug1.go b/test/fixedbugs/bug248.dir/bug1.go
index 7fc7401c5..78433f504 100644
--- a/test/fixedbugs/bug248.dir/bug1.go
+++ b/test/fixedbugs/bug248.dir/bug1.go
@@ -1,3 +1,7 @@
+// 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
+
 package p
 
 type T struct {
diff --git a/test/fixedbugs/bug248.dir/bug2.go b/test/fixedbugs/bug248.dir/bug2.go
index b6c816a5c..ba547d64a 100644
--- a/test/fixedbugs/bug248.dir/bug2.go
+++ b/test/fixedbugs/bug248.dir/bug2.go
@@ -1,3 +1,7 @@
+// 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
+
 package main
 
 import (
@@ -80,7 +84,7 @@ func main() {
 		case 2:
 			i = 3.14
 		}
-		switch k := i.(type) {
+		switch i.(type) {
 		case p0.T:
 			if j != 0 {
 				println("type switch p0.T")
diff --git a/test/fixedbugs/bug248.dir/bug3.go b/test/fixedbugs/bug248.dir/bug3.go
index e5a244955..4a56c5cc8 100644
--- a/test/fixedbugs/bug248.dir/bug3.go
+++ b/test/fixedbugs/bug248.dir/bug3.go
@@ -1,3 +1,7 @@
+// 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
+
 package main
 
 import (
diff --git a/test/fixedbugs/bug249.go b/test/fixedbugs/bug249.go
index c85708fd8..dc922455e 100644
--- a/test/fixedbugs/bug249.go
+++ b/test/fixedbugs/bug249.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug250.go b/test/fixedbugs/bug250.go
index cd28642bf..5140f3e29 100644
--- a/test/fixedbugs/bug250.go
+++ b/test/fixedbugs/bug250.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go || echo BUG: bug250
+// compile
 
 // 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.
 
-package main
+package bug250
 
 type I1 interface {
 	m() I2
diff --git a/test/fixedbugs/bug251.go b/test/fixedbugs/bug251.go
index c94ad2abe..43d9d526f 100644
--- a/test/fixedbugs/bug251.go
+++ b/test/fixedbugs/bug251.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -12,10 +12,10 @@ type I1 interface {
 }
 
 type I2 interface {
-	I1 // GC_ERROR "loop|interface"
+	I1 // ERROR "loop|interface"
 }
 
 
-var i1 I1 = i2 // GC_ERROR "missing m method|need type assertion"
+var i1 I1 = i2
 var i2 I2
 var i2a I2 = i1
diff --git a/test/fixedbugs/bug252.go b/test/fixedbugs/bug252.go
index a2c1dab9d..6f007fb77 100644
--- a/test/fixedbugs/bug252.go
+++ b/test/fixedbugs/bug252.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug253.go b/test/fixedbugs/bug253.go
index bb5b770f5..f6ab712ef 100644
--- a/test/fixedbugs/bug253.go
+++ b/test/fixedbugs/bug253.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug253
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug254.go b/test/fixedbugs/bug254.go
index c0c7f249e..9b1c81911 100644
--- a/test/fixedbugs/bug254.go
+++ b/test/fixedbugs/bug254.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug254
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug255.go b/test/fixedbugs/bug255.go
index 44427cfdb..dbd41cc6a 100644
--- a/test/fixedbugs/bug255.go
+++ b/test/fixedbugs/bug255.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug256.go b/test/fixedbugs/bug256.go
index 37fa5f5c8..0498a40d5 100644
--- a/test/fixedbugs/bug256.go
+++ b/test/fixedbugs/bug256.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug257.go b/test/fixedbugs/bug257.go
index 713c42481..003f3ff94 100644
--- a/test/fixedbugs/bug257.go
+++ b/test/fixedbugs/bug257.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bugxxx
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -20047,11 +20047,10 @@ var gettysburg = "  Four score and seven years ago our fathers brought forth on\
 	"\n" +
 	"Abraham Lincoln, November 19, 1863, Gettysburg, Pennsylvania\n"
 
-
 func main() {
 	m := md5.New()
 	io.WriteString(m, data)
-	hash := fmt.Sprintf("%x", m.Sum())
+	hash := fmt.Sprintf("%x", m.Sum(nil))
 	if hash != "525f06bc62a65017cd2217d7584e5920" {
 		println("BUG a", hash)
 		return
@@ -20059,7 +20058,7 @@ func main() {
 
 	m = md5.New()
 	io.WriteString(m, gettysburg)
-	hash = fmt.Sprintf("%x", m.Sum())
+	hash = fmt.Sprintf("%x", m.Sum(nil))
 	if hash != "d7ec5d9d47a4d166091e8d9ebd7ea0aa" {
 		println("BUG gettysburg", hash)
 		println(len(gettysburg))
diff --git a/test/fixedbugs/bug258.go b/test/fixedbugs/bug258.go
index 8984df592..d362e5a69 100644
--- a/test/fixedbugs/bug258.go
+++ b/test/fixedbugs/bug258.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug259.go b/test/fixedbugs/bug259.go
index d148fb3a0..e4dcaeb2f 100644
--- a/test/fixedbugs/bug259.go
+++ b/test/fixedbugs/bug259.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug260.go b/test/fixedbugs/bug260.go
index 34757c70e..6211c4885 100644
--- a/test/fixedbugs/bug260.go
+++ b/test/fixedbugs/bug260.go
@@ -1,4 +1,8 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug260 failed
+// run
+
+// 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
 
 // Test that structures pack densely, according to the alignment of the largest field.
 
@@ -24,8 +28,8 @@ func main() {
 	report := len(os.Args) > 1
 	status := 0
 	var b1 [10]T1
-	a0, _ := strconv.Btoui64(fmt.Sprintf("%p", &b1[0])[2:], 16)
-	a1, _ := strconv.Btoui64(fmt.Sprintf("%p", &b1[1])[2:], 16)
+	a0, _ := strconv.ParseUint(fmt.Sprintf("%p", &b1[0])[2:], 16, 64)
+	a1, _ := strconv.ParseUint(fmt.Sprintf("%p", &b1[1])[2:], 16, 64)
 	if a1 != a0+1 {
 		fmt.Println("FAIL")
 		if report {
@@ -34,8 +38,8 @@ func main() {
 		status = 1
 	}
 	var b2 [10]T2
-	a0, _ = strconv.Btoui64(fmt.Sprintf("%p", &b2[0])[2:], 16)
-	a1, _ = strconv.Btoui64(fmt.Sprintf("%p", &b2[1])[2:], 16)
+	a0, _ = strconv.ParseUint(fmt.Sprintf("%p", &b2[0])[2:], 16, 64)
+	a1, _ = strconv.ParseUint(fmt.Sprintf("%p", &b2[1])[2:], 16, 64)
 	if a1 != a0+2 {
 		if status == 0 {
 			fmt.Println("FAIL")
@@ -46,8 +50,8 @@ func main() {
 		}
 	}
 	var b4 [10]T4
-	a0, _ = strconv.Btoui64(fmt.Sprintf("%p", &b4[0])[2:], 16)
-	a1, _ = strconv.Btoui64(fmt.Sprintf("%p", &b4[1])[2:], 16)
+	a0, _ = strconv.ParseUint(fmt.Sprintf("%p", &b4[0])[2:], 16, 64)
+	a1, _ = strconv.ParseUint(fmt.Sprintf("%p", &b4[1])[2:], 16, 64)
 	if a1 != a0+4 {
 		if status == 0 {
 			fmt.Println("FAIL")
diff --git a/test/fixedbugs/bug261.go b/test/fixedbugs/bug261.go
index 8c3fda1e7..f7879b04c 100644
--- a/test/fixedbugs/bug261.go
+++ b/test/fixedbugs/bug261.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug262.go b/test/fixedbugs/bug262.go
index 66f580bd1..6cf248a18 100644
--- a/test/fixedbugs/bug262.go
+++ b/test/fixedbugs/bug262.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -7,7 +7,7 @@
 package main
 
 import (
-	"os"
+	"errors"
 	"strconv"
 )
 
@@ -18,9 +18,9 @@ func f() string {
 	return "abc"
 }
 
-func g() *os.Error {
+func g() *error {
 	trace += "g"
-	var x os.Error
+	var x error
 	return &x
 }
 
@@ -35,7 +35,6 @@ func i() *int {
 	return &i
 }
 
-
 func main() {
 	m := make(map[string]int)
 	m[f()], *g() = strconv.Atoi(h())
@@ -43,9 +42,9 @@ func main() {
 		println("BUG", m["abc"], trace)
 		panic("fail")
 	}
-	mm := make(map[string]os.Error)
+	mm := make(map[string]error)
 	trace = ""
-	mm["abc"] = os.EINVAL
+	mm["abc"] = errors.New("invalid")
 	*i(), mm[f()] = strconv.Atoi(h())
 	if mm["abc"] != nil || trace != "ifh" {
 		println("BUG1", mm["abc"], trace)
diff --git a/test/fixedbugs/bug263.go b/test/fixedbugs/bug263.go
index cab986ad5..f1cf9010d 100644
--- a/test/fixedbugs/bug263.go
+++ b/test/fixedbugs/bug263.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug264.go b/test/fixedbugs/bug264.go
index 6d86c6fe5..fcf373cce 100644
--- a/test/fixedbugs/bug264.go
+++ b/test/fixedbugs/bug264.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG
+// run
 
 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug265.go b/test/fixedbugs/bug265.go
index 55f32ecec..7f06fced6 100644
--- a/test/fixedbugs/bug265.go
+++ b/test/fixedbugs/bug265.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG
+// run
 
 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug266.go b/test/fixedbugs/bug266.go
index 25c246f7d..d4da891d3 100644
--- a/test/fixedbugs/bug266.go
+++ b/test/fixedbugs/bug266.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug266
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug267.go b/test/fixedbugs/bug267.go
index 9646142f2..cf8bf841f 100644
--- a/test/fixedbugs/bug267.go
+++ b/test/fixedbugs/bug267.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go || echo BUG
+// compile
 
 // 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.
 
-package main
+package bug267
 
 type T []int
 
diff --git a/test/fixedbugs/bug268.go b/test/fixedbugs/bug268.go
deleted file mode 100644
index a38d0545b..000000000
--- a/test/fixedbugs/bug268.go
+++ /dev/null
@@ -1,53 +0,0 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
-
-// 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.
-
-// http://code.google.com/p/go/issues/detail?id=745
-
-package main
-
-type T1 struct {
-	T2 *T2
-}
-
-type T2 struct {
-	T3 *T3
-}
-
-type T3 struct {
-	T4 []*T4
-}
-
-type T4 struct {
-	X int
-}
-
-func f() *T1 {
-	x := &T1{
-		&T2{
-			&T3{
-				[1]*T4{
-					&T4{5},
-				}[0:],
-			},
-		},
-	}
-	return x
-}
-
-func g(x int) {
-	if x == 0 {
-		return
-	}
-	g(x-1)
-}
-
-func main() {
-	x := f()
-	g(100) // smash temporaries left over on stack
-	if x.T2.T3.T4[0].X != 5 {
-		println("BUG", x.T2.T3.T4[0].X)
-	}
-}
diff --git a/test/fixedbugs/bug269.go b/test/fixedbugs/bug269.go
index 4cc0408c3..c13eb26ce 100644
--- a/test/fixedbugs/bug269.go
+++ b/test/fixedbugs/bug269.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug270.go b/test/fixedbugs/bug270.go
deleted file mode 100644
index a9cda7bd7..000000000
--- a/test/fixedbugs/bug270.go
+++ /dev/null
@@ -1,21 +0,0 @@
-// $G $D/$F.go
-
-// 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.
-
-// http://code.google.com/p/go/issues/detail?id=746
-
-package main
-
-type I interface { F() }
-
-type T struct{}
-
-func (T) F() {}
-
-func main() {
-	switch I(T{}).(type) {
-	case interface{}:
-	}
-}
diff --git a/test/fixedbugs/bug271.go b/test/fixedbugs/bug271.go
index ba93d93ed..88add7040 100644
--- a/test/fixedbugs/bug271.go
+++ b/test/fixedbugs/bug271.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug272.go b/test/fixedbugs/bug272.go
index 3b7c46674..c27f7ee44 100644
--- a/test/fixedbugs/bug272.go
+++ b/test/fixedbugs/bug272.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug273.go b/test/fixedbugs/bug273.go
index dd5aaa7b8..b35b17d2e 100644
--- a/test/fixedbugs/bug273.go
+++ b/test/fixedbugs/bug273.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug274.go b/test/fixedbugs/bug274.go
index 198544c3f..beb2d61ac 100644
--- a/test/fixedbugs/bug274.go
+++ b/test/fixedbugs/bug274.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug275.go b/test/fixedbugs/bug275.go
index 2bbc807c5..f5f6b14f0 100644
--- a/test/fixedbugs/bug275.go
+++ b/test/fixedbugs/bug275.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG should compile
+// compile
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug276.go b/test/fixedbugs/bug276.go
index 844a6b238..dc2308ea6 100644
--- a/test/fixedbugs/bug276.go
+++ b/test/fixedbugs/bug276.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG code should run
+// run
 
 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug277.go b/test/fixedbugs/bug277.go
index 22b2908c9..207556493 100644
--- a/test/fixedbugs/bug277.go
+++ b/test/fixedbugs/bug277.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG should compile
+// compile
 
 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug278.go b/test/fixedbugs/bug278.go
index 3699b9a14..68a3d811c 100644
--- a/test/fixedbugs/bug278.go
+++ b/test/fixedbugs/bug278.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug279.go b/test/fixedbugs/bug279.go
index af8e056d9..e5ec5943c 100644
--- a/test/fixedbugs/bug279.go
+++ b/test/fixedbugs/bug279.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug280.go b/test/fixedbugs/bug280.go
index 869d44626..ba594a2c4 100644
--- a/test/fixedbugs/bug280.go
+++ b/test/fixedbugs/bug280.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug281.go b/test/fixedbugs/bug281.go
index 821b02825..24d6fdce8 100644
--- a/test/fixedbugs/bug281.go
+++ b/test/fixedbugs/bug281.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug283.go b/test/fixedbugs/bug283.go
index 45ee9082f..eefed0334 100644
--- a/test/fixedbugs/bug283.go
+++ b/test/fixedbugs/bug283.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: should compile
+// compile
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -7,7 +7,7 @@
 // http://code.google.com/p/go/issues/detail?id=806
 // triggered out of registers on 8g
 
-package main
+package bug283
 
 type Point struct {
 	x int
diff --git a/test/fixedbugs/bug284.go b/test/fixedbugs/bug284.go
index bcf161e3d..68208085f 100644
--- a/test/fixedbugs/bug284.go
+++ b/test/fixedbugs/bug284.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug285.go b/test/fixedbugs/bug285.go
index 544d3487e..0a8a0f09e 100644
--- a/test/fixedbugs/bug285.go
+++ b/test/fixedbugs/bug285.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug285
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -45,20 +45,6 @@ func main() {
 	mp[p] = 42
 	mp[&T{7}] = 42
 
-	type F func(x int)
-	f := func(x int) {}
-	mf := make(map[F]int)
-	mf[nil] = 42
-	mf[f] = 42
-	mf[func(x int) {}] = 42
-
-	type M map[int]int
-	m := make(M)
-	mm := make(map[M]int)
-	mm[nil] = 42
-	mm[m] = 42
-	mm[make(M)] = 42
-
 	type C chan int
 	c := make(C)
 	mc := make(map[C]int)
diff --git a/test/fixedbugs/bug286.go b/test/fixedbugs/bug286.go
index 94423be81..44f05153f 100644
--- a/test/fixedbugs/bug286.go
+++ b/test/fixedbugs/bug286.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug286 failed
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -12,16 +12,14 @@ type I interface {
 	f()
 }
 
-
 var callee string
-var error bool
+var error_ bool
 
 type T int
 
 func (t *T) f() { callee = "f" }
 func (i *T) g() { callee = "g" }
 
-
 // test1 and test2 are the same except that in the interface J
 // the entries are swapped. test2 and test3 are the same except
 // that in test3 the interface J is declared outside the function.
@@ -36,11 +34,10 @@ func test1(x I) {
 	x.(J).f()
 	if callee != "f" {
 		println("test1 called", callee)
-		error = true
+		error_ = true
 	}
 }
 
-
 func test2(x I) {
 	type J interface {
 		g()
@@ -49,11 +46,10 @@ func test2(x I) {
 	x.(J).f()
 	if callee != "f" {
 		println("test2 called", callee)
-		error = true
+		error_ = true
 	}
 }
 
-
 type J interface {
 	g()
 	I
@@ -63,7 +59,7 @@ func test3(x I) {
 	x.(J).f()
 	if callee != "f" {
 		println("test3 called", callee)
-		error = true
+		error_ = true
 	}
 }
 
@@ -72,7 +68,7 @@ func main() {
 	test1(x)
 	test2(x)
 	test3(x)
-	if error {
+	if error_ {
 		panic("wrong method called")
 	}
 }
diff --git a/test/fixedbugs/bug287.go b/test/fixedbugs/bug287.go
index a4a08eedc..2ed81c593 100644
--- a/test/fixedbugs/bug287.go
+++ b/test/fixedbugs/bug287.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug288.go b/test/fixedbugs/bug288.go
index 0105159d1..d2461e6a9 100644
--- a/test/fixedbugs/bug288.go
+++ b/test/fixedbugs/bug288.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug289.go b/test/fixedbugs/bug289.go
index f7180ff04..3c6b68767 100644
--- a/test/fixedbugs/bug289.go
+++ b/test/fixedbugs/bug289.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug290.go b/test/fixedbugs/bug290.go
index 80437c7f8..c8ff0bc45 100644
--- a/test/fixedbugs/bug290.go
+++ b/test/fixedbugs/bug290.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug291.go b/test/fixedbugs/bug291.go
index 09334c921..17a5483ef 100644
--- a/test/fixedbugs/bug291.go
+++ b/test/fixedbugs/bug291.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug292.go b/test/fixedbugs/bug292.go
index 05852cd46..07051dd3f 100644
--- a/test/fixedbugs/bug292.go
+++ b/test/fixedbugs/bug292.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug293.go b/test/fixedbugs/bug293.go
index ca9b71a3a..bf926f5a4 100644
--- a/test/fixedbugs/bug293.go
+++ b/test/fixedbugs/bug293.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug294.go b/test/fixedbugs/bug294.go
index 18f45931c..0f3e38098 100644
--- a/test/fixedbugs/bug294.go
+++ b/test/fixedbugs/bug294.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug295.go b/test/fixedbugs/bug295.go
index fec2351f3..e2e5206ca 100644
--- a/test/fixedbugs/bug295.go
+++ b/test/fixedbugs/bug295.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug296.go b/test/fixedbugs/bug296.go
index 46d8dbcfe..a7c4e0c46 100644
--- a/test/fixedbugs/bug296.go
+++ b/test/fixedbugs/bug296.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug297.go b/test/fixedbugs/bug297.go
index 8767cdfea..b5dfa8d87 100644
--- a/test/fixedbugs/bug297.go
+++ b/test/fixedbugs/bug297.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug298.go b/test/fixedbugs/bug298.go
index c16c3f98a..bd362ace2 100644
--- a/test/fixedbugs/bug298.go
+++ b/test/fixedbugs/bug298.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug299.go b/test/fixedbugs/bug299.go
index 1c7adb5f5..9646723bf 100644
--- a/test/fixedbugs/bug299.go
+++ b/test/fixedbugs/bug299.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug300.go b/test/fixedbugs/bug300.go
index 09ee3ab69..1ef43a0ad 100644
--- a/test/fixedbugs/bug300.go
+++ b/test/fixedbugs/bug300.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug301.go b/test/fixedbugs/bug301.go
index a58f4e13b..572668f19 100644
--- a/test/fixedbugs/bug301.go
+++ b/test/fixedbugs/bug301.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: bug301.go
+// compile
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug302.go b/test/fixedbugs/bug302.go
index e9edb94ac..1088b2f3c 100644
--- a/test/fixedbugs/bug302.go
+++ b/test/fixedbugs/bug302.go
@@ -1,4 +1,4 @@
-// $G $D/bug302.dir/p.go && gopack grc pp.a p.$A && $G $D/bug302.dir/main.go
+// $G $D/bug302.dir/p.go && pack grc pp.a p.$A && $G $D/bug302.dir/main.go
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug303.go b/test/fixedbugs/bug303.go
index 3bd790f13..94ca07e70 100644
--- a/test/fixedbugs/bug303.go
+++ b/test/fixedbugs/bug303.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug304.go b/test/fixedbugs/bug304.go
index adcf08a35..ad71b20f3 100644
--- a/test/fixedbugs/bug304.go
+++ b/test/fixedbugs/bug304.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug305.go b/test/fixedbugs/bug305.go
index 758fee269..d0a4b24b8 100644
--- a/test/fixedbugs/bug305.go
+++ b/test/fixedbugs/bug305.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug307.go b/test/fixedbugs/bug307.go
index 1b42c09ab..644512529 100644
--- a/test/fixedbugs/bug307.go
+++ b/test/fixedbugs/bug307.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug308.go b/test/fixedbugs/bug308.go
index c2845f042..5bea5175b 100644
--- a/test/fixedbugs/bug308.go
+++ b/test/fixedbugs/bug308.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug309.go b/test/fixedbugs/bug309.go
index 07bebae74..948ca5c79 100644
--- a/test/fixedbugs/bug309.go
+++ b/test/fixedbugs/bug309.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -6,7 +6,7 @@
 
 // issue 1016
 
-package main
+package bug309
 
 func foo(t interface{}, c chan int) {
 	switch v := t.(type) {
@@ -15,5 +15,7 @@ func foo(t interface{}, c chan int) {
 		case <-c:
 			// bug was: internal compiler error: var without type, init: v
 		}
+	default:
+		_ = v
 	}
 }
diff --git a/test/fixedbugs/bug310.go b/test/fixedbugs/bug310.go
deleted file mode 100644
index 191f3ed2b..000000000
--- a/test/fixedbugs/bug310.go
+++ /dev/null
@@ -1,20 +0,0 @@
-// errchk $G $D/$F.go
-
-// 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.
-
-package p
-
-import (
-	"bytes"
-	"fmt"
-)
-
-type t int
-
-func main() {
-	_ = t.bar	// ERROR "no method"
-	var b bytes.Buffer
-	fmt.Print(b)	// ERROR "implicit assignment"
-}
diff --git a/test/fixedbugs/bug311.go b/test/fixedbugs/bug311.go
index ed937a674..edcd97596 100644
--- a/test/fixedbugs/bug311.go
+++ b/test/fixedbugs/bug311.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug312.go b/test/fixedbugs/bug312.go
index 70888dd41..c7c17e101 100644
--- a/test/fixedbugs/bug312.go
+++ b/test/fixedbugs/bug312.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug314.go b/test/fixedbugs/bug314.go
index 95d81d795..6e26d14e1 100644
--- a/test/fixedbugs/bug314.go
+++ b/test/fixedbugs/bug314.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug314
+// run
 
 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug315.go b/test/fixedbugs/bug315.go
index c59ef29e6..7b8a9e570 100644
--- a/test/fixedbugs/bug315.go
+++ b/test/fixedbugs/bug315.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: bug315
+// compile
 
 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug316.go b/test/fixedbugs/bug316.go
index 2146408a1..e1374122d 100644
--- a/test/fixedbugs/bug316.go
+++ b/test/fixedbugs/bug316.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: bug316
+// compile
 
 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug317.go b/test/fixedbugs/bug317.go
index 0cb26c29b..3ff4dc465 100644
--- a/test/fixedbugs/bug317.go
+++ b/test/fixedbugs/bug317.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug317
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug318.go b/test/fixedbugs/bug318.go
index 9c46a0426..93de2d847 100644
--- a/test/fixedbugs/bug318.go
+++ b/test/fixedbugs/bug318.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug319.go b/test/fixedbugs/bug319.go
index f60eee4fb..f8e959a31 100644
--- a/test/fixedbugs/bug319.go
+++ b/test/fixedbugs/bug319.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug320.go b/test/fixedbugs/bug320.go
index 06d41f2ed..c2dd31b81 100644
--- a/test/fixedbugs/bug320.go
+++ b/test/fixedbugs/bug320.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug321.go b/test/fixedbugs/bug321.go
index d0595ff59..7d018271f 100644
--- a/test/fixedbugs/bug321.go
+++ b/test/fixedbugs/bug321.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug321
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug323.go b/test/fixedbugs/bug323.go
index 23e2be660..9730ae5c8 100644
--- a/test/fixedbugs/bug323.go
+++ b/test/fixedbugs/bug323.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug325.go b/test/fixedbugs/bug325.go
index b86740fff..6ccd0e3c8 100644
--- a/test/fixedbugs/bug325.go
+++ b/test/fixedbugs/bug325.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug326.go b/test/fixedbugs/bug326.go
index efdd0ef71..57f6471dc 100644
--- a/test/fixedbugs/bug326.go
+++ b/test/fixedbugs/bug326.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -6,36 +6,34 @@
 
 package p
 
-import "os"
-
-func f() (_ int, err os.Error) {
+func f() (_ int, err error) {
 	return
 }
 
-func g() (x int, _ os.Error) {
+func g() (x int, _ error) {
 	return
 }
 
-func h() (_ int, _ os.Error) {
+func h() (_ int, _ error) {
 	return
 }
 
-func i() (int, os.Error) {
-	return	// ERROR "not enough arguments to return"
+func i() (int, error) {
+	return // ERROR "not enough arguments to return"
 }
 
-func f1() (_ int, err os.Error) {
+func f1() (_ int, err error) {
 	return 1, nil
 }
 
-func g1() (x int, _ os.Error) {
+func g1() (x int, _ error) {
 	return 1, nil
 }
 
-func h1() (_ int, _ os.Error) {
+func h1() (_ int, _ error) {
 	return 1, nil
 }
 
-func ii() (int, os.Error) {
+func ii() (int, error) {
 	return 1, nil
 }
diff --git a/test/fixedbugs/bug327.go b/test/fixedbugs/bug327.go
index 4ba5f6072..0598d95d6 100644
--- a/test/fixedbugs/bug327.go
+++ b/test/fixedbugs/bug327.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug328.go b/test/fixedbugs/bug328.go
index 64041f412..73ab46d45 100644
--- a/test/fixedbugs/bug328.go
+++ b/test/fixedbugs/bug328.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// cmpout
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug328.out b/test/fixedbugs/bug328.out
new file mode 100644
index 000000000..9982566dc
--- /dev/null
+++ b/test/fixedbugs/bug328.out
@@ -0,0 +1 @@
+0x0
diff --git a/test/fixedbugs/bug329.go b/test/fixedbugs/bug329.go
index 0b7074d62..74fc78198 100644
--- a/test/fixedbugs/bug329.go
+++ b/test/fixedbugs/bug329.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug330.go b/test/fixedbugs/bug330.go
index cf1d6cc2d..ef6a0777f 100644
--- a/test/fixedbugs/bug330.go
+++ b/test/fixedbugs/bug330.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -8,6 +8,6 @@ package main
 
 func main() {
 	x := ""
-	x = +"hello"  // ERROR "invalid operation.*string"
-	x = +x  // ERROR "invalid operation.*string"
+	x = +"hello"  // ERROR "invalid operation.*string|expected numeric"
+	x = +x  // ERROR "invalid operation.*string|expected numeric"
 }
diff --git a/test/fixedbugs/bug331.go b/test/fixedbugs/bug331.go
index 28aee1da0..fac0e3628 100644
--- a/test/fixedbugs/bug331.go
+++ b/test/fixedbugs/bug331.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug331
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -6,22 +6,22 @@
 
 package main
 
-import "os"
+import "io"
 
-func f() (_ string, x float64, err os.Error) {
+func f() (_ string, x float64, err error) {
 	return
 }
 
-func g() (_ string, x float64, err os.Error) {
-	return "hello", 3.14, os.EOF
+func g() (_ string, x float64, err error) {
+	return "hello", 3.14, io.EOF
 }
 
-var _ func() (string, float64, os.Error) = f
-var _ func() (string, float64, os.Error) = g
+var _ func() (string, float64, error) = f
+var _ func() (string, float64, error) = g
 
 func main() {
 	x, y, z := g()
-	if x != "hello" || y != 3.14 || z != os.EOF {
+	if x != "hello" || y != 3.14 || z != io.EOF {
 		println("wrong", x, len(x), y, z)
 	}
 }
diff --git a/test/fixedbugs/bug332.go b/test/fixedbugs/bug332.go
index be79286b8..702779ba6 100644
--- a/test/fixedbugs/bug332.go
+++ b/test/fixedbugs/bug332.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug333.go b/test/fixedbugs/bug333.go
index 515c1f3fa..bb690f0e5 100644
--- a/test/fixedbugs/bug333.go
+++ b/test/fixedbugs/bug333.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug334.go b/test/fixedbugs/bug334.go
index 870c9ae24..bd671696b 100644
--- a/test/fixedbugs/bug334.go
+++ b/test/fixedbugs/bug334.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: bug334
+// compile
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug336.go b/test/fixedbugs/bug336.go
index 8de36898f..fbf23207c 100644
--- a/test/fixedbugs/bug336.go
+++ b/test/fixedbugs/bug336.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug337.go b/test/fixedbugs/bug337.go
index 62e310e72..38dc665fa 100644
--- a/test/fixedbugs/bug337.go
+++ b/test/fixedbugs/bug337.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -14,6 +14,6 @@
 package main
 
 func main() {
-	len("foo")	// ERROR "len"
+	len("foo")	// ERROR "len|value computed is not used"
 }
 
diff --git a/test/fixedbugs/bug338.go b/test/fixedbugs/bug338.go
index c368a7fad..c2193fcc2 100644
--- a/test/fixedbugs/bug338.go
+++ b/test/fixedbugs/bug338.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug339.go b/test/fixedbugs/bug339.go
index eac7c5ee6..59921d41c 100644
--- a/test/fixedbugs/bug339.go
+++ b/test/fixedbugs/bug339.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug340.go b/test/fixedbugs/bug340.go
index 461cc6cd4..d996ab64c 100644
--- a/test/fixedbugs/bug340.go
+++ b/test/fixedbugs/bug340.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -10,8 +10,8 @@ package main
 
 func main() {
 	var x interface{}
-	switch t := x.(type) { // ERROR "0 is not a type"
-	case 0:
-		t.x = 1 // ERROR "type interface \{ \}"
+	switch t := x.(type) {
+	case 0:		// ERROR "type"
+		t.x = 1 // ERROR "type interface \{\}|reference to undefined field or method"
 	}
 }
diff --git a/test/fixedbugs/bug341.go b/test/fixedbugs/bug341.go
index 8ee52e1ef..db1af3eaa 100644
--- a/test/fixedbugs/bug341.go
+++ b/test/fixedbugs/bug341.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug341
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug342.go b/test/fixedbugs/bug342.go
index 0852cdd34..5f1efbdfe 100644
--- a/test/fixedbugs/bug342.go
+++ b/test/fixedbugs/bug342.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug343.go b/test/fixedbugs/bug343.go
index efc87e3d7..82201088b 100644
--- a/test/fixedbugs/bug343.go
+++ b/test/fixedbugs/bug343.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug343
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug344.go b/test/fixedbugs/bug344.go
index d217b3bd3..4a92624c7 100644
--- a/test/fixedbugs/bug344.go
+++ b/test/fixedbugs/bug344.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -14,10 +14,10 @@ func main() {
 	i := 42
 	a := []*int{&i, &i, &i, &i}
 	x := a[0]
-	goto start  // ERROR "goto start jumps into block"
+	goto start  // ERROR "jumps into block"
 	z := 1
 	_ = z
-	for _, x = range a {
+	for _, x = range a {	// GCCGO_ERROR "block"
 	start:
 		fmt.Sprint(*x)
 	}
diff --git a/test/fixedbugs/bug345.dir/main.go b/test/fixedbugs/bug345.dir/main.go
index 5bdc713f4..ddba8dad4 100644
--- a/test/fixedbugs/bug345.dir/main.go
+++ b/test/fixedbugs/bug345.dir/main.go
@@ -22,7 +22,7 @@ func main() {
 	// main.go:27: cannot use &x (type *"io".SectionReader) as type *"/Users/rsc/g/go/test/fixedbugs/bug345.dir/io".SectionReader in function argument
 
 	var w io.Writer
-	bufio.NewWriter(w)  // ERROR "test/io"
+	bufio.NewWriter(w)  // ERROR "test/io|has incompatible type"
 	var x goio.SectionReader
-	io.SR(&x)  // ERROR "test/io"
+	io.SR(&x)  // ERROR "test/io|has incompatible type"
 }
diff --git a/test/fixedbugs/bug346.go b/test/fixedbugs/bug346.go
index 31284c31a..d9203aa43 100644
--- a/test/fixedbugs/bug346.go
+++ b/test/fixedbugs/bug346.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: issue2056
+// run
 
 // Copyright 2011 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug347.go b/test/fixedbugs/bug347.go
index 5532cee83..08edf0f4f 100644
--- a/test/fixedbugs/bug347.go
+++ b/test/fixedbugs/bug347.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug348.go b/test/fixedbugs/bug348.go
index 1a539aa3e..54a289a8d 100644
--- a/test/fixedbugs/bug348.go
+++ b/test/fixedbugs/bug348.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug349.go b/test/fixedbugs/bug349.go
index 07005973e..a3e6bd161 100644
--- a/test/fixedbugs/bug349.go
+++ b/test/fixedbugs/bug349.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -9,5 +9,5 @@
 package main
 
 func foo() (a, b, c int) {
-	return 0, 1 2.01  // ERROR "unexpected literal 2.01"
+	return 0, 1 2.01  // ERROR "unexpected literal 2.01|expected ';' or '}' or newline|not enough arguments to return"
 }
diff --git a/test/fixedbugs/bug350.go b/test/fixedbugs/bug350.go
index aac294901..5ce8996ff 100644
--- a/test/fixedbugs/bug350.go
+++ b/test/fixedbugs/bug350.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -8,8 +8,8 @@ package main
 
 type T int
 
-func (T) m() {}
-func (T) m() {} // ERROR "T[.]m redeclared"
+func (T) m() {} // GCCGO_ERROR "previous"
+func (T) m() {} // ERROR "T[.]m redeclared|redefinition"
 
-func (*T) p() {}
-func (*T) p() {} // ERROR "[(][*]T[)][.]p redeclared"
+func (*T) p() {} // GCCGO_ERROR "previous"
+func (*T) p() {} // ERROR "[(][*]T[)][.]p redeclared|redefinition"
diff --git a/test/fixedbugs/bug351.go b/test/fixedbugs/bug351.go
index 2f631bbbb..4c5c7c327 100644
--- a/test/fixedbugs/bug351.go
+++ b/test/fixedbugs/bug351.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -9,5 +9,5 @@ package main
 var x int
 
 func main() {
-	(x) := 0  // ERROR "non-name [(]x[)]"
+	(x) := 0  // ERROR "non-name [(]x[)]|non-name on left side"
 }
diff --git a/test/fixedbugs/bug352.go b/test/fixedbugs/bug352.go
index 62fd006c4..1ae2d6139 100644
--- a/test/fixedbugs/bug352.go
+++ b/test/fixedbugs/bug352.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug352
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug353.go b/test/fixedbugs/bug353.go
index 46f5c36cb..2a532c491 100644
--- a/test/fixedbugs/bug353.go
+++ b/test/fixedbugs/bug353.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -13,7 +13,7 @@ import (
 	"os"
 )
 
-func echo(fd io.ReadWriterCloser) { // ERROR "undefined: io.ReadWriterCloser"
+func echo(fd io.ReadWriterCloser) { // ERROR "undefined.*io.ReadWriterCloser"
 	var buf [1024]byte
 	for {
 		n, err := fd.Read(buf)
diff --git a/test/fixedbugs/bug354.go b/test/fixedbugs/bug354.go
index 1f6a6dc9f..1245d91f5 100644
--- a/test/fixedbugs/bug354.go
+++ b/test/fixedbugs/bug354.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: bug354
+// compile
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -7,14 +7,10 @@
 // issue 2086
 // was calling makeclosure twice on the closure
 
-package main
-
-import (
-	"os"
-)
+package bug354
 
 type Inner struct {
-	F func() os.Error
+	F func() error
 }
 
 type Outer struct {
@@ -23,4 +19,4 @@ type Outer struct {
 
 // calls makeclosure twice on same closure
 
-var Foo = Outer{[]Inner{Inner{func() os.Error{ return nil }}}}
+var Foo = Outer{[]Inner{Inner{func() error { return nil }}}}
diff --git a/test/fixedbugs/bug355.go b/test/fixedbugs/bug355.go
index a9cf0161b..fcf859b7f 100644
--- a/test/fixedbugs/bug355.go
+++ b/test/fixedbugs/bug355.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug356.go b/test/fixedbugs/bug356.go
index d21f0cfac..273c5b8ef 100644
--- a/test/fixedbugs/bug356.go
+++ b/test/fixedbugs/bug356.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG: bug344
+// run
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug357.go b/test/fixedbugs/bug357.go
index 2220398d0..2ac64a80b 100644
--- a/test/fixedbugs/bug357.go
+++ b/test/fixedbugs/bug357.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -15,8 +15,9 @@ func bla1() bool {
 
 func bla5() bool {
 	_ = 1
-	false  // ERROR "false not used"
+	false  // ERROR "false not used|value computed is not used"
 	_ = 2
+	return false
 }
 
 func main() {
diff --git a/test/fixedbugs/bug358.go b/test/fixedbugs/bug358.go
index cc622c047..6a008484f 100644
--- a/test/fixedbugs/bug358.go
+++ b/test/fixedbugs/bug358.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -10,13 +10,13 @@
 package main
 
 import (
-	"http"
-	"io/ioutil"
+	"io/ioutil"	// GCCGO_ERROR "imported and not used"
+	"net/http"
 	"os"
 )
 
 func makeHandler(fn func(http.ResponseWriter, *http.Request, string)) http.HandlerFunc {
-	return func(w http.ResponseWriter, r *http.Request)  // ERROR "syntax error"
+	return func(w http.ResponseWriter, r *http.Request)  // ERROR "syntax error|invalid use of type"
 }
 
 type Page struct {
diff --git a/test/fixedbugs/bug359.go b/test/fixedbugs/bug359.go
deleted file mode 100644
index 7f34672f1..000000000
--- a/test/fixedbugs/bug359.go
+++ /dev/null
@@ -1,26 +0,0 @@
-// errchk $G $D/$F.go
-
-// Copyright 2011 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.
-
-// issue 1910
-// error on wrong line
-
-package main
-
-import "container/list"
-
-type Painting struct {
-	fragments list.List // private
-}
-
-func (p Painting) Foo() {
-	for e := p.fragments; e.Front() != nil; {  // ERROR "unexported field"
-	}
-}
-
-// from comment 4 of issue 1910
-type Foo interface {
-	Run(a int) (a int)  // ERROR "a redeclared"
-}
diff --git a/test/fixedbugs/bug361.go b/test/fixedbugs/bug361.go
index d2a64bcef..3e3b7c181 100644
--- a/test/fixedbugs/bug361.go
+++ b/test/fixedbugs/bug361.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: bug360
+// compile
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/fixedbugs/bug362.go b/test/fixedbugs/bug362.go
index 791209103..b888ccb44 100644
--- a/test/fixedbugs/bug362.go
+++ b/test/fixedbugs/bug362.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -10,7 +10,7 @@
 package main
 
 var (
-	a = iota  // ERROR "undefined: iota"
-	b = iota  // ERROR "undefined: iota"
-	c = iota  // ERROR "undefined: iota"
+	a = iota  // ERROR "undefined: iota|iota is only defined in const"
+	b = iota  // ERROR "undefined: iota|iota is only defined in const"
+	c = iota  // ERROR "undefined: iota|iota is only defined in const"
 )
diff --git a/test/fixedbugs/bug363.go b/test/fixedbugs/bug363.go
index 7e89749a0..615c66865 100644
--- a/test/fixedbugs/bug363.go
+++ b/test/fixedbugs/bug363.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -10,12 +10,12 @@ package main
 
 func main() {
 	var i uint = 33
-	var a = (1<<i) + 4.5  // ERROR "shift of type float64"
+	var a = (1<<i) + 4.5  // ERROR "shift of type float64|invalid.*shift"
 	println(a)
 	
-	var b = (1<<i) + 4.0  // ERROR "shift of type float64"
+	var b = (1<<i) + 4.0  // ERROR "shift of type float64|invalid.*shift"
 	println(b)
 
 	var c int64 = (1<<i) + 4.0  // ok - it's all int64
-	println(b)
+	println(c)
 }
diff --git a/test/fixedbugs/bug364.go b/test/fixedbugs/bug364.go
index a17453419..64120d164 100644
--- a/test/fixedbugs/bug364.go
+++ b/test/fixedbugs/bug364.go
@@ -1,3 +1,9 @@
+// run
+
+// Copyright 2011 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.
+
 package main
 
 import "fmt"
diff --git a/test/fixedbugs/bug365.go b/test/fixedbugs/bug365.go
index 7ec19b0c8..795323bb3 100644
--- a/test/fixedbugs/bug365.go
+++ b/test/fixedbugs/bug365.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -12,11 +12,11 @@
 package main
 
 type S struct {
-	err os.Error  // ERROR "undefined"
+	err foo.Bar // ERROR "undefined|expected package"
 	Num int
 }
 
 func main() {
 	s := S{}
-	_ = s.Num  // no error here please
+	_ = s.Num // no error here please
 }
diff --git a/test/fixedbugs/bug366.go b/test/fixedbugs/bug366.go
new file mode 100644
index 000000000..33a1a5a7e
--- /dev/null
+++ b/test/fixedbugs/bug366.go
@@ -0,0 +1,37 @@
+// run
+
+// Copyright 2011 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.
+
+// Issue 2206.  Incorrect sign extension of div arguments.
+
+package main
+
+func five(x int64) {
+	if x != 5 {
+		panic(x)
+	}
+}
+
+func main() {
+       // 5
+       five(int64(5 / (5 / 3)))
+
+       // 5
+       five(int64(byte(5) / (byte(5) / byte(3))))
+
+       // 5
+       var a, b byte = 5, 3
+       five(int64(a / (a / b)))
+       
+       // integer divide by zero in golang.org sandbox
+       // 0 on windows/amd64
+       x := [3]byte{2, 3, 5}
+       five(int64(x[2] / (x[2] / x[1])))
+
+       // integer divide by zero in golang.org sandbox
+       // crash on windows/amd64
+       y := x[1:3]
+       five(int64(y[1] / (y[1] / y[0])))
+}
+\ No newline at end of file
diff --git a/test/fixedbugs/bug367.dir/main.go b/test/fixedbugs/bug367.dir/main.go
new file mode 100644
index 000000000..c278e4dd9
--- /dev/null
+++ b/test/fixedbugs/bug367.dir/main.go
@@ -0,0 +1,28 @@
+// Copyright 2011 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
+
+package main
+
+import (
+	"./p"
+)
+
+type T struct{ *p.S }
+type I interface {
+	get()
+}
+
+func main() {
+	var t T
+	p.F(t)
+	var x interface{} = t
+	_, ok := x.(I)
+	if ok {
+		panic("should not satisfy main.I")
+	}
+	_, ok = x.(p.I)
+	if !ok {
+		panic("should satisfy p.I")
+	}
+}
diff --git a/test/fixedbugs/bug367.dir/p.go b/test/fixedbugs/bug367.dir/p.go
new file mode 100644
index 000000000..2028f740c
--- /dev/null
+++ b/test/fixedbugs/bug367.dir/p.go
@@ -0,0 +1,19 @@
+// Copyright 2011 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
+
+package p
+
+type T struct{ x int }
+type S struct{}
+
+func (p *S) get() {
+}
+
+type I interface {
+	get()
+}
+
+func F(i I) {
+	i.get()
+}
diff --git a/test/fixedbugs/bug367.go b/test/fixedbugs/bug367.go
new file mode 100644
index 000000000..25d11a153
--- /dev/null
+++ b/test/fixedbugs/bug367.go
@@ -0,0 +1,7 @@
+// $G $D/$F.dir/p.go && $G $D/$F.dir/main.go && $L main.$A && ./$A.out || echo BUG: should not fail
+
+// Copyright 2011 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.
+
+package ignored
diff --git a/test/fixedbugs/bug368.go b/test/fixedbugs/bug368.go
new file mode 100644
index 000000000..c38cc7fad
--- /dev/null
+++ b/test/fixedbugs/bug368.go
@@ -0,0 +1,26 @@
+// run
+
+// Copyright 2011 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.
+
+package main
+
+// 5g bug used to set up the 0 for -f() before calling f,
+// and the call to f smashed the register.
+
+func f(n int) int {
+	s := 0
+	for i := 0; i < n; i++ {
+		s += i>>1
+	}
+	return s
+}
+
+func main() {
+	x := -f(100)
+	if x != -2450 {
+		println(x)
+		panic("broken")
+	}
+}
diff --git a/test/fixedbugs/bug369.dir/pkg.go b/test/fixedbugs/bug369.dir/pkg.go
new file mode 100644
index 000000000..cf5704192
--- /dev/null
+++ b/test/fixedbugs/bug369.dir/pkg.go
@@ -0,0 +1,15 @@
+// Copyright 2011 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.
+
+package pkg
+
+func NonASCII(b []byte, i int) int {
+	for i = 0; i < len(b); i++ {
+		if b[i] >= 0x80 {
+			break
+		}
+	}
+	return i
+}
+
diff --git a/test/fixedbugs/bug369.go b/test/fixedbugs/bug369.go
new file mode 100644
index 000000000..4d98e8508
--- /dev/null
+++ b/test/fixedbugs/bug369.go
@@ -0,0 +1,59 @@
+// $G -N -o slow.$A $D/bug369.dir/pkg.go &&
+// $G -o fast.$A $D/bug369.dir/pkg.go &&
+// run
+
+// Copyright 2011 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.
+
+// Test that compiling with optimization turned on produces faster code.
+
+package main
+
+import (
+	"flag"
+	"os"
+	"runtime"
+	"testing"
+
+	fast "./fast"
+	slow "./slow"
+)
+
+var buf = make([]byte, 1048576)
+
+func BenchmarkFastNonASCII(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		fast.NonASCII(buf, 0)
+	}
+}
+
+func BenchmarkSlowNonASCII(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		slow.NonASCII(buf, 0)
+	}
+}
+
+func main() {
+	os.Args = []string{os.Args[0], "-test.benchtime=0.1"}
+	flag.Parse()
+	
+	rslow := testing.Benchmark(BenchmarkSlowNonASCII)
+	rfast := testing.Benchmark(BenchmarkFastNonASCII)
+	tslow := rslow.NsPerOp()
+	tfast := rfast.NsPerOp()
+
+	// Optimization should be good for at least 2x, but be forgiving.
+	// On the ARM simulator we see closer to 1.5x.
+	speedup := float64(tslow)/float64(tfast)
+	want := 1.8
+	if runtime.GOARCH == "arm" {
+		want = 1.3
+	}
+	if speedup < want {
+		// TODO(rsc): doesn't work on linux-amd64 or darwin-amd64 builders, nor on
+		// a Lenovo x200 (linux-amd64) laptop.
+		//println("fast:", tfast, "slow:", tslow, "speedup:", speedup, "want:", want)
+		//println("not fast enough")
+	}
+}
diff --git a/test/fixedbugs/bug370.go b/test/fixedbugs/bug370.go
new file mode 100644
index 000000000..246bc7c4e
--- /dev/null
+++ b/test/fixedbugs/bug370.go
@@ -0,0 +1,18 @@
+// run
+
+// Copyright 2011 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.
+
+package main
+
+// issue 2337
+// The program deadlocked.
+
+import "runtime"
+
+func main() {
+	runtime.GOMAXPROCS(2)
+	runtime.GC()
+	runtime.GOMAXPROCS(1)
+}
diff --git a/test/fixedbugs/bug371.go b/test/fixedbugs/bug371.go
new file mode 100644
index 000000000..6329e9635
--- /dev/null
+++ b/test/fixedbugs/bug371.go
@@ -0,0 +1,24 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// issue 2343
+
+package main
+
+type T struct {}
+
+func (t *T) pm() {}
+func (t T) m() {}
+
+func main() {
+	p := &T{}
+	p.pm()
+	p.m()
+
+	q := &p
+	q.m()  // ERROR "requires explicit dereference"
+	q.pm()
+}
diff --git a/test/fixedbugs/bug372.go b/test/fixedbugs/bug372.go
new file mode 100644
index 000000000..34578565a
--- /dev/null
+++ b/test/fixedbugs/bug372.go
@@ -0,0 +1,28 @@
+// run
+
+// Copyright 2011 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.
+
+// Issue 2355
+package main
+
+type T struct {}
+func (T) m() string { return "T" }
+
+type TT struct {
+	T
+	m func() string
+}
+
+
+func ff() string { return "ff" }
+
+func main() {
+	var tt TT
+	tt.m = ff
+
+	if tt.m() != "ff" {
+		println(tt.m(), "!= \"ff\"")
+	}
+}
diff --git a/test/fixedbugs/bug373.go b/test/fixedbugs/bug373.go
new file mode 100644
index 000000000..e91f26d6e
--- /dev/null
+++ b/test/fixedbugs/bug373.go
@@ -0,0 +1,32 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// Issue 873, 2162
+
+package foo
+
+func f(x interface{}) {
+	switch t := x.(type) {  // ERROR "declared and not used"
+	case int:
+	}
+}
+
+func g(x interface{}) {
+	switch t := x.(type) {
+	case int:
+	case float32:
+		println(t)
+	}
+}
+
+func h(x interface{}) {
+	switch t := x.(type) {
+	case int:
+	case float32:
+	default:
+		println(t)
+	}
+}
diff --git a/test/fixedbugs/bug374.go b/test/fixedbugs/bug374.go
new file mode 100644
index 000000000..4f0b721f2
--- /dev/null
+++ b/test/fixedbugs/bug374.go
@@ -0,0 +1,20 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// issue 1556
+package foo
+
+type I interface {
+	m() int
+}
+
+type T int
+
+var _ I = T(0)	// GCCGO_ERROR "incompatible"
+
+func (T) m(buf []byte) (a int, b xxxx) {  // ERROR "xxxx"
+	return 0, nil
+}
diff --git a/test/fixedbugs/bug375.go b/test/fixedbugs/bug375.go
new file mode 100644
index 000000000..cb159b0d6
--- /dev/null
+++ b/test/fixedbugs/bug375.go
@@ -0,0 +1,19 @@
+// run
+
+// Copyright 2011 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.
+
+// Issue 2423
+
+package main
+
+func main() {
+	var x interface{} = "hello"
+
+	switch x {
+	case "hello":
+	default:
+		println("FAIL")
+	}
+}
diff --git a/test/fixedbugs/bug376.go b/test/fixedbugs/bug376.go
new file mode 100644
index 000000000..5fbbc9cd4
--- /dev/null
+++ b/test/fixedbugs/bug376.go
@@ -0,0 +1,11 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// issue 1951
+package foo
+import "unsafe"
+var v = unsafe.Sizeof  // ERROR "must be called"
+
diff --git a/test/fixedbugs/bug377.dir/one.go b/test/fixedbugs/bug377.dir/one.go
new file mode 100644
index 000000000..e29b813a4
--- /dev/null
+++ b/test/fixedbugs/bug377.dir/one.go
@@ -0,0 +1,10 @@
+// Copyright 2011 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
+
+package one
+
+func Foo() (n int64, _ *int) {
+	return 42, nil
+}
+
diff --git a/test/fixedbugs/bug377.dir/two.go b/test/fixedbugs/bug377.dir/two.go
new file mode 100644
index 000000000..2a10812d5
--- /dev/null
+++ b/test/fixedbugs/bug377.dir/two.go
@@ -0,0 +1,8 @@
+// Copyright 2011 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
+
+package two
+
+import _ "./one"
+
diff --git a/test/fixedbugs/bug377.go b/test/fixedbugs/bug377.go
new file mode 100644
index 000000000..e905e34d6
--- /dev/null
+++ b/test/fixedbugs/bug377.go
@@ -0,0 +1,9 @@
+// $G $D/$F.dir/one.go && $G $D/$F.dir/two.go
+
+// Copyright 2011 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.
+
+// Issue 1802
+
+package ignored
diff --git a/test/fixedbugs/bug378.go b/test/fixedbugs/bug378.go
new file mode 100644
index 000000000..f3346c648
--- /dev/null
+++ b/test/fixedbugs/bug378.go
@@ -0,0 +1,19 @@
+// run
+
+// Copyright 2011 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.
+
+// Issue 2497
+
+package main
+
+type Header struct{}
+func (h Header) Method() {}
+
+var _ interface{} = Header{}
+
+func main() {
+  	type X Header
+  	var _ interface{} = X{}
+}
diff --git a/test/fixedbugs/bug379.go b/test/fixedbugs/bug379.go
new file mode 100644
index 000000000..81e9c266e
--- /dev/null
+++ b/test/fixedbugs/bug379.go
@@ -0,0 +1,18 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// Issue 2452.
+
+// Check that the error messages says 
+//	bug378.go:17: 1 + 2 not used
+// and not
+//	bug378.go:17: 1 not used
+
+package main
+
+func main() {
+	1 + 2 // ERROR "1 \+ 2 not used|value computed is not used"
+}
diff --git a/test/fixedbugs/bug380.go b/test/fixedbugs/bug380.go
new file mode 100644
index 000000000..96e1edeca
--- /dev/null
+++ b/test/fixedbugs/bug380.go
@@ -0,0 +1,11 @@
+// compile
+
+// Copyright 2011 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.
+
+// Used to cause a typechecking loop error.
+
+package pkg
+type T map[int]string
+var q = &T{}
diff --git a/test/fixedbugs/bug381.go b/test/fixedbugs/bug381.go
new file mode 100644
index 000000000..0253e1446
--- /dev/null
+++ b/test/fixedbugs/bug381.go
@@ -0,0 +1,31 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// Issue 2276.
+
+// Check that the error messages says 
+//	bug381.go:29: unsafe.Alignof(0) not used
+// and not
+//	bug381.go:29: 4 not used
+
+// Issue 2768: previously got
+//    bug381.go:30: cannot use 3 (type time.Weekday) as type int in function argument
+// want
+//    bug381.go:30: cannot use time.Wednesday (type time.Weekday) as type int in function argument
+
+package main
+
+import (
+	"time"
+	"unsafe"
+)
+
+func f(int)
+
+func main() {
+	unsafe.Alignof(0) // ERROR "unsafe\.Alignof|value computed is not used"
+	f(time.Wednesday) // ERROR "time.Wednesday|incompatible type"
+}
diff --git a/test/fixedbugs/bug382.dir/pkg.go b/test/fixedbugs/bug382.dir/pkg.go
new file mode 100644
index 000000000..f8d75d454
--- /dev/null
+++ b/test/fixedbugs/bug382.dir/pkg.go
@@ -0,0 +1,7 @@
+// Copyright 2011 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.
+
+package pkg
+type T struct {}
+var E T
diff --git a/test/fixedbugs/bug382.go b/test/fixedbugs/bug382.go
new file mode 100644
index 000000000..3f5d05cd5
--- /dev/null
+++ b/test/fixedbugs/bug382.go
@@ -0,0 +1,14 @@
+// $G $D/$F.dir/pkg.go && $G $D/$F.go || echo "Bug 382"
+
+// Copyright 2011 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
+
+// Issue 2529
+
+package main
+import "./pkg"
+
+var x = pkg.E
+
+var fo = struct {F pkg.T}{F: x}
diff --git a/test/fixedbugs/bug383.go b/test/fixedbugs/bug383.go
new file mode 100644
index 000000000..503779c37
--- /dev/null
+++ b/test/fixedbugs/bug383.go
@@ -0,0 +1,13 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// Issue 2520
+
+package main
+func main() {
+	if 2e9 { }      // ERROR "2e.09|expected bool"
+	if 3.14+1i { }  // ERROR "3.14 . 1i|expected bool"
+}
diff --git a/test/fixedbugs/bug384.go b/test/fixedbugs/bug384.go
new file mode 100644
index 000000000..0233c197c
--- /dev/null
+++ b/test/fixedbugs/bug384.go
@@ -0,0 +1,12 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// Issue 2500
+
+package foo
+
+// Check that we only get root cause message, no further complaints about r undefined
+func (r *indexWriter) foo() {}  // ERROR "undefined.*indexWriter"
diff --git a/test/fixedbugs/bug385_32.go b/test/fixedbugs/bug385_32.go
new file mode 100644
index 000000000..b9ecbb4c1
--- /dev/null
+++ b/test/fixedbugs/bug385_32.go
@@ -0,0 +1,14 @@
+// [ $A == 6 ] || errchk $G -e $D/$F.go
+
+// Copyright 2011 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.
+
+// Issue 2444
+
+package main
+func main() {
+	var arr [1000200030]int   // ERROR "type .* too large"
+	arr_bkup := arr
+	_ = arr_bkup
+}
+\ No newline at end of file
diff --git a/test/fixedbugs/bug385_64.go b/test/fixedbugs/bug385_64.go
new file mode 100644
index 000000000..7476b17d5
--- /dev/null
+++ b/test/fixedbugs/bug385_64.go
@@ -0,0 +1,15 @@
+// [ $A != 6 ]  || errchk $G -e $D/$F.go
+
+// Copyright 2011 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.
+
+// Issue 2444
+
+package main
+func main() {  // ERROR "stack frame too large"
+	var arr [1000200030]int
+	arr_bkup := arr
+	_ = arr_bkup
+}
+
diff --git a/test/fixedbugs/bug386.go b/test/fixedbugs/bug386.go
new file mode 100644
index 000000000..ec358bd36
--- /dev/null
+++ b/test/fixedbugs/bug386.go
@@ -0,0 +1,12 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// Issue 2451, 2452 
+package foo
+
+func f() error { return 0 } // ERROR "cannot use 0 .type int.|has no methods"
+
+func g() error { return -1 }  // ERROR "cannot use -1 .type int.|has no methods"
diff --git a/test/fixedbugs/bug387.go b/test/fixedbugs/bug387.go
new file mode 100644
index 000000000..59d5ef903
--- /dev/null
+++ b/test/fixedbugs/bug387.go
@@ -0,0 +1,30 @@
+// compile
+
+// Copyright 2011 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.
+
+// Issue 2549
+
+/*  Used to die with
+missing typecheck: [7f5bf07b4438]
+
+.   AS l(45)
+.   .   NAME-main.autotmp_0017 u(1) a(1) l(45) x(0+0) class(PAUTO)
+esc(N) tc(1) used(1) ARRAY-[2]string
+internal compiler error: missing typecheck 
+*/
+package main
+
+import (
+        "fmt"
+        "path/filepath"
+)
+
+func main() {
+        switch _, err := filepath.Glob(filepath.Join(".", "vnc")); {
+        case err != nil:
+                fmt.Println(err)
+        }
+}
+
diff --git a/test/fixedbugs/bug388.go b/test/fixedbugs/bug388.go
new file mode 100644
index 000000000..d41f9ea54
--- /dev/null
+++ b/test/fixedbugs/bug388.go
@@ -0,0 +1,39 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// Issue 2231
+
+package main
+import "runtime"
+
+func foo(runtime.UintType, i int) {  // ERROR "cannot declare name runtime.UintType|named/anonymous mix|undefined identifier"
+	println(i, runtime.UintType) // GCCGO_ERROR "undefined identifier"
+}
+
+func bar(i int) {
+	runtime.UintType := i       // ERROR "cannot declare name runtime.UintType|non-name on left side|undefined identifier"
+	println(runtime.UintType)	// GCCGO_ERROR "invalid use of type|undefined identifier"
+}
+
+func baz() {
+	main.i := 1	// ERROR "non-name main.i|non-name on left side"
+	println(main.i)	// GCCGO_ERROR "no fields or methods"
+}
+
+func qux() {
+	var main.i	// ERROR "unexpected [.]|expected type"
+	println(main.i)
+}
+
+func corge() {
+	var foo.i int  // ERROR "unexpected [.]|expected type"
+	println(foo.i)
+}
+
+func main() {
+	foo(42,43)
+	bar(1969)
+}
diff --git a/test/fixedbugs/bug389.go b/test/fixedbugs/bug389.go
new file mode 100644
index 000000000..55a02e05c
--- /dev/null
+++ b/test/fixedbugs/bug389.go
@@ -0,0 +1,12 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// Issue 2563
+package foo
+
+func fn(a float32) {}
+
+var f func(arg int) = fn  // ERROR "cannot use fn .type func.float32.. as type func.int. in assignment|different parameter types"
diff --git a/test/fixedbugs/bug390.go b/test/fixedbugs/bug390.go
new file mode 100644
index 000000000..7ce9e1370
--- /dev/null
+++ b/test/fixedbugs/bug390.go
@@ -0,0 +1,16 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// Issue 2627 -- unsafe.Pointer type isn't handled nicely in some errors
+
+package main
+
+import "unsafe"
+
+func main() {
+	var x *int
+	_ = unsafe.Pointer(x) - unsafe.Pointer(x) // ERROR "operator - not defined on unsafe.Pointer|expected integer, floating, or complex type"
+}
diff --git a/test/fixedbugs/bug391.go b/test/fixedbugs/bug391.go
new file mode 100644
index 000000000..07d129ddc
--- /dev/null
+++ b/test/fixedbugs/bug391.go
@@ -0,0 +1,14 @@
+// compile
+
+// Copyright 2011 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.
+
+// Issue 2576
+package bug
+
+type T struct { a int }
+
+func f(t T) {
+        switch _, _ = t.a, t.a; {}
+}
+\ No newline at end of file
diff --git a/test/fixedbugs/bug392.dir/one.go b/test/fixedbugs/bug392.dir/one.go
new file mode 100644
index 000000000..8242f2846
--- /dev/null
+++ b/test/fixedbugs/bug392.dir/one.go
@@ -0,0 +1,43 @@
+// Copyright 2012 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.
+
+// Functions that the inliner exported incorrectly.
+
+package one
+
+type T int
+
+// Issue 2678
+func F1(T *T) bool { return T == nil }
+
+// Issue 2682.
+func F2(c chan int) bool { return c == (<-chan int)(nil) }
+
+// Use of single named return value.
+func F3() (ret []int) { return append(ret, 1) }
+
+// Call of inlined method with blank receiver.
+func (_ *T) M() int { return 1 }
+func (t *T) MM() int { return t.M() }
+
+
+// One more like issue 2678
+type S struct { x, y int }
+type U []S
+
+func F4(S int) U { return U{{S,S}} }
+
+func F5() []*S {
+	return []*S{ {1,2}, { 3, 4} }
+}
+
+func F6(S int) *U {
+	return &U{{S,S}}
+}
+
+// Bug in the fix.
+
+type PB struct { x int }
+
+func (t *PB) Reset() { *t = PB{} }
diff --git a/test/fixedbugs/bug392.dir/three.go b/test/fixedbugs/bug392.dir/three.go
new file mode 100644
index 000000000..a6193bf91
--- /dev/null
+++ b/test/fixedbugs/bug392.dir/three.go
@@ -0,0 +1,13 @@
+// Copyright 2012 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.
+
+// Use the functions in one.go so that the inlined
+// forms get type-checked.
+
+package three
+
+import "./two"
+
+var x = two.F()
+var v = two.V
diff --git a/test/fixedbugs/bug392.dir/two.go b/test/fixedbugs/bug392.dir/two.go
new file mode 100644
index 000000000..a9033dbb0
--- /dev/null
+++ b/test/fixedbugs/bug392.dir/two.go
@@ -0,0 +1,25 @@
+// Copyright 2012 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.
+
+// Use the functions in one.go so that the inlined
+// forms get type-checked.
+
+package two
+
+import "./one"
+
+func use() {
+	one.F1(nil)
+	one.F2(nil)
+	one.F3()
+	one.F4(1)
+
+	var t *one.T
+	t.M()
+	t.MM()
+}
+
+var V = []one.PB{{}, {}}
+
+func F() *one.PB
diff --git a/test/fixedbugs/bug392.go b/test/fixedbugs/bug392.go
new file mode 100644
index 000000000..a7a4216c4
--- /dev/null
+++ b/test/fixedbugs/bug392.go
@@ -0,0 +1,7 @@
+// $G $D/$F.dir/one.go && $G $D/$F.dir/two.go && $G $D/$F.dir/three.go
+
+// Copyright 2011 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.
+
+package ignored
diff --git a/test/fixedbugs/bug393.go b/test/fixedbugs/bug393.go
new file mode 100644
index 000000000..f8a9c6578
--- /dev/null
+++ b/test/fixedbugs/bug393.go
@@ -0,0 +1,30 @@
+// compile
+
+// Copyright 2012 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.
+
+// issue 2672
+// was trying binary search with an interface type
+
+package bug393
+
+func f(x interface{}) int {
+	switch x {
+	case 1:
+		return 1
+	case 2:
+		return 2
+	case 3:
+		return 3
+	case 4:
+		return 4
+	case "5":
+		return 5
+	case "6":
+		return 6
+	default:
+		return 7
+	}
+	panic("switch")
+}
diff --git a/test/fixedbugs/bug394.go b/test/fixedbugs/bug394.go
new file mode 100644
index 000000000..2d77156c1
--- /dev/null
+++ b/test/fixedbugs/bug394.go
@@ -0,0 +1,10 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// Issue 2598
+package foo
+
+return nil // ERROR "non-declaration statement outside function body|expected declaration"
diff --git a/test/fixedbugs/bug396.dir/one.go b/test/fixedbugs/bug396.dir/one.go
new file mode 100644
index 000000000..7902a07d5
--- /dev/null
+++ b/test/fixedbugs/bug396.dir/one.go
@@ -0,0 +1,9 @@
+// Copyright 2012 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.
+
+package one
+
+type T struct { int }
+
+func New(i int) T { return T{i} }
diff --git a/test/fixedbugs/bug396.dir/two.go b/test/fixedbugs/bug396.dir/two.go
new file mode 100644
index 000000000..9b32508fd
--- /dev/null
+++ b/test/fixedbugs/bug396.dir/two.go
@@ -0,0 +1,14 @@
+// Copyright 2012 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.
+
+// Use the functions in one.go so that the inlined
+// forms get type-checked.
+
+package two
+
+import "./one"
+
+func use() {
+	_ = one.New(1)
+}
+\ No newline at end of file
diff --git a/test/fixedbugs/bug396.go b/test/fixedbugs/bug396.go
new file mode 100644
index 000000000..50af6006f
--- /dev/null
+++ b/test/fixedbugs/bug396.go
@@ -0,0 +1,7 @@
+// $G $D/$F.dir/one.go && $G $D/$F.dir/two.go
+
+// Copyright 2011 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.
+
+package ignored
diff --git a/test/fixedbugs/bug397.go b/test/fixedbugs/bug397.go
new file mode 100644
index 000000000..56cc7cdd4
--- /dev/null
+++ b/test/fixedbugs/bug397.go
@@ -0,0 +1,13 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+package main
+
+// Issue 2623
+var m = map[string]int {
+	"abc":1,
+	1:2, // ERROR "cannot use 1.*as type string in map key|incompatible type"
+}
diff --git a/test/fixedbugs/bug398.go b/test/fixedbugs/bug398.go
new file mode 100644
index 000000000..1dd3fa421
--- /dev/null
+++ b/test/fixedbugs/bug398.go
@@ -0,0 +1,24 @@
+// compile
+
+// Copyright 2012 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.
+
+// Used to crash compiler in interface type equality check.
+
+package p
+
+type I1 interface {
+      F() interface{I1}
+}
+
+type I2 interface {
+      F() interface{I2}
+}       
+
+var v1 I1
+var v2 I2
+
+func f() bool {
+       return v1 == v2
+}
diff --git a/test/fixedbugs/bug399.go b/test/fixedbugs/bug399.go
new file mode 100644
index 000000000..94852c9ee
--- /dev/null
+++ b/test/fixedbugs/bug399.go
@@ -0,0 +1,15 @@
+// compile
+
+// Copyright 2011 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.
+
+// Issue 2674
+
+package main
+const dow = "\000\003"
+
+func main() {
+	println(int(dow[1]))
+}
+
diff --git a/test/fixedbugs/bug401.go b/test/fixedbugs/bug401.go
new file mode 100644
index 000000000..5589b5b1b
--- /dev/null
+++ b/test/fixedbugs/bug401.go
@@ -0,0 +1,46 @@
+// run
+
+// Copyright 2011 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.
+
+// Issue 2582
+package main
+
+type T struct{}
+
+func (T) cplx() complex128 {
+	for false {
+	} // avoid inlining
+	return complex(1, 0)
+}
+
+func (T) cplx2() complex128 {
+	return complex(0, 1)
+}
+
+type I interface {
+	cplx() complex128
+}
+
+func main() {
+
+	var t T
+
+	if v := real(t.cplx()); v != 1 {
+		panic("not-inlined complex call failed")
+	}
+	_ = imag(t.cplx())
+
+	_ = real(t.cplx2())
+	if v := imag(t.cplx2()); v != 1 {
+		panic("potentially inlined complex call failed")
+	}
+
+	var i I
+	i = t
+	if v := real(i.cplx()); v != 1 {
+		panic("potentially inlined complex call failed")
+	}
+	_ = imag(i.cplx())
+}
diff --git a/test/fixedbugs/bug402.go b/test/fixedbugs/bug402.go
new file mode 100644
index 000000000..db3f3da44
--- /dev/null
+++ b/test/fixedbugs/bug402.go
@@ -0,0 +1,31 @@
+// run
+
+// Copyright 2012 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.
+
+package main
+
+import "fmt"
+
+var a = []int64{
+	0.0005 * 1e9,
+	0.001 * 1e9,
+	0.005 * 1e9,
+	0.01 * 1e9,
+	0.05 * 1e9,
+	0.1 * 1e9,
+	0.5 * 1e9,
+	1 * 1e9,
+	5 * 1e9,
+}
+
+func main() {
+	s := ""
+	for _, v := range a {
+		s += fmt.Sprint(v) + " "
+	}
+	if s != "500000 1000000 5000000 10000000 50000000 100000000 500000000 1000000000 5000000000 " {
+		panic(s)
+	}
+}
diff --git a/test/fixedbugs/bug403.go b/test/fixedbugs/bug403.go
new file mode 100644
index 000000000..ed7b49aea
--- /dev/null
+++ b/test/fixedbugs/bug403.go
@@ -0,0 +1,23 @@
+// compile
+
+// Copyright 2012 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.
+
+// Crashed gccgo.
+
+package p
+
+type S struct {
+	f interface{}
+}
+
+func F(p *S) bool {
+	v := p.f
+	switch a := v.(type) {
+	case nil:
+		_ = a
+		return true
+	}
+	return true
+}
diff --git a/test/fixedbugs/bug404.dir/one.go b/test/fixedbugs/bug404.dir/one.go
new file mode 100644
index 000000000..2024eb007
--- /dev/null
+++ b/test/fixedbugs/bug404.dir/one.go
@@ -0,0 +1,19 @@
+// Copyright 2012 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.
+
+package one
+
+type T1 int
+type T2 []T1
+type T3 T2
+
+func F1(T2) {
+}
+
+func (p *T1) M1() T3 {
+	return nil
+}
+
+func (p T3) M2() {
+}
diff --git a/test/fixedbugs/bug404.dir/two.go b/test/fixedbugs/bug404.dir/two.go
new file mode 100644
index 000000000..162eae712
--- /dev/null
+++ b/test/fixedbugs/bug404.dir/two.go
@@ -0,0 +1,12 @@
+// Copyright 2012 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.
+
+// The gccgo compiler would fail on the import statement.
+// two.go:10:13: error: use of undefined type ‘one.T2’
+
+package two
+
+import "./one"
+
+var V one.T3
diff --git a/test/fixedbugs/bug404.go b/test/fixedbugs/bug404.go
new file mode 100644
index 000000000..ac9e575bb
--- /dev/null
+++ b/test/fixedbugs/bug404.go
@@ -0,0 +1,7 @@
+// $G $D/$F.dir/one.go && $G $D/$F.dir/two.go
+
+// Copyright 2012 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.
+
+package ignored
diff --git a/test/fixedbugs/bug405.go b/test/fixedbugs/bug405.go
new file mode 100644
index 000000000..e8ecc4d03
--- /dev/null
+++ b/test/fixedbugs/bug405.go
@@ -0,0 +1,24 @@
+// run
+
+// Copyright 2012 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.
+
+// Test using _ receiver.  Failed with gccgo.
+
+package main
+
+type S struct {}
+
+func (_ S) F(i int) int {
+	return i
+}
+
+func main() {
+	s := S{}
+	const c = 123
+	i := s.F(c)
+	if i != c {
+		panic(i)
+	}
+}
diff --git a/test/fixedbugs/bug406.go b/test/fixedbugs/bug406.go
new file mode 100644
index 000000000..c6f8534c9
--- /dev/null
+++ b/test/fixedbugs/bug406.go
@@ -0,0 +1,25 @@
+// run
+
+// Copyright 2012 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.
+
+// Issue 2821
+package main
+
+type matrix struct {
+	e []int
+}
+
+func (a matrix) equal() bool {
+	for _ = range a.e {
+	}
+	return true
+}
+
+func main() {
+	var a matrix
+	var i interface{}
+	i = true && a.equal()
+	_ = i
+}
diff --git a/test/fixedbugs/bug407.dir/one.go b/test/fixedbugs/bug407.dir/one.go
new file mode 100644
index 000000000..a91d90433
--- /dev/null
+++ b/test/fixedbugs/bug407.dir/one.go
@@ -0,0 +1,20 @@
+// Copyright 2012 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.
+
+package one
+
+// Issue 2877
+type T struct {
+	f func(t *T, arg int)
+	g func(t T, arg int)
+}
+
+func (t *T) foo(arg int) {}
+func (t T) goo(arg int) {}
+
+func (t *T) F() { t.f = (*T).foo }
+func (t *T) G() { t.g = T.goo }
+
+
+
diff --git a/test/fixedbugs/bug407.dir/two.go b/test/fixedbugs/bug407.dir/two.go
new file mode 100644
index 000000000..67e1852ea
--- /dev/null
+++ b/test/fixedbugs/bug407.dir/two.go
@@ -0,0 +1,15 @@
+// Copyright 2012 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.
+
+// Use the functions in one.go so that the inlined
+// forms get type-checked.
+
+package two
+
+import "./one"
+
+func use() {
+	var r one.T
+	r.F()
+}
diff --git a/test/fixedbugs/bug407.go b/test/fixedbugs/bug407.go
new file mode 100644
index 000000000..50af6006f
--- /dev/null
+++ b/test/fixedbugs/bug407.go
@@ -0,0 +1,7 @@
+// $G $D/$F.dir/one.go && $G $D/$F.dir/two.go
+
+// Copyright 2011 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.
+
+package ignored
diff --git a/test/fixedbugs/bug409.go b/test/fixedbugs/bug409.go
new file mode 100644
index 000000000..1dca43b7a
--- /dev/null
+++ b/test/fixedbugs/bug409.go
@@ -0,0 +1,20 @@
+// cmpout
+
+// Copyright 2012 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.
+
+// Multiple inlined calls to a function that causes
+// redundant address loads.
+
+package main
+
+func F(v [2]float64) [2]float64 {
+	return [2]float64{v[0], v[1]}
+}
+
+func main() {
+	a := F([2]float64{1, 2})
+	b := F([2]float64{3, 4})
+	println(a[0], a[1], b[0], b[1])
+}
diff --git a/test/fixedbugs/bug409.out b/test/fixedbugs/bug409.out
new file mode 100644
index 000000000..3cb40ed59
--- /dev/null
+++ b/test/fixedbugs/bug409.out
@@ -0,0 +1 @@
++1.000000e+000 +2.000000e+000 +3.000000e+000 +4.000000e+000
diff --git a/test/fixedbugs/bug410.go b/test/fixedbugs/bug410.go
new file mode 100644
index 000000000..35ecbfc05
--- /dev/null
+++ b/test/fixedbugs/bug410.go
@@ -0,0 +1,24 @@
+// compile
+
+// Copyright 2012 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.
+
+// Used to run 6g out of registers.  Issue 2669.
+
+package p
+
+type y struct {
+	num int
+}
+
+func zzz () {
+    k := make([]byte, 10)
+	arr := make ([]*y, 0)
+    for s := range arr {
+        x := make([]byte, 10)
+        for i := 0; i < 100 ; i++ {
+            x[i] ^= k[i-arr[s].num%0]
+        }
+    }
+}
diff --git a/test/fixedbugs/bug411.go b/test/fixedbugs/bug411.go
new file mode 100644
index 000000000..3b90db88d
--- /dev/null
+++ b/test/fixedbugs/bug411.go
@@ -0,0 +1,19 @@
+// compile
+
+// Copyright 2012 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.
+
+// Issue 2588.  Used to trigger internal compiler error on 8g,
+// because the compiler tried to registerize the int64 being
+// used as a memory operand of a int64->float64 move.
+
+package p
+
+func f1(a int64) {
+	f2(float64(a), float64(a))
+}
+
+func f2(a,b float64) {
+}
+
diff --git a/test/fixedbugs/bug412.go b/test/fixedbugs/bug412.go
new file mode 100644
index 000000000..9148b68e7
--- /dev/null
+++ b/test/fixedbugs/bug412.go
@@ -0,0 +1,16 @@
+// errorcheck
+
+// Copyright 2012 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.
+
+package p
+
+type t struct {
+	x int  // ERROR "duplicate field x"
+	x int
+}
+
+func f(t *t) int {
+	return t.x  // ERROR "ambiguous selector t.x"
+}
diff --git a/test/fixedbugs/bug413.go b/test/fixedbugs/bug413.go
new file mode 100644
index 000000000..41270d906
--- /dev/null
+++ b/test/fixedbugs/bug413.go
@@ -0,0 +1,11 @@
+// errorcheck
+
+// Copyright 2012 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.
+
+package p
+
+func f(i int) int { return i }
+
+var i = func() int {a := f(i); return a}()  // ERROR "initialization loop"
+\ No newline at end of file
diff --git a/test/fixedbugs/bug414.dir/main.go b/test/fixedbugs/bug414.dir/main.go
new file mode 100644
index 000000000..52001233c
--- /dev/null
+++ b/test/fixedbugs/bug414.dir/main.go
@@ -0,0 +1,18 @@
+// Copyright 2012 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.
+
+	  package main
+	
+	  import "./p1"
+	
+	  type MyObject struct {
+	    p1.Fer
+	  }
+	
+	  func main() {
+	    var b p1.Fer = &p1.Object{}
+	    p1.PrintFer(b)
+	    var c p1.Fer = &MyObject{b}
+	    p1.PrintFer(c)
+	  }
diff --git a/test/fixedbugs/bug414.dir/p1.go b/test/fixedbugs/bug414.dir/p1.go
new file mode 100644
index 000000000..7768818bf
--- /dev/null
+++ b/test/fixedbugs/bug414.dir/p1.go
@@ -0,0 +1,21 @@
+// Copyright 2012 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.
+
+	  package p1
+	
+	  import "fmt"
+	
+	  type Fer interface {
+	    f() string
+	  }
+	
+	  type Object struct {}
+	
+	  func (this *Object) f() string {
+	    return "Object.f"
+	  }
+	
+	  func PrintFer(fer Fer) {
+	    fmt.Sprintln(fer.f())
+	  }
diff --git a/test/fixedbugs/bug414.go b/test/fixedbugs/bug414.go
new file mode 100644
index 000000000..8824b1a1e
--- /dev/null
+++ b/test/fixedbugs/bug414.go
@@ -0,0 +1,7 @@
+// $G $D/$F.dir/p1.go && $G $D/$F.dir/main.go && $L main.$A && ./$A.out
+
+// Copyright 2012 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.
+
+package ignored
diff --git a/test/fixedbugs/bug415.dir/main.go b/test/fixedbugs/bug415.dir/main.go
new file mode 100644
index 000000000..b894453fc
--- /dev/null
+++ b/test/fixedbugs/bug415.dir/main.go
@@ -0,0 +1,9 @@
+// Copyright 2012 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.
+
+package main
+import "./p"
+func main() {}
+var _ p.A
+
diff --git a/test/fixedbugs/bug415.dir/p.go b/test/fixedbugs/bug415.dir/p.go
new file mode 100644
index 000000000..b4152d63a
--- /dev/null
+++ b/test/fixedbugs/bug415.dir/p.go
@@ -0,0 +1,14 @@
+// Copyright 2012 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.
+
+package p
+
+type A struct {
+	s struct{int}
+}
+
+func (a *A) f() {
+	a.s = struct{int}{0}
+}
+
diff --git a/test/fixedbugs/bug415.go b/test/fixedbugs/bug415.go
new file mode 100644
index 000000000..fbf034218
--- /dev/null
+++ b/test/fixedbugs/bug415.go
@@ -0,0 +1,9 @@
+// $G $D/$F.dir/p.go && $G $D/$F.dir/main.go
+
+// Copyright 2012 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.
+
+// Issue 2716.  Export metadata error made main.go not compile.
+
+package ignored
diff --git a/test/fixedbugs/bug416.go b/test/fixedbugs/bug416.go
new file mode 100644
index 000000000..c12853842
--- /dev/null
+++ b/test/fixedbugs/bug416.go
@@ -0,0 +1,13 @@
+// errorcheck
+
+// Copyright 2012 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.
+
+package p
+
+type T struct {
+	X int
+}
+
+func (t *T) X() {} // ERROR "type T has both field and method named X"
diff --git a/test/fixedbugs/bug417.go b/test/fixedbugs/bug417.go
new file mode 100644
index 000000000..a9acb4238
--- /dev/null
+++ b/test/fixedbugs/bug417.go
@@ -0,0 +1,32 @@
+// compile
+
+// Copyright 2009 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.
+
+// Some indirect uses of types crashed gccgo, because it assumed that
+// the size of the type was known before it had been computed.
+
+package p
+
+type S1 struct {
+	p *[1]S3
+	s [][1]S3
+	m map[int][1]S3
+	c chan [1]S3
+	i interface { f([1]S3) [1]S3 }
+	f func([1]S3) [1]S3
+}
+
+type S2 struct {
+	p *struct { F S3 }
+	s []struct { F S3 }
+	m map[int]struct { F S3 }
+	c chan struct { F S3 }
+	i interface { f(struct { F S3 }) struct { F S3 } }
+	f func(struct { F S3 } ) struct { F S3 }
+}
+
+type S3 struct {
+	I int
+}
diff --git a/test/fixedbugs/bug418.go b/test/fixedbugs/bug418.go
new file mode 100644
index 000000000..64d86b340
--- /dev/null
+++ b/test/fixedbugs/bug418.go
@@ -0,0 +1,22 @@
+// errorcheck
+
+// Copyright 2012 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.
+
+// Issue 3044.
+// Multiple valued expressions in return lists.
+
+package p
+
+func Two() (a, b int)
+
+// F used to compile.
+func F() (x interface{}, y int) {
+	return Two(), 0 // ERROR "single-value context"
+}
+
+// Recursive used to trigger an internal compiler error.
+func Recursive() (x interface{}, y int) {
+	return Recursive(), 0 // ERROR "single-value context"
+}
diff --git a/test/fixedbugs/bug419.go b/test/fixedbugs/bug419.go
new file mode 100644
index 000000000..cfab404eb
--- /dev/null
+++ b/test/fixedbugs/bug419.go
@@ -0,0 +1,17 @@
+// compile
+
+// Copyright 2012 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.
+
+// Issue 1811.
+// gccgo failed to compile this.
+
+package p
+
+type E interface{}
+
+type I interface {
+	E
+	E
+}
diff --git a/test/fixedbugs/bug420.go b/test/fixedbugs/bug420.go
new file mode 100644
index 000000000..02b4349d8
--- /dev/null
+++ b/test/fixedbugs/bug420.go
@@ -0,0 +1,14 @@
+// compile
+
+// Copyright 2012 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.
+
+// Issue 1757.
+// gccgo failed to compile this.
+
+package main
+
+func main() {
+     (_) = 0
+}
diff --git a/test/fixedbugs/bug421.go b/test/fixedbugs/bug421.go
new file mode 100644
index 000000000..1fe02375a
--- /dev/null
+++ b/test/fixedbugs/bug421.go
@@ -0,0 +1,17 @@
+// errorcheck
+
+// Copyright 2012 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.
+
+// Issue 1927.
+// gccgo failed to issue the first error below.
+
+package main
+
+func main() {
+	println(int(1) == uint(1))	// ERROR "types"
+	var x int = 1
+	var y uint = 1
+	println(x == y)			// ERROR "types"
+}
diff --git a/test/fixedbugs/bug422.go b/test/fixedbugs/bug422.go
new file mode 100644
index 000000000..6865fe4b6
--- /dev/null
+++ b/test/fixedbugs/bug422.go
@@ -0,0 +1,11 @@
+// compile
+
+// Copyright 2012 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.
+
+// gccgo crashed compiling this file.
+
+package p
+
+var V = "a" > "b"
diff --git a/test/fixedbugs/bug423.go b/test/fixedbugs/bug423.go
new file mode 100644
index 000000000..726891245
--- /dev/null
+++ b/test/fixedbugs/bug423.go
@@ -0,0 +1,277 @@
+// run
+
+// Copyright 2012 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.
+
+// gc used to overflow a counter when a variable was
+// mentioned 256 times, and generate stack corruption.
+
+package main
+
+func main() {
+	F(1)
+}
+
+func F(arg int) {
+	var X interface{}
+	_ = X // used once
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0 // used 32 times
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0 // used 64 times
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0 // used 96 times
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0 // used 128 times
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0 // used 200 times
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0
+	X = 0 // used 256 times
+	if arg != 1 {
+		panic("argument was changed")
+	}
+}
diff --git a/test/fixedbugs/bug424.dir/lib.go b/test/fixedbugs/bug424.dir/lib.go
new file mode 100644
index 000000000..97054da3a
--- /dev/null
+++ b/test/fixedbugs/bug424.dir/lib.go
@@ -0,0 +1,16 @@
+// Copyright 2012 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.
+
+package lib
+
+type I interface {
+	m() string
+}
+
+type T struct{}
+
+// m is not accessible from outside this package.
+func (t *T) m() string {
+	return "lib.T.m"
+}
diff --git a/test/fixedbugs/bug424.go b/test/fixedbugs/bug424.go
new file mode 100644
index 000000000..42cff54d4
--- /dev/null
+++ b/test/fixedbugs/bug424.go
@@ -0,0 +1,99 @@
+// $G $D/$F.dir/lib.go && $G $D/$F.go && $L $F.$A && ./$A.out
+
+// Copyright 2012 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.
+
+// Tests that method calls through an interface always
+// call the locally defined method localT.m independent
+// at which embedding level it is and in which order
+// embedding is done.
+
+package main
+
+import "./lib"
+import "reflect"
+import "fmt"
+
+type localI interface {
+	m() string
+}
+
+type localT struct{}
+
+func (t *localT) m() string {
+	return "main.localT.m"
+}
+
+type myT1 struct {
+	localT
+}
+
+type myT2 struct {
+	localT
+	lib.T
+}
+
+type myT3 struct {
+	lib.T
+	localT
+}
+
+func main() {
+	var i localI
+
+	i = new(localT)
+	if i.m() != "main.localT.m" {
+		println("BUG: localT:", i.m(), "called")
+	}
+
+	i = new(myT1)
+	if i.m() != "main.localT.m" {
+		println("BUG: myT1:", i.m(), "called")
+	}
+
+	i = new(myT2)
+	if i.m() != "main.localT.m" {
+		println("BUG: myT2:", i.m(), "called")
+	}
+
+	t3 := new(myT3)
+	if t3.m() != "main.localT.m" {
+		println("BUG: t3:", t3.m(), "called")
+	}
+	
+	i = new(myT3)
+	if i.m() != "main.localT.m" {
+		t := reflect.TypeOf(i)
+		n := t.NumMethod()
+		for j := 0; j < n; j++ {
+			m := t.Method(j)
+			fmt.Printf("#%d: %s.%s %s\n", j, m.PkgPath, m.Name, m.Type)
+		}
+		println("BUG: myT3:", i.m(), "called")
+	}
+	
+	var t4 struct {
+		localT
+		lib.T
+	}
+	if t4.m() != "main.localT.m" {
+		println("BUG: t4:", t4.m(), "called")
+	}
+	i = &t4
+	if i.m() != "main.localT.m" {
+		println("BUG: myT4:", i.m(), "called")
+	}
+	
+	var t5 struct {
+		lib.T
+		localT
+	}
+	if t5.m() != "main.localT.m" {
+		println("BUG: t5:", t5.m(), "called")
+	}
+	i = &t5
+	if i.m() != "main.localT.m" {
+		println("BUG: myT5:", i.m(), "called")
+	}
+}
diff --git a/test/fixedbugs/bug425.go b/test/fixedbugs/bug425.go
new file mode 100644
index 000000000..5546bd96b
--- /dev/null
+++ b/test/fixedbugs/bug425.go
@@ -0,0 +1,17 @@
+// compile
+
+// Copyright 2012 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.
+
+// http://code.google.com/p/go/issues/detail?id=3119
+
+package main
+
+import "fmt"
+
+func main() {
+	s := "hello"
+	fmt.Println(s == "")
+	fmt.Println(s + "world" == "world")
+}
diff --git a/test/fixedbugs/bug426.go b/test/fixedbugs/bug426.go
new file mode 100644
index 000000000..a1af3cf99
--- /dev/null
+++ b/test/fixedbugs/bug426.go
@@ -0,0 +1,15 @@
+// compile
+
+// Copyright 2012 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.
+
+// gccgo crashed compiling this.
+
+package p
+
+type T *T
+
+func f(t T) {
+	println(t, *t)
+}
diff --git a/test/fixedbugs/bug427.go b/test/fixedbugs/bug427.go
new file mode 100644
index 000000000..1239e7a33
--- /dev/null
+++ b/test/fixedbugs/bug427.go
@@ -0,0 +1,39 @@
+// compile
+
+// Copyright 2012 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.
+
+// http://code.google.com/p/go/issues/detail?id=3351
+
+package main
+
+// struct with four fields of basic type
+type S struct {a, b, c, d int}
+
+// struct with five fields of basic type
+type T struct {a, b, c, d, e int}
+
+// array with four elements
+type A [4]int
+
+// array with five elements
+type B [5]int
+
+func main() {
+	var i interface{}
+
+	var s1, s2 S
+	i = s1 == s2
+
+	var t1, t2 T
+	i = t1 == t2
+
+	var a1, a2 A
+	i = a1 == a2
+
+	var b1, b2 B
+	i = b1 == b2
+
+	_ = i
+}
diff --git a/test/fixedbugs/bug428.go b/test/fixedbugs/bug428.go
new file mode 100644
index 000000000..298c45518
--- /dev/null
+++ b/test/fixedbugs/bug428.go
@@ -0,0 +1,19 @@
+// run
+
+// Copyright 2012 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.
+
+// Test that when the compiler expands append inline it does not
+// overwrite a value before it needs it (issue 3369).
+
+package main
+
+func main() {
+	s := make([]byte, 5, 6)
+	copy(s, "12346")
+	s = append(s[:len(s)-1], '5', s[len(s)-1])
+	if string(s) != "123456" {
+		panic(s)
+	}
+}
diff --git a/test/fixedbugs/bug429.go b/test/fixedbugs/bug429.go
new file mode 100644
index 000000000..c1bd1d4bb
--- /dev/null
+++ b/test/fixedbugs/bug429.go
@@ -0,0 +1,13 @@
+// $G $D/$F.go && $L $F.$A && ! ./$A.out || echo BUG: bug429
+
+// Copyright 2012 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.
+
+// Should print deadlock message, not hang.
+
+package main
+
+func main() {
+	select {}
+}
diff --git a/test/float_lit.go b/test/float_lit.go
index 7b91d88e5..2912c3749 100644
--- a/test/float_lit.go
+++ b/test/float_lit.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test floating-point literal syntax.
+
 package main
 
 var bad bool
diff --git a/test/floatcmp.go b/test/floatcmp.go
index f51cbc277..f9f59a937 100644
--- a/test/floatcmp.go
+++ b/test/floatcmp.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test floating-point comparison involving NaN.
+
 package main
 
 import "math"
diff --git a/test/for.go b/test/for.go
index 36ad15709..8a5009065 100644
--- a/test/for.go
+++ b/test/for.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test for loops.
+
 package main
 
 func assertequal(is, shouldbe int, msg string) {
diff --git a/test/func.go b/test/func.go
index e8ed928bc..246cb56fd 100644
--- a/test/func.go
+++ b/test/func.go
@@ -1,9 +1,10 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test simple functions.
 
 package main
 
diff --git a/test/func1.go b/test/func1.go
index 056ff9877..c89f7ff2e 100644
--- a/test/func1.go
+++ b/test/func1.go
@@ -1,14 +1,15 @@
-// errchk $G $F.go
+// errorcheck
 
 // Copyright 2009 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.
 
-// does not compile and should not compile
+// Test that result parameters are in the same scope as regular parameters.
+// Does not compile.
 
 package main
 
-func f1(a int) (int, float32) { // BUG (not caught by compiler): multiple return values must have names
+func f1(a int) (int, float32) {
 	return 7, 7.0
 }
 
diff --git a/test/func2.go b/test/func2.go
index 5a6d7d0e1..b5966a91f 100644
--- a/test/func2.go
+++ b/test/func2.go
@@ -1,11 +1,13 @@
-// $G $F.go || echo BUG: should compile
+// compile
 
 // Copyright 2009 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.
 
+// Test function signatures.
+// Compiled but not run.
+
 package main
-import os "os"
 
 type t1 int
 type t2 int
@@ -23,7 +25,7 @@ func f8(os int) int
 func f9(os int) int {
 	return os
 }
-func f10(err os.Error) os.Error {
+func f10(err error) error {
 	return err
 }
 func f11(t1 string) string {
diff --git a/test/func3.go b/test/func3.go
index 110b0ef1c..6be3bf018 100644
--- a/test/func3.go
+++ b/test/func3.go
@@ -1,9 +1,12 @@
-// errchk $G $F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Verify that illegal function signatures are detected.
+// Does not compile.
+
 package main
 
 type t1 int
diff --git a/test/func4.go b/test/func4.go
index 69ce56a19..85f1e4b81 100644
--- a/test/func4.go
+++ b/test/func4.go
@@ -1,9 +1,12 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Verify that it is illegal to take the address of a function.
+// Does not compile.
+
 package main
 
 var notmain func()
@@ -11,4 +14,5 @@ var notmain func()
 func main() {
 	var x = &main		// ERROR "address of|invalid"
 	main = notmain	// ERROR "assign to|invalid"
+	_ = x
 }
diff --git a/test/func5.go b/test/func5.go
index e27825c2b..2e058be7e 100644
--- a/test/func5.go
+++ b/test/func5.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test functions and goroutines.
+
 package main
 
 func caller(f func(int, int) int, a, b int, c chan int) {
diff --git a/test/func6.go b/test/func6.go
index 1356b6aa8..456cb49f0 100644
--- a/test/func6.go
+++ b/test/func6.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go
+// run
 
 // Copyright 2011 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.
 
+// Test closures in if conditions.
+
 package main
 
 func main() {
diff --git a/test/func7.go b/test/func7.go
index e38b008cc..6f6766f29 100644
--- a/test/func7.go
+++ b/test/func7.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2011 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.
 
+// Test evaluation order in if condition.
+
 package main
 
 var calledf = false
diff --git a/test/func8.go b/test/func8.go
new file mode 100644
index 000000000..7defe265b
--- /dev/null
+++ b/test/func8.go
@@ -0,0 +1,49 @@
+// run
+
+// Copyright 2011 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.
+
+// Test evaluation order.
+
+package main
+
+var calledf int
+
+func f() int {
+	calledf++
+	return 0
+}
+
+func g() int {
+	return calledf
+}
+
+var xy string
+
+func x() bool {
+	for false {
+	} // no inlining
+	xy += "x"
+	return false
+}
+
+func y() string {
+	for false {
+	} // no inlining
+	xy += "y"
+	return "abc"
+}
+
+func main() {
+	if f() == g() {
+		println("wrong f,g order")
+	}
+
+	if x() == (y() == "abc") {
+		panic("wrong compare")
+	}
+	if xy != "xy" {
+		println("wrong x,y order")
+	}
+}
diff --git a/test/gc.go b/test/gc.go
index 3aab8fac9..6688f9fbd 100644
--- a/test/gc.go
+++ b/test/gc.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Simple test of the garbage collector.
+
 package main
 
 import "runtime"
diff --git a/test/gc1.go b/test/gc1.go
index 84034e7ce..6049ea14e 100644
--- a/test/gc1.go
+++ b/test/gc1.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// A simple test of the garbage collector.
+
 package main
 
 func main() {
diff --git a/test/gc2.go b/test/gc2.go
index c54d807df..de52a4fbf 100644
--- a/test/gc2.go
+++ b/test/gc2.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2011 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.
 
-// Check that buffered channels are garbage collected properly.
+// Test that buffered channels are garbage collected properly.
 // An interesting case because they have finalizers and used to
 // have self loops that kept them from being collected.
 // (Cyclic data with finalizers is never finalized, nor collected.)
@@ -19,7 +19,9 @@ import (
 
 func main() {
 	const N = 10000
-	st := runtime.MemStats
+	st := new(runtime.MemStats)
+	memstats := new(runtime.MemStats)
+	runtime.ReadMemStats(st)
 	for i := 0; i < N; i++ {
 		c := make(chan int, 10)
 		_ = c
@@ -33,8 +35,8 @@ func main() {
 		}
 	}
 
-	runtime.UpdateMemStats()
-	obj := runtime.MemStats.HeapObjects - st.HeapObjects
+	runtime.ReadMemStats(memstats)
+	obj := memstats.HeapObjects - st.HeapObjects
 	if obj > N/5 {
 		fmt.Println("too many objects left:", obj)
 		os.Exit(1)
diff --git a/test/golden.out b/test/golden.out
index 1618ef68e..376af8e53 100644
--- a/test/golden.out
+++ b/test/golden.out
@@ -1,168 +1,24 @@
 
 == ./
 
-=========== ./cmp2.go
-panic: runtime error: comparing uncomparable type []int
-
-
-=========== ./cmp3.go
-panic: runtime error: comparing uncomparable type []int
-
-
-=========== ./cmp4.go
-panic: runtime error: hash of unhashable type []int
-
-
-=========== ./cmp5.go
-panic: runtime error: hash of unhashable type []int
-
-
-=========== ./deferprint.go
-printing: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
-42 true false true +1.500000e+000 world 0x0 [0/0]0x0 0x0 0x0 255
-
-=========== ./goprint.go
-42 true false true +1.500000e+000 world 0x0 [0/0]0x0 0x0 0x0 255
-
-=========== ./helloworld.go
-hello, world
-
-=========== ./peano.go
-0! = 1
-1! = 1
-2! = 2
-3! = 6
-4! = 24
-5! = 120
-6! = 720
-7! = 5040
-8! = 40320
-9! = 362880
-
-=========== ./printbig.go
--9223372036854775808
-9223372036854775807
-
-=========== ./sigchld.go
-survived SIGCHLD
-
-=========== ./sinit.go
-FAIL
-
-=========== ./turing.go
-Hello World!
-
 == ken/
 
-=========== ken/cplx0.go
-(+5.000000e+000+6.000000e+000i)
-(+5.000000e+000+6.000000e+000i)
-(+5.000000e+000+6.000000e+000i)
-(+5.000000e+000+6.000000e+000i)
-
-=========== ken/cplx3.go
-(+1.292308e+000-1.384615e-001i)
-(+1.292308e+000-1.384615e-001i)
-
-=========== ken/cplx4.go
-c = (-5.000000-6.000000i)
-c = (5.000000+6.000000i)
-c = (5.000000+6.000000i)
-c = (5.000000+6.000000i)
-c = (5+6i)
-c = (13+7i)
-
-=========== ken/cplx5.go
-(+5.000000e+000-5.000000e+000i)
-(+5.000000e+000-5.000000e+000i)
-(+5.000000e+000-5.000000e+000i)
-(+5.000000e+000-5.000000e+000i)
-(+5.000000e+000-5.000000e+000i)
-(+5.000000e+000-5.000000e+000i)
-(+5.000000e+000-5.000000e+000i)
-
-=========== ken/intervar.go
- print 1 bio 2 file 3 -- abc
-
-=========== ken/label.go
-100
-
-=========== ken/rob1.go
-9876543210
-
-=========== ken/rob2.go
-(defn foo (add 12 34))
-
-=========== ken/simpprint.go
-hello world
-
-=========== ken/simpswitch.go
-0out01out12out2aout34out4fiveout56out6aout78out89out9
-
-=========== ken/string.go
-abcxyz-abcxyz-abcxyz-abcxyz-abcxyz-abcxyz-abcxyz
-
 == chan/
 
-=========== chan/doubleselect.go
-PASS
-
-=========== chan/nonblock.go
-PASS
-
 == interface/
 
-=========== interface/fail.go
-panic: interface conversion: *main.S is not main.I: missing method Foo
-
-
-=========== interface/returntype.go
-panic: interface conversion: *main.S is not main.I2: missing method Name
-
-
-== nilptr/
-
 == syntax/
 
 == dwarf/
 
-== fixedbugs/
-
-=========== fixedbugs/bug027.go
-hi
-0 44444
-1 3333
-2 222
-3 11
-4 0
-0 44444
-1 3333
-2 222
-3 11
-4 0
-
-=========== fixedbugs/bug067.go
-ok
-
-=========== fixedbugs/bug070.go
-outer loop top k 0
-inner loop top i 0
-do break
-broke
-
-=========== fixedbugs/bug093.go
-M
-
-=========== fixedbugs/bug113.go
-panic: interface conversion: interface is int, not int32
-
-
-=========== fixedbugs/bug148.go
-2 3
-panic: interface conversion: interface is main.T, not main.T
+== safe/
 
+== fixedbugs/
 
-=========== fixedbugs/bug328.go
-0x0
+=========== fixedbugs/bug429.go
+throw: all goroutines are asleep - deadlock!
 
 == bugs/
+
+=========== bugs/bug395.go
+bug395 is broken
diff --git a/test/goprint.go b/test/goprint.go
index c0e34c750..2f0d3c390 100644
--- a/test/goprint.go
+++ b/test/goprint.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// cmpout
 
 // Copyright 2011 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.
 
+// Test that println can be the target of a go statement.
+
 package main
 
 import "time"
diff --git a/test/goprint.out b/test/goprint.out
new file mode 100644
index 000000000..da3919ed6
--- /dev/null
+++ b/test/goprint.out
@@ -0,0 +1 @@
+42 true false true +1.500000e+000 world 0x0 [0/0]0x0 0x0 0x0 255
diff --git a/test/goto.go b/test/goto.go
index 0a50938dc..ca477b3d0 100644
--- a/test/goto.go
+++ b/test/goto.go
@@ -1,9 +1,12 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2011 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.
 
+// Verify goto semantics.
+// Does not compile.
+//
 // Each test is in a separate function just so that if the
 // compiler stops processing after one error, we don't
 // lose other ones.
@@ -36,8 +39,8 @@ L:
 
 // goto across declaration not okay
 func _() {
-	goto L // ERROR "goto L jumps over declaration of x at LINE+1"
-	x := 1
+	goto L // ERROR "goto L jumps over declaration of x at LINE+1|goto jumps over declaration"
+	x := 1	// GCCGO_ERROR "defined here"
 	_ = x
 L:
 }
@@ -54,12 +57,12 @@ L:
 
 // goto across declaration after inner scope not okay
 func _() {
-	goto L // ERROR "goto L jumps over declaration of x at LINE+5"
+	goto L // ERROR "goto L jumps over declaration of x at LINE+5|goto jumps over declaration"
 	{
 		x := 1
 		_ = x
 	}
-	x := 1
+	x := 1	// GCCGO_ERROR "defined here"
 	_ = x
 L:
 }
@@ -74,8 +77,8 @@ L:
 
 // error shows first offending variable
 func _() {
-	goto L // ERROR "goto L jumps over declaration of x at LINE+1"
-	x := 1
+	goto L // ERROR "goto L jumps over declaration of x at LINE+1|goto jumps over declaration"
+	x := 1	// GCCGO_ERROR "defined here"
 	_ = x
 	y := 1
 	_ = y
@@ -84,8 +87,8 @@ L:
 
 // goto not okay even if code path is dead
 func _() {
-	goto L // ERROR "goto L jumps over declaration of x at LINE+1"
-	x := 1
+	goto L // ERROR "goto L jumps over declaration of x at LINE+1|goto jumps over declaration"
+	x := 1	// GCCGO_ERROR "defined here"
 	_ = x
 	y := 1
 	_ = y
@@ -111,26 +114,26 @@ L:
 
 // goto into inner block not okay
 func _() {
-	goto L // ERROR "goto L jumps into block starting at LINE+1"
-	{
+	goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
+	{	// GCCGO_ERROR "block starts here"
 	L:
 	}
 }
 
 // goto backward into inner block still not okay
 func _() {
-	{
+	{	// GCCGO_ERROR "block starts here"
 	L:
 	}
-	goto L // ERROR "goto L jumps into block starting at LINE-3"
+	goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
 }
 
 // error shows first (outermost) offending block
 func _() {
-	goto L // ERROR "goto L jumps into block starting at LINE+1"
+	goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
 	{
 		{
-			{
+			{	// GCCGO_ERROR "block starts here"
 			L:
 			}
 		}
@@ -139,10 +142,10 @@ func _() {
 
 // error prefers block diagnostic over declaration diagnostic
 func _() {
-	goto L // ERROR "goto L jumps into block starting at LINE+3"
+	goto L // ERROR "goto L jumps into block starting at LINE+3|goto jumps into block"
 	x := 1
 	_ = x
-	{
+	{	// GCCGO_ERROR "block starts here"
 	L:
 	}
 }
@@ -176,56 +179,56 @@ L:
 }
 
 func _() {
-	goto L // ERROR "goto L jumps into block starting at LINE+1"
-	if true {
+	goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
+	if true {	// GCCGO_ERROR "block starts here"
 	L:
 	}
 }
 
 func _() {
-	goto L // ERROR "goto L jumps into block starting at LINE+1"
-	if true {
+	goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
+	if true {	// GCCGO_ERROR "block starts here"
 	L:
 	} else {
 	}
 }
 
 func _() {
-	goto L // ERROR "goto L jumps into block starting at LINE+1"
+	goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
 	if true {
-	} else {
+	} else {	// GCCGO_ERROR "block starts here"
 	L:
 	}
 }
 
 func _() {
-	if false {
+	if false {	// GCCGO_ERROR "block starts here"
 	L:
 	} else {
-		goto L // ERROR "goto L jumps into block starting at LINE-3"
+		goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
 	}
 }
 
 func _() {
 	if true {
-		goto L // ERROR "goto L jumps into block starting at LINE+1"
-	} else {
+		goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
+	} else {	// GCCGO_ERROR "block starts here"
 	L:
 	}
 }
 
 func _() {
 	if true {
-		goto L // ERROR "goto L jumps into block starting at LINE+1"
-	} else if false {
+		goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
+	} else if false {	// GCCGO_ERROR "block starts here"
 	L:
 	}
 }
 
 func _() {
 	if true {
-		goto L // ERROR "goto L jumps into block starting at LINE+1"
-	} else if false {
+		goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
+	} else if false {	// GCCGO_ERROR "block starts here"
 	L:
 	} else {
 	}
@@ -238,9 +241,9 @@ func _() {
 	// really is LINE+1 (like in the previous test),
 	// even though it looks like it might be LINE+3 instead.
 	if true {
-		goto L // ERROR "goto L jumps into block starting at LINE+1"
+		goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
 	} else if false {
-	} else {
+	} else {	// GCCGO_ERROR "block starts here"
 	L:
 	}
 }
@@ -259,10 +262,10 @@ func _() {
 
 func _() {
 	// Still not okay.
-	if true {
+	if true {	//// GCCGO_ERROR "block starts here"
 	L:
 	} else
-		goto L //// ERROR "goto L jumps into block starting at LINE-3"
+		goto L //// ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
 }
 
 */
@@ -284,61 +287,61 @@ func _() {
 }
 
 func _() {
-	for {
+	for {	// GCCGO_ERROR "block starts here"
 	L:
 	}
-	goto L // ERROR "goto L jumps into block starting at LINE-3"
+	goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
 }
 
 func _() {
-	for {
+	for {	// GCCGO_ERROR "block starts here"
 		goto L
 	L1:
 	}
 L:
-	goto L1 // ERROR "goto L1 jumps into block starting at LINE-5"
+	goto L1 // ERROR "goto L1 jumps into block starting at LINE-5|goto jumps into block"
 }
 
 func _() {
-	for i < n {
+	for i < n {	// GCCGO_ERROR "block starts here"
 	L:
 	}
-	goto L // ERROR "goto L jumps into block starting at LINE-3"
+	goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
 }
 
 func _() {
-	for i = 0; i < n; i++ {
+	for i = 0; i < n; i++ {	// GCCGO_ERROR "block starts here"
 	L:
 	}
-	goto L // ERROR "goto L jumps into block starting at LINE-3"
+	goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
 }
 
 func _() {
-	for i = range x {
+	for i = range x {	// GCCGO_ERROR "block starts here"
 	L:
 	}
-	goto L // ERROR "goto L jumps into block starting at LINE-3"
+	goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
 }
 
 func _() {
-	for i = range c {
+	for i = range c {	// GCCGO_ERROR "block starts here"
 	L:
 	}
-	goto L // ERROR "goto L jumps into block starting at LINE-3"
+	goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
 }
 
 func _() {
-	for i = range m {
+	for i = range m {	// GCCGO_ERROR "block starts here"
 	L:
 	}
-	goto L // ERROR "goto L jumps into block starting at LINE-3"
+	goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
 }
 
 func _() {
-	for i = range s {
+	for i = range s {	// GCCGO_ERROR "block starts here"
 	L:
 	}
-	goto L // ERROR "goto L jumps into block starting at LINE-3"
+	goto L // ERROR "goto L jumps into block starting at LINE-3|goto jumps into block"
 }
 
 // switch
@@ -392,48 +395,48 @@ func _() {
 }
 
 func _() {
-	goto L // ERROR "goto L jumps into block starting at LINE+1"
+	goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
 	switch i {
 	case 0:
-	L:
+	L:	// GCCGO_ERROR "block starts here"
 	}
 }
 
 func _() {
-	goto L // ERROR "goto L jumps into block starting at LINE+1"
+	goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
 	switch i {
 	case 0:
-	L:
+	L:	// GCCGO_ERROR "block starts here"
 		;
 	default:
 	}
 }
 
 func _() {
-	goto L // ERROR "goto L jumps into block starting at LINE+1"
+	goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
 	switch i {
 	case 0:
 	default:
-	L:
+	L:	// GCCGO_ERROR "block starts here"
 	}
 }
 
 func _() {
 	switch i {
 	default:
-		goto L // ERROR "goto L jumps into block starting at LINE+1"
+		goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
 	case 0:
-	L:
+	L:	// GCCGO_ERROR "block starts here"
 	}
 }
 
 func _() {
 	switch i {
 	case 0:
-	L:
+	L:	// GCCGO_ERROR "block starts here"
 		;
 	default:
-		goto L // ERROR "goto L jumps into block starting at LINE-4"
+		goto L // ERROR "goto L jumps into block starting at LINE-4|goto jumps into block"
 	}
 }
 
@@ -489,47 +492,47 @@ func _() {
 }
 
 func _() {
-	goto L // ERROR "goto L jumps into block starting at LINE+2"
+	goto L // ERROR "goto L jumps into block starting at LINE+2|goto jumps into block"
 	select {
 	case c <- 1:
-	L:
+	L:	// GCCGO_ERROR "block starts here"
 	}
 }
 
 func _() {
-	goto L // ERROR "goto L jumps into block starting at LINE+2"
+	goto L // ERROR "goto L jumps into block starting at LINE+2|goto jumps into block"
 	select {
 	case c <- 1:
-	L:
+	L:	// GCCGO_ERROR "block starts here"
 		;
 	default:
 	}
 }
 
 func _() {
-	goto L // ERROR "goto L jumps into block starting at LINE+3"
+	goto L // ERROR "goto L jumps into block starting at LINE+3|goto jumps into block"
 	select {
 	case <-c:
 	default:
-	L:
+	L:	// GCCGO_ERROR "block starts here"
 	}
 }
 
 func _() {
 	select {
 	default:
-		goto L // ERROR "goto L jumps into block starting at LINE+1"
+		goto L // ERROR "goto L jumps into block starting at LINE+1|goto jumps into block"
 	case <-c:
-	L:
+	L:	// GCCGO_ERROR "block starts here"
 	}
 }
 
 func _() {
 	select {
 	case <-c:
-	L:
+	L:	// GCCGO_ERROR "block starts here"
 		;
 	default:
-		goto L // ERROR "goto L jumps into block starting at LINE-4"
+		goto L // ERROR "goto L jumps into block starting at LINE-4|goto jumps into block"
 	}
 }
diff --git a/test/hashmap.go b/test/hashmap.go
deleted file mode 100755
index 0a4d7ab61..000000000
--- a/test/hashmap.go
+++ /dev/null
@@ -1,181 +0,0 @@
-// $G $F.go && $L $F.$A && ./$A.out
-
-// Copyright 2009 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.
-
-package main
-
-// ----------------------------------------------------------------------------
-// Helper functions
-
-func ASSERT(p bool) {
-	if !p {
-		// panic 0
-	}
-}
-
-
-// ----------------------------------------------------------------------------
-// Implementation of the HashMap
-
-type KeyType interface {
-	Hash() uint32
-	Match(other KeyType) bool
-}
-
-
-type ValueType interface {
-	// empty interface
-}
-
-
-type Entry struct {
-	key KeyType
-	value ValueType
-}
-
-
-type Array [1024]Entry
-
-type HashMap struct {
-	map_ *Array
-	log2_capacity_ uint32
-	occupancy_ uint32
-}
-
-
-func (m *HashMap) capacity() uint32 {
-	return 1 << m.log2_capacity_
-}
-
-
-func (m *HashMap) Clear() {
-	// Mark all entries as empty.
-	var i uint32 = m.capacity() - 1
-	for i > 0 {
-		m.map_[i].key = nil
-		i = i - 1
-	}
-	m.occupancy_ = 0
-}
-
-
-func (m *HashMap) Initialize (initial_log2_capacity uint32) {
-	m.log2_capacity_ = initial_log2_capacity
-	m.map_ = new(Array)
-	m.Clear()
-}
-
-
-func (m *HashMap) Probe (key KeyType) *Entry {
-	ASSERT(key != nil)
-
-	var i uint32 = key.Hash() % m.capacity()
-	ASSERT(0 <= i && i < m.capacity())
-
-	ASSERT(m.occupancy_ < m.capacity())	// guarantees loop termination
-	for m.map_[i].key != nil && !m.map_[i].key.Match(key) {
-		i++
-		if i >= m.capacity() {
-			i = 0
-		}
-	}
-
-	return &m.map_[i]
-}
-
-
-func (m *HashMap) Lookup (key KeyType, insert bool) *Entry {
-	// Find a matching entry.
-	var p *Entry = m.Probe(key)
-		if p.key != nil {
-		return p
-	}
-
-	// No entry found; insert one if necessary.
-	if insert {
-		p.key = key
-		p.value = nil
-		m.occupancy_++
-
-		// Grow the map if we reached >= 80% occupancy.
-		if m.occupancy_ + m.occupancy_/4 >= m.capacity() {
-			m.Resize()
-			p = m.Probe(key)
-		}
-
-		return p
-	}
-
-	// No entry found and none inserted.
-	return nil
-}
-
-
-func (m *HashMap) Resize() {
-	var hmap *Array = m.map_
-	var n uint32 = m.occupancy_
-
-	// Allocate a new map of twice the current size.
-	m.Initialize(m.log2_capacity_ << 1)
-
-	// Rehash all current entries.
-	var i uint32 = 0
-	for n > 0 {
-		if hmap[i].key != nil {
-			m.Lookup(hmap[i].key, true).value = hmap[i].value
-			n = n - 1
-		}
-		i++
-	}
-}
-
-
-// ----------------------------------------------------------------------------
-// Test code
-
-type Number struct {
-	x uint32
-}
-
-
-func (n *Number) Hash() uint32 {
-	return n.x * 23
-}
-
-
-func (n *Number) Match(other KeyType) bool {
-	// var y *Number = other
-	// return n.x == y.x
-	return false
-}
-
-
-func MakeNumber (x uint32) *Number {
-	var n *Number = new(Number)
-	n.x = x
-	return n
-}
-
-
-func main() {
-	// func (n int) int { return n + 1; }(1)
-
-	//print "HashMap - gri 2/8/2008\n"
-
-	var hmap *HashMap = new(HashMap)
-	hmap.Initialize(0)
-
-	var x1 *Number = MakeNumber(1001)
-	var x2 *Number = MakeNumber(2002)
-	var x3 *Number = MakeNumber(3003)
-	_, _, _ = x1, x2, x3
-
-	// this doesn't work I think...
-	//hmap.Lookup(x1, true)
-	//hmap.Lookup(x2, true)
-	//hmap.Lookup(x3, true)
-
-	//print "done\n"
-}
diff --git a/test/helloworld.go b/test/helloworld.go
index e55a74bbd..5025ec9bb 100644
--- a/test/helloworld.go
+++ b/test/helloworld.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// cmpout
 
 // Copyright 2009 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.
 
+// Test that we can do page 1 of the C book.
+
 package main
 
 func main() {
diff --git a/test/helloworld.out b/test/helloworld.out
new file mode 100644
index 000000000..4b5fa6370
--- /dev/null
+++ b/test/helloworld.out
@@ -0,0 +1 @@
+hello, world
diff --git a/test/if.go b/test/if.go
index 18a6715d7..25cc14164 100644
--- a/test/if.go
+++ b/test/if.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test if statements in various forms.
+
 package main
 
 func assertequal(is, shouldbe int, msg string) {
diff --git a/test/import.go b/test/import.go
index 96330340d..d135cd284 100644
--- a/test/import.go
+++ b/test/import.go
@@ -1,11 +1,11 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2009 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.
 
-// check that when import gives multiple names
-// to a type, they're still all the same type
+// Test that when import gives multiple names
+// to a single type, they still all refer to the same type.
 
 package main
 
@@ -13,13 +13,12 @@ import _os_ "os"
 import "os"
 import . "os"
 
-func f(e os.Error)
+func f(e *os.File)
 
 func main() {
-	var _e_ _os_.Error
-	var dot Error
+	var _e_ *_os_.File
+	var dot *File
 
 	f(_e_)
 	f(dot)
 }
-
diff --git a/test/import1.go b/test/import1.go
index ebd704ef9..56b29d58c 100644
--- a/test/import1.go
+++ b/test/import1.go
@@ -1,10 +1,11 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
-// check for import conflicts
+// Verify that import conflicts are detected by the compiler.
+// Does not compile.
 
 package main
 
diff --git a/test/import2.go b/test/import2.go
index 0efc285fa..5c275f34b 100644
--- a/test/import2.go
+++ b/test/import2.go
@@ -1,9 +1,12 @@
-// true  # used by import3
+// skip # used by import3
 
 // 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.
 
+// Various declarations of exported variables and functions.
+// Imported by import3.go.
+
 package p
 
 var C1 chan <- chan int = (chan<- (chan int))(nil)
diff --git a/test/import3.go b/test/import3.go
index e4900b93d..274fcfe42 100644
--- a/test/import3.go
+++ b/test/import3.go
@@ -4,7 +4,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Check that all the types from import2.go made it
+// Test that all the types from import2.go made it
 // intact and with the same meaning, by assigning to or using them.
 
 package main
diff --git a/test/import4.go b/test/import4.go
index 1ae1d0e4a..cbfebf7e1 100644
--- a/test/import4.go
+++ b/test/import4.go
@@ -4,9 +4,11 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package main
+// Verify that various kinds of "imported and not used"
+// errors are caught by the compiler.
+// Does not compile.
 
-// various kinds of imported and not used
+package main
 
 // standard
 import "fmt"	// ERROR "imported and not used.*fmt"
diff --git a/test/import5.go b/test/import5.go
new file mode 100644
index 000000000..6480acff9
--- /dev/null
+++ b/test/import5.go
@@ -0,0 +1,55 @@
+// errorcheck
+
+// Copyright 2009 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.
+
+// Verify that invalid imports are rejected by the compiler.
+// Does not compile.
+
+package main
+
+// Correct import paths.
+import _ "fmt"
+import _ `time`
+import _ "m\x61th"
+import _ "go/parser"
+
+// Correct import paths, but the packages don't exist.
+// Don't test.
+//import "a.b"
+//import "greek/αβ"
+
+// Import paths must be strings.
+import 42    // ERROR "import statement"
+import 'a'   // ERROR "import statement"
+import 3.14  // ERROR "import statement"
+import 0.25i // ERROR "import statement"
+
+// Each of these pairs tests both `` vs "" strings
+// and also use of invalid characters spelled out as
+// escape sequences and written directly.
+// For example `"\x00"` tests import "\x00"
+// while "`\x00`" tests import `<actual-NUL-byte>`.
+import ""         // ERROR "import path"
+import ``         // ERROR "import path"
+import "\x00"     // ERROR "import path"
+import `\x00`     // ERROR "import path"
+import "\x7f"     // ERROR "import path"
+import `\x7f`     // ERROR "import path"
+import "a!"       // ERROR "import path"
+import `a!`       // ERROR "import path"
+import "a b"      // ERROR "import path"
+import `a b`      // ERROR "import path"
+import "a\\b"     // ERROR "import path"
+import `a\\b`     // ERROR "import path"
+import "\"`a`\""  // ERROR "import path"
+import `\"a\"`    // ERROR "import path"
+import "\x80\x80" // ERROR "import path"
+import `\x80\x80` // ERROR "import path"
+import "\xFFFD"   // ERROR "import path"
+import `\xFFFD`   // ERROR "import path"
+
+// Invalid local imports.
+import "/foo"  // ERROR "import path cannot be absolute path"
+import "c:/foo"  // ERROR "import path contains invalid character"
diff --git a/test/index.go b/test/index.go
index 38aa33dd3..eb0c45495 100644
--- a/test/index.go
+++ b/test/index.go
@@ -9,6 +9,7 @@
 // license that can be found in the LICENSE file.
 
 // Generate test of index and slice bounds checks.
+// The output is compiled and run.
 
 package main
 
diff --git a/test/indirect.go b/test/indirect.go
index cfddde9ce..bb20f3009 100644
--- a/test/indirect.go
+++ b/test/indirect.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG indirect
+// run
 
 // Copyright 2009 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.
 
+// Test various safe uses of indirection.
+
 package main
 
 var m0 map[string]int
diff --git a/test/indirect1.go b/test/indirect1.go
index 0fd5c19d4..51da4cc7c 100644
--- a/test/indirect1.go
+++ b/test/indirect1.go
@@ -1,9 +1,12 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Verify that illegal uses of indirection are caught by the compiler.
+// Does not compile.
+
 package main
 
 var m0 map[string]int
@@ -65,4 +68,5 @@ func f() {
 		cap(b2)+	// ERROR "illegal|invalid|must be"
 		cap(b3)+
 		cap(b4)	// ERROR "illegal|invalid|must be"
+	_ = x
 }
diff --git a/test/init.go b/test/init.go
index 74c2d5c26..f4689443c 100644
--- a/test/init.go
+++ b/test/init.go
@@ -1,9 +1,12 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2011 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.
 
+// Verify that erroneous use of init is detected.
+// Does not compile.
+
 package main
 
 import "runtime"
diff --git a/test/init1.go b/test/init1.go
new file mode 100644
index 000000000..a888ad744
--- /dev/null
+++ b/test/init1.go
@@ -0,0 +1,44 @@
+// run
+
+// Copyright 2011 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.
+
+// Test that goroutines and garbage collection run during init.
+
+package main
+
+import "runtime"
+
+var x []byte
+
+func init() {
+	c := make(chan int)
+	go send(c)
+	<-c
+
+	const chunk = 1 << 20
+	memstats := new(runtime.MemStats)
+	runtime.ReadMemStats(memstats)
+	sys := memstats.Sys
+	b := make([]byte, chunk)
+	for i := range b {
+		b[i] = byte(i%10 + '0')
+	}
+	s := string(b)
+	for i := 0; i < 1000; i++ {
+		x = []byte(s)
+	}
+	runtime.ReadMemStats(memstats)
+	sys1 := memstats.Sys
+	if sys1-sys > chunk*50 {
+		println("allocated 1000 chunks of", chunk, "and used ", sys1-sys, "memory")
+	}
+}
+
+func send(c chan int) {
+	c <- 1
+}
+
+func main() {
+}
diff --git a/test/initcomma.go b/test/initcomma.go
index 195d4575f..a54fce428 100644
--- a/test/initcomma.go
+++ b/test/initcomma.go
@@ -1,15 +1,17 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test trailing commas. DO NOT gofmt THIS FILE.
+
 package main
 
-var a = []int{1, 2}
-var b = [5]int{1, 2, 3}
-var c = []int{1}
-var d = [...]int{1, 2, 3}
+var a = []int{1, 2, }
+var b = [5]int{1, 2, 3, }
+var c = []int{1, }
+var d = [...]int{1, 2, 3, }
 
 func main() {
 	if len(a) != 2 {
diff --git a/test/initialize.go b/test/initialize.go
index 6dd7d67dc..1307e0209 100644
--- a/test/initialize.go
+++ b/test/initialize.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test initialization of package-level variables.
+
 package main
 
 import "fmt"
diff --git a/test/initializerr.go b/test/initializerr.go
index e7f8b0e92..48908c347 100644
--- a/test/initializerr.go
+++ b/test/initializerr.go
@@ -1,9 +1,12 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Verify that erroneous initialization expressions are caught by the compiler
+// Does not compile.
+
 package main
 
 type S struct {
diff --git a/test/initsyscall.go b/test/initsyscall.go
deleted file mode 100644
index b5e5812b6..000000000
--- a/test/initsyscall.go
+++ /dev/null
@@ -1,27 +0,0 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
-
-// Copyright 2009 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.
-
-// This used to crash because the scheduler
-// tried to kick off a new scheduling thread for f
-// when time.Nanoseconds went into the system call.
-// It's not okay to schedule new goroutines
-// until main has started.
-
-package main
-
-import "time"
-
-func f() {
-}
-
-func init() {
-	go f()
-	time.Nanoseconds()
-}
-
-func main() {
-}
-
diff --git a/test/int_lit.go b/test/int_lit.go
index 2644e17b5..78deaea13 100644
--- a/test/int_lit.go
+++ b/test/int_lit.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test integer literal syntax.
+
 package main
 
 import "os"
diff --git a/test/intcvt.go b/test/intcvt.go
index 407bcfd9b..3920528a4 100644
--- a/test/intcvt.go
+++ b/test/intcvt.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test implicit and explicit conversions of constants.
+
 package main
 
 const (
diff --git a/test/interface/bigdata.go b/test/interface/bigdata.go
index 44f6ab127..0f2e9a990 100644
--- a/test/interface/bigdata.go
+++ b/test/interface/bigdata.go
@@ -1,11 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
-// check that big vs small, pointer vs not
-// interface methods work.
+// Test big vs. small, pointer vs. value interface methods.
 
 package main
 
diff --git a/test/interface/convert.go b/test/interface/convert.go
index 7f429f703..eb6fd1d55 100644
--- a/test/interface/convert.go
+++ b/test/interface/convert.go
@@ -1,11 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
-// Check uses of all the different interface
-// conversion runtime functions.
+// Test all the different interface conversion runtime functions.
 
 package main
 
diff --git a/test/interface/convert1.go b/test/interface/convert1.go
index 658b1a92f..4a3ec8a37 100644
--- a/test/interface/convert1.go
+++ b/test/interface/convert1.go
@@ -1,11 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
-// Check that static interface conversion of
-// interface value nil succeeds.
+// Test static interface conversion of interface value nil.
 
 package main
 
diff --git a/test/interface/convert2.go b/test/interface/convert2.go
index 658b1a92f..4a3ec8a37 100644
--- a/test/interface/convert2.go
+++ b/test/interface/convert2.go
@@ -1,11 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
-// Check that static interface conversion of
-// interface value nil succeeds.
+// Test static interface conversion of interface value nil.
 
 package main
 
diff --git a/test/interface/embed.go b/test/interface/embed.go
index 2fddee190..5c52ac023 100644
--- a/test/interface/embed.go
+++ b/test/interface/embed.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
-// Check methods derived from embedded interface values.
+// Test methods derived from embedded interface values.
 
 package main
 
diff --git a/test/interface/embed0.go b/test/interface/embed0.go
index bbd81e760..e2ee20ade 100644
--- a/test/interface/embed0.go
+++ b/test/interface/embed0.go
@@ -1,10 +1,10 @@
-// true	# used by embed1.go
+// skip # used by embed1.go
 
 // Copyright 2009 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.
 
-// Check that embedded interface types can have local methods.
+// Test that embedded interface types can have local methods.
 
 package p
 
diff --git a/test/interface/embed1.go b/test/interface/embed1.go
index 24e50471f..ee502a162 100644
--- a/test/interface/embed1.go
+++ b/test/interface/embed1.go
@@ -4,7 +4,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// Check that embedded interface types can have local methods.
+// Test that embedded interface types can have local methods.
 
 package main
 
diff --git a/test/interface/embed2.go b/test/interface/embed2.go
index c18a1fece..1636db78e 100644
--- a/test/interface/embed2.go
+++ b/test/interface/embed2.go
@@ -1,10 +1,10 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
-// Check methods derived from embedded interface and *interface values.
+// Test methods derived from embedded interface and *interface values.
 
 package main
 
diff --git a/test/interface/explicit.go b/test/interface/explicit.go
index daae59b36..d19480a68 100644
--- a/test/interface/explicit.go
+++ b/test/interface/explicit.go
@@ -1,10 +1,11 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
-// Static error messages about interface conversions.
+// Verify compiler messages about erroneous static interface conversions.
+// Does not compile.
 
 package main
 
diff --git a/test/interface/fail.go b/test/interface/fail.go
index 3e741d3f9..72b854dc0 100644
--- a/test/interface/fail.go
+++ b/test/interface/fail.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ! ./$A.out
+// run
 
 // Copyright 2009 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.
 
-// Check that interface conversion fails when method is missing.
+// Test that interface conversion fails when method is missing.
 
 package main
 
@@ -13,6 +13,10 @@ type I interface {
 }
 
 func main() {
+	shouldPanic(p1)
+}
+
+func p1() {
 	var s *S
 	var i I
 	var e interface {}
@@ -21,6 +25,14 @@ func main() {
 	_ = i
 }
 
-// hide S down here to avoid static warning
 type S struct {
 }
+
+func shouldPanic(f func()) {
+	defer func() {
+		if recover() == nil {
+			panic("function should panic")
+		}
+	}()
+	f()
+}
diff --git a/test/interface/fake.go b/test/interface/fake.go
index ddb832542..861a64084 100644
--- a/test/interface/fake.go
+++ b/test/interface/fake.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
-// Interface comparisons using types hidden
+// Test interface comparisons using types hidden
 // inside reflected-on structs.
 
 package main
diff --git a/test/interface/noeq.go b/test/interface/noeq.go
new file mode 100644
index 000000000..1c5166ede
--- /dev/null
+++ b/test/interface/noeq.go
@@ -0,0 +1,40 @@
+// run
+
+// Copyright 2011 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.
+
+// Test run-time error detection for interface values containing types
+// that cannot be compared for equality.
+
+package main
+
+func main() {
+	cmp(1)
+
+	var (
+		m map[int]int
+		s struct{ x []int }
+		f func()
+	)
+	noCmp(m)
+	noCmp(s)
+	noCmp(f)
+}
+
+func cmp(x interface{}) bool {
+	return x == x
+}
+
+func noCmp(x interface{}) {
+	shouldPanic(func() { cmp(x) })
+}
+
+func shouldPanic(f func()) {
+	defer func() {
+		if recover() == nil {
+			panic("function should panic")
+		}
+	}()
+	f()
+}
diff --git a/test/interface/pointer.go b/test/interface/pointer.go
index fe4d8e3ef..292705066 100644
--- a/test/interface/pointer.go
+++ b/test/interface/pointer.go
@@ -1,10 +1,11 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
-// Check that interface{M()} = *interface{M()} produces a compiler error.
+// Test that interface{M()} = *interface{M()} produces a compiler error.
+// Does not compile.
 
 package main
 
@@ -33,5 +34,5 @@ func main() {
 	print("call addinst\n")
 	var x Inst = AddInst(new(Start)) // ERROR "pointer to interface"
 	print("return from  addinst\n")
-	var y *Inst = new(Start)  // ERROR "pointer to interface"
+	var y *Inst = new(Start)  // ERROR "pointer to interface|incompatible type"
 }
diff --git a/test/interface/private.go b/test/interface/private.go
index 37890c923..14dfc1ae5 100644
--- a/test/interface/private.go
+++ b/test/interface/private.go
@@ -4,6 +4,9 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// Test that unexported methods are not visible outside the package.
+// Does not compile.
+
 package main
 
 import "./private1"
diff --git a/test/interface/private1.go b/test/interface/private1.go
index 3173fbef4..3281c38be 100644
--- a/test/interface/private1.go
+++ b/test/interface/private1.go
@@ -1,9 +1,11 @@
-// true  # used by private.go
+// skip # used by private.go
 
 // Copyright 2011 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.
 
+// Imported by private.go, which should not be able to see the private method.
+
 package p
 
 type Exported interface {
diff --git a/test/interface/receiver.go b/test/interface/receiver.go
index f53daf8da..4511ab3b4 100644
--- a/test/interface/receiver.go
+++ b/test/interface/receiver.go
@@ -1,11 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
-// Implicit methods for embedded types.
-// Mixed pointer and non-pointer receivers.
+// Test Implicit methods for embedded types and
+// mixed pointer and non-pointer receivers.
 
 package main
 
diff --git a/test/interface/receiver1.go b/test/interface/receiver1.go
index 51312d000..2b7ccdc1a 100644
--- a/test/interface/receiver1.go
+++ b/test/interface/receiver1.go
@@ -1,10 +1,11 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
-// Error messages about missing implicit methods.
+// Verify compiler complains about missing implicit methods.
+// Does not compile.
 
 package main
 
diff --git a/test/interface/recursive.go b/test/interface/recursive.go
index 1eb56e976..fcc88331e 100644
--- a/test/interface/recursive.go
+++ b/test/interface/recursive.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go || echo BUG: should compile
+// compile
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -6,7 +6,7 @@
 
 // Check mutually recursive interfaces
 
-package main
+package recursive
 
 type I1 interface {
 	foo() I2
diff --git a/test/interface/recursive1.go b/test/interface/recursive1.go
new file mode 100644
index 000000000..cc3cdc37f
--- /dev/null
+++ b/test/interface/recursive1.go
@@ -0,0 +1,17 @@
+// skip # used by recursive2
+
+// Copyright 2012 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.
+
+// Mutually recursive type definitions imported and used by recursive1.go.
+
+package p
+
+type I1 interface {
+	F() I2
+}
+
+type I2 interface {
+	I1
+}
diff --git a/test/interface/recursive2.go b/test/interface/recursive2.go
new file mode 100644
index 000000000..5129ceb02
--- /dev/null
+++ b/test/interface/recursive2.go
@@ -0,0 +1,22 @@
+// $G $D/recursive1.go && $G $D/$F.go
+
+// Copyright 2012 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.
+
+// Test that the mutually recursive types in recursive1.go made it
+// intact and with the same meaning, by assigning to or using them.
+
+package main
+
+import "./recursive1"
+
+func main() {
+	var i1 p.I1
+	var i2 p.I2
+	i1 = i2
+	i2 = i1
+	i1 = i2.F()
+	i2 = i1.F()
+	_, _ = i1, i2
+}
diff --git a/test/interface/returntype.go b/test/interface/returntype.go
index c526b3b0e..4d86f3918 100644
--- a/test/interface/returntype.go
+++ b/test/interface/returntype.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go && $L $F.$A && (! ./$A.out || echo BUG: should not succeed)
+// run
 
 // Copyright 2009 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.
 
-// Check methods with different return types.
+// Test interface methods with different return types are distinct.
 
 package main
 
@@ -18,8 +18,21 @@ type I1 interface { Name() int8 }
 type I2 interface { Name() int64 }
 
 func main() {
+	shouldPanic(p1)
+}
+
+func p1() {
 	var i1 I1
 	var s *S
 	i1 = s
 	print(i1.(I2).Name())
 }
+
+func shouldPanic(f func()) {
+	defer func() {
+		if recover() == nil {
+			panic("function should panic")
+		}
+	}()
+	f()
+}
diff --git a/test/interface/struct.go b/test/interface/struct.go
index 40b7f4f91..f60819ca8 100644
--- a/test/interface/struct.go
+++ b/test/interface/struct.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG interface6
+// run
 
 // Copyright 2009 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.
 
-// Interface values containing structures.
+// Test interface values containing structures.
 
 package main
 
diff --git a/test/iota.go b/test/iota.go
index c40ca1f38..7187dbe33 100644
--- a/test/iota.go
+++ b/test/iota.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test iota.
+
 package main
 
 func assert(cond bool, msg string) {
diff --git a/test/ken/array.go b/test/ken/array.go
index 40209f5da..9412e3502 100644
--- a/test/ken/array.go
+++ b/test/ken/array.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test arrays and slices.
+
 package main
 
 func setpd(a []int) {
@@ -68,6 +70,9 @@ func testpdpd() {
 
 	a = a[5:25]
 	res(sumpd(a), 5, 25)
+
+	a = a[30:95]
+	res(sumpd(a), 35, 100)
 }
 
 // call ptr fixed with ptr fixed
diff --git a/test/ken/chan.go b/test/ken/chan.go
index ef75b044d..36b18f80e 100644
--- a/test/ken/chan.go
+++ b/test/ken/chan.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test communication operations including select.
+
 package main
 
 import "os"
diff --git a/test/ken/chan1.go b/test/ken/chan1.go
index e5fc033f3..cbd21a3d6 100644
--- a/test/ken/chan1.go
+++ b/test/ken/chan1.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test communication with multiple simultaneous goroutines.
+
 package main
 
 import "runtime"
diff --git a/test/ken/complit.go b/test/ken/complit.go
index da0a84a04..bc50bbe22 100644
--- a/test/ken/complit.go
+++ b/test/ken/complit.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test composite literals.
+
 package main
 
 type	M	map[int]int
diff --git a/test/ken/convert.go b/test/ken/convert.go
index 3780ec886..33acbd8cd 100644
--- a/test/ken/convert.go
+++ b/test/ken/convert.go
@@ -1,10 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // 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.
 
-// near-exhaustive test of converting numbers between types.
+// Test, near-exhaustive, of converting numbers between types.
+// No complex numbers though.
 
 package main
 
diff --git a/test/ken/cplx0.go b/test/ken/cplx0.go
index ba1fa196f..665e52a5f 100644
--- a/test/ken/cplx0.go
+++ b/test/ken/cplx0.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// cmpout
 
 // 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.
 
+// Test trivial, bootstrap-level complex numbers, including printing.
+
 package main
 
 const (
diff --git a/test/ken/cplx0.out b/test/ken/cplx0.out
new file mode 100644
index 000000000..7627c28df
--- /dev/null
+++ b/test/ken/cplx0.out
@@ -0,0 +1,4 @@
+(+5.000000e+000+6.000000e+000i)
+(+5.000000e+000+6.000000e+000i)
+(+5.000000e+000+6.000000e+000i)
+(+5.000000e+000+6.000000e+000i)
diff --git a/test/ken/cplx1.go b/test/ken/cplx1.go
index 8ec7d40f5..78240a563 100644
--- a/test/ken/cplx1.go
+++ b/test/ken/cplx1.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // 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.
 
+// Test simple arithmetic and assignment for complex numbers.
+
 package main
 
 const (
diff --git a/test/ken/cplx2.go b/test/ken/cplx2.go
index b36e93ecd..eb1da7b8c 100644
--- a/test/ken/cplx2.go
+++ b/test/ken/cplx2.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // 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.
 
+// Test arithmetic on complex numbers, including multiplication and division.
+
 package main
 
 const (
@@ -105,4 +107,16 @@ func main() {
 		println("opcode x", ce, Ce)
 		panic("fail")
 	}
+	
+	r32 := real(complex64(ce))
+	if r32 != float32(real(Ce)) {
+		println("real(complex64(ce))", r32, real(Ce))
+		panic("fail")
+	}
+	
+	r64 := real(complex128(ce))
+	if r64 != real(Ce) {
+		println("real(complex128(ce))", r64, real(Ce))
+		panic("fail")
+	}
 }
diff --git a/test/ken/cplx3.go b/test/ken/cplx3.go
index fa6ff1d52..be0b8646a 100644
--- a/test/ken/cplx3.go
+++ b/test/ken/cplx3.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // 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.
 
+// Test composition, decomposition, and reflection on complex numbers.
+
 package main
 
 import "unsafe"
@@ -19,10 +21,29 @@ const (
 func main() {
 	c0 := C1
 	c0 = (c0 + c0 + c0) / (c0 + c0 + 3i)
-	println(c0)
+	r, i := real(c0), imag(c0)
+	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))
-	println(c)
+	if c != c0 {
+		println(c, "!=", c)
+		panic(0)
+	}
 
 	var a interface{}
 	switch c := reflect.ValueOf(a); c.Kind() {
diff --git a/test/ken/cplx4.go b/test/ken/cplx4.go
index 8524e47ae..97d5d16f4 100644
--- a/test/ken/cplx4.go
+++ b/test/ken/cplx4.go
@@ -1,9 +1,12 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // 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.
 
+// Test complex numbers,including fmt support.
+// Used to crash.
+
 package main
 
 import "fmt"
@@ -15,30 +18,44 @@ const (
 	C1 = R + I // ADD(5,6)
 )
 
-func doprint(c complex128) { fmt.Printf("c = %f\n", c) }
+func want(s, w string) {
+	if s != w {
+		panic(s + " != " + w)
+	}
+}
+
+func doprint(c complex128, w string) {
+	s := fmt.Sprintf("%f", c)
+	want(s, w)
+}
 
 func main() {
 
 	// constants
-	fmt.Printf("c = %f\n", -C1)
-	doprint(C1)
+	s := fmt.Sprintf("%f", -C1)
+	want(s, "(-5.000000-6.000000i)")
+	doprint(C1, "(5.000000+6.000000i)")
 
 	// variables
 	c1 := C1
-	fmt.Printf("c = %f\n", c1)
-	doprint(c1)
+	s = fmt.Sprintf("%f", c1)
+	want(s, "(5.000000+6.000000i)")
+	doprint(c1, "(5.000000+6.000000i)")
 
 	// 128
 	c2 := complex128(C1)
-	fmt.Printf("c = %G\n", c2)
+	s = fmt.Sprintf("%G", c2)
+	want(s, "(5+6i)")
 
 	// real, imag, complex
 	c3 := complex(real(c2)+3, imag(c2)-5) + c2
-	fmt.Printf("c = %G\n", c3)
+	s = fmt.Sprintf("%G", c3)
+	want(s, "(13+7i)")
 
 	// compiler used to crash on nested divide
 	c4 := complex(real(c3/2), imag(c3/2))
 	if c4 != c3/2 {
 		fmt.Printf("BUG: c3 = %G != c4 = %G\n", c3, c4)
+		panic(0)
 	}
 }
diff --git a/test/ken/cplx5.go b/test/ken/cplx5.go
index d425a7c4c..4e8f4433d 100644
--- a/test/ken/cplx5.go
+++ b/test/ken/cplx5.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // 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.
 
+// Test compound types made of complex numbers.
+
 package main
 
 var a [12]complex128
@@ -19,36 +21,52 @@ func main() {
 	for i := 0; i < len(a); i++ {
 		a[i] = complex(float64(i), float64(-i))
 	}
-	println(a[5])
+	if a[5] != 5-5i {
+		panic(a[5])
+	}
 
 	// slice of complex128
 	s = make([]complex128, len(a))
 	for i := 0; i < len(s); i++ {
 		s[i] = a[i]
 	}
-	println(s[5])
+	if s[5] != 5-5i {
+		panic(s[5])
+	}
 
 	// chan
 	c = make(chan complex128)
 	go chantest(c)
-	println(<-c)
+	vc := <-c
+	if vc != 5-5i {
+		panic(vc)
+	}
 
 	// pointer of complex128
 	v := a[5]
 	pv := &v
-	println(*pv)
+	if *pv != 5-5i {
+		panic(*pv)
+	}
 
 	// field of complex128
 	f.c = a[5]
-	println(f.c)
+	if f.c != 5-5i {
+		panic(f.c)
+	}
 
 	// map of complex128
 	m = make(map[complex128]complex128)
 	for i := 0; i < len(s); i++ {
 		m[-a[i]] = a[i]
 	}
-	println(m[5i-5])
-	println(m[complex(-5, 5)])
+	if m[5i-5] != 5-5i {
+		panic(m[5i-5])
+	}
+	vm := m[complex(-5, 5)]
+	if vm != 5-5i {
+		panic(vm)
+	}
 }
 
 func chantest(c chan complex128) { c <- a[5] }
diff --git a/test/ken/divconst.go b/test/ken/divconst.go
index c3b9092cd..670e07417 100644
--- a/test/ken/divconst.go
+++ b/test/ken/divconst.go
@@ -1,12 +1,14 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test integer division by constants.
+
 package main
 
-import "rand"
+import "math/rand"
 
 const Count = 1e5
 
diff --git a/test/ken/divmod.go b/test/ken/divmod.go
index dc44ea245..f1bd56ec6 100644
--- a/test/ken/divmod.go
+++ b/test/ken/divmod.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test integer division and modulus.
+
 package main
 
 const (
diff --git a/test/ken/embed.go b/test/ken/embed.go
index 9805e479b..9b35c56ac 100644
--- a/test/ken/embed.go
+++ b/test/ken/embed.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test embedded fields of structs, including methods.
+
 package main
 
 
diff --git a/test/ken/for.go b/test/ken/for.go
index 176ecd749..db35548db 100644
--- a/test/ken/for.go
+++ b/test/ken/for.go
@@ -1,9 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test simple for loop.
 
 package main
 
diff --git a/test/ken/interbasic.go b/test/ken/interbasic.go
index 9bb50886a..d8fbb95a3 100644
--- a/test/ken/interbasic.go
+++ b/test/ken/interbasic.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test interfaces on basic types.
+
 package main
 
 type myint int
diff --git a/test/ken/interfun.go b/test/ken/interfun.go
index 94bc7eaad..9432181df 100644
--- a/test/ken/interfun.go
+++ b/test/ken/interfun.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test interfaces and methods.
+
 package main
 
 type S struct {
diff --git a/test/ken/intervar.go b/test/ken/intervar.go
index c2aaaa870..8a2fca0d4 100644
--- a/test/ken/intervar.go
+++ b/test/ken/intervar.go
@@ -1,13 +1,15 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test interface assignment.
+
 package main
 
 type	Iputs	interface {
-	puts	(s string);
+	puts	(s string) string;
 }
 
 // ---------
@@ -17,9 +19,9 @@ type	Print	struct {
 	put	Iputs;
 }
 
-func (p *Print) dop() {
-	print(" print ", p.whoami);
-	p.put.puts("abc");
+func (p *Print) dop() string {
+	r := " print " + string(p.whoami + '0')
+	return r + p.put.puts("abc");
 }
 
 // ---------
@@ -29,9 +31,9 @@ type	Bio	struct {
 	put	Iputs;
 }
 
-func (b *Bio) puts(s string) {
-	print(" bio ", b.whoami);
-	b.put.puts(s);
+func (b *Bio) puts(s string) string {
+	r := " bio " + string(b.whoami + '0')
+	return r + b.put.puts(s);
 }
 
 // ---------
@@ -41,8 +43,8 @@ type	File	struct {
 	put	Iputs;
 }
 
-func (f *File) puts(s string) {
-	print(" file ", f.whoami, " -- ", s);
+func (f *File) puts(s string) string {
+	return " file " + string(f.whoami + '0') + " -- " + s
 }
 
 func
@@ -59,6 +61,9 @@ main() {
 
 	f.whoami = 3;
 
-	p.dop();
-	print("\n");
+	r := p.dop();
+	expected := " print 1 bio 2 file 3 -- abc"
+	if r != expected {
+		panic(r + " != " + expected)
+	}
 }
diff --git a/test/ken/label.go b/test/ken/label.go
index 770f33e39..fcb3e611d 100644
--- a/test/ken/label.go
+++ b/test/ken/label.go
@@ -1,36 +1,34 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test goto and labels.
 
 package main
 
-func
-main() {
-	i := 0;
+func main() {
+	i := 0
 	if false {
-		goto gogoloop;
+		goto gogoloop
 	}
 	if false {
-		goto gogoloop;
+		goto gogoloop
 	}
 	if false {
-		goto gogoloop;
+		goto gogoloop
 	}
-	goto gogoloop;
+	goto gogoloop
 
-// backward declared
+	// backward declared
 loop:
-	i = i+1;
+	i = i + 1
 	if i < 100 {
-		goto loop;
+		goto loop
 	}
-	print(i);
-	print("\n");
-	return;
+	return
 
 gogoloop:
-	goto loop;
+	goto loop
 }
diff --git a/test/ken/litfun.go b/test/ken/litfun.go
index bac2bc17c..e241d4edb 100644
--- a/test/ken/litfun.go
+++ b/test/ken/litfun.go
@@ -1,9 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test simple function literals.
 
 package main
 
diff --git a/test/ken/mfunc.go b/test/ken/mfunc.go
index ae0bc0c58..ef2499194 100644
--- a/test/ken/mfunc.go
+++ b/test/ken/mfunc.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test simple multi-argument multi-valued function.
+
 package main
 
 func
diff --git a/test/ken/modconst.go b/test/ken/modconst.go
index acb8831ef..d88cf1003 100644
--- a/test/ken/modconst.go
+++ b/test/ken/modconst.go
@@ -1,12 +1,14 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test integer modulus by contstants.
+
 package main
 
-import "rand"
+import "math/rand"
 
 const Count = 1e5
 
diff --git a/test/ken/ptrfun.go b/test/ken/ptrfun.go
index 6739ba33a..af806cfd9 100644
--- a/test/ken/ptrfun.go
+++ b/test/ken/ptrfun.go
@@ -1,9 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test method invocation with pointer receivers and function-valued fields.
 
 package main
 
diff --git a/test/ken/ptrvar.go b/test/ken/ptrvar.go
index e2ddde629..d78170c9d 100644
--- a/test/ken/ptrvar.go
+++ b/test/ken/ptrvar.go
@@ -1,9 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test pointers and the . (selector) operator on structs.
 
 package main
 
diff --git a/test/ken/range.go b/test/ken/range.go
index 9535fd497..89c14e5c3 100644
--- a/test/ken/range.go
+++ b/test/ken/range.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test 'for range' on arrays, slices, and maps.
+
 package main
 
 const size = 16
diff --git a/test/ken/rob1.go b/test/ken/rob1.go
index 03350662a..3042a671b 100644
--- a/test/ken/rob1.go
+++ b/test/ken/rob1.go
@@ -1,67 +1,72 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test general operation using a list implementation.
+
 package main
 
 type Item interface {
-	Print();
+	Print() string
 }
 
 type ListItem struct {
-	item    Item;
-	next    *ListItem;
+	item Item
+	next *ListItem
 }
 
 type List struct {
-	head    *ListItem;
+	head *ListItem
 }
 
 func (list *List) Init() {
-	list.head = nil;
+	list.head = nil
 }
 
 func (list *List) Insert(i Item) {
-	item := new(ListItem);
-	item.item = i;
-	item.next = list.head;
-	list.head = item;
+	item := new(ListItem)
+	item.item = i
+	item.next = list.head
+	list.head = item
 }
 
-func (list *List) Print() {
-	i := list.head;
+func (list *List) Print() string {
+	r := ""
+	i := list.head
 	for i != nil {
-		i.item.Print();
-		i = i.next;
+		r += i.item.Print()
+		i = i.next
 	}
+	return r
 }
 
 // Something to put in a list
 type Integer struct {
-	val		int;
+	val int
 }
 
 func (this *Integer) Init(i int) *Integer {
-	this.val = i;
-	return this;
+	this.val = i
+	return this
 }
 
-func (this *Integer) Print() {
-	print(this.val);
+func (this *Integer) Print() string {
+	return string(this.val + '0')
 }
 
-func
-main() {
-	list := new(List);
-	list.Init();
+func main() {
+	list := new(List)
+	list.Init()
 	for i := 0; i < 10; i = i + 1 {
-		integer := new(Integer);
-		integer.Init(i);
-		list.Insert(integer);
+		integer := new(Integer)
+		integer.Init(i)
+		list.Insert(integer)
 	}
 
-	list.Print();
-	print("\n");
+	r := list.Print()
+	if r != "9876543210" {
+		panic(r)
+	}
 }
diff --git a/test/ken/rob2.go b/test/ken/rob2.go
index af63e4d9f..4b4410ee8 100644
--- a/test/ken/rob2.go
+++ b/test/ken/rob2.go
@@ -1,272 +1,280 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test general operation using s-list.
+// First Go program ever run (although not in this exact form).
 
 package main
 
-const nilchar = 0;
+import "fmt"
+
+const nilchar = 0
 
 type Atom struct {
-	str		string;
-	integer		int;
-	next		*Slist;	/* in hash bucket */
+	str     string
+	integer int
+	next    *Slist /* in hash bucket */
 }
 
 type List struct {
-	car		*Slist;
-	cdr*Slist;
+	car *Slist
+	cdr *Slist
 }
 
 type Slist struct {
-	isatom		bool;
-	isstring	bool;
+	isatom   bool
+	isstring bool
 	//union {
-	atom		Atom;
-	list		List;
+	atom Atom
+	list List
 	//} u;
 
 }
 
 func (this *Slist) Car() *Slist {
-	return this.list.car;
+	return this.list.car
 }
 
 func (this *Slist) Cdr() *Slist {
-	return this.list.cdr;
+	return this.list.cdr
 }
 
 func (this *Slist) String() string {
-	return this.atom.str;
+	return this.atom.str
 }
 
 func (this *Slist) Integer() int {
-	return this.atom.integer;
+	return this.atom.integer
 }
 
 func (slist *Slist) Free() {
 	if slist == nil {
-		return;
+		return
 	}
 	if slist.isatom {
-//		free(slist.String());
+		//		free(slist.String());
 	} else {
-		slist.Car().Free();
-		slist.Cdr().Free();
+		slist.Car().Free()
+		slist.Cdr().Free()
 	}
-//	free(slist);
+	//	free(slist);
 }
 
 //Slist* atom(byte *s, int i);
 
-var token int;
-var peekc int = -1;
-var lineno int32 = 1;
+var token int
+var peekc int = -1
+var lineno int32 = 1
 
-var input string;
-var inputindex int = 0;
-var tokenbuf [100]byte;
-var tokenlen int = 0;
+var input string
+var inputindex int = 0
+var tokenbuf [100]byte
+var tokenlen int = 0
 
-const EOF int = -1;
+const EOF int = -1
 
 func main() {
-	var list *Slist;
+	var list *Slist
 
-	OpenFile();
-	for ;; {
-		list = Parse();
+	OpenFile()
+	for {
+		list = Parse()
 		if list == nil {
-			break;
+			break
+		}
+		r := list.Print()
+		list.Free()
+		if r != "(defn foo (add 12 34))" {
+			panic(r)
 		}
-		list.Print();
-		list.Free();
-		break;
+		break
 	}
 }
 
-func (slist *Slist) PrintOne(doparen bool) {
+func (slist *Slist) PrintOne(doparen bool) string {
 	if slist == nil {
-		return;
+		return ""
 	}
+	var r string
 	if slist.isatom {
 		if slist.isstring {
-			print(slist.String());
+			r = slist.String()
 		} else {
-			print(slist.Integer());
+			r = fmt.Sprintf("%v", slist.Integer())
 		}
 	} else {
 		if doparen {
-			print("(" );
+			r += "("
 		}
-		slist.Car().PrintOne(true);
+		r += slist.Car().PrintOne(true)
 		if slist.Cdr() != nil {
-			print(" ");
-			slist.Cdr().PrintOne(false);
+			r += " "
+			r += slist.Cdr().PrintOne(false)
 		}
 		if doparen {
-			print(")");
+			r += ")"
 		}
 	}
+	return r
 }
 
-func (slist *Slist) Print() {
-	slist.PrintOne(true);
-	print("\n");
+func (slist *Slist) Print() string {
+	return slist.PrintOne(true)
 }
 
 func Get() int {
-	var c int;
+	var c int
 
 	if peekc >= 0 {
-		c = peekc;
-		peekc = -1;
+		c = peekc
+		peekc = -1
 	} else {
-		c = int(input[inputindex]);
-		inputindex++;
+		c = int(input[inputindex])
+		inputindex++
 		if c == '\n' {
-			lineno = lineno + 1;
+			lineno = lineno + 1
 		}
 		if c == nilchar {
-			inputindex = inputindex - 1;
-			c = EOF;
+			inputindex = inputindex - 1
+			c = EOF
 		}
 	}
-	return c;
+	return c
 }
 
 func WhiteSpace(c int) bool {
-	return c == ' ' || c == '\t' || c == '\r' || c == '\n';
+	return c == ' ' || c == '\t' || c == '\r' || c == '\n'
 }
 
 func NextToken() {
-	var i, c int;
+	var i, c int
 
-	tokenbuf[0] = nilchar;	// clear previous token
-	c = Get();
+	tokenbuf[0] = nilchar // clear previous token
+	c = Get()
 	for WhiteSpace(c) {
-		c = Get();
+		c = Get()
 	}
 	switch c {
 	case EOF:
-		token = EOF;
+		token = EOF
 	case '(', ')':
-		token = c;
-		break;
+		token = c
+		break
 	default:
-		for i = 0; i < 100 - 1; {	// sizeof tokenbuf - 1
-			tokenbuf[i] = byte(c);
-			i = i + 1;
-			c = Get();
+		for i = 0; i < 100-1; { // sizeof tokenbuf - 1
+			tokenbuf[i] = byte(c)
+			i = i + 1
+			c = Get()
 			if c == EOF {
-				break;
+				break
 			}
 			if WhiteSpace(c) || c == ')' {
-				peekc = c;
-				break;
+				peekc = c
+				break
 			}
 		}
-		if i >= 100 - 1 {	// sizeof tokenbuf - 1
-			panic("atom too long\n");
+		if i >= 100-1 { // sizeof tokenbuf - 1
+			panic("atom too long\n")
 		}
-		tokenlen = i;
-		tokenbuf[i] = nilchar;
+		tokenlen = i
+		tokenbuf[i] = nilchar
 		if '0' <= tokenbuf[0] && tokenbuf[0] <= '9' {
-			token = '0';
+			token = '0'
 		} else {
-			token = 'A';
+			token = 'A'
 		}
 	}
 }
 
 func Expect(c int) {
 	if token != c {
-		print("parse error: expected ", c, "\n");
-		panic("parse");
+		print("parse error: expected ", c, "\n")
+		panic("parse")
 	}
-	NextToken();
+	NextToken()
 }
 
 // Parse a non-parenthesized list up to a closing paren or EOF
 func ParseList() *Slist {
-	var slist, retval *Slist;
-
-	slist = new(Slist);
-	slist.list.car = nil;
-	slist.list.cdr = nil;
-	slist.isatom = false;
-	slist.isstring = false;
-
-	retval = slist;
-	for ;; {
-		slist.list.car = Parse();
-		if token == ')' || token == EOF {	// empty cdr
-			break;
+	var slist, retval *Slist
+
+	slist = new(Slist)
+	slist.list.car = nil
+	slist.list.cdr = nil
+	slist.isatom = false
+	slist.isstring = false
+
+	retval = slist
+	for {
+		slist.list.car = Parse()
+		if token == ')' || token == EOF { // empty cdr
+			break
 		}
-		slist.list.cdr = new(Slist);
-		slist = slist.list.cdr;
+		slist.list.cdr = new(Slist)
+		slist = slist.list.cdr
 	}
-	return retval;
+	return retval
 }
 
-func atom(i int) *Slist	{ // BUG: uses tokenbuf; should take argument)
-	var slist *Slist;
+func atom(i int) *Slist { // BUG: uses tokenbuf; should take argument)
+	var slist *Slist
 
-	slist = new(Slist);
+	slist = new(Slist)
 	if token == '0' {
-		slist.atom.integer = i;
-		slist.isstring = false;
+		slist.atom.integer = i
+		slist.isstring = false
 	} else {
-		slist.atom.str = string(tokenbuf[0:tokenlen]);
-		slist.isstring = true;
+		slist.atom.str = string(tokenbuf[0:tokenlen])
+		slist.isstring = true
 	}
-	slist.isatom = true;
-	return slist;
+	slist.isatom = true
+	return slist
 }
 
-func atoi() int	{ // BUG: uses tokenbuf; should take argument)
-	var v int = 0;
+func atoi() int { // BUG: uses tokenbuf; should take argument)
+	var v int = 0
 	for i := 0; i < tokenlen && '0' <= tokenbuf[i] && tokenbuf[i] <= '9'; i = i + 1 {
-		v = 10 * v + int(tokenbuf[i] - '0');
+		v = 10*v + int(tokenbuf[i]-'0')
 	}
-	return v;
+	return v
 }
 
 func Parse() *Slist {
-	var slist *Slist;
+	var slist *Slist
 
 	if token == EOF || token == ')' {
-		return nil;
+		return nil
 	}
 	if token == '(' {
-		NextToken();
-		slist = ParseList();
-		Expect(')');
-		return slist;
+		NextToken()
+		slist = ParseList()
+		Expect(')')
+		return slist
 	} else {
 		// Atom
 		switch token {
 		case EOF:
-			return nil;
+			return nil
 		case '0':
-			slist = atom(atoi());
+			slist = atom(atoi())
 		case '"', 'A':
-			slist = atom(0);
+			slist = atom(0)
 		default:
-			slist = nil;
-			print("unknown token: ", token, "\n");
+			slist = nil
+			print("unknown token: ", token, "\n")
 		}
-		NextToken();
-		return slist;
+		NextToken()
+		return slist
 	}
-	return nil;
+	return nil
 }
 
 func OpenFile() {
-	input = "(defn foo (add 12 34))\n\x00";
-	inputindex = 0;
-	peekc = -1;		// BUG
-	NextToken();
+	input = "(defn foo (add 12 34))\n\x00"
+	inputindex = 0
+	peekc = -1 // BUG
+	NextToken()
 }
diff --git a/test/ken/robfor.go b/test/ken/robfor.go
index 05188a472..c6a420b39 100644
--- a/test/ken/robfor.go
+++ b/test/ken/robfor.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test for loops of many forms.
+
 package main
 
 func assertequal(is, shouldbe int, msg string) {
diff --git a/test/ken/robfunc.go b/test/ken/robfunc.go
index 6b3d4b2e4..885267e30 100644
--- a/test/ken/robfunc.go
+++ b/test/ken/robfunc.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test functions of many signatures.
+
 package main
 
 func assertequal(is, shouldbe int, msg string) {
diff --git a/test/ken/shift.go b/test/ken/shift.go
index 157a07aec..af8789615 100644
--- a/test/ken/shift.go
+++ b/test/ken/shift.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test shift.
+
 package main
 
 var	ians	[18]int;
diff --git a/test/ken/simparray.go b/test/ken/simparray.go
index 1b6f245ee..0e81a341b 100644
--- a/test/ken/simparray.go
+++ b/test/ken/simparray.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test simple operations on arrays.
+
 package main
 
 var b[10] float32;
diff --git a/test/ken/simpbool.go b/test/ken/simpbool.go
index dbd9c8d8b..ab2ecc21a 100644
--- a/test/ken/simpbool.go
+++ b/test/ken/simpbool.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test basic operations on bool.
+
 package main
 
 type s struct {
diff --git a/test/ken/simpconv.go b/test/ken/simpconv.go
index feb85d299..22cad2ad0 100644
--- a/test/ken/simpconv.go
+++ b/test/ken/simpconv.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test simple arithmetic conversion.
+
 package main
 
 type vlong int64
diff --git a/test/ken/simpfun.go b/test/ken/simpfun.go
index ba9ce6f7b..e5dc2b249 100644
--- a/test/ken/simpfun.go
+++ b/test/ken/simpfun.go
@@ -1,9 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test simple functions.
 
 package main
 
diff --git a/test/ken/simpprint.go b/test/ken/simpprint.go
deleted file mode 100644
index 6077f7eb0..000000000
--- a/test/ken/simpprint.go
+++ /dev/null
@@ -1,13 +0,0 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
-
-// Copyright 2009 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.
-
-
-package main
-
-func
-main() {
-	print("hello world\n");
-}
diff --git a/test/ken/simpswitch.go b/test/ken/simpswitch.go
index ab5dd356b..b28250b1d 100644
--- a/test/ken/simpswitch.go
+++ b/test/ken/simpswitch.go
@@ -1,24 +1,28 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test simple switch.
+
 package main
 
-func
-main() {
-	a := 3;
-	for i:=0; i<10; i=i+1 {
-		switch(i) {
+func main() {
+	r := ""
+	a := 3
+	for i := 0; i < 10; i = i + 1 {
+		switch i {
 		case 5:
-			print("five");
-		case a,7:
-			print("a");
+			r += "five"
+		case a, 7:
+			r += "a"
 		default:
-			print(i);
+			r += string(i + '0')
 		}
-		print("out", i);
+		r += "out" + string(i+'0')
+	}
+	if r != "0out01out12out2aout34out4fiveout56out6aout78out89out9" {
+		panic(r)
 	}
-	print("\n");
 }
diff --git a/test/ken/simpvar.go b/test/ken/simpvar.go
index fd060b0e2..c6eefbb5a 100644
--- a/test/ken/simpvar.go
+++ b/test/ken/simpvar.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test scoping of variables.
+
 
 package main
 
diff --git a/test/ken/slicearray.go b/test/ken/slicearray.go
index 5c31270fc..6cf676c58 100644
--- a/test/ken/slicearray.go
+++ b/test/ken/slicearray.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test basic operations of slices and arrays.
+
 package main
 
 var bx [10]byte
diff --git a/test/ken/sliceslice.go b/test/ken/sliceslice.go
index 639042128..c07c59125 100644
--- a/test/ken/sliceslice.go
+++ b/test/ken/sliceslice.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test slicing and re-slicing.
+
 package main
 
 var bx []byte
diff --git a/test/ken/string.go b/test/ken/string.go
index cbedad4e8..6df8dc4dd 100644
--- a/test/ken/string.go
+++ b/test/ken/string.go
@@ -1,9 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// cmpout
 
 // Copyright 2009 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.
 
+// Test string operations including printing.
 
 package main
 
@@ -71,16 +72,14 @@ func main() {
 	/* create string with integer constant */
 	c = string('x')
 	if c != "x" {
-		print("create int ", c)
-		panic("fail")
+		panic("create int " + c)
 	}
 
 	/* create string with integer variable */
 	v := 'x'
 	c = string(v)
 	if c != "x" {
-		print("create int ", c)
-		panic("fail")
+		panic("create int " + c)
 	}
 
 	/* create string with byte array */
@@ -90,19 +89,17 @@ func main() {
 	z1[2] = 'c'
 	c = string(z1[0:])
 	if c != "abc" {
-		print("create byte array ", c)
-		panic("fail")
+		panic("create byte array " + c)
 	}
 
 	/* create string with int array */
-	var z2 [3]int
+	var z2 [3]rune
 	z2[0] = 'a'
 	z2[1] = '\u1234'
 	z2[2] = 'c'
 	c = string(z2[0:])
 	if c != "a\u1234c" {
-		print("create int array ", c)
-		panic("fail")
+		panic("create int array " + c)
 	}
 
 	/* create string with byte array pointer */
@@ -112,7 +109,6 @@ func main() {
 	z3[2] = 'c'
 	c = string(z3[0:])
 	if c != "abc" {
-		print("create array pointer ", c)
-		panic("fail")
+		panic("create array pointer " + c)
 	}
 }
diff --git a/test/ken/string.out b/test/ken/string.out
new file mode 100644
index 000000000..8bc36bc6f
--- /dev/null
+++ b/test/ken/string.out
@@ -0,0 +1 @@
+abcxyz-abcxyz-abcxyz-abcxyz-abcxyz-abcxyz-abcxyz
diff --git a/test/ken/strvar.go b/test/ken/strvar.go
index dfaaf1213..4d511fe67 100644
--- a/test/ken/strvar.go
+++ b/test/ken/strvar.go
@@ -1,9 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test struct-valued variables (not pointers).
 
 package main
 
diff --git a/test/label.go b/test/label.go
index e3d853266..b30c27ec4 100644
--- a/test/label.go
+++ b/test/label.go
@@ -1,10 +1,12 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2011 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.
 
-// Pass 1 label errors.
+// Verify that erroneous labels are caught by the compiler.
+// This set is caught by pass 1.
+// Does not compile.
 
 package main
 
diff --git a/test/label1.go b/test/label1.go
index 656daaeea..f923a1882 100644
--- a/test/label1.go
+++ b/test/label1.go
@@ -1,10 +1,13 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2011 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.
 
-// Pass 2 label errors.
+
+// Verify that erroneous labels are caught by the compiler.
+// This set is caught by pass 2. That's why this file is label1.go.
+// Does not compile.
 
 package main
 
diff --git a/test/linkx.go b/test/linkx.go
new file mode 100644
index 000000000..d2c954567
--- /dev/null
+++ b/test/linkx.go
@@ -0,0 +1,17 @@
+// $G $D/$F.go && $L -X main.tbd hello $F.$A && ./$A.out
+
+// Copyright 2012 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.
+
+// Test the -X facility of the gc linker (6l etc.).
+
+package main
+
+var tbd string
+
+func main() {
+	if tbd != "hello" {
+		println("BUG: test/linkx", len(tbd), tbd)
+	}
+}
diff --git a/test/literal.go b/test/literal.go
index bf0538812..ba185fc9a 100644
--- a/test/literal.go
+++ b/test/literal.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test literal syntax for basic types.
+
 package main
 
 var nbad int
diff --git a/test/malloc1.go b/test/malloc1.go
deleted file mode 100644
index 61f1797c7..000000000
--- a/test/malloc1.go
+++ /dev/null
@@ -1,25 +0,0 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
-
-// Copyright 2009 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.
-
-// trivial malloc test
-
-package main
-
-import (
-	"flag"
-	"fmt"
-	"runtime"
-)
-
-var chatty = flag.Bool("v", false, "chatty")
-
-func main() {
-	runtime.Free(runtime.Alloc(1))
-	runtime.UpdateMemStats()
-	if *chatty {
-		fmt.Printf("%+v %v\n", runtime.MemStats, uint64(0))
-	}
-}
diff --git a/test/mallocfin.go b/test/mallocfin.go
index dc6d74bad..be6d79b2b 100644
--- a/test/mallocfin.go
+++ b/test/mallocfin.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
-// trivial finalizer test
+// Test basic operation of finalizers.
 
 package main
 
@@ -47,18 +47,28 @@ func finalB(b *B) {
 	nfinal++
 }
 
+func nofinalB(b *B) {
+	panic("nofinalB run")
+}
+
 func main() {
 	runtime.GOMAXPROCS(4)
 	for i = 0; i < N; i++ {
 		b := &B{i}
 		a := &A{b, i}
+		c := new(B)
+		runtime.SetFinalizer(c, nofinalB)
 		runtime.SetFinalizer(b, finalB)
 		runtime.SetFinalizer(a, finalA)
+		runtime.SetFinalizer(c, nil)
 	}
 	for i := 0; i < N; i++ {
 		runtime.GC()
 		runtime.Gosched()
 		time.Sleep(1e6)
+		if nfinal >= N*8/10 {
+			break
+		}
 	}
 	if nfinal < N*8/10 {
 		println("not enough finalizing:", nfinal, "/", N)
diff --git a/test/mallocrand.go b/test/mallocrand.go
deleted file mode 100644
index f014b441b..000000000
--- a/test/mallocrand.go
+++ /dev/null
@@ -1,92 +0,0 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
-
-// Copyright 2009 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.
-
-// Random malloc test.
-
-package main
-
-import (
-	"flag"
-	"rand"
-	"runtime"
-	"unsafe"
-)
-
-var chatty = flag.Bool("v", false, "chatty")
-
-var footprint uint64
-var allocated uint64
-
-func bigger() {
-	runtime.UpdateMemStats()
-	if f := runtime.MemStats.Sys; footprint < f {
-		footprint = f
-		if *chatty {
-			println("Footprint", footprint, " for ", allocated)
-		}
-		if footprint > 1e9 {
-			println("too big")
-			panic("fail")
-		}
-	}
-}
-
-// Prime the data structures by allocating one of
-// each block in order.  After this, there should be
-// little reason to ask for more memory from the OS.
-func prime() {
-	for i := 0; i < 16; i++ {
-		b := runtime.Alloc(1 << uint(i))
-		runtime.Free(b)
-	}
-	for i := uintptr(0); i < 256; i++ {
-		b := runtime.Alloc(i << 12)
-		runtime.Free(b)
-	}
-}
-
-func memset(b *byte, c byte, n uintptr) {
-	np := uintptr(n)
-	for i := uintptr(0); i < np; i++ {
-		*(*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(b)) + i)) = c
-	}
-}
-
-func main() {
-	flag.Parse()
-	//	prime()
-	var blocks [1]struct {
-		base *byte
-		siz  uintptr
-	}
-	for i := 0; i < 1<<10; i++ {
-		if i%(1<<10) == 0 && *chatty {
-			println(i)
-		}
-		b := rand.Int() % len(blocks)
-		if blocks[b].base != nil {
-			//	println("Free", blocks[b].siz, blocks[b].base)
-			runtime.Free(blocks[b].base)
-			blocks[b].base = nil
-			allocated -= uint64(blocks[b].siz)
-			continue
-		}
-		siz := uintptr(rand.Int() >> (11 + rand.Uint32()%20))
-		base := runtime.Alloc(siz)
-		//	ptr := uintptr(syscall.BytePtr(base))+uintptr(siz/2)
-		//	obj, size, ref, ok := allocator.find(ptr)
-		//	if obj != base || *ref != 0 || !ok {
-		//		println("find", siz, obj, ref, ok)
-		//		panic("fail")
-		//	}
-		blocks[b].base = base
-		blocks[b].siz = siz
-		allocated += uint64(siz)
-		//	println("Alloc", siz, base)
-		memset(base, 0xbb, siz)
-		bigger()
-	}
-}
diff --git a/test/mallocrep.go b/test/mallocrep.go
deleted file mode 100644
index 9f47e52e2..000000000
--- a/test/mallocrep.go
+++ /dev/null
@@ -1,69 +0,0 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
-
-// Copyright 2009 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.
-
-// Repeated malloc test.
-
-package main
-
-import (
-	"flag"
-	"runtime"
-)
-
-var chatty = flag.Bool("v", false, "chatty")
-
-var oldsys uint64
-
-func bigger() {
-	runtime.UpdateMemStats()
-	if st := runtime.MemStats; oldsys < st.Sys {
-		oldsys = st.Sys
-		if *chatty {
-			println(st.Sys, " system bytes for ", st.Alloc, " Go bytes")
-		}
-		if st.Sys > 1e9 {
-			println("too big")
-			panic("fail")
-		}
-	}
-}
-
-func main() {
-	runtime.GC()               // clean up garbage from init
-	runtime.MemProfileRate = 0 // disable profiler
-	runtime.MemStats.Alloc = 0 // ignore stacks
-	flag.Parse()
-	for i := 0; i < 1<<7; i++ {
-		for j := 1; j <= 1<<22; j <<= 1 {
-			if i == 0 && *chatty {
-				println("First alloc:", j)
-			}
-			if a := runtime.MemStats.Alloc; a != 0 {
-				println("no allocations but stats report", a, "bytes allocated")
-				panic("fail")
-			}
-			b := runtime.Alloc(uintptr(j))
-			runtime.UpdateMemStats()
-			during := runtime.MemStats.Alloc
-			runtime.Free(b)
-			runtime.UpdateMemStats()
-			if a := runtime.MemStats.Alloc; a != 0 {
-				println("allocated ", j, ": wrong stats: during=", during, " after=", a, " (want 0)")
-				panic("fail")
-			}
-			bigger()
-		}
-		if i%(1<<10) == 0 && *chatty {
-			println(i)
-		}
-		if i == 0 {
-			if *chatty {
-				println("Primed", i)
-			}
-			//	runtime.frozen = true
-		}
-	}
-}
diff --git a/test/mallocrep1.go b/test/mallocrep1.go
deleted file mode 100644
index 0b1479900..000000000
--- a/test/mallocrep1.go
+++ /dev/null
@@ -1,143 +0,0 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
-
-// Copyright 2009 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.
-
-// Repeated malloc test.
-
-package main
-
-import (
-	"flag"
-	"fmt"
-	"runtime"
-	"strconv"
-)
-
-var chatty = flag.Bool("v", false, "chatty")
-var reverse = flag.Bool("r", false, "reverse")
-var longtest = flag.Bool("l", false, "long test")
-
-var b []*byte
-var stats = &runtime.MemStats
-
-func OkAmount(size, n uintptr) bool {
-	if n < size {
-		return false
-	}
-	if size < 16*8 {
-		if n > size+16 {
-			return false
-		}
-	} else {
-		if n > size*9/8 {
-			return false
-		}
-	}
-	return true
-}
-
-func AllocAndFree(size, count int) {
-	if *chatty {
-		fmt.Printf("size=%d count=%d ...\n", size, count)
-	}
-	runtime.UpdateMemStats()
-	n1 := stats.Alloc
-	for i := 0; i < count; i++ {
-		b[i] = runtime.Alloc(uintptr(size))
-		base, n := runtime.Lookup(b[i])
-		if base != b[i] || !OkAmount(uintptr(size), n) {
-			println("lookup failed: got", base, n, "for", b[i])
-			panic("fail")
-		}
-		runtime.UpdateMemStats()
-		if stats.Sys > 1e9 {
-			println("too much memory allocated")
-			panic("fail")
-		}
-	}
-	runtime.UpdateMemStats()
-	n2 := stats.Alloc
-	if *chatty {
-		fmt.Printf("size=%d count=%d stats=%+v\n", size, count, *stats)
-	}
-	n3 := stats.Alloc
-	for j := 0; j < count; j++ {
-		i := j
-		if *reverse {
-			i = count - 1 - j
-		}
-		alloc := uintptr(stats.Alloc)
-		base, n := runtime.Lookup(b[i])
-		if base != b[i] || !OkAmount(uintptr(size), n) {
-			println("lookup failed: got", base, n, "for", b[i])
-			panic("fail")
-		}
-		runtime.Free(b[i])
-		runtime.UpdateMemStats()
-		if stats.Alloc != uint64(alloc-n) {
-			println("free alloc got", stats.Alloc, "expected", alloc-n, "after free of", n)
-			panic("fail")
-		}
-		if runtime.MemStats.Sys > 1e9 {
-			println("too much memory allocated")
-			panic("fail")
-		}
-	}
-	runtime.UpdateMemStats()
-	n4 := stats.Alloc
-
-	if *chatty {
-		fmt.Printf("size=%d count=%d stats=%+v\n", size, count, *stats)
-	}
-	if n2-n1 != n3-n4 {
-		println("wrong alloc count: ", n2-n1, n3-n4)
-		panic("fail")
-	}
-}
-
-func atoi(s string) int {
-	i, _ := strconv.Atoi(s)
-	return i
-}
-
-func main() {
-	runtime.MemProfileRate = 0 // disable profiler
-	flag.Parse()
-	b = make([]*byte, 10000)
-	if flag.NArg() > 0 {
-		AllocAndFree(atoi(flag.Arg(0)), atoi(flag.Arg(1)))
-		return
-	}
-	maxb := 1 << 22
-	if !*longtest {
-		maxb = 1 << 19
-	}
-	for j := 1; j <= maxb; j <<= 1 {
-		n := len(b)
-		max := uintptr(1 << 28)
-		if !*longtest {
-			max = uintptr(maxb)
-		}
-		if uintptr(j)*uintptr(n) > max {
-			n = int(max / uintptr(j))
-		}
-		if n < 10 {
-			n = 10
-		}
-		for m := 1; m <= n; {
-			AllocAndFree(j, m)
-			if m == n {
-				break
-			}
-			m = 5 * m / 4
-			if m < 4 {
-				m++
-			}
-			if m > n {
-				m = n
-			}
-		}
-	}
-}
diff --git a/test/map.go b/test/map.go
index c3963499b..6dec0dfd7 100644
--- a/test/map.go
+++ b/test/map.go
@@ -1,14 +1,18 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test maps, almost exhaustively.
+
 package main
 
 import (
 	"fmt"
+	"math"
 	"strconv"
+	"time"
 )
 
 const count = 100
@@ -26,6 +30,12 @@ func P(a []string) string {
 }
 
 func main() {
+	testbasic()
+	testfloat()
+	testnan()
+}
+
+func testbasic() {
 	// Test a map literal.
 	mlit := map[string]int{"0": 0, "1": 1, "2": 2, "3": 3, "4": 4}
 	for i := 0; i < len(mlit); i++ {
@@ -479,7 +489,7 @@ func main() {
 
 		mipM[i][i]++
 		if mipM[i][i] != (i+1)+1 {
-			fmt.Printf("update mipM[%d][%d] = %i\n", i, i, mipM[i][i])
+			fmt.Printf("update mipM[%d][%d] = %d\n", i, i, mipM[i][i])
 		}
 	}
 
@@ -489,3 +499,195 @@ func main() {
 		panic("range mnil")
 	}
 }
+
+func testfloat() {
+	// Test floating point numbers in maps.
+	// Two map keys refer to the same entry if the keys are ==.
+	// The special cases, then, are that +0 == -0 and that NaN != NaN.
+
+	{
+		var (
+			pz   = float32(0)
+			nz   = math.Float32frombits(1 << 31)
+			nana = float32(math.NaN())
+			nanb = math.Float32frombits(math.Float32bits(nana) ^ 2)
+		)
+
+		m := map[float32]string{
+			pz:   "+0",
+			nana: "NaN",
+			nanb: "NaN",
+		}
+		if m[pz] != "+0" {
+			fmt.Println("float32 map cannot read back m[+0]:", m[pz])
+		}
+		if m[nz] != "+0" {
+			fmt.Println("float32 map does not treat", pz, "and", nz, "as equal for read")
+			fmt.Println("float32 map does not treat -0 and +0 as equal for read")
+		}
+		m[nz] = "-0"
+		if m[pz] != "-0" {
+			fmt.Println("float32 map does not treat -0 and +0 as equal for write")
+		}
+		if _, ok := m[nana]; ok {
+			fmt.Println("float32 map allows NaN lookup (a)")
+		}
+		if _, ok := m[nanb]; ok {
+			fmt.Println("float32 map allows NaN lookup (b)")
+		}
+		if len(m) != 3 {
+			fmt.Println("float32 map should have 3 entries:", m)
+		}
+		m[nana] = "NaN"
+		m[nanb] = "NaN"
+		if len(m) != 5 {
+			fmt.Println("float32 map should have 5 entries:", m)
+		}
+	}
+
+	{
+		var (
+			pz   = float64(0)
+			nz   = math.Float64frombits(1 << 63)
+			nana = float64(math.NaN())
+			nanb = math.Float64frombits(math.Float64bits(nana) ^ 2)
+		)
+
+		m := map[float64]string{
+			pz:   "+0",
+			nana: "NaN",
+			nanb: "NaN",
+		}
+		if m[nz] != "+0" {
+			fmt.Println("float64 map does not treat -0 and +0 as equal for read")
+		}
+		m[nz] = "-0"
+		if m[pz] != "-0" {
+			fmt.Println("float64 map does not treat -0 and +0 as equal for write")
+		}
+		if _, ok := m[nana]; ok {
+			fmt.Println("float64 map allows NaN lookup (a)")
+		}
+		if _, ok := m[nanb]; ok {
+			fmt.Println("float64 map allows NaN lookup (b)")
+		}
+		if len(m) != 3 {
+			fmt.Println("float64 map should have 3 entries:", m)
+		}
+		m[nana] = "NaN"
+		m[nanb] = "NaN"
+		if len(m) != 5 {
+			fmt.Println("float64 map should have 5 entries:", m)
+		}
+	}
+
+	{
+		var (
+			pz   = complex64(0)
+			nz   = complex(0, math.Float32frombits(1<<31))
+			nana = complex(5, float32(math.NaN()))
+			nanb = complex(5, math.Float32frombits(math.Float32bits(float32(math.NaN()))^2))
+		)
+
+		m := map[complex64]string{
+			pz:   "+0",
+			nana: "NaN",
+			nanb: "NaN",
+		}
+		if m[nz] != "+0" {
+			fmt.Println("complex64 map does not treat -0 and +0 as equal for read")
+		}
+		m[nz] = "-0"
+		if m[pz] != "-0" {
+			fmt.Println("complex64 map does not treat -0 and +0 as equal for write")
+		}
+		if _, ok := m[nana]; ok {
+			fmt.Println("complex64 map allows NaN lookup (a)")
+		}
+		if _, ok := m[nanb]; ok {
+			fmt.Println("complex64 map allows NaN lookup (b)")
+		}
+		if len(m) != 3 {
+			fmt.Println("complex64 map should have 3 entries:", m)
+		}
+		m[nana] = "NaN"
+		m[nanb] = "NaN"
+		if len(m) != 5 {
+			fmt.Println("complex64 map should have 5 entries:", m)
+		}
+	}
+
+	{
+		var (
+			pz   = complex128(0)
+			nz   = complex(0, math.Float64frombits(1<<63))
+			nana = complex(5, float64(math.NaN()))
+			nanb = complex(5, math.Float64frombits(math.Float64bits(float64(math.NaN()))^2))
+		)
+
+		m := map[complex128]string{
+			pz:   "+0",
+			nana: "NaN",
+			nanb: "NaN",
+		}
+		if m[nz] != "+0" {
+			fmt.Println("complex128 map does not treat -0 and +0 as equal for read")
+		}
+		m[nz] = "-0"
+		if m[pz] != "-0" {
+			fmt.Println("complex128 map does not treat -0 and +0 as equal for write")
+		}
+		if _, ok := m[nana]; ok {
+			fmt.Println("complex128 map allows NaN lookup (a)")
+		}
+		if _, ok := m[nanb]; ok {
+			fmt.Println("complex128 map allows NaN lookup (b)")
+		}
+		if len(m) != 3 {
+			fmt.Println("complex128 map should have 3 entries:", m)
+		}
+		m[nana] = "NaN"
+		m[nanb] = "NaN"
+		if len(m) != 5 {
+			fmt.Println("complex128 map should have 5 entries:", m)
+		}
+	}
+}
+
+func testnan() {
+	// Test that NaNs in maps don't go quadratic.
+	t := func(n int) time.Duration {
+		t0 := time.Now()
+		m := map[float64]int{}
+		nan := math.NaN()
+		for i := 0; i < n; i++ {
+			m[nan] = 1
+		}
+		if len(m) != n {
+			panic("wrong size map after nan insertion")
+		}
+		return time.Since(t0)
+	}
+
+	// Depending on the machine and OS, this test might be too fast
+	// to measure with accurate enough granularity. On failure,
+	// make it run longer, hoping that the timing granularity
+	// is eventually sufficient.
+
+	n := 30000 // 0.02 seconds on a MacBook Air
+	fails := 0
+	for {
+		t1 := t(n)
+		t2 := t(2 * n)
+		// should be 2x (linear); allow up to 3x
+		if t2 < 3*t1 {
+			return
+		}
+		fails++
+		if fails == 4 {
+			fmt.Printf("too slow: %d inserts: %v; %d inserts: %v\n", n, t1, 2*n, t2)
+			return
+		}
+		n *= 2
+	}
+}
diff --git a/test/map1.go b/test/map1.go
new file mode 100644
index 000000000..369e49da5
--- /dev/null
+++ b/test/map1.go
@@ -0,0 +1,44 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// Test map declarations of many types, including erroneous ones.
+// Does not compile.
+
+package main
+
+func main() {}
+
+type v bool
+
+var (
+	// valid
+	_ map[int8]v
+	_ map[uint8]v
+	_ map[int16]v
+	_ map[uint16]v
+	_ map[int32]v
+	_ map[uint32]v
+	_ map[int64]v
+	_ map[uint64]v
+	_ map[int]v
+	_ map[uint]v
+	_ map[uintptr]v
+	_ map[float32]v
+	_ map[float64]v
+	_ map[complex64]v
+	_ map[complex128]v
+	_ map[bool]v
+	_ map[string]v
+	_ map[chan int]v
+	_ map[*int]v
+	_ map[struct{}]v
+	_ map[[10]int]v
+
+	// invalid
+	_ map[[]int]v       // ERROR "invalid map key"
+	_ map[func()]v      // ERROR "invalid map key"
+	_ map[map[int]int]v // ERROR "invalid map key"
+)
diff --git a/test/method.go b/test/method.go
index b5a02c687..0c239afbd 100644
--- a/test/method.go
+++ b/test/method.go
@@ -1,9 +1,12 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test simple methods of various types, with pointer and
+// value receivers.
+
 package main
 
 type S string
@@ -91,27 +94,27 @@ func main() {
 	}
 
 	if val(s) != 1 {
-		println("s.val:", val(s))
+		println("val(s):", val(s))
 		panic("fail")
 	}
 	if val(ps) != 2 {
-		println("ps.val:", val(ps))
+		println("val(ps):", val(ps))
 		panic("fail")
 	}
 	if val(i) != 3 {
-		println("i.val:", val(i))
+		println("val(i):", val(i))
 		panic("fail")
 	}
 	if val(pi) != 4 {
-		println("pi.val:", val(pi))
+		println("val(pi):", val(pi))
 		panic("fail")
 	}
 	if val(t) != 7 {
-		println("t.val:", val(t))
+		println("val(t):", val(t))
 		panic("fail")
 	}
 	if val(pt) != 8 {
-		println("pt.val:", val(pt))
+		println("val(pt):", val(pt))
 		panic("fail")
 	}
 
@@ -124,4 +127,124 @@ func main() {
 		println("Val.val(v):", Val.val(v))
 		panic("fail")
 	}
+
+	var zs struct { S }
+	var zps struct { *S1 }
+	var zi struct { I }
+	var zpi struct { *I1 }
+	var zpt struct { *T1 }
+	var zt struct { T }
+	var zv struct { Val }
+
+	if zs.val() != 1 {
+		println("zs.val:", zs.val())
+		panic("fail")
+	}
+	if zps.val() != 2 {
+		println("zps.val:", zps.val())
+		panic("fail")
+	}
+	if zi.val() != 3 {
+		println("zi.val:", zi.val())
+		panic("fail")
+	}
+	if zpi.val() != 4 {
+		println("zpi.val:", zpi.val())
+		panic("fail")
+	}
+	if zt.val() != 7 {
+		println("zt.val:", zt.val())
+		panic("fail")
+	}
+	if zpt.val() != 8 {
+		println("zpt.val:", zpt.val())
+		panic("fail")
+	}
+
+	if val(zs) != 1 {
+		println("val(zs):", val(zs))
+		panic("fail")
+	}
+	if val(zps) != 2 {
+		println("val(zps):", val(zps))
+		panic("fail")
+	}
+	if val(zi) != 3 {
+		println("val(zi):", val(zi))
+		panic("fail")
+	}
+	if val(zpi) != 4 {
+		println("val(zpi):", val(zpi))
+		panic("fail")
+	}
+	if val(zt) != 7 {
+		println("val(zt):", val(zt))
+		panic("fail")
+	}
+	if val(zpt) != 8 {
+		println("val(zpt):", val(zpt))
+		panic("fail")
+	}
+
+	zv.Val = zi
+	if zv.val() != 3 {
+		println("zv.val():", zv.val())
+		panic("fail")
+	}
+
+	if (&zs).val() != 1 {
+		println("(&zs).val:", (&zs).val())
+		panic("fail")
+	}
+	if (&zps).val() != 2 {
+		println("(&zps).val:", (&zps).val())
+		panic("fail")
+	}
+	if (&zi).val() != 3 {
+		println("(&zi).val:", (&zi).val())
+		panic("fail")
+	}
+	if (&zpi).val() != 4 {
+		println("(&zpi).val:", (&zpi).val())
+		panic("fail")
+	}
+	if (&zt).val() != 7 {
+		println("(&zt).val:", (&zt).val())
+		panic("fail")
+	}
+	if (&zpt).val() != 8 {
+		println("(&zpt).val:", (&zpt).val())
+		panic("fail")
+	}
+
+	if val(&zs) != 1 {
+		println("val(&zs):", val(&zs))
+		panic("fail")
+	}
+	if val(&zps) != 2 {
+		println("val(&zps):", val(&zps))
+		panic("fail")
+	}
+	if val(&zi) != 3 {
+		println("val(&zi):", val(&zi))
+		panic("fail")
+	}
+	if val(&zpi) != 4 {
+		println("val(&zpi):", val(&zpi))
+		panic("fail")
+	}
+	if val(&zt) != 7 {
+		println("val(&zt):", val(&zt))
+		panic("fail")
+	}
+	if val(&zpt) != 8 {
+		println("val(&zpt):", val(&zpt))
+		panic("fail")
+	}
+
+	zv.Val = &zi
+	if zv.val() != 3 {
+		println("zv.val():", zv.val())
+		panic("fail")
+	}
 }
diff --git a/test/method1.go b/test/method1.go
index ec14ef9e4..365b8ca55 100644
--- a/test/method1.go
+++ b/test/method1.go
@@ -1,9 +1,12 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Verify that method redeclarations are caught by the compiler.
+// Does not compile.
+
 package main
 
 type T struct { }
diff --git a/test/method2.go b/test/method2.go
index 2fdc9fc3c..b63da10dc 100644
--- a/test/method2.go
+++ b/test/method2.go
@@ -1,9 +1,12 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Verify that pointers and interface types cannot be method receivers.
+// Does not compile.
+
 package main
 
 type T struct {
@@ -12,14 +15,14 @@ type T struct {
 type P *T
 type P1 *T
 
-func (p P) val() int   { return 1 } // ERROR "receiver.* pointer"
-func (p *P1) val() int { return 1 } // ERROR "receiver.* pointer"
+func (p P) val() int   { return 1 } // ERROR "receiver.* pointer|invalid pointer or interface receiver"
+func (p *P1) val() int { return 1 } // ERROR "receiver.* pointer|invalid pointer or interface receiver"
 
 type I interface{}
 type I1 interface{}
 
-func (p I) val() int { return 1 } // ERROR "receiver.*interface"
-func (p *I1) val() int { return 1 } // ERROR "receiver.*interface"
+func (p I) val() int { return 1 } // ERROR "receiver.*interface|invalid pointer or interface receiver"
+func (p *I1) val() int { return 1 } // ERROR "receiver.*interface|invalid pointer or interface receiver"
 
 type Val interface {
 	val() int
diff --git a/test/method3.go b/test/method3.go
index 7946a8750..fd6477152 100644
--- a/test/method3.go
+++ b/test/method3.go
@@ -1,10 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG method3
+// run
 
 // Copyright 2009 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.
 
-// test that methods on slices work
+// Test methods on slices.
 
 package main
 
diff --git a/test/method4.go b/test/method4.go
new file mode 100644
index 000000000..77e409b91
--- /dev/null
+++ b/test/method4.go
@@ -0,0 +1,106 @@
+// $G $D/method4a.go && $G $D/$F.go && $L $F.$A && ./$A.out
+
+// Copyright 2012 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.
+
+// Test method expressions with arguments.
+
+package main
+
+import "./method4a"
+
+type T1 int
+
+type T2 struct {
+	f int
+}
+
+type I1 interface {
+	Sum([]int, int) int
+}
+
+type I2 interface {
+	Sum(a []int, b int) int
+}
+
+func (i T1) Sum(a []int, b int) int {
+	r := int(i) + b
+	for _, v := range a {
+		r += v
+	}
+	return r
+}
+
+func (p *T2) Sum(a []int, b int) int {
+	r := p.f + b
+	for _, v := range a {
+		r += v
+	}
+	return r
+}
+
+func eq(v1, v2 int) {
+	if v1 != v2 {
+		panic(0)
+	}
+}
+
+func main() {
+	a := []int{1, 2, 3}
+	t1 := T1(4)
+	t2 := &T2{4}
+
+	eq(t1.Sum(a, 5), 15)
+	eq(t2.Sum(a, 6), 16)
+
+	eq(T1.Sum(t1, a, 7), 17)
+	eq((*T2).Sum(t2, a, 8), 18)
+
+	f1 := T1.Sum
+	eq(f1(t1, a, 9), 19)
+	f2 := (*T2).Sum
+	eq(f2(t2, a, 10), 20)
+
+	eq(I1.Sum(t1, a, 11), 21)
+	eq(I1.Sum(t2, a, 12), 22)
+
+	f3 := I1.Sum
+	eq(f3(t1, a, 13), 23)
+	eq(f3(t2, a, 14), 24)
+
+	eq(I2.Sum(t1, a, 15), 25)
+	eq(I2.Sum(t2, a, 16), 26)
+
+	f4 := I2.Sum
+	eq(f4(t1, a, 17), 27)
+	eq(f4(t2, a, 18), 28)
+	
+	mt1 := method4a.T1(4)
+	mt2 := &method4a.T2{4}
+
+	eq(mt1.Sum(a, 30), 40)
+	eq(mt2.Sum(a, 31), 41)
+
+	eq(method4a.T1.Sum(mt1, a, 32), 42)
+	eq((*method4a.T2).Sum(mt2, a, 33), 43)
+
+	g1 := method4a.T1.Sum
+	eq(g1(mt1, a, 34), 44)
+	g2 := (*method4a.T2).Sum
+	eq(g2(mt2, a, 35), 45)
+
+	eq(method4a.I1.Sum(mt1, a, 36), 46)
+	eq(method4a.I1.Sum(mt2, a, 37), 47)
+
+	g3 := method4a.I1.Sum
+	eq(g3(mt1, a, 38), 48)
+	eq(g3(mt2, a, 39), 49)
+
+	eq(method4a.I2.Sum(mt1, a, 40), 50)
+	eq(method4a.I2.Sum(mt2, a, 41), 51)
+
+	g4 := method4a.I2.Sum
+	eq(g4(mt1, a, 42), 52)
+	eq(g4(mt2, a, 43), 53)
+}
diff --git a/test/method4a.go b/test/method4a.go
new file mode 100644
index 000000000..d23039bfa
--- /dev/null
+++ b/test/method4a.go
@@ -0,0 +1,40 @@
+// skip
+
+// Copyright 2012 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.
+
+// Test method expressions with arguments.
+// This file is not tested by itself; it is imported by method4.go.
+
+package method4a
+
+type T1 int
+
+type T2 struct {
+	F int
+}
+
+type I1 interface {
+	Sum([]int, int) int
+}
+
+type I2 interface {
+	Sum(a []int, b int) int
+}
+
+func (i T1) Sum(a []int, b int) int {
+	r := int(i) + b
+	for _, v := range a {
+		r += v
+	}
+	return r
+}
+
+func (p *T2) Sum(a []int, b int) int {
+	r := p.F + b
+	for _, v := range a {
+		r += v
+	}
+	return r
+}
diff --git a/test/named.go b/test/named.go
index 5b6bb81fe..d0330ab23 100644
--- a/test/named.go
+++ b/test/named.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/named1.go b/test/named1.go
index 7e7aab9c1..62b874c5c 100644
--- a/test/named1.go
+++ b/test/named1.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -6,6 +6,7 @@
 
 // Test that basic operations on named types are valid
 // and preserve the type.
+// Does not compile.
 
 package main
 
@@ -37,11 +38,10 @@ func main() {
 	asBool(true)
 	asBool(*&b)
 	asBool(Bool(true))
-	asBool(1 != 2) // ERROR "cannot use.*type bool.*as type Bool"
-	asBool(i < j)  // ERROR "cannot use.*type bool.*as type Bool"
+	asBool(1 != 2) // ok now
+	asBool(i < j)  // ok now
 
 	_, b = m[2] // ERROR "cannot .* bool.*type Bool"
-	m[2] = 1, b // ERROR "cannot use.*type Bool.*as type bool"
 
 	var inter interface{}
 	_, b = inter.(Map) // ERROR "cannot .* bool.*type Bool"
@@ -55,8 +55,8 @@ func main() {
 
 	_, bb := <-c
 	asBool(bb) // ERROR "cannot use.*type bool.*as type Bool"
-	_, b = <-c     // ERROR "cannot .* bool.*type Bool"
+	_, b = <-c // ERROR "cannot .* bool.*type Bool"
 	_ = b
 
-	asString(String(slice)) // ERROR "cannot .*type Slice.*type String"
+	asString(String(slice)) // ok
 }
diff --git a/test/nil.go b/test/nil.go
index 30cc2705b..9f7bcbb59 100644
--- a/test/nil.go
+++ b/test/nil.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test nil.
+
 package main
 
 import (
@@ -150,7 +152,7 @@ func maptest() {
 		m[2] = 3
 	})
 	shouldPanic(func() {
-		m[2] = 0, false
+		delete(m, 2)
 	})
 }
 
diff --git a/test/nilptr.go b/test/nilptr.go
new file mode 100644
index 000000000..b784914e5
--- /dev/null
+++ b/test/nilptr.go
@@ -0,0 +1,132 @@
+// run
+
+// Copyright 2011 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.
+
+// Test that the implementation catches nil ptr indirection
+// in a large address space.
+
+package main
+
+import "unsafe"
+
+// Having a big address space means that indexing
+// at a 256 MB offset from a nil pointer might not
+// cause a memory access fault. This test checks
+// that Go is doing the correct explicit checks to catch
+// these nil pointer accesses, not just relying on the hardware.
+var dummy [256 << 20]byte // give us a big address space
+
+func main() {
+	// the test only tests what we intend to test
+	// if dummy starts in the first 256 MB of memory.
+	// otherwise there might not be anything mapped
+	// at the address that might be accidentally
+	// dereferenced below.
+	if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
+		panic("dummy too far out")
+	}
+
+	shouldPanic(p1)
+	shouldPanic(p2)
+	shouldPanic(p3)
+	shouldPanic(p4)
+	shouldPanic(p5)
+	shouldPanic(p6)
+	shouldPanic(p7)
+	shouldPanic(p8)
+	shouldPanic(p9)
+	shouldPanic(p10)
+}
+
+func shouldPanic(f func()) {
+	defer func() {
+		if recover() == nil {
+			panic("memory reference did not panic")
+		}
+	}()
+	f()
+}
+
+func p1() {
+	// Array index.
+	var p *[1 << 30]byte = nil
+	println(p[256<<20]) // very likely to be inside dummy, but should panic
+}
+
+var xb byte
+
+func p2() {
+	var p *[1 << 30]byte = nil
+	xb = 123
+
+	// Array index.
+	println(p[uintptr(unsafe.Pointer(&xb))]) // should panic
+}
+
+func p3() {
+	// Array to slice.
+	var p *[1 << 30]byte = nil
+	var x []byte = p[0:] // should panic
+	_ = x
+}
+
+var q *[1 << 30]byte
+
+func p4() {
+	// Array to slice.
+	var x []byte
+	var y = &x
+	*y = q[0:] // should crash (uses arraytoslice runtime routine)
+}
+
+func fb([]byte) {
+	panic("unreachable")
+}
+
+func p5() {
+	// Array to slice.
+	var p *[1 << 30]byte = nil
+	fb(p[0:]) // should crash
+}
+
+func p6() {
+	// Array to slice.
+	var p *[1 << 30]byte = nil
+	var _ []byte = p[10 : len(p)-10] // should crash
+}
+
+type T struct {
+	x [256 << 20]byte
+	i int
+}
+
+func f() *T {
+	return nil
+}
+
+var y *T
+var x = &y
+
+func p7() {
+	// Struct field access with large offset.
+	println(f().i) // should crash
+}
+
+func p8() {
+	// Struct field access with large offset.
+	println((*x).i) // should crash
+}
+
+func p9() {
+	// Struct field access with large offset.
+	var t *T
+	println(&t.i) // should crash
+}
+
+func p10() {
+	// Struct field access with large offset.
+	var t *T
+	println(t.i) // should crash
+}
diff --git a/test/nilptr/arrayindex.go b/test/nilptr/arrayindex.go
deleted file mode 100644
index fa26532c6..000000000
--- a/test/nilptr/arrayindex.go
+++ /dev/null
@@ -1,26 +0,0 @@
-// $G $D/$F.go && $L $F.$A &&
-//	((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-
-// Copyright 2009 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.
-
-package main
-
-import "unsafe"
-
-var x byte
-
-func main() {
-	var p *[1<<30]byte = nil
-	x = 123
-
-	// The problem here is not the use of unsafe:
-	// it is that indexing into p[] with a large
-	// enough index jumps out of the unmapped section
-	// at the beginning of memory and into valid memory.
-	// Pointer offsets and array indices, if they are
-	// very large, need to dereference the base pointer
-	// to trigger a trap.
-	println(p[uintptr(unsafe.Pointer(&x))])	// should crash
-}
diff --git a/test/nilptr/arrayindex1.go b/test/nilptr/arrayindex1.go
deleted file mode 100644
index 64f46e14d..000000000
--- a/test/nilptr/arrayindex1.go
+++ /dev/null
@@ -1,31 +0,0 @@
-// $G $D/$F.go && $L $F.$A &&
-//	((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-
-// Copyright 2009 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.
-
-package main
-
-import "unsafe"
-
-var dummy [512<<20]byte	// give us a big address space
-func main() {
-	// the test only tests what we intend to test
-	// if dummy starts in the first 256 MB of memory.
-	// otherwise there might not be anything mapped
-	// at the address that might be accidentally
-	// dereferenced below.
-	if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
-		panic("dummy too far out")
-	}
-
-	// The problem here is that indexing into p[] with a large
-	// enough index jumps out of the unmapped section
-	// at the beginning of memory and into valid memory.
-	// Pointer offsets and array indices, if they are
-	// very large, need to dereference the base pointer
-	// to trigger a trap.
-	var p *[1<<30]byte = nil
-	println(p[256<<20])	// very likely to be inside dummy, but should crash
-}
diff --git a/test/nilptr/arraytoslice.go b/test/nilptr/arraytoslice.go
deleted file mode 100644
index 03879fb42..000000000
--- a/test/nilptr/arraytoslice.go
+++ /dev/null
@@ -1,36 +0,0 @@
-// $G $D/$F.go && $L $F.$A &&
-//	((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-
-// Copyright 2009 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.
-
-package main
-
-import "unsafe"
-
-func f([]byte) {
-	panic("unreachable")
-}
-
-var dummy [512<<20]byte	// give us a big address space
-func main() {
-	// the test only tests what we intend to test
-	// if dummy starts in the first 256 MB of memory.
-	// otherwise there might not be anything mapped
-	// at the address that might be accidentally
-	// dereferenced below.
-	if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
-		panic("dummy too far out")
-	}
-
-	// The problem here is that indexing into p[] with a large
-	// enough index can jump out of the unmapped section
-	// at the beginning of memory and into valid memory.
-	//
-	// To avoid needing a check on every slice beyond the
-	// usual len and cap, we require the *array -> slice
-	// conversion to do the check.
-	var p *[1<<30]byte = nil
-	f(p[0:])	// should crash
-}
diff --git a/test/nilptr/arraytoslice1.go b/test/nilptr/arraytoslice1.go
deleted file mode 100644
index c86070fa4..000000000
--- a/test/nilptr/arraytoslice1.go
+++ /dev/null
@@ -1,33 +0,0 @@
-// $G $D/$F.go && $L $F.$A &&
-//	((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-
-// Copyright 2009 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.
-
-package main
-
-import "unsafe"
-
-var dummy [512<<20]byte	// give us a big address space
-func main() {
-	// the test only tests what we intend to test
-	// if dummy starts in the first 256 MB of memory.
-	// otherwise there might not be anything mapped
-	// at the address that might be accidentally
-	// dereferenced below.
-	if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
-		panic("dummy too far out")
-	}
-
-	// The problem here is that indexing into p[] with a large
-	// enough index can jump out of the unmapped section
-	// at the beginning of memory and into valid memory.
-	//
-	// To avoid needing a check on every slice beyond the
-	// usual len and cap, we require the *array -> slice
-	// conversion to do the check.
-	var p *[1<<30]byte = nil
-	var x []byte = p[0:]	// should crash
-	_ = x
-}
diff --git a/test/nilptr/arraytoslice2.go b/test/nilptr/arraytoslice2.go
deleted file mode 100644
index 68ea44083..000000000
--- a/test/nilptr/arraytoslice2.go
+++ /dev/null
@@ -1,34 +0,0 @@
-// $G $D/$F.go && $L $F.$A &&
-//	((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-
-// Copyright 2009 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.
-
-package main
-
-import "unsafe"
-
-var dummy [512<<20]byte	// give us a big address space
-var q *[1<<30]byte
-func main() {
-	// the test only tests what we intend to test
-	// if dummy starts in the first 256 MB of memory.
-	// otherwise there might not be anything mapped
-	// at the address that might be accidentally
-	// dereferenced below.
-	if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
-		panic("dummy too far out")
-	}
-
-	// The problem here is that indexing into p[] with a large
-	// enough index can jump out of the unmapped section
-	// at the beginning of memory and into valid memory.
-	//
-	// To avoid needing a check on every slice beyond the
-	// usual len and cap, we require the *array -> slice
-	// conversion to do the check.
-	var x []byte
-	var y = &x
-	*y = q[0:]	// should crash (uses arraytoslice runtime routine)
-}
diff --git a/test/nilptr/slicearray.go b/test/nilptr/slicearray.go
deleted file mode 100644
index 26ca42773..000000000
--- a/test/nilptr/slicearray.go
+++ /dev/null
@@ -1,32 +0,0 @@
-// $G $D/$F.go && $L $F.$A &&
-//	((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-
-// Copyright 2009 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.
-
-package main
-
-import "unsafe"
-
-var dummy [512<<20]byte	// give us a big address space
-func main() {
-	// the test only tests what we intend to test
-	// if dummy starts in the first 256 MB of memory.
-	// otherwise there might not be anything mapped
-	// at the address that might be accidentally
-	// dereferenced below.
-	if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
-		panic("dummy too far out")
-	}
-
-	// The problem here is that indexing into p[] with a large
-	// enough index can jump out of the unmapped section
-	// at the beginning of memory and into valid memory.
-	//
-	// To avoid needing a check on every slice beyond the
-	// usual len and cap, we require the slice operation
-	// to do the check.
-	var p *[1<<30]byte = nil
-	var _ []byte = p[10:len(p)-10]	// should crash
-}
diff --git a/test/nilptr/structfield.go b/test/nilptr/structfield.go
deleted file mode 100644
index 35196bb68..000000000
--- a/test/nilptr/structfield.go
+++ /dev/null
@@ -1,34 +0,0 @@
-// $G $D/$F.go && $L $F.$A &&
-//	((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-
-// Copyright 2009 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.
-
-package main
-
-import "unsafe"
-
-var dummy [512<<20]byte	// give us a big address space
-type T struct {
-	x [256<<20] byte
-	i int
-}
-
-func main() {
-	// the test only tests what we intend to test
-	// if dummy starts in the first 256 MB of memory.
-	// otherwise there might not be anything mapped
-	// at the address that might be accidentally
-	// dereferenced below.
-	if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
-		panic("dummy too far out")
-	}
-
-	// The problem here is that indexing into t with a large
-	// enough index can jump out of the unmapped section
-	// at the beginning of memory and into valid memory.
-	// We require the pointer dereference to check.
-	var t *T
-	println(t.i)	// should crash
-}
diff --git a/test/nilptr/structfield1.go b/test/nilptr/structfield1.go
deleted file mode 100644
index 7c7abed1a..000000000
--- a/test/nilptr/structfield1.go
+++ /dev/null
@@ -1,37 +0,0 @@
-// $G $D/$F.go && $L $F.$A &&
-//	((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-
-// Copyright 2009 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.
-
-package main
-
-import "unsafe"
-
-var dummy [512<<20]byte	// give us a big address space
-type T struct {
-	x [256<<20] byte
-	i int
-}
-
-func f() *T {
-	return nil
-}
-
-func main() {
-	// the test only tests what we intend to test
-	// if dummy starts in the first 256 MB of memory.
-	// otherwise there might not be anything mapped
-	// at the address that might be accidentally
-	// dereferenced below.
-	if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
-		panic("dummy too far out")
-	}
-
-	// The problem here is that indexing into t with a large
-	// enough index can jump out of the unmapped section
-	// at the beginning of memory and into valid memory.
-	// We require the pointer dereference to check.
-	println(f().i)	// should crash
-}
diff --git a/test/nilptr/structfield2.go b/test/nilptr/structfield2.go
deleted file mode 100644
index 02a44f173..000000000
--- a/test/nilptr/structfield2.go
+++ /dev/null
@@ -1,36 +0,0 @@
-// $G $D/$F.go && $L $F.$A &&
-//	((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-
-// Copyright 2009 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.
-
-package main
-
-import "unsafe"
-
-var dummy [512<<20]byte	// give us a big address space
-type T struct {
-	x [256<<20] byte
-	i int
-}
-
-var y *T
-var x = &y
-
-func main() {
-	// the test only tests what we intend to test
-	// if dummy starts in the first 256 MB of memory.
-	// otherwise there might not be anything mapped
-	// at the address that might be accidentally
-	// dereferenced below.
-	if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
-		panic("dummy too far out")
-	}
-
-	// The problem here is that indexing into t with a large
-	// enough index can jump out of the unmapped section
-	// at the beginning of memory and into valid memory.
-	// We require the pointer dereference to check.
-	println((*x).i)	// should crash
-}
diff --git a/test/nilptr/structfieldaddr.go b/test/nilptr/structfieldaddr.go
deleted file mode 100644
index f3177bafb..000000000
--- a/test/nilptr/structfieldaddr.go
+++ /dev/null
@@ -1,34 +0,0 @@
-// $G $D/$F.go && $L $F.$A &&
-//	((! sh -c ./$A.out) >/dev/null 2>&1 || echo BUG: should fail)
-
-// Copyright 2009 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.
-
-package main
-
-import "unsafe"
-
-var dummy [512<<20]byte	// give us a big address space
-type T struct {
-	x [256<<20] byte
-	i int
-}
-
-func main() {
-	// the test only tests what we intend to test
-	// if dummy starts in the first 256 MB of memory.
-	// otherwise there might not be anything mapped
-	// at the address that might be accidentally
-	// dereferenced below.
-	if uintptr(unsafe.Pointer(&dummy)) > 256<<20 {
-		panic("dummy too far out")
-	}
-
-	// The problem here is that indexing into t with a large
-	// enough index can jump out of the unmapped section
-	// at the beginning of memory and into valid memory.
-	// We require the address calculation to check.
-	var t *T
-	println(&t.i)	// should crash
-}
diff --git a/test/parentype.go b/test/parentype.go
index 1872cd0eb..eafa07648 100644
--- a/test/parentype.go
+++ b/test/parentype.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2009 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.
 
+// Test that types can be parenthesized.
+
 package main
 
 func f(interface{})
diff --git a/test/peano.go b/test/peano.go
index f4c59d1e1..745f5153f 100644
--- a/test/peano.go
+++ b/test/peano.go
@@ -1,14 +1,16 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test that heavy recursion works. Simple torture test for
+// segmented stacks: do math in unary by recursion.
+
 package main
 
 type Number *Number
 
-
 // -------------------------------------
 // Peano primitives
 
@@ -16,24 +18,20 @@ func zero() *Number {
 	return nil
 }
 
-
 func is_zero(x *Number) bool {
 	return x == nil
 }
 
-
 func add1(x *Number) *Number {
 	e := new(Number)
 	*e = x
 	return e
 }
 
-
 func sub1(x *Number) *Number {
 	return *x
 }
 
-
 func add(x, y *Number) *Number {
 	if is_zero(y) {
 		return x
@@ -42,7 +40,6 @@ func add(x, y *Number) *Number {
 	return add(add1(x), sub1(y))
 }
 
-
 func mul(x, y *Number) *Number {
 	if is_zero(x) || is_zero(y) {
 		return zero()
@@ -51,7 +48,6 @@ func mul(x, y *Number) *Number {
 	return add(mul(x, sub1(y)), x)
 }
 
-
 func fact(n *Number) *Number {
 	if is_zero(n) {
 		return add1(zero())
@@ -60,7 +56,6 @@ func fact(n *Number) *Number {
 	return mul(fact(sub1(n)), n)
 }
 
-
 // -------------------------------------
 // Helpers to generate/count Peano integers
 
@@ -72,7 +67,6 @@ func gen(n int) *Number {
 	return zero()
 }
 
-
 func count(x *Number) int {
 	if is_zero(x) {
 		return 0
@@ -81,7 +75,6 @@ func count(x *Number) int {
 	return count(sub1(x)) + 1
 }
 
-
 func check(x *Number, expected int) {
 	var c = count(x)
 	if c != expected {
@@ -90,7 +83,6 @@ func check(x *Number, expected int) {
 	}
 }
 
-
 // -------------------------------------
 // Test basic functionality
 
@@ -115,12 +107,19 @@ func init() {
 	check(fact(gen(5)), 120)
 }
 
-
 // -------------------------------------
 // Factorial
 
+var results = [...]int{
+	1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800,
+	39916800, 479001600,
+}
+
 func main() {
 	for i := 0; i <= 9; i++ {
-		print(i, "! = ", count(fact(gen(i))), "\n")
+		if f := count(fact(gen(i))); f != results[i] {
+			println("FAIL:", i, "!:", f, "!=", results[i])
+			panic(0)
+		}
 	}
 }
diff --git a/test/printbig.go b/test/printbig.go
index bbb707004..5693c58d4 100644
--- a/test/printbig.go
+++ b/test/printbig.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// cmpout
 
 // Copyright 2009 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.
 
+// Test that big numbers work as constants and print can print them.
+
 package main
 
 func main() {
diff --git a/test/printbig.out b/test/printbig.out
new file mode 100644
index 000000000..6a16b15d9
--- /dev/null
+++ b/test/printbig.out
@@ -0,0 +1,2 @@
+-9223372036854775808
+9223372036854775807
diff --git a/test/range.go b/test/range.go
index 91ccd6307..b0f3ae605 100644
--- a/test/range.go
+++ b/test/range.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test the 'for range' construct.
+
 package main
 
 // test range over channels
@@ -172,7 +174,7 @@ func makestring() string {
 }
 
 func teststring() {
-	s := 0
+	var s rune
 	nmake = 0
 	for _, v := range makestring() {
 		s += v
@@ -208,7 +210,7 @@ func teststring1() {
 
 func makemap() map[int]int {
 	nmake++
-	return map[int]int{0:'a', 1:'b', 2:'c', 3:'d', 4:'☺'}
+	return map[int]int{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: '☺'}
 }
 
 func testmap() {
diff --git a/test/recover.go b/test/recover.go
index ca6f07288..eea655ec5 100644
--- a/test/recover.go
+++ b/test/recover.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -244,3 +244,30 @@ func test7() {
 		die()
 	}
 }
+
+func varargs(s *int, a ...int) {
+	*s = 0
+	for _, v := range a {
+		*s += v
+	}
+	if recover() != nil {
+		*s += 100
+	}
+}
+
+func test8a() (r int) {
+	defer varargs(&r, 1, 2, 3)
+	panic(0)
+}
+
+func test8b() (r int) {
+	defer varargs(&r, 4, 5, 6)
+	return
+}
+
+func test8() {
+	if test8a() != 106 || test8b() != 15 {
+		println("wrong value")
+		die()
+	}
+}
diff --git a/test/recover1.go b/test/recover1.go
index db584738b..b763a1074 100644
--- a/test/recover1.go
+++ b/test/recover1.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/recover2.go b/test/recover2.go
index 9affe25d4..946d05ae6 100644
--- a/test/recover2.go
+++ b/test/recover2.go
@@ -1,4 +1,4 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
@@ -11,10 +11,7 @@
 
 package main
 
-import (
-	"os"
-	"strings"
-)
+import "strings"
 
 var x = make([]byte, 10)
 
@@ -33,7 +30,7 @@ func mustRecover(s string) {
 	if v == nil {
 		panic("expected panic")
 	}
-	if e := v.(os.Error).String(); strings.Index(e, s) < 0 {
+	if e := v.(error).Error(); strings.Index(e, s) < 0 {
 		panic("want: " + s + "; have: " + e)
 	}
 }
@@ -63,6 +60,7 @@ func test4() {
 
 type T struct {
 	a, b int
+	c    []int
 }
 
 func test5() {
diff --git a/test/recover3.go b/test/recover3.go
index 2aa1df616..98700231e 100644
--- a/test/recover3.go
+++ b/test/recover3.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // 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.
 
+// Test recovering from runtime errors.
+
 package main
 
 import (
@@ -35,7 +37,7 @@ func check(name string, f func(), err string) {
 			println(name, "panicked but not with runtime.Error")
 			return
 		}
-		s := runt.String()
+		s := runt.Error()
 		if strings.Index(s, err) < 0 {
 			bug()
 			println(name, "panicked with", s, "not", err)
diff --git a/test/rename.go b/test/rename.go
index f21ef015b..e54427455 100644
--- a/test/rename.go
+++ b/test/rename.go
@@ -1,73 +1,99 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test that predeclared names can be redeclared by the user.
+
 package main
 
 import "fmt"
 
 func main() {
 	n :=
-		bool +
+		append +
+			bool +
 			byte +
-			float +
+			complex +
+			complex64 +
+			complex128 +
+			cap +
+			close +
+			delete +
+			error +
+			false +
 			float32 +
 			float64 +
+			imag +
 			int +
 			int8 +
 			int16 +
 			int32 +
 			int64 +
+			len +
+			make +
+			new +
+			nil +
+			panic +
+			print +
+			println +
+			real +
+			recover +
+			rune +
+			string +
+			true +
 			uint +
 			uint8 +
 			uint16 +
 			uint32 +
 			uint64 +
 			uintptr +
-			true +
-			false +
-			iota +
-			nil +
-			cap +
-			len +
-			make +
-			new +
-			panic +
-			print +
-			println
-	if n != 27*28/2 {
-		fmt.Println("BUG: wrong n", n, 27*28/2)
+			iota
+	if n != NUM*(NUM-1)/2 {
+		fmt.Println("BUG: wrong n", n, NUM*(NUM-1)/2)
 	}
 }
 
 const (
-	bool    = 1
-	byte    = 2
-	float   = 3
-	float32 = 4
-	float64 = 5
-	int     = 6
-	int8    = 7
-	int16   = 8
-	int32   = 9
-	int64   = 10
-	uint    = 11
-	uint8   = 12
-	uint16  = 13
-	uint32  = 14
-	uint64  = 15
-	uintptr = 16
-	true    = 17
-	false   = 18
-	iota    = 19
-	nil     = 20
-	cap     = 21
-	len     = 22
-	make    = 23
-	new     = 24
-	panic   = 25
-	print   = 26
-	println = 27
+	// cannot use iota here, because iota = 38 below
+	append     = 1
+	bool       = 2
+	byte       = 3
+	complex    = 4
+	complex64  = 5
+	complex128 = 6
+	cap        = 7
+	close      = 8
+	delete     = 9
+	error      = 10
+	false      = 11
+	float32    = 12
+	float64    = 13
+	imag       = 14
+	int        = 15
+	int8       = 16
+	int16      = 17
+	int32      = 18
+	int64      = 19
+	len        = 20
+	make       = 21
+	new        = 22
+	nil        = 23
+	panic      = 24
+	print      = 25
+	println    = 26
+	real       = 27
+	recover    = 28
+	rune       = 29
+	string     = 30
+	true       = 31
+	uint       = 32
+	uint8      = 33
+	uint16     = 34
+	uint32     = 35
+	uint64     = 36
+	uintptr    = 37
+	iota       = 38
+	NUM        = 39
 )
diff --git a/test/rename1.go b/test/rename1.go
index 3e78bfca0..53db68de1 100644
--- a/test/rename1.go
+++ b/test/rename1.go
@@ -1,14 +1,17 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Verify that renamed identifiers no longer have their old meaning.
+// Does not compile.
+
 package main
 
 func main() {
 	var n byte       // ERROR "not a type|expected type"
-	var y = float(0) // ERROR "cannot call|expected function"
+	var y = float32(0) // ERROR "cannot call|expected function"
 	const (
 		a = 1 + iota // ERROR "string|incompatible types" "convert iota"
 	)
@@ -16,31 +19,42 @@ func main() {
 }
 
 const (
-	bool    = 1
-	byte    = 2
-	float   = 3
-	float32 = 4
-	float64 = 5
-	int     = 6
-	int8    = 7
-	int16   = 8
-	int32   = 9
-	int64   = 10
-	uint    = 11
-	uint8   = 12
-	uint16  = 13
-	uint32  = 14
-	uint64  = 15
-	uintptr = 16
-	true    = 17
-	false   = 18
-	iota    = "abc"
-	nil     = 20
-	cap     = 21
-	len     = 22
-	make    = 23
-	new     = 24
-	panic   = 25
-	print   = 26
-	println = 27
+	append     = 1
+	bool       = 2
+	byte       = 3
+	complex    = 4
+	complex64  = 5
+	complex128 = 6
+	cap        = 7
+	close      = 8
+	delete     = 9
+	error      = 10
+	false      = 11
+	float32    = 12
+	float64    = 13
+	imag       = 14
+	int        = 15
+	int8       = 16
+	int16      = 17
+	int32      = 18
+	int64      = 19
+	len        = 20
+	make       = 21
+	new        = 22
+	nil        = 23
+	panic      = 24
+	print      = 25
+	println    = 26
+	real       = 27
+	recover    = 28
+	rune       = 29
+	string     = 30
+	true       = 31
+	uint       = 32
+	uint8      = 33
+	uint16     = 34
+	uint32     = 35
+	uint64     = 36
+	uintptr    = 37
+	iota       = "38"
 )
diff --git a/test/reorder.go b/test/reorder.go
new file mode 100644
index 000000000..007039e8a
--- /dev/null
+++ b/test/reorder.go
@@ -0,0 +1,121 @@
+// run
+
+// Copyright 2011 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.
+
+// Test reordering of assignments.
+
+package main
+
+import "fmt"
+
+func main() {
+	p1()
+	p2()
+	p3()
+	p4()
+	p5()
+	p6()
+	p7()
+	p8()
+}
+
+var gx []int
+
+func f(i int) int {
+	return gx[i]
+}
+
+func check(x []int, x0, x1, x2 int) {
+	if x[0] != x0 || x[1] != x1 || x[2] != x2 {
+		fmt.Printf("%v, want %d,%d,%d\n", x, x0, x1, x2)
+		panic("failed")
+	}
+}
+
+func check3(x, y, z, xx, yy, zz int) {
+	if x != xx || y != yy || z != zz {
+		fmt.Printf("%d,%d,%d, want %d,%d,%d\n", x, y, z, xx, yy, zz)
+		panic("failed")
+	}
+}
+
+func p1() {
+	x := []int{1,2,3}
+	i := 0
+	i, x[i] = 1, 100
+	_ = i
+	check(x, 100, 2, 3)
+}
+
+func p2() {
+	x := []int{1,2,3}
+	i := 0
+	x[i], i = 100, 1
+	_ = i
+	check(x, 100, 2, 3)
+}
+
+func p3() {
+	x := []int{1,2,3}
+	y := x
+	gx = x
+	x[1], y[0] = f(0), f(1)
+	check(x, 2, 1, 3)
+}
+
+func p4() {
+	x := []int{1,2,3}
+	y := x
+	gx = x
+	x[1], y[0] = gx[0], gx[1]
+	check(x, 2, 1, 3)
+}
+
+func p5() {
+	x := []int{1,2,3}
+	y := x
+	p := &x[0]
+	q := &x[1]
+	*p, *q = x[1], y[0]
+	check(x, 2, 1, 3)
+}
+
+func p6() {
+	x := 1
+	y := 2
+	z := 3
+	px := &x
+	py := &y
+	*px, *py = y, x
+	check3(x, y, z, 2, 1, 3)	
+}
+
+func f1(x, y, z int) (xx, yy, zz int) {
+	return x, y, z
+}
+
+func f2() (x, y, z int) {
+	return f1(2, 1, 3)
+}
+
+func p7() {
+	x, y, z := f2()
+	check3(x, y, z, 2, 1, 3)
+}
+
+func p8() {
+	x := []int{1,2,3}
+
+	defer func() {
+		err := recover()
+		if err == nil {
+			panic("not panicking")
+		}
+		check(x, 100, 2, 3)
+	}()
+
+	i := 0
+	i, x[i], x[5] = 1, 100, 500
+}
diff --git a/test/reorder2.go b/test/reorder2.go
new file mode 100644
index 000000000..d91f1d895
--- /dev/null
+++ b/test/reorder2.go
@@ -0,0 +1,174 @@
+// run
+
+// 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.
+
+// Test reorderings; derived from fixedbugs/bug294.go.
+
+package main
+
+var log string
+
+type TT int
+
+func (t TT) a(s string) TT {
+	log += "a(" + s + ")"
+	return t
+}
+
+func (TT) b(s string) string {
+	log += "b(" + s + ")"
+	return s
+}
+
+type F func(s string) F
+
+func a(s string) F {
+	log += "a(" + s + ")"
+	return F(a)
+}
+
+func b(s string) string {
+	log += "b(" + s + ")"
+	return s
+}
+
+type I interface {
+	a(s string) I
+	b(s string) string
+}
+
+type T1 int
+
+func (t T1) a(s string) I {
+	log += "a(" + s + ")"
+	return t
+}
+
+func (T1) b(s string) string {
+	log += "b(" + s + ")"
+	return s
+}
+
+// f(g(), h()) where g is not inlinable but h is will have the same problem.
+// As will x := g() + h() (same conditions).
+// And g() <- h().
+func f(x, y string) {
+	log += "f(" + x + ", " + y + ")"
+}
+
+func ff(x, y string) {
+	for false {
+	} // prevent inl
+	log += "ff(" + x + ", " + y + ")"
+}
+
+func h(x string) string {
+	log += "h(" + x + ")"
+	return x
+}
+
+func g(x string) string {
+	for false {
+	} // prevent inl
+	log += "g(" + x + ")"
+	return x
+}
+
+func main() {
+	err := 0
+	var t TT
+	if a("1")("2")("3"); log != "a(1)a(2)a(3)" {
+		println("expecting a(1)a(2)a(3) , got ", log)
+		err++
+	}
+	log = ""
+
+	if t.a("1").a(t.b("2")); log != "a(1)b(2)a(2)" {
+		println("expecting a(1)b(2)a(2), got ", log)
+		err++
+	}
+	log = ""
+	if a("3")(b("4"))(b("5")); log != "a(3)b(4)a(4)b(5)a(5)" {
+		println("expecting a(3)b(4)a(4)b(5)a(5), got ", log)
+		err++
+	}
+	log = ""
+	var i I = T1(0)
+	if i.a("6").a(i.b("7")).a(i.b("8")).a(i.b("9")); log != "a(6)b(7)a(7)b(8)a(8)b(9)a(9)" {
+		println("expecting a(6)ba(7)ba(8)ba(9), got", log)
+		err++
+	}
+	log = ""
+
+	if s := t.a("1").b("3"); log != "a(1)b(3)" || s != "3" {
+		println("expecting a(1)b(3) and 3, got ", log, " and ", s)
+		err++
+	}
+	log = ""
+
+	if s := t.a("1").a(t.b("2")).b("3") + t.a("4").b("5"); log != "a(1)b(2)a(2)b(3)a(4)b(5)" || s != "35" {
+		println("expecting a(1)b(2)a(2)b(3)a(4)b(5) and 35, got ", log, " and ", s)
+		err++
+	}
+	log = ""
+
+	if s := t.a("4").b("5") + t.a("1").a(t.b("2")).b("3"); log != "a(4)b(5)a(1)b(2)a(2)b(3)" || s != "53" {
+		println("expecting a(4)b(5)a(1)b(2)a(2)b(3) and 35, got ", log, " and ", s)
+		err++
+	}
+	log = ""
+
+	if ff(g("1"), g("2")); log != "g(1)g(2)ff(1, 2)" {
+		println("expecting g(1)g(2)ff..., got ", log)
+		err++
+	}
+	log = ""
+
+	if ff(g("1"), h("2")); log != "g(1)h(2)ff(1, 2)" {
+		println("expecting g(1)h(2)ff..., got ", log)
+		err++
+	}
+	log = ""
+
+	if ff(h("1"), g("2")); log != "h(1)g(2)ff(1, 2)" {
+		println("expecting h(1)g(2)ff..., got ", log)
+		err++
+	}
+	log = ""
+
+	if ff(h("1"), h("2")); log != "h(1)h(2)ff(1, 2)" {
+		println("expecting h(1)h(2)ff..., got ", log)
+		err++
+	}
+	log = ""
+
+	if s := g("1") + g("2"); log != "g(1)g(2)" || s != "12" {
+		println("expecting g1g2 and 12, got ", log, " and ", s)
+		err++
+	}
+	log = ""
+
+	if s := g("1") + h("2"); log != "g(1)h(2)" || s != "12" {
+		println("expecting g1h2 and 12, got ", log, " and ", s)
+		err++
+	}
+	log = ""
+
+	if s := h("1") + g("2"); log != "h(1)g(2)" || s != "12" {
+		println("expecting h1g2 and 12, got ", log, " and ", s)
+		err++
+	}
+	log = ""
+
+	if s := h("1") + h("2"); log != "h(1)h(2)" || s != "12" {
+		println("expecting h1h2 and 12, got ", log, " and ", s)
+		err++
+	}
+	log = ""
+
+	if err > 0 {
+		panic("fail")
+	}
+}
diff --git a/test/run b/test/run
index fce4d012f..302578eaa 100755
--- a/test/run
+++ b/test/run
@@ -3,8 +3,8 @@
 # Use of this source code is governed by a BSD-style
 # license that can be found in the LICENSE file.
 
-eval $(gomake --no-print-directory -f ../src/Make.inc go-env)
-
+eval $(go tool dist env)
+export GOARCH GOOS GOROOT
 export E=
 
 case X"$GOARCH" in
@@ -23,19 +23,24 @@ Xarm)
 	exit 1
 esac
 
-export G=${A}g
+export G="${A}g ${GCFLAGS}"
 export L=${A}l
 export GOTRACEBACK=0
 export LANG=C
 unset GREP_OPTIONS	# in case user has a non-standard set
 
+unset GOROOT_FINAL  # breaks ./ imports
+
 failed=0
 
-PATH=/bin:/usr/bin:/usr/local/bin:${GOBIN:-$GOROOT/bin}:`pwd`
+PATH=${GOBIN:-$GOROOT/bin}:`pwd`:/bin:/usr/bin:/usr/local/bin
+
+# TODO: We add the tool directory to the PATH to avoid thinking about a better way.
+PATH="$GOTOOLDIR:$PATH"
 
-RUNFILE="/tmp/gorun-$$-$USER"
-TMP1FILE="/tmp/gotest1-$$-$USER"
-TMP2FILE="/tmp/gotest2-$$-$USER"
+RUNFILE="${TMPDIR:-/tmp}/gorun-$$-$USER"
+TMP1FILE="${TMPDIR:-/tmp}/gotest1-$$-$USER"
+TMP2FILE="${TMPDIR:-/tmp}/gotest2-$$-$USER"
 
 # don't run the machine out of memory: limit individual processes to 4GB.
 # on thresher, 3GB suffices to run the tests; with 2GB, peano fails.
@@ -53,7 +58,7 @@ filterout() {
 	grep '^'"$2"'$' $1 >/dev/null
 }
 
-for dir in . ken chan interface nilptr syntax dwarf fixedbugs bugs
+for dir in . ken chan interface syntax dwarf safe fixedbugs bugs
 do
 	echo
 	echo '==' $dir'/'
@@ -64,7 +69,8 @@ do
 		fi
 		export F=$(basename $i .go)
 		export D=$dir
-		sed '/^\/\//!q' $i | sed 's@//@@; $d' |sed 's|./\$A.out|$E &|g' >"$RUNFILE"
+		echo '. ./testlib' >"$RUNFILE"
+		sed '/^\/\//!q' $i | sed 's@//@@; $d' |sed 's|./\$A.out|$E &|g' >>"$RUNFILE"
 		if ! { time -p bash -c "bash '$RUNFILE' >'$TMP1FILE' 2>&1" ; } 2>"$TMP2FILE"
 		then
 			echo
diff --git a/test/run.go b/test/run.go
new file mode 100644
index 000000000..ac6e3c0e2
--- /dev/null
+++ b/test/run.go
@@ -0,0 +1,465 @@
+// skip
+
+// Copyright 2012 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.
+
+// Run runs tests in the test directory.
+// 
+// TODO(bradfitz): docs of some sort, once we figure out how we're changing
+// headers of files
+package main
+
+import (
+	"bytes"
+	"errors"
+	"flag"
+	"fmt"
+	"go/build"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"runtime"
+	"sort"
+	"strconv"
+	"strings"
+)
+
+var (
+	verbose     = flag.Bool("v", false, "verbose. if set, parallelism is set to 1.")
+	numParallel = flag.Int("n", runtime.NumCPU(), "number of parallel tests to run")
+	summary     = flag.Bool("summary", false, "show summary of results")
+	showSkips   = flag.Bool("show_skips", false, "show skipped tests")
+)
+
+var (
+	// gc and ld are [568][gl].
+	gc, ld string
+
+	// letter is the build.ArchChar
+	letter string
+
+	// dirs are the directories to look for *.go files in.
+	// TODO(bradfitz): just use all directories?
+	dirs = []string{".", "ken", "chan", "interface", "syntax", "dwarf", "fixedbugs", "bugs"}
+
+	// ratec controls the max number of tests running at a time.
+	ratec chan bool
+
+	// toRun is the channel of tests to run.
+	// It is nil until the first test is started.
+	toRun chan *test
+)
+
+// maxTests is an upper bound on the total number of tests.
+// It is used as a channel buffer size to make sure sends don't block.
+const maxTests = 5000
+
+func main() {
+	flag.Parse()
+
+	// Disable parallelism if printing
+	if *verbose {
+		*numParallel = 1
+	}
+
+	ratec = make(chan bool, *numParallel)
+	var err error
+	letter, err = build.ArchChar(build.Default.GOARCH)
+	check(err)
+	gc = letter + "g"
+	ld = letter + "l"
+
+	var tests []*test
+	if flag.NArg() > 0 {
+		for _, arg := range flag.Args() {
+			if arg == "-" || arg == "--" {
+				// Permit running either:
+				// $ go run run.go - env.go
+				// $ go run run.go -- env.go
+				continue
+			}
+			if !strings.HasSuffix(arg, ".go") {
+				log.Fatalf("can't yet deal with non-go file %q", arg)
+			}
+			dir, file := filepath.Split(arg)
+			tests = append(tests, startTest(dir, file))
+		}
+	} else {
+		for _, dir := range dirs {
+			for _, baseGoFile := range goFiles(dir) {
+				tests = append(tests, startTest(dir, baseGoFile))
+			}
+		}
+	}
+
+	failed := false
+	resCount := map[string]int{}
+	for _, test := range tests {
+		<-test.donec
+		_, isSkip := test.err.(skipError)
+		errStr := "pass"
+		if isSkip {
+			errStr = "skip"
+		}
+		if test.err != nil {
+			errStr = test.err.Error()
+			if !isSkip {
+				failed = true
+			}
+		}
+		resCount[errStr]++
+		if isSkip && !*verbose && !*showSkips {
+			continue
+		}
+		if !*verbose && test.err == nil {
+			continue
+		}
+		fmt.Printf("%-10s %-20s: %s\n", test.action, test.goFileName(), errStr)
+	}
+
+	if *summary {
+		for k, v := range resCount {
+			fmt.Printf("%5d %s\n", v, k)
+		}
+	}
+
+	if failed {
+		os.Exit(1)
+	}
+}
+
+func toolPath(name string) string {
+	p := filepath.Join(os.Getenv("GOROOT"), "bin", "tool", name)
+	if _, err := os.Stat(p); err != nil {
+		log.Fatalf("didn't find binary at %s", p)
+	}
+	return p
+}
+
+func goFiles(dir string) []string {
+	f, err := os.Open(dir)
+	check(err)
+	dirnames, err := f.Readdirnames(-1)
+	check(err)
+	names := []string{}
+	for _, name := range dirnames {
+		if !strings.HasPrefix(name, ".") && strings.HasSuffix(name, ".go") {
+			names = append(names, name)
+		}
+	}
+	sort.Strings(names)
+	return names
+}
+
+// skipError describes why a test was skipped.
+type skipError string
+
+func (s skipError) Error() string { return string(s) }
+
+func check(err error) {
+	if err != nil {
+		log.Fatal(err)
+	}
+}
+
+// test holds the state of a test.
+type test struct {
+	dir, gofile string
+	donec       chan bool // closed when done
+
+	src    string
+	action string // "compile", "build", "run", "errorcheck", "skip"
+
+	tempDir string
+	err     error
+}
+
+// startTest 
+func startTest(dir, gofile string) *test {
+	t := &test{
+		dir:    dir,
+		gofile: gofile,
+		donec:  make(chan bool, 1),
+	}
+	if toRun == nil {
+		toRun = make(chan *test, maxTests)
+		go runTests()
+	}
+	select {
+	case toRun <- t:
+	default:
+		panic("toRun buffer size (maxTests) is too small")
+	}
+	return t
+}
+
+// runTests runs tests in parallel, but respecting the order they
+// were enqueued on the toRun channel.
+func runTests() {
+	for {
+		ratec <- true
+		t := <-toRun
+		go func() {
+			t.run()
+			<-ratec
+		}()
+	}
+}
+
+var cwd, _ = os.Getwd()
+
+func (t *test) goFileName() string {
+	return filepath.Join(t.dir, t.gofile)
+}
+
+// run runs a test.
+func (t *test) run() {
+	defer close(t.donec)
+
+	srcBytes, err := ioutil.ReadFile(t.goFileName())
+	if err != nil {
+		t.err = err
+		return
+	}
+	t.src = string(srcBytes)
+	if t.src[0] == '\n' {
+		t.err = skipError("starts with newline")
+		return
+	}
+	pos := strings.Index(t.src, "\n\n")
+	if pos == -1 {
+		t.err = errors.New("double newline not found")
+		return
+	}
+	action := t.src[:pos]
+	if strings.HasPrefix(action, "//") {
+		action = action[2:]
+	}
+
+	var args []string
+	f := strings.Fields(action)
+	if len(f) > 0 {
+		action = f[0]
+		args = f[1:]
+	}
+
+	switch action {
+	case "cmpout":
+		action = "run" // the run case already looks for <dir>/<test>.out files
+		fallthrough
+	case "compile", "build", "run", "errorcheck":
+		t.action = action
+	case "skip":
+		t.action = "skip"
+		return
+	default:
+		t.err = skipError("skipped; unknown pattern: " + action)
+		t.action = "??"
+		return
+	}
+
+	t.makeTempDir()
+	defer os.RemoveAll(t.tempDir)
+
+	err = ioutil.WriteFile(filepath.Join(t.tempDir, t.gofile), srcBytes, 0644)
+	check(err)
+
+	// A few tests (of things like the environment) require these to be set.
+	os.Setenv("GOOS", runtime.GOOS)
+	os.Setenv("GOARCH", runtime.GOARCH)
+
+	useTmp := true
+	runcmd := func(args ...string) ([]byte, error) {
+		cmd := exec.Command(args[0], args[1:]...)
+		var buf bytes.Buffer
+		cmd.Stdout = &buf
+		cmd.Stderr = &buf
+		if useTmp {
+			cmd.Dir = t.tempDir
+		}
+		err := cmd.Run()
+		return buf.Bytes(), err
+	}
+
+	long := filepath.Join(cwd, t.goFileName())
+	switch action {
+	default:
+		t.err = fmt.Errorf("unimplemented action %q", action)
+
+	case "errorcheck":
+		out, _ := runcmd("go", "tool", gc, "-e", "-o", "a."+letter, long)
+		t.err = t.errorCheck(string(out), long, t.gofile)
+		return
+
+	case "compile":
+		out, err := runcmd("go", "tool", gc, "-e", "-o", "a."+letter, long)
+		if err != nil {
+			t.err = fmt.Errorf("%s\n%s", err, out)
+		}
+
+	case "build":
+		out, err := runcmd("go", "build", "-o", "a.exe", long)
+		if err != nil {
+			t.err = fmt.Errorf("%s\n%s", err, out)
+		}
+
+	case "run":
+		useTmp = false
+		out, err := runcmd(append([]string{"go", "run", t.goFileName()}, args...)...)
+		if err != nil {
+			t.err = fmt.Errorf("%s\n%s", err, out)
+		}
+		if string(out) != t.expectedOutput() {
+			t.err = fmt.Errorf("incorrect output\n%s", out)
+		}
+	}
+}
+
+func (t *test) String() string {
+	return filepath.Join(t.dir, t.gofile)
+}
+
+func (t *test) makeTempDir() {
+	var err error
+	t.tempDir, err = ioutil.TempDir("", "")
+	check(err)
+}
+
+func (t *test) expectedOutput() string {
+	filename := filepath.Join(t.dir, t.gofile)
+	filename = filename[:len(filename)-len(".go")]
+	filename += ".out"
+	b, _ := ioutil.ReadFile(filename)
+	return string(b)
+}
+
+func (t *test) errorCheck(outStr string, full, short string) (err error) {
+	defer func() {
+		if *verbose && err != nil {
+			log.Printf("%s gc output:\n%s", t, outStr)
+		}
+	}()
+	var errs []error
+
+	var out []string
+	// 6g error messages continue onto additional lines with leading tabs.
+	// Split the output at the beginning of each line that doesn't begin with a tab.
+	for _, line := range strings.Split(outStr, "\n") {
+		if strings.HasPrefix(line, "\t") {
+			out[len(out)-1] += "\n" + line
+		} else {
+			out = append(out, line)
+		}
+	}
+
+	// Cut directory name.
+	for i := range out {
+		out[i] = strings.Replace(out[i], full, short, -1)
+	}
+
+	for _, we := range t.wantedErrors() {
+		var errmsgs []string
+		errmsgs, out = partitionStrings(we.filterRe, out)
+		if len(errmsgs) == 0 {
+			errs = append(errs, fmt.Errorf("%s:%d: missing error %q", we.file, we.lineNum, we.reStr))
+			continue
+		}
+		matched := false
+		for _, errmsg := range errmsgs {
+			if we.re.MatchString(errmsg) {
+				matched = true
+			} else {
+				out = append(out, errmsg)
+			}
+		}
+		if !matched {
+			errs = append(errs, fmt.Errorf("%s:%d: no match for %q in%s", we.file, we.lineNum, we.reStr, strings.Join(out, "\n")))
+			continue
+		}
+	}
+
+	if len(errs) == 0 {
+		return nil
+	}
+	if len(errs) == 1 {
+		return errs[0]
+	}
+	var buf bytes.Buffer
+	fmt.Fprintf(&buf, "\n")
+	for _, err := range errs {
+		fmt.Fprintf(&buf, "%s\n", err.Error())
+	}
+	return errors.New(buf.String())
+
+}
+
+func partitionStrings(rx *regexp.Regexp, strs []string) (matched, unmatched []string) {
+	for _, s := range strs {
+		if rx.MatchString(s) {
+			matched = append(matched, s)
+		} else {
+			unmatched = append(unmatched, s)
+		}
+	}
+	return
+}
+
+type wantedError struct {
+	reStr    string
+	re       *regexp.Regexp
+	lineNum  int
+	file     string
+	filterRe *regexp.Regexp // /^file:linenum\b/m
+}
+
+var (
+	errRx       = regexp.MustCompile(`// (?:GC_)?ERROR (.*)`)
+	errQuotesRx = regexp.MustCompile(`"([^"]*)"`)
+	lineRx      = regexp.MustCompile(`LINE(([+-])([0-9]+))?`)
+)
+
+func (t *test) wantedErrors() (errs []wantedError) {
+	for i, line := range strings.Split(t.src, "\n") {
+		lineNum := i + 1
+		if strings.Contains(line, "////") {
+			// double comment disables ERROR
+			continue
+		}
+		m := errRx.FindStringSubmatch(line)
+		if m == nil {
+			continue
+		}
+		all := m[1]
+		mm := errQuotesRx.FindAllStringSubmatch(all, -1)
+		if mm == nil {
+			log.Fatalf("invalid errchk line in %s: %s", t.goFileName(), line)
+		}
+		for _, m := range mm {
+			rx := lineRx.ReplaceAllStringFunc(m[1], func(m string) string {
+				n := lineNum
+				if strings.HasPrefix(m, "LINE+") {
+					delta, _ := strconv.Atoi(m[5:])
+					n += delta
+				} else if strings.HasPrefix(m, "LINE-") {
+					delta, _ := strconv.Atoi(m[5:])
+					n -= delta
+				}
+				return fmt.Sprintf("%s:%d", t.gofile, n)
+			})
+			filterPattern := fmt.Sprintf(`^(\w+/)?%s:%d[:[]`, t.gofile, lineNum)
+			errs = append(errs, wantedError{
+				reStr:    rx,
+				re:       regexp.MustCompile(rx),
+				filterRe: regexp.MustCompile(filterPattern),
+				lineNum:  lineNum,
+				file:     t.gofile,
+			})
+		}
+	}
+
+	return
+}
diff --git a/test/rune.go b/test/rune.go
new file mode 100644
index 000000000..c013c471d
--- /dev/null
+++ b/test/rune.go
@@ -0,0 +1,47 @@
+// compile
+
+// Copyright 2011 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.
+
+// Test rune constants, expressions and types.
+// Compiles but does not run.
+
+package rune
+
+var (
+	r0 = 'a'
+	r1 = 'a'+1
+	r2 = 1+'a'
+	r3 = 'a'*2
+	r4 = 'a'/2
+	r5 = 'a'<<1
+	r6 = 'b'<<2
+	r7 int32
+
+	r = []rune{r0, r1, r2, r3, r4, r5, r6, r7}
+)
+
+var (
+	f0 = 1.2
+	f1 = 1.2/'a'
+
+	f = []float64{f0, f1}
+)
+
+var (
+	i0 = 1
+	i1 = 1<<'\x01'
+	
+	i = []int{i0, i1}
+)
+
+const (
+	maxRune = '\U0010FFFF'
+)
+
+var (
+	b0 = maxRune < r0
+	
+	b = []bool{b0}
+)
diff --git a/test/runtime.go b/test/runtime.go
index 4be1d055b..89f59e3ed 100644
--- a/test/runtime.go
+++ b/test/runtime.go
@@ -1,15 +1,16 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
-// make sure that even if a file imports runtime,
+// Test that even if a file imports runtime,
 // it cannot get at the low-level runtime definitions
-// known to the compiler.  for normal packages
+// known to the compiler.  For normal packages
 // the compiler doesn't even record the lower case
 // functions in its symbol table, but some functions
 // in runtime are hard-coded into the compiler.
+// Does not compile.
 
 package main
 
diff --git a/test/safe/main.go b/test/safe/main.go
new file mode 100644
index 000000000..d173ed926
--- /dev/null
+++ b/test/safe/main.go
@@ -0,0 +1,14 @@
+// true
+
+// Copyright 2012 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.
+
+package main
+
+// can't use local path with -u, use -I. instead
+import "pkg"  // ERROR "import unsafe package"
+
+func main() {
+	print(pkg.Float32bits(1.0))
+}
diff --git a/test/safe/nousesafe.go b/test/safe/nousesafe.go
new file mode 100644
index 000000000..f61e7fe4f
--- /dev/null
+++ b/test/safe/nousesafe.go
@@ -0,0 +1,8 @@
+// $G $D/pkg.go && pack grc pkg.a pkg.$A 2> /dev/null && rm pkg.$A && errchk $G -I. -u $D/main.go
+// rm -f pkg.a
+
+// Copyright 2012 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.
+
+package ignored
diff --git a/test/safe/pkg.go b/test/safe/pkg.go
new file mode 100644
index 000000000..bebc43a21
--- /dev/null
+++ b/test/safe/pkg.go
@@ -0,0 +1,16 @@
+// true
+
+// Copyright 2012 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.
+
+// a package that uses unsafe on the inside but not in it's api
+
+package pkg
+
+import "unsafe"
+
+// this should be inlinable
+func Float32bits(f float32) uint32 {
+	return *(*uint32)(unsafe.Pointer(&f))
+}
+\ No newline at end of file
diff --git a/test/safe/usesafe.go b/test/safe/usesafe.go
new file mode 100644
index 000000000..07c13c1c3
--- /dev/null
+++ b/test/safe/usesafe.go
@@ -0,0 +1,8 @@
+// $G $D/pkg.go && pack grcS pkg.a pkg.$A 2> /dev/null && rm pkg.$A && $G -I. -u $D/main.go
+// rm -f pkg.a
+
+// Copyright 2012 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.
+
+package ignored
diff --git a/test/shift1.go b/test/shift1.go
index 6a8e26e5e..b33d22ff8 100644
--- a/test/shift1.go
+++ b/test/shift1.go
@@ -1,10 +1,12 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2011 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.
 
+// Test illegal shifts.
 // Issue 1708, illegal cases.
+// Does not compile.
 
 package p
 
@@ -15,14 +17,14 @@ func h(x float64) int     { return 0 }
 // from the spec
 var (
 	s uint    = 33
-	u         = 1.0 << s // ERROR "invalid operation"
-	v float32 = 1 << s   // ERROR "invalid operation" "as type float32"
+	u         = 1.0 << s // ERROR "invalid operation|shift of non-integer operand"
+	v float32 = 1 << s   // ERROR "invalid" "as type float32"
 )
 
 // non-constant shift expressions
 var (
-	e1       = g(2.0 << s) // ERROR "invalid operation" "as type interface"
-	f1       = h(2 << s)   // ERROR "invalid operation" "as type float64"
+	e1       = g(2.0 << s) // ERROR "invalid" "as type interface"
+	f1       = h(2 << s)   // ERROR "invalid" "as type float64"
 	g1 int64 = 1.1 << s    // ERROR "truncated"
 )
 
diff --git a/test/shift2.go b/test/shift2.go
index ec4c7addc..88ef3c40f 100644
--- a/test/shift2.go
+++ b/test/shift2.go
@@ -1,10 +1,12 @@
-// $G $D/$F.go || echo BUG: shift2
+// compile
 
 // Copyright 2011 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.
 
+// Test legal shifts.
 // Issue 1708, legal cases.
+// Compiles but does not run.
 
 package p
 
diff --git a/test/sieve.go b/test/sieve.go
index 4fa111582..0cd120c54 100644
--- a/test/sieve.go
+++ b/test/sieve.go
@@ -1,9 +1,12 @@
-// $G $F.go && $L $F.$A  # don't run it - goes forever
+// build
 
 // Copyright 2009 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.
 
+// Test basic concurrency: the classic prime sieve.
+// Do not run - loops forever.
+
 package main
 
 // Send the sequence 2, 3, 4, ... to channel 'ch'.
diff --git a/test/sigchld.go b/test/sigchld.go
index 1fb2e21bd..25625a6f4 100644
--- a/test/sigchld.go
+++ b/test/sigchld.go
@@ -1,9 +1,12 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// [ "$GOOS" == windows ] ||
+// ($G $D/$F.go && $L $F.$A && ./$A.out 2>&1 | cmp - $D/$F.out)
 
 // Copyright 2009 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.
 
+// Test that a program can survive SIGCHLD.
+
 package main
 
 import "syscall"
diff --git a/test/sigchld.out b/test/sigchld.out
new file mode 100644
index 000000000..477d02579
--- /dev/null
+++ b/test/sigchld.out
@@ -0,0 +1 @@
+survived SIGCHLD
diff --git a/test/simassign.go b/test/simassign.go
index 28408abc2..6ba5c783e 100644
--- a/test/simassign.go
+++ b/test/simassign.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test simultaneous assignment.
+
 package main
 
 var a, b, c, d, e, f, g, h, i int
diff --git a/test/sinit.go b/test/sinit.go
index 2adb931e1..1bc281037 100644
--- a/test/sinit.go
+++ b/test/sinit.go
@@ -1,53 +1,56 @@
-// $G -S $D/$F.go | egrep initdone >/dev/null && echo FAIL || true
+// $G -S $D/$F.go | egrep initdone >/dev/null && echo BUG sinit || true
 
 // 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.
 
+// Test that many initializations can be done at link time and
+// generate no executable init functions.
+
 package p
 
 // Should be no init func in the assembly.
 // All these initializations should be done at link time.
 
-type	S	struct{ a,b,c int }
-type	SS	struct{ aa,bb,cc S }
-type	SA	struct{ a,b,c [3]int }
-type	SC	struct{ a,b,c []int }
+type S struct{ a, b, c int }
+type SS struct{ aa, bb, cc S }
+type SA struct{ a, b, c [3]int }
+type SC struct{ a, b, c []int }
 
 var (
-	zero = 2
-	one = 1
-	pi = 3.14
-	slice = []byte{1,2,3}
-	sliceInt = []int{1,2,3}
-	hello = "hello, world"
-	bytes = []byte("hello, world")
-	four, five = 4, 5
-	x, y = 0.1, "hello"
-	nilslice []byte = nil
-	nilmap map[string]int = nil
-	nilfunc func() = nil
-	nilchan chan int = nil
-	nilptr *byte = nil
+	zero                      = 2
+	one                       = 1
+	pi                        = 3.14
+	slice                     = []byte{1, 2, 3}
+	sliceInt                  = []int{1, 2, 3}
+	hello                     = "hello, world"
+	bytes                     = []byte("hello, world")
+	four, five                = 4, 5
+	x, y                      = 0.1, "hello"
+	nilslice   []byte         = nil
+	nilmap     map[string]int = nil
+	nilfunc    func()         = nil
+	nilchan    chan int       = nil
+	nilptr     *byte          = nil
 )
 
-var	a	= [3]int{1001, 1002, 1003}
-var	s	= S{1101, 1102, 1103}
-var	c	= []int{1201, 1202, 1203}
+var a = [3]int{1001, 1002, 1003}
+var s = S{1101, 1102, 1103}
+var c = []int{1201, 1202, 1203}
 
-var	aa	= [3][3]int{[3]int{2001,2002,2003}, [3]int{2004,2005,2006}, [3]int{2007,2008,2009}}
-var	as	= [3]S{S{2101,2102,2103},S{2104,2105,2106},S{2107,2108,2109}}
-var	ac	= [3][]int{[]int{2201,2202,2203}, []int{2204,2205,2206}, []int{2207,2208,2209}}
+var aa = [3][3]int{[3]int{2001, 2002, 2003}, [3]int{2004, 2005, 2006}, [3]int{2007, 2008, 2009}}
+var as = [3]S{S{2101, 2102, 2103}, S{2104, 2105, 2106}, S{2107, 2108, 2109}}
+var ac = [3][]int{[]int{2201, 2202, 2203}, []int{2204, 2205, 2206}, []int{2207, 2208, 2209}}
 
-var	sa	= SA{[3]int{3001,3002,3003},[3]int{3004,3005,3006},[3]int{3007,3008,3009}}
-var	ss	= SS{S{3101,3102,3103},S{3104,3105,3106},S{3107,3108,3109}}
-var	sc	= SC{[]int{3201,3202,3203},[]int{3204,3205,3206},[]int{3207,3208,3209}}
+var sa = SA{[3]int{3001, 3002, 3003}, [3]int{3004, 3005, 3006}, [3]int{3007, 3008, 3009}}
+var ss = SS{S{3101, 3102, 3103}, S{3104, 3105, 3106}, S{3107, 3108, 3109}}
+var sc = SC{[]int{3201, 3202, 3203}, []int{3204, 3205, 3206}, []int{3207, 3208, 3209}}
 
-var	ca	= [][3]int{[3]int{4001,4002,4003}, [3]int{4004,4005,4006}, [3]int{4007,4008,4009}}
-var	cs	= []S{S{4101,4102,4103},S{4104,4105,4106},S{4107,4108,4109}}
-var	cc	= [][]int{[]int{4201,4202,4203}, []int{4204,4205,4206}, []int{4207,4208,4209}}
+var ca = [][3]int{[3]int{4001, 4002, 4003}, [3]int{4004, 4005, 4006}, [3]int{4007, 4008, 4009}}
+var cs = []S{S{4101, 4102, 4103}, S{4104, 4105, 4106}, S{4107, 4108, 4109}}
+var cc = [][]int{[]int{4201, 4202, 4203}, []int{4204, 4205, 4206}, []int{4207, 4208, 4209}}
 
-var	answers	= [...]int {
+var answers = [...]int{
 	// s
 	1101, 1102, 1103,
 
@@ -98,3 +101,158 @@ var	answers	= [...]int {
 	2008, 2208, 2308, 4008, 4208, 4308, 5008, 5208, 5308,
 	2009, 2209, 2309, 4009, 4209, 4309, 5009, 5209, 5309,
 }
+
+var (
+	copy_zero = zero
+	copy_one = one
+	copy_pi = pi
+	copy_slice = slice
+	copy_sliceInt = sliceInt
+	copy_hello = hello
+	copy_bytes = bytes
+	copy_four, copy_five = four, five
+	copy_x, copy_y = x, y
+	copy_nilslice = nilslice
+	copy_nilmap = nilmap
+	copy_nilfunc = nilfunc
+	copy_nilchan = nilchan
+	copy_nilptr = nilptr
+)
+
+var copy_a = a
+var copy_s = s
+var copy_c = c
+
+var copy_aa = aa
+var copy_as = as
+var copy_ac = ac
+
+var copy_sa = sa
+var copy_ss = ss
+var copy_sc = sc
+
+var copy_ca = ca
+var copy_cs = cs
+var copy_cc = cc
+
+var copy_answers = answers
+
+var bx bool
+var b0 = false
+var b1 = true
+
+var fx float32
+var f0 = float32(0)
+var f1 = float32(1)
+
+var gx float64
+var g0 = float64(0)
+var g1 = float64(1)
+
+var ix int
+var i0 = 0
+var i1 = 1
+
+var jx uint
+var j0 = uint(0)
+var j1 = uint(1)
+
+var cx complex64
+var c0 = complex64(0)
+var c1 = complex64(1)
+
+var dx complex128
+var d0 = complex128(0)
+var d1 = complex128(1)
+
+var sx []int
+var s0 = []int{0, 0, 0}
+var s1 = []int{1, 2, 3}
+
+func fi() int
+
+var ax [10]int
+var a0 = [10]int{0, 0, 0}
+var a1 = [10]int{1, 2, 3, 4}
+
+type T struct{ X, Y int }
+
+var tx T
+var t0 = T{}
+var t0a = T{0, 0}
+var t0b = T{X: 0}
+var t1 = T{X: 1, Y: 2}
+var t1a = T{3, 4}
+
+var psx *[]int
+var ps0 = &[]int{0, 0, 0}
+var ps1 = &[]int{1, 2, 3}
+
+var pax *[10]int
+var pa0 = &[10]int{0, 0, 0}
+var pa1 = &[10]int{1, 2, 3}
+
+var ptx *T
+var pt0 = &T{}
+var pt0a = &T{0, 0}
+var pt0b = &T{X: 0}
+var pt1 = &T{X: 1, Y: 2}
+var pt1a = &T{3, 4}
+
+var copy_bx = bx
+var copy_b0 = b0
+var copy_b1 = b1
+
+var copy_fx = fx
+var copy_f0 = f0
+var copy_f1 = f1
+
+var copy_gx = gx
+var copy_g0 = g0
+var copy_g1 = g1
+
+var copy_ix = ix
+var copy_i0 = i0
+var copy_i1 = i1
+
+var copy_jx = jx
+var copy_j0 = j0
+var copy_j1 = j1
+
+var copy_cx = cx
+var copy_c0 = c0
+var copy_c1 = c1
+
+var copy_dx = dx
+var copy_d0 = d0
+var copy_d1 = d1
+
+var copy_sx = sx
+var copy_s0 = s0
+var copy_s1 = s1
+
+var copy_ax = ax
+var copy_a0 = a0
+var copy_a1 = a1
+
+var copy_tx = tx
+var copy_t0 = t0
+var copy_t0a = t0a
+var copy_t0b = t0b
+var copy_t1 = t1
+var copy_t1a = t1a
+
+var copy_psx = psx
+var copy_ps0 = ps0
+var copy_ps1 = ps1
+
+var copy_pax = pax
+var copy_pa0 = pa0
+var copy_pa1 = pa1
+
+var copy_ptx = ptx
+var copy_pt0 = pt0
+var copy_pt0a = pt0a
+var copy_pt0b = pt0b
+var copy_pt1 = pt1
+var copy_pt1a = pt1a
diff --git a/test/sizeof.go b/test/sizeof.go
index 544e4c52c..a6abdd5c6 100644
--- a/test/sizeof.go
+++ b/test/sizeof.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go
+// compile
 
 // Copyright 2011 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.
 
+// Test unsafe.Sizeof, unsafe.Alignof, and unsafe.Offsetof all return uintptr.
+
 package main
 
 import "unsafe"
diff --git a/test/solitaire.go b/test/solitaire.go
index c789bf24a..ac54cec0a 100644
--- a/test/solitaire.go
+++ b/test/solitaire.go
@@ -1,9 +1,13 @@
-// $G $F.go && $L $F.$A  # don't run it - produces too much output
+// build
 
 // 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.
 
+// Test general operation by solving a peg solitaire game.
+// A version of this is in the Go playground.
+// Don't run it - produces too much output.
+
 // This program solves the (English) peg solitaire board game.
 // See also: http://en.wikipedia.org/wiki/Peg_solitaire
 
@@ -14,7 +18,7 @@ const N = 11 + 1 // length of a board row (+1 for newline)
 // The board must be surrounded by 2 illegal fields in each direction
 // so that move() doesn't need to check the board boundaries. Periods
 // represent illegal fields, ● are pegs, and ○ are holes.
-var board = []int(
+var board = []rune(
 	`...........
 ...........
 ....●●●....
@@ -28,7 +32,6 @@ var board = []int(
 ...........
 `)
 
-
 // center is the position of the center hole if there is a single one;
 // otherwise it is -1.
 var center int
@@ -46,7 +49,6 @@ func init() {
 	}
 }
 
-
 var moves int // number of times move is called
 
 // move tests if there is a peg at position pos that can jump over another peg
@@ -63,7 +65,6 @@ func move(pos, dir int) bool {
 	return false
 }
 
-
 // unmove reverts a previously executed valid move.
 func unmove(pos, dir int) {
 	board[pos] = '●'
@@ -71,7 +72,6 @@ func unmove(pos, dir int) {
 	board[pos+2*dir] = '○'
 }
 
-
 // solve tries to find a sequence of moves such that there is only one peg left
 // at the end; if center is >= 0, that last peg must be in the center position.
 // If a solution is found, solve prints the board after each move in a backward
@@ -110,7 +110,6 @@ func solve() bool {
 	return false
 }
 
-
 func main() {
 	if !solve() {
 		println("no solution found")
diff --git a/test/stack.go b/test/stack.go
index 1fd57161f..b62febd48 100644
--- a/test/stack.go
+++ b/test/stack.go
@@ -1,9 +1,10 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test stack splitting code.
 // Try to tickle stack splitting bugs by doing
 // go, defer, and closure calls at different stack depths.
 
diff --git a/test/string_lit.go b/test/string_lit.go
index 4358dd8e8..956330038 100644
--- a/test/string_lit.go
+++ b/test/string_lit.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test string literal syntax.
+
 package main
 
 import "os"
@@ -35,14 +37,14 @@ func assert(a, b, c string) {
 }
 
 const (
-	gx1 = "aä本☺"
-	gx2 = "aä\xFF\xFF本☺"
+	gx1    = "aä本☺"
+	gx2    = "aä\xFF\xFF本☺"
 	gx2fix = "aä\uFFFD\uFFFD本☺"
 )
 
 var (
-	gr1 = []int(gx1)
-	gr2 = []int(gx2)
+	gr1 = []rune(gx1)
+	gr2 = []rune(gx2)
 	gb1 = []byte(gx1)
 	gb2 = []byte(gx2)
 )
@@ -93,26 +95,26 @@ func main() {
 
 	// test large runes. perhaps not the most logical place for this test.
 	var r int32
-	r = 0x10ffff;	// largest rune value
+	r = 0x10ffff // largest rune value
 	s = string(r)
 	assert(s, "\xf4\x8f\xbf\xbf", "largest rune")
 	r = 0x10ffff + 1
 	s = string(r)
 	assert(s, "\xef\xbf\xbd", "too-large rune")
 
-	assert(string(gr1), gx1, "global ->[]int")
-	assert(string(gr2), gx2fix, "global invalid ->[]int")
+	assert(string(gr1), gx1, "global ->[]rune")
+	assert(string(gr2), gx2fix, "global invalid ->[]rune")
 	assert(string(gb1), gx1, "->[]byte")
 	assert(string(gb2), gx2, "global invalid ->[]byte")
 
 	var (
-		r1 = []int(gx1)
-		r2 = []int(gx2)
+		r1 = []rune(gx1)
+		r2 = []rune(gx2)
 		b1 = []byte(gx1)
 		b2 = []byte(gx2)
 	)
-	assert(string(r1), gx1, "->[]int")
-	assert(string(r2), gx2fix, "invalid ->[]int")
+	assert(string(r1), gx1, "->[]rune")
+	assert(string(r2), gx2fix, "invalid ->[]rune")
 	assert(string(b1), gx1, "->[]byte")
 	assert(string(b2), gx2, "invalid ->[]byte")
 
diff --git a/test/stringrange.go b/test/stringrange.go
index d5ada2628..daaba91c6 100644
--- a/test/stringrange.go
+++ b/test/stringrange.go
@@ -1,36 +1,39 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test range over strings.
+
 package main
 
 import (
 	"fmt"
 	"os"
-	"utf8"
+	"unicode/utf8"
 )
 
 func main() {
 	s := "\000\123\x00\xca\xFE\u0123\ubabe\U0000babe\U0010FFFFx"
-	expect := []int{ 0, 0123, 0, 0xFFFD, 0xFFFD, 0x123, 0xbabe, 0xbabe, 0x10FFFF, 'x' }
+	expect := []rune{0, 0123, 0, 0xFFFD, 0xFFFD, 0x123, 0xbabe, 0xbabe, 0x10FFFF, 'x'}
 	offset := 0
-	var i, c int
+	var i int
+	var c rune
 	ok := true
 	cnum := 0
 	for i, c = range s {
-		rune, size := utf8.DecodeRuneInString(s[i:len(s)])  // check it another way
+		r, size := utf8.DecodeRuneInString(s[i:len(s)]) // check it another way
 		if i != offset {
 			fmt.Printf("unexpected offset %d not %d\n", i, offset)
 			ok = false
 		}
-		if rune != expect[cnum] {
-			fmt.Printf("unexpected rune %d from DecodeRuneInString: %x not %x\n", i, rune, expect[cnum])
+		if r != expect[cnum] {
+			fmt.Printf("unexpected rune %d from DecodeRuneInString: %x not %x\n", i, r, expect[cnum])
 			ok = false
 		}
 		if c != expect[cnum] {
-			fmt.Printf("unexpected rune %d from range: %x not %x\n", i, rune, expect[cnum])
+			fmt.Printf("unexpected rune %d from range: %x not %x\n", i, r, expect[cnum])
 			ok = false
 		}
 		offset += size
diff --git a/test/struct0.go b/test/struct0.go
new file mode 100644
index 000000000..e29eb30f5
--- /dev/null
+++ b/test/struct0.go
@@ -0,0 +1,34 @@
+// run
+
+// Copyright 2011 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.
+
+// Test zero length structs.
+// Used to not be evaluated.
+// Issue 2232.
+
+package main
+
+func recv(c chan interface{}) struct{} {
+	return (<-c).(struct{})
+}
+
+var m = make(map[interface{}]int)
+
+func recv1(c chan interface{}) {
+	defer rec()
+	m[(<-c).(struct{})] = 0
+}
+
+func rec() {
+	recover()
+}
+
+func main() {
+	c := make(chan interface{})
+	go recv(c)
+	c <- struct{}{}
+	go recv1(c)
+	c <- struct{}{}
+}
diff --git a/test/switch.go b/test/switch.go
index 0c253d6e2..09bf4341a 100644
--- a/test/switch.go
+++ b/test/switch.go
@@ -1,11 +1,15 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test switch statements.
+
 package main
 
+import "os"
+
 func assert(cond bool, msg string) {
 	if !cond {
 		print("assertion fail: ", msg, "\n")
@@ -19,48 +23,75 @@ func main() {
 	hello := "hello"
 
 	switch true {
-	case i5 < 5: assert(false, "<")
-	case i5 == 5: assert(true, "!")
-	case i5 > 5: assert(false, ">")
+	case i5 < 5:
+		assert(false, "<")
+	case i5 == 5:
+		assert(true, "!")
+	case i5 > 5:
+		assert(false, ">")
 	}
 
 	switch {
-	case i5 < 5: assert(false, "<")
-	case i5 == 5: assert(true, "!")
-	case i5 > 5: assert(false, ">")
+	case i5 < 5:
+		assert(false, "<")
+	case i5 == 5:
+		assert(true, "!")
+	case i5 > 5:
+		assert(false, ">")
 	}
 
 	switch x := 5; true {
-	case i5 < x: assert(false, "<")
-	case i5 == x: assert(true, "!")
-	case i5 > x: assert(false, ">")
+	case i5 < x:
+		assert(false, "<")
+	case i5 == x:
+		assert(true, "!")
+	case i5 > x:
+		assert(false, ">")
 	}
 
 	switch x := 5; true {
-	case i5 < x: assert(false, "<")
-	case i5 == x: assert(true, "!")
-	case i5 > x: assert(false, ">")
+	case i5 < x:
+		assert(false, "<")
+	case i5 == x:
+		assert(true, "!")
+	case i5 > x:
+		assert(false, ">")
 	}
 
 	switch i5 {
-	case 0: assert(false, "0")
-	case 1: assert(false, "1")
-	case 2: assert(false, "2")
-	case 3: assert(false, "3")
-	case 4: assert(false, "4")
-	case 5: assert(true, "5")
-	case 6: assert(false, "6")
-	case 7: assert(false, "7")
-	case 8: assert(false, "8")
-	case 9: assert(false, "9")
-	default: assert(false, "default")
+	case 0:
+		assert(false, "0")
+	case 1:
+		assert(false, "1")
+	case 2:
+		assert(false, "2")
+	case 3:
+		assert(false, "3")
+	case 4:
+		assert(false, "4")
+	case 5:
+		assert(true, "5")
+	case 6:
+		assert(false, "6")
+	case 7:
+		assert(false, "7")
+	case 8:
+		assert(false, "8")
+	case 9:
+		assert(false, "9")
+	default:
+		assert(false, "default")
 	}
 
 	switch i5 {
-	case 0,1,2,3,4: assert(false, "4")
-	case 5: assert(true, "5")
-	case 6,7,8,9: assert(false, "9")
-	default: assert(false, "default")
+	case 0, 1, 2, 3, 4:
+		assert(false, "4")
+	case 5:
+		assert(true, "5")
+	case 6, 7, 8, 9:
+		assert(false, "9")
+	default:
+		assert(false, "default")
 	}
 
 	switch i5 {
@@ -68,72 +99,197 @@ func main() {
 	case 1:
 	case 2:
 	case 3:
-	case 4: assert(false, "4")
-	case 5: assert(true, "5")
+	case 4:
+		assert(false, "4")
+	case 5:
+		assert(true, "5")
 	case 6:
 	case 7:
 	case 8:
 	case 9:
-	default: assert(i5 == 5, "good")
+	default:
+		assert(i5 == 5, "good")
 	}
 
 	switch i5 {
-	case 0: dummy := 0; _ = dummy; fallthrough
-	case 1: dummy := 0; _ = dummy; fallthrough
-	case 2: dummy := 0; _ = dummy; fallthrough
-	case 3: dummy := 0; _ = dummy; fallthrough
-	case 4: dummy := 0; _ = dummy; assert(false, "4")
-	case 5: dummy := 0; _ = dummy; fallthrough
-	case 6: dummy := 0; _ = dummy; fallthrough
-	case 7: dummy := 0; _ = dummy; fallthrough
-	case 8: dummy := 0; _ = dummy; fallthrough
-	case 9: dummy := 0; _ = dummy; fallthrough
-	default: dummy := 0; _ = dummy; assert(i5 == 5, "good")
+	case 0:
+		dummy := 0
+		_ = dummy
+		fallthrough
+	case 1:
+		dummy := 0
+		_ = dummy
+		fallthrough
+	case 2:
+		dummy := 0
+		_ = dummy
+		fallthrough
+	case 3:
+		dummy := 0
+		_ = dummy
+		fallthrough
+	case 4:
+		dummy := 0
+		_ = dummy
+		assert(false, "4")
+	case 5:
+		dummy := 0
+		_ = dummy
+		fallthrough
+	case 6:
+		dummy := 0
+		_ = dummy
+		fallthrough
+	case 7:
+		dummy := 0
+		_ = dummy
+		fallthrough
+	case 8:
+		dummy := 0
+		_ = dummy
+		fallthrough
+	case 9:
+		dummy := 0
+		_ = dummy
+		fallthrough
+	default:
+		dummy := 0
+		_ = dummy
+		assert(i5 == 5, "good")
 	}
 
 	fired := false
 	switch i5 {
-	case 0: dummy := 0; _ = dummy; fallthrough;  // tests scoping of cases
-	case 1: dummy := 0; _ = dummy; fallthrough
-	case 2: dummy := 0; _ = dummy; fallthrough
-	case 3: dummy := 0; _ = dummy; fallthrough
-	case 4: dummy := 0; _ = dummy; assert(false, "4")
-	case 5: dummy := 0; _ = dummy; fallthrough
-	case 6: dummy := 0; _ = dummy; fallthrough
-	case 7: dummy := 0; _ = dummy; fallthrough
-	case 8: dummy := 0; _ = dummy; fallthrough
-	case 9: dummy := 0; _ = dummy; fallthrough
-	default: dummy := 0; _ = dummy; fired = !fired; assert(i5 == 5, "good")
+	case 0:
+		dummy := 0
+		_ = dummy
+		fallthrough // tests scoping of cases
+	case 1:
+		dummy := 0
+		_ = dummy
+		fallthrough
+	case 2:
+		dummy := 0
+		_ = dummy
+		fallthrough
+	case 3:
+		dummy := 0
+		_ = dummy
+		fallthrough
+	case 4:
+		dummy := 0
+		_ = dummy
+		assert(false, "4")
+	case 5:
+		dummy := 0
+		_ = dummy
+		fallthrough
+	case 6:
+		dummy := 0
+		_ = dummy
+		fallthrough
+	case 7:
+		dummy := 0
+		_ = dummy
+		fallthrough
+	case 8:
+		dummy := 0
+		_ = dummy
+		fallthrough
+	case 9:
+		dummy := 0
+		_ = dummy
+		fallthrough
+	default:
+		dummy := 0
+		_ = dummy
+		fired = !fired
+		assert(i5 == 5, "good")
 	}
 	assert(fired, "fired")
 
 	count := 0
 	switch i5 {
-	case 0: count = count + 1; fallthrough
-	case 1: count = count + 1; fallthrough
-	case 2: count = count + 1; fallthrough
-	case 3: count = count + 1; fallthrough
-	case 4: count = count + 1; assert(false, "4")
-	case 5: count = count + 1; fallthrough
-	case 6: count = count + 1; fallthrough
-	case 7: count = count + 1; fallthrough
-	case 8: count = count + 1; fallthrough
-	case 9: count = count + 1; fallthrough
-	default: assert(i5 == count, "good")
+	case 0:
+		count = count + 1
+		fallthrough
+	case 1:
+		count = count + 1
+		fallthrough
+	case 2:
+		count = count + 1
+		fallthrough
+	case 3:
+		count = count + 1
+		fallthrough
+	case 4:
+		count = count + 1
+		assert(false, "4")
+	case 5:
+		count = count + 1
+		fallthrough
+	case 6:
+		count = count + 1
+		fallthrough
+	case 7:
+		count = count + 1
+		fallthrough
+	case 8:
+		count = count + 1
+		fallthrough
+	case 9:
+		count = count + 1
+		fallthrough
+	default:
+		assert(i5 == count, "good")
 	}
 	assert(fired, "fired")
 
 	switch hello {
-	case "wowie": assert(false, "wowie")
-	case "hello": assert(true, "hello")
-	case "jumpn": assert(false, "jumpn")
-	default: assert(false, "default")
+	case "wowie":
+		assert(false, "wowie")
+	case "hello":
+		assert(true, "hello")
+	case "jumpn":
+		assert(false, "jumpn")
+	default:
+		assert(false, "default")
 	}
 
 	fired = false
 	switch i := i5 + 2; i {
-	case i7: fired = true
-	default: assert(false, "fail")
+	case i7:
+		fired = true
+	default:
+		assert(false, "fail")
 	}
 	assert(fired, "var")
+
+	// switch on nil-only comparison types
+	switch f := func() {}; f {
+	case nil:
+		assert(false, "f should not be nil")
+	default:
+	}
+
+	switch m := make(map[int]int); m {
+	case nil:
+		assert(false, "m should not be nil")
+	default:
+	}
+
+	switch a := make([]int, 1); a {
+	case nil:
+		assert(false, "m should not be nil")
+	default:
+	}
+
+	i := 0
+	switch x := 5; {
+		case i < x:
+			os.Exit(0)
+		case i == x:
+		case i > x:
+			os.Exit(1)
+	}
 }
diff --git a/test/switch1.go b/test/switch1.go
deleted file mode 100644
index 5bd9d7c5d..000000000
--- a/test/switch1.go
+++ /dev/null
@@ -1,20 +0,0 @@
-// $G $F.go && $L $F.$A && ./$A.out
-
-// Copyright 2009 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.
-
-package main
-
-import "os"
-
-func main() {
-	i := 0
-	switch x := 5; {
-		case i < x:
-			os.Exit(0)
-		case i == x:
-		case i > x:
-			os.Exit(1)
-	}
-}
diff --git a/test/switch3.go b/test/switch3.go
new file mode 100644
index 000000000..dcb6fff20
--- /dev/null
+++ b/test/switch3.go
@@ -0,0 +1,61 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// Verify that erroneous switch statements are detected by the compiler.
+// Does not compile.
+
+package main
+
+type I interface {
+	M()
+}
+
+func bad() {
+	var i I
+	var s string
+
+	switch i {
+	case s: // ERROR "mismatched types string and I|incompatible types"
+	}
+
+	switch s {
+	case i: // ERROR "mismatched types I and string|incompatible types"
+	}
+
+	var m, m1 map[int]int
+	switch m {
+	case nil:
+	case m1: // ERROR "can only compare map m to nil|map can only be compared to nil"
+	default:
+	}
+
+	var a, a1 []int
+	switch a {
+	case nil:
+	case a1: // ERROR "can only compare slice a to nil|slice can only be compared to nil"
+	default:
+	}
+
+	var f, f1 func()
+	switch f {
+	case nil:
+	case f1: // ERROR "can only compare func f to nil|func can only be compared to nil"
+	default:
+	}
+}
+
+func good() {
+	var i interface{}
+	var s string
+
+	switch i {
+	case s:
+	}
+
+	switch s {
+	case i:
+	}
+}
diff --git a/test/syntax/chan.go b/test/syntax/chan.go
index ff3577502..3b68bda35 100644
--- a/test/syntax/chan.go
+++ b/test/syntax/chan.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/syntax/chan1.go b/test/syntax/chan1.go
index 9c12e5e6f..868a1226d 100644
--- a/test/syntax/chan1.go
+++ b/test/syntax/chan1.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/syntax/else.go b/test/syntax/else.go
new file mode 100644
index 000000000..e985a9c09
--- /dev/null
+++ b/test/syntax/else.go
@@ -0,0 +1,12 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+package main
+
+func main() {
+	if true {
+	} else ;  // ERROR "else must be followed by if or statement block|expected .if. or .{."
+}
diff --git a/test/syntax/forvar.go b/test/syntax/forvar.go
index f12ce55ca..dc592d2b6 100644
--- a/test/syntax/forvar.go
+++ b/test/syntax/forvar.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/syntax/if.go b/test/syntax/if.go
index a3b51f0c0..b2a65f9a5 100644
--- a/test/syntax/if.go
+++ b/test/syntax/if.go
@@ -1,4 +1,4 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/syntax/import.go b/test/syntax/import.go
index dd1f26134..f0a792126 100644
--- a/test/syntax/import.go
+++ b/test/syntax/import.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/syntax/interface.go b/test/syntax/interface.go
index a7f43533a..0b76b5416 100644
--- a/test/syntax/interface.go
+++ b/test/syntax/interface.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/syntax/semi1.go b/test/syntax/semi1.go
index 547d9bf79..8fbfb206a 100644
--- a/test/syntax/semi1.go
+++ b/test/syntax/semi1.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/syntax/semi2.go b/test/syntax/semi2.go
index 28d1d3906..cfb0ed17b 100644
--- a/test/syntax/semi2.go
+++ b/test/syntax/semi2.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/syntax/semi3.go b/test/syntax/semi3.go
index ab5941bda..645af7354 100644
--- a/test/syntax/semi3.go
+++ b/test/syntax/semi3.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/syntax/semi4.go b/test/syntax/semi4.go
index 7a9c2956e..e192348aa 100644
--- a/test/syntax/semi4.go
+++ b/test/syntax/semi4.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/syntax/semi5.go b/test/syntax/semi5.go
index 5f8ccc688..cf690f084 100644
--- a/test/syntax/semi5.go
+++ b/test/syntax/semi5.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/syntax/semi6.go b/test/syntax/semi6.go
index b6279ed30..c1e1cc363 100644
--- a/test/syntax/semi6.go
+++ b/test/syntax/semi6.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/syntax/semi7.go b/test/syntax/semi7.go
index 5a7b3ff4c..6c9ade8bc 100644
--- a/test/syntax/semi7.go
+++ b/test/syntax/semi7.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/syntax/topexpr.go b/test/syntax/topexpr.go
index 93d86fbe9..c5958f5dd 100644
--- a/test/syntax/topexpr.go
+++ b/test/syntax/topexpr.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/syntax/typesw.go b/test/syntax/typesw.go
index 47f683cdf..cd8cf3523 100644
--- a/test/syntax/typesw.go
+++ b/test/syntax/typesw.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2011 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/syntax/vareq.go b/test/syntax/vareq.go
index 8525be8cf..f08955e91 100644
--- a/test/syntax/vareq.go
+++ b/test/syntax/vareq.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/syntax/vareq1.go b/test/syntax/vareq1.go
index 9d70bea39..e900eabeb 100644
--- a/test/syntax/vareq1.go
+++ b/test/syntax/vareq1.go
@@ -1,4 +1,4 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2010 The Go Authors.  All rights reserved.
 // Use of this source code is governed by a BSD-style
diff --git a/test/test0.go b/test/test0.go
deleted file mode 100644
index d8d86c427..000000000
--- a/test/test0.go
+++ /dev/null
@@ -1,92 +0,0 @@
-// $G $F.go && $L $F.$A && ./$A.out
-
-// Copyright 2009 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.
-
-package main
-
-const a_const = 0
-
-const (
-	pi    = /* the usual */ 3.14159265358979323
-	e     = 2.718281828
-	mask1 int = 1 << iota
-	mask2 = 1 << iota
-	mask3 = 1 << iota
-	mask4 = 1 << iota
-)
-
-type (
-	Empty interface{}
-	Point struct {
-		x, y int
-	}
-	Point2 Point
-)
-
-func (p *Point) Initialize(x, y int) *Point {
-	p.x, p.y = x, y
-	return p
-}
-
-func (p *Point) Distance() int {
-	return p.x*p.x + p.y*p.y
-}
-
-var (
-	x1      int
-	x2      int
-	u, v, w float32
-)
-
-func foo() {}
-
-func min(x, y int) int {
-	if x < y {
-		return x
-	}
-	return y
-}
-
-func swap(x, y int) (u, v int) {
-	u = y
-	v = x
-	return
-}
-
-func control_structs() {
-	var p *Point = new(Point).Initialize(2, 3)
-	i := p.Distance()
-	var f float32 = 0.3
-	_ = f
-	for {
-	}
-	for {
-	}
-	for j := 0; j < i; j++ {
-		if i == 0 {
-		} else {
-			i = 0
-		}
-		var x float32
-		_ = x
-	}
-foo: // a label
-	var j int
-	switch y := 0; true {
-	case i < y:
-		fallthrough
-	case i < j:
-	case i == 0, i == 1, i == j:
-		i++
-		i++
-		goto foo
-	default:
-		i = -+-+i
-		break
-	}
-}
-
-func main() {
-}
diff --git a/test/testlib b/test/testlib
new file mode 100644
index 000000000..3858431a7
--- /dev/null
+++ b/test/testlib
@@ -0,0 +1,44 @@
+# Copyright 2012 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.
+
+# These function names are also known to
+# (and are the plan for transitioning to) run.go.
+
+compile() {
+	$G $D/$F.go
+}
+
+build() {
+	$G $D/$F.go && $L $F.$A
+}
+
+run() {
+	gofiles=""
+	ingo=true
+	while $ingo; do
+		case "$1" in
+		*.go)
+			gofiles="$gofiles $1"
+			shift
+			;;
+		*)
+			ingo=false
+			;;
+		esac
+	done
+
+	$G $D/$F.go $gofiles && $L $F.$A && ./$A.out "$@"
+}
+
+cmpout() {
+	$G $D/$F.go && $L $F.$A && ./$A.out 2>&1 | cmp - $D/$F.out
+}
+
+errorcheck() {
+	errchk $G -e $D/$F.go
+}
+
+skip() {
+	true
+}
diff --git a/test/turing.go b/test/turing.go
index 0af39de8b..acbe85b64 100644
--- a/test/turing.go
+++ b/test/turing.go
@@ -1,51 +1,58 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test simulating a Turing machine, sort of.
+
 package main
 
 // brainfuck
 
 var p, pc int
 var a [30000]byte
+
 const prog = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.!"
 
 func scan(dir int) {
 	for nest := dir; dir*nest > 0; pc += dir {
 		switch prog[pc+dir] {
-			case ']':
-				nest--
-			case '[':
-				nest++
+		case ']':
+			nest--
+		case '[':
+			nest++
 		}
 	}
 }
 
 func main() {
+	r := ""
 	for {
 		switch prog[pc] {
-			case '>':
-					p++
-			case '<':
-					p--
-			case '+':
-					a[p]++
-			case '-':
-					a[p]--
-			case '.':
-					print(string(a[p]))
-			case '[':
-				if a[p] == 0 {
-					scan(1)
-				}
-			case ']':
-				if a[p] != 0 {
-					scan(-1)
-				}
-			default:
-					return
+		case '>':
+			p++
+		case '<':
+			p--
+		case '+':
+			a[p]++
+		case '-':
+			a[p]--
+		case '.':
+			r += string(a[p])
+		case '[':
+			if a[p] == 0 {
+				scan(1)
+			}
+		case ']':
+			if a[p] != 0 {
+				scan(-1)
+			}
+		default:
+			if r != "Hello World!\n" {
+				panic(r)
+			}
+			return
 		}
 		pc++
 	}
diff --git a/test/typeswitch.go b/test/typeswitch.go
index 83fb0985a..30a4b4975 100644
--- a/test/typeswitch.go
+++ b/test/typeswitch.go
@@ -1,9 +1,11 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test simple type switches, including chans, maps etc.
+
 package main
 
 import "os"
@@ -82,9 +84,9 @@ func main() {
 		case []int:
 			assert(x[3] == 3 && i == Array, "array")
 		case map[string]int:
-			assert(x == m && i == Map, "map")
+			assert(x != nil && i == Map, "map")
 		case func(i int) interface{}:
-			assert(x == f && i == Func, "fun")
+			assert(x != nil && i == Func, "fun")
 		default:
 			assert(false, "unknown")
 		}
@@ -111,5 +113,4 @@ func main() {
 	default:
 		assert(false, "switch 4 unknown")
 	}
-
 }
diff --git a/test/typeswitch1.go b/test/typeswitch1.go
index 9613b166f..a980ce4c0 100644
--- a/test/typeswitch1.go
+++ b/test/typeswitch1.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test simple type switches on basic types.
+
 package main
 
 import "fmt"
diff --git a/test/typeswitch2.go b/test/typeswitch2.go
index f8fe396ea..6c703076a 100644
--- a/test/typeswitch2.go
+++ b/test/typeswitch2.go
@@ -1,9 +1,12 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // Copyright 2009 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.
 
+// Verify that various erroneous type switches are caught be the compiler.
+// Does not compile.
+
 package main
 
 import "io"
@@ -18,11 +21,27 @@ func whatis(x interface{}) string {
 		return "Reader1"
 	case io.Reader: // ERROR "duplicate"
 		return "Reader2"
-	case interface { r(); w() }:
+	case interface {
+		r()
+		w()
+	}:
 		return "rw"
-	case interface { w(); r() }:	// ERROR "duplicate"
+	case interface {	// GCCGO_ERROR "duplicate"
+		w()
+		r()
+	}: // GC_ERROR "duplicate"
 		return "wr"
-	
+
 	}
 	return ""
 }
+
+func notused(x interface{}) {
+	// The first t is in a different scope than the 2nd t; it cannot
+	// be accessed (=> declared and not used error); but it is legal
+	// to declare it.
+	switch t := 0; t := x.(type) { // ERROR "declared and not used"
+	case int:
+		_ = t // this is using the t of "t := x.(type)"
+	}
+}
diff --git a/test/typeswitch3.go b/test/typeswitch3.go
new file mode 100644
index 000000000..5475a8a6d
--- /dev/null
+++ b/test/typeswitch3.go
@@ -0,0 +1,43 @@
+// errorcheck
+
+// Copyright 2011 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.
+
+// Verify that erroneous type switches are caught be the compiler.
+// Issue 2700, among other things.
+// Does not compile.
+
+package main
+
+import (
+	"io"
+)
+
+type I interface {
+	M()
+}
+
+func main(){
+	var x I
+	switch x.(type) {
+	case string:	// ERROR "impossible"
+		println("FAIL")
+	}
+	
+	// Issue 2700: if the case type is an interface, nothing is impossible
+	
+	var r io.Reader
+	
+	_, _ = r.(io.Writer)
+	
+	switch r.(type) {
+	case io.Writer:
+	}
+	
+	// Issue 2827.
+	switch _ := r.(type) {  // ERROR "invalid variable name _"
+	}
+}
+
+
diff --git a/test/undef.go b/test/undef.go
index 7ef07882a..0a77e5937 100644
--- a/test/undef.go
+++ b/test/undef.go
@@ -1,10 +1,11 @@
-// errchk $G -e $D/$F.go
+// errorcheck
 
 // 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.
 
-// Check line numbers in error messages.
+// Test line numbers in error messages.
+// Does not compile.
 
 package main
 
diff --git a/test/utf.go b/test/utf.go
index a93fc2934..3ac79447e 100644
--- a/test/utf.go
+++ b/test/utf.go
@@ -1,15 +1,17 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // Copyright 2009 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.
 
+// Test UTF-8 in strings and character constants.
+
 package main
 
-import "utf8"
+import "unicode/utf8"
 
 func main() {
-	var chars [6] int
+	var chars [6]rune
 	chars[0] = 'a'
 	chars[1] = 'b'
 	chars[2] = 'c'
@@ -21,16 +23,22 @@ func main() {
 		s += string(chars[i])
 	}
 	var l = len(s)
-	for w, i, j := 0,0,0; i < l; i += w {
-		var r int
+	for w, i, j := 0, 0, 0; i < l; i += w {
+		var r rune
 		r, w = utf8.DecodeRuneInString(s[i:len(s)])
-		if w == 0 { panic("zero width in string") }
-		if r != chars[j] { panic("wrong value from string") }
+		if w == 0 {
+			panic("zero width in string")
+		}
+		if r != chars[j] {
+			panic("wrong value from string")
+		}
 		j++
 	}
 	// encoded as bytes:  'a' 'b' 'c' e6 97 a5 e6 9c ac e8 aa 9e
 	const L = 12
-	if L != l { panic("wrong length constructing array") }
+	if L != l {
+		panic("wrong length constructing array")
+	}
 	a := make([]byte, L)
 	a[0] = 'a'
 	a[1] = 'b'
@@ -44,11 +52,15 @@ func main() {
 	a[9] = 0xe8
 	a[10] = 0xaa
 	a[11] = 0x9e
-	for w, i, j := 0,0,0; i < L; i += w {
-		var r int
+	for w, i, j := 0, 0, 0; i < L; i += w {
+		var r rune
 		r, w = utf8.DecodeRune(a[i:L])
-		if w == 0 { panic("zero width in bytes") }
-		if r != chars[j] { panic("wrong value from bytes") }
+		if w == 0 {
+			panic("zero width in bytes")
+		}
+		if r != chars[j] {
+			panic("wrong value from bytes")
+		}
 		j++
 	}
 }
diff --git a/test/varerr.go b/test/varerr.go
index ddd718f5b..22aa9324f 100644
--- a/test/varerr.go
+++ b/test/varerr.go
@@ -1,9 +1,12 @@
-// errchk $G $D/$F.go
+// errorcheck
 
 // 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.
 
+// Verify that a couple of illegal variable declarations are caught by the compiler.
+// Does not compile.
+
 package main
 
 func main() {
diff --git a/test/varinit.go b/test/varinit.go
index c76877793..84a4a1aa5 100644
--- a/test/varinit.go
+++ b/test/varinit.go
@@ -1,9 +1,11 @@
-// $G $D/$F.go && $L $F.$A && ./$A.out || echo BUG wrong result
+// run
 
 // Copyright 2009 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.
 
+// Test var x = x + 1 works.
+
 package main
 
 func main() {
diff --git a/test/vectors.go b/test/vectors.go
deleted file mode 100644
index ed5905da3..000000000
--- a/test/vectors.go
+++ /dev/null
@@ -1,64 +0,0 @@
-// $G $F.go && $L $F.$A && ./$A.out
-
-// Copyright 2009 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.
-
-package main
-
-import "container/vector"
-
-
-type S struct {
-	val int
-}
-
-
-func (p *S) Init(val int) *S {
-	p.val = val
-	return p
-}
-
-
-func test0() {
-	v := new(vector.Vector)
-	if v.Len() != 0 {
-		print("len = ", v.Len(), "\n")
-		panic("fail")
-	}
-}
-
-
-func test1() {
-	var a [1000]*S
-	for i := 0; i < len(a); i++ {
-		a[i] = new(S).Init(i)
-	}
-
-	v := new(vector.Vector)
-	for i := 0; i < len(a); i++ {
-		v.Insert(0, a[i])
-		if v.Len() != i+1 {
-			print("len = ", v.Len(), "\n")
-			panic("fail")
-		}
-	}
-
-	for i := 0; i < v.Len(); i++ {
-		x := v.At(i).(*S)
-		if x.val != v.Len()-i-1 {
-			print("expected ", i, ", found ", x.val, "\n")
-			panic("fail")
-		}
-	}
-
-	for v.Len() > 10 {
-		v.Delete(10)
-	}
-}
-
-
-func main() {
-	test0()
-	test1()
-}
diff --git a/test/zerodivide.go b/test/zerodivide.go
index 1948528d2..673d1d18d 100644
--- a/test/zerodivide.go
+++ b/test/zerodivide.go
@@ -1,21 +1,20 @@
-// $G $F.go && $L $F.$A && ./$A.out
+// run
 
 // 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.
 
+// Test that zero division causes a panic.
+
 package main
 
 import (
 	"fmt"
 	"math"
+	"runtime"
 	"strings"
 )
 
-type Error interface {
-	String() string
-}
-
 type ErrorTest struct {
 	name string
 	fn   func()
@@ -161,10 +160,10 @@ var errorTests = []ErrorTest{
 	ErrorTest{"complex128 1/0", func() { use(e128 / d128) }, ""},
 }
 
-func error(fn func()) (error string) {
+func error_(fn func()) (error string) {
 	defer func() {
 		if e := recover(); e != nil {
-			error = e.(Error).String()
+			error = e.(runtime.Error).Error()
 		}
 	}()
 	fn()
@@ -199,7 +198,7 @@ func main() {
 		if t.err != "" {
 			continue
 		}
-		err := error(t.fn)
+		err := error_(t.fn)
 		switch {
 		case t.err == "" && err == "":
 			// fine
author	Ondřej Surý <ondrej@sury.org>	2012-04-06 15:14:11 +0200
committer	Ondřej Surý <ondrej@sury.org>	2012-04-06 15:14:11 +0200
commit	505c19580e0f43fe5224431459cacb7c21edd93d (patch)
tree	79e2634c253d60afc0cc0b2f510dc7dcbb48497b /test
parent	1336a7c91e596c423a49d1194ea42d98bca0d958 (diff)
download	golang-505c19580e0f43fe5224431459cacb7c21edd93d.tar.gz