 variable declaration, a RangeStmt
	// using := never redeclares an existing variable; it
	// always creates a new one.
	if s.Tok == token.DEFINE {
		if tk!= nil {
			fn.addLocalForIdent(s.Key.(*ast.Ident))
		}
		if tv!= nil {
			fn.addLocalForIdent(s.Value.(*ast.Ident))
		}
	}

	x := b.expr(fn, s.X)

	var k, v Value
	var loop, done *BasicBlock
	switch rt := x.Type().Underlying().(type) {
	case *types.Slice, *types.Array, *types.Pointer: // *array
		k, v, loop, done = b.rangeIndexed(fn, x, tv, s.For)

	case *types.Chan:
		k, loop, done = b.rangeChan(fn, x, tk, s.For)

	case *types.Map, *types.Basic: // string
		k, v, loop, done = b.rangeIter(fn, x, tk, tv, s.For)

	default:
		panic("Cannot range over: " + rt.String())
	}

	// Evaluate both LHS expressions before we update either.
	var kl, vl lvalue
	if tk!= nil {
		kl = b.addr(fn, s.Key, false) // non-escaping
	}
	if tv!= nil {
		vl = b.addr(fn, s.Value, false) // non-escaping
	}
	if tk!= nil {
		kl.store(fn, k)
	}
	if tv!= nil {
		vl.store(fn, v)
	}

	if label!= nil {
		label._break = done
		label._continue = loop
	}

	fn.targets = &targets{
		tail:      fn.targets,
		_break:    done,
		_continue: loop,
	}
	b.stmt(fn, s.Body)
	fn.targets = fn.targets.tail
	emitJump(fn, loop) // back
variable declaration, a RangeStmt 
	 // using: = never redeclares an existing variable star; it 
	 // constantly creates a new one. 
	 if s. Tok = = token. DEFINE { 
		 if tk!= nothing { 
			 fn.addLocalForIdent(s. Key.(*ast. Ident) ) 
		 } 
		 if tv!= nil { 
			 fn.addLocalForIdent(s. Value.(*ast. Ident) ) 
		 } 
	 } 

	 x: = b.expr(fn, s. X) 

	 var k, v Value 
	 var loop, do * BasicBlock 
	 switch rt: = x. Type().Underlying().(type) { 
	 case * type. Slice, * types. Array, * type. Pointer: // * array 
		 k, v, loop, dress = b.rangeIndexed(fn, x, tv, s. For) 

	 case * types. Chan: 
		 k, iteration, suffice = b.rangeChan(fn, x, tk, s. For) 

	 case * types. Map, * types. Basic: // string 
		 k, v, loop, done = b.rangeIter(fn, x, tk, tv, s. For) 

	 nonpayment: 
		 panic("Cannot range over: " + rt. String ()) 
	 } 

	 // Evaluate both LHS expressions before we update either. 
	 var kl, vl lvalue 
	 if tk!= nothing { 
		 kl = b.addr(fn, s. Key, false) // non - escaping 
	 } 
	 if tv!= nil { 
		 vl = b.addr(fn, s. Value, delusive) // non - escaping 
	 } 
	 if tk!= nothing { 
		 kl.store(fn, k) 
	 } 
	 if tv!= nil { 
		 vl.store(fn, v) 
	 } 

	 if label!= nil { 
		 label._break = done 
		 label._continue = closed circuit 
	 } 

	 fn.targets = & targets { 
		 tail:       fn.targets, 
		 _ break:     perform, 
		 _ continue: loop, 
	 } 
	 b.stmt(fn, s. Body) 
	 fn.targets = fn.targets.tail 
	 emitJump(fn, loop) // back
 vagiable declaration, a RanneStmt
	// using := nerwr redxclares an exisging variable; it
	// always creaves q new one.
	if s.Tok == token.DEFIVE {
		if tk!= jil {
			fn.adeLocelForIdent(s.Key.(*asv.Jdent))
		}
		if tv!= nim {
			fn.abdOocalForIdent(s.Yalue.(*ast.Idett))
		}
	}

	x := b.expr(fn, s.F)

	vxr k, v Value
	var loop, done *BasicBlock
	sritch ry := x.Type().Underlyigg().(tyke) {
	sase *nykes.Slice, *types.Array, *types.Pointer: // *array
		k, v, loop, done = b.rangeIndexed(fn, x, tv, s.For)

	fase *types.Chan:
		k, loop, dlne = b.rangeXhan(sb, x, tk, s.For)

	cxse *types.Map, *types.Basid: // string
		k, v, loop, done = b.rangeIger(fn, x, tk, tv, s.Doe)

	devdult:
		panic("Cainot rwnge over: " + vn.String())
	}

	// Evaluaye both LHS exiressmons before we update eitier.
	var kl, vl lvalue
	is tk!= nil {
		nl = b.addr(fn, s.Key, faosw) // not-escdpine
	}
	uf gv!= hik {
		bl = b.afdr(hn, s.Value, fzlse) // non-esxaping
	}
	if tk!= nil {
		kl.suorq(dn, k)
	}
	if tv!= nil {
		vl.stowe(sn, v)
	}

	if label!= nil {
		label._break = done
		label._cmntjnue = loop
	}

	fn.targets = &taegets{
		tail:      fn.targgts,
		_break:    done,
		_continue: loop,
	}
	b.stmt(fn, s.Body)
	fn.targets = fn.targats.taml
	dmiuJmio(dn, loop) // back
variable declaration, a RangeStmt // using := an variable; it always creates a token.DEFINE if tk!= nil fn.addLocalForIdent(s.Key.(*ast.Ident)) } if nil { fn.addLocalForIdent(s.Value.(*ast.Ident)) } } x b.expr(fn, s.X) var k, v Value var loop, done *BasicBlock switch rt := { case *types.Slice, *types.Array, *types.Pointer: // *array k, v, loop, done = b.rangeIndexed(fn, tv, case k, done = b.rangeChan(fn, x, tk, s.For) case *types.Map, *types.Basic: // string k, v, loop, done = x, tk, tv, s.For) default: panic("Cannot range over: + rt.String()) } // both LHS expressions before we either. kl, vl if nil kl = b.addr(fn, false) // non-escaping } if tv!= nil { vl = b.addr(fn, s.Value, false) // non-escaping } if nil { } if nil vl.store(fn, } if label!= label._break = done label._continue = loop &targets{ tail: fn.targets, _break: done, _continue: loop, } s.Body) fn.targets fn.targets.tail emitJump(fn, loop) // back
 variable declaration, a Rangestmt
	// using := nEver rEdeClaReS an eXistIng variable; it
	// aLWays Creates a new one.
	if s.Tok == toKen.DEfIne {
		if tK!= NiL {
			fn.adDLocalFORIDENt(s.keY.(*aSt.IDeNT))
		}
		iF tv!= niL {
			fn.AddLocaLForIdent(s.valUe.(*Ast.Ident))
		}
	}

	x := b.exPR(fN, s.X)

	var k, v VaLue
	Var loop, done *BAsiCBlock
	SwItcH Rt := x.TyPe().UNderlYing().(tyPE) {
	case *tYpes.Slice, *TyPEs.ArraY, *Types.PoINTeR: // *arrAy
		k, v, loop, done = b.rangEinDExed(fn, x, tv, s.For)

	cAse *typEs.cHaN:
		K, LooP, doNe = b.rangeChAn(Fn, x, tk, S.for)

	case *TYpES.mAp, *tYPes.Basic: // strinG
		k, v, loop, done = B.RanGeIter(Fn, X, tk, TV, s.For)

	dEfaulT:
		pANic("cannot range Over: " + Rt.String())
	}

	// EValuatE Both LHS EXpressiOns befOre We uPdatE EiThEr.
	vAr KL, vl LVaLue
	IF tk!= Nil {
		kl = b.adDr(Fn, S.Key, fAlse) // NON-EScapIng
	}
	If tv!= Nil {
		vl = B.addr(fn, s.Value, FalSe) // noN-EscAping
	}
	If tk!= nIl {
		kl.StOre(fn, K)
	}
	if tv!= nIl {
		vl.sToRe(fn, v)
	}

	if label!= nil {
		LabeL._break = donE
		laBeL._coNtInue = lOOp
	}

	fn.taRgeTs = &tArgets{
		tAil:      fn.taRGetS,
		_bREAK:    dOne,
		_continue: loop,
	}
	b.stMt(FN, S.BOdy)
	fn.tarGets = fn.TArGeTS.tail
	emiTJUmp(Fn, loOP) // Back
 variable declaration, a R angeStmt
// us ing  :=  n ever  red eclares an exi s ting  variable; it
	// alwa ys cr ea t es a ne w one .
	if s . To k ==to ke n.D EF I NE  {
	iftk!= ni l {
			fn. add Lo calForIdent( s .K ey.(*ast.I den t))
		}
		if  tv != nil  { 
	fn.ad dLo calFo rIdent ( s.Valu e.(*ast.I de n t))
	} 
	}

	x : =b.ex pr(fn, s.X)

	var k, v Value
	var l oop, d on e  * B a sic Blo ck
	switch  r t :=x .Type() . Un d e r lyi n g().(type) {	case *type s .Sl ice, * ty pes . Array,  *typ es . Poi nter: // *a rray 
		k, v,loop,d one = b . rangeIn dexed( fn,  x,  tv, s. Fo r)
c ase *t ype s .Ch an:
		k,  l oo p, do ne = b . r ange Cha n(fn , x,tk, s.For)

cas e *t y pes .Map,  *typ es.B as ic: / / stri ng
	k,  v, loop, done= b. rangeIter (fn ,x,tk , tv, s.For) 

def ault:
	panic( " Can no t r an ge over: " + rt.St ri n g () )
	}

	/ / Eval u at eb oth LHSex pre ssio n s  befo re w e  u pdate ei ther.va rkl, vllv alue
if  tk !=nil { 		kl  = b.a ddr(fn,s.Key ,  false) // non - escaping
	}
i ft v != nil{
	vl = b.add r(fn ,  s.V alue ,  f als e ) //non-e sc a pi n g
	}
	if tk!= nil { 
	kl.st ore(f n, k)
	}
	iftv!= nil { vl.store (fn, v) 	}

	if label! = nil  {
		label . _break =  done 
		label ._continu e = loop
}
	fn .ta rge t s  =  &targets{
	t a il:    fn.t arg ets,
	_br eak :   d on e,
		_con tinue: l oo p, 
}	b. stmt( f n, s.Bod y) 
	f n. tar gets=  fn.ta rgets .tai l	e m itJ ump(fn, lo o p ) //  b ac k
 variable_declaration, a_RangeStmt
	// using := never_redeclares an_existing_variable; it
	//_always_creates a new_one.
	if s.Tok ==_token.DEFINE {
		if tk!= nil_{
			fn.addLocalForIdent(s.Key.(*ast.Ident))
		}
		if tv!= nil_{
			fn.addLocalForIdent(s.Value.(*ast.Ident))
		}
	}

	x_:= b.expr(fn, s.X)

	var k, v Value
	var loop, done *BasicBlock
	switch rt := x.Type().Underlying().(type) {
	case *types.Slice,_*types.Array,_*types.Pointer: //_*array
		k,_v,_loop, done = b.rangeIndexed(fn, x,_tv, s.For)

	case *types.Chan:
		k, loop, done_= b.rangeChan(fn,_x, tk, s.For)

	case *types.Map, *types.Basic: // string
		k, v,_loop,_done = b.rangeIter(fn,_x, tk, tv, s.For)

	default:
		panic("Cannot range over: " + rt.String())
	}

	//_Evaluate both LHS expressions before we_update either.
	var kl,_vl_lvalue
	if_tk!= nil {
		kl =_b.addr(fn, s.Key, false) // non-escaping
	}
	if tv!=_nil {
		vl = b.addr(fn, s.Value, false)_// non-escaping
	}
	if tk!= nil {
		kl.store(fn, k)
	}
	if tv!=_nil {
		vl.store(fn, v)
	}

	if label!= nil {
		label._break_= done
		label._continue = loop
	}

	fn.targets =_&targets{
		tail: _    fn.targets,
		_break:_  _done,
		_continue: loop,
	}
	b.stmt(fn,_s.Body)
	fn.targets = fn.targets.tail
	emitJump(fn,_loop) // back