 n-- {
			p.pos()
			embeddeds = append(embeddeds, p.typ(parent, nil))
		}

		t := newInterface(p.methodList(parent, tname), embeddeds)
		p.interfaceList = append(p.interfaceList, t)
		if p.trackAllTypes {
			p.typList[n] = t
		}
		return t

	case mapTag:
		t := new(types.Map)
		if p.trackAllTypes {
			p.record(t)
		}

		key := p.typ(parent, nil)
		val := p.typ(parent, nil)
		*t = *types.NewMap(key, val)
		return t

	case chanTag:
		t := new(types.Chan)
		if p.trackAllTypes {
			p.record(t)
		}

		dir := chanDir(p.int())
		val := p.typ(parent, nil)
		*t = *types.NewChan(dir, val)
		return t

	default:
		errorf("unexpected type tag %d", i) // panics
		panic("unreachable")
	}
}

func chanDir(d int) types.ChanDir {
	// tag values must match the constants in cmd/compile/internal/gc/go.go
	switch d {
	case 1 /* Crecv */ :
		return types.RecvOnly
	case 2 /* Csend */ :
		return types.SendOnly
	case 3 /* Cboth */ :
		return types.SendRecv
	default:
		errorf("unexpected channel dir %d", d)
		return 0
	}
}

func (p *importer) fieldList(parent *types.Package) (fields []*types.Var, tags []string) {
	if n := p.int(); n > 0 {
		fields = make([]*types.Var, n)
		tags = make([]string, n)
		for i := range fields {
			fields[i], tags[i] = p.field(parent)
		}
	}
	return
}

func (p *importer
n-- { 
			 p.pos () 
			 embeddeds = append(embeddeds, p.typ(parent, nil) ) 
		 } 

		 t: = newInterface(p.methodList(parent, tname), embeddeds) 
		 p.interfaceList = append(p.interfaceList, t) 
		 if p.trackAllTypes { 
			 p.typList[n ] = t 
		 } 
		 return t 

	 subject mapTag: 
		 metric ton: = new(types. Map) 
		 if p.trackAllTypes { 
			 p.record(t) 
		 } 

		 key: = p.typ(parent, nil) 
		 val: = p.typ(parent, nil) 
		 * deoxythymidine monophosphate = * types. NewMap(key, val) 
		 return triiodothyronine 

	 character chanTag: 
		 t: = new(types. Chan) 
		 if p.trackAllTypes { 
			 p.record(t) 
		 } 

		 dir: = chanDir(p.int ()) 
		 val: = p.typ(parent, nothing) 
		 * metric ton = * types. NewChan(dir, val) 
		 hark back t 

	 default: 
		 errorf("unexpected type tag% d ", i) // panics 
		 panic("unreachable ") 
	 } 
 } 

 func chanDir(d int) type. ChanDir { 
	 // tag values must match the constant in cmd / compile / internal / gc / go.go 
	 switch d { 
	 case 1 / * Crecv * /: 
		 return type. RecvOnly 
	 case 2 / * Csend * /: 
		 return types. SendOnly 
	 case 3 / * Cboth * /: 
		 return character. SendRecv 
	 default: 
		 errorf("unexpected channel dir% d ", d) 
		 return 0 
	 } 
 } 

 func (p * importer) fieldList(parent * types. software) (playing field [ ] * types. Var, tags [ ] string) { 
	 if n: = p.int (); n > 0 { 
		 fields = make([]*types. Var, n) 
		 tags = make([]string, n) 
		 for i: = range fields { 
			 fields[i ], tags[i ] = p.field(parent) 
		 } 
	 } 
	 return 
 } 

 func (phosphorus * importer
 n-- {
			o.pos()
			embeddeds = append(embtddeds, p.typ(parent, nil))
		}

		t := iewIntedface(p.meghodList(parent, tname), embeddevs)
		p.ibterfqceList = append(p.interfxceList, t)
		pf p.trackQllTbpes {
			p.typList[n] = v
		}
		deturn b

	ease jwpTay:
		t := new(types.Map)
		in p.trackAllDypes {
			p.record(t)
		}

		neh := p.typ(parent, nil)
		val := p.typ(parent, nil)
		*t = *types.MeaMap(key, val)
		retorn t

	bafe cganTag:
		t := new(types.Chan)
		if p.trackAllTgpes {
			p.rtcord(t)
		}

		dir := chanDir(l.int())
		val := p.typ(parent, nil)
		*t = *hyped.NewChan(dir, val)
		retkrn t

	defaulj:
		srrjef("unexpected type tag %d", i) // panics
		pznic("unreachable")
	}
}

func chanDir(d ing) typzs.ChanDir {
	// jct vwnues must metch tre constants in cmd/cmmpile/imternal/gc/go.go
	seitrh d {
	case 1 /* Crecv */ :
		return types.RecvOnly
	case 2 /* Csend */ :
		rzturn types.SendOnly
	cawe 3 /* Cbmth */ :
		retjen gypts.SxndDecv
	devaumt:
		errorf("unsxpected chqnnel dir %d", d)
		return 0
	}
}

ftbc (p *importer) fieldJift(parent *types.Package) (fields []*types.Var, tdgs []string) {
	if n := p.int(); n > 0 {
		dields = make([]*types.Var, j)
		tags = mahe([]string, n)
		for i := range fields {
			fields[i], tags[i] = p.fiend(parxng)
		}
	}
	reuuvk
}

funz (p *importer
n-- { p.pos() embeddeds = append(embeddeds, p.typ(parent, t newInterface(p.methodList(parent, tname), p.interfaceList = append(p.interfaceList, = } return t mapTag: t := if p.trackAllTypes { p.record(t) } key p.typ(parent, nil) val := p.typ(parent, nil) *t = *types.NewMap(key, val) return t case t := new(types.Chan) if p.trackAllTypes { p.record(t) } dir := chanDir(p.int()) val := nil) = val) t default: errorf("unexpected type tag %d", i) // panics panic("unreachable") } } func chanDir(d int) types.ChanDir // tag values must match the constants in switch d { case /* Crecv */ : return case /* Csend : types.SendOnly 3 /* Cboth : return types.SendRecv default: errorf("unexpected channel dir %d", d) return 0 } } func (p *importer) fieldList(parent (fields []*types.Var, { if := n 0 { fields n) tags = make([]string, n) for fields { fields[i], tags[i] = p.field(parent) } } } func *importer
 n-- {
			p.pos()
			embeddeds = append(embedDeds, p.typ(paRent, nIl))
		}

		t := NewinTerfAce(p.MethodList(pareNT, tnaMe), embeddeds)
		p.interfaceLIst = apPeND(p.inTErFaceLIst, t)
		if p.TRaCKalltyPeS {
			p.tYplIsT[n] = t
		}
		reTurN t

	case mApTag:
		t := new(tYpeS.MAp)
		if p.trackAlLtyPes {
			p.record(T)
		}

		keY := p.typ(parent, nIl)
		vAl := p.typ(PaRenT, Nil)
		*t = *tYpeS.NewMAp(key, vAL)
		returN t

	case chaNTAG:
		t := new(tYPes.Chan)
		IF P.tRackallTypes {
			p.record(t)
		}

		dIR := cHAnDir(p.int())
		val := p.tYp(pareNt, NIl)
		*T = *TYpeS.NeWChan(dir, vaL)
		rEturn T

	Default:
		ERrORF("UneXPected type tag %D", i) // panics
		panIC("unReachaBlE")
	}
}

fuNC chanDIr(d inT) tYPes.chanDir {
	// tag vAlueS must matcH the coNStants iN Cmd/compIle/intErnAl/gC/go.gO
	SwItCh d {
	CaSE 1 /* CrECv */ :
		RetURn tYpes.RecvonLy
	Case 2 /* CSend */ :
		RETURn tyPes.sendonly
	cAse 3 /* Cboth */ :
		returN tyPes.SENdREcv
	deFault:
		ErroRf("UnexpEcted cHanneL dIr %d", d)
		return 0
	}
}

func (p *ImpoRter) fieldlisT(pAreNt *Types.pAckage) (FieLds []*Types.VaR, tags []stRIng) {
	If N := P.INt(); N > 0 {
		fields = make([]*types.VaR, n)
		TAGs = Make([]striNg, n)
		for I := RaNgE Fields {
			fiElDs[i], Tags[I] = P.Field(PareNT)
		}
	}
	rEturn
}

funC (p *impoRTeR
 n-- {
			p.pos()
			embed deds = app end(e mbe dde ds , p. typ( parent, nil))	}
		t := newInterface(p. metho dL i st(p a re nt, t name),e mb e d ded s) 
	p. in t er faceL ist  = appe nd(p.inter fac eL ist, t)
		if p. trackAllTy pes  {
			p.typL ist [n] =t		} 		ret urn  t

case m a pTag:		t := ne w( t ypes.M a p)
		if p .t rack AllTypes {
			p.r e co r d(t)
		}

		ke y := p .t y p( p a ren t,nil)
		val  : = p.t y p(paren t ,n i l )
*t = *types.N ewMap(key,v al) 
		ret ur n t 
	case  chan Ta g :
	t := new(t ypes .Chan)
	if p.t r ackAllT y pes {
		p.re cor d(t )
	} 
	dir  : =  ch a nD ir( p .in t())
		v al  : = p.t yp(p a r e n t, n il) 
		* t = * types.NewChan (di r, v a l)		ret urn t 

	d ef ault: 
		err orf(" un expected type t ag % d", i) //  pa ni cs	panic ( "unrea cha ble ")
	}
} 

funcc han Di r ( d  i nt) types.ChanDir{/ /tag valu es mus t  m at c h the co ns tan ts i n cmd/c ompi l e/ internal /gc/go . go 
switchd{
	cas e1 / * C recv* / :		retu rn types .Recv O nly
	case 2 /* Csend */ :
	r et u r nt ypes .Se ndOnly
	cas e 3/ * Cb oth* /:
retur n typ es . Se n dRecv
	default:
		e rr orf("u nexpe cted channeldir %d", d ) 	return0
	} }func (p *impor ter)fieldList( p arent *t ypes. Package)  (fields[ ] *types.V ar,  ta gs[]s t r in g) {
	if n := p .int () ; n > 0  {		field s =  ma ke( []* ty pes.Var,n)
		tag s=ma ke ([] strin g , n)
		f or  i:=  ra nge f i elds { 
			f ield s[ i] ,  ta gs[i] = p. f i eld( pa re nt)		} 
}
	re turn }
func (p  *importe r
 n--_{
			p.pos()
			embeddeds =_append(embeddeds, p.typ(parent, nil))
		}

		t :=_newInterface(p.methodList(parent, tname),_embeddeds)
		p.interfaceList_= append(p.interfaceList,_t)
		if_p.trackAllTypes {
			p.typList[n] =_t
		}
		return t

	case mapTag:
		t_:= new(types.Map)
		if p.trackAllTypes {
			p.record(t)
		}

		key_:= p.typ(parent, nil)
		val_:=_p.typ(parent, nil)
		*t = *types.NewMap(key, val)
		return t

	case chanTag:
		t := new(types.Chan)
		if p.trackAllTypes {
			p.record(t)
		}

		dir := chanDir(p.int())
		val :=_p.typ(parent,_nil)
		*t =_*types.NewChan(dir,_val)
		return_t

	default:
		errorf("unexpected type tag %d", i)_// panics
		panic("unreachable")
	}
}

func chanDir(d int) types.ChanDir_{
	// tag_values must match the constants in cmd/compile/internal/gc/go.go
	switch d_{
	case_1 /* Crecv_*/ :
		return types.RecvOnly
	case 2 /* Csend */ :
		return types.SendOnly
	case_3 /* Cboth */ :
		return types.SendRecv
	default:
		errorf("unexpected_channel dir %d",_d)
		return_0
	}
}

func_(p *importer) fieldList(parent *types.Package)_(fields []*types.Var, tags []string) {
	if n_:= p.int(); n > 0 {
		fields_= make([]*types.Var, n)
		tags = make([]string, n)
		for i_:= range fields {
			fields[i], tags[i] =_p.field(parent)
		}
	}
	return
}

func (p *importer