// Types don't generally have position information.
		// If we don't have a valid pos provided, try to use
		// one close enough.
		if !pos.IsValid() && len(ityp.methods) > 0 {
			pos = ityp.methods[0].pos
		}

		check.trace(pos, "-- type set for %s", ityp)
		check.indent++
		defer func() {
			check.indent--
			check.trace(pos, "=> %s ", ityp.typeSet())
		}()
	}

		// Types don't generally have position information.
		// If we don't have a valid pos provided, try to use
		// one close enough.
		if !pos.IsKnown() && len(ityp.methods) > 0 {
			pos = ityp.methods[0].pos
		}

		check.trace(pos, "-- type set for %s", ityp)
		check.indent++
		defer func() {
			check.indent--
			check.trace(pos, "=> %s ", ityp.typeSet())
		}()
	}

		sss := make([]smallScalar, 25)
		for i := range sss {
			sss[i] = smallScalar{12}
		}
		runSubTestUserArenaSlice(t, sss, true)

		mpos := make([]mediumPointerOdd, 5)
		for i := range mpos {
			mpos[i] = *mpo
		}
		runSubTestUserArenaSlice(t, mpos, true)

		sps := make([]smallPointer, UserArenaChunkBytes/unsafe.Sizeof(smallPointer{})+1)
		for i := range sps {
			sps[i] = *sp
		}

	prevLine   int64
	prevColumn int64
}

func (r *importReader) obj(name string) {
	tag := r.byte()
	pos := r.pos()

	switch tag {
	case 'A':
		typ := r.typ()

		r.declare(types.NewTypeName(pos, r.currPkg, name, typ))

	case 'C':
		typ, val := r.value()

		r.declare(types.NewConst(pos, r.currPkg, name, typ, val))

	case 'F', 'G':
		var tparams []*types.TypeParam
		if tag == 'G' {

}

// NewFunc returns a new Func with the given name and type.
//
// fpos is the position of the "func" token, and npos is the position
// of the name identifier.
//
// TODO(mdempsky): I suspect there's no need for separate fpos and
// npos.
func NewFunc(fpos, npos src.XPos, sym *types.Sym, typ *types.Type) *Func {
	name := NewNameAt(npos, sym, typ)
	name.Class = PFUNC
	sym.SetFunc(true)

	fn := &Func{Nname: name}

	}
	base := *orig
	base.inl = inlTreeIndex
	base.fileIndex = -1
	if orig == orig.pos.base {
		base.pos.base = &base
	}
	return &base
}

var noPos Pos

// Pos returns the position at which base is located.
// If b == nil, the result is the zero position.
func (b *PosBase) Pos() *Pos {
	if b != nil {
		return &b.pos
	}
	return &noPos
}

		return nil
	}
}

func truncate(b *Block, pos src.XPos, v *Value, from, to int64) *Value {
	switch from*10 + to {
	case 82:
		return b.NewValue1(pos, OpTrunc64to16, types.Types[types.TUINT16], v)
	case 84:
		return b.NewValue1(pos, OpTrunc64to32, types.Types[types.TUINT32], v)
	case 42:
		return b.NewValue1(pos, OpTrunc32to16, types.Types[types.TUINT16], v)
	default:

	{"net.key.spd_dump", []_C_int{4, 30, 2}},
	{"net.mpls.ifq.congestion", []_C_int{4, 33, 3, 4}},
	{"net.mpls.ifq.drops", []_C_int{4, 33, 3, 3}},
	{"net.mpls.ifq.len", []_C_int{4, 33, 3, 1}},
	{"net.mpls.ifq.maxlen", []_C_int{4, 33, 3, 2}},
	{"net.mpls.mapttl_ip", []_C_int{4, 33, 5}},
	{"net.mpls.mapttl_ip6", []_C_int{4, 33, 6}},
	{"net.mpls.ttl", []_C_int{4, 33, 2}},
	{"net.pflow.stats", []_C_int{4, 34, 1}},

        @Override
        protected void doProcess(Buffer buffer, int length, int type, int id) throws IOException {
            int originalBufferPosition = buffer.rpos()

            int pos = buffer.rpos()
            def command = commandMessage(buffer, type)
            buffer.rpos(pos)

            def matched = expectations.find { it.matches(buffer, type, id) }
            if (matched) {
                if (matched.failing) {

	{"net.key.spd_dump", []_C_int{4, 30, 2}},
	{"net.mpls.ifq.congestion", []_C_int{4, 33, 3, 4}},
	{"net.mpls.ifq.drops", []_C_int{4, 33, 3, 3}},
	{"net.mpls.ifq.len", []_C_int{4, 33, 3, 1}},
	{"net.mpls.ifq.maxlen", []_C_int{4, 33, 3, 2}},
	{"net.mpls.mapttl_ip", []_C_int{4, 33, 5}},
	{"net.mpls.mapttl_ip6", []_C_int{4, 33, 6}},
	{"net.mpls.ttl", []_C_int{4, 33, 2}},
	{"net.pflow.stats", []_C_int{4, 34, 1}},