interpreter checkpoint.

  * generate different versions of binary operators
    for each size of int and float, so that proper
    truncating happens after each operation to
    simulate the various sized ops.
  * add slice expressions
  * publish World.CompileStmtList, CompileDeclList, CompileExpr
  * handle type-less expressions in CompileExpr

R=austin
DELTA=1459  (1327 added, 11 deleted, 121 changed)
OCL=34382
CL=35581

1 files changed, 1134 insertions, 92 deletions

diff --git a/usr/austin/eval/expr1.go b/usr/austin/eval/expr1.go
index d337ea177..7787a2112 100644
--- a/usr/austin/eval/expr1.go
+++ b/usr/austin/eval/expr1.go
@@ -1,4 +1,3 @@
-
 // This file is machine generated by gen.go.
 // 6g gen.go && 6l gen.6 && ./6.out >expr1.go
 
@@ -58,31 +57,31 @@ func (a *expr) asMulti() (func(*Thread) []Value) {
 
 func (a *expr) asInterface() (func(*Thread) interface{}) {
 	switch sf := a.eval.(type) {
-	case func(*Thread)bool:
-		return func(t *Thread) interface{} { return sf(t) }
-	case func(*Thread)uint64:
+	case func(t *Thread)bool:
 		return func(t *Thread) interface{} { return sf(t) }
-	case func(*Thread)int64:
+	case func(t *Thread)uint64:
 		return func(t *Thread) interface{} { return sf(t) }
-	case func(*Thread)*bignum.Integer:
+	case func(t *Thread)int64:
 		return func(t *Thread) interface{} { return sf(t) }
-	case func(*Thread)float64:
+	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(*Thread)*bignum.Rational:
+	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(*Thread)string:
+	case func(t *Thread)ArrayValue:
 		return func(t *Thread) interface{} { return sf(t) }
-	case func(*Thread)ArrayValue:
+	case func(t *Thread)StructValue:
 		return func(t *Thread) interface{} { return sf(t) }
-	case func(*Thread)StructValue:
+	case func(t *Thread)Value:
 		return func(t *Thread) interface{} { return sf(t) }
-	case func(*Thread)Value:
+	case func(t *Thread)Func:
 		return func(t *Thread) interface{} { return sf(t) }
-	case func(*Thread)Func:
+	case func(t *Thread)Slice:
 		return func(t *Thread) interface{} { return sf(t) }
-	case func(*Thread)Slice:
-		return func(t *Thread) interface{} { return sf(t) }
-	case func(*Thread)Map:
+	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);
@@ -272,16 +271,104 @@ 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) }
+}
+
+func (a *expr) genBinOpLogOr(l, r *expr) {
+	lf := l.asBool();
+	rf := r.asBool();
+	a.eval = func(t *Thread) bool { return lf(t) || rf(t) }
+}
+
 func (a *expr) genBinOpAdd(l, r *expr) {
-	switch l.t.lit().(type) {
+	switch t := l.t.lit().(type) {
 	case *uintType:
 		lf := l.asUint();
 		rf := r.asUint();
-		a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l + r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				ret = l + r;
+				return uint64(uint(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *intType:
 		lf := l.asInt();
 		rf := r.asInt();
-		a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l + r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				ret = l + r;
+				return int64(int(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
@@ -290,7 +377,31 @@ func (a *expr) genBinOpAdd(l, r *expr) {
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
-		a.eval = func(t *Thread) float64 { l, r := lf(t), rf(t); return l + r }
+		switch t.Bits {
+		case 32:
+			a.eval = func(t *Thread) float64 {
+				l, r := lf(t), rf(t);
+				var ret float64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) float64 {
+				l, r := lf(t), rf(t);
+				var ret float64;
+				ret = l + r;
+				return float64(float(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *idealFloatType:
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
@@ -299,22 +410,101 @@ func (a *expr) genBinOpAdd(l, r *expr) {
 	case *stringType:
 		lf := l.asString();
 		rf := r.asString();
-		a.eval = func(t *Thread) string { l, r := lf(t), rf(t); return l + r }
+		a.eval = func(t *Thread) string {
+			l, r := lf(t), rf(t);
+			return l + r
+		}
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
 }
 
 func (a *expr) genBinOpSub(l, r *expr) {
-	switch l.t.lit().(type) {
+	switch t := l.t.lit().(type) {
 	case *uintType:
 		lf := l.asUint();
 		rf := r.asUint();
-		a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l - r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				ret = l - r;
+				return uint64(uint(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *intType:
 		lf := l.asInt();
 		rf := r.asInt();
-		a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l - r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				ret = l - r;
+				return int64(int(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
@@ -323,7 +513,31 @@ func (a *expr) genBinOpSub(l, r *expr) {
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
-		a.eval = func(t *Thread) float64 { l, r := lf(t), rf(t); return l - r }
+		switch t.Bits {
+		case 32:
+			a.eval = func(t *Thread) float64 {
+				l, r := lf(t), rf(t);
+				var ret float64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) float64 {
+				l, r := lf(t), rf(t);
+				var ret float64;
+				ret = l - r;
+				return float64(float(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *idealFloatType:
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
@@ -335,15 +549,91 @@ func (a *expr) genBinOpSub(l, r *expr) {
 }
 
 func (a *expr) genBinOpMul(l, r *expr) {
-	switch l.t.lit().(type) {
+	switch t := l.t.lit().(type) {
 	case *uintType:
 		lf := l.asUint();
 		rf := r.asUint();
-		a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l * r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				ret = l * r;
+				return uint64(uint(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *intType:
 		lf := l.asInt();
 		rf := r.asInt();
-		a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l * r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				ret = l * r;
+				return int64(int(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
@@ -352,7 +642,31 @@ func (a *expr) genBinOpMul(l, r *expr) {
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
-		a.eval = func(t *Thread) float64 { l, r := lf(t), rf(t); return l * r }
+		switch t.Bits {
+		case 32:
+			a.eval = func(t *Thread) float64 {
+				l, r := lf(t), rf(t);
+				var ret float64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) float64 {
+				l, r := lf(t), rf(t);
+				var ret float64;
+				ret = l * r;
+				return float64(float(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *idealFloatType:
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
@@ -364,15 +678,91 @@ func (a *expr) genBinOpMul(l, r *expr) {
 }
 
 func (a *expr) genBinOpQuo(l, r *expr) {
-	switch l.t.lit().(type) {
+	switch t := l.t.lit().(type) {
 	case *uintType:
 		lf := l.asUint();
 		rf := r.asUint();
-		a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); if r == 0 { t.Abort(DivByZeroError{}) } return l / r }
+		switch t.Bits {
+		case 8:
+			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))
+			}
+		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))
+			}
+		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))
+			}
+		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))
+			}
+		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))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *intType:
 		lf := l.asInt();
 		rf := r.asInt();
-		a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); if r == 0 { t.Abort(DivByZeroError{}) } return l / r }
+		switch t.Bits {
+		case 8:
+			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))
+			}
+		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))
+			}
+		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))
+			}
+		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))
+			}
+		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))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
@@ -381,7 +771,31 @@ func (a *expr) genBinOpQuo(l, r *expr) {
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
-		a.eval = func(t *Thread) float64 { l, r := lf(t), rf(t); if r == 0 { t.Abort(DivByZeroError{}) } return l / r }
+		switch t.Bits {
+		case 32:
+			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))
+			}
+		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))
+			}
+		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))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *idealFloatType:
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
@@ -393,15 +807,91 @@ func (a *expr) genBinOpQuo(l, r *expr) {
 }
 
 func (a *expr) genBinOpRem(l, r *expr) {
-	switch l.t.lit().(type) {
+	switch t := l.t.lit().(type) {
 	case *uintType:
 		lf := l.asUint();
 		rf := r.asUint();
-		a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); if r == 0 { t.Abort(DivByZeroError{}) } return l % r }
+		switch t.Bits {
+		case 8:
+			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))
+			}
+		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))
+			}
+		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))
+			}
+		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))
+			}
+		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))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *intType:
 		lf := l.asInt();
 		rf := r.asInt();
-		a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); if r == 0 { t.Abort(DivByZeroError{}) } return l % r }
+		switch t.Bits {
+		case 8:
+			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))
+			}
+		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))
+			}
+		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))
+			}
+		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))
+			}
+		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))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
@@ -413,15 +903,91 @@ func (a *expr) genBinOpRem(l, r *expr) {
 }
 
 func (a *expr) genBinOpAnd(l, r *expr) {
-	switch l.t.lit().(type) {
+	switch t := l.t.lit().(type) {
 	case *uintType:
 		lf := l.asUint();
 		rf := r.asUint();
-		a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l & r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				ret = l & r;
+				return uint64(uint(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *intType:
 		lf := l.asInt();
 		rf := r.asInt();
-		a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l & r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				ret = l & r;
+				return int64(int(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
@@ -433,15 +999,91 @@ func (a *expr) genBinOpAnd(l, r *expr) {
 }
 
 func (a *expr) genBinOpOr(l, r *expr) {
-	switch l.t.lit().(type) {
+	switch t := l.t.lit().(type) {
 	case *uintType:
 		lf := l.asUint();
 		rf := r.asUint();
-		a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l | r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				ret = l | r;
+				return uint64(uint(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *intType:
 		lf := l.asInt();
 		rf := r.asInt();
-		a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l | r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				ret = l | r;
+				return int64(int(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
@@ -453,15 +1095,91 @@ func (a *expr) genBinOpOr(l, r *expr) {
 }
 
 func (a *expr) genBinOpXor(l, r *expr) {
-	switch l.t.lit().(type) {
+	switch t := l.t.lit().(type) {
 	case *uintType:
 		lf := l.asUint();
 		rf := r.asUint();
-		a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l ^ r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				ret = l ^ r;
+				return uint64(uint(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *intType:
 		lf := l.asInt();
 		rf := r.asInt();
-		a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l ^ r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				ret = l ^ r;
+				return int64(int(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
@@ -473,15 +1191,91 @@ func (a *expr) genBinOpXor(l, r *expr) {
 }
 
 func (a *expr) genBinOpAndNot(l, r *expr) {
-	switch l.t.lit().(type) {
+	switch t := l.t.lit().(type) {
 	case *uintType:
 		lf := l.asUint();
 		rf := r.asUint();
-		a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l &^ r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				ret = l &^ r;
+				return uint64(uint(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *intType:
 		lf := l.asInt();
 		rf := r.asInt();
-		a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l &^ r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				ret = l &^ r;
+				return int64(int(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
@@ -493,45 +1287,203 @@ func (a *expr) genBinOpAndNot(l, r *expr) {
 }
 
 func (a *expr) genBinOpShl(l, r *expr) {
-	switch l.t.lit().(type) {
+	switch t := l.t.lit().(type) {
 	case *uintType:
 		lf := l.asUint();
 		rf := r.asUint();
-		a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l << r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				ret = l << r;
+				return uint64(uint(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *intType:
 		lf := l.asInt();
 		rf := r.asUint();
-		a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l << r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				ret = l << r;
+				return int64(int(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
 }
 
 func (a *expr) genBinOpShr(l, r *expr) {
-	switch l.t.lit().(type) {
+	switch t := l.t.lit().(type) {
 	case *uintType:
 		lf := l.asUint();
 		rf := r.asUint();
-		a.eval = func(t *Thread) uint64 { l, r := lf(t), rf(t); return l >> r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) uint64 {
+				l, r := lf(t), rf(t);
+				var ret uint64;
+				ret = l >> r;
+				return uint64(uint(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	case *intType:
 		lf := l.asInt();
 		rf := r.asUint();
-		a.eval = func(t *Thread) int64 { l, r := lf(t), rf(t); return l >> r }
+		switch t.Bits {
+		case 8:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 32:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				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))
+			}
+		case 0:
+			a.eval = func(t *Thread) int64 {
+				l, r := lf(t), rf(t);
+				var ret int64;
+				ret = l >> r;
+				return int64(int(ret))
+			}
+		default:
+			log.Crashf("unexpected size %d in type %v at %v", t.Bits, t, a.pos);
+		}
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
 }
 
 func (a *expr) genBinOpLss(l, r *expr) {
-	switch l.t.lit().(type) {
+	switch t := l.t.lit().(type) {
 	case *uintType:
 		lf := l.asUint();
 		rf := r.asUint();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l < r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			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 }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l < r
+		}
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
@@ -540,7 +1492,10 @@ func (a *expr) genBinOpLss(l, r *expr) {
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l < r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l < r
+		}
 	case *idealFloatType:
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
@@ -549,22 +1504,31 @@ func (a *expr) genBinOpLss(l, r *expr) {
 	case *stringType:
 		lf := l.asString();
 		rf := r.asString();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l < r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l < r
+		}
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
 }
 
 func (a *expr) genBinOpGtr(l, r *expr) {
-	switch l.t.lit().(type) {
+	switch t := l.t.lit().(type) {
 	case *uintType:
 		lf := l.asUint();
 		rf := r.asUint();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l > r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			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 }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l > r
+		}
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
@@ -573,7 +1537,10 @@ func (a *expr) genBinOpGtr(l, r *expr) {
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l > r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l > r
+		}
 	case *idealFloatType:
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
@@ -582,22 +1549,31 @@ func (a *expr) genBinOpGtr(l, r *expr) {
 	case *stringType:
 		lf := l.asString();
 		rf := r.asString();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l > r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l > r
+		}
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
 }
 
 func (a *expr) genBinOpLeq(l, r *expr) {
-	switch l.t.lit().(type) {
+	switch t := l.t.lit().(type) {
 	case *uintType:
 		lf := l.asUint();
 		rf := r.asUint();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l <= r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			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 }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l <= r
+		}
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
@@ -606,7 +1582,10 @@ func (a *expr) genBinOpLeq(l, r *expr) {
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l <= r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l <= r
+		}
 	case *idealFloatType:
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
@@ -615,22 +1594,31 @@ func (a *expr) genBinOpLeq(l, r *expr) {
 	case *stringType:
 		lf := l.asString();
 		rf := r.asString();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l <= r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l <= r
+		}
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
 }
 
 func (a *expr) genBinOpGeq(l, r *expr) {
-	switch l.t.lit().(type) {
+	switch t := l.t.lit().(type) {
 	case *uintType:
 		lf := l.asUint();
 		rf := r.asUint();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l >= r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			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 }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l >= r
+		}
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
@@ -639,7 +1627,10 @@ func (a *expr) genBinOpGeq(l, r *expr) {
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l >= r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l >= r
+		}
 	case *idealFloatType:
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
@@ -648,26 +1639,38 @@ func (a *expr) genBinOpGeq(l, r *expr) {
 	case *stringType:
 		lf := l.asString();
 		rf := r.asString();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l >= r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l >= r
+		}
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
 }
 
 func (a *expr) genBinOpEql(l, r *expr) {
-	switch l.t.lit().(type) {
+	switch t := l.t.lit().(type) {
 	case *boolType:
 		lf := l.asBool();
 		rf := r.asBool();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l == r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			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 }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			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 }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l == r
+		}
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
@@ -676,7 +1679,10 @@ func (a *expr) genBinOpEql(l, r *expr) {
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l == r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l == r
+		}
 	case *idealFloatType:
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
@@ -685,38 +1691,59 @@ func (a *expr) genBinOpEql(l, r *expr) {
 	case *stringType:
 		lf := l.asString();
 		rf := r.asString();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l == r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			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 }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			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 }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			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 }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l == r
+		}
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}
 }
 
 func (a *expr) genBinOpNeq(l, r *expr) {
-	switch l.t.lit().(type) {
+	switch t := l.t.lit().(type) {
 	case *boolType:
 		lf := l.asBool();
 		rf := r.asBool();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l != r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			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 }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			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 }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l != r
+		}
 	case *idealIntType:
 		l := l.asIdealInt()();
 		r := r.asIdealInt()();
@@ -725,7 +1752,10 @@ func (a *expr) genBinOpNeq(l, r *expr) {
 	case *floatType:
 		lf := l.asFloat();
 		rf := r.asFloat();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l != r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l != r
+		}
 	case *idealFloatType:
 		l := l.asIdealFloat()();
 		r := r.asIdealFloat()();
@@ -734,19 +1764,31 @@ func (a *expr) genBinOpNeq(l, r *expr) {
 	case *stringType:
 		lf := l.asString();
 		rf := r.asString();
-		a.eval = func(t *Thread) bool { l, r := lf(t), rf(t); return l != r }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			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 }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			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 }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			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 }
+		a.eval = func(t *Thread) bool {
+			l, r := lf(t), rf(t);
+			return l != r
+		}
 	default:
 		log.Crashf("unexpected type %v at %v", l.t, a.pos);
 	}