gofmt-ify eval

R=rsc
http://go/go-review/1016054

1 files changed, 676 insertions, 567 deletions

diff --git a/src/pkg/exp/eval/expr1.go b/src/pkg/exp/eval/expr1.go
index 7787a2112..547ca380a 100644
--- a/src/pkg/exp/eval/expr1.go
+++ b/src/pkg/exp/eval/expr1.go
@@ -13,76 +13,76 @@ import (
  * expr, panicking if the requested evaluator has the wrong type.
  */
 func (a *expr) asBool() (func(*Thread) bool) {
-	return a.eval.(func(*Thread)(bool))
+	return a.eval.(func(*Thread) bool);
 }
 func (a *expr) asUint() (func(*Thread) uint64) {
-	return a.eval.(func(*Thread)(uint64))
+	return a.eval.(func(*Thread) uint64);
 }
 func (a *expr) asInt() (func(*Thread) int64) {
-	return a.eval.(func(*Thread)(int64))
+	return a.eval.(func(*Thread) int64);
 }
 func (a *expr) asIdealInt() (func() *bignum.Integer) {
-	return a.eval.(func()(*bignum.Integer))
+	return a.eval.(func() *bignum.Integer);
 }
 func (a *expr) asFloat() (func(*Thread) float64) {
-	return a.eval.(func(*Thread)(float64))
+	return a.eval.(func(*Thread) float64);
 }
 func (a *expr) asIdealFloat() (func() *bignum.Rational) {
-	return a.eval.(func()(*bignum.Rational))
+	return a.eval.(func() *bignum.Rational);
 }
 func (a *expr) asString() (func(*Thread) string) {
-	return a.eval.(func(*Thread)(string))
+	return a.eval.(func(*Thread) string);
 }
 func (a *expr) asArray() (func(*Thread) ArrayValue) {
-	return a.eval.(func(*Thread)(ArrayValue))
+	return a.eval.(func(*Thread) ArrayValue);
 }
 func (a *expr) asStruct() (func(*Thread) StructValue) {
-	return a.eval.(func(*Thread)(StructValue))
+	return a.eval.(func(*Thread) StructValue);
 }
 func (a *expr) asPtr() (func(*Thread) Value) {
-	return a.eval.(func(*Thread)(Value))
+	return a.eval.(func(*Thread) Value);
 }
 func (a *expr) asFunc() (func(*Thread) Func) {
-	return a.eval.(func(*Thread)(Func))
+	return a.eval.(func(*Thread) Func);
 }
 func (a *expr) asSlice() (func(*Thread) Slice) {
-	return a.eval.(func(*Thread)(Slice))
+	return a.eval.(func(*Thread) Slice);
 }
 func (a *expr) asMap() (func(*Thread) Map) {
-	return a.eval.(func(*Thread)(Map))
+	return a.eval.(func(*Thread) Map);
 }
 func (a *expr) asMulti() (func(*Thread) []Value) {
-	return a.eval.(func(*Thread)[]Value)
+	return a.eval.(func(*Thread) []Value);
 }
 
 func (a *expr) asInterface() (func(*Thread) interface{}) {
 	switch sf := a.eval.(type) {
-	case func(t *Thread)bool:
-		return func(t *Thread) interface{} { return sf(t) }
-	case func(t *Thread)uint64:
-		return func(t *Thread) interface{} { return sf(t) }
-	case func(t *Thread)int64:
-		return func(t *Thread) interface{} { return sf(t) }
-	case func()*bignum.Integer:
-		return func(*Thread) interface{} { return sf() }
-	case func(t *Thread)float64:
-		return func(t *Thread) interface{} { return sf(t) }
-	case func()*bignum.Rational:
-		return func(*Thread) interface{} { return sf() }
-	case func(t *Thread)string:
-		return func(t *Thread) interface{} { return sf(t) }
-	case func(t *Thread)ArrayValue:
-		return func(t *Thread) interface{} { return sf(t) }
-	case func(t *Thread)StructValue:
-		return func(t *Thread) interface{} { return sf(t) }
-	case func(t *Thread)Value:
-		return func(t *Thread) interface{} { return sf(t) }
-	case func(t *Thread)Func:
-		return func(t *Thread) interface{} { return sf(t) }
-	case func(t *Thread)Slice:
-		return func(t *Thread) interface{} { return sf(t) }
-	case func(t *Thread)Map:
-		return func(t *Thread) interface{} { return sf(t) }
+	case func(t *Thread) bool:
+		return func(t *Thread) interface{} { return sf(t) };
+	case func(t *Thread) uint64:
+		return func(t *Thread) interface{} { return sf(t) };
+	case func(t *Thread) int64:
+		return func(t *Thread) interface{} { return sf(t) };
+	case func() *bignum.Integer:
+		return func(*Thread) interface{} { return sf() };
+	case func(t *Thread) float64:
+		return func(t *Thread) interface{} { return sf(t) };
+	case func() *bignum.Rational:
+		return func(*Thread) interface{} { return sf() };
+	case func(t *Thread) string:
+		return func(t *Thread) interface{} { return sf(t) };
+	case func(t *Thread) ArrayValue:
+		return func(t *Thread) interface{} { return sf(t) };
+	case func(t *Thread) StructValue:
+		return func(t *Thread) interface{} { return sf(t) };
+	case func(t *Thread) Value:
+		return func(t *Thread) interface{} { return sf(t) };
+	case func(t *Thread) Func:
+		return func(t *Thread) interface{} { return sf(t) };
+	case func(t *Thread) Slice:
+		return func(t *Thread) interface{} { return sf(t) };
+	case func(t *Thread) Map:
+		return func(t *Thread) interface{} { return sf(t) };
 	default:
 		log.Crashf("unexpected expression node type %T at %v", a.eval, a.pos);
 	}
@@ -96,33 +96,33 @@ func (a *expr) asInterface() (func(*Thread) interface{}) {
 func (a *expr) genConstant(v Value) {
 	switch a.t.lit().(type) {
 	case *boolType:
-		a.eval = func(t *Thread) bool { return v.(BoolValue).Get(t) }
+		a.eval = func(t *Thread) bool { return v.(BoolValue).Get(t) };
 	case *uintType:
-		a.eval = func(t *Thread) uint64 { return v.(UintValue).Get(t) }
+		a.eval = func(t *Thread) uint64 { return v.(UintValue).Get(t) };
 	case *intType:
-		a.eval = func(t *Thread) int64 { return v.(IntValue).Get(t) }
+		a.eval = func(t *Thread) int64 { return v.(IntValue).Get(t) };
 	case *idealIntType:
 		val := v.(IdealIntValue).Get();
-		a.eval = func() *bignum.Integer { return val }
+		a.eval = func() *bignum.Integer { return val };
 	case *floatType:
-		a.eval = func(t *Thread) float64 { return v.(FloatValue).Get(t) }
+		a.eval = func(t *Thread) float64 { return v.(FloatValue).Get(t) };
 	case *idealFloatType:
 		val := v.(IdealFloatValue).Get();
-		a.eval = func() *bignum.Rational { return val }
+		a.eval = func() *bignum.Rational { return val };
 	case *stringType:
-		a.eval = func(t *Thread) string { return v.(StringValue).Get(t) }
+		a.eval = func(t *Thread) string { return v.(StringValue).Get(t) };
 	case *ArrayType:
-		a.eval = func(t *Thread) ArrayValue { return v.(ArrayValue).Get(t) }
+		a.eval = func(t *Thread) ArrayValue { return v.(ArrayValue).Get(t) };
 	case *StructType:
-		a.eval = func(t *Thread) StructValue { return v.(StructValue).Get(t) }
+		a.eval = func(t *Thread) StructValue { return v.(StructValue).Get(t) };
 	case *PtrType:
-		a.eval = func(t *Thread) Value { return v.(PtrValue).Get(t) }
+		a.eval = func(t *Thread) Value { return v.(PtrValue).Get(t) };
 	case *FuncType:
-		a.eval = func(t *Thread) Func { return v.(FuncValue).Get(t) }
+		a.eval = func(t *Thread) Func { return v.(FuncValue).Get(t) };
 	case *SliceType:
-		a.eval = func(t *Thread) Slice { return v.(SliceValue).Get(t) }
+		a.eval = func(t *Thread) Slice { return v.(SliceValue).Get(t) };
 	case *MapType:
-		a.eval = func(t *Thread) Map { return v.(MapValue).Get(t) }
+		a.eval = func(t *Thread) Map { return v.(MapValue).Get(t) };
 	default:
 		log.Crashf("unexpected constant type %v at %v", a.t, a.pos);
 	}
@@ -132,59 +132,81 @@ func (a *expr) genIdentOp(level, index int) {
 	a.evalAddr = func(t *Thread) Value { return t.f.Get(level, index) };
 	switch a.t.lit().(type) {
 	case *boolType:
-		a.eval = func(t *Thread) bool { return t.f.Get(level, index).(BoolValue).Get(t) }
+		a.eval = func(t *Thread) bool {
+			return t.f.Get(level, index).(BoolValue).Get(t);
+		};
 	case *uintType:
-		a.eval = func(t *Thread) uint64 { return t.f.Get(level, index).(UintValue).Get(t) }
+		a.eval = func(t *Thread) uint64 {
+			return t.f.Get(level, index).(UintValue).Get(t);
+		};
 	case *intType:
-		a.eval = func(t *Thread) int64 { return t.f.Get(level, index).(IntValue).Get(t) }
+		a.eval = func(t *Thread) int64 {
+			return t.f.Get(level, index).(IntValue).Get(t);
+		};
 	case *floatType:
-		a.eval = func(t *Thread) float64 { return t.f.Get(level, index).(FloatValue).Get(t) }
+		a.eval = func(t *Thread) float64 {
+			return t.f.Get(level, index).(FloatValue).Get(t);
+		};
 	case *stringType:
-		a.eval = func(t *Thread) string { return t.f.Get(level, index).(StringValue).Get(t) }
+		a.eval = func(t *Thread) string {
+			return t.f.Get(level, index).(StringValue).Get(t);
+		};
 	case *ArrayType:
-		a.eval = func(t *Thread) ArrayValue { return t.f.Get(level, index).(ArrayValue).Get(t) }
+		a.eval = func(t *Thread) ArrayValue {
+			return t.f.Get(level, index).(ArrayValue).Get(t);
+		};
 	case *StructType:
-		a.eval = func(t *Thread) StructValue { return t.f.Get(level, index).(StructValue).Get(t) }
+		a.eval = func(t *Thread) StructValue {
+			return t.f.Get(level, index).(StructValue).Get(t);
+		};
 	case *PtrType:
-		a.eval = func(t *Thread) Value { return t.f.Get(level, index).(PtrValue).Get(t) }
+		a.eval = func(t *Thread) Value {
+			return t.f.Get(level, index).(PtrValue).Get(t);
+		};
 	case *FuncType:
-		a.eval = func(t *Thread) Func { return t.f.Get(level, index).(FuncValue).Get(t) }
+		a.eval = func(t *Thread) Func {
+			return t.f.Get(level, index).(FuncValue).Get(t);
+		};
 	case *SliceType:
-		a.eval = func(t *Thread) Slice { return t.f.Get(level, index).(SliceValue).Get(t) }
+		a.eval = func(t *Thread) Slice {
+			return t.f.Get(level, index).(SliceValue).Get(t);
+		};
 	case *MapType:
-		a.eval = func(t *Thread) Map { return t.f.Get(level, index).(MapValue).Get(t) }
+		a.eval = func(t *Thread) Map {
+			return t.f.Get(level, index).(MapValue).Get(t);
+		};
 	default:
 		log.Crashf("unexpected identifier type %v at %v", a.t, a.pos);
 	}
 }
 
 func (a *expr) genFuncCall(call func(t *Thread) []Value) {
-	a.exec = func(t *Thread) { call(t)};
+	a.exec = func(t *Thread) { call(t) };
 	switch a.t.lit().(type) {
 	case *boolType:
-		a.eval = func(t *Thread) bool { return call(t)[0].(BoolValue).Get(t) }
+		a.eval = func(t *Thread) bool { return call(t)[0].(BoolValue).Get(t) };
 	case *uintType:
-		a.eval = func(t *Thread) uint64 { return call(t)[0].(UintValue).Get(t) }
+		a.eval = func(t *Thread) uint64 { return call(t)[0].(UintValue).Get(t) };
 	case *intType:
-		a.eval = func(t *Thread) int64 { return call(t)[0].(IntValue).Get(t) }
+		a.eval = func(t *Thread) int64 { return call(t)[0].(IntValue).Get(t) };
 	case *floatType:
-		a.eval = func(t *Thread) float64 { return call(t)[0].(FloatValue).Get(t) }
+		a.eval = func(t *Thread) float64 { return call(t)[0].(FloatValue).Get(t) };
 	case *stringType:
-		a.eval = func(t *Thread) string { return call(t)[0].(StringValue).Get(t) }
+		a.eval = func(t *Thread) string { return call(t)[0].(StringValue).Get(t) };
 	case *ArrayType:
-		a.eval = func(t *Thread) ArrayValue { return call(t)[0].(ArrayValue).Get(t) }
+		a.eval = func(t *Thread) ArrayValue { return call(t)[0].(ArrayValue).Get(t) };
 	case *StructType:
-		a.eval = func(t *Thread) StructValue { return call(t)[0].(StructValue).Get(t) }
+		a.eval = func(t *Thread) StructValue { return call(t)[0].(StructValue).Get(t) };
 	case *PtrType:
-		a.eval = func(t *Thread) Value { return call(t)[0].(PtrValue).Get(t) }
+		a.eval = func(t *Thread) Value { return call(t)[0].(PtrValue).Get(t) };
 	case *FuncType:
-		a.eval = func(t *Thread) Func { return call(t)[0].(FuncValue).Get(t) }
+		a.eval = func(t *Thread) Func { return call(t)[0].(FuncValue).Get(t) };
 	case *SliceType:
-		a.eval = func(t *Thread) Slice { return call(t)[0].(SliceValue).Get(t) }
+		a.eval = func(t *Thread) Slice { return call(t)[0].(SliceValue).Get(t) };
 	case *MapType:
-		a.eval = func(t *Thread) Map { return call(t)[0].(MapValue).Get(t) }
+		a.eval = func(t *Thread) Map { return call(t)[0].(MapValue).Get(t) };
 	case *MultiType:
-		a.eval = func(t *Thread) []Value { return call(t) }
+		a.eval = func(t *Thread) []Value { return call(t) };
 	default:
 		log.Crashf("unexpected result type %v at %v", a.t, a.pos);
 	}
@@ -194,27 +216,27 @@ func (a *expr) genValue(vf func(*Thread) Value) {
 	a.evalAddr = vf;
 	switch a.t.lit().(type) {
 	case *boolType:
-		a.eval = func(t *Thread) bool { return vf(t).(BoolValue).Get(t) }
+		a.eval = func(t *Thread) bool { return vf(t).(BoolValue).Get(t) };
 	case *uintType:
-		a.eval = func(t *Thread) uint64 { return vf(t).(UintValue).Get(t) }
+		a.eval = func(t *Thread) uint64 { return vf(t).(UintValue).Get(t) };
 	case *intType:
-		a.eval = func(t *Thread) int64 { return vf(t).(IntValue).Get(t) }
+		a.eval = func(t *Thread) int64 { return vf(t).(IntValue).Get(t) };
 	case *floatType:
-		a.eval = func(t *Thread) float64 { return vf(t).(FloatValue).Get(t) }
+		a.eval = func(t *Thread) float64 { return vf(t).(FloatValue).Get(t) };
 	case *stringType:
-		a.eval = func(t *Thread) string { return vf(t).(StringValue).Get(t) }
+		a.eval = func(t *Thread) string { return vf(t).(StringValue).Get(t) };
 	case *ArrayType:
-		a.eval = func(t *Thread) ArrayValue { return vf(t).(ArrayValue).Get(t) }
+		a.eval = func(t *Thread) ArrayValue { return vf(t).(ArrayValue).Get(t) };
 	case *StructType:
-		a.eval = func(t *Thread) StructValue { return vf(t).(StructValue).Get(t) }
+		a.eval = func(t *Thread) StructValue { return vf(t).(StructValue).Get(t) };
 	case *PtrType:
-		a.eval = func(t *Thread) Value { return vf(t).(PtrValue).Get(t) }
+		a.eval = func(t *Thread) Value { return vf(t).(PtrValue).Get(t) };
 	case *FuncType:
-		a.eval = func(t *Thread) Func { return vf(t).(FuncValue).Get(t) }
+		a.eval = func(t *Thread) Func { return vf(t).(FuncValue).Get(t) };
 	case *SliceType:
-		a.eval = func(t *Thread) Slice { return vf(t).(SliceValue).Get(t) }
+		a.eval = func(t *Thread) Slice { return vf(t).(SliceValue).Get(t) };
 	case *MapType:
-		a.eval = func(t *Thread) Map { return vf(t).(MapValue).Get(t) }
+		a.eval = func(t *Thread) Map { return vf(t).(MapValue).Get(t) };
 	default:
 		log.Crashf("unexpected result type %v at %v", a.t, a.pos);
 	}
@@ -224,21 +246,30 @@ func (a *expr) genUnaryOpNeg(v *expr) {
 	switch a.t.lit().(type) {
 	case *uintType:
 		vf := v.asUint();
-		a.eval = func(t *Thread) uint64 { v := vf(t); return -v }
+		a.eval = func(t *Thread) uint64 {
+			v := vf(t);
+			return -v;
+		};
 	case *intType:
 		vf := v.asInt();
-		a.eval = func(t *Thread) int64 { v := vf(t); return -v }
+		a.eval = func(t *Thread) int64 {
+			v := vf(t);
+			return -v;
+		};
 	case *idealIntType:
 		v := v.asIdealInt()();
 		val := v.Neg();
-		a.eval = func() *bignum.Integer { return val }
+		a.eval = func() *bignum.Integer { return val };
 	case *floatType:
 		vf := v.asFloat();
-		a.eval = func(t *Thread) float64 { v := vf(t); return -v }
+		a.eval = func(t *Thread) float64 {
+			v := vf(t);
+			return -v;
+		};
 	case *idealFloatType:
 		v := v.asIdealFloat()();
 		val := v.Neg();
-		a.eval = func() *bignum.Rational { return val }
+		a.eval = func() *bignum.Rational { return val };
 	default:
 		log.Crashf("unexpected type %v at %v", a.t, a.pos);
 	}
@@ -248,7 +279,10 @@ func (a *expr) genUnaryOpNot(v *expr) {
 	switch a.t.lit().(type) {
 	case *boolType:
 		vf := v.asBool();
-		a.eval = func(t *Thread) bool { v := vf(t); return !v }
+		a.eval = func(t *Thread) bool {
+			v := vf(t);
+			return !v;
+		};
 	default:
 		log.Crashf("unexpected type %v at %v", a.t, a.pos);
 	}
@@ -258,14 +292,20 @@ func (a *expr) genUnaryOpXor(v *expr) {
 	switch a.t.lit().(type) {
 	case *uintType:
 		vf := v.asUint();
-		a.eval = func(t *Thread) uint64 { v := vf(t); return ^v }
+		a.eval = func(t *Thread) uint64 {
+			v := vf(t);
+			return ^v;
+		};
 	case *intType:
 		vf := v.asInt();
-		a.eval = func(t *Thread) int64 { v := vf(t); return ^v }
+		a.eval = func(t *Thread) int64 {
+			v := vf(t);
+			return ^v;
+		};
 	case *idealIntType:
 		v := v.asIdealInt()();
 		val := v.Neg().Sub(bignum.Int(1));
-		a.eval = func() *bignum.Integer { return val }
+		a.eval = func() *bignum.Integer { return val };
 	default:
 		log.Crashf("unexpected type %v at %v", a.t, a.pos);
 	}
@@ -274,13 +314,13 @@ func (a *expr) genUnaryOpXor(v *expr) {
 func (a *expr) genBinOpLogAnd(l, r *expr) {
 	lf := l.asBool();
 	rf := r.asBool();
-	a.eval = func(t *Thread) bool { return lf(t) && rf(t) }
+	a.eval = func(t *Thread) bool { return lf(t) && rf(t) };
 }
 
 func (a *expr) genBinOpLogOr(l, r *expr) {
 	lf := l.asBool();
 	rf := r.asBool();
-	a.eval = func(t *Thread) bool { return lf(t) || rf(t) }
+	a.eval = func(t *Thread) bool { return lf(t) || rf(t) };
 }
 
 func (a *expr) genBinOpAdd(l, r *expr) {
@@ -293,37 +333,37 @@ func (a *expr) genBinOpAdd(l, r *expr) {
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l + r;
-				return uint64(uint8(ret))
-			}
+				ret = l+r;
+				return uint64(uint8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l + r;
-				return uint64(uint16(ret))
-			}
+				ret = l+r;
+				return uint64(uint16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l + r;
-				return uint64(uint32(ret))
-			}
+				ret = l+r;
+				return uint64(uint32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l + r;
-				return uint64(uint64(ret))
-			}
+				ret = l+r;
+				return uint64(uint64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l + r;
-				return uint64(uint(ret))
-			}
+				ret = l+r;
+				return uint64(uint(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -335,37 +375,37 @@ func (a *expr) genBinOpAdd(l, r *expr) {
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l + r;
-				return int64(int8(ret))
-			}
+				ret = l+r;
+				return int64(int8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l + r;
-				return int64(int16(ret))
-			}
+				ret = l+r;
+				return int64(int16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l + r;
-				return int64(int32(ret))
-			}
+				ret = l+r;
+				return int64(int32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l + r;
-				return int64(int64(ret))
-			}
+				ret = l+r;
+				return int64(int64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l + r;
-				return int64(int(ret))
-			}
+				ret = l+r;
+				return int64(int(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -373,7 +413,7 @@ func (a *expr) genBinOpAdd(l, r *expr) {
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
 		val := l.Add(r);
-		a.eval = func() *bignum.Integer { return val }
+		a.eval = func() *bignum.Integer { return val };
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
@@ -382,23 +422,23 @@ func (a *expr) genBinOpAdd(l, r *expr) {
 			a.eval = func(t *Thread) float64 {
 				l, r := lf(t), rf(t);
 				var ret float64;
-				ret = l + r;
-				return float64(float32(ret))
-			}
+				ret = l+r;
+				return float64(float32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) float64 {
 				l, r := lf(t), rf(t);
 				var ret float64;
-				ret = l + r;
-				return float64(float64(ret))
-			}
+				ret = l+r;
+				return float64(float64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) float64 {
 				l, r := lf(t), rf(t);
 				var ret float64;
-				ret = l + r;
-				return float64(float(ret))
-			}
+				ret = l+r;
+				return float64(float(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -406,14 +446,14 @@ func (a *expr) genBinOpAdd(l, r *expr) {
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
 		val := l.Add(r);
-		a.eval = func() *bignum.Rational { return val }
+		a.eval = func() *bignum.Rational { return val };
 	case *stringType:
 		lf := l.asString();
 		rf := r.asString();
 		a.eval = func(t *Thread) string {
 			l, r := lf(t), rf(t);
-			return l + r
-		}
+			return l+r;
+		};
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
@@ -429,37 +469,37 @@ func (a *expr) genBinOpSub(l, r *expr) {
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l - r;
-				return uint64(uint8(ret))
-			}
+				ret = l-r;
+				return uint64(uint8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l - r;
-				return uint64(uint16(ret))
-			}
+				ret = l-r;
+				return uint64(uint16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l - r;
-				return uint64(uint32(ret))
-			}
+				ret = l-r;
+				return uint64(uint32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l - r;
-				return uint64(uint64(ret))
-			}
+				ret = l-r;
+				return uint64(uint64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l - r;
-				return uint64(uint(ret))
-			}
+				ret = l-r;
+				return uint64(uint(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -471,37 +511,37 @@ func (a *expr) genBinOpSub(l, r *expr) {
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l - r;
-				return int64(int8(ret))
-			}
+				ret = l-r;
+				return int64(int8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l - r;
-				return int64(int16(ret))
-			}
+				ret = l-r;
+				return int64(int16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l - r;
-				return int64(int32(ret))
-			}
+				ret = l-r;
+				return int64(int32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l - r;
-				return int64(int64(ret))
-			}
+				ret = l-r;
+				return int64(int64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l - r;
-				return int64(int(ret))
-			}
+				ret = l-r;
+				return int64(int(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -509,7 +549,7 @@ func (a *expr) genBinOpSub(l, r *expr) {
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
 		val := l.Sub(r);
-		a.eval = func() *bignum.Integer { return val }
+		a.eval = func() *bignum.Integer { return val };
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
@@ -518,23 +558,23 @@ func (a *expr) genBinOpSub(l, r *expr) {
 			a.eval = func(t *Thread) float64 {
 				l, r := lf(t), rf(t);
 				var ret float64;
-				ret = l - r;
-				return float64(float32(ret))
-			}
+				ret = l-r;
+				return float64(float32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) float64 {
 				l, r := lf(t), rf(t);
 				var ret float64;
-				ret = l - r;
-				return float64(float64(ret))
-			}
+				ret = l-r;
+				return float64(float64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) float64 {
 				l, r := lf(t), rf(t);
 				var ret float64;
-				ret = l - r;
-				return float64(float(ret))
-			}
+				ret = l-r;
+				return float64(float(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -542,7 +582,7 @@ func (a *expr) genBinOpSub(l, r *expr) {
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
 		val := l.Sub(r);
-		a.eval = func() *bignum.Rational { return val }
+		a.eval = func() *bignum.Rational { return val };
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
@@ -558,37 +598,37 @@ func (a *expr) genBinOpMul(l, r *expr) {
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l * r;
-				return uint64(uint8(ret))
-			}
+				ret = l*r;
+				return uint64(uint8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l * r;
-				return uint64(uint16(ret))
-			}
+				ret = l*r;
+				return uint64(uint16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l * r;
-				return uint64(uint32(ret))
-			}
+				ret = l*r;
+				return uint64(uint32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l * r;
-				return uint64(uint64(ret))
-			}
+				ret = l*r;
+				return uint64(uint64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l * r;
-				return uint64(uint(ret))
-			}
+				ret = l*r;
+				return uint64(uint(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -600,37 +640,37 @@ func (a *expr) genBinOpMul(l, r *expr) {
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l * r;
-				return int64(int8(ret))
-			}
+				ret = l*r;
+				return int64(int8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l * r;
-				return int64(int16(ret))
-			}
+				ret = l*r;
+				return int64(int16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l * r;
-				return int64(int32(ret))
-			}
+				ret = l*r;
+				return int64(int32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l * r;
-				return int64(int64(ret))
-			}
+				ret = l*r;
+				return int64(int64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l * r;
-				return int64(int(ret))
-			}
+				ret = l*r;
+				return int64(int(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -638,7 +678,7 @@ func (a *expr) genBinOpMul(l, r *expr) {
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
 		val := l.Mul(r);
-		a.eval = func() *bignum.Integer { return val }
+		a.eval = func() *bignum.Integer { return val };
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
@@ -647,23 +687,23 @@ func (a *expr) genBinOpMul(l, r *expr) {
 			a.eval = func(t *Thread) float64 {
 				l, r := lf(t), rf(t);
 				var ret float64;
-				ret = l * r;
-				return float64(float32(ret))
-			}
+				ret = l*r;
+				return float64(float32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) float64 {
 				l, r := lf(t), rf(t);
 				var ret float64;
-				ret = l * r;
-				return float64(float64(ret))
-			}
+				ret = l*r;
+				return float64(float64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) float64 {
 				l, r := lf(t), rf(t);
 				var ret float64;
-				ret = l * r;
-				return float64(float(ret))
-			}
+				ret = l*r;
+				return float64(float(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -671,7 +711,7 @@ func (a *expr) genBinOpMul(l, r *expr) {
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
 		val := l.Mul(r);
-		a.eval = func() *bignum.Rational { return val }
+		a.eval = func() *bignum.Rational { return val };
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
@@ -687,37 +727,52 @@ func (a *expr) genBinOpQuo(l, r *expr) {
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret =  l / r;
-				return uint64(uint8(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l/r;
+				return uint64(uint8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret =  l / r;
-				return uint64(uint16(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l/r;
+				return uint64(uint16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret =  l / r;
-				return uint64(uint32(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l/r;
+				return uint64(uint32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret =  l / r;
-				return uint64(uint64(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l/r;
+				return uint64(uint64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret =  l / r;
-				return uint64(uint(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l/r;
+				return uint64(uint(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -729,37 +784,52 @@ func (a *expr) genBinOpQuo(l, r *expr) {
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret =  l / r;
-				return int64(int8(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l/r;
+				return int64(int8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret =  l / r;
-				return int64(int16(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l/r;
+				return int64(int16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret =  l / r;
-				return int64(int32(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l/r;
+				return int64(int32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret =  l / r;
-				return int64(int64(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l/r;
+				return int64(int64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret =  l / r;
-				return int64(int(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l/r;
+				return int64(int(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -767,7 +837,7 @@ func (a *expr) genBinOpQuo(l, r *expr) {
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
 		val := l.Quo(r);
-		a.eval = func() *bignum.Integer { return val }
+		a.eval = func() *bignum.Integer { return val };
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
@@ -776,23 +846,32 @@ func (a *expr) genBinOpQuo(l, r *expr) {
 			a.eval = func(t *Thread) float64 {
 				l, r := lf(t), rf(t);
 				var ret float64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret =  l / r;
-				return float64(float32(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l/r;
+				return float64(float32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) float64 {
 				l, r := lf(t), rf(t);
 				var ret float64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret =  l / r;
-				return float64(float64(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l/r;
+				return float64(float64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) float64 {
 				l, r := lf(t), rf(t);
 				var ret float64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret =  l / r;
-				return float64(float(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l/r;
+				return float64(float(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -800,7 +879,7 @@ func (a *expr) genBinOpQuo(l, r *expr) {
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
 		val := l.Quo(r);
-		a.eval = func() *bignum.Rational { return val }
+		a.eval = func() *bignum.Rational { return val };
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
@@ -816,37 +895,52 @@ func (a *expr) genBinOpRem(l, r *expr) {
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
-				return uint64(uint8(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l%r;
+				return uint64(uint8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
-				return uint64(uint16(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l%r;
+				return uint64(uint16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
-				return uint64(uint32(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l%r;
+				return uint64(uint32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
-				return uint64(uint64(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l%r;
+				return uint64(uint64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
-				return uint64(uint(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l%r;
+				return uint64(uint(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -858,37 +952,52 @@ func (a *expr) genBinOpRem(l, r *expr) {
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
-				return int64(int8(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l%r;
+				return int64(int8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
-				return int64(int16(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l%r;
+				return int64(int16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
-				return int64(int32(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l%r;
+				return int64(int32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
-				return int64(int64(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l%r;
+				return int64(int64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				if r == 0 { t.Abort(DivByZeroError{}) } ret = l % r;
-				return int64(int(ret))
-			}
+				if r == 0 {
+					t.Abort(DivByZeroError{});
+				}
+				ret = l%r;
+				return int64(int(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -896,7 +1005,7 @@ func (a *expr) genBinOpRem(l, r *expr) {
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
 		val := l.Rem(r);
-		a.eval = func() *bignum.Integer { return val }
+		a.eval = func() *bignum.Integer { return val };
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
@@ -912,37 +1021,37 @@ func (a *expr) genBinOpAnd(l, r *expr) {
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l & r;
-				return uint64(uint8(ret))
-			}
+				ret = l&r;
+				return uint64(uint8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l & r;
-				return uint64(uint16(ret))
-			}
+				ret = l&r;
+				return uint64(uint16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l & r;
-				return uint64(uint32(ret))
-			}
+				ret = l&r;
+				return uint64(uint32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l & r;
-				return uint64(uint64(ret))
-			}
+				ret = l&r;
+				return uint64(uint64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l & r;
-				return uint64(uint(ret))
-			}
+				ret = l&r;
+				return uint64(uint(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -954,37 +1063,37 @@ func (a *expr) genBinOpAnd(l, r *expr) {
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l & r;
-				return int64(int8(ret))
-			}
+				ret = l&r;
+				return int64(int8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l & r;
-				return int64(int16(ret))
-			}
+				ret = l&r;
+				return int64(int16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l & r;
-				return int64(int32(ret))
-			}
+				ret = l&r;
+				return int64(int32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l & r;
-				return int64(int64(ret))
-			}
+				ret = l&r;
+				return int64(int64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l & r;
-				return int64(int(ret))
-			}
+				ret = l&r;
+				return int64(int(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -992,7 +1101,7 @@ func (a *expr) genBinOpAnd(l, r *expr) {
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
 		val := l.And(r);
-		a.eval = func() *bignum.Integer { return val }
+		a.eval = func() *bignum.Integer { return val };
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
@@ -1008,37 +1117,37 @@ func (a *expr) genBinOpOr(l, r *expr) {
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l | r;
-				return uint64(uint8(ret))
-			}
+				ret = l|r;
+				return uint64(uint8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l | r;
-				return uint64(uint16(ret))
-			}
+				ret = l|r;
+				return uint64(uint16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l | r;
-				return uint64(uint32(ret))
-			}
+				ret = l|r;
+				return uint64(uint32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l | r;
-				return uint64(uint64(ret))
-			}
+				ret = l|r;
+				return uint64(uint64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l | r;
-				return uint64(uint(ret))
-			}
+				ret = l|r;
+				return uint64(uint(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -1050,37 +1159,37 @@ func (a *expr) genBinOpOr(l, r *expr) {
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l | r;
-				return int64(int8(ret))
-			}
+				ret = l|r;
+				return int64(int8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l | r;
-				return int64(int16(ret))
-			}
+				ret = l|r;
+				return int64(int16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l | r;
-				return int64(int32(ret))
-			}
+				ret = l|r;
+				return int64(int32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l | r;
-				return int64(int64(ret))
-			}
+				ret = l|r;
+				return int64(int64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l | r;
-				return int64(int(ret))
-			}
+				ret = l|r;
+				return int64(int(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -1088,7 +1197,7 @@ func (a *expr) genBinOpOr(l, r *expr) {
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
 		val := l.Or(r);
-		a.eval = func() *bignum.Integer { return val }
+		a.eval = func() *bignum.Integer { return val };
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
@@ -1104,37 +1213,37 @@ func (a *expr) genBinOpXor(l, r *expr) {
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l ^ r;
-				return uint64(uint8(ret))
-			}
+				ret = l^r;
+				return uint64(uint8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l ^ r;
-				return uint64(uint16(ret))
-			}
+				ret = l^r;
+				return uint64(uint16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l ^ r;
-				return uint64(uint32(ret))
-			}
+				ret = l^r;
+				return uint64(uint32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l ^ r;
-				return uint64(uint64(ret))
-			}
+				ret = l^r;
+				return uint64(uint64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l ^ r;
-				return uint64(uint(ret))
-			}
+				ret = l^r;
+				return uint64(uint(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -1146,37 +1255,37 @@ func (a *expr) genBinOpXor(l, r *expr) {
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l ^ r;
-				return int64(int8(ret))
-			}
+				ret = l^r;
+				return int64(int8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l ^ r;
-				return int64(int16(ret))
-			}
+				ret = l^r;
+				return int64(int16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l ^ r;
-				return int64(int32(ret))
-			}
+				ret = l^r;
+				return int64(int32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l ^ r;
-				return int64(int64(ret))
-			}
+				ret = l^r;
+				return int64(int64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l ^ r;
-				return int64(int(ret))
-			}
+				ret = l^r;
+				return int64(int(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -1184,7 +1293,7 @@ func (a *expr) genBinOpXor(l, r *expr) {
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
 		val := l.Xor(r);
-		a.eval = func() *bignum.Integer { return val }
+		a.eval = func() *bignum.Integer { return val };
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
@@ -1200,37 +1309,37 @@ func (a *expr) genBinOpAndNot(l, r *expr) {
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l &^ r;
-				return uint64(uint8(ret))
-			}
+				ret = l&^r;
+				return uint64(uint8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l &^ r;
-				return uint64(uint16(ret))
-			}
+				ret = l&^r;
+				return uint64(uint16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l &^ r;
-				return uint64(uint32(ret))
-			}
+				ret = l&^r;
+				return uint64(uint32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l &^ r;
-				return uint64(uint64(ret))
-			}
+				ret = l&^r;
+				return uint64(uint64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l &^ r;
-				return uint64(uint(ret))
-			}
+				ret = l&^r;
+				return uint64(uint(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -1242,37 +1351,37 @@ func (a *expr) genBinOpAndNot(l, r *expr) {
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l &^ r;
-				return int64(int8(ret))
-			}
+				ret = l&^r;
+				return int64(int8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l &^ r;
-				return int64(int16(ret))
-			}
+				ret = l&^r;
+				return int64(int16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l &^ r;
-				return int64(int32(ret))
-			}
+				ret = l&^r;
+				return int64(int32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l &^ r;
-				return int64(int64(ret))
-			}
+				ret = l&^r;
+				return int64(int64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l &^ r;
-				return int64(int(ret))
-			}
+				ret = l&^r;
+				return int64(int(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -1280,7 +1389,7 @@ func (a *expr) genBinOpAndNot(l, r *expr) {
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
 		val := l.AndNot(r);
-		a.eval = func() *bignum.Integer { return val }
+		a.eval = func() *bignum.Integer { return val };
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
@@ -1296,37 +1405,37 @@ func (a *expr) genBinOpShl(l, r *expr) {
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l << r;
-				return uint64(uint8(ret))
-			}
+				ret = l<<r;
+				return uint64(uint8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l << r;
-				return uint64(uint16(ret))
-			}
+				ret = l<<r;
+				return uint64(uint16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l << r;
-				return uint64(uint32(ret))
-			}
+				ret = l<<r;
+				return uint64(uint32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l << r;
-				return uint64(uint64(ret))
-			}
+				ret = l<<r;
+				return uint64(uint64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l << r;
-				return uint64(uint(ret))
-			}
+				ret = l<<r;
+				return uint64(uint(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -1338,37 +1447,37 @@ func (a *expr) genBinOpShl(l, r *expr) {
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l << r;
-				return int64(int8(ret))
-			}
+				ret = l<<r;
+				return int64(int8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l << r;
-				return int64(int16(ret))
-			}
+				ret = l<<r;
+				return int64(int16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l << r;
-				return int64(int32(ret))
-			}
+				ret = l<<r;
+				return int64(int32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l << r;
-				return int64(int64(ret))
-			}
+				ret = l<<r;
+				return int64(int64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l << r;
-				return int64(int(ret))
-			}
+				ret = l<<r;
+				return int64(int(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -1387,37 +1496,37 @@ func (a *expr) genBinOpShr(l, r *expr) {
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l >> r;
-				return uint64(uint8(ret))
-			}
+				ret = l>>r;
+				return uint64(uint8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l >> r;
-				return uint64(uint16(ret))
-			}
+				ret = l>>r;
+				return uint64(uint16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l >> r;
-				return uint64(uint32(ret))
-			}
+				ret = l>>r;
+				return uint64(uint32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l >> r;
-				return uint64(uint64(ret))
-			}
+				ret = l>>r;
+				return uint64(uint64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) uint64 {
 				l, r := lf(t), rf(t);
 				var ret uint64;
-				ret = l >> r;
-				return uint64(uint(ret))
-			}
+				ret = l>>r;
+				return uint64(uint(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -1429,37 +1538,37 @@ func (a *expr) genBinOpShr(l, r *expr) {
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l >> r;
-				return int64(int8(ret))
-			}
+				ret = l>>r;
+				return int64(int8(ret));
+			};
 		case 16:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l >> r;
-				return int64(int16(ret))
-			}
+				ret = l>>r;
+				return int64(int16(ret));
+			};
 		case 32:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l >> r;
-				return int64(int32(ret))
-			}
+				ret = l>>r;
+				return int64(int32(ret));
+			};
 		case 64:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l >> r;
-				return int64(int64(ret))
-			}
+				ret = l>>r;
+				return int64(int64(ret));
+			};
 		case 0:
 			a.eval = func(t *Thread) int64 {
 				l, r := lf(t), rf(t);
 				var ret int64;
-				ret = l >> r;
-				return int64(int(ret))
-			}
+				ret = l>>r;
+				return int64(int(ret));
+			};
 		default:
 			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
 		}
@@ -1475,39 +1584,39 @@ func (a *expr) genBinOpLss(l, r *expr) {
 		rf := r.asUint();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l < r
-		}
+			return l < r;
+		};
 	case *intType:
 		lf := l.asInt();
 		rf := r.asInt();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l < r
-		}
+			return l < r;
+		};
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
 		val := l.Cmp(r) < 0;
-		a.eval = func(t *Thread) bool { return val }
+		a.eval = func(t *Thread) bool { return val };
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l < r
-		}
+			return l < r;
+		};
 	case *idealFloatType:
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
 		val := l.Cmp(r) < 0;
-		a.eval = func(t *Thread) bool { return val }
+		a.eval = func(t *Thread) bool { return val };
 	case *stringType:
 		lf := l.asString();
 		rf := r.asString();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l < r
-		}
+			return l < r;
+		};
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
@@ -1520,39 +1629,39 @@ func (a *expr) genBinOpGtr(l, r *expr) {
 		rf := r.asUint();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l > r
-		}
+			return l > r;
+		};
 	case *intType:
 		lf := l.asInt();
 		rf := r.asInt();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l > r
-		}
+			return l > r;
+		};
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
 		val := l.Cmp(r) > 0;
-		a.eval = func(t *Thread) bool { return val }
+		a.eval = func(t *Thread) bool { return val };
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l > r
-		}
+			return l > r;
+		};
 	case *idealFloatType:
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
 		val := l.Cmp(r) > 0;
-		a.eval = func(t *Thread) bool { return val }
+		a.eval = func(t *Thread) bool { return val };
 	case *stringType:
 		lf := l.asString();
 		rf := r.asString();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l > r
-		}
+			return l > r;
+		};
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
@@ -1565,39 +1674,39 @@ func (a *expr) genBinOpLeq(l, r *expr) {
 		rf := r.asUint();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l <= r
-		}
+			return l <= r;
+		};
 	case *intType:
 		lf := l.asInt();
 		rf := r.asInt();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l <= r
-		}
+			return l <= r;
+		};
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
 		val := l.Cmp(r) <= 0;
-		a.eval = func(t *Thread) bool { return val }
+		a.eval = func(t *Thread) bool { return val };
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l <= r
-		}
+			return l <= r;
+		};
 	case *idealFloatType:
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
 		val := l.Cmp(r) <= 0;
-		a.eval = func(t *Thread) bool { return val }
+		a.eval = func(t *Thread) bool { return val };
 	case *stringType:
 		lf := l.asString();
 		rf := r.asString();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l <= r
-		}
+			return l <= r;
+		};
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
@@ -1610,39 +1719,39 @@ func (a *expr) genBinOpGeq(l, r *expr) {
 		rf := r.asUint();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l >= r
-		}
+			return l >= r;
+		};
 	case *intType:
 		lf := l.asInt();
 		rf := r.asInt();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l >= r
-		}
+			return l >= r;
+		};
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
 		val := l.Cmp(r) >= 0;
-		a.eval = func(t *Thread) bool { return val }
+		a.eval = func(t *Thread) bool { return val };
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l >= r
-		}
+			return l >= r;
+		};
 	case *idealFloatType:
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
 		val := l.Cmp(r) >= 0;
-		a.eval = func(t *Thread) bool { return val }
+		a.eval = func(t *Thread) bool { return val };
 	case *stringType:
 		lf := l.asString();
 		rf := r.asString();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l >= r
-		}
+			return l >= r;
+		};
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
@@ -1655,67 +1764,67 @@ func (a *expr) genBinOpEql(l, r *expr) {
 		rf := r.asBool();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l == r
-		}
+			return l == r;
+		};
 	case *uintType:
 		lf := l.asUint();
 		rf := r.asUint();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l == r
-		}
+			return l == r;
+		};
 	case *intType:
 		lf := l.asInt();
 		rf := r.asInt();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l == r
-		}
+			return l == r;
+		};
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
 		val := l.Cmp(r) == 0;
-		a.eval = func(t *Thread) bool { return val }
+		a.eval = func(t *Thread) bool { return val };
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l == r
-		}
+			return l == r;
+		};
 	case *idealFloatType:
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
 		val := l.Cmp(r) == 0;
-		a.eval = func(t *Thread) bool { return val }
+		a.eval = func(t *Thread) bool { return val };
 	case *stringType:
 		lf := l.asString();
 		rf := r.asString();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l == r
-		}
+			return l == r;
+		};
 	case *PtrType:
 		lf := l.asPtr();
 		rf := r.asPtr();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l == r
-		}
+			return l == r;
+		};
 	case *FuncType:
 		lf := l.asFunc();
 		rf := r.asFunc();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l == r
-		}
+			return l == r;
+		};
 	case *MapType:
 		lf := l.asMap();
 		rf := r.asMap();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l == r
-		}
+			return l == r;
+		};
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
@@ -1728,67 +1837,67 @@ func (a *expr) genBinOpNeq(l, r *expr) {
 		rf := r.asBool();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l != r
-		}
+			return l != r;
+		};
 	case *uintType:
 		lf := l.asUint();
 		rf := r.asUint();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l != r
-		}
+			return l != r;
+		};
 	case *intType:
 		lf := l.asInt();
 		rf := r.asInt();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l != r
-		}
+			return l != r;
+		};
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
 		val := l.Cmp(r) != 0;
-		a.eval = func(t *Thread) bool { return val }
+		a.eval = func(t *Thread) bool { return val };
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l != r
-		}
+			return l != r;
+		};
 	case *idealFloatType:
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
 		val := l.Cmp(r) != 0;
-		a.eval = func(t *Thread) bool { return val }
+		a.eval = func(t *Thread) bool { return val };
 	case *stringType:
 		lf := l.asString();
 		rf := r.asString();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l != r
-		}
+			return l != r;
+		};
 	case *PtrType:
 		lf := l.asPtr();
 		rf := r.asPtr();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l != r
-		}
+			return l != r;
+		};
 	case *FuncType:
 		lf := l.asFunc();
 		rf := r.asFunc();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l != r
-		}
+			return l != r;
+		};
 	case *MapType:
 		lf := l.asMap();
 		rf := r.asMap();
 		a.eval = func(t *Thread) bool {
 			l, r := lf(t), rf(t);
-			return l != r
-		}
+			return l != r;
+		};
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
@@ -1798,37 +1907,37 @@ func genAssign(lt Type, r *expr) (func(lv Value, t *Thread)) {
 	switch lt.lit().(type) {
 	case *boolType:
 		rf := r.asBool();
-		return func(lv Value, t *Thread) { lv.(BoolValue).Set(t, rf(t)) }
+		return func(lv Value, t *Thread) { lv.(BoolValue).Set(t, rf(t)) };
 	case *uintType:
 		rf := r.asUint();
-		return func(lv Value, t *Thread) { lv.(UintValue).Set(t, rf(t)) }
+		return func(lv Value, t *Thread) { lv.(UintValue).Set(t, rf(t)) };
 	case *intType:
 		rf := r.asInt();
-		return func(lv Value, t *Thread) { lv.(IntValue).Set(t, rf(t)) }
+		return func(lv Value, t *Thread) { lv.(IntValue).Set(t, rf(t)) };
 	case *floatType:
 		rf := r.asFloat();
-		return func(lv Value, t *Thread) { lv.(FloatValue).Set(t, rf(t)) }
+		return func(lv Value, t *Thread) { lv.(FloatValue).Set(t, rf(t)) };
 	case *stringType:
 		rf := r.asString();
-		return func(lv Value, t *Thread) { lv.(StringValue).Set(t, rf(t)) }
+		return func(lv Value, t *Thread) { lv.(StringValue).Set(t, rf(t)) };
 	case *ArrayType:
 		rf := r.asArray();
-		return func(lv Value, t *Thread) { lv.Assign(t, rf(t)) }
+		return func(lv Value, t *Thread) { lv.Assign(t, rf(t)) };
 	case *StructType:
 		rf := r.asStruct();
-		return func(lv Value, t *Thread) { lv.Assign(t, rf(t)) }
+		return func(lv Value, t *Thread) { lv.Assign(t, rf(t)) };
 	case *PtrType:
 		rf := r.asPtr();
-		return func(lv Value, t *Thread) { lv.(PtrValue).Set(t, rf(t)) }
+		return func(lv Value, t *Thread) { lv.(PtrValue).Set(t, rf(t)) };
 	case *FuncType:
 		rf := r.asFunc();
-		return func(lv Value, t *Thread) { lv.(FuncValue).Set(t, rf(t)) }
+		return func(lv Value, t *Thread) { lv.(FuncValue).Set(t, rf(t)) };
 	case *SliceType:
 		rf := r.asSlice();
-		return func(lv Value, t *Thread) { lv.(SliceValue).Set(t, rf(t)) }
+		return func(lv Value, t *Thread) { lv.(SliceValue).Set(t, rf(t)) };
 	case *MapType:
 		rf := r.asMap();
-		return func(lv Value, t *Thread) { lv.(MapValue).Set(t, rf(t)) }
+		return func(lv Value, t *Thread) { lv.(MapValue).Set(t, rf(t)) };
 	default:
 		log.Crashf("unexpected left operand type %v at %v", lt, r.pos);
 	}