diff --git a/arm/armspec/code.go b/arm/armspec/code.go
deleted file mode 100644
index 5269d21..0000000
--- a/arm/armspec/code.go
+++ /dev/null
@@ -1,985 +0,0 @@
-// Copyright 2014 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"reflect"
-	"strconv"
-	"strings"
-)
-
-var errSeeOther = fmt.Errorf("see other")
-var errStop = fmt.Errorf("stop")
-var errUndefined = fmt.Errorf("undefined")
-
-type StmtOp int
-
-const (
-	_      StmtOp = iota
-	Assign        // 1
-	Return
-	Undefined
-	Unpredictable
-	See
-	ImplDefined
-	SubarchDefined
-	If
-	Repeat
-	While // 10
-	For
-	Case
-	Enum
-	Block
-	StmtExpr
-	Fndef
-	Assert
-)
-
-type Stmt struct {
-	Op      StmtOp
-	X, Y, Z *Expr
-	List    []*Expr
-	Text    string
-	Body    *Stmt
-	Else    *Stmt
-	When    []*When
-	ElseIf  []*ElseIf
-	Block   []*Stmt
-	Type    *Type
-}
-
-type When struct {
-	Cond []*Expr
-	Body *Stmt
-}
-
-type ElseIf struct {
-	Cond *Expr
-	Body *Stmt
-}
-
-type ExprOp int
-
-const (
-	_     ExprOp = iota
-	Blank        // 1
-	Const
-	Name
-	Decl
-	Unknown
-	Call
-	ExprTuple
-	Eq
-	NotEq
-	LtEq // 10
-	Lt
-	GtEq
-	Gt
-	BitIndex
-	IfElse
-	Not
-	AndAnd
-	OrOr
-	Eor
-	Colon // 20
-	And
-	Or
-	Plus
-	Minus
-	Add
-	Sub
-	Mul
-	Div
-	BigDIV
-	BigMOD // 30
-	BigAND
-	BigOR
-	BigEOR
-	TwoPow
-	Lsh
-	Rsh
-	Index
-	Dot
-)
-
-type Expr struct {
-	Op      ExprOp
-	Text    string
-	X, Y, Z *Expr
-	List    []*Expr
-	Type    *Type
-}
-
-type TypeOp int
-
-const (
-	_ TypeOp = iota
-	BoolType
-	BitType
-	IntegerType
-	NamedType
-	TupleType
-)
-
-type Type struct {
-	Op   TypeOp
-	List []*Type
-	N    int
-	NX   *Expr
-	Text string
-}
-
-type Exec struct {
-	Vars map[string]Value
-}
-
-type Inconsistent struct {
-}
-
-func (Inconsistent) String() string {
-	return "INCONSISTENT"
-}
-
-type Bits struct {
-	N        int
-	Val      uint32
-	DontCare uint32
-}
-
-func (b Bits) String() string {
-	var buf bytes.Buffer
-	fmt.Fprintf(&buf, "`")
-	for i := b.N - 1; i >= 0; i-- {
-		if (b.DontCare>>uint(i))&1 != 0 {
-			fmt.Fprintf(&buf, "x")
-		} else if (b.Val>>uint(i))&1 != 0 {
-			fmt.Fprintf(&buf, "1")
-		} else {
-			fmt.Fprintf(&buf, "0")
-		}
-	}
-	fmt.Fprintf(&buf, "'")
-	return buf.String()
-}
-
-func (b Bits) Eq(v Value) bool {
-	c := v.(Bits)
-	if b.N != c.N {
-		panic(fmt.Errorf("compare of mismatched bit lengths %v and %v", b, c))
-	}
-	return b.Val&^c.DontCare == c.Val
-}
-
-func (b Bits) Lt(v Value) bool {
-	panic("less than on bits")
-}
-
-func (b Bits) Gt(v Value) bool {
-	panic("greater than on bits")
-}
-
-func isValid(inst *Inst, w uint32) bool {
-	var ctxt Exec
-	ctxt.Vars = make(map[string]Value)
-	off := 0
-	for _, b := range strings.Split(inst.Bits, "|") {
-		wid := 1
-		if i := strings.Index(b, ":"); i >= 0 {
-			wid, _ = strconv.Atoi(b[i+1:])
-			b = b[:i]
-		}
-		switch b {
-		case "1", "(1)":
-			if (w>>uint(31-off))&1 != 1 {
-				return false
-			}
-		case "0", "(0)":
-			if (w>>uint(31-off))&1 != 0 {
-				return false
-			}
-		default:
-			bits := Bits{N: wid, Val: (w >> uint(32-off-wid)) & (1<<uint(wid) - 1)}
-			//	fmt.Print(b, " ", bits)
-			if old, ok := ctxt.Vars[b]; ok && old != bits {
-				ctxt.Define(b, Inconsistent{})
-			}
-			ctxt.Define(b, bits)
-		}
-		off += wid
-	}
-	//	fmt.Println()
-
-	for _, stmt := range inst.Prog {
-		err := ctxt.stmt(stmt)
-		if err != nil {
-			if err == errSeeOther || err == errUndefined {
-				return false
-			}
-			if err == errStop {
-				break
-			}
-			panic(err)
-		}
-	}
-	return true
-}
-
-func (ctxt *Exec) Define(name string, value Value) {
-	ctxt.Vars[name] = value
-}
-
-func (ctxt *Exec) Assign(name string, value Value) error {
-	ctxt.Vars[name] = value
-	return nil
-}
-
-/*
-
-var global = map[string]Value{
-	"ConditionPassed": _ConditionPassed,
-	"UInt": _UInt,
-	"SInt": _SInt,
-}
-
-type Defn struct {
-	Name string
-	Value Value
-	Next *Defn
-}
-
-func (ctxt *Exec) Assign(name string, value Value) error {
-	for d := ctxt.Scope; d != nil; d = d.Next {
-		if d.Name == name {
-			d.Value = value
-			return nil
-		}
-	}
-	ctxt.Define(name, value)
-	return nil
-}
-
-func _ConditionPassed(ctxt *Exec, args []Value) (Value, error) {
-	return Bool(true), nil
-}
-*/
-
-type Int int64
-
-func (x Int) String() string {
-	return fmt.Sprint(int64(x))
-}
-
-func (x Int) Eq(y Value) bool { return x == y }
-func (x Int) Lt(y Value) bool { return x < y.(Int) }
-func (x Int) Gt(y Value) bool { return x > y.(Int) }
-
-func (x Int) Add(y Value) Value { return x + y.(Int) }
-func (x Int) Sub(y Value) Value { return x - y.(Int) }
-func (x Int) Mul(y Value) Value { return x * y.(Int) }
-
-func (x Int) Lsh(y Value) Value { return x << uint(y.(Int)) }
-func (x Int) Rsh(y Value) Value { return x >> uint(y.(Int)) }
-func (x Int) DIV(y Value) Value { return x / y.(Int) }
-
-func _UInt(_ *Exec, args []Value) (Value, error) {
-	if len(args) != 1 {
-		return nil, fmt.Errorf("UInt takes a single argument")
-	}
-	b, ok := args[0].(Bits)
-	if !ok {
-		return nil, fmt.Errorf("UInt takes a Bits, not %T", args[0])
-	}
-	if b.N > 63 {
-		return nil, fmt.Errorf("UInt cannot handle %d-bit Bits", b.N)
-	}
-	return Int(b.Val), nil
-}
-
-func _SInt(_ *Exec, args []Value) (Value, error) {
-	if len(args) != 1 {
-		return nil, fmt.Errorf("SInt takes a single argument")
-	}
-	b, ok := args[0].(Bits)
-	if !ok {
-		return nil, fmt.Errorf("SInt takes a Bits, not %T", args[0])
-	}
-	if b.N > 64 {
-		return nil, fmt.Errorf("SInt cannot handle %d-bit Bits", b.N)
-	}
-	return Int(int64(b.Val) << uint(64-b.N) >> uint(64-b.N)), nil
-}
-
-/*
-
-func (ctxt *Exec) Run(prog []*Stmt) error {
-	for _, stmt := range prog {
-		if err := ctxt.stmt(stmt); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-*/
-
-func (ctxt *Exec) stmt(stmt *Stmt) error {
-	switch stmt.Op {
-	case If:
-		v, err := toBool(ctxt.expr(stmt.X))
-		if err != nil {
-			return err
-		}
-		if v {
-			return ctxt.stmt(stmt.Body)
-		}
-		for _, elseif := range stmt.ElseIf {
-			v, err := toBool(ctxt.expr(elseif.Cond))
-			if err != nil {
-				return err
-			}
-			if v {
-				return ctxt.stmt(elseif.Body)
-			}
-		}
-		if stmt.Else == nil {
-			return nil
-		}
-		return ctxt.stmt(stmt.Else)
-
-	case Case:
-		v, err := ctxt.expr(stmt.X)
-		if err != nil {
-			return err
-		}
-		vv, ok := v.(interface {
-			Eq(Value) bool
-		})
-		if !ok {
-			return fmt.Errorf("use of uncomparable value %T(%v) in case statement", v, v)
-		}
-		for _, when := range stmt.When {
-			for _, cond := range when.Cond {
-				w, err := ctxt.expr(cond)
-				if err != nil {
-					return err
-				}
-				if reflect.TypeOf(v) != reflect.TypeOf(w) {
-					return fmt.Errorf("mistyped comparison of %T(%v) and %T(%v) in case statement", v, v, w, w)
-				}
-				if vv.Eq(w) {
-					return ctxt.stmt(when.Body)
-				}
-			}
-		}
-		if stmt.Else == nil {
-			return nil
-		}
-		return ctxt.stmt(stmt.Else)
-
-	case Block:
-		for _, x := range stmt.Block {
-			if err := ctxt.stmt(x); err != nil {
-				return err
-			}
-		}
-		return nil
-
-	case See:
-		return errSeeOther
-
-	case Undefined:
-		return errUndefined
-
-	case Unpredictable, ImplDefined, SubarchDefined:
-		return errStop
-
-	case StmtExpr:
-		_, err := ctxt.expr(stmt.X)
-		return err
-
-	case Assign:
-		v, err := ctxt.expr(stmt.Y)
-		if err != nil {
-			return err
-		}
-		if stmt.X.Op == ExprTuple {
-			vv, ok := v.(Tuple)
-			if !ok {
-				return fmt.Errorf("assignment of non-tuple %T to tuple", v)
-			}
-			if len(stmt.X.List) != len(vv) {
-				return fmt.Errorf("%d = %d in tuple assignment", len(stmt.X.List), len(vv))
-			}
-			for i, x := range stmt.X.List {
-				if x.Op == Blank {
-					continue
-				}
-				if x.Op != Name {
-					return fmt.Errorf("cannot assign to expr op %d", x.Op)
-				}
-				if err := ctxt.Assign(x.Text, vv[i]); err != nil {
-					return err
-				}
-			}
-			return nil
-		}
-		x := stmt.X
-		if x.Op != Name {
-			return fmt.Errorf("cannot assign to expr op %d", x.Op)
-		}
-		return ctxt.Assign(x.Text, v)
-	}
-	return fmt.Errorf("unknown stmt op %d", stmt.Op)
-}
-
-func toBool(v Value, err error) (b Bool, xerr error) {
-	if err != nil {
-		return false, err
-	}
-	switch v := v.(type) {
-	case Bool:
-		return v, nil
-	default:
-		return false, fmt.Errorf("value of type %T used as bool", v)
-	}
-}
-
-type Value interface {
-	String() string
-}
-
-type Bool bool
-
-func (b Bool) Eq(v Value) bool { return b == v }
-
-func (b Bool) Not() Value { return !b }
-
-func (b Bool) String() string {
-	if b {
-		return "TRUE"
-	}
-	return "FALSE"
-}
-
-type Tuple []Value
-
-func (t Tuple) String() string {
-	var buf bytes.Buffer
-	fmt.Fprintf(&buf, "(")
-	for i, v := range t {
-		if i > 0 {
-			fmt.Fprintf(&buf, ", ")
-		}
-		fmt.Fprintf(&buf, v.String())
-	}
-	fmt.Fprintf(&buf, ")")
-	return buf.String()
-}
-
-func (ctxt *Exec) expr(x *Expr) (v Value, err error) {
-	switch x.Op {
-	case Call:
-		fn, err := ctxt.name(x.Text)
-		if err != nil {
-			return nil, err
-		}
-		var list []Value
-		for _, y := range x.List {
-			v, err := ctxt.expr(y)
-			if err != nil {
-				return nil, err
-			}
-			list = append(list, v)
-		}
-		return ctxt.call(x.Text, fn, list)
-
-	case ExprTuple:
-		var list []Value
-		for _, y := range x.List {
-			v, err := ctxt.expr(y)
-			if err != nil {
-				return nil, err
-			}
-			list = append(list, v)
-		}
-		if len(list) == 1 {
-			return list[0], nil
-		}
-		return Tuple(list), nil
-
-	case AndAnd:
-		v, err := toBool(ctxt.expr(x.X))
-		if err != nil {
-			return nil, err
-		}
-		if !v {
-			return v, nil
-		}
-		return ctxt.expr(x.Y)
-
-	case OrOr:
-		v, err := toBool(ctxt.expr(x.X))
-		if err != nil {
-			return nil, err
-		}
-		if v {
-			return v, nil
-		}
-		return ctxt.expr(x.Y)
-
-	case Colon:
-		v, err := ctxt.expr(x.X)
-		if err != nil {
-			return nil, err
-		}
-		y, err := ctxt.expr(x.Y)
-		if err != nil {
-			return nil, err
-		}
-		xb, ok := v.(Bits)
-		yb, ok2 := y.(Bits)
-		if !ok || !ok2 {
-			return nil, fmt.Errorf("colon operator requires bit strings")
-		}
-		b := xb
-		b.N += yb.N
-		b.Val <<= uint(yb.N)
-		b.DontCare <<= yb.DontCare
-		return b, nil
-
-	case Name:
-		return ctxt.name(x.Text)
-
-	case Const:
-		if (strings.HasPrefix(x.Text, "‘") || strings.HasPrefix(x.Text, "’")) && strings.HasSuffix(x.Text, "’") {
-			text := x.Text[len("‘") : len(x.Text)-len("’")]
-			var b Bits
-			b.N = len(text)
-			for _, c := range text {
-				b.Val <<= 1
-				b.DontCare <<= 1
-				if c == '1' {
-					b.Val |= 1
-				}
-				if c == 'x' {
-					b.DontCare |= 1
-				}
-			}
-			return b, nil
-		}
-		n, err := strconv.Atoi(x.Text)
-		if err == nil {
-			return Int(n), nil
-		}
-		println("const", x.Text)
-
-	case Not:
-		l, err := ctxt.expr(x.X)
-		if err != nil {
-			return nil, err
-		}
-		switch x.Op {
-		case Not:
-			ll, ok := l.(interface {
-				Not() Value
-			})
-			if !ok {
-				return nil, fmt.Errorf("type %T does not support !", l)
-			}
-			return ll.Not(), nil
-		}
-
-	case Eq, NotEq, Lt, LtEq, Gt, GtEq, Add, Sub, Mul, Lsh, Rsh, BigDIV:
-		l, err := ctxt.expr(x.X)
-		if err != nil {
-			return nil, err
-		}
-		r, err := ctxt.expr(x.Y)
-		if err != nil {
-			return nil, err
-		}
-		tl := reflect.TypeOf(l)
-		tr := reflect.TypeOf(r)
-		if tl != tr {
-			return nil, fmt.Errorf("arithmetic (expr op %d) of %T(%v) with %T(%v)", x.Op, l, l, r, r)
-		}
-		switch x.Op {
-		case Eq:
-			ll, ok := l.(interface {
-				Eq(Value) bool
-			})
-			if !ok {
-				return nil, fmt.Errorf("type %T does not support ==", l)
-			}
-			return Bool(ll.Eq(r)), nil
-		case NotEq:
-			ll, ok := l.(interface {
-				Eq(Value) bool
-			})
-			if !ok {
-				return nil, fmt.Errorf("type %T does not support !=", l)
-			}
-			return Bool(!ll.Eq(r)), nil
-		case Lt:
-			ll, ok := l.(interface {
-				Lt(Value) bool
-			})
-			if !ok {
-				return nil, fmt.Errorf("type %T does not support <", l)
-			}
-			return Bool(ll.Lt(r)), nil
-		case GtEq:
-			ll, ok := l.(interface {
-				Lt(Value) bool
-			})
-			if !ok {
-				return nil, fmt.Errorf("type %T does not support >=", l)
-			}
-			return Bool(!ll.Lt(r)), nil
-		case Gt:
-			ll, ok := l.(interface {
-				Gt(Value) bool
-			})
-			if !ok {
-				return nil, fmt.Errorf("type %T does not support >", l)
-			}
-			return Bool(ll.Gt(r)), nil
-		case LtEq:
-			ll, ok := l.(interface {
-				Gt(Value) bool
-			})
-			if !ok {
-				return nil, fmt.Errorf("type %T does not support <=", l)
-			}
-			return Bool(!ll.Gt(r)), nil
-		case Add:
-			ll, ok := l.(interface {
-				Add(Value) Value
-			})
-			if !ok {
-				return nil, fmt.Errorf("type %T does not support +", l)
-			}
-			return ll.Add(r), nil
-		case Sub:
-			ll, ok := l.(interface {
-				Sub(Value) Value
-			})
-			if !ok {
-				return nil, fmt.Errorf("type %T does not support -", l)
-			}
-			return ll.Sub(r), nil
-		case Mul:
-			ll, ok := l.(interface {
-				Mul(Value) Value
-			})
-			if !ok {
-				return nil, fmt.Errorf("type %T does not support *", l)
-			}
-			return ll.Mul(r), nil
-		case Lsh:
-			ll, ok := l.(interface {
-				Lsh(Value) Value
-			})
-			if !ok {
-				return nil, fmt.Errorf("type %T does not support <<", l)
-			}
-			return ll.Lsh(r), nil
-		case Rsh:
-			ll, ok := l.(interface {
-				Rsh(Value) Value
-			})
-			if !ok {
-				return nil, fmt.Errorf("type %T does not support >>", l)
-			}
-			return ll.Rsh(r), nil
-		case BigDIV:
-			ll, ok := l.(interface {
-				DIV(Value) Value
-			})
-			if !ok {
-				return nil, fmt.Errorf("type %T does not support DIV", l)
-			}
-			return ll.DIV(r), nil
-		}
-
-	case BitIndex:
-		l, err := ctxt.expr(x.X)
-		if err != nil {
-			return nil, err
-		}
-		b, ok := l.(Bits)
-		if !ok {
-			return nil, fmt.Errorf("bit index operator requires bitstring, not %T(%v)", l, l)
-		}
-		out := Bits{}
-		for _, ix := range x.List {
-			if ix.Op == Colon {
-				r1, err := ctxt.expr(ix.X)
-				if err != nil {
-					return nil, err
-				}
-				r2, err := ctxt.expr(ix.Y)
-				if err != nil {
-					return nil, err
-				}
-				i1, ok := r1.(Int)
-				i2, ok2 := r2.(Int)
-				if !ok || !ok2 {
-					return nil, fmt.Errorf("bit indexes must be int")
-				}
-				if i1 <= i2 {
-					return nil, fmt.Errorf("inverted bit indexes %d:%d", i1, i2)
-				}
-				w := int(i1 + 1 - i2)
-				out.N += w
-				out.Val <<= uint(w)
-				out.DontCare <<= uint(w)
-				out.Val |= (b.Val >> uint(i2)) & (1<<uint(w) - 1)
-				out.DontCare |= (b.DontCare >> uint(i2)) & (1<<uint(w) - 1)
-			} else {
-				r, err := ctxt.expr(ix)
-				if err != nil {
-					return nil, err
-				}
-				i, ok := r.(Int)
-				if !ok {
-					return nil, fmt.Errorf("bit index operator index must be int")
-				}
-				out.N++
-				out.Val <<= 1
-				out.DontCare <<= 1
-				out.Val |= (b.Val >> uint(i)) & 1
-			}
-		}
-		return out, nil
-
-	case IfElse:
-		v, err := toBool(ctxt.expr(x.X))
-		if err != nil {
-			return nil, err
-		}
-		if v {
-			return ctxt.expr(x.Y)
-		}
-		return ctxt.expr(x.Z)
-	}
-	return nil, fmt.Errorf("unknown expr op %d", x.Op)
-}
-
-type Func struct {
-	Name string
-	F    func(*Exec, []Value) (Value, error)
-}
-
-func (f Func) String() string {
-	return f.Name
-}
-
-func (ctxt *Exec) call(name string, fn Value, args []Value) (Value, error) {
-	switch fn := fn.(type) {
-	case Func:
-		return fn.F(ctxt, args)
-	}
-	return nil, fmt.Errorf("cannot call %s of type %T", name, fn)
-}
-
-var global = map[string]Value{
-	"UInt":           Func{"UInt", _UInt},
-	"DecodeImmShift": Func{"DecodeImmShift", _DecodeImmShift},
-	"ArchVersion":    Func{"ArchVersion", _ArchVersion},
-	"ZeroExtend":     Func{"ZeroExtend", _ZeroExtend},
-	"ARMExpandImm":   Func{"ARMExpandImm", _ARMExpandImm},
-	"Zeros":          Func{"Zeros", _Zeros},
-	"TRUE":           Bool(true),
-	"FALSE":          Bool(false),
-	"BitCount":       Func{"BitCount", _BitCount},
-	"Consistent":     Func{"Consistent", _Consistent},
-}
-
-func _Consistent(ctxt *Exec, args []Value) (Value, error) {
-	if len(args) != 1 {
-		return nil, fmt.Errorf("BitCount requires one argument")
-	}
-	_, inconsistent := args[0].(Inconsistent)
-	return Bool(!inconsistent), nil
-}
-
-func _BitCount(ctxt *Exec, args []Value) (Value, error) {
-	if len(args) != 1 {
-		return nil, fmt.Errorf("BitCount requires one argument")
-	}
-	b, ok1 := args[0].(Bits)
-	if !ok1 {
-		return nil, fmt.Errorf("BitCount requires bitstring argument")
-	}
-
-	n := 0
-	for i := 0; i < b.N; i++ {
-		if b.Val&(1<<uint(i)) != 0 {
-			n++
-		}
-	}
-	return Int(n), nil
-}
-
-func _ArchVersion(ctxt *Exec, args []Value) (Value, error) {
-	return Int(7), nil
-}
-
-func _ZeroExtend(ctxt *Exec, args []Value) (Value, error) {
-	if len(args) != 2 {
-		return nil, fmt.Errorf("ZeroExtend requires two arguments")
-	}
-	b, ok := args[0].(Bits)
-	n, ok2 := args[1].(Int)
-	if !ok || !ok2 {
-		return nil, fmt.Errorf("DecodeImmShift requires bitstring, int arguments")
-	}
-	b.N = int(n)
-	return b, nil
-}
-
-func _DecodeImmShift(ctxt *Exec, args []Value) (Value, error) {
-	if len(args) != 2 {
-		return nil, fmt.Errorf("DecodeImmShift requires two arguments")
-	}
-	b1, ok1 := args[0].(Bits)
-	b2, ok2 := args[1].(Bits)
-	if !ok1 || !ok2 {
-		return nil, fmt.Errorf("DecodeImmShift requires bitstring arguments")
-	}
-	_ = b1
-	_ = b2
-	// TODO
-	return Tuple{Int(0), Int(0)}, nil
-}
-
-func _ARMExpandImm(ctxt *Exec, args []Value) (Value, error) {
-	if len(args) != 1 {
-		return nil, fmt.Errorf("ARMExpandImm requires one argument")
-	}
-	b, ok1 := args[0].(Bits)
-	if !ok1 || b.N != 12 {
-		return nil, fmt.Errorf("ARMExpandImm requires 12-bit bitstring argument")
-	}
-	v := uint32(b.Val & 0xFF)
-	rot := uint(2 * ((b.Val >> 8) & 0xF))
-	v = v>>rot | v<<(32-rot)
-	return Bits{N: 32, Val: v}, nil
-}
-
-func _Zeros(ctxt *Exec, args []Value) (Value, error) {
-	if len(args) != 1 {
-		return nil, fmt.Errorf("Zeros requires one argument")
-	}
-	n, ok := args[0].(Int)
-	if !ok {
-		return nil, fmt.Errorf("Zeros requires int argument")
-	}
-	return Bits{N: int(n)}, nil
-}
-
-type Symbol string
-
-func (s Symbol) String() string { return string(s) }
-
-func (ctxt *Exec) name(name string) (v Value, err error) {
-	v, ok := ctxt.Vars[name]
-	if ok {
-		return v, nil
-	}
-	v, ok = global[name]
-	if ok {
-		return v, nil
-	}
-	return Symbol(name), nil
-	return nil, fmt.Errorf("unknown name %s", name)
-}
-
-/*
-func pseudoExec(base uint32, enc *Enc) {
-	var ctxt Exec
-	ctxt.Define("EncodingSpecificOperations", func(ctxt *Exec, args []Value) (Value, error) {
-		return nil, ctxt.Run(enc.Prog)
-	})
-
-	var n uint
-	for _, f := range enc.Fields {
-		switch f {
-		case "0", "1", "(0)", "(1)":
-			n++
-		default:
-			wid := size[f]
-			if wid == 0 {
-				panic("missing width for " + f)
-			}
-			ctxt.Define(f, Bits{N: wid, Val: (base>>(31-n))&(1<<uint(wid)-1)})
-			n += uint(wid)
-		}
-	}
-
-	if err := ctxt.Run(enc.Inst.Prog); err != nil {
-		log.Printf("%#x: %v", base, err)
-	}
-}
-
-func loadLibrary(data []byte) {
-	prog := parse("speclib.txt", string(data))
-	for _, stmt := range prog {
-		switch stmt.Op {
-		default:
-			log.Fatalf("unexpected statement in speclib.txt: %d", stmt.Op)
-		case Fndef:
-			global[stmt.Text] = funcImpl(stmt)
-		case Enum:
-			// TODO
-		}
-	}
-}
-
-func funcImpl(stmt *Stmt) func(*Exec, []Value) (Value, error) {
-	return func(ctxt *Exec, args []Value) (Value, error) {
-		ctxt1 := *ctxt
-		if len(args) != len(stmt.List) {
-			return nil, fmt.Errorf("calling %s: have %d arguments, want %d", stmt.Text, len(args), len(stmt.List))
-		}
-		for i, decl := range stmt.List {
-			v, err := convert(args[i], decl.Type)
-			if err != nil {
-				return nil, fmt.Errorf("calling %s: %v", stmt.Text, err)
-			}
-			ctxt1.Define(decl.Text, v)
-		}
-		err := ctxt1.stmt(stmt.Body)
-		if err != nil {
-			return nil, err
-		}
-		if ctxt1.ret == nil && stmt.Type != nil {
-			return nil, fmt.Errorf("calling %s: function body missing return", stmt.Text)
-		}
-		if ctxt1.ret != nil && stmt.Type == nil {
-			return nil, fmt.Errorf("calling %s: unexpected return value from function with no result", stmt.Text)
-		}
-		return ctxt1.ret, nil
-	}
-}
-
-func convert(v Value, typ *Type) (Value, error) {
-	switch typ.Op {
-	case BoolType:
-		if v, ok := v.(Bool); ok {
-			return v, nil
-		}
-	case BitType:
-		if v, ok := v.(Bits); ok && v.N == typ.N {
-			return v, nil
-		}
-	}
-	return nil, fmt.Errorf("cannot convert %s to type %v", v, typ)
-}
-
-*/
diff --git a/arm/armspec/pseudo.go b/arm/armspec/pseudo.go
deleted file mode 100644
index 20bcec8..0000000
--- a/arm/armspec/pseudo.go
+++ /dev/null
@@ -1,264 +0,0 @@
-// Copyright 2014 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"fmt"
-	"os"
-	"regexp"
-	"strings"
-)
-
-type Lexer struct {
-	input  string
-	file   string
-	lineno int
-	sym    string
-	prog   []*Stmt
-}
-
-type Line struct {
-	File   string
-	Lineno int
-}
-
-func (l Line) String() string {
-	return fmt.Sprintf("%s:%d", l.File, l.Lineno)
-}
-
-var nerror int
-
-func (l Line) Errorf(format string, args ...interface{}) {
-	fmt.Printf("%s: %s\n", l, fmt.Sprintf(format, args...))
-	if nerror++; nerror > 20 {
-		fmt.Printf("too many errors\n")
-		os.Exit(1)
-	}
-}
-
-func re(s string) *regexp.Regexp {
-	return regexp.MustCompile(`\A(?:` + s + `)`)
-}
-
-var tokens = []struct {
-	re  *regexp.Regexp
-	val int
-	fn  func(*Lexer, string, *yySymType)
-}{
-	{re(`//[^\n]*`), -1, nil},
-	{re(`/\*(.|\n)*?\*/`), -1, nil},
-	{re(`[ \t\n]+`), -1, nil},
-	{re(`»`), _INDENT, nil},
-	{re(`«`), _UNINDENT, str},
-	{re(`return`), _RETURN, str},
-	{re(`UNDEFINED`), _UNDEFINED, str},
-	{re(`UNPREDICTABLE`), _UNPREDICTABLE, str},
-	{re(`SEE [^;]+`), _SEE, str},
-	{re(`IMPLEMENTATION_DEFINED( [^;]+)?`), _IMPLEMENTATION_DEFINED, str},
-	{re(`SUBARCHITECTURE_DEFINED( [^;]+)?`), _SUBARCHITECTURE_DEFINED, str},
-	{re(`if`), _IF, nil},
-	{re(`then`), _THEN, nil},
-	{re(`repeat`), _REPEAT, nil},
-	{re(`until`), _UNTIL, nil},
-	{re(`while`), _WHILE, nil},
-	{re(`case`), _CASE, nil},
-	{re(`for`), _FOR, nil},
-	{re(`to`), _TO, nil},
-	{re(`do`), _DO, nil},
-	{re(`of`), _OF, nil},
-	{re(`elsif`), _ELSIF, nil},
-	{re(`else`), _ELSE, nil},
-	{re(`otherwise`), _OTHERWISE, nil},
-	{re(`enumeration`), _ENUMERATION, nil},
-	{re(`when`), _WHEN, nil},
-	{re(`UNKNOWN`), _UNKNOWN, nil},
-	{re(`DIV`), _DIV, nil},
-	{re(`MOD`), _MOD, nil},
-	{re(`AND`), _AND, nil},
-	{re(`OR`), _OR, nil},
-	{re(`EOR`), _EOR, nil},
-	{re(`&&`), _ANDAND, nil},
-	{re(`\|\|`), _OROR, nil},
-	{re(`==`), _EQ, nil},
-	{re(`!=`), _NE, nil},
-	{re(` <`), _LT, nil},
-	{re(` ?<=`), _LE, nil},
-	{re(` ?>=`), _GE, nil},
-	{re(` >`), _GT, nil},
-	{re(`{`), '{', nil},
-	{re(`}`), '}', nil},
-	{re(`<`), '<', nil},
-	{re(`>`), '>', nil},
-	{re(`2^`), _TWOPOW, nil},
-	{re(` ?<<`), _LSH, nil},
-	{re(` ?>>`), _RSH, nil},
-	{re(`,`), ',', nil},
-	{re(`:`), ':', nil},
-	{re(`\+`), '+', nil},
-	{re(`\.`), '.', nil},
-	{re(`-`), '-', nil},
-	{re(`|`), '|', nil},
-	{re(`\^`), '^', nil},
-	{re(`\*`), '*', nil},
-	{re(`/`), '/', nil},
-	{re(`%`), '%', nil},
-	{re(`&`), '&', nil},
-	{re(`!`), '!', nil},
-	{re(`;`), ';', nil},
-	{re(`=`), '=', nil},
-	{re(`\(`), '(', nil},
-	{re(`\)`), ')', nil},
-	{re(`\[`), '[', nil},
-	{re(`\]`), ']', nil},
-	{re(`!`), '!', nil},
-	{re(`[0-9]+`), _CONST, str},
-	{re(`[0-9]+\.[0-9]+`), _CONST, str},
-	{re(`0x[0-9A-Fa-f]+`), _CONST, str},
-	{re("[‘’][ 0-9x]+’"), _CONST, strNoSpaces},
-	{re(`bit`), _BIT, str},
-	{re(`bits\(`), _BITS, str1x},
-	{re(`assert`), _ASSERT, str},
-	{re(`integer`), _INTEGER, nil},
-	{re(`boolean`), _BOOLEAN, nil},
-
-	{re(`[A-Za-z_][A-Za-z0-9_]*`), _NAME, str},
-	{re(`[A-Za-z_][A-Za-z0-9_]*\(`), _NAME_PAREN, str1x},
-}
-
-func (lx *Lexer) Lex(yy *yySymType) int {
-	if len(lx.input) == 0 {
-		return _EOF
-	}
-	var (
-		longest    string
-		longestVal int
-		longestFn  func(*Lexer, string, *yySymType)
-	)
-	for _, tok := range tokens {
-		s := tok.re.FindString(lx.input)
-		if len(s) > len(longest) {
-			longest = s
-			longestVal = tok.val
-			longestFn = tok.fn
-		}
-	}
-	if longest == "" {
-		lx.Error(fmt.Sprintf("lexer stuck at %.10q", lx.input))
-		return -1
-	}
-	//println(longest)
-	yy.line = lx.line()
-	if longestFn != nil {
-		lx.sym = longest
-		longestFn(lx, longest, yy)
-	}
-	lx.input = lx.input[len(longest):]
-	lx.lineno += strings.Count(longest, "\n")
-	if longestVal < 0 {
-		// skip
-		return lx.Lex(yy)
-	}
-	return longestVal
-}
-
-func (lx *Lexer) Error(s string) {
-	lx.line().Errorf("%s near %s", s, lx.sym)
-}
-
-func (lx *Lexer) line() Line {
-	return Line{lx.file, lx.lineno}
-}
-
-func nop(*Lexer, string, *yySymType) {
-	// having a function in the table
-	// will make the lexer save the string
-	// for use in error messages.
-	// nothing more to do.
-}
-
-func str(lx *Lexer, s string, yy *yySymType) {
-	yy.str = s
-}
-
-func str1(lx *Lexer, s string, yy *yySymType) {
-	yy.str = s[1:]
-}
-
-func str1x(lx *Lexer, s string, yy *yySymType) {
-	yy.str = s[:len(s)-1]
-}
-
-func strNoSpaces(lx *Lexer, s string, yy *yySymType) {
-	yy.str = strings.Replace(s, " ", "", -1)
-}
-
-func parse(name, text string) []*Stmt {
-	text = markup(text)
-	lx := &Lexer{
-		input:  text,
-		file:   name,
-		lineno: 1,
-	}
-	nerror = 0
-	yyParse(lx)
-	return lx.prog
-}
-
-func markup(text string) string {
-	prefix := ""
-
-	// Fix typos.
-	text = strings.Replace(text, "R[i}", "R[i]", -1)
-	text = strings.Replace(text, "R[n}", "R[n]", -1)
-	text = strings.Replace(text, "(1 << (3-UInt(op)-UInt(size));", "(1 << (3-UInt(op)-UInt(size)));", -1)
-	text = strings.Replace(text, "(D[n+r] AND NOT(D[m+r]);", "(D[n+r] AND NOT(D[m+r]));", -1)
-	text = strings.Replace(text, "(D[d+r] AND NOT(D[m+r]);", "(D[d+r] AND NOT(D[m+r]));", -1)
-	text = strings.Replace(text, "(D[n+r] AND D[d+r]) OR (D[m+r] AND NOT(D[d+r]);", "(D[n+r] AND D[d+r]) OR (D[m+r] AND NOT(D[d+r]));", -1)
-
-	// Add indent, unindent tags.
-	lines := strings.Split(text, "\n")
-	var indent []int
-	for j, line := range lines {
-		if i := strings.Index(line, "//"); i >= 0 {
-			line = line[:i]
-		}
-		if strings.TrimSpace(line) == "" {
-			continue
-		}
-		n := 0
-		for n < len(line) && line[n] == '\t' {
-			n++
-		}
-		if len(indent) == 0 {
-			indent = append(indent, n)
-		}
-		i := indent[len(indent)-1]
-		if i > n {
-			for i > n {
-				line = "«" + line
-				indent = indent[:len(indent)-1]
-				if len(indent) == 0 {
-					i = -1
-				} else {
-					i = indent[len(indent)-1]
-				}
-			}
-			if i == -1 {
-				indent = append(indent, n)
-				i = n
-			}
-		}
-		if i < n {
-			line = "»" + line
-			indent = append(indent, n)
-		}
-		lines[j] = line
-	}
-	n := len(indent) - 1
-	if n < 0 {
-		n = 0
-	}
-	return prefix + strings.Join(lines, "\n") + strings.Repeat("«", n)
-}
diff --git a/arm/armspec/pseudo.y b/arm/armspec/pseudo.y
deleted file mode 100644
index 6d9532f..0000000
--- a/arm/armspec/pseudo.y
+++ /dev/null
@@ -1,553 +0,0 @@
-// Copyright 2014 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-%{
-package main
-
-import (
-	"strconv"
-)
-
-%}
-
-%union {
-	str string
-	line Line
-	stmt *Stmt
-	stmts []*Stmt
-	expr *Expr
-	exprs []*Expr
-	elseifs []*ElseIf
-	when *When
-	whens []*When
-	typ *Type
-	typs []*Type
-}
-
-%token	_ASSERT
-%token	_BITS
-%token	_BIT
-%token	_IF
-%token	_EOF
-%token	_NAME _NAME_PAREN
-%token	_RETURN
-%token	_UNDEFINED
-%token	_UNPREDICTABLE
-%token	_IMPLEMENTATION_DEFINED
-%token	_SUBARCHITECTURE_DEFINED
-%token	_ENUMERATION
-%token	_DO
-%token	_INDENT
-%token	_UNINDENT
-%token	_THEN
-%token	_REPEAT
-%token	_UNTIL
-%token	_WHILE
-%token	_CASE
-%token	_FOR
-%token	_TO
-%token	_OF
-%token	_ELSIF
-%token	_ELSE
-%token	_OTHERWISE
-%token	_WHEN
-%token	_CONST
-%token	_UNKNOWN
-%token	_EQ
-%token	_NE
-%token	_LE
-%token	_GE
-%token	_AND
-%token	_OR
-%token	_EOR
-%token	_ANDAND
-%token	_OROR
-%token	_DIV
-%token	_MOD
-%token	_TWOPOW
-%token	_LSH
-%token	_RSH
-%token	_INTEGER
-%token	_BOOLEAN
-
-%token	<str>	_NAME _NAME_PAREN _CONST
-%token	<str>	_SEE
-
-%left last_resort
-%left '='
-%left ','
-%left _IF
-%left _ANDAND _OROR
-%left	_LT _LE '>' _GE _GT _EQ _NE
-%left ':'
-%left	'+' '-' '|' '^' _OR _EOR
-%left	'*' '/' '%' '&' _LSH _RSH _DIV _MOD _AND
-%left _TWOPOW
-%left '.' '<' '['
-%left	unary
-
-%type	<stmts>	stmt_list simple_stmt_list stmt_list_opt
-%type	<stmt>	stmt simple_stmt block simple_block otherwise enumeration
-%type	<stmt>	else_opt simple_else_opt else_end simple_else_end
-%type	<elseifs>	elsif_list simple_elsif_list
-%type	<when>	when
-%type	<whens>	when_list
-%type	<exprs>	expr_list_opt expr_list expr_minus_list const_list
-%type	<expr>	expr call_expr const
-%type	<typ>	unnamed_type
-
-%%
-
-top:
-	stmt_list_opt _EOF
-	{
-		yylex.(*Lexer).prog = $1
-		return 0
-	}
-
-simple_stmt:
-	expr '=' expr ';'
-	{
-		$$ = &Stmt{Op: Assign, X: $1, Y: $3}
-	}
-|	expr _EQ expr ';'
-	{
-		$$ = &Stmt{Op: Assign, X: $1, Y: $3}
-	}
-|	call_expr ';'
-	{
-		$$ = &Stmt{Op: StmtExpr, X: $1}
-	}
-|	_RETURN expr_list_opt ';'
-	{
-		$$ = &Stmt{Op: Return, List: $2}
-	}
-|	_UNDEFINED ';'
-	{
-		$$ = &Stmt{Op: Undefined}
-	}
-|	_UNPREDICTABLE ';'
-	{
-		$$ = &Stmt{Op: Unpredictable}
-	}
-|	_SEE ';'
-	{
-		$$ = &Stmt{Op: See, Text: $1}
-	}
-|	_IMPLEMENTATION_DEFINED ';'
-	{
-		$$ = &Stmt{Op: ImplDefined}
-	}
-|	_SUBARCHITECTURE_DEFINED ';'
-	{
-		$$ = &Stmt{Op: SubarchDefined}
-	}
-	
-stmt:
-	simple_stmt
-|	unnamed_type _NAME ';'
-	{
-		$$ = &Stmt{Op: StmtExpr, X: &Expr{Op: Decl, Type: $1, Text: $2}}
-	}
-|	_IF expr _THEN block else_opt
-	{
-		$$ = &Stmt{Op: If, X: $2, Body: $4, ElseIf: $<elseifs>5, Else: $5}
-	}
-|	_IF expr _THEN simple_stmt simple_else_opt
-	{
-		$$ = &Stmt{Op: If, X: $2, Body: $4, ElseIf: $<elseifs>5, Else: $5}
-	}
-|	_REPEAT block _UNTIL expr ';'
-	{
-		$$ = &Stmt{Op: Repeat, Body: $2, X: $4}
-	}
-|	_WHILE expr do block
-	{
-		$$ = &Stmt{Op: While, X: $2, Body: $4}
-	}
-|	_FOR expr '=' expr _TO expr do block
-	{
-		$$ = &Stmt{Op: For, X: $2, Y: $4, Z: $6, Body: $8}
-	}
-|	_CASE expr _OF _INDENT when_list otherwise _UNINDENT
-	{
-		$$ = &Stmt{Op: Case, X: $2, When: $5, Else: $6}
-	}
-|	_ASSERT expr ';'
-	{
-		$$ = &Stmt{Op: Assert, X: $2}
-	}
-|	block
-	{
-		$$ = $1
-	}
-|	enumeration
-
-enumeration:
-	_ENUMERATION _NAME '{' expr_list '}' ';'
-	{
-		$$ = &Stmt{Op: Enum, Text: $2, List: $4}
-	}
-
-do:
-|	_DO
-
-block:
-	_INDENT stmt_list _UNINDENT
-	{
-		$$ = &Stmt{Op: Block, Block: $2}
-	}
-
-simple_block:
-	simple_stmt_list
-	{
-		$$ = &Stmt{Op: Block, Block: $1}
-	}
-
-simple_stmt_list:
-	simple_stmt
-	{
-		$$ = []*Stmt{$1}
-	}
-|	simple_stmt_list simple_stmt
-	{
-		$$ = append($1, $2)
-	}
-
-stmt_list:
-	stmt
-	{
-		$$ = []*Stmt{$1}
-	}
-|	stmt_list stmt
-	{
-		$$ = append($1, $2)
-	}
-
-stmt_list_opt:
-	{
-		$$ = nil
-	}
-|	stmt_list
-
-else_opt:
-	elsif_list else_end
-	{
-		$<elseifs>$ = $1
-		$$ = $2
-	}
-
-simple_else_opt:
-	simple_elsif_list simple_else_end
-	{
-		$<elseifs>$ = $1
-		$$ = $2
-	}
-
-elsif_list:
-	{
-		$$ = nil
-	}
-|	elsif_list _ELSIF expr _THEN block
-	{
-		$$ = append($1, &ElseIf{Cond: $3, Body: $5})
-	}
-
-simple_elsif_list:
-	{
-		$$ = nil
-	}
-|	simple_elsif_list _ELSIF expr _THEN simple_stmt
-	{
-		$$ = append($1, &ElseIf{Cond: $3, Body: $5})
-	}
-	
-else_end:
-	{
-		$$ = nil
-	}
-|	_ELSE block
-	{
-		$$ = $2
-	}
-|	_ELSE simple_stmt
-	{
-		$$ = $2
-	}
-
-simple_else_end:
-	{
-		$$ = nil
-	}
-|	_ELSE simple_stmt
-	{
-		$$ = $2
-	}
-
-when_list:
-	{
-		$$ = nil
-	}
-|	when_list when
-	{
-		$$ = append($1, $2)
-	}
-
-when:
-	_WHEN const_list then block
-	{
-		$$ = &When{Cond: $2, Body: $4}
-	}
-|	_WHEN const_list then simple_block
-	{
-		$$ = &When{Cond: $2, Body: $4}
-	}
-
-then:
-|	_THEN
-
-otherwise:
-	{
-		$$ = nil
-	}
-|	_OTHERWISE block
-	{
-		$$ = $2
-	}
-|	_OTHERWISE simple_block
-	{
-		$$ = $2
-	}
-
-expr_list_opt:
-	{
-		$$ = nil
-	}
-|	expr_list
-
-expr_list:
-	expr
-	{
-		$$ = []*Expr{$1}
-	}
-|	expr_list ',' expr
-	{
-		$$ = append($1, $3)
-	}
-
-const_list:
-	const
-	{
-		$$ = []*Expr{$1}
-	}
-|	const_list ',' const
-	{
-		$$ = append($1, $3)
-	}
-
-const:
-	_CONST
-	{
-		$$ = &Expr{Op: Const, Text: $1}
-	}
-|	_NAME
-	{
-		$$ = &Expr{Op: Name, Text: $1}
-	}
-
-expr_minus_list:
-	expr
-	{
-		$$ = []*Expr{$1}
-	}
-|	'-'
-	{
-		$$ = []*Expr{&Expr{Op: Blank}}
-	}
-|	expr_minus_list ',' expr
-	{
-		$$ = append($1, $3)
-	}
-|	expr_minus_list ',' '-'
-	{
-		$$ = append($1, &Expr{Op: Blank})
-	}
-
-expr:
-	_CONST
-	{
-		$$ = &Expr{Op: Const, Text: $1}
-	}
-|	_NAME
-	{
-		$$ = &Expr{Op: Name, Text: $1}
-	}
-|	unnamed_type _NAME
-	{
-		$$ = &Expr{Op: Decl, Type: $1, Text: $2}
-	}
-|	_UNKNOWN
-	{
-		$$ = &Expr{Op: Unknown}
-	}
-|	unnamed_type _UNKNOWN
-	{
-		$$ = &Expr{Op: Unknown, Type: $1}
-	}
-|	call_expr
-|	'(' expr_minus_list ')'
-	{
-		$$ = &Expr{Op: ExprTuple, List: $2}
-	}
-|	expr _EQ expr
-	{
-		$$ = &Expr{Op: Eq, X: $1, Y: $3}
-	}
-|	expr _NE expr
-	{
-		$$ = &Expr{Op: NotEq, X: $1, Y: $3}
-	}
-|	expr _LE expr
-	{
-		$$ = &Expr{Op: LtEq, X: $1, Y: $3}
-	}
-|	expr '<' expr_list '>'
-	{
-		$$ = &Expr{Op: BitIndex, X: $1, List: $3}
-	}
-|	expr _LT expr
-	{
-		$$ = &Expr{Op: Lt, X: $1, Y: $3}
-	}
-|	expr _GE expr
-	{
-		$$ = &Expr{Op: GtEq, X: $1, Y: $3}
-	}
-|	expr _GT expr
-	{
-		$$ = &Expr{Op: Gt, X: $1, Y: $3}
-	}
-|	_IF expr _THEN expr _ELSE expr %prec _IF
-	{
-		$$ = &Expr{Op: IfElse, X: $2, Y: $4, Z: $6}
-	}
-|	'!' expr %prec unary
-	{
-		$$ = &Expr{Op: Not, X: $2}
-	}
-|	expr _ANDAND expr
-	{
-		$$ = &Expr{Op: AndAnd, X: $1, Y: $3}
-	}
-|	expr _OROR expr
-	{
-		$$ = &Expr{Op: OrOr, X: $1, Y: $3}
-	}
-|	expr '^' expr
-	{
-		$$ = &Expr{Op: Eor, X: $1, Y: $3}
-	}
-|	expr ':' expr
-	{
-		$$ = &Expr{Op: Colon, X: $1, Y: $3}
-	}
-|	expr _AND expr
-	{
-		$$ = &Expr{Op: BigAND, X: $1, Y: $3}
-	}
-|	expr _OR expr
-	{
-		$$ = &Expr{Op: BigOR, X: $1, Y: $3}
-	}
-|	expr _EOR expr
-	{
-		$$ = &Expr{Op: BigEOR, X: $1, Y: $3}
-	}
-|	'+' expr %prec unary
-	{
-		$$ = &Expr{Op: Plus, X: $2}
-	}
-|	'-' expr %prec unary
-	{
-		$$ = &Expr{Op: Minus, X: $2}
-	}
-|	expr '+' expr
-	{
-		$$ = &Expr{Op: Add, X: $1, Y: $3}
-	}
-|	expr '-' expr
-	{
-		$$ = &Expr{Op: Sub, X: $1, Y: $3}
-	}
-|	expr '*' expr
-	{
-		$$ = &Expr{Op: Mul, X: $1, Y: $3}
-	}
-|	expr '/' expr
-	{
-		$$ = &Expr{Op: Div, X: $1, Y: $3}
-	}
-|	expr _DIV expr
-	{
-		$$ = &Expr{Op: BigDIV, X: $1, Y: $3}
-	}
-|	expr _MOD expr
-	{
-		$$ = &Expr{Op: BigMOD, X: $1, Y: $3}
-	}
-|	_TWOPOW expr
-	{
-		$$ = &Expr{Op: TwoPow, X: $2}
-	}
-|	expr _LSH expr
-	{
-		$$ = &Expr{Op: Lsh, X: $1, Y: $3}
-	}
-|	expr _RSH expr
-	{
-		$$ = &Expr{Op: Rsh, X: $1, Y: $3}
-	}
-|	expr '[' expr_list ']'
-	{
-		$$ = &Expr{Op: Index, X: $1, List: $3}
-	}
-|	expr '.' _NAME
-	{
-		$$ = &Expr{Op: Dot, X: $1, Text: $3}
-	}
-|	expr '=' expr %prec last_resort
-	{
-		$$ = &Expr{Op: Eq, X: $1, Y: $3}
-	}
-
-call_expr:
-	_NAME_PAREN expr_list_opt ')'
-	{
-		$$ = &Expr{Op: Call, Text: $1, List: $2}
-	}
-	
-unnamed_type:
-	_BITS expr ')'
-	{
-		$$ = &Type{Op: BitType, NX: $2}
-	}
-|	_BIT
-	{
-		$$ = &Type{Op: BitType, N: 1}
-	}
-|	_INTEGER
-	{
-		$$ = &Type{Op: IntegerType}
-	}
-|	_BOOLEAN
-	{
-		$$ = &Type{Op: BoolType}
-	}
-
-%%
-
-func parseIntConst(s string) int {
-	n, _ := strconv.Atoi(s)
-	return n
-}
diff --git a/arm/armspec/y.go b/arm/armspec/y.go
deleted file mode 100644
index 8a289ce..0000000
--- a/arm/armspec/y.go
+++ /dev/null
@@ -1,1165 +0,0 @@
-//line pseudo.y:2
-package main
-
-import __yyfmt__ "fmt"
-
-//line pseudo.y:2
-import (
-	"strconv"
-)
-
-//line pseudo.y:10
-type yySymType struct {
-	yys     int
-	str     string
-	line    Line
-	stmt    *Stmt
-	stmts   []*Stmt
-	expr    *Expr
-	exprs   []*Expr
-	elseifs []*ElseIf
-	when    *When
-	whens   []*When
-	typ     *Type
-	typs    []*Type
-}
-
-const _ASSERT = 57346
-const _BITS = 57347
-const _BIT = 57348
-const _IF = 57349
-const _EOF = 57350
-const _NAME = 57351
-const _NAME_PAREN = 57352
-const _RETURN = 57353
-const _UNDEFINED = 57354
-const _UNPREDICTABLE = 57355
-const _IMPLEMENTATION_DEFINED = 57356
-const _SUBARCHITECTURE_DEFINED = 57357
-const _ENUMERATION = 57358
-const _DO = 57359
-const _INDENT = 57360
-const _UNINDENT = 57361
-const _THEN = 57362
-const _REPEAT = 57363
-const _UNTIL = 57364
-const _WHILE = 57365
-const _CASE = 57366
-const _FOR = 57367
-const _TO = 57368
-const _OF = 57369
-const _ELSIF = 57370
-const _ELSE = 57371
-const _OTHERWISE = 57372
-const _WHEN = 57373
-const _CONST = 57374
-const _UNKNOWN = 57375
-const _EQ = 57376
-const _NE = 57377
-const _LE = 57378
-const _GE = 57379
-const _AND = 57380
-const _OR = 57381
-const _EOR = 57382
-const _ANDAND = 57383
-const _OROR = 57384
-const _DIV = 57385
-const _MOD = 57386
-const _TWOPOW = 57387
-const _LSH = 57388
-const _RSH = 57389
-const _INTEGER = 57390
-const _BOOLEAN = 57391
-const _SEE = 57392
-const last_resort = 57393
-const _LT = 57394
-const _GT = 57395
-const unary = 57396
-
-var yyToknames = []string{
-	"_ASSERT",
-	"_BITS",
-	"_BIT",
-	"_IF",
-	"_EOF",
-	"_NAME",
-	"_NAME_PAREN",
-	"_RETURN",
-	"_UNDEFINED",
-	"_UNPREDICTABLE",
-	"_IMPLEMENTATION_DEFINED",
-	"_SUBARCHITECTURE_DEFINED",
-	"_ENUMERATION",
-	"_DO",
-	"_INDENT",
-	"_UNINDENT",
-	"_THEN",
-	"_REPEAT",
-	"_UNTIL",
-	"_WHILE",
-	"_CASE",
-	"_FOR",
-	"_TO",
-	"_OF",
-	"_ELSIF",
-	"_ELSE",
-	"_OTHERWISE",
-	"_WHEN",
-	"_CONST",
-	"_UNKNOWN",
-	"_EQ",
-	"_NE",
-	"_LE",
-	"_GE",
-	"_AND",
-	"_OR",
-	"_EOR",
-	"_ANDAND",
-	"_OROR",
-	"_DIV",
-	"_MOD",
-	"_TWOPOW",
-	"_LSH",
-	"_RSH",
-	"_INTEGER",
-	"_BOOLEAN",
-	"_SEE",
-	"last_resort",
-	" =",
-	" ,",
-	"_LT",
-	" >",
-	"_GT",
-	" :",
-	" +",
-	" -",
-	" |",
-	" ^",
-	" *",
-	" /",
-	" %",
-	" &",
-	" .",
-	" <",
-	" [",
-	"unary",
-}
-var yyStatenames = []string{}
-
-const yyEofCode = 1
-const yyErrCode = 2
-const yyMaxDepth = 200
-
-//line pseudo.y:544
-func parseIntConst(s string) int {
-	n, _ := strconv.Atoi(s)
-	return n
-}
-
-//line yacctab:1
-var yyExca = []int{
-	-1, 1,
-	1, -1,
-	-2, 0,
-}
-
-const yyNprod = 107
-const yyPrivate = 57344
-
-var yyTokenNames []string
-var yyStates []string
-
-const yyLast = 1272
-
-var yyAct = []int{
-
-	15, 190, 103, 44, 16, 134, 194, 16, 42, 5,
-	47, 48, 49, 50, 140, 4, 13, 137, 79, 39,
-	78, 138, 43, 6, 85, 46, 6, 181, 154, 134,
-	133, 16, 96, 89, 91, 92, 93, 94, 79, 75,
-	55, 74, 139, 134, 84, 83, 101, 82, 168, 81,
-	6, 80, 108, 109, 110, 111, 79, 113, 114, 115,
-	116, 117, 118, 119, 120, 121, 122, 123, 124, 125,
-	126, 127, 128, 129, 130, 79, 112, 76, 134, 102,
-	153, 77, 203, 3, 100, 188, 40, 27, 63, 150,
-	16, 93, 132, 70, 71, 131, 72, 73, 143, 144,
-	145, 16, 39, 147, 179, 180, 149, 142, 41, 6,
-	41, 86, 68, 69, 141, 202, 75, 55, 74, 95,
-	148, 98, 53, 54, 57, 63, 64, 65, 59, 60,
-	70, 71, 38, 72, 73, 155, 87, 196, 79, 157,
-	201, 56, 1, 58, 62, 66, 67, 164, 61, 68,
-	69, 173, 174, 75, 55, 74, 193, 88, 156, 93,
-	195, 170, 171, 167, 175, 178, 162, 176, 160, 172,
-	169, 182, 161, 159, 185, 16, 14, 177, 16, 187,
-	2, 184, 191, 16, 186, 0, 0, 0, 183, 192,
-	0, 0, 0, 0, 0, 16, 189, 0, 0, 0,
-	0, 200, 16, 207, 199, 16, 0, 0, 205, 208,
-	0, 192, 0, 0, 204, 0, 0, 0, 206, 12,
-	23, 24, 7, 0, 30, 37, 17, 18, 19, 21,
-	22, 28, 0, 27, 136, 0, 8, 0, 9, 11,
-	10, 0, 0, 0, 0, 0, 0, 29, 31, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	36, 0, 0, 25, 26, 20, 0, 0, 0, 0,
-	0, 0, 0, 34, 35, 12, 23, 24, 7, 0,
-	30, 37, 17, 18, 19, 21, 22, 28, 32, 27,
-	33, 0, 8, 0, 9, 11, 10, 0, 0, 0,
-	0, 0, 0, 29, 31, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 36, 0, 0, 25,
-	26, 20, 0, 0, 0, 0, 0, 0, 0, 34,
-	35, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 32, 0, 33, 98, 53, 54,
-	57, 63, 64, 65, 59, 60, 70, 71, 0, 72,
-	73, 0, 0, 0, 0, 99, 0, 56, 0, 58,
-	62, 66, 67, 0, 61, 68, 69, 0, 0, 75,
-	55, 74, 0, 0, 23, 24, 45, 135, 30, 37,
-	17, 18, 19, 21, 22, 0, 0, 27, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 29, 31, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 36, 0, 0, 25, 26, 20,
-	0, 0, 0, 0, 0, 0, 0, 34, 35, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 32, 0, 33, 98, 53, 54, 57, 63,
-	64, 65, 59, 60, 70, 71, 0, 72, 73, 0,
-	0, 0, 0, 99, 0, 56, 0, 58, 62, 66,
-	67, 0, 61, 68, 69, 0, 0, 75, 55, 74,
-	0, 165, 98, 53, 54, 57, 63, 64, 65, 59,
-	60, 70, 71, 0, 72, 73, 0, 0, 0, 0,
-	99, 0, 56, 0, 58, 62, 66, 67, 0, 61,
-	68, 69, 0, 0, 75, 55, 74, 0, 151, 98,
-	53, 54, 57, 63, 64, 65, 59, 60, 70, 71,
-	0, 72, 73, 0, 0, 0, 0, 99, 0, 56,
-	0, 58, 62, 66, 67, 0, 61, 68, 69, 0,
-	0, 75, 55, 74, 0, 107, 23, 24, 45, 0,
-	30, 37, 17, 18, 19, 21, 22, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 29, 31, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 36, 0, 0, 25,
-	26, 20, 0, 0, 0, 0, 0, 0, 0, 34,
-	35, 0, 0, 198, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 32, 0, 33, 98, 53, 54,
-	57, 63, 64, 65, 59, 60, 70, 71, 0, 72,
-	73, 0, 0, 0, 0, 99, 0, 56, 197, 58,
-	62, 66, 67, 0, 61, 68, 69, 0, 0, 75,
-	55, 74, 98, 53, 54, 57, 63, 64, 65, 59,
-	60, 70, 71, 0, 72, 73, 0, 0, 0, 0,
-	99, 104, 56, 0, 58, 62, 66, 67, 0, 61,
-	68, 69, 0, 0, 75, 55, 74, 0, 98, 53,
-	54, 57, 63, 64, 65, 59, 60, 70, 71, 0,
-	72, 73, 0, 0, 0, 0, 99, 0, 56, 0,
-	58, 62, 66, 67, 0, 61, 68, 69, 163, 0,
-	75, 55, 74, 98, 53, 54, 57, 63, 64, 65,
-	59, 60, 70, 71, 0, 72, 73, 0, 0, 0,
-	0, 99, 0, 56, 0, 58, 62, 66, 67, 0,
-	61, 68, 69, 166, 0, 75, 55, 74, 0, 0,
-	0, 98, 53, 54, 57, 63, 64, 65, 59, 60,
-	70, 71, 0, 72, 73, 0, 0, 0, 0, 99,
-	0, 56, 0, 58, 62, 66, 67, 0, 61, 68,
-	69, 163, 0, 75, 55, 74, 52, 53, 54, 57,
-	63, 64, 65, 59, 60, 70, 71, 0, 72, 73,
-	0, 0, 0, 0, 51, 0, 56, 146, 58, 62,
-	66, 67, 0, 61, 68, 69, 0, 0, 75, 55,
-	74, 98, 53, 54, 57, 63, 64, 65, 59, 60,
-	70, 71, 0, 72, 73, 0, 0, 0, 0, 99,
-	0, 56, 0, 58, 62, 66, 67, 0, 61, 68,
-	69, 106, 0, 75, 55, 74, 0, 0, 98, 53,
-	54, 57, 63, 64, 65, 59, 60, 70, 71, 0,
-	72, 73, 0, 0, 0, 0, 99, 0, 56, 97,
-	58, 62, 66, 67, 0, 61, 68, 69, 0, 0,
-	75, 55, 74, 98, 53, 54, 57, 63, 64, 65,
-	59, 60, 70, 71, 0, 72, 73, 0, 0, 0,
-	0, 99, 0, 56, 0, 58, 62, 66, 67, 0,
-	61, 68, 69, 0, 0, 75, 55, 74, 98, 53,
-	54, 57, 63, 64, 65, 59, 60, 70, 71, 0,
-	72, 73, 0, 0, 0, 0, 99, 0, 56, 0,
-	58, 62, 66, 67, 0, 61, 68, 69, 0, 0,
-	75, 55, 74, 98, 53, 54, 57, 63, 64, 65,
-	59, 60, 70, 71, 0, 72, 73, 0, 0, 0,
-	0, 105, 0, 56, 0, 58, 62, 66, 67, 0,
-	61, 68, 69, 0, 0, 75, 55, 74, 52, 53,
-	54, 57, 63, 64, 65, 59, 60, 70, 71, 0,
-	72, 73, 0, 0, 0, 0, 51, 0, 56, 0,
-	58, 62, 66, 67, 0, 61, 68, 69, 0, 0,
-	75, 55, 74, 98, 53, 54, 57, 63, 64, 65,
-	0, 0, 70, 71, 0, 72, 73, 23, 24, 45,
-	0, 30, 37, 56, 0, 58, 62, 66, 67, 0,
-	61, 68, 69, 0, 0, 75, 55, 74, 23, 24,
-	45, 0, 30, 37, 29, 31, 23, 24, 45, 0,
-	30, 37, 0, 0, 0, 0, 0, 36, 0, 0,
-	25, 26, 0, 0, 0, 29, 31, 0, 0, 0,
-	34, 35, 0, 29, 31, 0, 0, 0, 36, 0,
-	0, 25, 26, 0, 0, 32, 36, 33, 0, 25,
-	26, 34, 158, 0, 0, 0, 0, 0, 0, 34,
-	90, 0, 0, 0, 0, 0, 32, 0, 33, 0,
-	0, 0, 0, 0, 32, 0, 33, 63, 64, 65,
-	0, 0, 70, 71, 0, 72, 73, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 62, 66, 67, 0,
-	61, 68, 69, 0, 0, 75, 55, 74, 0, 152,
-	63, 64, 65, 0, 0, 70, 71, 0, 72, 73,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 62,
-	66, 67, 0, 61, 68, 69, 0, 0, 75, 55,
-	74, 63, 64, 65, 0, 0, 70, 71, 0, 72,
-	73, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 66, 67, 0, 61, 68, 69, 0, 0, 75,
-	55, 74,
-}
-var yyPact = []int{
-
-	271, -1000, 124, 271, -1000, -1000, 77, 1072, 69, 1072,
-	1072, 1072, 1072, -1000, -1000, 994, 7, 1072, -19, -21,
-	-23, -25, -26, 1072, -1000, -1000, -1000, 271, 127, -1000,
-	-1000, -1000, 1101, 1072, 1072, 1072, 1072, 1072, -1000, -1000,
-	-38, -1000, 889, 75, -1000, 1072, 57, 674, 959, 854,
-	495, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072,
-	1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072, 1072,
-	1072, 1072, 1072, 1072, 1072, 83, -1000, -40, -10, 924,
-	-1000, -1000, -1000, -1000, -1000, 313, 215, -54, -32, 924,
-	1072, -1000, -1000, -1000, -27, -60, -1000, 379, 1072, 1072,
-	-1000, 817, 1072, 69, -1000, 1072, 71, -1000, 458, 1139,
-	1172, 1172, 25, 1172, 1172, 1172, 1029, 1029, 50, 1203,
-	-27, 50, 50, 50, 50, -27, -27, -27, -27, -27,
-	-27, -48, -1000, -1000, 1072, -1000, -1000, 1072, 1093, -1000,
-	-1000, -1000, -1000, 782, 1172, 924, 1072, 421, -1000, 747,
-	-1000, -1000, -1000, -1000, -1000, 924, -24, 924, 1072, -1000,
-	133, -1000, 123, 1072, 709, -1000, 1072, 74, -43, -1000,
-	1072, 379, -1000, 1072, 561, 87, 674, 66, -1000, 379,
-	128, -1000, 638, -1000, -1000, 603, -1000, 69, -1000, -1000,
-	-1000, 561, -1000, 62, -1000, -1000, -1000, 69, 561, -1000,
-	-1000, 379, 128, -1000, -1000, -1000, -1000, -1000, -1000,
-}
-var yyPgo = []int{
-
-	0, 83, 182, 180, 15, 9, 16, 1, 177, 176,
-	173, 172, 170, 169, 168, 166, 165, 163, 81, 20,
-	157, 156, 0, 3, 6, 22, 142, 2, 140,
-}
-var yyR1 = []int{
-
-	0, 26, 5, 5, 5, 5, 5, 5, 5, 5,
-	5, 4, 4, 4, 4, 4, 4, 4, 4, 4,
-	4, 4, 9, 27, 27, 6, 7, 2, 2, 1,
-	1, 3, 3, 10, 11, 14, 14, 15, 15, 12,
-	12, 12, 13, 13, 17, 17, 16, 16, 28, 28,
-	8, 8, 8, 18, 18, 19, 19, 21, 21, 24,
-	24, 20, 20, 20, 20, 22, 22, 22, 22, 22,
-	22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-	22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-	22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
-	22, 22, 23, 25, 25, 25, 25,
-}
-var yyR2 = []int{
-
-	0, 2, 4, 4, 2, 3, 2, 2, 2, 2,
-	2, 1, 3, 5, 5, 5, 4, 8, 7, 3,
-	1, 1, 6, 0, 1, 3, 1, 1, 2, 1,
-	2, 0, 1, 2, 2, 0, 5, 0, 5, 0,
-	2, 2, 0, 2, 0, 2, 4, 4, 0, 1,
-	0, 2, 2, 0, 1, 1, 3, 1, 3, 1,
-	1, 1, 1, 3, 3, 1, 1, 2, 1, 2,
-	1, 3, 3, 3, 3, 4, 3, 3, 3, 6,
-	2, 3, 3, 3, 3, 3, 3, 3, 2, 2,
-	3, 3, 3, 3, 3, 3, 2, 3, 3, 4,
-	3, 3, 3, 3, 1, 1, 1,
-}
-var yyChk = []int{
-
-	-1000, -26, -3, -1, -4, -5, -25, 7, 21, 23,
-	25, 24, 4, -6, -9, -22, -23, 11, 12, 13,
-	50, 14, 15, 5, 6, 48, 49, 18, 16, 32,
-	9, 33, 73, 75, 58, 59, 45, 10, 8, -4,
-	9, 33, -22, -25, -23, 7, -6, -22, -22, -22,
-	-22, 52, 34, 35, 36, 67, 54, 37, 56, 41,
-	42, 61, 57, 38, 39, 40, 58, 59, 62, 63,
-	43, 44, 46, 47, 68, 66, 70, -18, -19, -22,
-	70, 70, 70, 70, 70, -22, -1, 9, -20, -22,
-	59, -22, -22, -22, -22, -18, 70, 20, 34, 52,
-	9, -22, 22, -27, 17, 52, 27, 70, -22, -22,
-	-22, -22, -19, -22, -22, -22, -22, -22, -22, -22,
-	-22, -22, -22, -22, -22, -22, -22, -22, -22, -22,
-	-22, -19, 9, 70, 53, 74, 19, 71, 53, 74,
-	74, -6, -5, -22, -22, -22, 20, -22, -6, -22,
-	18, 70, 70, 55, 76, -22, -19, -22, 59, -10,
-	-14, -11, -15, 29, -22, 70, 26, -17, 72, -12,
-	28, 29, -13, 28, 29, -22, -22, -8, -16, 30,
-	31, 70, -22, -6, -5, -22, -5, -27, 19, -6,
-	-7, -2, -5, -21, -24, 32, 9, 20, 20, -6,
-	-5, -28, 53, 20, -6, -5, -6, -7, -24,
-}
-var yyDef = []int{
-
-	31, -2, 0, 32, 29, 11, 0, 0, 0, 0,
-	0, 0, 0, 20, 21, 0, 70, 53, 0, 0,
-	0, 0, 0, 0, 104, 105, 106, 0, 0, 65,
-	66, 68, 0, 0, 0, 0, 0, 53, 1, 30,
-	67, 69, 0, 0, 70, 0, 0, 23, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-	0, 0, 0, 0, 0, 0, 4, 0, 54, 55,
-	6, 7, 8, 9, 10, 0, 0, 0, 0, 61,
-	62, 80, 88, 89, 96, 0, 12, 0, 0, 0,
-	67, 0, 0, 0, 24, 0, 0, 19, 101, 72,
-	73, 74, 0, 76, 77, 78, 81, 82, 83, 84,
-	85, 86, 87, 90, 91, 92, 93, 94, 95, 97,
-	98, 0, 100, 5, 0, 103, 25, 0, 0, 71,
-	102, 35, 37, 0, 72, 101, 0, 0, 16, 0,
-	44, 2, 3, 75, 99, 56, 0, 63, 64, 13,
-	39, 14, 42, 0, 0, 15, 0, 50, 0, 33,
-	0, 0, 34, 0, 0, 79, 23, 0, 45, 0,
-	0, 22, 0, 40, 41, 0, 43, 0, 18, 51,
-	52, 26, 27, 48, 57, 59, 60, 0, 0, 17,
-	28, 0, 0, 49, 36, 38, 46, 47, 58,
-}
-var yyTok1 = []int{
-
-	1, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 75, 3, 3, 3, 64, 65, 3,
-	73, 74, 62, 58, 53, 59, 66, 63, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 57, 70,
-	67, 52, 55, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 68, 3, 76, 61, 3, 3, 3, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
-	3, 3, 3, 71, 60, 72,
-}
-var yyTok2 = []int{
-
-	2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
-	12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
-	22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
-	32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
-	42, 43, 44, 45, 46, 47, 48, 49, 50, 51,
-	54, 56, 69,
-}
-var yyTok3 = []int{
-	0,
-}
-
-//line yaccpar:1
-
-/*	parser for yacc output	*/
-
-var yyDebug = 0
-
-type yyLexer interface {
-	Lex(lval *yySymType) int
-	Error(s string)
-}
-
-const yyFlag = -1000
-
-func yyTokname(c int) string {
-	// 4 is TOKSTART above
-	if c >= 4 && c-4 < len(yyToknames) {
-		if yyToknames[c-4] != "" {
-			return yyToknames[c-4]
-		}
-	}
-	return __yyfmt__.Sprintf("tok-%v", c)
-}
-
-func yyStatname(s int) string {
-	if s >= 0 && s < len(yyStatenames) {
-		if yyStatenames[s] != "" {
-			return yyStatenames[s]
-		}
-	}
-	return __yyfmt__.Sprintf("state-%v", s)
-}
-
-func yylex1(lex yyLexer, lval *yySymType) int {
-	c := 0
-	char := lex.Lex(lval)
-	if char <= 0 {
-		c = yyTok1[0]
-		goto out
-	}
-	if char < len(yyTok1) {
-		c = yyTok1[char]
-		goto out
-	}
-	if char >= yyPrivate {
-		if char < yyPrivate+len(yyTok2) {
-			c = yyTok2[char-yyPrivate]
-			goto out
-		}
-	}
-	for i := 0; i < len(yyTok3); i += 2 {
-		c = yyTok3[i+0]
-		if c == char {
-			c = yyTok3[i+1]
-			goto out
-		}
-	}
-
-out:
-	if c == 0 {
-		c = yyTok2[1] /* unknown char */
-	}
-	if yyDebug >= 3 {
-		__yyfmt__.Printf("lex %s(%d)\n", yyTokname(c), uint(char))
-	}
-	return c
-}
-
-func yyParse(yylex yyLexer) int {
-	var yyn int
-	var yylval yySymType
-	var yyVAL yySymType
-	yyS := make([]yySymType, yyMaxDepth)
-
-	Nerrs := 0   /* number of errors */
-	Errflag := 0 /* error recovery flag */
-	yystate := 0
-	yychar := -1
-	yyp := -1
-	goto yystack
-
-ret0:
-	return 0
-
-ret1:
-	return 1
-
-yystack:
-	/* put a state and value onto the stack */
-	if yyDebug >= 4 {
-		__yyfmt__.Printf("char %v in %v\n", yyTokname(yychar), yyStatname(yystate))
-	}
-
-	yyp++
-	if yyp >= len(yyS) {
-		nyys := make([]yySymType, len(yyS)*2)
-		copy(nyys, yyS)
-		yyS = nyys
-	}
-	yyS[yyp] = yyVAL
-	yyS[yyp].yys = yystate
-
-yynewstate:
-	yyn = yyPact[yystate]
-	if yyn <= yyFlag {
-		goto yydefault /* simple state */
-	}
-	if yychar < 0 {
-		yychar = yylex1(yylex, &yylval)
-	}
-	yyn += yychar
-	if yyn < 0 || yyn >= yyLast {
-		goto yydefault
-	}
-	yyn = yyAct[yyn]
-	if yyChk[yyn] == yychar { /* valid shift */
-		yychar = -1
-		yyVAL = yylval
-		yystate = yyn
-		if Errflag > 0 {
-			Errflag--
-		}
-		goto yystack
-	}
-
-yydefault:
-	/* default state action */
-	yyn = yyDef[yystate]
-	if yyn == -2 {
-		if yychar < 0 {
-			yychar = yylex1(yylex, &yylval)
-		}
-
-		/* look through exception table */
-		xi := 0
-		for {
-			if yyExca[xi+0] == -1 && yyExca[xi+1] == yystate {
-				break
-			}
-			xi += 2
-		}
-		for xi += 2; ; xi += 2 {
-			yyn = yyExca[xi+0]
-			if yyn < 0 || yyn == yychar {
-				break
-			}
-		}
-		yyn = yyExca[xi+1]
-		if yyn < 0 {
-			goto ret0
-		}
-	}
-	if yyn == 0 {
-		/* error ... attempt to resume parsing */
-		switch Errflag {
-		case 0: /* brand new error */
-			yylex.Error("syntax error")
-			Nerrs++
-			if yyDebug >= 1 {
-				__yyfmt__.Printf("%s", yyStatname(yystate))
-				__yyfmt__.Printf(" saw %s\n", yyTokname(yychar))
-			}
-			fallthrough
-
-		case 1, 2: /* incompletely recovered error ... try again */
-			Errflag = 3
-
-			/* find a state where "error" is a legal shift action */
-			for yyp >= 0 {
-				yyn = yyPact[yyS[yyp].yys] + yyErrCode
-				if yyn >= 0 && yyn < yyLast {
-					yystate = yyAct[yyn] /* simulate a shift of "error" */
-					if yyChk[yystate] == yyErrCode {
-						goto yystack
-					}
-				}
-
-				/* the current p has no shift on "error", pop stack */
-				if yyDebug >= 2 {
-					__yyfmt__.Printf("error recovery pops state %d\n", yyS[yyp].yys)
-				}
-				yyp--
-			}
-			/* there is no state on the stack with an error shift ... abort */
-			goto ret1
-
-		case 3: /* no shift yet; clobber input char */
-			if yyDebug >= 2 {
-				__yyfmt__.Printf("error recovery discards %s\n", yyTokname(yychar))
-			}
-			if yychar == yyEofCode {
-				goto ret1
-			}
-			yychar = -1
-			goto yynewstate /* try again in the same state */
-		}
-	}
-
-	/* reduction by production yyn */
-	if yyDebug >= 2 {
-		__yyfmt__.Printf("reduce %v in:\n\t%v\n", yyn, yyStatname(yystate))
-	}
-
-	yynt := yyn
-	yypt := yyp
-	_ = yypt // guard against "declared and not used"
-
-	yyp -= yyR2[yyn]
-	yyVAL = yyS[yyp+1]
-
-	/* consult goto table to find next state */
-	yyn = yyR1[yyn]
-	yyg := yyPgo[yyn]
-	yyj := yyg + yyS[yyp].yys + 1
-
-	if yyj >= yyLast {
-		yystate = yyAct[yyg]
-	} else {
-		yystate = yyAct[yyj]
-		if yyChk[yystate] != -yyn {
-			yystate = yyAct[yyg]
-		}
-	}
-	// dummy call; replaced with literal code
-	switch yynt {
-
-	case 1:
-		//line pseudo.y:100
-		{
-			yylex.(*Lexer).prog = yyS[yypt-1].stmts
-			return 0
-		}
-	case 2:
-		//line pseudo.y:107
-		{
-			yyVAL.stmt = &Stmt{Op: Assign, X: yyS[yypt-3].expr, Y: yyS[yypt-1].expr}
-		}
-	case 3:
-		//line pseudo.y:111
-		{
-			yyVAL.stmt = &Stmt{Op: Assign, X: yyS[yypt-3].expr, Y: yyS[yypt-1].expr}
-		}
-	case 4:
-		//line pseudo.y:115
-		{
-			yyVAL.stmt = &Stmt{Op: StmtExpr, X: yyS[yypt-1].expr}
-		}
-	case 5:
-		//line pseudo.y:119
-		{
-			yyVAL.stmt = &Stmt{Op: Return, List: yyS[yypt-1].exprs}
-		}
-	case 6:
-		//line pseudo.y:123
-		{
-			yyVAL.stmt = &Stmt{Op: Undefined}
-		}
-	case 7:
-		//line pseudo.y:127
-		{
-			yyVAL.stmt = &Stmt{Op: Unpredictable}
-		}
-	case 8:
-		//line pseudo.y:131
-		{
-			yyVAL.stmt = &Stmt{Op: See, Text: yyS[yypt-1].str}
-		}
-	case 9:
-		//line pseudo.y:135
-		{
-			yyVAL.stmt = &Stmt{Op: ImplDefined}
-		}
-	case 10:
-		//line pseudo.y:139
-		{
-			yyVAL.stmt = &Stmt{Op: SubarchDefined}
-		}
-	case 11:
-		yyVAL.stmt = yyS[yypt-0].stmt
-	case 12:
-		//line pseudo.y:146
-		{
-			yyVAL.stmt = &Stmt{Op: StmtExpr, X: &Expr{Op: Decl, Type: yyS[yypt-2].typ, Text: yyS[yypt-1].str}}
-		}
-	case 13:
-		//line pseudo.y:150
-		{
-			yyVAL.stmt = &Stmt{Op: If, X: yyS[yypt-3].expr, Body: yyS[yypt-1].stmt, ElseIf: yyS[yypt-0].elseifs, Else: yyS[yypt-0].stmt}
-		}
-	case 14:
-		//line pseudo.y:154
-		{
-			yyVAL.stmt = &Stmt{Op: If, X: yyS[yypt-3].expr, Body: yyS[yypt-1].stmt, ElseIf: yyS[yypt-0].elseifs, Else: yyS[yypt-0].stmt}
-		}
-	case 15:
-		//line pseudo.y:158
-		{
-			yyVAL.stmt = &Stmt{Op: Repeat, Body: yyS[yypt-3].stmt, X: yyS[yypt-1].expr}
-		}
-	case 16:
-		//line pseudo.y:162
-		{
-			yyVAL.stmt = &Stmt{Op: While, X: yyS[yypt-2].expr, Body: yyS[yypt-0].stmt}
-		}
-	case 17:
-		//line pseudo.y:166
-		{
-			yyVAL.stmt = &Stmt{Op: For, X: yyS[yypt-6].expr, Y: yyS[yypt-4].expr, Z: yyS[yypt-2].expr, Body: yyS[yypt-0].stmt}
-		}
-	case 18:
-		//line pseudo.y:170
-		{
-			yyVAL.stmt = &Stmt{Op: Case, X: yyS[yypt-5].expr, When: yyS[yypt-2].whens, Else: yyS[yypt-1].stmt}
-		}
-	case 19:
-		//line pseudo.y:174
-		{
-			yyVAL.stmt = &Stmt{Op: Assert, X: yyS[yypt-1].expr}
-		}
-	case 20:
-		//line pseudo.y:178
-		{
-			yyVAL.stmt = yyS[yypt-0].stmt
-		}
-	case 21:
-		yyVAL.stmt = yyS[yypt-0].stmt
-	case 22:
-		//line pseudo.y:185
-		{
-			yyVAL.stmt = &Stmt{Op: Enum, Text: yyS[yypt-4].str, List: yyS[yypt-2].exprs}
-		}
-	case 25:
-		//line pseudo.y:194
-		{
-			yyVAL.stmt = &Stmt{Op: Block, Block: yyS[yypt-1].stmts}
-		}
-	case 26:
-		//line pseudo.y:200
-		{
-			yyVAL.stmt = &Stmt{Op: Block, Block: yyS[yypt-0].stmts}
-		}
-	case 27:
-		//line pseudo.y:206
-		{
-			yyVAL.stmts = []*Stmt{yyS[yypt-0].stmt}
-		}
-	case 28:
-		//line pseudo.y:210
-		{
-			yyVAL.stmts = append(yyS[yypt-1].stmts, yyS[yypt-0].stmt)
-		}
-	case 29:
-		//line pseudo.y:216
-		{
-			yyVAL.stmts = []*Stmt{yyS[yypt-0].stmt}
-		}
-	case 30:
-		//line pseudo.y:220
-		{
-			yyVAL.stmts = append(yyS[yypt-1].stmts, yyS[yypt-0].stmt)
-		}
-	case 31:
-		//line pseudo.y:225
-		{
-			yyVAL.stmts = nil
-		}
-	case 32:
-		yyVAL.stmts = yyS[yypt-0].stmts
-	case 33:
-		//line pseudo.y:232
-		{
-			yyVAL.elseifs = yyS[yypt-1].elseifs
-			yyVAL.stmt = yyS[yypt-0].stmt
-		}
-	case 34:
-		//line pseudo.y:239
-		{
-			yyVAL.elseifs = yyS[yypt-1].elseifs
-			yyVAL.stmt = yyS[yypt-0].stmt
-		}
-	case 35:
-		//line pseudo.y:245
-		{
-			yyVAL.elseifs = nil
-		}
-	case 36:
-		//line pseudo.y:249
-		{
-			yyVAL.elseifs = append(yyS[yypt-4].elseifs, &ElseIf{Cond: yyS[yypt-2].expr, Body: yyS[yypt-0].stmt})
-		}
-	case 37:
-		//line pseudo.y:254
-		{
-			yyVAL.elseifs = nil
-		}
-	case 38:
-		//line pseudo.y:258
-		{
-			yyVAL.elseifs = append(yyS[yypt-4].elseifs, &ElseIf{Cond: yyS[yypt-2].expr, Body: yyS[yypt-0].stmt})
-		}
-	case 39:
-		//line pseudo.y:263
-		{
-			yyVAL.stmt = nil
-		}
-	case 40:
-		//line pseudo.y:267
-		{
-			yyVAL.stmt = yyS[yypt-0].stmt
-		}
-	case 41:
-		//line pseudo.y:271
-		{
-			yyVAL.stmt = yyS[yypt-0].stmt
-		}
-	case 42:
-		//line pseudo.y:276
-		{
-			yyVAL.stmt = nil
-		}
-	case 43:
-		//line pseudo.y:280
-		{
-			yyVAL.stmt = yyS[yypt-0].stmt
-		}
-	case 44:
-		//line pseudo.y:285
-		{
-			yyVAL.whens = nil
-		}
-	case 45:
-		//line pseudo.y:289
-		{
-			yyVAL.whens = append(yyS[yypt-1].whens, yyS[yypt-0].when)
-		}
-	case 46:
-		//line pseudo.y:295
-		{
-			yyVAL.when = &When{Cond: yyS[yypt-2].exprs, Body: yyS[yypt-0].stmt}
-		}
-	case 47:
-		//line pseudo.y:299
-		{
-			yyVAL.when = &When{Cond: yyS[yypt-2].exprs, Body: yyS[yypt-0].stmt}
-		}
-	case 50:
-		//line pseudo.y:307
-		{
-			yyVAL.stmt = nil
-		}
-	case 51:
-		//line pseudo.y:311
-		{
-			yyVAL.stmt = yyS[yypt-0].stmt
-		}
-	case 52:
-		//line pseudo.y:315
-		{
-			yyVAL.stmt = yyS[yypt-0].stmt
-		}
-	case 53:
-		//line pseudo.y:320
-		{
-			yyVAL.exprs = nil
-		}
-	case 54:
-		yyVAL.exprs = yyS[yypt-0].exprs
-	case 55:
-		//line pseudo.y:327
-		{
-			yyVAL.exprs = []*Expr{yyS[yypt-0].expr}
-		}
-	case 56:
-		//line pseudo.y:331
-		{
-			yyVAL.exprs = append(yyS[yypt-2].exprs, yyS[yypt-0].expr)
-		}
-	case 57:
-		//line pseudo.y:337
-		{
-			yyVAL.exprs = []*Expr{yyS[yypt-0].expr}
-		}
-	case 58:
-		//line pseudo.y:341
-		{
-			yyVAL.exprs = append(yyS[yypt-2].exprs, yyS[yypt-0].expr)
-		}
-	case 59:
-		//line pseudo.y:347
-		{
-			yyVAL.expr = &Expr{Op: Const, Text: yyS[yypt-0].str}
-		}
-	case 60:
-		//line pseudo.y:351
-		{
-			yyVAL.expr = &Expr{Op: Name, Text: yyS[yypt-0].str}
-		}
-	case 61:
-		//line pseudo.y:357
-		{
-			yyVAL.exprs = []*Expr{yyS[yypt-0].expr}
-		}
-	case 62:
-		//line pseudo.y:361
-		{
-			yyVAL.exprs = []*Expr{&Expr{Op: Blank}}
-		}
-	case 63:
-		//line pseudo.y:365
-		{
-			yyVAL.exprs = append(yyS[yypt-2].exprs, yyS[yypt-0].expr)
-		}
-	case 64:
-		//line pseudo.y:369
-		{
-			yyVAL.exprs = append(yyS[yypt-2].exprs, &Expr{Op: Blank})
-		}
-	case 65:
-		//line pseudo.y:375
-		{
-			yyVAL.expr = &Expr{Op: Const, Text: yyS[yypt-0].str}
-		}
-	case 66:
-		//line pseudo.y:379
-		{
-			yyVAL.expr = &Expr{Op: Name, Text: yyS[yypt-0].str}
-		}
-	case 67:
-		//line pseudo.y:383
-		{
-			yyVAL.expr = &Expr{Op: Decl, Type: yyS[yypt-1].typ, Text: yyS[yypt-0].str}
-		}
-	case 68:
-		//line pseudo.y:387
-		{
-			yyVAL.expr = &Expr{Op: Unknown}
-		}
-	case 69:
-		//line pseudo.y:391
-		{
-			yyVAL.expr = &Expr{Op: Unknown, Type: yyS[yypt-1].typ}
-		}
-	case 70:
-		yyVAL.expr = yyS[yypt-0].expr
-	case 71:
-		//line pseudo.y:396
-		{
-			yyVAL.expr = &Expr{Op: ExprTuple, List: yyS[yypt-1].exprs}
-		}
-	case 72:
-		//line pseudo.y:400
-		{
-			yyVAL.expr = &Expr{Op: Eq, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 73:
-		//line pseudo.y:404
-		{
-			yyVAL.expr = &Expr{Op: NotEq, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 74:
-		//line pseudo.y:408
-		{
-			yyVAL.expr = &Expr{Op: LtEq, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 75:
-		//line pseudo.y:412
-		{
-			yyVAL.expr = &Expr{Op: BitIndex, X: yyS[yypt-3].expr, List: yyS[yypt-1].exprs}
-		}
-	case 76:
-		//line pseudo.y:416
-		{
-			yyVAL.expr = &Expr{Op: Lt, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 77:
-		//line pseudo.y:420
-		{
-			yyVAL.expr = &Expr{Op: GtEq, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 78:
-		//line pseudo.y:424
-		{
-			yyVAL.expr = &Expr{Op: Gt, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 79:
-		//line pseudo.y:428
-		{
-			yyVAL.expr = &Expr{Op: IfElse, X: yyS[yypt-4].expr, Y: yyS[yypt-2].expr, Z: yyS[yypt-0].expr}
-		}
-	case 80:
-		//line pseudo.y:432
-		{
-			yyVAL.expr = &Expr{Op: Not, X: yyS[yypt-0].expr}
-		}
-	case 81:
-		//line pseudo.y:436
-		{
-			yyVAL.expr = &Expr{Op: AndAnd, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 82:
-		//line pseudo.y:440
-		{
-			yyVAL.expr = &Expr{Op: OrOr, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 83:
-		//line pseudo.y:444
-		{
-			yyVAL.expr = &Expr{Op: Eor, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 84:
-		//line pseudo.y:448
-		{
-			yyVAL.expr = &Expr{Op: Colon, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 85:
-		//line pseudo.y:452
-		{
-			yyVAL.expr = &Expr{Op: BigAND, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 86:
-		//line pseudo.y:456
-		{
-			yyVAL.expr = &Expr{Op: BigOR, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 87:
-		//line pseudo.y:460
-		{
-			yyVAL.expr = &Expr{Op: BigEOR, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 88:
-		//line pseudo.y:464
-		{
-			yyVAL.expr = &Expr{Op: Plus, X: yyS[yypt-0].expr}
-		}
-	case 89:
-		//line pseudo.y:468
-		{
-			yyVAL.expr = &Expr{Op: Minus, X: yyS[yypt-0].expr}
-		}
-	case 90:
-		//line pseudo.y:472
-		{
-			yyVAL.expr = &Expr{Op: Add, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 91:
-		//line pseudo.y:476
-		{
-			yyVAL.expr = &Expr{Op: Sub, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 92:
-		//line pseudo.y:480
-		{
-			yyVAL.expr = &Expr{Op: Mul, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 93:
-		//line pseudo.y:484
-		{
-			yyVAL.expr = &Expr{Op: Div, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 94:
-		//line pseudo.y:488
-		{
-			yyVAL.expr = &Expr{Op: BigDIV, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 95:
-		//line pseudo.y:492
-		{
-			yyVAL.expr = &Expr{Op: BigMOD, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 96:
-		//line pseudo.y:496
-		{
-			yyVAL.expr = &Expr{Op: TwoPow, X: yyS[yypt-0].expr}
-		}
-	case 97:
-		//line pseudo.y:500
-		{
-			yyVAL.expr = &Expr{Op: Lsh, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 98:
-		//line pseudo.y:504
-		{
-			yyVAL.expr = &Expr{Op: Rsh, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 99:
-		//line pseudo.y:508
-		{
-			yyVAL.expr = &Expr{Op: Index, X: yyS[yypt-3].expr, List: yyS[yypt-1].exprs}
-		}
-	case 100:
-		//line pseudo.y:512
-		{
-			yyVAL.expr = &Expr{Op: Dot, X: yyS[yypt-2].expr, Text: yyS[yypt-0].str}
-		}
-	case 101:
-		//line pseudo.y:516
-		{
-			yyVAL.expr = &Expr{Op: Eq, X: yyS[yypt-2].expr, Y: yyS[yypt-0].expr}
-		}
-	case 102:
-		//line pseudo.y:522
-		{
-			yyVAL.expr = &Expr{Op: Call, Text: yyS[yypt-2].str, List: yyS[yypt-1].exprs}
-		}
-	case 103:
-		//line pseudo.y:528
-		{
-			yyVAL.typ = &Type{Op: BitType, NX: yyS[yypt-1].expr}
-		}
-	case 104:
-		//line pseudo.y:532
-		{
-			yyVAL.typ = &Type{Op: BitType, N: 1}
-		}
-	case 105:
-		//line pseudo.y:536
-		{
-			yyVAL.typ = &Type{Op: IntegerType}
-		}
-	case 106:
-		//line pseudo.y:540
-		{
-			yyVAL.typ = &Type{Op: BoolType}
-		}
-	}
-	goto yystack /* stack new state and value */
-}