delete all uses of panicln by rewriting them using panic or,

in the tests, println+panic.
gofmt some tests too.

R=rsc
CC=golang-dev
http://codereview.appspot.com/741041

11 files changed, 2007 insertions, 1287 deletions

diff --git a/test/ken/chan1.go b/test/ken/chan1.go
index d4c4f460f..e5fc033f3 100644
--- a/test/ken/chan1.go
+++ b/test/ken/chan1.go
@@ -8,47 +8,46 @@ package main
 
 import "runtime"
 
-const	N	= 1000;		// sent messages
-const	M	= 10;		// receiving goroutines
-const	W	= 2;		// channel buffering
-var	h	[N]int;		// marking of send/recv
+const N = 1000 // sent messages
+const M = 10   // receiving goroutines
+const W = 2    // channel buffering
+var h [N]int   // marking of send/recv
 
-func
-r(c chan int, m int) {
+func r(c chan int, m int) {
 	for {
 		select {
-		case r := <- c:
+		case r := <-c:
 			if h[r] != 1 {
-				panicln("r",
+				println("r",
 					"m=", m,
 					"r=", r,
-					"h=", h[r]);
+					"h=", h[r])
+				panic("fail")
 			}
-			h[r] = 2;
+			h[r] = 2
 		}
 	}
 }
 
-func
-s(c chan int) {
-	for n:=0; n<N; n++ {
-		r := n;
+func s(c chan int) {
+	for n := 0; n < N; n++ {
+		r := n
 		if h[r] != 0 {
-			panicln("s");
+			println("s")
+			panic("fail")
 		}
-		h[r] = 1;
-		c <- r;
+		h[r] = 1
+		c <- r
 	}
 }
 
-func
-main() {
-	c := make(chan int, W);
-	for m:=0; m<M; m++ {
-		go r(c, m);
-		runtime.Gosched();
+func main() {
+	c := make(chan int, W)
+	for m := 0; m < M; m++ {
+		go r(c, m)
+		runtime.Gosched()
 	}
-	runtime.Gosched();
-	runtime.Gosched();
-	s(c);
+	runtime.Gosched()
+	runtime.Gosched()
+	s(c)
 }
diff --git a/test/ken/cplx1.go b/test/ken/cplx1.go
index 379e2e10b..26b113992 100644
--- a/test/ken/cplx1.go
+++ b/test/ken/cplx1.go
@@ -19,22 +19,26 @@ func main() {
 	// constants
 	b = (5 + 6i) == C1
 	if !b {
-		panicln("const bool 1", b)
+		println("const bool 1", b)
+		panic("fail")
 	}
 
 	b = (5 + 6i) != C1
 	if b {
-		panicln("const bool 2", b)
+		println("const bool 2", b)
+		panic("fail")
 	}
 
 	b = C1 == (5 + 6i)
 	if !b {
-		panicln("const bool 3", b)
+		println("const bool 3", b)
+		panic("fail")
 	}
 
 	b = C1 != (5 + 6i)
 	if b {
-		panicln("const bool 4", b)
+		println("const bool 4", b)
+		panic("fail")
 	}
 
 	// vars passed through parameters
@@ -49,37 +53,45 @@ func booltest(a complex, r bool) {
 
 	b = a == C1
 	if b != r {
-		panicln("param bool 1", a, b, r)
+		println("param bool 1", a, b, r)
+		panic("fail")
 	}
 
 	b = a != C1
 	if b == r {
-		panicln("param bool 2", a, b, r)
+		println("param bool 2", a, b, r)
+		panic("fail")
 	}
 
 	b = C1 == a
 	if b != r {
-		panicln("param bool 3", a, b, r)
+		println("param bool 3", a, b, r)
+		panic("fail")
 	}
 
 	b = C1 != a
 	if b == r {
-		panicln("param bool 4", a, b, r)
+		println("param bool 4", a, b, r)
+		panic("fail")
 	}
 
 	if r {
 		if a != C1 {
-			panicln("param bool 5", a, b, r)
+			println("param bool 5", a, b, r)
+			panic("fail")
 		}
 		if C1 != a {
-			panicln("param bool 6", a, b, r)
+			println("param bool 6", a, b, r)
+			panic("fail")
 		}
 	} else {
 		if a == C1 {
-			panicln("param bool 6", a, b, r)
+			println("param bool 6", a, b, r)
+			panic("fail")
 		}
 		if C1 == a {
-			panicln("param bool 7", a, b, r)
+			println("param bool 7", a, b, r)
+			panic("fail")
 		}
 	}
 }
diff --git a/test/ken/cplx2.go b/test/ken/cplx2.go
index 7d3e5d735..5a66dc9a9 100644
--- a/test/ken/cplx2.go
+++ b/test/ken/cplx2.go
@@ -30,66 +30,79 @@ func main() {
 
 	r := 5 + 0i
 	if r != R {
-		panicln("opcode 1", r, R)
+		println("opcode 1", r, R)
+		panic("fail")
 	}
 
 	i := 6i
 	if i != I {
-		panicln("opcode 2", i, I)
+		println("opcode 2", i, I)
+		panic("fail")
 	}
 
 	c1 := r + i
 	if c1 != C1 {
-		panicln("opcode x", c1, C1)
+		println("opcode x", c1, C1)
+		panic("fail")
 	}
 
 	c2 := r - i
 	if c2 != C2 {
-		panicln("opcode x", c2, C2)
+		println("opcode x", c2, C2)
+		panic("fail")
 	}
 
 	c3 := -(r + i)
 	if c3 != C3 {
-		panicln("opcode x", c3, C3)
+		println("opcode x", c3, C3)
+		panic("fail")
 	}
 
 	c4 := -(r - i)
 	if c4 != C4 {
-		panicln("opcode x", c4, C4)
+		println("opcode x", c4, C4)
+		panic("fail")
 	}
 
 	c5 := c1 + r
 	if c5 != C5 {
-		panicln("opcode x", c5, C5)
+		println("opcode x", c5, C5)
+		panic("fail")
 	}
 
 	c6 := c1 + i
 	if c6 != C6 {
-		panicln("opcode x", c6, C6)
+		println("opcode x", c6, C6)
+		panic("fail")
 	}
 
 	ca := c5 + c6
 	if ca != Ca {
-		panicln("opcode x", ca, Ca)
+		println("opcode x", ca, Ca)
+		panic("fail")
 	}
 
 	cb := c5 - c6
 	if cb != Cb {
-		panicln("opcode x", cb, Cb)
+		println("opcode x", cb, Cb)
+		panic("fail")
 	}
 
 	cc := c5 * c6
 	if cc != Cc {
-		panicln("opcode x", cc, Cc)
+		println("opcode x", cc, Cc)
+		panic("fail")
 	}
 
 	cd := c5 / c6
 	if cd != Cd {
-		panicln("opcode x", cd, Cd)
+		println("opcode x", cd, Cd)
+		panic("fail")
 	}
 
 	ce := cd * c6
 	if ce != Ce {
-		panicln("opcode x", ce, Ce)
+		println("opcode x", ce, Ce)
+		panic("fail")
 	}
 }
diff --git a/test/ken/divconst.go b/test/ken/divconst.go
index 4143dc581..c3b9092cd 100644
--- a/test/ken/divconst.go
+++ b/test/ken/divconst.go
@@ -6,447 +6,627 @@
 
 package main
 
-import	"rand"
+import "rand"
 
-const	Count	= 1e5
+const Count = 1e5
 
-func
-i64rand() int64 {
+func i64rand() int64 {
 	for {
-		a := int64(rand.Uint32());
-		a = (a<<32) | int64(rand.Uint32());
-		a >>= uint(rand.Intn(64));
+		a := int64(rand.Uint32())
+		a = (a << 32) | int64(rand.Uint32())
+		a >>= uint(rand.Intn(64))
 		if -a != a {
-			return a;
+			return a
 		}
 	}
-	return 0;	// impossible
+	return 0 // impossible
 }
 
-func
-i64test(a,b,c int64) {
-	d := a/c;
+func i64test(a, b, c int64) {
+	d := a / c
 	if d != b {
-		panicln("i64", a, b, c, d);
+		println("i64", a, b, c, d)
+		panic("fail")
 	}
 }
 
-func
-i64run() {
-	var a, b int64;
-
-	for i:=0; i<Count; i++ {
-		a = i64rand();
-
-		b = a/1;	i64test(a,b,1);
-		b = a/2;	i64test(a,b,2);
-		b = a/3;	i64test(a,b,3);
-		b = a/4;	i64test(a,b,4);
-		b = a/5;	i64test(a,b,5);
-		b = a/6;	i64test(a,b,6);
-		b = a/7;	i64test(a,b,7);
-		b = a/8;	i64test(a,b,8);
-		b = a/10;	i64test(a,b,10);
-		b = a/16;	i64test(a,b,16);
-		b = a/20;	i64test(a,b,20);
-		b = a/32;	i64test(a,b,32);
-		b = a/60;	i64test(a,b,60);
-		b = a/64;	i64test(a,b,64);
-		b = a/128;	i64test(a,b,128);
-		b = a/256;	i64test(a,b,256);
-		b = a/16384;	i64test(a,b,16384);
-
-		b = a/-1;	i64test(a,b,-1);
-		b = a/-2;	i64test(a,b,-2);
-		b = a/-3;	i64test(a,b,-3);
-		b = a/-4;	i64test(a,b,-4);
-		b = a/-5;	i64test(a,b,-5);
-		b = a/-6;	i64test(a,b,-6);
-		b = a/-7;	i64test(a,b,-7);
-		b = a/-8;	i64test(a,b,-8);
-		b = a/-10;	i64test(a,b,-10);
-		b = a/-16;	i64test(a,b,-16);
-		b = a/-20;	i64test(a,b,-20);
-		b = a/-32;	i64test(a,b,-32);
-		b = a/-60;	i64test(a,b,-60);
-		b = a/-64;	i64test(a,b,-64);
-		b = a/-128;	i64test(a,b,-128);
-		b = a/-256;	i64test(a,b,-256);
-		b = a/-16384;	i64test(a,b,-16384);
+func i64run() {
+	var a, b int64
+
+	for i := 0; i < Count; i++ {
+		a = i64rand()
+
+		b = a / 1
+		i64test(a, b, 1)
+		b = a / 2
+		i64test(a, b, 2)
+		b = a / 3
+		i64test(a, b, 3)
+		b = a / 4
+		i64test(a, b, 4)
+		b = a / 5
+		i64test(a, b, 5)
+		b = a / 6
+		i64test(a, b, 6)
+		b = a / 7
+		i64test(a, b, 7)
+		b = a / 8
+		i64test(a, b, 8)
+		b = a / 10
+		i64test(a, b, 10)
+		b = a / 16
+		i64test(a, b, 16)
+		b = a / 20
+		i64test(a, b, 20)
+		b = a / 32
+		i64test(a, b, 32)
+		b = a / 60
+		i64test(a, b, 60)
+		b = a / 64
+		i64test(a, b, 64)
+		b = a / 128
+		i64test(a, b, 128)
+		b = a / 256
+		i64test(a, b, 256)
+		b = a / 16384
+		i64test(a, b, 16384)
+
+		b = a / -1
+		i64test(a, b, -1)
+		b = a / -2
+		i64test(a, b, -2)
+		b = a / -3
+		i64test(a, b, -3)
+		b = a / -4
+		i64test(a, b, -4)
+		b = a / -5
+		i64test(a, b, -5)
+		b = a / -6
+		i64test(a, b, -6)
+		b = a / -7
+		i64test(a, b, -7)
+		b = a / -8
+		i64test(a, b, -8)
+		b = a / -10
+		i64test(a, b, -10)
+		b = a / -16
+		i64test(a, b, -16)
+		b = a / -20
+		i64test(a, b, -20)
+		b = a / -32
+		i64test(a, b, -32)
+		b = a / -60
+		i64test(a, b, -60)
+		b = a / -64
+		i64test(a, b, -64)
+		b = a / -128
+		i64test(a, b, -128)
+		b = a / -256
+		i64test(a, b, -256)
+		b = a / -16384
+		i64test(a, b, -16384)
 	}
 }
 
-func
-u64rand() uint64 {
-	a := uint64(rand.Uint32());
-	a = (a<<32) | uint64(rand.Uint32());
-	a >>= uint(rand.Intn(64));
-	return a;
+func u64rand() uint64 {
+	a := uint64(rand.Uint32())
+	a = (a << 32) | uint64(rand.Uint32())
+	a >>= uint(rand.Intn(64))
+	return a
 }
 
-func
-u64test(a,b,c uint64) {
-	d := a/c;
+func u64test(a, b, c uint64) {
+	d := a / c
 	if d != b {
-		panicln("u64", a, b, c, d);
+		println("u64", a, b, c, d)
+		panic("fail")
 	}
 }
 
-func
-u64run() {
-	var a, b uint64;
-
-	for i:=0; i<Count; i++ {
-		a = u64rand();
-
-		b = a/1;	u64test(a,b,1);
-		b = a/2;	u64test(a,b,2);
-		b = a/3;	u64test(a,b,3);
-		b = a/4;	u64test(a,b,4);
-		b = a/5;	u64test(a,b,5);
-		b = a/6;	u64test(a,b,6);
-		b = a/7;	u64test(a,b,7);
-		b = a/8;	u64test(a,b,8);
-		b = a/10;	u64test(a,b,10);
-		b = a/16;	u64test(a,b,16);
-		b = a/20;	u64test(a,b,20);
-		b = a/32;	u64test(a,b,32);
-		b = a/60;	u64test(a,b,60);
-		b = a/64;	u64test(a,b,64);
-		b = a/128;	u64test(a,b,128);
-		b = a/256;	u64test(a,b,256);
-		b = a/16384;	u64test(a,b,16384);
+func u64run() {
+	var a, b uint64
+
+	for i := 0; i < Count; i++ {
+		a = u64rand()
+
+		b = a / 1
+		u64test(a, b, 1)
+		b = a / 2
+		u64test(a, b, 2)
+		b = a / 3
+		u64test(a, b, 3)
+		b = a / 4
+		u64test(a, b, 4)
+		b = a / 5
+		u64test(a, b, 5)
+		b = a / 6
+		u64test(a, b, 6)
+		b = a / 7
+		u64test(a, b, 7)
+		b = a / 8
+		u64test(a, b, 8)
+		b = a / 10
+		u64test(a, b, 10)
+		b = a / 16
+		u64test(a, b, 16)
+		b = a / 20
+		u64test(a, b, 20)
+		b = a / 32
+		u64test(a, b, 32)
+		b = a / 60
+		u64test(a, b, 60)
+		b = a / 64
+		u64test(a, b, 64)
+		b = a / 128
+		u64test(a, b, 128)
+		b = a / 256
+		u64test(a, b, 256)
+		b = a / 16384
+		u64test(a, b, 16384)
 	}
 }
 
-func
-i32rand() int32 {
+func i32rand() int32 {
 	for {
-		a := int32(rand.Uint32());
-		a >>= uint(rand.Intn(32));
+		a := int32(rand.Uint32())
+		a >>= uint(rand.Intn(32))
 		if -a != a {
-			return a;
+			return a
 		}
 	}
-	return 0;	// impossible
+	return 0 // impossible
 }
 
-func
-i32test(a,b,c int32) {
-	d := a/c;
+func i32test(a, b, c int32) {
+	d := a / c
 	if d != b {
-		panicln("i32", a, b, c, d);
+		println("i32", a, b, c, d)
+		panic("fail")
 	}
 }
 
-func
-i32run() {
-	var a, b int32;
-
-	for i:=0; i<Count; i++ {
-		a = i32rand();
-
-		b = a/1;	i32test(a,b,1);
-		b = a/2;	i32test(a,b,2);
-		b = a/3;	i32test(a,b,3);
-		b = a/4;	i32test(a,b,4);
-		b = a/5;	i32test(a,b,5);
-		b = a/6;	i32test(a,b,6);
-		b = a/7;	i32test(a,b,7);
-		b = a/8;	i32test(a,b,8);
-		b = a/10;	i32test(a,b,10);
-		b = a/16;	i32test(a,b,16);
-		b = a/20;	i32test(a,b,20);
-		b = a/32;	i32test(a,b,32);
-		b = a/60;	i32test(a,b,60);
-		b = a/64;	i32test(a,b,64);
-		b = a/128;	i32test(a,b,128);
-		b = a/256;	i32test(a,b,256);
-		b = a/16384;	i32test(a,b,16384);
-
-		b = a/-1;	i32test(a,b,-1);
-		b = a/-2;	i32test(a,b,-2);
-		b = a/-3;	i32test(a,b,-3);
-		b = a/-4;	i32test(a,b,-4);
-		b = a/-5;	i32test(a,b,-5);
-		b = a/-6;	i32test(a,b,-6);
-		b = a/-7;	i32test(a,b,-7);
-		b = a/-8;	i32test(a,b,-8);
-		b = a/-10;	i32test(a,b,-10);
-		b = a/-16;	i32test(a,b,-16);
-		b = a/-20;	i32test(a,b,-20);
-		b = a/-32;	i32test(a,b,-32);
-		b = a/-60;	i32test(a,b,-60);
-		b = a/-64;	i32test(a,b,-64);
-		b = a/-128;	i32test(a,b,-128);
-		b = a/-256;	i32test(a,b,-256);
+func i32run() {
+	var a, b int32
+
+	for i := 0; i < Count; i++ {
+		a = i32rand()
+
+		b = a / 1
+		i32test(a, b, 1)
+		b = a / 2
+		i32test(a, b, 2)
+		b = a / 3
+		i32test(a, b, 3)
+		b = a / 4
+		i32test(a, b, 4)
+		b = a / 5
+		i32test(a, b, 5)
+		b = a / 6
+		i32test(a, b, 6)
+		b = a / 7
+		i32test(a, b, 7)
+		b = a / 8
+		i32test(a, b, 8)
+		b = a / 10
+		i32test(a, b, 10)
+		b = a / 16
+		i32test(a, b, 16)
+		b = a / 20
+		i32test(a, b, 20)
+		b = a / 32
+		i32test(a, b, 32)
+		b = a / 60
+		i32test(a, b, 60)
+		b = a / 64
+		i32test(a, b, 64)
+		b = a / 128
+		i32test(a, b, 128)
+		b = a / 256
+		i32test(a, b, 256)
+		b = a / 16384
+		i32test(a, b, 16384)
+
+		b = a / -1
+		i32test(a, b, -1)
+		b = a / -2
+		i32test(a, b, -2)
+		b = a / -3
+		i32test(a, b, -3)
+		b = a / -4
+		i32test(a, b, -4)
+		b = a / -5
+		i32test(a, b, -5)
+		b = a / -6
+		i32test(a, b, -6)
+		b = a / -7
+		i32test(a, b, -7)
+		b = a / -8
+		i32test(a, b, -8)
+		b = a / -10
+		i32test(a, b, -10)
+		b = a / -16
+		i32test(a, b, -16)
+		b = a / -20
+		i32test(a, b, -20)
+		b = a / -32
+		i32test(a, b, -32)
+		b = a / -60
+		i32test(a, b, -60)
+		b = a / -64
+		i32test(a, b, -64)
+		b = a / -128
+		i32test(a, b, -128)
+		b = a / -256
+		i32test(a, b, -256)
 	}
 }
 
-func
-u32rand() uint32 {
-	a := uint32(rand.Uint32());
-	a >>= uint(rand.Intn(32));
-	return a;
+func u32rand() uint32 {
+	a := uint32(rand.Uint32())
+	a >>= uint(rand.Intn(32))
+	return a
 }
 
-func
-u32test(a,b,c uint32) {
-	d := a/c;
+func u32test(a, b, c uint32) {
+	d := a / c
 	if d != b {
-		panicln("u32", a, b, c, d);
+		println("u32", a, b, c, d)
+		panic("fail")
 	}
 }
 
-func
-u32run() {
-	var a, b uint32;
-
-	for i:=0; i<Count; i++ {
-		a = u32rand();
-
-		b = a/1;	u32test(a,b,1);
-		b = a/2;	u32test(a,b,2);
-		b = a/3;	u32test(a,b,3);
-		b = a/4;	u32test(a,b,4);
-		b = a/5;	u32test(a,b,5);
-		b = a/6;	u32test(a,b,6);
-		b = a/7;	u32test(a,b,7);
-		b = a/8;	u32test(a,b,8);
-		b = a/10;	u32test(a,b,10);
-		b = a/16;	u32test(a,b,16);
-		b = a/20;	u32test(a,b,20);
-		b = a/32;	u32test(a,b,32);
-		b = a/60;	u32test(a,b,60);
-		b = a/64;	u32test(a,b,64);
-		b = a/128;	u32test(a,b,128);
-		b = a/256;	u32test(a,b,256);
-		b = a/16384;	u32test(a,b,16384);
+func u32run() {
+	var a, b uint32
+
+	for i := 0; i < Count; i++ {
+		a = u32rand()
+
+		b = a / 1
+		u32test(a, b, 1)
+		b = a / 2
+		u32test(a, b, 2)
+		b = a / 3
+		u32test(a, b, 3)
+		b = a / 4
+		u32test(a, b, 4)
+		b = a / 5
+		u32test(a, b, 5)
+		b = a / 6
+		u32test(a, b, 6)
+		b = a / 7
+		u32test(a, b, 7)
+		b = a / 8
+		u32test(a, b, 8)
+		b = a / 10
+		u32test(a, b, 10)
+		b = a / 16
+		u32test(a, b, 16)
+		b = a / 20
+		u32test(a, b, 20)
+		b = a / 32
+		u32test(a, b, 32)
+		b = a / 60
+		u32test(a, b, 60)
+		b = a / 64
+		u32test(a, b, 64)
+		b = a / 128
+		u32test(a, b, 128)
+		b = a / 256
+		u32test(a, b, 256)
+		b = a / 16384
+		u32test(a, b, 16384)
 	}
 }
 
-func
-i16rand() int16 {
+func i16rand() int16 {
 	for {
-		a := int16(rand.Uint32());
-		a >>= uint(rand.Intn(16));
+		a := int16(rand.Uint32())
+		a >>= uint(rand.Intn(16))
 		if -a != a {
-			return a;
+			return a
 		}
 	}
-	return 0;	// impossible
+	return 0 // impossible
 }
 
-func
-i16test(a,b,c int16) {
-	d := a/c;
+func i16test(a, b, c int16) {
+	d := a / c
 	if d != b {
-		panicln("i16", a, b, c, d);
+		println("i16", a, b, c, d)
+		panic("fail")
 	}
 }
 
-func
-i16run() {
-	var a, b int16;
-
-	for i:=0; i<Count; i++ {
-		a = i16rand();
-
-		b = a/1;	i16test(a,b,1);
-		b = a/2;	i16test(a,b,2);
-		b = a/3;	i16test(a,b,3);
-		b = a/4;	i16test(a,b,4);
-		b = a/5;	i16test(a,b,5);
-		b = a/6;	i16test(a,b,6);
-		b = a/7;	i16test(a,b,7);
-		b = a/8;	i16test(a,b,8);
-		b = a/10;	i16test(a,b,10);
-		b = a/16;	i16test(a,b,16);
-		b = a/20;	i16test(a,b,20);
-		b = a/32;	i16test(a,b,32);
-		b = a/60;	i16test(a,b,60);
-		b = a/64;	i16test(a,b,64);
-		b = a/128;	i16test(a,b,128);
-		b = a/256;	i16test(a,b,256);
-		b = a/16384;	i16test(a,b,16384);
-
-		b = a/-1;	i16test(a,b,-1);
-		b = a/-2;	i16test(a,b,-2);
-		b = a/-3;	i16test(a,b,-3);
-		b = a/-4;	i16test(a,b,-4);
-		b = a/-5;	i16test(a,b,-5);
-		b = a/-6;	i16test(a,b,-6);
-		b = a/-7;	i16test(a,b,-7);
-		b = a/-8;	i16test(a,b,-8);
-		b = a/-10;	i16test(a,b,-10);
-		b = a/-16;	i16test(a,b,-16);
-		b = a/-20;	i16test(a,b,-20);
-		b = a/-32;	i16test(a,b,-32);
-		b = a/-60;	i16test(a,b,-60);
-		b = a/-64;	i16test(a,b,-64);
-		b = a/-128;	i16test(a,b,-128);
-		b = a/-256;	i16test(a,b,-256);
-		b = a/-16384;	i16test(a,b,-16384);
+func i16run() {
+	var a, b int16
+
+	for i := 0; i < Count; i++ {
+		a = i16rand()
+
+		b = a / 1
+		i16test(a, b, 1)
+		b = a / 2
+		i16test(a, b, 2)
+		b = a / 3
+		i16test(a, b, 3)
+		b = a / 4
+		i16test(a, b, 4)
+		b = a / 5
+		i16test(a, b, 5)
+		b = a / 6
+		i16test(a, b, 6)
+		b = a / 7
+		i16test(a, b, 7)
+		b = a / 8
+		i16test(a, b, 8)
+		b = a / 10
+		i16test(a, b, 10)
+		b = a / 16
+		i16test(a, b, 16)
+		b = a / 20
+		i16test(a, b, 20)
+		b = a / 32
+		i16test(a, b, 32)
+		b = a / 60
+		i16test(a, b, 60)
+		b = a / 64
+		i16test(a, b, 64)
+		b = a / 128
+		i16test(a, b, 128)
+		b = a / 256
+		i16test(a, b, 256)
+		b = a / 16384
+		i16test(a, b, 16384)
+
+		b = a / -1
+		i16test(a, b, -1)
+		b = a / -2
+		i16test(a, b, -2)
+		b = a / -3
+		i16test(a, b, -3)
+		b = a / -4
+		i16test(a, b, -4)
+		b = a / -5
+		i16test(a, b, -5)
+		b = a / -6
+		i16test(a, b, -6)
+		b = a / -7
+		i16test(a, b, -7)
+		b = a / -8
+		i16test(a, b, -8)
+		b = a / -10
+		i16test(a, b, -10)
+		b = a / -16
+		i16test(a, b, -16)
+		b = a / -20
+		i16test(a, b, -20)
+		b = a / -32
+		i16test(a, b, -32)
+		b = a / -60
+		i16test(a, b, -60)
+		b = a / -64
+		i16test(a, b, -64)
+		b = a / -128
+		i16test(a, b, -128)
+		b = a / -256
+		i16test(a, b, -256)
+		b = a / -16384
+		i16test(a, b, -16384)
 	}
 }
 
-func
-u16rand() uint16 {
-	a := uint16(rand.Uint32());
-	a >>= uint(rand.Intn(16));
-	return a;
+func u16rand() uint16 {
+	a := uint16(rand.Uint32())
+	a >>= uint(rand.Intn(16))
+	return a
 }
 
-func
-u16test(a,b,c uint16) {
-	d := a/c;
+func u16test(a, b, c uint16) {
+	d := a / c
 	if d != b {
-		panicln("u16", a, b, c, d);
+		println("u16", a, b, c, d)
+		panic("fail")
 	}
 }
 
-func
-u16run() {
-	var a, b uint16;
-
-	for i:=0; i<Count; i++ {
-		a = u16rand();
-
-		b = a/1;	u16test(a,b,1);
-		b = a/2;	u16test(a,b,2);
-		b = a/3;	u16test(a,b,3);
-		b = a/4;	u16test(a,b,4);
-		b = a/5;	u16test(a,b,5);
-		b = a/6;	u16test(a,b,6);
-		b = a/7;	u16test(a,b,7);
-		b = a/8;	u16test(a,b,8);
-		b = a/10;	u16test(a,b,10);
-		b = a/16;	u16test(a,b,16);
-		b = a/20;	u16test(a,b,20);
-		b = a/32;	u16test(a,b,32);
-		b = a/60;	u16test(a,b,60);
-		b = a/64;	u16test(a,b,64);
-		b = a/128;	u16test(a,b,128);
-		b = a/256;	u16test(a,b,256);
-		b = a/16384;	u16test(a,b,16384);
+func u16run() {
+	var a, b uint16
+
+	for i := 0; i < Count; i++ {
+		a = u16rand()
+
+		b = a / 1
+		u16test(a, b, 1)
+		b = a / 2
+		u16test(a, b, 2)
+		b = a / 3
+		u16test(a, b, 3)
+		b = a / 4
+		u16test(a, b, 4)
+		b = a / 5
+		u16test(a, b, 5)
+		b = a / 6
+		u16test(a, b, 6)
+		b = a / 7
+		u16test(a, b, 7)
+		b = a / 8
+		u16test(a, b, 8)
+		b = a / 10
+		u16test(a, b, 10)
+		b = a / 16
+		u16test(a, b, 16)
+		b = a / 20
+		u16test(a, b, 20)
+		b = a / 32
+		u16test(a, b, 32)
+		b = a / 60
+		u16test(a, b, 60)
+		b = a / 64
+		u16test(a, b, 64)
+		b = a / 128
+		u16test(a, b, 128)
+		b = a / 256
+		u16test(a, b, 256)
+		b = a / 16384
+		u16test(a, b, 16384)
 	}
 }
 
-func
-i8rand() int8 {
+func i8rand() int8 {
 	for {
-		a := int8(rand.Uint32());
-		a >>= uint(rand.Intn(8));
+		a := int8(rand.Uint32())
+		a >>= uint(rand.Intn(8))
 		if -a != a {
-			return a;
+			return a
 		}
 	}
-	return 0;	// impossible
+	return 0 // impossible
 }
 
-func
-i8test(a,b,c int8) {
-	d := a/c;
+func i8test(a, b, c int8) {
+	d := a / c
 	if d != b {
-		panicln("i8", a, b, c, d);
+		println("i8", a, b, c, d)
+		panic("fail")
 	}
 }
 
-func
-i8run() {
-	var a, b int8;
-
-	for i:=0; i<Count; i++ {
-		a = i8rand();
-
-		b = a/1;	i8test(a,b,1);
-		b = a/2;	i8test(a,b,2);
-		b = a/3;	i8test(a,b,3);
-		b = a/4;	i8test(a,b,4);
-		b = a/5;	i8test(a,b,5);
-		b = a/6;	i8test(a,b,6);
-		b = a/7;	i8test(a,b,7);
-		b = a/8;	i8test(a,b,8);
-		b = a/10;	i8test(a,b,10);
-		b = a/8;	i8test(a,b,8);
-		b = a/20;	i8test(a,b,20);
-		b = a/32;	i8test(a,b,32);
-		b = a/60;	i8test(a,b,60);
-		b = a/64;	i8test(a,b,64);
-		b = a/127;	i8test(a,b,127);
-
-		b = a/-1;	i8test(a,b,-1);
-		b = a/-2;	i8test(a,b,-2);
-		b = a/-3;	i8test(a,b,-3);
-		b = a/-4;	i8test(a,b,-4);
-		b = a/-5;	i8test(a,b,-5);
-		b = a/-6;	i8test(a,b,-6);
-		b = a/-7;	i8test(a,b,-7);
-		b = a/-8;	i8test(a,b,-8);
-		b = a/-10;	i8test(a,b,-10);
-		b = a/-8;	i8test(a,b,-8);
-		b = a/-20;	i8test(a,b,-20);
-		b = a/-32;	i8test(a,b,-32);
-		b = a/-60;	i8test(a,b,-60);
-		b = a/-64;	i8test(a,b,-64);
-		b = a/-128;	i8test(a,b,-128);
+func i8run() {
+	var a, b int8
+
+	for i := 0; i < Count; i++ {
+		a = i8rand()
+
+		b = a / 1
+		i8test(a, b, 1)
+		b = a / 2
+		i8test(a, b, 2)
+		b = a / 3
+		i8test(a, b, 3)
+		b = a / 4
+		i8test(a, b, 4)
+		b = a / 5
+		i8test(a, b, 5)
+		b = a / 6
+		i8test(a, b, 6)
+		b = a / 7
+		i8test(a, b, 7)
+		b = a / 8
+		i8test(a, b, 8)
+		b = a / 10
+		i8test(a, b, 10)
+		b = a / 8
+		i8test(a, b, 8)
+		b = a / 20
+		i8test(a, b, 20)
+		b = a / 32
+		i8test(a, b, 32)
+		b = a / 60
+		i8test(a, b, 60)
+		b = a / 64
+		i8test(a, b, 64)
+		b = a / 127
+		i8test(a, b, 127)
+
+		b = a / -1
+		i8test(a, b, -1)
+		b = a / -2
+		i8test(a, b, -2)
+		b = a / -3
+		i8test(a, b, -3)
+		b = a / -4
+		i8test(a, b, -4)
+		b = a / -5
+		i8test(a, b, -5)
+		b = a / -6
+		i8test(a, b, -6)
+		b = a / -7
+		i8test(a, b, -7)
+		b = a / -8
+		i8test(a, b, -8)
+		b = a / -10
+		i8test(a, b, -10)
+		b = a / -8
+		i8test(a, b, -8)
+		b = a / -20
+		i8test(a, b, -20)
+		b = a / -32
+		i8test(a, b, -32)
+		b = a / -60
+		i8test(a, b, -60)
+		b = a / -64
+		i8test(a, b, -64)
+		b = a / -128
+		i8test(a, b, -128)
 	}
 }
 
-func
-u8rand() uint8 {
-	a := uint8(rand.Uint32());
-	a >>= uint(rand.Intn(8));
-	return a;
+func u8rand() uint8 {
+	a := uint8(rand.Uint32())
+	a >>= uint(rand.Intn(8))
+	return a
 }
 
-func
-u8test(a,b,c uint8) {
-	d := a/c;
+func u8test(a, b, c uint8) {
+	d := a / c
 	if d != b {
-		panicln("u8", a, b, c, d);
+		println("u8", a, b, c, d)
+		panic("fail")
 	}
 }
 
-func
-u8run() {
-	var a, b uint8;
-
-	for i:=0; i<Count; i++ {
-		a = u8rand();
-
-		b = a/1;	u8test(a,b,1);
-		b = a/2;	u8test(a,b,2);
-		b = a/3;	u8test(a,b,3);
-		b = a/4;	u8test(a,b,4);
-		b = a/5;	u8test(a,b,5);
-		b = a/6;	u8test(a,b,6);
-		b = a/7;	u8test(a,b,7);
-		b = a/8;	u8test(a,b,8);
-		b = a/10;	u8test(a,b,10);
-		b = a/8;	u8test(a,b,8);
-		b = a/20;	u8test(a,b,20);
-		b = a/32;	u8test(a,b,32);
-		b = a/60;	u8test(a,b,60);
-		b = a/64;	u8test(a,b,64);
-		b = a/128;	u8test(a,b,128);
-		b = a/184;	u8test(a,b,184);
+func u8run() {
+	var a, b uint8
+
+	for i := 0; i < Count; i++ {
+		a = u8rand()
+
+		b = a / 1
+		u8test(a, b, 1)
+		b = a / 2
+		u8test(a, b, 2)
+		b = a / 3
+		u8test(a, b, 3)
+		b = a / 4
+		u8test(a, b, 4)
+		b = a / 5
+		u8test(a, b, 5)
+		b = a / 6
+		u8test(a, b, 6)
+		b = a / 7
+		u8test(a, b, 7)
+		b = a / 8
+		u8test(a, b, 8)
+		b = a / 10
+		u8test(a, b, 10)
+		b = a / 8
+		u8test(a, b, 8)
+		b = a / 20
+		u8test(a, b, 20)
+		b = a / 32
+		u8test(a, b, 32)
+		b = a / 60
+		u8test(a, b, 60)
+		b = a / 64
+		u8test(a, b, 64)
+		b = a / 128
+		u8test(a, b, 128)
+		b = a / 184
+		u8test(a, b, 184)
 	}
 }
 
-func
-main() {
-	xtest();
-	i64run();
-	u64run();
-	i32run();
-	u32run();
-	i16run();
-	u16run();
-	i8run();
-	u8run();
+func main() {
+	xtest()
+	i64run()
+	u64run()
+	i32run()
+	u32run()
+	i16run()
+	u16run()
+	i8run()
+	u8run()
 }
 
-func
-xtest() {
+func xtest() {
 }
diff --git a/test/ken/divmod.go b/test/ken/divmod.go
index 73c26927b..dc44ea245 100644
--- a/test/ken/divmod.go
+++ b/test/ken/divmod.go
@@ -6,205 +6,242 @@
 
 package main
 
-const
-(
+const (
 	// example from the spec
-	n1	= +5;
-	n2	= -5;
-	d1	= +3;
-	d2	= -3;
-
-	q1	= +1;
-	q2	= -1;
-	q3	= -1;
-	q4	= +1;
-
-	r1	= +2;
-	r2	= -2;
-	r3	= +2;
-	r4	= -2;
+	n1 = +5
+	n2 = -5
+	d1 = +3
+	d2 = -3
+
+	q1 = +1
+	q2 = -1
+	q3 = -1
+	q4 = +1
+
+	r1 = +2
+	r2 = -2
+	r3 = +2
+	r4 = -2
 )
 
-func
-main() {
+func main() {
 	/* ideals */
 	if n1/d1 != q1 || n1%d1 != r1 {
-		panicln("ideal-1", n1, d1, n1/d1, n1%d1);
+		println("ideal-1", n1, d1, n1/d1, n1%d1)
+		panic("fail")
 	}
 	if n2/d1 != q2 || n2%d1 != r2 {
-		panicln("ideal-2", n2, d1, n2/d1, n2%d1);
+		println("ideal-2", n2, d1, n2/d1, n2%d1)
+		panic("fail")
 	}
 	if n1/d2 != q3 || n1%d2 != r3 {
-		panicln("ideal-3", n1, d2, n1/d2, n1%d2);
+		println("ideal-3", n1, d2, n1/d2, n1%d2)
+		panic("fail")
 	}
 	if n2/d2 != q4 || n2%d2 != r4 {
-		panicln("ideal-4", n2, d2, n2/d2, n2%d2);
+		println("ideal-4", n2, d2, n2/d2, n2%d2)
+		panic("fail")
 	}
 
 	/* int */
-	var in1 int = +5;
-	var in2 int = -5;
-	var id1 int = +3;
-	var id2 int = -3;
+	var in1 int = +5
+	var in2 int = -5
+	var id1 int = +3
+	var id2 int = -3
 
 	if in1/id1 != q1 || in1%id1 != r1 {
-		panicln("int-1", in1, id1, in1/id1, in1%id1);
+		println("int-1", in1, id1, in1/id1, in1%id1)
+		panic("fail")
 	}
 	if in2/id1 != q2 || in2%id1 != r2 {
-		panicln("int-2", in2, id1, in2/id1, in2%id1);
+		println("int-2", in2, id1, in2/id1, in2%id1)
+		panic("fail")
 	}
 	if in1/id2 != q3 || in1%id2 != r3 {
-		panicln("int-3", in1, id2, in1/id2, in1%id2);
+		println("int-3", in1, id2, in1/id2, in1%id2)
+		panic("fail")
 	}
 	if in2/id2 != q4 || in2%id2 != r4 {
-		panicln("int-4", in2, id2, in2/id2, in2%id2);
+		println("int-4", in2, id2, in2/id2, in2%id2)
+		panic("fail")
 	}
 
 	/* int8 */
-	var bn1 int8 = +5;
-	var bn2 int8 = -5;
-	var bd1 int8 = +3;
-	var bd2 int8 = -3;
+	var bn1 int8 = +5
+	var bn2 int8 = -5
+	var bd1 int8 = +3
+	var bd2 int8 = -3
 
 	if bn1/bd1 != q1 || bn1%bd1 != r1 {
-		panicln("int8-1", bn1, bd1, bn1/bd1, bn1%bd1);
+		println("int8-1", bn1, bd1, bn1/bd1, bn1%bd1)
+		panic("fail")
 	}
 	if bn2/bd1 != q2 || bn2%bd1 != r2 {
-		panicln("int8-2", bn2, bd1, bn2/bd1, bn2%bd1);
+		println("int8-2", bn2, bd1, bn2/bd1, bn2%bd1)
+		panic("fail")
 	}
 	if bn1/bd2 != q3 || bn1%bd2 != r3 {
-		panicln("int8-3", bn1, bd2, bn1/bd2, bn1%bd2);
+		println("int8-3", bn1, bd2, bn1/bd2, bn1%bd2)
+		panic("fail")
 	}
 	if bn2/bd2 != q4 || bn2%bd2 != r4 {
-		panicln("int8-4", bn2, bd2, bn2/bd2, bn2%bd2);
+		println("int8-4", bn2, bd2, bn2/bd2, bn2%bd2)
+		panic("fail")
 	}
 
 	/* int16 */
-	var sn1 int16 = +5;
-	var sn2 int16 = -5;
-	var sd1 int16 = +3;
-	var sd2 int16 = -3;
+	var sn1 int16 = +5
+	var sn2 int16 = -5
+	var sd1 int16 = +3
+	var sd2 int16 = -3
 
 	if sn1/sd1 != q1 || sn1%sd1 != r1 {
-		panicln("int16-1", sn1, sd1, sn1/sd1, sn1%sd1);
+		println("int16-1", sn1, sd1, sn1/sd1, sn1%sd1)
+		panic("fail")
 	}
 	if sn2/sd1 != q2 || sn2%sd1 != r2 {
-		panicln("int16-2", sn2, sd1, sn2/sd1, sn2%sd1);
+		println("int16-2", sn2, sd1, sn2/sd1, sn2%sd1)
+		panic("fail")
 	}
 	if sn1/sd2 != q3 || sn1%sd2 != r3 {
-		panicln("int16-3", sn1, sd2, sn1/sd2, sn1%sd2);
+		println("int16-3", sn1, sd2, sn1/sd2, sn1%sd2)
+		panic("fail")
 	}
 	if sn2/sd2 != q4 || sn2%sd2 != r4 {
-		panicln("int16-4", sn2, sd2, sn2/sd2, sn2%sd2);
+		println("int16-4", sn2, sd2, sn2/sd2, sn2%sd2)
+		panic("fail")
 	}
 
 	/* int32 */
-	var ln1 int32 = +5;
-	var ln2 int32 = -5;
-	var ld1 int32 = +3;
-	var ld2 int32 = -3;
+	var ln1 int32 = +5
+	var ln2 int32 = -5
+	var ld1 int32 = +3
+	var ld2 int32 = -3
 
 	if ln1/ld1 != q1 || ln1%ld1 != r1 {
-		panicln("int32-1", ln1, ld1, ln1/ld1, ln1%ld1);
+		println("int32-1", ln1, ld1, ln1/ld1, ln1%ld1)
+		panic("fail")
 	}
 	if ln2/ld1 != q2 || ln2%ld1 != r2 {
-		panicln("int32-2", ln2, ld1, ln2/ld1, ln2%ld1);
+		println("int32-2", ln2, ld1, ln2/ld1, ln2%ld1)
+		panic("fail")
 	}
 	if ln1/ld2 != q3 || ln1%ld2 != r3 {
-		panicln("int32-3", ln1, ld2, ln1/ld2, ln1%ld2);
+		println("int32-3", ln1, ld2, ln1/ld2, ln1%ld2)
+		panic("fail")
 	}
 	if ln2/ld2 != q4 || ln2%ld2 != r4 {
-		panicln("int32-4", ln2, ld2, ln2/ld2, ln2%ld2);
+		println("int32-4", ln2, ld2, ln2/ld2, ln2%ld2)
+		panic("fail")
 	}
 
 	/* int64 */
-	var qn1 int64 = +5;
-	var qn2 int64 = -5;
-	var qd1 int64 = +3;
-	var qd2 int64 = -3;
+	var qn1 int64 = +5
+	var qn2 int64 = -5
+	var qd1 int64 = +3
+	var qd2 int64 = -3
 
 	if qn1/qd1 != q1 || qn1%qd1 != r1 {
-		panicln("int64-1", qn1, qd1, qn1/qd1, qn1%qd1);
+		println("int64-1", qn1, qd1, qn1/qd1, qn1%qd1)
+		panic("fail")
 	}
 	if qn2/qd1 != q2 || qn2%qd1 != r2 {
-		panicln("int64-2", qn2, qd1, qn2/qd1, qn2%qd1);
+		println("int64-2", qn2, qd1, qn2/qd1, qn2%qd1)
+		panic("fail")
 	}
 	if qn1/qd2 != q3 || qn1%qd2 != r3 {
-		panicln("int64-3", qn1, qd2, qn1/qd2, qn1%qd2);
+		println("int64-3", qn1, qd2, qn1/qd2, qn1%qd2)
+		panic("fail")
 	}
 	if qn2/qd2 != q4 || qn2%qd2 != r4 {
-		panicln("int64-4", qn2, qd2, qn2/qd2, qn2%qd2);
+		println("int64-4", qn2, qd2, qn2/qd2, qn2%qd2)
+		panic("fail")
 	}
 
 	if n1/qd1 != q1 || n1%qd1 != r1 {
-		panicln("mixed int64-1", n1, qd1, n1/qd1, n1%qd1);
+		println("mixed int64-1", n1, qd1, n1/qd1, n1%qd1)
+		panic("fail")
 	}
 	if n2/qd1 != q2 || n2%qd1 != r2 {
-		panicln("mixed int64-2", n2, qd1, n2/qd1, n2%qd1);
+		println("mixed int64-2", n2, qd1, n2/qd1, n2%qd1)
+		panic("fail")
 	}
 	if n1/qd2 != q3 || n1%qd2 != r3 {
-		panicln("mixed int64-3", n1, qd2, n1/qd2, n1%qd2);
+		println("mixed int64-3", n1, qd2, n1/qd2, n1%qd2)
+		panic("fail")
 	}
 	if n2/qd2 != q4 || n2%qd2 != r4 {
-		panicln("mixed int64-4", n2, qd2, n2/qd2, n2%qd2);
+		println("mixed int64-4", n2, qd2, n2/qd2, n2%qd2)
+		panic("fail")
 	}
 
 	if qn1/d1 != q1 || qn1%d1 != r1 {
-		panicln("mixed int64-5", qn1, d1, qn1/d1, qn1%d1);
+		println("mixed int64-5", qn1, d1, qn1/d1, qn1%d1)
+		panic("fail")
 	}
 	if qn2/d1 != q2 || qn2%d1 != r2 {
-		panicln("mixed int64-6", qn2, d1, qn2/d1, qn2%d1);
+		println("mixed int64-6", qn2, d1, qn2/d1, qn2%d1)
+		panic("fail")
 	}
 	if qn1/d2 != q3 || qn1%d2 != r3 {
-		panicln("mixed int64-7", qn1, d2, qn1/d2, qn1%d2);
+		println("mixed int64-7", qn1, d2, qn1/d2, qn1%d2)
+		panic("fail")
 	}
 	if qn2/d2 != q4 || qn2%d2 != r4 {
-		panicln("mixed int64-8", qn2, d2, qn2/d2, qn2%d2);
+		println("mixed int64-8", qn2, d2, qn2/d2, qn2%d2)
+		panic("fail")
 	}
 
 	/* uint */
-	var uin1 uint = +5;
-	var uid1 uint = +3;
+	var uin1 uint = +5
+	var uid1 uint = +3
 
 	if uin1/uid1 != q1 || uin1%uid1 != r1 {
-		panicln("uint", uin1, uid1, uin1/uid1, uin1%uid1);
+		println("uint", uin1, uid1, uin1/uid1, uin1%uid1)
+		panic("fail")
 	}
 
 	/* uint8 */
-	var ubn1 uint8 = +5;
-	var ubd1 uint8 = +3;
+	var ubn1 uint8 = +5
+	var ubd1 uint8 = +3
 
 	if ubn1/ubd1 != q1 || ubn1%ubd1 != r1 {
-		panicln("uint8", ubn1, ubd1, ubn1/ubd1, ubn1%ubd1);
+		println("uint8", ubn1, ubd1, ubn1/ubd1, ubn1%ubd1)
+		panic("fail")
 	}
 
 	/* uint16 */
-	var usn1 uint16 = +5;
-	var usd1 uint16 = +3;
+	var usn1 uint16 = +5
+	var usd1 uint16 = +3
 
 	if usn1/usd1 != q1 || usn1%usd1 != r1 {
-		panicln("uint16", usn1, usd1, usn1/usd1, usn1%usd1);
+		println("uint16", usn1, usd1, usn1/usd1, usn1%usd1)
+		panic("fail")
 	}
 
 	/* uint32 */
-	var uln1 uint32 = +5;
-	var uld1 uint32 = +3;
+	var uln1 uint32 = +5
+	var uld1 uint32 = +3
 
 	if uln1/uld1 != q1 || uln1%uld1 != r1 {
-		panicln("uint32", uln1, uld1, uln1/uld1, uln1%uld1);
+		println("uint32", uln1, uld1, uln1/uld1, uln1%uld1)
+		panic("fail")
 	}
 
 	/* uint64 */
-	var uqn1 uint64 = +5;
-	var uqd1 uint64 = +3;
+	var uqn1 uint64 = +5
+	var uqd1 uint64 = +3
 
 	if uqn1/uqd1 != q1 || uqn1%uqd1 != r1 {
-		panicln("uint64", uqn1, uqd1, uqn1/uqd1, uqn1%uqd1);
+		println("uint64", uqn1, uqd1, uqn1/uqd1, uqn1%uqd1)
+		panic("fail")
 	}
 	if n1/uqd1 != q1 || n1%uqd1 != r1 {
-		panicln("mixed uint64-1", n1, uqd1, n1/uqd1, n1%uqd1);
+		println("mixed uint64-1", n1, uqd1, n1/uqd1, n1%uqd1)
+		panic("fail")
 	}
 	if uqn1/d1 != q1 || uqn1%d1 != r1 {
-		panicln("mixed uint64-2", uqn1, d1, uqn1/d1, uqn1%d1);
+		println("mixed uint64-2", uqn1, d1, uqn1/d1, uqn1%d1)
+		panic("fail")
 	}
 }
diff --git a/test/ken/embed.go b/test/ken/embed.go
index 893485bfa..9805e479b 100644
--- a/test/ken/embed.go
+++ b/test/ken/embed.go
@@ -7,63 +7,67 @@
 package main
 
 
-type
-I	interface {
-	test1() int;
-	test2() int;
-	test3() int;
-	test4() int;
-	test5() int;
-	test6() int;
-	test7() int;
-};
+type I interface {
+	test1() int
+	test2() int
+	test3() int
+	test4() int
+	test5() int
+	test6() int
+	test7() int
+}
 
 /******
  ******
  ******/
 
-type
-SubpSubp	struct {
-	a7	int;
-	a	int;
+type SubpSubp struct {
+	a7 int
+	a  int
 }
+
 func (p *SubpSubp) test7() int {
-	if p.a != p.a7 { panicln("SubpSubp", p, p.a7) }
+	if p.a != p.a7 {
+		println("SubpSubp", p, p.a7)
+		panic("fail")
+	}
 	return p.a
 }
-func (p *SubpSubp) testx() {
-	println("SubpSubp", p, p.a7);
-}
+func (p *SubpSubp) testx() { println("SubpSubp", p, p.a7) }
 
 /******
  ******
  ******/
 
-type
-SubpSub	struct {
-	a6	int;
-		SubpSubp;
-	a	int;
+type SubpSub struct {
+	a6 int
+	SubpSubp
+	a int
 }
+
 func (p *SubpSub) test6() int {
-	if p.a != p.a6 { panicln("SubpSub", p, p.a6) }
+	if p.a != p.a6 {
+		println("SubpSub", p, p.a6)
+		panic("fail")
+	}
 	return p.a
 }
-func (p *SubpSub) testx() {
-	println("SubpSub", p, p.a6);
-}
+func (p *SubpSub) testx() { println("SubpSub", p, p.a6) }
 
 /******
  ******
  ******/
 
-type
-SubSubp	struct {
-	a5	int;
-	a	int;
+type SubSubp struct {
+	a5 int
+	a  int
 }
+
 func (p *SubSubp) test5() int {
-	if p.a != p.a5 { panicln("SubpSub", p, p.a5) }
+	if p.a != p.a5 {
+		println("SubpSub", p, p.a5)
+		panic("fail")
+	}
 	return p.a
 }
 
@@ -71,13 +75,16 @@ func (p *SubSubp) test5() int {
  ******
  ******/
 
-type
-SubSub	struct {
-	a4	int;
-	a	int;
+type SubSub struct {
+	a4 int
+	a  int
 }
+
 func (p *SubSub) test4() int {
-	if p.a != p.a4 { panicln("SubpSub", p, p.a4) }
+	if p.a != p.a4 {
+		println("SubpSub", p, p.a4)
+		panic("fail")
+	}
 	return p.a
 }
 
@@ -85,15 +92,18 @@ func (p *SubSub) test4() int {
  ******
  ******/
 
-type
-Subp	struct {
-	a3	int;
-		*SubpSubp;
-		SubpSub;
-	a	int;
+type Subp struct {
+	a3 int
+	*SubpSubp
+	SubpSub
+	a int
 }
+
 func (p *Subp) test3() int {
-	if p.a != p.a3 { panicln("SubpSub", p, p.a3) }
+	if p.a != p.a3 {
+		println("SubpSub", p, p.a3)
+		panic("fail")
+	}
 	return p.a
 }
 
@@ -101,16 +111,18 @@ func (p *Subp) test3() int {
  ******
  ******/
 
-type
-Sub	struct
-{
-	a2	int;
-		*SubSubp;
-		SubSub;
-	a	int;
+type Sub struct {
+	a2 int
+	*SubSubp
+	SubSub
+	a int
 }
+
 func (p *Sub) test2() int {
-	if p.a != p.a2 { panicln("SubpSub", p, p.a2) }
+	if p.a != p.a2 {
+		println("SubpSub", p, p.a2)
+		panic("fail")
+	}
 	return p.a
 }
 
@@ -118,15 +130,18 @@ func (p *Sub) test2() int {
  ******
  ******/
 
-type
-S	struct {
-	a1	int;
-		Sub;
-		*Subp;
-	a	int;
+type S struct {
+	a1 int
+	Sub
+	*Subp
+	a int
 }
+
 func (p *S) test1() int {
-	if p.a != p.a1 { panicln("SubpSub", p, p.a1) }
+	if p.a != p.a1 {
+		println("SubpSub", p, p.a1)
+		panic("fail")
+	}
 	return p.a
 }
 
@@ -134,77 +149,169 @@ func (p *S) test1() int {
  ******
  ******/
 
-func
-main() {
-	var i I;
-	var s *S;
+func main() {
+	var i I
+	var s *S
 
 	// allocate
-	s = new(S);
-	s.Subp = new(Subp);
-	s.Sub.SubSubp = new(SubSubp);
-	s.Subp.SubpSubp = new(SubpSubp);
+	s = new(S)
+	s.Subp = new(Subp)
+	s.Sub.SubSubp = new(SubSubp)
+	s.Subp.SubpSubp = new(SubpSubp)
 
 	// explicit assignment
-	s.a = 1;
-	s.Sub.a = 2;
-	s.Subp.a = 3;
-	s.Sub.SubSub.a = 4;
-	s.Sub.SubSubp.a = 5;
-	s.Subp.SubpSub.a = 6;
-	s.Subp.SubpSubp.a = 7;
+	s.a = 1
+	s.Sub.a = 2
+	s.Subp.a = 3
+	s.Sub.SubSub.a = 4
+	s.Sub.SubSubp.a = 5
+	s.Subp.SubpSub.a = 6
+	s.Subp.SubpSubp.a = 7
 
 	// embedded (unique) assignment
-	s.a1 = 1;
-	s.a2 = 2;
-	s.a3 = 3;
-	s.a4 = 4;
-	s.a5 = 5;
-	s.a6 = 6;
-	s.a7 = 7;
+	s.a1 = 1
+	s.a2 = 2
+	s.a3 = 3
+	s.a4 = 4
+	s.a5 = 5
+	s.a6 = 6
+	s.a7 = 7
 
 	// unique calls with explicit &
-	if s.test1() != 1 { panicln("t1", 1) }
-	if (&s.Sub).test2() != 2 { panicln("t1", 2) }
-	if s.Subp.test3() != 3 { panicln("t1", 3) }
-	if (&s.Sub.SubSub).test4() != 4 { panicln("t1", 4) }
-	if s.Sub.SubSubp.test5() != 5 { panicln("t1", 5) }
-	if (&s.Subp.SubpSub).test6() != 6 { panicln("t1", 6) }
-	if s.Subp.SubpSubp.test7() != 7 { panicln("t1", 7) }
+	if s.test1() != 1 {
+		println("t1", 1)
+		panic("fail")
+	}
+	if (&s.Sub).test2() != 2 {
+		println("t1", 2)
+		panic("fail")
+	}
+	if s.Subp.test3() != 3 {
+		println("t1", 3)
+		panic("fail")
+	}
+	if (&s.Sub.SubSub).test4() != 4 {
+		println("t1", 4)
+		panic("fail")
+	}
+	if s.Sub.SubSubp.test5() != 5 {
+		println("t1", 5)
+		panic("fail")
+	}
+	if (&s.Subp.SubpSub).test6() != 6 {
+		println("t1", 6)
+		panic("fail")
+	}
+	if s.Subp.SubpSubp.test7() != 7 {
+		println("t1", 7)
+		panic("fail")
+	}
 
 	// automatic &
-	if s.Sub.test2() != 2 { panicln("t2", 2) }
-	if s.Sub.SubSub.test4() != 4 { panicln("t2", 4) }
-	if s.Subp.SubpSub.test6() != 6 { panicln("t2", 6) }
+	if s.Sub.test2() != 2 {
+		println("t2", 2)
+		panic("fail")
+	}
+	if s.Sub.SubSub.test4() != 4 {
+		println("t2", 4)
+		panic("fail")
+	}
+	if s.Subp.SubpSub.test6() != 6 {
+		println("t2", 6)
+		panic("fail")
+	}
 
 	// embedded calls
-	if s.test1() != s.a1 { panicln("t3", 1) }
-	if s.test2() != s.a2 { panicln("t3", 2) }
-	if s.test3() != s.a3 { panicln("t3", 3) }
-	if s.test4() != s.a4 { panicln("t3", 4) }
-	if s.test5() != s.a5 { panicln("t3", 5) }
-	if s.test6() != s.a6 { panicln("t3", 6) }
-	if s.test7() != s.a7 { panicln("t3", 7) }
+	if s.test1() != s.a1 {
+		println("t3", 1)
+		panic("fail")
+	}
+	if s.test2() != s.a2 {
+		println("t3", 2)
+		panic("fail")
+	}
+	if s.test3() != s.a3 {
+		println("t3", 3)
+		panic("fail")
+	}
+	if s.test4() != s.a4 {
+		println("t3", 4)
+		panic("fail")
+	}
+	if s.test5() != s.a5 {
+		println("t3", 5)
+		panic("fail")
+	}
+	if s.test6() != s.a6 {
+		println("t3", 6)
+		panic("fail")
+	}
+	if s.test7() != s.a7 {
+		println("t3", 7)
+		panic("fail")
+	}
 
 	// run it thru an interface
-	i = s;
-	s = i.(*S);
+	i = s
+	s = i.(*S)
 
 	// same as t3
-	if s.test1() != s.a1 { panicln("t4", 1) }
-	if s.test2() != s.a2 { panicln("t4", 2) }
-	if s.test3() != s.a3 { panicln("t4", 3) }
-	if s.test4() != s.a4 { panicln("t4", 4) }
-	if s.test5() != s.a5 { panicln("t4", 5) }
-	if s.test6() != s.a6 { panicln("t4", 6) }
-	if s.test7() != s.a7 { panicln("t4", 7) }
+	if s.test1() != s.a1 {
+		println("t4", 1)
+		panic("fail")
+	}
+	if s.test2() != s.a2 {
+		println("t4", 2)
+		panic("fail")
+	}
+	if s.test3() != s.a3 {
+		println("t4", 3)
+		panic("fail")
+	}
+	if s.test4() != s.a4 {
+		println("t4", 4)
+		panic("fail")
+	}
+	if s.test5() != s.a5 {
+		println("t4", 5)
+		panic("fail")
+	}
+	if s.test6() != s.a6 {
+		println("t4", 6)
+		panic("fail")
+	}
+	if s.test7() != s.a7 {
+		println("t4", 7)
+		panic("fail")
+	}
 
 	// call interface
-	if i.test1() != s.test1() { panicln("t5", 1) }
-	if i.test2() != s.test2() { panicln("t5", 2) }
-	if i.test3() != s.test3() { panicln("t5", 3) }
-	if i.test4() != s.test4() { panicln("t5", 4) }
-	if i.test5() != s.test5() { panicln("t5", 5) }
-	if i.test6() != s.test6() { panicln("t5", 6) }
-	if i.test7() != s.test7() { panicln("t5", 7) }
+	if i.test1() != s.test1() {
+		println("t5", 1)
+		panic("fail")
+	}
+	if i.test2() != s.test2() {
+		println("t5", 2)
+		panic("fail")
+	}
+	if i.test3() != s.test3() {
+		println("t5", 3)
+		panic("fail")
+	}
+	if i.test4() != s.test4() {
+		println("t5", 4)
+		panic("fail")
+	}
+	if i.test5() != s.test5() {
+		println("t5", 5)
+		panic("fail")
+	}
+	if i.test6() != s.test6() {
+		println("t5", 6)
+		panic("fail")
+	}
+	if i.test7() != s.test7() {
+		println("t5", 7)
+		panic("fail")
+	}
 }
diff --git a/test/ken/interbasic.go b/test/ken/interbasic.go
index 5199c4174..9bb50886a 100644
--- a/test/ken/interbasic.go
+++ b/test/ken/interbasic.go
@@ -6,98 +6,177 @@
 
 package main
 
-type	myint		int;
-type	mystring	string;
-type	I0		interface {};
-
-func
-f() {
-	var ia, ib I0;
-	var i myint;
-	var s mystring;
-
-	if ia != ib { panicln("1"); }
-
-	i = 1;
-	ia = i;
-	ib = i;
-	if ia != ib { panicln("2"); }
-	if ia == nil { panicln("3"); }
-
-	i = 2;
-	ia = i;
-	if ia == ib { panicln("4"); }
-
-	ia = nil;
-	if ia == ib { panicln("5"); }
-
-	ib = nil;
-	if ia != ib { panicln("6"); }
-
-	if ia != nil { panicln("7"); }
-
-	s = "abc";
-	ia = s;
-	ib = nil;
-	if ia == ib { panicln("8"); }
-
-	s = "def";
-	ib = s;
-	if ia == ib { panicln("9"); }
-
-	s = "abc";
-	ib = s;
-	if ia != ib { panicln("a"); }
+type myint int
+type mystring string
+type I0 interface{}
+
+func f() {
+	var ia, ib I0
+	var i myint
+	var s mystring
+
+	if ia != ib {
+		panic("1")
+	}
+
+	i = 1
+	ia = i
+	ib = i
+	if ia != ib {
+		panic("2")
+	}
+	if ia == nil {
+		panic("3")
+	}
+
+	i = 2
+	ia = i
+	if ia == ib {
+		panic("4")
+	}
+
+	ia = nil
+	if ia == ib {
+		panic("5")
+	}
+
+	ib = nil
+	if ia != ib {
+		panic("6")
+	}
+
+	if ia != nil {
+		panic("7")
+	}
+
+	s = "abc"
+	ia = s
+	ib = nil
+	if ia == ib {
+		panic("8")
+	}
+
+	s = "def"
+	ib = s
+	if ia == ib {
+		panic("9")
+	}
+
+	s = "abc"
+	ib = s
+	if ia != ib {
+		panic("a")
+	}
 }
 
-func
-main() {
-	var ia [20]I0;
-	var b bool;
-	var s string;
-	var i8 int8;
-	var i16 int16;
-	var i32 int32;
-	var i64 int64;
-	var u8 uint8;
-	var u16 uint16;
-	var u32 uint32;
-	var u64 uint64;
-
-	f();
-
-	ia[0] = "xxx";
-	ia[1] = 12345;
-	ia[2] = true;
-
-	s = "now is";	ia[3] = s;
-	b = false;	ia[4] = b;
-
-	i8 = 29;	ia[5] = i8;
-	i16 = 994;	ia[6] = i16;
-	i32 = 3434;	ia[7] = i32;
-	i64 = 1234567;	ia[8] = i64;
-
-	u8 = 12;	ia[9] = u8;
-	u16 = 799;	ia[10] = u16;
-	u32 = 4455;	ia[11] = u32;
-	u64 = 765432;	ia[12] = u64;
-
-	s = ia[0].(string);	if s != "xxx" { panicln(0,s); }
-	i32 = int32(ia[1].(int));
-			if i32 != 12345 { panicln(1,i32); }
-	b = ia[2].(bool);	if b != true { panicln(2,b); }
-
-	s = ia[3].(string);	if s != "now is" { panicln(3,s); }
-	b = ia[4].(bool);	if b != false { panicln(4,b); }
-
-	i8 = ia[5].(int8);	if i8 != 29 { panicln(5,i8); }
-	i16 = ia[6].(int16);	if i16 != 994 { panicln(6,i16); }
-	i32 = ia[7].(int32);	if i32 != 3434 { panicln(7,i32); }
-	i64 = ia[8].(int64);	if i64 != 1234567 { panicln(8,i64); }
-
-	u8 = ia[9].(uint8);	if u8 != 12 { panicln(5,u8); }
-	u16 = ia[10].(uint16);	if u16 != 799 { panicln(6,u16); }
-	u32 = ia[11].(uint32);	if u32 != 4455 { panicln(7,u32); }
-	u64 = ia[12].(uint64);	if u64 != 765432 { panicln(8,u64); }
+func main() {
+	var ia [20]I0
+	var b bool
+	var s string
+	var i8 int8
+	var i16 int16
+	var i32 int32
+	var i64 int64
+	var u8 uint8
+	var u16 uint16
+	var u32 uint32
+	var u64 uint64
+
+	f()
+
+	ia[0] = "xxx"
+	ia[1] = 12345
+	ia[2] = true
+
+	s = "now is"
+	ia[3] = s
+	b = false
+	ia[4] = b
+
+	i8 = 29
+	ia[5] = i8
+	i16 = 994
+	ia[6] = i16
+	i32 = 3434
+	ia[7] = i32
+	i64 = 1234567
+	ia[8] = i64
+
+	u8 = 12
+	ia[9] = u8
+	u16 = 799
+	ia[10] = u16
+	u32 = 4455
+	ia[11] = u32
+	u64 = 765432
+	ia[12] = u64
+
+	s = ia[0].(string)
+	if s != "xxx" {
+		println(0, s)
+		panic("fail")
+	}
+	i32 = int32(ia[1].(int))
+	if i32 != 12345 {
+		println(1, i32)
+		panic("fail")
+	}
+	b = ia[2].(bool)
+	if b != true {
+		println(2, b)
+		panic("fail")
+	}
+
+	s = ia[3].(string)
+	if s != "now is" {
+		println(3, s)
+		panic("fail")
+	}
+	b = ia[4].(bool)
+	if b != false {
+		println(4, b)
+		panic("fail")
+	}
+
+	i8 = ia[5].(int8)
+	if i8 != 29 {
+		println(5, i8)
+		panic("fail")
+	}
+	i16 = ia[6].(int16)
+	if i16 != 994 {
+		println(6, i16)
+		panic("fail")
+	}
+	i32 = ia[7].(int32)
+	if i32 != 3434 {
+		println(7, i32)
+		panic("fail")
+	}
+	i64 = ia[8].(int64)
+	if i64 != 1234567 {
+		println(8, i64)
+		panic("fail")
+	}
+
+	u8 = ia[9].(uint8)
+	if u8 != 12 {
+		println(5, u8)
+		panic("fail")
+	}
+	u16 = ia[10].(uint16)
+	if u16 != 799 {
+		println(6, u16)
+		panic("fail")
+	}
+	u32 = ia[11].(uint32)
+	if u32 != 4455 {
+		println(7, u32)
+		panic("fail")
+	}
+	u64 = ia[12].(uint64)
+	if u64 != 765432 {
+		println(8, u64)
+		panic("fail")
+	}
 }
diff --git a/test/ken/modconst.go b/test/ken/modconst.go
index fa53d0b25..acb8831ef 100644
--- a/test/ken/modconst.go
+++ b/test/ken/modconst.go
@@ -6,447 +6,627 @@
 
 package main
 
-import	"rand"
+import "rand"
 
-const	Count	= 1e5
+const Count = 1e5
 
-func
-i64rand() int64 {
+func i64rand() int64 {
 	for {
-		a := int64(rand.Uint32());
-		a = (a<<32) | int64(rand.Uint32());
-		a >>= uint(rand.Intn(64));
+		a := int64(rand.Uint32())
+		a = (a << 32) | int64(rand.Uint32())
+		a >>= uint(rand.Intn(64))
 		if -a != a {
-			return a;
+			return a
 		}
 	}
-	return 0;	// impossible
+	return 0 // impossible
 }
 
-func
-i64test(a,b,c int64) {
-	d := a%c;
+func i64test(a, b, c int64) {
+	d := a % c
 	if d != b {
-		panicln("i64", a, b, c, d);
+		println("i64", a, b, c, d)
+		panic("fail")
 	}
 }
 
-func
-i64run() {
-	var a, b int64;
-
-	for i:=0; i<Count; i++ {
-		a = i64rand();
-
-		b = a%1;	i64test(a,b,1);
-		b = a%2;	i64test(a,b,2);
-		b = a%3;	i64test(a,b,3);
-		b = a%4;	i64test(a,b,4);
-		b = a%5;	i64test(a,b,5);
-		b = a%6;	i64test(a,b,6);
-		b = a%7;	i64test(a,b,7);
-		b = a%8;	i64test(a,b,8);
-		b = a%10;	i64test(a,b,10);
-		b = a%16;	i64test(a,b,16);
-		b = a%20;	i64test(a,b,20);
-		b = a%32;	i64test(a,b,32);
-		b = a%60;	i64test(a,b,60);
-		b = a%64;	i64test(a,b,64);
-		b = a%128;	i64test(a,b,128);
-		b = a%256;	i64test(a,b,256);
-		b = a%16384;	i64test(a,b,16384);
-
-		b = a%-1;	i64test(a,b,-1);
-		b = a%-2;	i64test(a,b,-2);
-		b = a%-3;	i64test(a,b,-3);
-		b = a%-4;	i64test(a,b,-4);
-		b = a%-5;	i64test(a,b,-5);
-		b = a%-6;	i64test(a,b,-6);
-		b = a%-7;	i64test(a,b,-7);
-		b = a%-8;	i64test(a,b,-8);
-		b = a%-10;	i64test(a,b,-10);
-		b = a%-16;	i64test(a,b,-16);
-		b = a%-20;	i64test(a,b,-20);
-		b = a%-32;	i64test(a,b,-32);
-		b = a%-60;	i64test(a,b,-60);
-		b = a%-64;	i64test(a,b,-64);
-		b = a%-128;	i64test(a,b,-128);
-		b = a%-256;	i64test(a,b,-256);
-		b = a%-16384;	i64test(a,b,-16384);
+func i64run() {
+	var a, b int64
+
+	for i := 0; i < Count; i++ {
+		a = i64rand()
+
+		b = a % 1
+		i64test(a, b, 1)
+		b = a % 2
+		i64test(a, b, 2)
+		b = a % 3
+		i64test(a, b, 3)
+		b = a % 4
+		i64test(a, b, 4)
+		b = a % 5
+		i64test(a, b, 5)
+		b = a % 6
+		i64test(a, b, 6)
+		b = a % 7
+		i64test(a, b, 7)
+		b = a % 8
+		i64test(a, b, 8)
+		b = a % 10
+		i64test(a, b, 10)
+		b = a % 16
+		i64test(a, b, 16)
+		b = a % 20
+		i64test(a, b, 20)
+		b = a % 32
+		i64test(a, b, 32)
+		b = a % 60
+		i64test(a, b, 60)
+		b = a % 64
+		i64test(a, b, 64)
+		b = a % 128
+		i64test(a, b, 128)
+		b = a % 256
+		i64test(a, b, 256)
+		b = a % 16384
+		i64test(a, b, 16384)
+
+		b = a % -1
+		i64test(a, b, -1)
+		b = a % -2
+		i64test(a, b, -2)
+		b = a % -3
+		i64test(a, b, -3)
+		b = a % -4
+		i64test(a, b, -4)
+		b = a % -5
+		i64test(a, b, -5)
+		b = a % -6
+		i64test(a, b, -6)
+		b = a % -7
+		i64test(a, b, -7)
+		b = a % -8
+		i64test(a, b, -8)
+		b = a % -10
+		i64test(a, b, -10)
+		b = a % -16
+		i64test(a, b, -16)
+		b = a % -20
+		i64test(a, b, -20)
+		b = a % -32
+		i64test(a, b, -32)
+		b = a % -60
+		i64test(a, b, -60)
+		b = a % -64
+		i64test(a, b, -64)
+		b = a % -128
+		i64test(a, b, -128)
+		b = a % -256
+		i64test(a, b, -256)
+		b = a % -16384
+		i64test(a, b, -16384)
 	}
 }
 
-func
-u64rand() uint64 {
-	a := uint64(rand.Uint32());
-	a = (a<<32) | uint64(rand.Uint32());
-	a >>= uint(rand.Intn(64));
-	return a;
+func u64rand() uint64 {
+	a := uint64(rand.Uint32())
+	a = (a << 32) | uint64(rand.Uint32())
+	a >>= uint(rand.Intn(64))
+	return a
 }
 
-func
-u64test(a,b,c uint64) {
-	d := a%c;
+func u64test(a, b, c uint64) {
+	d := a % c
 	if d != b {
-		panicln("u64", a, b, c, d);
+		println("u64", a, b, c, d)
+		panic("fail")
 	}
 }
 
-func
-u64run() {
-	var a, b uint64;
-
-	for i:=0; i<Count; i++ {
-		a = u64rand();
-
-		b = a%1;	u64test(a,b,1);
-		b = a%2;	u64test(a,b,2);
-		b = a%3;	u64test(a,b,3);
-		b = a%4;	u64test(a,b,4);
-		b = a%5;	u64test(a,b,5);
-		b = a%6;	u64test(a,b,6);
-		b = a%7;	u64test(a,b,7);
-		b = a%8;	u64test(a,b,8);
-		b = a%10;	u64test(a,b,10);
-		b = a%16;	u64test(a,b,16);
-		b = a%20;	u64test(a,b,20);
-		b = a%32;	u64test(a,b,32);
-		b = a%60;	u64test(a,b,60);
-		b = a%64;	u64test(a,b,64);
-		b = a%128;	u64test(a,b,128);
-		b = a%256;	u64test(a,b,256);
-		b = a%16384;	u64test(a,b,16384);
+func u64run() {
+	var a, b uint64
+
+	for i := 0; i < Count; i++ {
+		a = u64rand()
+
+		b = a % 1
+		u64test(a, b, 1)
+		b = a % 2
+		u64test(a, b, 2)
+		b = a % 3
+		u64test(a, b, 3)
+		b = a % 4
+		u64test(a, b, 4)
+		b = a % 5
+		u64test(a, b, 5)
+		b = a % 6
+		u64test(a, b, 6)
+		b = a % 7
+		u64test(a, b, 7)
+		b = a % 8
+		u64test(a, b, 8)
+		b = a % 10
+		u64test(a, b, 10)
+		b = a % 16
+		u64test(a, b, 16)
+		b = a % 20
+		u64test(a, b, 20)
+		b = a % 32
+		u64test(a, b, 32)
+		b = a % 60
+		u64test(a, b, 60)
+		b = a % 64
+		u64test(a, b, 64)
+		b = a % 128
+		u64test(a, b, 128)
+		b = a % 256
+		u64test(a, b, 256)
+		b = a % 16384
+		u64test(a, b, 16384)
 	}
 }
 
-func
-i32rand() int32 {
+func i32rand() int32 {
 	for {
-		a := int32(rand.Uint32());
-		a >>= uint(rand.Intn(32));
+		a := int32(rand.Uint32())
+		a >>= uint(rand.Intn(32))
 		if -a != a {
-			return a;
+			return a
 		}
 	}
-	return 0;	// impossible
+	return 0 // impossible
 }
 
-func
-i32test(a,b,c int32) {
-	d := a%c;
+func i32test(a, b, c int32) {
+	d := a % c
 	if d != b {
-		panicln("i32", a, b, c, d);
+		println("i32", a, b, c, d)
+		panic("fail")
 	}
 }
 
-func
-i32run() {
-	var a, b int32;
-
-	for i:=0; i<Count; i++ {
-		a = i32rand();
-
-		b = a%1;	i32test(a,b,1);
-		b = a%2;	i32test(a,b,2);
-		b = a%3;	i32test(a,b,3);
-		b = a%4;	i32test(a,b,4);
-		b = a%5;	i32test(a,b,5);
-		b = a%6;	i32test(a,b,6);
-		b = a%7;	i32test(a,b,7);
-		b = a%8;	i32test(a,b,8);
-		b = a%10;	i32test(a,b,10);
-		b = a%16;	i32test(a,b,16);
-		b = a%20;	i32test(a,b,20);
-		b = a%32;	i32test(a,b,32);
-		b = a%60;	i32test(a,b,60);
-		b = a%64;	i32test(a,b,64);
-		b = a%128;	i32test(a,b,128);
-		b = a%256;	i32test(a,b,256);
-		b = a%16384;	i32test(a,b,16384);
-
-		b = a%-1;	i32test(a,b,-1);
-		b = a%-2;	i32test(a,b,-2);
-		b = a%-3;	i32test(a,b,-3);
-		b = a%-4;	i32test(a,b,-4);
-		b = a%-5;	i32test(a,b,-5);
-		b = a%-6;	i32test(a,b,-6);
-		b = a%-7;	i32test(a,b,-7);
-		b = a%-8;	i32test(a,b,-8);
-		b = a%-10;	i32test(a,b,-10);
-		b = a%-16;	i32test(a,b,-16);
-		b = a%-20;	i32test(a,b,-20);
-		b = a%-32;	i32test(a,b,-32);
-		b = a%-60;	i32test(a,b,-60);
-		b = a%-64;	i32test(a,b,-64);
-		b = a%-128;	i32test(a,b,-128);
-		b = a%-256;	i32test(a,b,-256);
+func i32run() {
+	var a, b int32
+
+	for i := 0; i < Count; i++ {
+		a = i32rand()
+
+		b = a % 1
+		i32test(a, b, 1)
+		b = a % 2
+		i32test(a, b, 2)
+		b = a % 3
+		i32test(a, b, 3)
+		b = a % 4
+		i32test(a, b, 4)
+		b = a % 5
+		i32test(a, b, 5)
+		b = a % 6
+		i32test(a, b, 6)
+		b = a % 7
+		i32test(a, b, 7)
+		b = a % 8
+		i32test(a, b, 8)
+		b = a % 10
+		i32test(a, b, 10)
+		b = a % 16
+		i32test(a, b, 16)
+		b = a % 20
+		i32test(a, b, 20)
+		b = a % 32
+		i32test(a, b, 32)
+		b = a % 60
+		i32test(a, b, 60)
+		b = a % 64
+		i32test(a, b, 64)
+		b = a % 128
+		i32test(a, b, 128)
+		b = a % 256
+		i32test(a, b, 256)
+		b = a % 16384
+		i32test(a, b, 16384)
+
+		b = a % -1
+		i32test(a, b, -1)
+		b = a % -2
+		i32test(a, b, -2)
+		b = a % -3
+		i32test(a, b, -3)
+		b = a % -4
+		i32test(a, b, -4)
+		b = a % -5
+		i32test(a, b, -5)
+		b = a % -6
+		i32test(a, b, -6)
+		b = a % -7
+		i32test(a, b, -7)
+		b = a % -8
+		i32test(a, b, -8)
+		b = a % -10
+		i32test(a, b, -10)
+		b = a % -16
+		i32test(a, b, -16)
+		b = a % -20
+		i32test(a, b, -20)
+		b = a % -32
+		i32test(a, b, -32)
+		b = a % -60
+		i32test(a, b, -60)
+		b = a % -64
+		i32test(a, b, -64)
+		b = a % -128
+		i32test(a, b, -128)
+		b = a % -256
+		i32test(a, b, -256)
 	}
 }
 
-func
-u32rand() uint32 {
-	a := uint32(rand.Uint32());
-	a >>= uint(rand.Intn(32));
-	return a;
+func u32rand() uint32 {
+	a := uint32(rand.Uint32())
+	a >>= uint(rand.Intn(32))
+	return a
 }
 
-func
-u32test(a,b,c uint32) {
-	d := a%c;
+func u32test(a, b, c uint32) {
+	d := a % c
 	if d != b {
-		panicln("u32", a, b, c, d);
+		println("u32", a, b, c, d)
+		panic("fail")
 	}
 }
 
-func
-u32run() {
-	var a, b uint32;
-
-	for i:=0; i<Count; i++ {
-		a = u32rand();
-
-		b = a%1;	u32test(a,b,1);
-		b = a%2;	u32test(a,b,2);
-		b = a%3;	u32test(a,b,3);
-		b = a%4;	u32test(a,b,4);
-		b = a%5;	u32test(a,b,5);
-		b = a%6;	u32test(a,b,6);
-		b = a%7;	u32test(a,b,7);
-		b = a%8;	u32test(a,b,8);
-		b = a%10;	u32test(a,b,10);
-		b = a%16;	u32test(a,b,16);
-		b = a%20;	u32test(a,b,20);
-		b = a%32;	u32test(a,b,32);
-		b = a%60;	u32test(a,b,60);
-		b = a%64;	u32test(a,b,64);
-		b = a%128;	u32test(a,b,128);
-		b = a%256;	u32test(a,b,256);
-		b = a%16384;	u32test(a,b,16384);
+func u32run() {
+	var a, b uint32
+
+	for i := 0; i < Count; i++ {
+		a = u32rand()
+
+		b = a % 1
+		u32test(a, b, 1)
+		b = a % 2
+		u32test(a, b, 2)
+		b = a % 3
+		u32test(a, b, 3)
+		b = a % 4
+		u32test(a, b, 4)
+		b = a % 5
+		u32test(a, b, 5)
+		b = a % 6
+		u32test(a, b, 6)
+		b = a % 7
+		u32test(a, b, 7)
+		b = a % 8
+		u32test(a, b, 8)
+		b = a % 10
+		u32test(a, b, 10)
+		b = a % 16
+		u32test(a, b, 16)
+		b = a % 20
+		u32test(a, b, 20)
+		b = a % 32
+		u32test(a, b, 32)
+		b = a % 60
+		u32test(a, b, 60)
+		b = a % 64
+		u32test(a, b, 64)
+		b = a % 128
+		u32test(a, b, 128)
+		b = a % 256
+		u32test(a, b, 256)
+		b = a % 16384
+		u32test(a, b, 16384)
 	}
 }
 
-func
-i16rand() int16 {
+func i16rand() int16 {
 	for {
-		a := int16(rand.Uint32());
-		a >>= uint(rand.Intn(16));
+		a := int16(rand.Uint32())
+		a >>= uint(rand.Intn(16))
 		if -a != a {
-			return a;
+			return a
 		}
 	}
-	return 0;	// impossible
+	return 0 // impossible
 }
 
-func
-i16test(a,b,c int16) {
-	d := a%c;
+func i16test(a, b, c int16) {
+	d := a % c
 	if d != b {
-		panicln("i16", a, b, c, d);
+		println("i16", a, b, c, d)
+		panic("fail")
 	}
 }
 
-func
-i16run() {
-	var a, b int16;
-
-	for i:=0; i<Count; i++ {
-		a = i16rand();
-
-		b = a%1;	i16test(a,b,1);
-		b = a%2;	i16test(a,b,2);
-		b = a%3;	i16test(a,b,3);
-		b = a%4;	i16test(a,b,4);
-		b = a%5;	i16test(a,b,5);
-		b = a%6;	i16test(a,b,6);
-		b = a%7;	i16test(a,b,7);
-		b = a%8;	i16test(a,b,8);
-		b = a%10;	i16test(a,b,10);
-		b = a%16;	i16test(a,b,16);
-		b = a%20;	i16test(a,b,20);
-		b = a%32;	i16test(a,b,32);
-		b = a%60;	i16test(a,b,60);
-		b = a%64;	i16test(a,b,64);
-		b = a%128;	i16test(a,b,128);
-		b = a%256;	i16test(a,b,256);
-		b = a%16384;	i16test(a,b,16384);
-
-		b = a%-1;	i16test(a,b,-1);
-		b = a%-2;	i16test(a,b,-2);
-		b = a%-3;	i16test(a,b,-3);
-		b = a%-4;	i16test(a,b,-4);
-		b = a%-5;	i16test(a,b,-5);
-		b = a%-6;	i16test(a,b,-6);
-		b = a%-7;	i16test(a,b,-7);
-		b = a%-8;	i16test(a,b,-8);
-		b = a%-10;	i16test(a,b,-10);
-		b = a%-16;	i16test(a,b,-16);
-		b = a%-20;	i16test(a,b,-20);
-		b = a%-32;	i16test(a,b,-32);
-		b = a%-60;	i16test(a,b,-60);
-		b = a%-64;	i16test(a,b,-64);
-		b = a%-128;	i16test(a,b,-128);
-		b = a%-256;	i16test(a,b,-256);
-		b = a%-16384;	i16test(a,b,-16384);
+func i16run() {
+	var a, b int16
+
+	for i := 0; i < Count; i++ {
+		a = i16rand()
+
+		b = a % 1
+		i16test(a, b, 1)
+		b = a % 2
+		i16test(a, b, 2)
+		b = a % 3
+		i16test(a, b, 3)
+		b = a % 4
+		i16test(a, b, 4)
+		b = a % 5
+		i16test(a, b, 5)
+		b = a % 6
+		i16test(a, b, 6)
+		b = a % 7
+		i16test(a, b, 7)
+		b = a % 8
+		i16test(a, b, 8)
+		b = a % 10
+		i16test(a, b, 10)
+		b = a % 16
+		i16test(a, b, 16)
+		b = a % 20
+		i16test(a, b, 20)
+		b = a % 32
+		i16test(a, b, 32)
+		b = a % 60
+		i16test(a, b, 60)
+		b = a % 64
+		i16test(a, b, 64)
+		b = a % 128
+		i16test(a, b, 128)
+		b = a % 256
+		i16test(a, b, 256)
+		b = a % 16384
+		i16test(a, b, 16384)
+
+		b = a % -1
+		i16test(a, b, -1)
+		b = a % -2
+		i16test(a, b, -2)
+		b = a % -3
+		i16test(a, b, -3)
+		b = a % -4
+		i16test(a, b, -4)
+		b = a % -5
+		i16test(a, b, -5)
+		b = a % -6
+		i16test(a, b, -6)
+		b = a % -7
+		i16test(a, b, -7)
+		b = a % -8
+		i16test(a, b, -8)
+		b = a % -10
+		i16test(a, b, -10)
+		b = a % -16
+		i16test(a, b, -16)
+		b = a % -20
+		i16test(a, b, -20)
+		b = a % -32
+		i16test(a, b, -32)
+		b = a % -60
+		i16test(a, b, -60)
+		b = a % -64
+		i16test(a, b, -64)
+		b = a % -128
+		i16test(a, b, -128)
+		b = a % -256
+		i16test(a, b, -256)
+		b = a % -16384
+		i16test(a, b, -16384)
 	}
 }
 
-func
-u16rand() uint16 {
-	a := uint16(rand.Uint32());
-	a >>= uint(rand.Intn(16));
-	return a;
+func u16rand() uint16 {
+	a := uint16(rand.Uint32())
+	a >>= uint(rand.Intn(16))
+	return a
 }
 
-func
-u16test(a,b,c uint16) {
-	d := a%c;
+func u16test(a, b, c uint16) {
+	d := a % c
 	if d != b {
-		panicln("u16", a, b, c, d);
+		println("u16", a, b, c, d)
+		panic("fail")
 	}
 }
 
-func
-u16run() {
-	var a, b uint16;
-
-	for i:=0; i<Count; i++ {
-		a = u16rand();
-
-		b = a%1;	u16test(a,b,1);
-		b = a%2;	u16test(a,b,2);
-		b = a%3;	u16test(a,b,3);
-		b = a%4;	u16test(a,b,4);
-		b = a%5;	u16test(a,b,5);
-		b = a%6;	u16test(a,b,6);
-		b = a%7;	u16test(a,b,7);
-		b = a%8;	u16test(a,b,8);
-		b = a%10;	u16test(a,b,10);
-		b = a%16;	u16test(a,b,16);
-		b = a%20;	u16test(a,b,20);
-		b = a%32;	u16test(a,b,32);
-		b = a%60;	u16test(a,b,60);
-		b = a%64;	u16test(a,b,64);
-		b = a%128;	u16test(a,b,128);
-		b = a%256;	u16test(a,b,256);
-		b = a%16384;	u16test(a,b,16384);
+func u16run() {
+	var a, b uint16
+
+	for i := 0; i < Count; i++ {
+		a = u16rand()
+
+		b = a % 1
+		u16test(a, b, 1)
+		b = a % 2
+		u16test(a, b, 2)
+		b = a % 3
+		u16test(a, b, 3)
+		b = a % 4
+		u16test(a, b, 4)
+		b = a % 5
+		u16test(a, b, 5)
+		b = a % 6
+		u16test(a, b, 6)
+		b = a % 7
+		u16test(a, b, 7)
+		b = a % 8
+		u16test(a, b, 8)
+		b = a % 10
+		u16test(a, b, 10)
+		b = a % 16
+		u16test(a, b, 16)
+		b = a % 20
+		u16test(a, b, 20)
+		b = a % 32
+		u16test(a, b, 32)
+		b = a % 60
+		u16test(a, b, 60)
+		b = a % 64
+		u16test(a, b, 64)
+		b = a % 128
+		u16test(a, b, 128)
+		b = a % 256
+		u16test(a, b, 256)
+		b = a % 16384
+		u16test(a, b, 16384)
 	}
 }
 
-func
-i8rand() int8 {
+func i8rand() int8 {
 	for {
-		a := int8(rand.Uint32());
-		a >>= uint(rand.Intn(8));
+		a := int8(rand.Uint32())
+		a >>= uint(rand.Intn(8))
 		if -a != a {
-			return a;
+			return a
 		}
 	}
-	return 0;	// impossible
+	return 0 // impossible
 }
 
-func
-i8test(a,b,c int8) {
-	d := a%c;
+func i8test(a, b, c int8) {
+	d := a % c
 	if d != b {
-		panicln("i8", a, b, c, d);
+		println("i8", a, b, c, d)
+		panic("fail")
 	}
 }
 
-func
-i8run() {
-	var a, b int8;
-
-	for i:=0; i<Count; i++ {
-		a = i8rand();
-
-		b = a%1;	i8test(a,b,1);
-		b = a%2;	i8test(a,b,2);
-		b = a%3;	i8test(a,b,3);
-		b = a%4;	i8test(a,b,4);
-		b = a%5;	i8test(a,b,5);
-		b = a%6;	i8test(a,b,6);
-		b = a%7;	i8test(a,b,7);
-		b = a%8;	i8test(a,b,8);
-		b = a%10;	i8test(a,b,10);
-		b = a%8;	i8test(a,b,8);
-		b = a%20;	i8test(a,b,20);
-		b = a%32;	i8test(a,b,32);
-		b = a%60;	i8test(a,b,60);
-		b = a%64;	i8test(a,b,64);
-		b = a%127;	i8test(a,b,127);
-
-		b = a%-1;	i8test(a,b,-1);
-		b = a%-2;	i8test(a,b,-2);
-		b = a%-3;	i8test(a,b,-3);
-		b = a%-4;	i8test(a,b,-4);
-		b = a%-5;	i8test(a,b,-5);
-		b = a%-6;	i8test(a,b,-6);
-		b = a%-7;	i8test(a,b,-7);
-		b = a%-8;	i8test(a,b,-8);
-		b = a%-10;	i8test(a,b,-10);
-		b = a%-8;	i8test(a,b,-8);
-		b = a%-20;	i8test(a,b,-20);
-		b = a%-32;	i8test(a,b,-32);
-		b = a%-60;	i8test(a,b,-60);
-		b = a%-64;	i8test(a,b,-64);
-		b = a%-128;	i8test(a,b,-128);
-		b = a%-101;	i8test(a,b,-101);
+func i8run() {
+	var a, b int8
+
+	for i := 0; i < Count; i++ {
+		a = i8rand()
+
+		b = a % 1
+		i8test(a, b, 1)
+		b = a % 2
+		i8test(a, b, 2)
+		b = a % 3
+		i8test(a, b, 3)
+		b = a % 4
+		i8test(a, b, 4)
+		b = a % 5
+		i8test(a, b, 5)
+		b = a % 6
+		i8test(a, b, 6)
+		b = a % 7
+		i8test(a, b, 7)
+		b = a % 8
+		i8test(a, b, 8)
+		b = a % 10
+		i8test(a, b, 10)
+		b = a % 8
+		i8test(a, b, 8)
+		b = a % 20
+		i8test(a, b, 20)
+		b = a % 32
+		i8test(a, b, 32)
+		b = a % 60
+		i8test(a, b, 60)
+		b = a % 64
+		i8test(a, b, 64)
+		b = a % 127
+		i8test(a, b, 127)
+
+		b = a % -1
+		i8test(a, b, -1)
+		b = a % -2
+		i8test(a, b, -2)
+		b = a % -3
+		i8test(a, b, -3)
+		b = a % -4
+		i8test(a, b, -4)
+		b = a % -5
+		i8test(a, b, -5)
+		b = a % -6
+		i8test(a, b, -6)
+		b = a % -7
+		i8test(a, b, -7)
+		b = a % -8
+		i8test(a, b, -8)
+		b = a % -10
+		i8test(a, b, -10)
+		b = a % -8
+		i8test(a, b, -8)
+		b = a % -20
+		i8test(a, b, -20)
+		b = a % -32
+		i8test(a, b, -32)
+		b = a % -60
+		i8test(a, b, -60)
+		b = a % -64
+		i8test(a, b, -64)
+		b = a % -128
+		i8test(a, b, -128)
+		b = a % -101
+		i8test(a, b, -101)
 	}
 }
 
-func
-u8rand() uint8 {
-	a := uint8(rand.Uint32());
-	a >>= uint(rand.Intn(8));
-	return a;
+func u8rand() uint8 {
+	a := uint8(rand.Uint32())
+	a >>= uint(rand.Intn(8))
+	return a
 }
 
-func
-u8test(a,b,c uint8) {
-	d := a%c;
+func u8test(a, b, c uint8) {
+	d := a % c
 	if d != b {
-		panicln("u8", a, b, c, d);
+		println("u8", a, b, c, d)
+		panic("fail")
 	}
 }
 
-func
-u8run() {
-	var a, b uint8;
-
-	for i:=0; i<Count; i++ {
-		a = u8rand();
-
-		b = a%1;	u8test(a,b,1);
-		b = a%2;	u8test(a,b,2);
-		b = a%3;	u8test(a,b,3);
-		b = a%4;	u8test(a,b,4);
-		b = a%5;	u8test(a,b,5);
-		b = a%6;	u8test(a,b,6);
-		b = a%7;	u8test(a,b,7);
-		b = a%8;	u8test(a,b,8);
-		b = a%10;	u8test(a,b,10);
-		b = a%8;	u8test(a,b,8);
-		b = a%20;	u8test(a,b,20);
-		b = a%32;	u8test(a,b,32);
-		b = a%60;	u8test(a,b,60);
-		b = a%64;	u8test(a,b,64);
-		b = a%127;	u8test(a,b,127);
+func u8run() {
+	var a, b uint8
+
+	for i := 0; i < Count; i++ {
+		a = u8rand()
+
+		b = a % 1
+		u8test(a, b, 1)
+		b = a % 2
+		u8test(a, b, 2)
+		b = a % 3
+		u8test(a, b, 3)
+		b = a % 4
+		u8test(a, b, 4)
+		b = a % 5
+		u8test(a, b, 5)
+		b = a % 6
+		u8test(a, b, 6)
+		b = a % 7
+		u8test(a, b, 7)
+		b = a % 8
+		u8test(a, b, 8)
+		b = a % 10
+		u8test(a, b, 10)
+		b = a % 8
+		u8test(a, b, 8)
+		b = a % 20
+		u8test(a, b, 20)
+		b = a % 32
+		u8test(a, b, 32)
+		b = a % 60
+		u8test(a, b, 60)
+		b = a % 64
+		u8test(a, b, 64)
+		b = a % 127
+		u8test(a, b, 127)
 	}
 }
 
-func
-main() {
-	xtest();
-	i64run();
-	u64run();
-	i32run();
-	u32run();
-	i16run();
-	u16run();
-	i8run();
-	u8run();
+func main() {
+	xtest()
+	i64run()
+	u64run()
+	i32run()
+	u32run()
+	i16run()
+	u16run()
+	i8run()
+	u8run()
 }
 
-func
-xtest() {
+func xtest() {
 }
diff --git a/test/ken/range.go b/test/ken/range.go
index 8da830247..9535fd497 100644
--- a/test/ken/range.go
+++ b/test/ken/range.go
@@ -6,105 +6,114 @@
 
 package main
 
-const	size	= 16;
+const size = 16
 
-var	a	[size]byte;
-var	p	[]byte;
-var	m	map[int]byte;
+var a [size]byte
+var p []byte
+var m map[int]byte
 
-func
-f(k int) byte {
-	return byte(k*10007 % size);
+func f(k int) byte {
+	return byte(k * 10007 % size)
 }
 
-func
-init() {
-	p = make([]byte, size);
-	m = make(map[int]byte);
-	for k:=0; k<size; k++ {
-		v := f(k);
-		a[k] = v;
-		p[k] = v;
-		m[k] = v;
+func init() {
+	p = make([]byte, size)
+	m = make(map[int]byte)
+	for k := 0; k < size; k++ {
+		v := f(k)
+		a[k] = v
+		p[k] = v
+		m[k] = v
 	}
 }
 
-func
-main() {
-	var i int;
+func main() {
+	var i int
 
 	/*
 	 * key only
 	 */
-	i = 0;
+	i = 0
 	for k := range a {
-		v := a[k];
+		v := a[k]
 		if v != f(k) {
-			panicln("key array range", k, v, a[k]);
+			println("key array range", k, v, a[k])
+			panic("fail")
 		}
-		i++;
+		i++
 	}
 	if i != size {
-		panicln("key array size", i);
+		println("key array size", i)
+		panic("fail")
 	}
 
-	i = 0;
+	i = 0
 	for k := range p {
-		v := p[k];
+		v := p[k]
 		if v != f(k) {
-			panicln("key pointer range", k, v, p[k]);
+			println("key pointer range", k, v, p[k])
+			panic("fail")
 		}
-		i++;
+		i++
 	}
 	if i != size {
-		panicln("key pointer size", i);
+		println("key pointer size", i)
+		panic("fail")
 	}
 
-	i = 0;
+	i = 0
 	for k := range m {
-		v := m[k];
+		v := m[k]
 		if v != f(k) {
-			panicln("key map range", k, v, m[k]);
+			println("key map range", k, v, m[k])
+			panic("fail")
 		}
-		i++;
+		i++
 	}
 	if i != size {
-		panicln("key map size", i);
+		println("key map size", i)
+		panic("fail")
 	}
 
 	/*
 	 * key,value
 	 */
-	i = 0;
-	for k,v := range a {
+	i = 0
+	for k, v := range a {
 		if v != f(k) {
-			panicln("key:value array range", k, v, a[k]);
+			println("key:value array range", k, v, a[k])
+			panic("fail")
 		}
-		i++;
+		i++
 	}
 	if i != size {
-		panicln("key:value array size", i);
+		println("key:value array size", i)
+		panic("fail")
 	}
 
-	i = 0;
-	for k,v := range p {
+	i = 0
+	for k, v := range p {
 		if v != f(k) {
-			panicln("key:value pointer range", k, v, p[k]);
+			println("key:value pointer range", k, v, p[k])
+			panic("fail")
 		}
-		i++;
+		i++
 	}
 	if i != size {
-		panicln("key:value pointer size", i);
+		println("key:value pointer size", i)
+		panic("fail")
 	}
 
-	i = 0;
-	for k,v := range m {
+	i = 0
+	for k, v := range m {
 		if v != f(k) {
-			panicln("key:value map range", k, v, m[k]);
+			println("key:value map range", k, v, m[k])
+			panic("fail")
 		}
-		i++;
+		i++
 	}
 	if i != size {
-		panicln("key:value map size", i);
+		println("key:value map size", i)
+		panic("fail")
 	}
 }
diff --git a/test/ken/slicearray.go b/test/ken/slicearray.go
index f24c7fc9c..76ec80931 100644
--- a/test/ken/slicearray.go
+++ b/test/ken/slicearray.go
@@ -6,131 +6,185 @@
 
 package main
 
-var	bx	[10]byte
-var	by	[]byte;
-var	fx	[10]float
-var	fy	[]float;
-var	lb,hb	int
-var	t	int
-
-func
-main() {
-	lb = 0; hb = 10;
-	by = &bx; tstb();
-
-	lb = 0; hb = 10;
-	fy = &fx; tstf();
+var bx [10]byte
+var by []byte
+var fx [10]float
+var fy []float
+var lb, hb int
+var t int
+
+func main() {
+	lb = 0
+	hb = 10
+	by = &bx
+	tstb()
+
+	lb = 0
+	hb = 10
+	fy = &fx
+	tstf()
 
 	// width 1 (byte)
-	lb = 0; hb = 10;
-	by = bx[lb:hb]; tstb();
-	by = bx[lb:10]; tstb();
-	by = bx[lb:]; tstb();
-	by = bx[0:hb]; tstb();
-	by = bx[0:10]; tstb();
-	by = bx[0:]; tstb();
-
-	lb = 2; hb = 10;
-	by = bx[lb:hb]; tstb();
-	by = bx[lb:10]; tstb();
-	by = bx[lb:]; tstb();
-	by = bx[2:hb]; tstb();
-	by = bx[2:10]; tstb();
-	by = bx[2:]; tstb();
-
-	lb = 0; hb = 8;
-	by = bx[lb:hb]; tstb();
-	by = bx[lb:8]; tstb();
-	by = bx[0:hb]; tstb();
-	by = bx[0:8]; tstb();
-
-	lb = 2; hb = 8;
-	by = bx[lb:hb]; tstb();
-	by = bx[lb:8]; tstb();
-	by = bx[2:hb]; tstb();
-	by = bx[2:8]; tstb();
+	lb = 0
+	hb = 10
+	by = bx[lb:hb]
+	tstb()
+	by = bx[lb:10]
+	tstb()
+	by = bx[lb:]
+	tstb()
+	by = bx[0:hb]
+	tstb()
+	by = bx[0:10]
+	tstb()
+	by = bx[0:]
+	tstb()
+
+	lb = 2
+	hb = 10
+	by = bx[lb:hb]
+	tstb()
+	by = bx[lb:10]
+	tstb()
+	by = bx[lb:]
+	tstb()
+	by = bx[2:hb]
+	tstb()
+	by = bx[2:10]
+	tstb()
+	by = bx[2:]
+	tstb()
+
+	lb = 0
+	hb = 8
+	by = bx[lb:hb]
+	tstb()
+	by = bx[lb:8]
+	tstb()
+	by = bx[0:hb]
+	tstb()
+	by = bx[0:8]
+	tstb()
+
+	lb = 2
+	hb = 8
+	by = bx[lb:hb]
+	tstb()
+	by = bx[lb:8]
+	tstb()
+	by = bx[2:hb]
+	tstb()
+	by = bx[2:8]
+	tstb()
 
 	// width 4 (float)
-	lb = 0; hb = 10;
-	fy = fx[lb:hb]; tstf();
-	fy = fx[lb:10]; tstf();
-	fy = fx[lb:]; tstf();
-	fy = fx[0:hb]; tstf();
-	fy = fx[0:10]; tstf();
-	fy = fx[0:]; tstf();
-
-	lb = 2; hb = 10;
-	fy = fx[lb:hb]; tstf();
-	fy = fx[lb:10]; tstf();
-	fy = fx[lb:]; tstf();
-	fy = fx[2:hb]; tstf();
-	fy = fx[2:10]; tstf();
-	fy = fx[2:]; tstf();
-
-	lb = 0; hb = 8;
-	fy = fx[lb:hb]; tstf();
-	fy = fx[lb:8]; tstf();
-	fy = fx[0:hb]; tstf();
-	fy = fx[0:8]; tstf();
-
-	lb = 2; hb = 8;
-	fy = fx[lb:hb]; tstf();
-	fy = fx[lb:8]; tstf();
-	fy = fx[2:hb]; tstf();
-	fy = fx[2:8]; tstf();
+	lb = 0
+	hb = 10
+	fy = fx[lb:hb]
+	tstf()
+	fy = fx[lb:10]
+	tstf()
+	fy = fx[lb:]
+	tstf()
+	fy = fx[0:hb]
+	tstf()
+	fy = fx[0:10]
+	tstf()
+	fy = fx[0:]
+	tstf()
+
+	lb = 2
+	hb = 10
+	fy = fx[lb:hb]
+	tstf()
+	fy = fx[lb:10]
+	tstf()
+	fy = fx[lb:]
+	tstf()
+	fy = fx[2:hb]
+	tstf()
+	fy = fx[2:10]
+	tstf()
+	fy = fx[2:]
+	tstf()
+
+	lb = 0
+	hb = 8
+	fy = fx[lb:hb]
+	tstf()
+	fy = fx[lb:8]
+	tstf()
+	fy = fx[0:hb]
+	tstf()
+	fy = fx[0:8]
+	tstf()
+
+	lb = 2
+	hb = 8
+	fy = fx[lb:hb]
+	tstf()
+	fy = fx[lb:8]
+	tstf()
+	fy = fx[2:hb]
+	tstf()
+	fy = fx[2:8]
+	tstf()
 }
 
-func
-tstb() {
-	t++;
+func tstb() {
+	t++
 	if len(by) != hb-lb {
-		panicln("t=", t, "lb=", lb, "hb=", hb,
-			"len=", len(by), "hb-lb=", hb-lb);
+		println("t=", t, "lb=", lb, "hb=", hb,
+			"len=", len(by), "hb-lb=", hb-lb)
+		panic("fail")
 	}
 	if cap(by) != len(bx)-lb {
-		panicln("t=", t, "lb=", lb, "hb=", hb,
-			"cap=", cap(by), "len(bx)-lb=", len(bx)-lb);
+		println("t=", t, "lb=", lb, "hb=", hb,
+			"cap=", cap(by), "len(bx)-lb=", len(bx)-lb)
+		panic("fail")
 	}
-	for i:=lb; i<hb; i++ {
+	for i := lb; i < hb; i++ {
 		if bx[i] != by[i-lb] {
-			panicln("t=", t, "lb=", lb, "hb=", hb,
+			println("t=", t, "lb=", lb, "hb=", hb,
 				"bx[", i, "]=", bx[i],
-				"by[", i-lb, "]=", by[i-lb]);
+				"by[", i-lb, "]=", by[i-lb])
+			panic("fail")
 		}
 	}
-	by = nil;
+	by = nil
 }
 
-func
-tstf() {
-	t++;
+func tstf() {
+	t++
 	if len(fy) != hb-lb {
-		panicln("t=", t, "lb=", lb, "hb=", hb,
-			"len=", len(fy), "hb-lb=", hb-lb);
+		println("t=", t, "lb=", lb, "hb=", hb,
+			"len=", len(fy), "hb-lb=", hb-lb)
+		panic("fail")
 	}
 	if cap(fy) != len(fx)-lb {
-		panicln("t=", t, "lb=", lb, "hb=", hb,
-			"cap=", cap(fy), "len(fx)-lb=", len(fx)-lb);
+		println("t=", t, "lb=", lb, "hb=", hb,
+			"cap=", cap(fy), "len(fx)-lb=", len(fx)-lb)
+		panic("fail")
 	}
-	for i:=lb; i<hb; i++ {
+	for i := lb; i < hb; i++ {
 		if fx[i] != fy[i-lb] {
-			panicln("t=", t, "lb=", lb, "hb=", hb,
+			println("t=", t, "lb=", lb, "hb=", hb,
 				"fx[", i, "]=", fx[i],
-				"fy[", i-lb, "]=", fy[i-lb]);
+				"fy[", i-lb, "]=", fy[i-lb])
+			panic("fail")
 		}
 	}
-	fy = nil;
+	fy = nil
 }
 
-func
-init() {
-	for i:=0; i<len(bx); i++ {
-		bx[i] = byte(i+20);
+func init() {
+	for i := 0; i < len(bx); i++ {
+		bx[i] = byte(i + 20)
 	}
-	by = nil;
+	by = nil
 
-	for i:=0; i<len(fx); i++ {
-		fx[i] = float(i+20);
+	for i := 0; i < len(fx); i++ {
+		fx[i] = float(i + 20)
 	}
-	fy = nil;
+	fy = nil
 }
diff --git a/test/ken/sliceslice.go b/test/ken/sliceslice.go
index 7b38082bb..7e7f1b4ac 100644
--- a/test/ken/sliceslice.go
+++ b/test/ken/sliceslice.go
@@ -6,128 +6,178 @@
 
 package main
 
-var	bx	[]byte
-var	by	[]byte;
-var	fx	[]float
-var	fy	[]float;
-var	lb,hb	int
-var	t	int
+var bx []byte
+var by []byte
+var fx []float
+var fy []float
+var lb, hb int
+var t int
 
-func
-main() {
+func main() {
 
 	// width 1 (byte)
-	lb = 0; hb = 10;
-	by = bx[lb:hb]; tstb();
-	by = bx[lb:10]; tstb();
-	by = bx[lb:]; tstb();
-	by = bx[0:hb]; tstb();
-	by = bx[0:10]; tstb();
-	by = bx[0:]; tstb();
-
-	lb = 2; hb = 10;
-	by = bx[lb:hb]; tstb();
-	by = bx[lb:10]; tstb();
-	by = bx[lb:]; tstb();
-	by = bx[2:hb]; tstb();
-	by = bx[2:10]; tstb();
-	by = bx[2:]; tstb();
-
-	lb = 0; hb = 8;
-	by = bx[lb:hb]; tstb();
-	by = bx[lb:8]; tstb();
-	by = bx[0:hb]; tstb();
-	by = bx[0:8]; tstb();
-
-	lb = 2; hb = 8;
-	by = bx[lb:hb]; tstb();
-	by = bx[lb:8]; tstb();
-	by = bx[2:hb]; tstb();
-	by = bx[2:8]; tstb();
+	lb = 0
+	hb = 10
+	by = bx[lb:hb]
+	tstb()
+	by = bx[lb:10]
+	tstb()
+	by = bx[lb:]
+	tstb()
+	by = bx[0:hb]
+	tstb()
+	by = bx[0:10]
+	tstb()
+	by = bx[0:]
+	tstb()
+
+	lb = 2
+	hb = 10
+	by = bx[lb:hb]
+	tstb()
+	by = bx[lb:10]
+	tstb()
+	by = bx[lb:]
+	tstb()
+	by = bx[2:hb]
+	tstb()
+	by = bx[2:10]
+	tstb()
+	by = bx[2:]
+	tstb()
+
+	lb = 0
+	hb = 8
+	by = bx[lb:hb]
+	tstb()
+	by = bx[lb:8]
+	tstb()
+	by = bx[0:hb]
+	tstb()
+	by = bx[0:8]
+	tstb()
+
+	lb = 2
+	hb = 8
+	by = bx[lb:hb]
+	tstb()
+	by = bx[lb:8]
+	tstb()
+	by = bx[2:hb]
+	tstb()
+	by = bx[2:8]
+	tstb()
 
 	// width 4 (float)
-	lb = 0; hb = 10;
-	fy = fx[lb:hb]; tstf();
-	fy = fx[lb:10]; tstf();
-	fy = fx[lb:]; tstf();
-	fy = fx[0:hb]; tstf();
-	fy = fx[0:10]; tstf();
-	fy = fx[0:]; tstf();
-
-	lb = 2; hb = 10;
-	fy = fx[lb:hb]; tstf();
-	fy = fx[lb:10]; tstf();
-	fy = fx[lb:]; tstf();
-	fy = fx[2:hb]; tstf();
-	fy = fx[2:10]; tstf();
-	fy = fx[2:]; tstf();
-
-	lb = 0; hb = 8;
-	fy = fx[lb:hb]; tstf();
-	fy = fx[lb:8]; tstf();
-	fy = fx[0:hb]; tstf();
-	fy = fx[0:8]; tstf();
-
-	lb = 2; hb = 8;
-	fy = fx[lb:hb]; tstf();
-	fy = fx[lb:8]; tstf();
-	fy = fx[2:hb]; tstf();
-	fy = fx[2:8]; tstf();
+	lb = 0
+	hb = 10
+	fy = fx[lb:hb]
+	tstf()
+	fy = fx[lb:10]
+	tstf()
+	fy = fx[lb:]
+	tstf()
+	fy = fx[0:hb]
+	tstf()
+	fy = fx[0:10]
+	tstf()
+	fy = fx[0:]
+	tstf()
+
+	lb = 2
+	hb = 10
+	fy = fx[lb:hb]
+	tstf()
+	fy = fx[lb:10]
+	tstf()
+	fy = fx[lb:]
+	tstf()
+	fy = fx[2:hb]
+	tstf()
+	fy = fx[2:10]
+	tstf()
+	fy = fx[2:]
+	tstf()
+
+	lb = 0
+	hb = 8
+	fy = fx[lb:hb]
+	tstf()
+	fy = fx[lb:8]
+	tstf()
+	fy = fx[0:hb]
+	tstf()
+	fy = fx[0:8]
+	tstf()
+
+	lb = 2
+	hb = 8
+	fy = fx[lb:hb]
+	tstf()
+	fy = fx[lb:8]
+	tstf()
+	fy = fx[2:hb]
+	tstf()
+	fy = fx[2:8]
+	tstf()
 }
 
-func
-tstb() {
-	t++;
+func tstb() {
+	t++
 	if len(by) != hb-lb {
-		panicln("t=", t, "lb=", lb, "hb=", hb,
-			"len=", len(by), "hb-lb=", hb-lb);
+		println("t=", t, "lb=", lb, "hb=", hb,
+			"len=", len(by), "hb-lb=", hb-lb)
+		panic("fail")
 	}
 	if cap(by) != len(bx)-lb {
-		panicln("t=", t, "lb=", lb, "hb=", hb,
-			"cap=", cap(by), "len(bx)-lb=", len(bx)-lb);
+		println("t=", t, "lb=", lb, "hb=", hb,
+			"cap=", cap(by), "len(bx)-lb=", len(bx)-lb)
+		panic("fail")
 	}
-	for i:=lb; i<hb; i++ {
+	for i := lb; i < hb; i++ {
 		if bx[i] != by[i-lb] {
-			panicln("t=", t, "lb=", lb, "hb=", hb,
+			println("t=", t, "lb=", lb, "hb=", hb,
 				"bx[", i, "]=", bx[i],
-				"by[", i-lb, "]=", by[i-lb]);
+				"by[", i-lb, "]=", by[i-lb])
+			panic("fail")
 		}
 	}
-	by = nil;
+	by = nil
 }
 
-func
-tstf() {
-	t++;
+func tstf() {
+	t++
 	if len(fy) != hb-lb {
-		panicln("t=", t, "lb=", lb, "hb=", hb,
-			"len=", len(fy), "hb-lb=", hb-lb);
+		println("t=", t, "lb=", lb, "hb=", hb,
+			"len=", len(fy), "hb-lb=", hb-lb)
+		panic("fail")
 	}
 	if cap(fy) != len(fx)-lb {
-		panicln("t=", t, "lb=", lb, "hb=", hb,
-			"cap=", cap(fy), "len(fx)-lb=", len(fx)-lb);
+		println("t=", t, "lb=", lb, "hb=", hb,
+			"cap=", cap(fy), "len(fx)-lb=", len(fx)-lb)
+		panic("fail")
 	}
-	for i:=lb; i<hb; i++ {
+	for i := lb; i < hb; i++ {
 		if fx[i] != fy[i-lb] {
-			panicln("t=", t, "lb=", lb, "hb=", hb,
+			println("t=", t, "lb=", lb, "hb=", hb,
 				"fx[", i, "]=", fx[i],
-				"fy[", i-lb, "]=", fy[i-lb]);
+				"fy[", i-lb, "]=", fy[i-lb])
+			panic("fail")
 		}
 	}
-	fy = nil;
+	fy = nil
 }
 
-func
-init() {
-	bx = make([]byte, 10);
-	for i:=0; i<len(bx); i++ {
-		bx[i] = byte(i+20);
+func init() {
+	bx = make([]byte, 10)
+	for i := 0; i < len(bx); i++ {
+		bx[i] = byte(i + 20)
 	}
-	by = nil;
+	by = nil
 
-	fx = make([]float, 10);
-	for i:=0; i<len(fx); i++ {
-		fx[i] = float(i+20);
+	fx = make([]float, 10)
+	for i := 0; i < len(fx); i++ {
+		fx[i] = float(i + 20)
 	}
-	fy = nil;
+	fy = nil
 }