1package interp
2
3// Code generated by 'go run ../internal/cmd/genop/genop.go'. DO NOT EDIT.
4
5import (
6	"go/constant"
7	"go/token"
8	"reflect"
9)
10
11// Arithmetic operators
12
13func add(n *node) {
14	next := getExec(n.tnext)
15	typ := n.typ.concrete().TypeOf()
16	isInterface := n.typ.TypeOf().Kind() == reflect.Interface
17	dest := genValueOutput(n, typ)
18	c0, c1 := n.child[0], n.child[1]
19
20	switch typ.Kind() {
21	case reflect.String:
22		switch {
23		case isInterface:
24			v0 := genValue(c0)
25			v1 := genValue(c1)
26			n.exec = func(f *frame) bltn {
27				dest(f).Set(reflect.ValueOf(v0(f).String() + v1(f).String()).Convert(typ))
28				return next
29			}
30		case c0.rval.IsValid():
31			s0 := vString(c0.rval)
32			v1 := genValue(c1)
33			n.exec = func(f *frame) bltn {
34				dest(f).SetString(s0 + v1(f).String())
35				return next
36			}
37		case c1.rval.IsValid():
38			v0 := genValue(c0)
39			s1 := vString(c1.rval)
40			n.exec = func(f *frame) bltn {
41				dest(f).SetString(v0(f).String() + s1)
42				return next
43			}
44		default:
45			v0 := genValue(c0)
46			v1 := genValue(c1)
47			n.exec = func(f *frame) bltn {
48				dest(f).SetString(v0(f).String() + v1(f).String())
49				return next
50			}
51		}
52	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
53		switch {
54		case isInterface:
55			v0 := genValueInt(c0)
56			v1 := genValueInt(c1)
57			n.exec = func(f *frame) bltn {
58				_, i := v0(f)
59				_, j := v1(f)
60				dest(f).Set(reflect.ValueOf(i + j).Convert(typ))
61				return next
62			}
63		case c0.rval.IsValid():
64			i := vInt(c0.rval)
65			v1 := genValueInt(c1)
66			n.exec = func(f *frame) bltn {
67				_, j := v1(f)
68				dest(f).SetInt(i + j)
69				return next
70			}
71		case c1.rval.IsValid():
72			v0 := genValueInt(c0)
73			j := vInt(c1.rval)
74			n.exec = func(f *frame) bltn {
75				_, i := v0(f)
76				dest(f).SetInt(i + j)
77				return next
78			}
79		default:
80			v0 := genValueInt(c0)
81			v1 := genValueInt(c1)
82			n.exec = func(f *frame) bltn {
83				_, i := v0(f)
84				_, j := v1(f)
85				dest(f).SetInt(i + j)
86				return next
87			}
88		}
89	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
90		switch {
91		case isInterface:
92			v0 := genValueUint(c0)
93			v1 := genValueUint(c1)
94			n.exec = func(f *frame) bltn {
95				_, i := v0(f)
96				_, j := v1(f)
97				dest(f).Set(reflect.ValueOf(i + j).Convert(typ))
98				return next
99			}
100		case c0.rval.IsValid():
101			i := vUint(c0.rval)
102			v1 := genValueUint(c1)
103			n.exec = func(f *frame) bltn {
104				_, j := v1(f)
105				dest(f).SetUint(i + j)
106				return next
107			}
108		case c1.rval.IsValid():
109			j := vUint(c1.rval)
110			v0 := genValueUint(c0)
111			n.exec = func(f *frame) bltn {
112				_, i := v0(f)
113				dest(f).SetUint(i + j)
114				return next
115			}
116		default:
117			v0 := genValueUint(c0)
118			v1 := genValueUint(c1)
119			n.exec = func(f *frame) bltn {
120				_, i := v0(f)
121				_, j := v1(f)
122				dest(f).SetUint(i + j)
123				return next
124			}
125		}
126	case reflect.Float32, reflect.Float64:
127		switch {
128		case isInterface:
129			v0 := genValueFloat(c0)
130			v1 := genValueFloat(c1)
131			n.exec = func(f *frame) bltn {
132				_, i := v0(f)
133				_, j := v1(f)
134				dest(f).Set(reflect.ValueOf(i + j).Convert(typ))
135				return next
136			}
137		case c0.rval.IsValid():
138			i := vFloat(c0.rval)
139			v1 := genValueFloat(c1)
140			n.exec = func(f *frame) bltn {
141				_, j := v1(f)
142				dest(f).SetFloat(i + j)
143				return next
144			}
145		case c1.rval.IsValid():
146			j := vFloat(c1.rval)
147			v0 := genValueFloat(c0)
148			n.exec = func(f *frame) bltn {
149				_, i := v0(f)
150				dest(f).SetFloat(i + j)
151				return next
152			}
153		default:
154			v0 := genValueFloat(c0)
155			v1 := genValueFloat(c1)
156			n.exec = func(f *frame) bltn {
157				_, i := v0(f)
158				_, j := v1(f)
159				dest(f).SetFloat(i + j)
160				return next
161			}
162		}
163	case reflect.Complex64, reflect.Complex128:
164		switch {
165		case isInterface:
166			v0 := genComplex(c0)
167			v1 := genComplex(c1)
168			n.exec = func(f *frame) bltn {
169				dest(f).Set(reflect.ValueOf(v0(f) + v1(f)).Convert(typ))
170				return next
171			}
172		case c0.rval.IsValid():
173			r0 := vComplex(c0.rval)
174			v1 := genComplex(c1)
175			n.exec = func(f *frame) bltn {
176				dest(f).SetComplex(r0 + v1(f))
177				return next
178			}
179		case c1.rval.IsValid():
180			r1 := vComplex(c1.rval)
181			v0 := genComplex(c0)
182			n.exec = func(f *frame) bltn {
183				dest(f).SetComplex(v0(f) + r1)
184				return next
185			}
186		default:
187			v0 := genComplex(c0)
188			v1 := genComplex(c1)
189			n.exec = func(f *frame) bltn {
190				dest(f).SetComplex(v0(f) + v1(f))
191				return next
192			}
193		}
194	}
195}
196
197func addConst(n *node) {
198	v0, v1 := n.child[0].rval, n.child[1].rval
199	isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
200	t := n.typ.rtype
201	if isConst {
202		t = constVal
203	}
204	n.rval = reflect.New(t).Elem()
205	switch {
206	case isConst:
207		v := constant.BinaryOp(vConstantValue(v0), token.ADD, vConstantValue(v1))
208		n.rval.Set(reflect.ValueOf(v))
209	case isString(t):
210		n.rval.SetString(vString(v0) + vString(v1))
211	case isComplex(t):
212		n.rval.SetComplex(vComplex(v0) + vComplex(v1))
213	case isFloat(t):
214		n.rval.SetFloat(vFloat(v0) + vFloat(v1))
215	case isUint(t):
216		n.rval.SetUint(vUint(v0) + vUint(v1))
217	case isInt(t):
218		n.rval.SetInt(vInt(v0) + vInt(v1))
219	}
220}
221
222func and(n *node) {
223	next := getExec(n.tnext)
224	typ := n.typ.concrete().TypeOf()
225	isInterface := n.typ.TypeOf().Kind() == reflect.Interface
226	dest := genValueOutput(n, typ)
227	c0, c1 := n.child[0], n.child[1]
228
229	switch typ.Kind() {
230	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
231		switch {
232		case isInterface:
233			v0 := genValueInt(c0)
234			v1 := genValueInt(c1)
235			n.exec = func(f *frame) bltn {
236				_, i := v0(f)
237				_, j := v1(f)
238				dest(f).Set(reflect.ValueOf(i & j).Convert(typ))
239				return next
240			}
241		case c0.rval.IsValid():
242			i := vInt(c0.rval)
243			v1 := genValueInt(c1)
244			n.exec = func(f *frame) bltn {
245				_, j := v1(f)
246				dest(f).SetInt(i & j)
247				return next
248			}
249		case c1.rval.IsValid():
250			v0 := genValueInt(c0)
251			j := vInt(c1.rval)
252			n.exec = func(f *frame) bltn {
253				_, i := v0(f)
254				dest(f).SetInt(i & j)
255				return next
256			}
257		default:
258			v0 := genValueInt(c0)
259			v1 := genValueInt(c1)
260			n.exec = func(f *frame) bltn {
261				_, i := v0(f)
262				_, j := v1(f)
263				dest(f).SetInt(i & j)
264				return next
265			}
266		}
267	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
268		switch {
269		case isInterface:
270			v0 := genValueUint(c0)
271			v1 := genValueUint(c1)
272			n.exec = func(f *frame) bltn {
273				_, i := v0(f)
274				_, j := v1(f)
275				dest(f).Set(reflect.ValueOf(i & j).Convert(typ))
276				return next
277			}
278		case c0.rval.IsValid():
279			i := vUint(c0.rval)
280			v1 := genValueUint(c1)
281			n.exec = func(f *frame) bltn {
282				_, j := v1(f)
283				dest(f).SetUint(i & j)
284				return next
285			}
286		case c1.rval.IsValid():
287			j := vUint(c1.rval)
288			v0 := genValueUint(c0)
289			n.exec = func(f *frame) bltn {
290				_, i := v0(f)
291				dest(f).SetUint(i & j)
292				return next
293			}
294		default:
295			v0 := genValueUint(c0)
296			v1 := genValueUint(c1)
297			n.exec = func(f *frame) bltn {
298				_, i := v0(f)
299				_, j := v1(f)
300				dest(f).SetUint(i & j)
301				return next
302			}
303		}
304	}
305}
306
307func andConst(n *node) {
308	v0, v1 := n.child[0].rval, n.child[1].rval
309	isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
310	t := n.typ.rtype
311	if isConst {
312		t = constVal
313	}
314	n.rval = reflect.New(t).Elem()
315	switch {
316	case isConst:
317		v := constant.BinaryOp(constant.ToInt(vConstantValue(v0)), token.AND, constant.ToInt(vConstantValue(v1)))
318		n.rval.Set(reflect.ValueOf(v))
319	case isUint(t):
320		n.rval.SetUint(vUint(v0) & vUint(v1))
321	case isInt(t):
322		n.rval.SetInt(vInt(v0) & vInt(v1))
323	}
324}
325
326func andNot(n *node) {
327	next := getExec(n.tnext)
328	typ := n.typ.concrete().TypeOf()
329	isInterface := n.typ.TypeOf().Kind() == reflect.Interface
330	dest := genValueOutput(n, typ)
331	c0, c1 := n.child[0], n.child[1]
332
333	switch typ.Kind() {
334	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
335		switch {
336		case isInterface:
337			v0 := genValueInt(c0)
338			v1 := genValueInt(c1)
339			n.exec = func(f *frame) bltn {
340				_, i := v0(f)
341				_, j := v1(f)
342				dest(f).Set(reflect.ValueOf(i &^ j).Convert(typ))
343				return next
344			}
345		case c0.rval.IsValid():
346			i := vInt(c0.rval)
347			v1 := genValueInt(c1)
348			n.exec = func(f *frame) bltn {
349				_, j := v1(f)
350				dest(f).SetInt(i &^ j)
351				return next
352			}
353		case c1.rval.IsValid():
354			v0 := genValueInt(c0)
355			j := vInt(c1.rval)
356			n.exec = func(f *frame) bltn {
357				_, i := v0(f)
358				dest(f).SetInt(i &^ j)
359				return next
360			}
361		default:
362			v0 := genValueInt(c0)
363			v1 := genValueInt(c1)
364			n.exec = func(f *frame) bltn {
365				_, i := v0(f)
366				_, j := v1(f)
367				dest(f).SetInt(i &^ j)
368				return next
369			}
370		}
371	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
372		switch {
373		case isInterface:
374			v0 := genValueUint(c0)
375			v1 := genValueUint(c1)
376			n.exec = func(f *frame) bltn {
377				_, i := v0(f)
378				_, j := v1(f)
379				dest(f).Set(reflect.ValueOf(i &^ j).Convert(typ))
380				return next
381			}
382		case c0.rval.IsValid():
383			i := vUint(c0.rval)
384			v1 := genValueUint(c1)
385			n.exec = func(f *frame) bltn {
386				_, j := v1(f)
387				dest(f).SetUint(i &^ j)
388				return next
389			}
390		case c1.rval.IsValid():
391			j := vUint(c1.rval)
392			v0 := genValueUint(c0)
393			n.exec = func(f *frame) bltn {
394				_, i := v0(f)
395				dest(f).SetUint(i &^ j)
396				return next
397			}
398		default:
399			v0 := genValueUint(c0)
400			v1 := genValueUint(c1)
401			n.exec = func(f *frame) bltn {
402				_, i := v0(f)
403				_, j := v1(f)
404				dest(f).SetUint(i &^ j)
405				return next
406			}
407		}
408	}
409}
410
411func andNotConst(n *node) {
412	v0, v1 := n.child[0].rval, n.child[1].rval
413	isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
414	t := n.typ.rtype
415	if isConst {
416		t = constVal
417	}
418	n.rval = reflect.New(t).Elem()
419	switch {
420	case isConst:
421		v := constant.BinaryOp(constant.ToInt(vConstantValue(v0)), token.AND_NOT, constant.ToInt(vConstantValue(v1)))
422		n.rval.Set(reflect.ValueOf(v))
423	case isUint(t):
424		n.rval.SetUint(vUint(v0) &^ vUint(v1))
425	case isInt(t):
426		n.rval.SetInt(vInt(v0) &^ vInt(v1))
427	}
428}
429
430func mul(n *node) {
431	next := getExec(n.tnext)
432	typ := n.typ.concrete().TypeOf()
433	isInterface := n.typ.TypeOf().Kind() == reflect.Interface
434	dest := genValueOutput(n, typ)
435	c0, c1 := n.child[0], n.child[1]
436
437	switch typ.Kind() {
438	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
439		switch {
440		case isInterface:
441			v0 := genValueInt(c0)
442			v1 := genValueInt(c1)
443			n.exec = func(f *frame) bltn {
444				_, i := v0(f)
445				_, j := v1(f)
446				dest(f).Set(reflect.ValueOf(i * j).Convert(typ))
447				return next
448			}
449		case c0.rval.IsValid():
450			i := vInt(c0.rval)
451			v1 := genValueInt(c1)
452			n.exec = func(f *frame) bltn {
453				_, j := v1(f)
454				dest(f).SetInt(i * j)
455				return next
456			}
457		case c1.rval.IsValid():
458			v0 := genValueInt(c0)
459			j := vInt(c1.rval)
460			n.exec = func(f *frame) bltn {
461				_, i := v0(f)
462				dest(f).SetInt(i * j)
463				return next
464			}
465		default:
466			v0 := genValueInt(c0)
467			v1 := genValueInt(c1)
468			n.exec = func(f *frame) bltn {
469				_, i := v0(f)
470				_, j := v1(f)
471				dest(f).SetInt(i * j)
472				return next
473			}
474		}
475	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
476		switch {
477		case isInterface:
478			v0 := genValueUint(c0)
479			v1 := genValueUint(c1)
480			n.exec = func(f *frame) bltn {
481				_, i := v0(f)
482				_, j := v1(f)
483				dest(f).Set(reflect.ValueOf(i * j).Convert(typ))
484				return next
485			}
486		case c0.rval.IsValid():
487			i := vUint(c0.rval)
488			v1 := genValueUint(c1)
489			n.exec = func(f *frame) bltn {
490				_, j := v1(f)
491				dest(f).SetUint(i * j)
492				return next
493			}
494		case c1.rval.IsValid():
495			j := vUint(c1.rval)
496			v0 := genValueUint(c0)
497			n.exec = func(f *frame) bltn {
498				_, i := v0(f)
499				dest(f).SetUint(i * j)
500				return next
501			}
502		default:
503			v0 := genValueUint(c0)
504			v1 := genValueUint(c1)
505			n.exec = func(f *frame) bltn {
506				_, i := v0(f)
507				_, j := v1(f)
508				dest(f).SetUint(i * j)
509				return next
510			}
511		}
512	case reflect.Float32, reflect.Float64:
513		switch {
514		case isInterface:
515			v0 := genValueFloat(c0)
516			v1 := genValueFloat(c1)
517			n.exec = func(f *frame) bltn {
518				_, i := v0(f)
519				_, j := v1(f)
520				dest(f).Set(reflect.ValueOf(i * j).Convert(typ))
521				return next
522			}
523		case c0.rval.IsValid():
524			i := vFloat(c0.rval)
525			v1 := genValueFloat(c1)
526			n.exec = func(f *frame) bltn {
527				_, j := v1(f)
528				dest(f).SetFloat(i * j)
529				return next
530			}
531		case c1.rval.IsValid():
532			j := vFloat(c1.rval)
533			v0 := genValueFloat(c0)
534			n.exec = func(f *frame) bltn {
535				_, i := v0(f)
536				dest(f).SetFloat(i * j)
537				return next
538			}
539		default:
540			v0 := genValueFloat(c0)
541			v1 := genValueFloat(c1)
542			n.exec = func(f *frame) bltn {
543				_, i := v0(f)
544				_, j := v1(f)
545				dest(f).SetFloat(i * j)
546				return next
547			}
548		}
549	case reflect.Complex64, reflect.Complex128:
550		switch {
551		case isInterface:
552			v0 := genComplex(c0)
553			v1 := genComplex(c1)
554			n.exec = func(f *frame) bltn {
555				dest(f).Set(reflect.ValueOf(v0(f) * v1(f)).Convert(typ))
556				return next
557			}
558		case c0.rval.IsValid():
559			r0 := vComplex(c0.rval)
560			v1 := genComplex(c1)
561			n.exec = func(f *frame) bltn {
562				dest(f).SetComplex(r0 * v1(f))
563				return next
564			}
565		case c1.rval.IsValid():
566			r1 := vComplex(c1.rval)
567			v0 := genComplex(c0)
568			n.exec = func(f *frame) bltn {
569				dest(f).SetComplex(v0(f) * r1)
570				return next
571			}
572		default:
573			v0 := genComplex(c0)
574			v1 := genComplex(c1)
575			n.exec = func(f *frame) bltn {
576				dest(f).SetComplex(v0(f) * v1(f))
577				return next
578			}
579		}
580	}
581}
582
583func mulConst(n *node) {
584	v0, v1 := n.child[0].rval, n.child[1].rval
585	isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
586	t := n.typ.rtype
587	if isConst {
588		t = constVal
589	}
590	n.rval = reflect.New(t).Elem()
591	switch {
592	case isConst:
593		v := constant.BinaryOp(vConstantValue(v0), token.MUL, vConstantValue(v1))
594		n.rval.Set(reflect.ValueOf(v))
595	case isComplex(t):
596		n.rval.SetComplex(vComplex(v0) * vComplex(v1))
597	case isFloat(t):
598		n.rval.SetFloat(vFloat(v0) * vFloat(v1))
599	case isUint(t):
600		n.rval.SetUint(vUint(v0) * vUint(v1))
601	case isInt(t):
602		n.rval.SetInt(vInt(v0) * vInt(v1))
603	}
604}
605
606func or(n *node) {
607	next := getExec(n.tnext)
608	typ := n.typ.concrete().TypeOf()
609	isInterface := n.typ.TypeOf().Kind() == reflect.Interface
610	dest := genValueOutput(n, typ)
611	c0, c1 := n.child[0], n.child[1]
612
613	switch typ.Kind() {
614	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
615		switch {
616		case isInterface:
617			v0 := genValueInt(c0)
618			v1 := genValueInt(c1)
619			n.exec = func(f *frame) bltn {
620				_, i := v0(f)
621				_, j := v1(f)
622				dest(f).Set(reflect.ValueOf(i | j).Convert(typ))
623				return next
624			}
625		case c0.rval.IsValid():
626			i := vInt(c0.rval)
627			v1 := genValueInt(c1)
628			n.exec = func(f *frame) bltn {
629				_, j := v1(f)
630				dest(f).SetInt(i | j)
631				return next
632			}
633		case c1.rval.IsValid():
634			v0 := genValueInt(c0)
635			j := vInt(c1.rval)
636			n.exec = func(f *frame) bltn {
637				_, i := v0(f)
638				dest(f).SetInt(i | j)
639				return next
640			}
641		default:
642			v0 := genValueInt(c0)
643			v1 := genValueInt(c1)
644			n.exec = func(f *frame) bltn {
645				_, i := v0(f)
646				_, j := v1(f)
647				dest(f).SetInt(i | j)
648				return next
649			}
650		}
651	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
652		switch {
653		case isInterface:
654			v0 := genValueUint(c0)
655			v1 := genValueUint(c1)
656			n.exec = func(f *frame) bltn {
657				_, i := v0(f)
658				_, j := v1(f)
659				dest(f).Set(reflect.ValueOf(i | j).Convert(typ))
660				return next
661			}
662		case c0.rval.IsValid():
663			i := vUint(c0.rval)
664			v1 := genValueUint(c1)
665			n.exec = func(f *frame) bltn {
666				_, j := v1(f)
667				dest(f).SetUint(i | j)
668				return next
669			}
670		case c1.rval.IsValid():
671			j := vUint(c1.rval)
672			v0 := genValueUint(c0)
673			n.exec = func(f *frame) bltn {
674				_, i := v0(f)
675				dest(f).SetUint(i | j)
676				return next
677			}
678		default:
679			v0 := genValueUint(c0)
680			v1 := genValueUint(c1)
681			n.exec = func(f *frame) bltn {
682				_, i := v0(f)
683				_, j := v1(f)
684				dest(f).SetUint(i | j)
685				return next
686			}
687		}
688	}
689}
690
691func orConst(n *node) {
692	v0, v1 := n.child[0].rval, n.child[1].rval
693	isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
694	t := n.typ.rtype
695	if isConst {
696		t = constVal
697	}
698	n.rval = reflect.New(t).Elem()
699	switch {
700	case isConst:
701		v := constant.BinaryOp(constant.ToInt(vConstantValue(v0)), token.OR, constant.ToInt(vConstantValue(v1)))
702		n.rval.Set(reflect.ValueOf(v))
703	case isUint(t):
704		n.rval.SetUint(vUint(v0) | vUint(v1))
705	case isInt(t):
706		n.rval.SetInt(vInt(v0) | vInt(v1))
707	}
708}
709
710func quo(n *node) {
711	next := getExec(n.tnext)
712	typ := n.typ.concrete().TypeOf()
713	isInterface := n.typ.TypeOf().Kind() == reflect.Interface
714	dest := genValueOutput(n, typ)
715	c0, c1 := n.child[0], n.child[1]
716
717	switch typ.Kind() {
718	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
719		switch {
720		case isInterface:
721			v0 := genValueInt(c0)
722			v1 := genValueInt(c1)
723			n.exec = func(f *frame) bltn {
724				_, i := v0(f)
725				_, j := v1(f)
726				dest(f).Set(reflect.ValueOf(i / j).Convert(typ))
727				return next
728			}
729		case c0.rval.IsValid():
730			i := vInt(c0.rval)
731			v1 := genValueInt(c1)
732			n.exec = func(f *frame) bltn {
733				_, j := v1(f)
734				dest(f).SetInt(i / j)
735				return next
736			}
737		case c1.rval.IsValid():
738			v0 := genValueInt(c0)
739			j := vInt(c1.rval)
740			n.exec = func(f *frame) bltn {
741				_, i := v0(f)
742				dest(f).SetInt(i / j)
743				return next
744			}
745		default:
746			v0 := genValueInt(c0)
747			v1 := genValueInt(c1)
748			n.exec = func(f *frame) bltn {
749				_, i := v0(f)
750				_, j := v1(f)
751				dest(f).SetInt(i / j)
752				return next
753			}
754		}
755	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
756		switch {
757		case isInterface:
758			v0 := genValueUint(c0)
759			v1 := genValueUint(c1)
760			n.exec = func(f *frame) bltn {
761				_, i := v0(f)
762				_, j := v1(f)
763				dest(f).Set(reflect.ValueOf(i / j).Convert(typ))
764				return next
765			}
766		case c0.rval.IsValid():
767			i := vUint(c0.rval)
768			v1 := genValueUint(c1)
769			n.exec = func(f *frame) bltn {
770				_, j := v1(f)
771				dest(f).SetUint(i / j)
772				return next
773			}
774		case c1.rval.IsValid():
775			j := vUint(c1.rval)
776			v0 := genValueUint(c0)
777			n.exec = func(f *frame) bltn {
778				_, i := v0(f)
779				dest(f).SetUint(i / j)
780				return next
781			}
782		default:
783			v0 := genValueUint(c0)
784			v1 := genValueUint(c1)
785			n.exec = func(f *frame) bltn {
786				_, i := v0(f)
787				_, j := v1(f)
788				dest(f).SetUint(i / j)
789				return next
790			}
791		}
792	case reflect.Float32, reflect.Float64:
793		switch {
794		case isInterface:
795			v0 := genValueFloat(c0)
796			v1 := genValueFloat(c1)
797			n.exec = func(f *frame) bltn {
798				_, i := v0(f)
799				_, j := v1(f)
800				dest(f).Set(reflect.ValueOf(i / j).Convert(typ))
801				return next
802			}
803		case c0.rval.IsValid():
804			i := vFloat(c0.rval)
805			v1 := genValueFloat(c1)
806			n.exec = func(f *frame) bltn {
807				_, j := v1(f)
808				dest(f).SetFloat(i / j)
809				return next
810			}
811		case c1.rval.IsValid():
812			j := vFloat(c1.rval)
813			v0 := genValueFloat(c0)
814			n.exec = func(f *frame) bltn {
815				_, i := v0(f)
816				dest(f).SetFloat(i / j)
817				return next
818			}
819		default:
820			v0 := genValueFloat(c0)
821			v1 := genValueFloat(c1)
822			n.exec = func(f *frame) bltn {
823				_, i := v0(f)
824				_, j := v1(f)
825				dest(f).SetFloat(i / j)
826				return next
827			}
828		}
829	case reflect.Complex64, reflect.Complex128:
830		switch {
831		case isInterface:
832			v0 := genComplex(c0)
833			v1 := genComplex(c1)
834			n.exec = func(f *frame) bltn {
835				dest(f).Set(reflect.ValueOf(v0(f) / v1(f)).Convert(typ))
836				return next
837			}
838		case c0.rval.IsValid():
839			r0 := vComplex(c0.rval)
840			v1 := genComplex(c1)
841			n.exec = func(f *frame) bltn {
842				dest(f).SetComplex(r0 / v1(f))
843				return next
844			}
845		case c1.rval.IsValid():
846			r1 := vComplex(c1.rval)
847			v0 := genComplex(c0)
848			n.exec = func(f *frame) bltn {
849				dest(f).SetComplex(v0(f) / r1)
850				return next
851			}
852		default:
853			v0 := genComplex(c0)
854			v1 := genComplex(c1)
855			n.exec = func(f *frame) bltn {
856				dest(f).SetComplex(v0(f) / v1(f))
857				return next
858			}
859		}
860	}
861}
862
863func quoConst(n *node) {
864	v0, v1 := n.child[0].rval, n.child[1].rval
865	isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
866	t := n.typ.rtype
867	if isConst {
868		t = constVal
869	}
870	n.rval = reflect.New(t).Elem()
871	switch {
872	case isConst:
873		var operator token.Token
874		// When the result of the operation is expected to be an int (because both
875		// operands are ints), we want to force the type of the whole expression to be an
876		// int (and not a float), which is achieved by using the QUO_ASSIGN operator.
877		if n.typ.untyped && isInt(n.typ.rtype) {
878			operator = token.QUO_ASSIGN
879		} else {
880			operator = token.QUO
881		}
882		v := constant.BinaryOp(vConstantValue(v0), operator, vConstantValue(v1))
883		n.rval.Set(reflect.ValueOf(v))
884	case isComplex(t):
885		n.rval.SetComplex(vComplex(v0) / vComplex(v1))
886	case isFloat(t):
887		n.rval.SetFloat(vFloat(v0) / vFloat(v1))
888	case isUint(t):
889		n.rval.SetUint(vUint(v0) / vUint(v1))
890	case isInt(t):
891		n.rval.SetInt(vInt(v0) / vInt(v1))
892	}
893}
894
895func rem(n *node) {
896	next := getExec(n.tnext)
897	typ := n.typ.concrete().TypeOf()
898	isInterface := n.typ.TypeOf().Kind() == reflect.Interface
899	dest := genValueOutput(n, typ)
900	c0, c1 := n.child[0], n.child[1]
901
902	switch typ.Kind() {
903	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
904		switch {
905		case isInterface:
906			v0 := genValueInt(c0)
907			v1 := genValueInt(c1)
908			n.exec = func(f *frame) bltn {
909				_, i := v0(f)
910				_, j := v1(f)
911				dest(f).Set(reflect.ValueOf(i % j).Convert(typ))
912				return next
913			}
914		case c0.rval.IsValid():
915			i := vInt(c0.rval)
916			v1 := genValueInt(c1)
917			n.exec = func(f *frame) bltn {
918				_, j := v1(f)
919				dest(f).SetInt(i % j)
920				return next
921			}
922		case c1.rval.IsValid():
923			v0 := genValueInt(c0)
924			j := vInt(c1.rval)
925			n.exec = func(f *frame) bltn {
926				_, i := v0(f)
927				dest(f).SetInt(i % j)
928				return next
929			}
930		default:
931			v0 := genValueInt(c0)
932			v1 := genValueInt(c1)
933			n.exec = func(f *frame) bltn {
934				_, i := v0(f)
935				_, j := v1(f)
936				dest(f).SetInt(i % j)
937				return next
938			}
939		}
940	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
941		switch {
942		case isInterface:
943			v0 := genValueUint(c0)
944			v1 := genValueUint(c1)
945			n.exec = func(f *frame) bltn {
946				_, i := v0(f)
947				_, j := v1(f)
948				dest(f).Set(reflect.ValueOf(i % j).Convert(typ))
949				return next
950			}
951		case c0.rval.IsValid():
952			i := vUint(c0.rval)
953			v1 := genValueUint(c1)
954			n.exec = func(f *frame) bltn {
955				_, j := v1(f)
956				dest(f).SetUint(i % j)
957				return next
958			}
959		case c1.rval.IsValid():
960			j := vUint(c1.rval)
961			v0 := genValueUint(c0)
962			n.exec = func(f *frame) bltn {
963				_, i := v0(f)
964				dest(f).SetUint(i % j)
965				return next
966			}
967		default:
968			v0 := genValueUint(c0)
969			v1 := genValueUint(c1)
970			n.exec = func(f *frame) bltn {
971				_, i := v0(f)
972				_, j := v1(f)
973				dest(f).SetUint(i % j)
974				return next
975			}
976		}
977	}
978}
979
980func remConst(n *node) {
981	v0, v1 := n.child[0].rval, n.child[1].rval
982	isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
983	t := n.typ.rtype
984	if isConst {
985		t = constVal
986	}
987	n.rval = reflect.New(t).Elem()
988	switch {
989	case isConst:
990		v := constant.BinaryOp(constant.ToInt(vConstantValue(v0)), token.REM, constant.ToInt(vConstantValue(v1)))
991		n.rval.Set(reflect.ValueOf(v))
992	case isUint(t):
993		n.rval.SetUint(vUint(v0) % vUint(v1))
994	case isInt(t):
995		n.rval.SetInt(vInt(v0) % vInt(v1))
996	}
997}
998
999func shl(n *node) {
1000	next := getExec(n.tnext)
1001	typ := n.typ.concrete().TypeOf()
1002	isInterface := n.typ.TypeOf().Kind() == reflect.Interface
1003	dest := genValueOutput(n, typ)
1004	c0, c1 := n.child[0], n.child[1]
1005
1006	switch typ.Kind() {
1007	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1008		switch {
1009		case isInterface:
1010			v0 := genValueInt(c0)
1011			v1 := genValueUint(c1)
1012			n.exec = func(f *frame) bltn {
1013				_, i := v0(f)
1014				_, j := v1(f)
1015				dest(f).Set(reflect.ValueOf(i << j).Convert(typ))
1016				return next
1017			}
1018		case c0.rval.IsValid():
1019			i := vInt(c0.rval)
1020			v1 := genValueUint(c1)
1021			n.exec = func(f *frame) bltn {
1022				_, j := v1(f)
1023				dest(f).SetInt(i << j)
1024				return next
1025			}
1026		case c1.rval.IsValid():
1027			v0 := genValueInt(c0)
1028			j := vUint(c1.rval)
1029			n.exec = func(f *frame) bltn {
1030				_, i := v0(f)
1031				dest(f).SetInt(i << j)
1032				return next
1033			}
1034		default:
1035			v0 := genValueInt(c0)
1036			v1 := genValueUint(c1)
1037			n.exec = func(f *frame) bltn {
1038				_, i := v0(f)
1039				_, j := v1(f)
1040				dest(f).SetInt(i << j)
1041				return next
1042			}
1043		}
1044	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1045		switch {
1046		case isInterface:
1047			v0 := genValueUint(c0)
1048			v1 := genValueUint(c1)
1049			n.exec = func(f *frame) bltn {
1050				_, i := v0(f)
1051				_, j := v1(f)
1052				dest(f).Set(reflect.ValueOf(i << j).Convert(typ))
1053				return next
1054			}
1055		case c0.rval.IsValid():
1056			i := vUint(c0.rval)
1057			v1 := genValueUint(c1)
1058			n.exec = func(f *frame) bltn {
1059				_, j := v1(f)
1060				dest(f).SetUint(i << j)
1061				return next
1062			}
1063		case c1.rval.IsValid():
1064			j := vUint(c1.rval)
1065			v0 := genValueUint(c0)
1066			n.exec = func(f *frame) bltn {
1067				_, i := v0(f)
1068				dest(f).SetUint(i << j)
1069				return next
1070			}
1071		default:
1072			v0 := genValueUint(c0)
1073			v1 := genValueUint(c1)
1074			n.exec = func(f *frame) bltn {
1075				_, i := v0(f)
1076				_, j := v1(f)
1077				dest(f).SetUint(i << j)
1078				return next
1079			}
1080		}
1081	}
1082}
1083
1084func shlConst(n *node) {
1085	v0, v1 := n.child[0].rval, n.child[1].rval
1086	isConst := (v0.IsValid() && isConstantValue(v0.Type()))
1087	t := n.typ.rtype
1088	if isConst {
1089		t = constVal
1090	}
1091	n.rval = reflect.New(t).Elem()
1092	switch {
1093	case isConst:
1094		v := constant.Shift(vConstantValue(v0), token.SHL, uint(vUint(v1)))
1095		n.rval.Set(reflect.ValueOf(v))
1096	case isUint(t):
1097		n.rval.SetUint(vUint(v0) << vUint(v1))
1098	case isInt(t):
1099		n.rval.SetInt(vInt(v0) << vUint(v1))
1100	}
1101}
1102
1103func shr(n *node) {
1104	next := getExec(n.tnext)
1105	typ := n.typ.concrete().TypeOf()
1106	isInterface := n.typ.TypeOf().Kind() == reflect.Interface
1107	dest := genValueOutput(n, typ)
1108	c0, c1 := n.child[0], n.child[1]
1109
1110	switch typ.Kind() {
1111	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1112		switch {
1113		case isInterface:
1114			v0 := genValueInt(c0)
1115			v1 := genValueUint(c1)
1116			n.exec = func(f *frame) bltn {
1117				_, i := v0(f)
1118				_, j := v1(f)
1119				dest(f).Set(reflect.ValueOf(i >> j).Convert(typ))
1120				return next
1121			}
1122		case c0.rval.IsValid():
1123			i := vInt(c0.rval)
1124			v1 := genValueUint(c1)
1125			n.exec = func(f *frame) bltn {
1126				_, j := v1(f)
1127				dest(f).SetInt(i >> j)
1128				return next
1129			}
1130		case c1.rval.IsValid():
1131			v0 := genValueInt(c0)
1132			j := vUint(c1.rval)
1133			n.exec = func(f *frame) bltn {
1134				_, i := v0(f)
1135				dest(f).SetInt(i >> j)
1136				return next
1137			}
1138		default:
1139			v0 := genValueInt(c0)
1140			v1 := genValueUint(c1)
1141			n.exec = func(f *frame) bltn {
1142				_, i := v0(f)
1143				_, j := v1(f)
1144				dest(f).SetInt(i >> j)
1145				return next
1146			}
1147		}
1148	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1149		switch {
1150		case isInterface:
1151			v0 := genValueUint(c0)
1152			v1 := genValueUint(c1)
1153			n.exec = func(f *frame) bltn {
1154				_, i := v0(f)
1155				_, j := v1(f)
1156				dest(f).Set(reflect.ValueOf(i >> j).Convert(typ))
1157				return next
1158			}
1159		case c0.rval.IsValid():
1160			i := vUint(c0.rval)
1161			v1 := genValueUint(c1)
1162			n.exec = func(f *frame) bltn {
1163				_, j := v1(f)
1164				dest(f).SetUint(i >> j)
1165				return next
1166			}
1167		case c1.rval.IsValid():
1168			j := vUint(c1.rval)
1169			v0 := genValueUint(c0)
1170			n.exec = func(f *frame) bltn {
1171				_, i := v0(f)
1172				dest(f).SetUint(i >> j)
1173				return next
1174			}
1175		default:
1176			v0 := genValueUint(c0)
1177			v1 := genValueUint(c1)
1178			n.exec = func(f *frame) bltn {
1179				_, i := v0(f)
1180				_, j := v1(f)
1181				dest(f).SetUint(i >> j)
1182				return next
1183			}
1184		}
1185	}
1186}
1187
1188func shrConst(n *node) {
1189	v0, v1 := n.child[0].rval, n.child[1].rval
1190	isConst := (v0.IsValid() && isConstantValue(v0.Type()))
1191	t := n.typ.rtype
1192	if isConst {
1193		t = constVal
1194	}
1195	n.rval = reflect.New(t).Elem()
1196	switch {
1197	case isConst:
1198		v := constant.Shift(vConstantValue(v0), token.SHR, uint(vUint(v1)))
1199		n.rval.Set(reflect.ValueOf(v))
1200	case isUint(t):
1201		n.rval.SetUint(vUint(v0) >> vUint(v1))
1202	case isInt(t):
1203		n.rval.SetInt(vInt(v0) >> vUint(v1))
1204	}
1205}
1206
1207func sub(n *node) {
1208	next := getExec(n.tnext)
1209	typ := n.typ.concrete().TypeOf()
1210	isInterface := n.typ.TypeOf().Kind() == reflect.Interface
1211	dest := genValueOutput(n, typ)
1212	c0, c1 := n.child[0], n.child[1]
1213
1214	switch typ.Kind() {
1215	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1216		switch {
1217		case isInterface:
1218			v0 := genValueInt(c0)
1219			v1 := genValueInt(c1)
1220			n.exec = func(f *frame) bltn {
1221				_, i := v0(f)
1222				_, j := v1(f)
1223				dest(f).Set(reflect.ValueOf(i - j).Convert(typ))
1224				return next
1225			}
1226		case c0.rval.IsValid():
1227			i := vInt(c0.rval)
1228			v1 := genValueInt(c1)
1229			n.exec = func(f *frame) bltn {
1230				_, j := v1(f)
1231				dest(f).SetInt(i - j)
1232				return next
1233			}
1234		case c1.rval.IsValid():
1235			v0 := genValueInt(c0)
1236			j := vInt(c1.rval)
1237			n.exec = func(f *frame) bltn {
1238				_, i := v0(f)
1239				dest(f).SetInt(i - j)
1240				return next
1241			}
1242		default:
1243			v0 := genValueInt(c0)
1244			v1 := genValueInt(c1)
1245			n.exec = func(f *frame) bltn {
1246				_, i := v0(f)
1247				_, j := v1(f)
1248				dest(f).SetInt(i - j)
1249				return next
1250			}
1251		}
1252	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1253		switch {
1254		case isInterface:
1255			v0 := genValueUint(c0)
1256			v1 := genValueUint(c1)
1257			n.exec = func(f *frame) bltn {
1258				_, i := v0(f)
1259				_, j := v1(f)
1260				dest(f).Set(reflect.ValueOf(i - j).Convert(typ))
1261				return next
1262			}
1263		case c0.rval.IsValid():
1264			i := vUint(c0.rval)
1265			v1 := genValueUint(c1)
1266			n.exec = func(f *frame) bltn {
1267				_, j := v1(f)
1268				dest(f).SetUint(i - j)
1269				return next
1270			}
1271		case c1.rval.IsValid():
1272			j := vUint(c1.rval)
1273			v0 := genValueUint(c0)
1274			n.exec = func(f *frame) bltn {
1275				_, i := v0(f)
1276				dest(f).SetUint(i - j)
1277				return next
1278			}
1279		default:
1280			v0 := genValueUint(c0)
1281			v1 := genValueUint(c1)
1282			n.exec = func(f *frame) bltn {
1283				_, i := v0(f)
1284				_, j := v1(f)
1285				dest(f).SetUint(i - j)
1286				return next
1287			}
1288		}
1289	case reflect.Float32, reflect.Float64:
1290		switch {
1291		case isInterface:
1292			v0 := genValueFloat(c0)
1293			v1 := genValueFloat(c1)
1294			n.exec = func(f *frame) bltn {
1295				_, i := v0(f)
1296				_, j := v1(f)
1297				dest(f).Set(reflect.ValueOf(i - j).Convert(typ))
1298				return next
1299			}
1300		case c0.rval.IsValid():
1301			i := vFloat(c0.rval)
1302			v1 := genValueFloat(c1)
1303			n.exec = func(f *frame) bltn {
1304				_, j := v1(f)
1305				dest(f).SetFloat(i - j)
1306				return next
1307			}
1308		case c1.rval.IsValid():
1309			j := vFloat(c1.rval)
1310			v0 := genValueFloat(c0)
1311			n.exec = func(f *frame) bltn {
1312				_, i := v0(f)
1313				dest(f).SetFloat(i - j)
1314				return next
1315			}
1316		default:
1317			v0 := genValueFloat(c0)
1318			v1 := genValueFloat(c1)
1319			n.exec = func(f *frame) bltn {
1320				_, i := v0(f)
1321				_, j := v1(f)
1322				dest(f).SetFloat(i - j)
1323				return next
1324			}
1325		}
1326	case reflect.Complex64, reflect.Complex128:
1327		switch {
1328		case isInterface:
1329			v0 := genComplex(c0)
1330			v1 := genComplex(c1)
1331			n.exec = func(f *frame) bltn {
1332				dest(f).Set(reflect.ValueOf(v0(f) - v1(f)).Convert(typ))
1333				return next
1334			}
1335		case c0.rval.IsValid():
1336			r0 := vComplex(c0.rval)
1337			v1 := genComplex(c1)
1338			n.exec = func(f *frame) bltn {
1339				dest(f).SetComplex(r0 - v1(f))
1340				return next
1341			}
1342		case c1.rval.IsValid():
1343			r1 := vComplex(c1.rval)
1344			v0 := genComplex(c0)
1345			n.exec = func(f *frame) bltn {
1346				dest(f).SetComplex(v0(f) - r1)
1347				return next
1348			}
1349		default:
1350			v0 := genComplex(c0)
1351			v1 := genComplex(c1)
1352			n.exec = func(f *frame) bltn {
1353				dest(f).SetComplex(v0(f) - v1(f))
1354				return next
1355			}
1356		}
1357	}
1358}
1359
1360func subConst(n *node) {
1361	v0, v1 := n.child[0].rval, n.child[1].rval
1362	isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
1363	t := n.typ.rtype
1364	if isConst {
1365		t = constVal
1366	}
1367	n.rval = reflect.New(t).Elem()
1368	switch {
1369	case isConst:
1370		v := constant.BinaryOp(vConstantValue(v0), token.SUB, vConstantValue(v1))
1371		n.rval.Set(reflect.ValueOf(v))
1372	case isComplex(t):
1373		n.rval.SetComplex(vComplex(v0) - vComplex(v1))
1374	case isFloat(t):
1375		n.rval.SetFloat(vFloat(v0) - vFloat(v1))
1376	case isUint(t):
1377		n.rval.SetUint(vUint(v0) - vUint(v1))
1378	case isInt(t):
1379		n.rval.SetInt(vInt(v0) - vInt(v1))
1380	}
1381}
1382
1383func xor(n *node) {
1384	next := getExec(n.tnext)
1385	typ := n.typ.concrete().TypeOf()
1386	isInterface := n.typ.TypeOf().Kind() == reflect.Interface
1387	dest := genValueOutput(n, typ)
1388	c0, c1 := n.child[0], n.child[1]
1389
1390	switch typ.Kind() {
1391	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1392		switch {
1393		case isInterface:
1394			v0 := genValueInt(c0)
1395			v1 := genValueInt(c1)
1396			n.exec = func(f *frame) bltn {
1397				_, i := v0(f)
1398				_, j := v1(f)
1399				dest(f).Set(reflect.ValueOf(i ^ j).Convert(typ))
1400				return next
1401			}
1402		case c0.rval.IsValid():
1403			i := vInt(c0.rval)
1404			v1 := genValueInt(c1)
1405			n.exec = func(f *frame) bltn {
1406				_, j := v1(f)
1407				dest(f).SetInt(i ^ j)
1408				return next
1409			}
1410		case c1.rval.IsValid():
1411			v0 := genValueInt(c0)
1412			j := vInt(c1.rval)
1413			n.exec = func(f *frame) bltn {
1414				_, i := v0(f)
1415				dest(f).SetInt(i ^ j)
1416				return next
1417			}
1418		default:
1419			v0 := genValueInt(c0)
1420			v1 := genValueInt(c1)
1421			n.exec = func(f *frame) bltn {
1422				_, i := v0(f)
1423				_, j := v1(f)
1424				dest(f).SetInt(i ^ j)
1425				return next
1426			}
1427		}
1428	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1429		switch {
1430		case isInterface:
1431			v0 := genValueUint(c0)
1432			v1 := genValueUint(c1)
1433			n.exec = func(f *frame) bltn {
1434				_, i := v0(f)
1435				_, j := v1(f)
1436				dest(f).Set(reflect.ValueOf(i ^ j).Convert(typ))
1437				return next
1438			}
1439		case c0.rval.IsValid():
1440			i := vUint(c0.rval)
1441			v1 := genValueUint(c1)
1442			n.exec = func(f *frame) bltn {
1443				_, j := v1(f)
1444				dest(f).SetUint(i ^ j)
1445				return next
1446			}
1447		case c1.rval.IsValid():
1448			j := vUint(c1.rval)
1449			v0 := genValueUint(c0)
1450			n.exec = func(f *frame) bltn {
1451				_, i := v0(f)
1452				dest(f).SetUint(i ^ j)
1453				return next
1454			}
1455		default:
1456			v0 := genValueUint(c0)
1457			v1 := genValueUint(c1)
1458			n.exec = func(f *frame) bltn {
1459				_, i := v0(f)
1460				_, j := v1(f)
1461				dest(f).SetUint(i ^ j)
1462				return next
1463			}
1464		}
1465	}
1466}
1467
1468func xorConst(n *node) {
1469	v0, v1 := n.child[0].rval, n.child[1].rval
1470	isConst := (v0.IsValid() && isConstantValue(v0.Type())) && (v1.IsValid() && isConstantValue(v1.Type()))
1471	t := n.typ.rtype
1472	if isConst {
1473		t = constVal
1474	}
1475	n.rval = reflect.New(t).Elem()
1476	switch {
1477	case isConst:
1478		v := constant.BinaryOp(constant.ToInt(vConstantValue(v0)), token.XOR, constant.ToInt(vConstantValue(v1)))
1479		n.rval.Set(reflect.ValueOf(v))
1480	case isUint(t):
1481		n.rval.SetUint(vUint(v0) ^ vUint(v1))
1482	case isInt(t):
1483		n.rval.SetInt(vInt(v0) ^ vInt(v1))
1484	}
1485}
1486
1487// Assign operators
1488
1489func addAssign(n *node) {
1490	next := getExec(n.tnext)
1491	typ := n.typ.TypeOf()
1492	c0, c1 := n.child[0], n.child[1]
1493	setMap := isMapEntry(c0)
1494	var mapValue, indexValue func(*frame) reflect.Value
1495
1496	if setMap {
1497		mapValue = genValue(c0.child[0])
1498		indexValue = genValue(c0.child[1])
1499	}
1500
1501	if c1.rval.IsValid() {
1502		switch typ.Kind() {
1503		case reflect.String:
1504			v0 := genValueString(c0)
1505			v1 := vString(c1.rval)
1506			n.exec = func(f *frame) bltn {
1507				v, s := v0(f)
1508				v.SetString(s + v1)
1509				if setMap {
1510					mapValue(f).SetMapIndex(indexValue(f), v)
1511				}
1512				return next
1513			}
1514		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1515			v0 := genValueInt(c0)
1516			j := vInt(c1.rval)
1517			n.exec = func(f *frame) bltn {
1518				v, i := v0(f)
1519				v.SetInt(i + j)
1520				if setMap {
1521					mapValue(f).SetMapIndex(indexValue(f), v)
1522				}
1523				return next
1524			}
1525		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1526			v0 := genValueUint(c0)
1527			j := vUint(c1.rval)
1528			n.exec = func(f *frame) bltn {
1529				v, i := v0(f)
1530				v.SetUint(i + j)
1531				if setMap {
1532					mapValue(f).SetMapIndex(indexValue(f), v)
1533				}
1534				return next
1535			}
1536		case reflect.Float32, reflect.Float64:
1537			v0 := genValueFloat(c0)
1538			j := vFloat(c1.rval)
1539			n.exec = func(f *frame) bltn {
1540				v, i := v0(f)
1541				v.SetFloat(i + j)
1542				if setMap {
1543					mapValue(f).SetMapIndex(indexValue(f), v)
1544				}
1545				return next
1546			}
1547		case reflect.Complex64, reflect.Complex128:
1548			v0 := genValue(c0)
1549			v1 := vComplex(c1.rval)
1550			n.exec = func(f *frame) bltn {
1551				v := v0(f)
1552				v.SetComplex(v.Complex() + v1)
1553				if setMap {
1554					mapValue(f).SetMapIndex(indexValue(f), v)
1555				}
1556				return next
1557			}
1558		}
1559	} else {
1560		switch typ.Kind() {
1561		case reflect.String:
1562			v0 := genValueString(c0)
1563			v1 := genValue(c1)
1564			n.exec = func(f *frame) bltn {
1565				v, s := v0(f)
1566				v.SetString(s + v1(f).String())
1567				if setMap {
1568					mapValue(f).SetMapIndex(indexValue(f), v)
1569				}
1570				return next
1571			}
1572		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1573			v0 := genValueInt(c0)
1574			v1 := genValueInt(c1)
1575			n.exec = func(f *frame) bltn {
1576				v, i := v0(f)
1577				_, j := v1(f)
1578				v.SetInt(i + j)
1579				if setMap {
1580					mapValue(f).SetMapIndex(indexValue(f), v)
1581				}
1582				return next
1583			}
1584		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1585			v0 := genValueUint(c0)
1586			v1 := genValueUint(c1)
1587			n.exec = func(f *frame) bltn {
1588				v, i := v0(f)
1589				_, j := v1(f)
1590				v.SetUint(i + j)
1591				if setMap {
1592					mapValue(f).SetMapIndex(indexValue(f), v)
1593				}
1594				return next
1595			}
1596		case reflect.Float32, reflect.Float64:
1597			v0 := genValueFloat(c0)
1598			v1 := genValueFloat(c1)
1599			n.exec = func(f *frame) bltn {
1600				v, i := v0(f)
1601				_, j := v1(f)
1602				v.SetFloat(i + j)
1603				if setMap {
1604					mapValue(f).SetMapIndex(indexValue(f), v)
1605				}
1606				return next
1607			}
1608		case reflect.Complex64, reflect.Complex128:
1609			v0 := genValue(c0)
1610			v1 := genValue(c1)
1611			n.exec = func(f *frame) bltn {
1612				v := v0(f)
1613				v.SetComplex(v.Complex() + v1(f).Complex())
1614				if setMap {
1615					mapValue(f).SetMapIndex(indexValue(f), v)
1616				}
1617				return next
1618			}
1619		}
1620	}
1621}
1622
1623func andAssign(n *node) {
1624	next := getExec(n.tnext)
1625	typ := n.typ.TypeOf()
1626	c0, c1 := n.child[0], n.child[1]
1627	setMap := isMapEntry(c0)
1628	var mapValue, indexValue func(*frame) reflect.Value
1629
1630	if setMap {
1631		mapValue = genValue(c0.child[0])
1632		indexValue = genValue(c0.child[1])
1633	}
1634
1635	if c1.rval.IsValid() {
1636		switch typ.Kind() {
1637		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1638			v0 := genValueInt(c0)
1639			j := vInt(c1.rval)
1640			n.exec = func(f *frame) bltn {
1641				v, i := v0(f)
1642				v.SetInt(i & j)
1643				if setMap {
1644					mapValue(f).SetMapIndex(indexValue(f), v)
1645				}
1646				return next
1647			}
1648		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1649			v0 := genValueUint(c0)
1650			j := vUint(c1.rval)
1651			n.exec = func(f *frame) bltn {
1652				v, i := v0(f)
1653				v.SetUint(i & j)
1654				if setMap {
1655					mapValue(f).SetMapIndex(indexValue(f), v)
1656				}
1657				return next
1658			}
1659		}
1660	} else {
1661		switch typ.Kind() {
1662		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1663			v0 := genValueInt(c0)
1664			v1 := genValueInt(c1)
1665			n.exec = func(f *frame) bltn {
1666				v, i := v0(f)
1667				_, j := v1(f)
1668				v.SetInt(i & j)
1669				if setMap {
1670					mapValue(f).SetMapIndex(indexValue(f), v)
1671				}
1672				return next
1673			}
1674		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1675			v0 := genValueUint(c0)
1676			v1 := genValueUint(c1)
1677			n.exec = func(f *frame) bltn {
1678				v, i := v0(f)
1679				_, j := v1(f)
1680				v.SetUint(i & j)
1681				if setMap {
1682					mapValue(f).SetMapIndex(indexValue(f), v)
1683				}
1684				return next
1685			}
1686		}
1687	}
1688}
1689
1690func andNotAssign(n *node) {
1691	next := getExec(n.tnext)
1692	typ := n.typ.TypeOf()
1693	c0, c1 := n.child[0], n.child[1]
1694	setMap := isMapEntry(c0)
1695	var mapValue, indexValue func(*frame) reflect.Value
1696
1697	if setMap {
1698		mapValue = genValue(c0.child[0])
1699		indexValue = genValue(c0.child[1])
1700	}
1701
1702	if c1.rval.IsValid() {
1703		switch typ.Kind() {
1704		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1705			v0 := genValueInt(c0)
1706			j := vInt(c1.rval)
1707			n.exec = func(f *frame) bltn {
1708				v, i := v0(f)
1709				v.SetInt(i &^ j)
1710				if setMap {
1711					mapValue(f).SetMapIndex(indexValue(f), v)
1712				}
1713				return next
1714			}
1715		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1716			v0 := genValueUint(c0)
1717			j := vUint(c1.rval)
1718			n.exec = func(f *frame) bltn {
1719				v, i := v0(f)
1720				v.SetUint(i &^ j)
1721				if setMap {
1722					mapValue(f).SetMapIndex(indexValue(f), v)
1723				}
1724				return next
1725			}
1726		}
1727	} else {
1728		switch typ.Kind() {
1729		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1730			v0 := genValueInt(c0)
1731			v1 := genValueInt(c1)
1732			n.exec = func(f *frame) bltn {
1733				v, i := v0(f)
1734				_, j := v1(f)
1735				v.SetInt(i &^ j)
1736				if setMap {
1737					mapValue(f).SetMapIndex(indexValue(f), v)
1738				}
1739				return next
1740			}
1741		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1742			v0 := genValueUint(c0)
1743			v1 := genValueUint(c1)
1744			n.exec = func(f *frame) bltn {
1745				v, i := v0(f)
1746				_, j := v1(f)
1747				v.SetUint(i &^ j)
1748				if setMap {
1749					mapValue(f).SetMapIndex(indexValue(f), v)
1750				}
1751				return next
1752			}
1753		}
1754	}
1755}
1756
1757func mulAssign(n *node) {
1758	next := getExec(n.tnext)
1759	typ := n.typ.TypeOf()
1760	c0, c1 := n.child[0], n.child[1]
1761	setMap := isMapEntry(c0)
1762	var mapValue, indexValue func(*frame) reflect.Value
1763
1764	if setMap {
1765		mapValue = genValue(c0.child[0])
1766		indexValue = genValue(c0.child[1])
1767	}
1768
1769	if c1.rval.IsValid() {
1770		switch typ.Kind() {
1771		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1772			v0 := genValueInt(c0)
1773			j := vInt(c1.rval)
1774			n.exec = func(f *frame) bltn {
1775				v, i := v0(f)
1776				v.SetInt(i * j)
1777				if setMap {
1778					mapValue(f).SetMapIndex(indexValue(f), v)
1779				}
1780				return next
1781			}
1782		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1783			v0 := genValueUint(c0)
1784			j := vUint(c1.rval)
1785			n.exec = func(f *frame) bltn {
1786				v, i := v0(f)
1787				v.SetUint(i * j)
1788				if setMap {
1789					mapValue(f).SetMapIndex(indexValue(f), v)
1790				}
1791				return next
1792			}
1793		case reflect.Float32, reflect.Float64:
1794			v0 := genValueFloat(c0)
1795			j := vFloat(c1.rval)
1796			n.exec = func(f *frame) bltn {
1797				v, i := v0(f)
1798				v.SetFloat(i * j)
1799				if setMap {
1800					mapValue(f).SetMapIndex(indexValue(f), v)
1801				}
1802				return next
1803			}
1804		case reflect.Complex64, reflect.Complex128:
1805			v0 := genValue(c0)
1806			v1 := vComplex(c1.rval)
1807			n.exec = func(f *frame) bltn {
1808				v := v0(f)
1809				v.SetComplex(v.Complex() * v1)
1810				if setMap {
1811					mapValue(f).SetMapIndex(indexValue(f), v)
1812				}
1813				return next
1814			}
1815		}
1816	} else {
1817		switch typ.Kind() {
1818		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1819			v0 := genValueInt(c0)
1820			v1 := genValueInt(c1)
1821			n.exec = func(f *frame) bltn {
1822				v, i := v0(f)
1823				_, j := v1(f)
1824				v.SetInt(i * j)
1825				if setMap {
1826					mapValue(f).SetMapIndex(indexValue(f), v)
1827				}
1828				return next
1829			}
1830		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1831			v0 := genValueUint(c0)
1832			v1 := genValueUint(c1)
1833			n.exec = func(f *frame) bltn {
1834				v, i := v0(f)
1835				_, j := v1(f)
1836				v.SetUint(i * j)
1837				if setMap {
1838					mapValue(f).SetMapIndex(indexValue(f), v)
1839				}
1840				return next
1841			}
1842		case reflect.Float32, reflect.Float64:
1843			v0 := genValueFloat(c0)
1844			v1 := genValueFloat(c1)
1845			n.exec = func(f *frame) bltn {
1846				v, i := v0(f)
1847				_, j := v1(f)
1848				v.SetFloat(i * j)
1849				if setMap {
1850					mapValue(f).SetMapIndex(indexValue(f), v)
1851				}
1852				return next
1853			}
1854		case reflect.Complex64, reflect.Complex128:
1855			v0 := genValue(c0)
1856			v1 := genValue(c1)
1857			n.exec = func(f *frame) bltn {
1858				v := v0(f)
1859				v.SetComplex(v.Complex() * v1(f).Complex())
1860				if setMap {
1861					mapValue(f).SetMapIndex(indexValue(f), v)
1862				}
1863				return next
1864			}
1865		}
1866	}
1867}
1868
1869func orAssign(n *node) {
1870	next := getExec(n.tnext)
1871	typ := n.typ.TypeOf()
1872	c0, c1 := n.child[0], n.child[1]
1873	setMap := isMapEntry(c0)
1874	var mapValue, indexValue func(*frame) reflect.Value
1875
1876	if setMap {
1877		mapValue = genValue(c0.child[0])
1878		indexValue = genValue(c0.child[1])
1879	}
1880
1881	if c1.rval.IsValid() {
1882		switch typ.Kind() {
1883		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1884			v0 := genValueInt(c0)
1885			j := vInt(c1.rval)
1886			n.exec = func(f *frame) bltn {
1887				v, i := v0(f)
1888				v.SetInt(i | j)
1889				if setMap {
1890					mapValue(f).SetMapIndex(indexValue(f), v)
1891				}
1892				return next
1893			}
1894		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1895			v0 := genValueUint(c0)
1896			j := vUint(c1.rval)
1897			n.exec = func(f *frame) bltn {
1898				v, i := v0(f)
1899				v.SetUint(i | j)
1900				if setMap {
1901					mapValue(f).SetMapIndex(indexValue(f), v)
1902				}
1903				return next
1904			}
1905		}
1906	} else {
1907		switch typ.Kind() {
1908		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1909			v0 := genValueInt(c0)
1910			v1 := genValueInt(c1)
1911			n.exec = func(f *frame) bltn {
1912				v, i := v0(f)
1913				_, j := v1(f)
1914				v.SetInt(i | j)
1915				if setMap {
1916					mapValue(f).SetMapIndex(indexValue(f), v)
1917				}
1918				return next
1919			}
1920		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1921			v0 := genValueUint(c0)
1922			v1 := genValueUint(c1)
1923			n.exec = func(f *frame) bltn {
1924				v, i := v0(f)
1925				_, j := v1(f)
1926				v.SetUint(i | j)
1927				if setMap {
1928					mapValue(f).SetMapIndex(indexValue(f), v)
1929				}
1930				return next
1931			}
1932		}
1933	}
1934}
1935
1936func quoAssign(n *node) {
1937	next := getExec(n.tnext)
1938	typ := n.typ.TypeOf()
1939	c0, c1 := n.child[0], n.child[1]
1940	setMap := isMapEntry(c0)
1941	var mapValue, indexValue func(*frame) reflect.Value
1942
1943	if setMap {
1944		mapValue = genValue(c0.child[0])
1945		indexValue = genValue(c0.child[1])
1946	}
1947
1948	if c1.rval.IsValid() {
1949		switch typ.Kind() {
1950		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1951			v0 := genValueInt(c0)
1952			j := vInt(c1.rval)
1953			n.exec = func(f *frame) bltn {
1954				v, i := v0(f)
1955				v.SetInt(i / j)
1956				if setMap {
1957					mapValue(f).SetMapIndex(indexValue(f), v)
1958				}
1959				return next
1960			}
1961		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
1962			v0 := genValueUint(c0)
1963			j := vUint(c1.rval)
1964			n.exec = func(f *frame) bltn {
1965				v, i := v0(f)
1966				v.SetUint(i / j)
1967				if setMap {
1968					mapValue(f).SetMapIndex(indexValue(f), v)
1969				}
1970				return next
1971			}
1972		case reflect.Float32, reflect.Float64:
1973			v0 := genValueFloat(c0)
1974			j := vFloat(c1.rval)
1975			n.exec = func(f *frame) bltn {
1976				v, i := v0(f)
1977				v.SetFloat(i / j)
1978				if setMap {
1979					mapValue(f).SetMapIndex(indexValue(f), v)
1980				}
1981				return next
1982			}
1983		case reflect.Complex64, reflect.Complex128:
1984			v0 := genValue(c0)
1985			v1 := vComplex(c1.rval)
1986			n.exec = func(f *frame) bltn {
1987				v := v0(f)
1988				v.SetComplex(v.Complex() / v1)
1989				if setMap {
1990					mapValue(f).SetMapIndex(indexValue(f), v)
1991				}
1992				return next
1993			}
1994		}
1995	} else {
1996		switch typ.Kind() {
1997		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
1998			v0 := genValueInt(c0)
1999			v1 := genValueInt(c1)
2000			n.exec = func(f *frame) bltn {
2001				v, i := v0(f)
2002				_, j := v1(f)
2003				v.SetInt(i / j)
2004				if setMap {
2005					mapValue(f).SetMapIndex(indexValue(f), v)
2006				}
2007				return next
2008			}
2009		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
2010			v0 := genValueUint(c0)
2011			v1 := genValueUint(c1)
2012			n.exec = func(f *frame) bltn {
2013				v, i := v0(f)
2014				_, j := v1(f)
2015				v.SetUint(i / j)
2016				if setMap {
2017					mapValue(f).SetMapIndex(indexValue(f), v)
2018				}
2019				return next
2020			}
2021		case reflect.Float32, reflect.Float64:
2022			v0 := genValueFloat(c0)
2023			v1 := genValueFloat(c1)
2024			n.exec = func(f *frame) bltn {
2025				v, i := v0(f)
2026				_, j := v1(f)
2027				v.SetFloat(i / j)
2028				if setMap {
2029					mapValue(f).SetMapIndex(indexValue(f), v)
2030				}
2031				return next
2032			}
2033		case reflect.Complex64, reflect.Complex128:
2034			v0 := genValue(c0)
2035			v1 := genValue(c1)
2036			n.exec = func(f *frame) bltn {
2037				v := v0(f)
2038				v.SetComplex(v.Complex() / v1(f).Complex())
2039				if setMap {
2040					mapValue(f).SetMapIndex(indexValue(f), v)
2041				}
2042				return next
2043			}
2044		}
2045	}
2046}
2047
2048func remAssign(n *node) {
2049	next := getExec(n.tnext)
2050	typ := n.typ.TypeOf()
2051	c0, c1 := n.child[0], n.child[1]
2052	setMap := isMapEntry(c0)
2053	var mapValue, indexValue func(*frame) reflect.Value
2054
2055	if setMap {
2056		mapValue = genValue(c0.child[0])
2057		indexValue = genValue(c0.child[1])
2058	}
2059
2060	if c1.rval.IsValid() {
2061		switch typ.Kind() {
2062		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
2063			v0 := genValueInt(c0)
2064			j := vInt(c1.rval)
2065			n.exec = func(f *frame) bltn {
2066				v, i := v0(f)
2067				v.SetInt(i % j)
2068				if setMap {
2069					mapValue(f).SetMapIndex(indexValue(f), v)
2070				}
2071				return next
2072			}
2073		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
2074			v0 := genValueUint(c0)
2075			j := vUint(c1.rval)
2076			n.exec = func(f *frame) bltn {
2077				v, i := v0(f)
2078				v.SetUint(i % j)
2079				if setMap {
2080					mapValue(f).SetMapIndex(indexValue(f), v)
2081				}
2082				return next
2083			}
2084		}
2085	} else {
2086		switch typ.Kind() {
2087		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
2088			v0 := genValueInt(c0)
2089			v1 := genValueInt(c1)
2090			n.exec = func(f *frame) bltn {
2091				v, i := v0(f)
2092				_, j := v1(f)
2093				v.SetInt(i % j)
2094				if setMap {
2095					mapValue(f).SetMapIndex(indexValue(f), v)
2096				}
2097				return next
2098			}
2099		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
2100			v0 := genValueUint(c0)
2101			v1 := genValueUint(c1)
2102			n.exec = func(f *frame) bltn {
2103				v, i := v0(f)
2104				_, j := v1(f)
2105				v.SetUint(i % j)
2106				if setMap {
2107					mapValue(f).SetMapIndex(indexValue(f), v)
2108				}
2109				return next
2110			}
2111		}
2112	}
2113}
2114
2115func shlAssign(n *node) {
2116	next := getExec(n.tnext)
2117	typ := n.typ.TypeOf()
2118	c0, c1 := n.child[0], n.child[1]
2119	setMap := isMapEntry(c0)
2120	var mapValue, indexValue func(*frame) reflect.Value
2121
2122	if setMap {
2123		mapValue = genValue(c0.child[0])
2124		indexValue = genValue(c0.child[1])
2125	}
2126
2127	if c1.rval.IsValid() {
2128		switch typ.Kind() {
2129		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
2130			v0 := genValueInt(c0)
2131			j := vUint(c1.rval)
2132			n.exec = func(f *frame) bltn {
2133				v, i := v0(f)
2134				v.SetInt(i << j)
2135				if setMap {
2136					mapValue(f).SetMapIndex(indexValue(f), v)
2137				}
2138				return next
2139			}
2140		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
2141			v0 := genValueUint(c0)
2142			j := vUint(c1.rval)
2143			n.exec = func(f *frame) bltn {
2144				v, i := v0(f)
2145				v.SetUint(i << j)
2146				if setMap {
2147					mapValue(f).SetMapIndex(indexValue(f), v)
2148				}
2149				return next
2150			}
2151		}
2152	} else {
2153		switch typ.Kind() {
2154		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
2155			v0 := genValueInt(c0)
2156			v1 := genValueUint(c1)
2157			n.exec = func(f *frame) bltn {
2158				v, i := v0(f)
2159				_, j := v1(f)
2160				v.SetInt(i << j)
2161				if setMap {
2162					mapValue(f).SetMapIndex(indexValue(f), v)
2163				}
2164				return next
2165			}
2166		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
2167			v0 := genValueUint(c0)
2168			v1 := genValueUint(c1)
2169			n.exec = func(f *frame) bltn {
2170				v, i := v0(f)
2171				_, j := v1(f)
2172				v.SetUint(i << j)
2173				if setMap {
2174					mapValue(f).SetMapIndex(indexValue(f), v)
2175				}
2176				return next
2177			}
2178		}
2179	}
2180}
2181
2182func shrAssign(n *node) {
2183	next := getExec(n.tnext)
2184	typ := n.typ.TypeOf()
2185	c0, c1 := n.child[0], n.child[1]
2186	setMap := isMapEntry(c0)
2187	var mapValue, indexValue func(*frame) reflect.Value
2188
2189	if setMap {
2190		mapValue = genValue(c0.child[0])
2191		indexValue = genValue(c0.child[1])
2192	}
2193
2194	if c1.rval.IsValid() {
2195		switch typ.Kind() {
2196		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
2197			v0 := genValueInt(c0)
2198			j := vUint(c1.rval)
2199			n.exec = func(f *frame) bltn {
2200				v, i := v0(f)
2201				v.SetInt(i >> j)
2202				if setMap {
2203					mapValue(f).SetMapIndex(indexValue(f), v)
2204				}
2205				return next
2206			}
2207		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
2208			v0 := genValueUint(c0)
2209			j := vUint(c1.rval)
2210			n.exec = func(f *frame) bltn {
2211				v, i := v0(f)
2212				v.SetUint(i >> j)
2213				if setMap {
2214					mapValue(f).SetMapIndex(indexValue(f), v)
2215				}
2216				return next
2217			}
2218		}
2219	} else {
2220		switch typ.Kind() {
2221		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
2222			v0 := genValueInt(c0)
2223			v1 := genValueUint(c1)
2224			n.exec = func(f *frame) bltn {
2225				v, i := v0(f)
2226				_, j := v1(f)
2227				v.SetInt(i >> j)
2228				if setMap {
2229					mapValue(f).SetMapIndex(indexValue(f), v)
2230				}
2231				return next
2232			}
2233		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
2234			v0 := genValueUint(c0)
2235			v1 := genValueUint(c1)
2236			n.exec = func(f *frame) bltn {
2237				v, i := v0(f)
2238				_, j := v1(f)
2239				v.SetUint(i >> j)
2240				if setMap {
2241					mapValue(f).SetMapIndex(indexValue(f), v)
2242				}
2243				return next
2244			}
2245		}
2246	}
2247}
2248
2249func subAssign(n *node) {
2250	next := getExec(n.tnext)
2251	typ := n.typ.TypeOf()
2252	c0, c1 := n.child[0], n.child[1]
2253	setMap := isMapEntry(c0)
2254	var mapValue, indexValue func(*frame) reflect.Value
2255
2256	if setMap {
2257		mapValue = genValue(c0.child[0])
2258		indexValue = genValue(c0.child[1])
2259	}
2260
2261	if c1.rval.IsValid() {
2262		switch typ.Kind() {
2263		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
2264			v0 := genValueInt(c0)
2265			j := vInt(c1.rval)
2266			n.exec = func(f *frame) bltn {
2267				v, i := v0(f)
2268				v.SetInt(i - j)
2269				if setMap {
2270					mapValue(f).SetMapIndex(indexValue(f), v)
2271				}
2272				return next
2273			}
2274		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
2275			v0 := genValueUint(c0)
2276			j := vUint(c1.rval)
2277			n.exec = func(f *frame) bltn {
2278				v, i := v0(f)
2279				v.SetUint(i - j)
2280				if setMap {
2281					mapValue(f).SetMapIndex(indexValue(f), v)
2282				}
2283				return next
2284			}
2285		case reflect.Float32, reflect.Float64:
2286			v0 := genValueFloat(c0)
2287			j := vFloat(c1.rval)
2288			n.exec = func(f *frame) bltn {
2289				v, i := v0(f)
2290				v.SetFloat(i - j)
2291				if setMap {
2292					mapValue(f).SetMapIndex(indexValue(f), v)
2293				}
2294				return next
2295			}
2296		case reflect.Complex64, reflect.Complex128:
2297			v0 := genValue(c0)
2298			v1 := vComplex(c1.rval)
2299			n.exec = func(f *frame) bltn {
2300				v := v0(f)
2301				v.SetComplex(v.Complex() - v1)
2302				if setMap {
2303					mapValue(f).SetMapIndex(indexValue(f), v)
2304				}
2305				return next
2306			}
2307		}
2308	} else {
2309		switch typ.Kind() {
2310		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
2311			v0 := genValueInt(c0)
2312			v1 := genValueInt(c1)
2313			n.exec = func(f *frame) bltn {
2314				v, i := v0(f)
2315				_, j := v1(f)
2316				v.SetInt(i - j)
2317				if setMap {
2318					mapValue(f).SetMapIndex(indexValue(f), v)
2319				}
2320				return next
2321			}
2322		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
2323			v0 := genValueUint(c0)
2324			v1 := genValueUint(c1)
2325			n.exec = func(f *frame) bltn {
2326				v, i := v0(f)
2327				_, j := v1(f)
2328				v.SetUint(i - j)
2329				if setMap {
2330					mapValue(f).SetMapIndex(indexValue(f), v)
2331				}
2332				return next
2333			}
2334		case reflect.Float32, reflect.Float64:
2335			v0 := genValueFloat(c0)
2336			v1 := genValueFloat(c1)
2337			n.exec = func(f *frame) bltn {
2338				v, i := v0(f)
2339				_, j := v1(f)
2340				v.SetFloat(i - j)
2341				if setMap {
2342					mapValue(f).SetMapIndex(indexValue(f), v)
2343				}
2344				return next
2345			}
2346		case reflect.Complex64, reflect.Complex128:
2347			v0 := genValue(c0)
2348			v1 := genValue(c1)
2349			n.exec = func(f *frame) bltn {
2350				v := v0(f)
2351				v.SetComplex(v.Complex() - v1(f).Complex())
2352				if setMap {
2353					mapValue(f).SetMapIndex(indexValue(f), v)
2354				}
2355				return next
2356			}
2357		}
2358	}
2359}
2360
2361func xorAssign(n *node) {
2362	next := getExec(n.tnext)
2363	typ := n.typ.TypeOf()
2364	c0, c1 := n.child[0], n.child[1]
2365	setMap := isMapEntry(c0)
2366	var mapValue, indexValue func(*frame) reflect.Value
2367
2368	if setMap {
2369		mapValue = genValue(c0.child[0])
2370		indexValue = genValue(c0.child[1])
2371	}
2372
2373	if c1.rval.IsValid() {
2374		switch typ.Kind() {
2375		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
2376			v0 := genValueInt(c0)
2377			j := vInt(c1.rval)
2378			n.exec = func(f *frame) bltn {
2379				v, i := v0(f)
2380				v.SetInt(i ^ j)
2381				if setMap {
2382					mapValue(f).SetMapIndex(indexValue(f), v)
2383				}
2384				return next
2385			}
2386		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
2387			v0 := genValueUint(c0)
2388			j := vUint(c1.rval)
2389			n.exec = func(f *frame) bltn {
2390				v, i := v0(f)
2391				v.SetUint(i ^ j)
2392				if setMap {
2393					mapValue(f).SetMapIndex(indexValue(f), v)
2394				}
2395				return next
2396			}
2397		}
2398	} else {
2399		switch typ.Kind() {
2400		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
2401			v0 := genValueInt(c0)
2402			v1 := genValueInt(c1)
2403			n.exec = func(f *frame) bltn {
2404				v, i := v0(f)
2405				_, j := v1(f)
2406				v.SetInt(i ^ j)
2407				if setMap {
2408					mapValue(f).SetMapIndex(indexValue(f), v)
2409				}
2410				return next
2411			}
2412		case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
2413			v0 := genValueUint(c0)
2414			v1 := genValueUint(c1)
2415			n.exec = func(f *frame) bltn {
2416				v, i := v0(f)
2417				_, j := v1(f)
2418				v.SetUint(i ^ j)
2419				if setMap {
2420					mapValue(f).SetMapIndex(indexValue(f), v)
2421				}
2422				return next
2423			}
2424		}
2425	}
2426}
2427
2428func dec(n *node) {
2429	next := getExec(n.tnext)
2430	typ := n.typ.TypeOf()
2431	c0 := n.child[0]
2432	setMap := isMapEntry(c0)
2433	var mapValue, indexValue func(*frame) reflect.Value
2434
2435	if setMap {
2436		mapValue = genValue(c0.child[0])
2437		indexValue = genValue(c0.child[1])
2438	}
2439
2440	switch typ.Kind() {
2441	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
2442		v0 := genValueInt(c0)
2443		n.exec = func(f *frame) bltn {
2444			v, i := v0(f)
2445			v.SetInt(i - 1)
2446			if setMap {
2447				mapValue(f).SetMapIndex(indexValue(f), v)
2448			}
2449			return next
2450		}
2451	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
2452		v0 := genValueUint(c0)
2453		n.exec = func(f *frame) bltn {
2454			v, i := v0(f)
2455			v.SetUint(i - 1)
2456			if setMap {
2457				mapValue(f).SetMapIndex(indexValue(f), v)
2458			}
2459			return next
2460		}
2461	case reflect.Float32, reflect.Float64:
2462		v0 := genValueFloat(c0)
2463		n.exec = func(f *frame) bltn {
2464			v, i := v0(f)
2465			v.SetFloat(i - 1)
2466			if setMap {
2467				mapValue(f).SetMapIndex(indexValue(f), v)
2468			}
2469			return next
2470		}
2471	case reflect.Complex64, reflect.Complex128:
2472		v0 := genValue(c0)
2473		n.exec = func(f *frame) bltn {
2474			v := v0(f)
2475			v.SetComplex(v.Complex() - 1)
2476			if setMap {
2477				mapValue(f).SetMapIndex(indexValue(f), v)
2478			}
2479			return next
2480		}
2481	}
2482}
2483
2484func inc(n *node) {
2485	next := getExec(n.tnext)
2486	typ := n.typ.TypeOf()
2487	c0 := n.child[0]
2488	setMap := isMapEntry(c0)
2489	var mapValue, indexValue func(*frame) reflect.Value
2490
2491	if setMap {
2492		mapValue = genValue(c0.child[0])
2493		indexValue = genValue(c0.child[1])
2494	}
2495
2496	switch typ.Kind() {
2497	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
2498		v0 := genValueInt(c0)
2499		n.exec = func(f *frame) bltn {
2500			v, i := v0(f)
2501			v.SetInt(i + 1)
2502			if setMap {
2503				mapValue(f).SetMapIndex(indexValue(f), v)
2504			}
2505			return next
2506		}
2507	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
2508		v0 := genValueUint(c0)
2509		n.exec = func(f *frame) bltn {
2510			v, i := v0(f)
2511			v.SetUint(i + 1)
2512			if setMap {
2513				mapValue(f).SetMapIndex(indexValue(f), v)
2514			}
2515			return next
2516		}
2517	case reflect.Float32, reflect.Float64:
2518		v0 := genValueFloat(c0)
2519		n.exec = func(f *frame) bltn {
2520			v, i := v0(f)
2521			v.SetFloat(i + 1)
2522			if setMap {
2523				mapValue(f).SetMapIndex(indexValue(f), v)
2524			}
2525			return next
2526		}
2527	case reflect.Complex64, reflect.Complex128:
2528		v0 := genValue(c0)
2529		n.exec = func(f *frame) bltn {
2530			v := v0(f)
2531			v.SetComplex(v.Complex() + 1)
2532			if setMap {
2533				mapValue(f).SetMapIndex(indexValue(f), v)
2534			}
2535			return next
2536		}
2537	}
2538}
2539
2540func bitNotConst(n *node) {
2541	v0 := n.child[0].rval
2542	isConst := v0.IsValid() && isConstantValue(v0.Type())
2543	t := n.typ.rtype
2544	if isConst {
2545		t = constVal
2546	}
2547	n.rval = reflect.New(t).Elem()
2548	switch {
2549	case isConst:
2550		v := constant.UnaryOp(token.XOR, vConstantValue(v0), 0)
2551		n.rval.Set(reflect.ValueOf(v))
2552	case isUint(t):
2553		n.rval.SetUint(^v0.Uint())
2554	case isInt(t):
2555		n.rval.SetInt(^v0.Int())
2556	}
2557}
2558
2559func negConst(n *node) {
2560	v0 := n.child[0].rval
2561	isConst := v0.IsValid() && isConstantValue(v0.Type())
2562	t := n.typ.rtype
2563	if isConst {
2564		t = constVal
2565	}
2566	n.rval = reflect.New(t).Elem()
2567	switch {
2568	case isConst:
2569		v := constant.UnaryOp(token.SUB, vConstantValue(v0), 0)
2570		n.rval.Set(reflect.ValueOf(v))
2571	case isUint(t):
2572		n.rval.SetUint(-v0.Uint())
2573	case isInt(t):
2574		n.rval.SetInt(-v0.Int())
2575	case isFloat(t):
2576		n.rval.SetFloat(-v0.Float())
2577	case isComplex(t):
2578		n.rval.SetComplex(-v0.Complex())
2579	}
2580}
2581
2582func notConst(n *node) {
2583	v0 := n.child[0].rval
2584	isConst := v0.IsValid() && isConstantValue(v0.Type())
2585	t := n.typ.rtype
2586	if isConst {
2587		t = constVal
2588	}
2589	n.rval = reflect.New(t).Elem()
2590	if isConst {
2591		v := constant.UnaryOp(token.NOT, vConstantValue(v0), 0)
2592		n.rval.Set(reflect.ValueOf(v))
2593	} else {
2594		n.rval.SetBool(!v0.Bool())
2595	}
2596}
2597
2598func posConst(n *node) {
2599	v0 := n.child[0].rval
2600	isConst := v0.IsValid() && isConstantValue(v0.Type())
2601	t := n.typ.rtype
2602	if isConst {
2603		t = constVal
2604	}
2605	n.rval = reflect.New(t).Elem()
2606	switch {
2607	case isConst:
2608		v := constant.UnaryOp(token.ADD, vConstantValue(v0), 0)
2609		n.rval.Set(reflect.ValueOf(v))
2610	case isUint(t):
2611		n.rval.SetUint(+v0.Uint())
2612	case isInt(t):
2613		n.rval.SetInt(+v0.Int())
2614	case isFloat(t):
2615		n.rval.SetFloat(+v0.Float())
2616	case isComplex(t):
2617		n.rval.SetComplex(+v0.Complex())
2618	}
2619}
2620
2621func equal(n *node) {
2622	tnext := getExec(n.tnext)
2623	dest := genValueOutput(n, reflect.TypeOf(true))
2624	typ := n.typ.concrete().TypeOf()
2625	isInterface := n.typ.TypeOf().Kind() == reflect.Interface
2626	c0, c1 := n.child[0], n.child[1]
2627
2628	if c0.typ.cat == aliasT || c1.typ.cat == aliasT {
2629		switch {
2630		case isInterface:
2631			v0 := genValue(c0)
2632			v1 := genValue(c1)
2633			dest := genValue(n)
2634			n.exec = func(f *frame) bltn {
2635				i0 := v0(f).Interface()
2636				i1 := v1(f).Interface()
2637				dest(f).Set(reflect.ValueOf(i0 == i1).Convert(typ))
2638				return tnext
2639			}
2640		case c0.rval.IsValid():
2641			i0 := c0.rval.Interface()
2642			v1 := genValue(c1)
2643			if n.fnext != nil {
2644				fnext := getExec(n.fnext)
2645				n.exec = func(f *frame) bltn {
2646					i1 := v1(f).Interface()
2647					if i0 == i1 {
2648						dest(f).SetBool(true)
2649						return tnext
2650					}
2651					dest(f).SetBool(false)
2652					return fnext
2653				}
2654			} else {
2655				dest := genValue(n)
2656				n.exec = func(f *frame) bltn {
2657					i1 := v1(f).Interface()
2658					dest(f).SetBool(i0 == i1)
2659					return tnext
2660				}
2661			}
2662		case c1.rval.IsValid():
2663			i1 := c1.rval.Interface()
2664			v0 := genValue(c0)
2665			if n.fnext != nil {
2666				fnext := getExec(n.fnext)
2667				n.exec = func(f *frame) bltn {
2668					i0 := v0(f).Interface()
2669					if i0 == i1 {
2670						dest(f).SetBool(true)
2671						return tnext
2672					}
2673					dest(f).SetBool(false)
2674					return fnext
2675				}
2676			} else {
2677				dest := genValue(n)
2678				n.exec = func(f *frame) bltn {
2679					i0 := v0(f).Interface()
2680					dest(f).SetBool(i0 == i1)
2681					return tnext
2682				}
2683			}
2684		default:
2685			v0 := genValue(c0)
2686			v1 := genValue(c1)
2687			if n.fnext != nil {
2688				fnext := getExec(n.fnext)
2689				n.exec = func(f *frame) bltn {
2690					i0 := v0(f).Interface()
2691					i1 := v1(f).Interface()
2692					if i0 == i1 {
2693						dest(f).SetBool(true)
2694						return tnext
2695					}
2696					dest(f).SetBool(false)
2697					return fnext
2698				}
2699			} else {
2700				dest := genValue(n)
2701				n.exec = func(f *frame) bltn {
2702					i0 := v0(f).Interface()
2703					i1 := v1(f).Interface()
2704					dest(f).SetBool(i0 == i1)
2705					return tnext
2706				}
2707			}
2708		}
2709		return
2710	}
2711
2712	switch t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf(); {
2713	case isString(t0) || isString(t1):
2714		switch {
2715		case isInterface:
2716			v0 := genValueString(c0)
2717			v1 := genValueString(c1)
2718			n.exec = func(f *frame) bltn {
2719				_, s0 := v0(f)
2720				_, s1 := v1(f)
2721				dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ))
2722				return tnext
2723			}
2724		case c0.rval.IsValid():
2725			s0 := vString(c0.rval)
2726			v1 := genValueString(c1)
2727			if n.fnext != nil {
2728				fnext := getExec(n.fnext)
2729				n.exec = func(f *frame) bltn {
2730					_, s1 := v1(f)
2731					if s0 == s1 {
2732						dest(f).SetBool(true)
2733						return tnext
2734					}
2735					dest(f).SetBool(false)
2736					return fnext
2737				}
2738			} else {
2739				n.exec = func(f *frame) bltn {
2740					_, s1 := v1(f)
2741					dest(f).SetBool(s0 == s1)
2742					return tnext
2743				}
2744			}
2745		case c1.rval.IsValid():
2746			s1 := vString(c1.rval)
2747			v0 := genValueString(c0)
2748			if n.fnext != nil {
2749				fnext := getExec(n.fnext)
2750				n.exec = func(f *frame) bltn {
2751					_, s0 := v0(f)
2752					if s0 == s1 {
2753						dest(f).SetBool(true)
2754						return tnext
2755					}
2756					dest(f).SetBool(false)
2757					return fnext
2758				}
2759			} else {
2760				n.exec = func(f *frame) bltn {
2761					_, s0 := v0(f)
2762					dest(f).SetBool(s0 == s1)
2763					return tnext
2764				}
2765			}
2766		default:
2767			v0 := genValueString(c0)
2768			v1 := genValueString(c1)
2769			if n.fnext != nil {
2770				fnext := getExec(n.fnext)
2771				n.exec = func(f *frame) bltn {
2772					_, s0 := v0(f)
2773					_, s1 := v1(f)
2774					if s0 == s1 {
2775						dest(f).SetBool(true)
2776						return tnext
2777					}
2778					dest(f).SetBool(false)
2779					return fnext
2780				}
2781			} else {
2782				n.exec = func(f *frame) bltn {
2783					_, s0 := v0(f)
2784					_, s1 := v1(f)
2785					dest(f).SetBool(s0 == s1)
2786					return tnext
2787				}
2788			}
2789		}
2790	case isFloat(t0) || isFloat(t1):
2791		switch {
2792		case isInterface:
2793			v0 := genValueFloat(c0)
2794			v1 := genValueFloat(c1)
2795			n.exec = func(f *frame) bltn {
2796				_, s0 := v0(f)
2797				_, s1 := v1(f)
2798				dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ))
2799				return tnext
2800			}
2801		case c0.rval.IsValid():
2802			s0 := vFloat(c0.rval)
2803			v1 := genValueFloat(c1)
2804			if n.fnext != nil {
2805				fnext := getExec(n.fnext)
2806				n.exec = func(f *frame) bltn {
2807					_, s1 := v1(f)
2808					if s0 == s1 {
2809						dest(f).SetBool(true)
2810						return tnext
2811					}
2812					dest(f).SetBool(false)
2813					return fnext
2814				}
2815			} else {
2816				n.exec = func(f *frame) bltn {
2817					_, s1 := v1(f)
2818					dest(f).SetBool(s0 == s1)
2819					return tnext
2820				}
2821			}
2822		case c1.rval.IsValid():
2823			s1 := vFloat(c1.rval)
2824			v0 := genValueFloat(c0)
2825			if n.fnext != nil {
2826				fnext := getExec(n.fnext)
2827				n.exec = func(f *frame) bltn {
2828					_, s0 := v0(f)
2829					if s0 == s1 {
2830						dest(f).SetBool(true)
2831						return tnext
2832					}
2833					dest(f).SetBool(false)
2834					return fnext
2835				}
2836			} else {
2837				dest := genValue(n)
2838				n.exec = func(f *frame) bltn {
2839					_, s0 := v0(f)
2840					dest(f).SetBool(s0 == s1)
2841					return tnext
2842				}
2843			}
2844		default:
2845			v0 := genValueFloat(c0)
2846			v1 := genValueFloat(c1)
2847			if n.fnext != nil {
2848				fnext := getExec(n.fnext)
2849				n.exec = func(f *frame) bltn {
2850					_, s0 := v0(f)
2851					_, s1 := v1(f)
2852					if s0 == s1 {
2853						dest(f).SetBool(true)
2854						return tnext
2855					}
2856					dest(f).SetBool(false)
2857					return fnext
2858				}
2859			} else {
2860				dest := genValue(n)
2861				n.exec = func(f *frame) bltn {
2862					_, s0 := v0(f)
2863					_, s1 := v1(f)
2864					dest(f).SetBool(s0 == s1)
2865					return tnext
2866				}
2867			}
2868		}
2869	case isUint(t0) || isUint(t1):
2870		switch {
2871		case isInterface:
2872			v0 := genValueUint(c0)
2873			v1 := genValueUint(c1)
2874			n.exec = func(f *frame) bltn {
2875				_, s0 := v0(f)
2876				_, s1 := v1(f)
2877				dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ))
2878				return tnext
2879			}
2880		case c0.rval.IsValid():
2881			s0 := vUint(c0.rval)
2882			v1 := genValueUint(c1)
2883			if n.fnext != nil {
2884				fnext := getExec(n.fnext)
2885				n.exec = func(f *frame) bltn {
2886					_, s1 := v1(f)
2887					if s0 == s1 {
2888						dest(f).SetBool(true)
2889						return tnext
2890					}
2891					dest(f).SetBool(false)
2892					return fnext
2893				}
2894			} else {
2895				dest := genValue(n)
2896				n.exec = func(f *frame) bltn {
2897					_, s1 := v1(f)
2898					dest(f).SetBool(s0 == s1)
2899					return tnext
2900				}
2901			}
2902		case c1.rval.IsValid():
2903			s1 := vUint(c1.rval)
2904			v0 := genValueUint(c0)
2905			if n.fnext != nil {
2906				fnext := getExec(n.fnext)
2907				n.exec = func(f *frame) bltn {
2908					_, s0 := v0(f)
2909					if s0 == s1 {
2910						dest(f).SetBool(true)
2911						return tnext
2912					}
2913					dest(f).SetBool(false)
2914					return fnext
2915				}
2916			} else {
2917				dest := genValue(n)
2918				n.exec = func(f *frame) bltn {
2919					_, s0 := v0(f)
2920					dest(f).SetBool(s0 == s1)
2921					return tnext
2922				}
2923			}
2924		default:
2925			v0 := genValueUint(c0)
2926			v1 := genValueUint(c1)
2927			if n.fnext != nil {
2928				fnext := getExec(n.fnext)
2929				n.exec = func(f *frame) bltn {
2930					_, s0 := v0(f)
2931					_, s1 := v1(f)
2932					if s0 == s1 {
2933						dest(f).SetBool(true)
2934						return tnext
2935					}
2936					dest(f).SetBool(false)
2937					return fnext
2938				}
2939			} else {
2940				dest := genValue(n)
2941				n.exec = func(f *frame) bltn {
2942					_, s0 := v0(f)
2943					_, s1 := v1(f)
2944					dest(f).SetBool(s0 == s1)
2945					return tnext
2946				}
2947			}
2948		}
2949	case isInt(t0) || isInt(t1):
2950		switch {
2951		case isInterface:
2952			v0 := genValueInt(c0)
2953			v1 := genValueInt(c1)
2954			n.exec = func(f *frame) bltn {
2955				_, s0 := v0(f)
2956				_, s1 := v1(f)
2957				dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ))
2958				return tnext
2959			}
2960		case c0.rval.IsValid():
2961			s0 := vInt(c0.rval)
2962			v1 := genValueInt(c1)
2963			if n.fnext != nil {
2964				fnext := getExec(n.fnext)
2965				n.exec = func(f *frame) bltn {
2966					_, s1 := v1(f)
2967					if s0 == s1 {
2968						dest(f).SetBool(true)
2969						return tnext
2970					}
2971					dest(f).SetBool(false)
2972					return fnext
2973				}
2974			} else {
2975				dest := genValue(n)
2976				n.exec = func(f *frame) bltn {
2977					_, s1 := v1(f)
2978					dest(f).SetBool(s0 == s1)
2979					return tnext
2980				}
2981			}
2982		case c1.rval.IsValid():
2983			s1 := vInt(c1.rval)
2984			v0 := genValueInt(c0)
2985			if n.fnext != nil {
2986				fnext := getExec(n.fnext)
2987				n.exec = func(f *frame) bltn {
2988					_, s0 := v0(f)
2989					if s0 == s1 {
2990						dest(f).SetBool(true)
2991						return tnext
2992					}
2993					dest(f).SetBool(false)
2994					return fnext
2995				}
2996			} else {
2997				dest := genValue(n)
2998				n.exec = func(f *frame) bltn {
2999					_, s0 := v0(f)
3000					dest(f).SetBool(s0 == s1)
3001					return tnext
3002				}
3003			}
3004		default:
3005			v0 := genValueInt(c0)
3006			v1 := genValueInt(c1)
3007			if n.fnext != nil {
3008				fnext := getExec(n.fnext)
3009				n.exec = func(f *frame) bltn {
3010					_, s0 := v0(f)
3011					_, s1 := v1(f)
3012					if s0 == s1 {
3013						dest(f).SetBool(true)
3014						return tnext
3015					}
3016					dest(f).SetBool(false)
3017					return fnext
3018				}
3019			} else {
3020				dest := genValue(n)
3021				n.exec = func(f *frame) bltn {
3022					_, s0 := v0(f)
3023					_, s1 := v1(f)
3024					dest(f).SetBool(s0 == s1)
3025					return tnext
3026				}
3027			}
3028		}
3029	case isComplex(t0) || isComplex(t1):
3030		switch {
3031		case isInterface:
3032			v0 := genComplex(c0)
3033			v1 := genComplex(c1)
3034			n.exec = func(f *frame) bltn {
3035				s0 := v0(f)
3036				s1 := v1(f)
3037				dest(f).Set(reflect.ValueOf(s0 == s1).Convert(typ))
3038				return tnext
3039			}
3040		case c0.rval.IsValid():
3041			s0 := vComplex(c0.rval)
3042			v1 := genComplex(c1)
3043			if n.fnext != nil {
3044				fnext := getExec(n.fnext)
3045				n.exec = func(f *frame) bltn {
3046					s1 := v1(f)
3047					if s0 == s1 {
3048						dest(f).SetBool(true)
3049						return tnext
3050					}
3051					dest(f).SetBool(false)
3052					return fnext
3053				}
3054			} else {
3055				n.exec = func(f *frame) bltn {
3056					s1 := v1(f)
3057					dest(f).SetBool(s0 == s1)
3058					return tnext
3059				}
3060			}
3061		case c1.rval.IsValid():
3062			s1 := vComplex(c1.rval)
3063			v0 := genComplex(c0)
3064			if n.fnext != nil {
3065				fnext := getExec(n.fnext)
3066				n.exec = func(f *frame) bltn {
3067					s0 := v0(f)
3068					if s0 == s1 {
3069						dest(f).SetBool(true)
3070						return tnext
3071					}
3072					dest(f).SetBool(false)
3073					return fnext
3074				}
3075			} else {
3076				dest := genValue(n)
3077				n.exec = func(f *frame) bltn {
3078					s0 := v0(f)
3079					dest(f).SetBool(s0 == s1)
3080					return tnext
3081				}
3082			}
3083		default:
3084			v0 := genComplex(c0)
3085			v1 := genComplex(c1)
3086			if n.fnext != nil {
3087				fnext := getExec(n.fnext)
3088				n.exec = func(f *frame) bltn {
3089					s0 := v0(f)
3090					s1 := v1(f)
3091					if s0 == s1 {
3092						dest(f).SetBool(true)
3093						return tnext
3094					}
3095					dest(f).SetBool(false)
3096					return fnext
3097				}
3098			} else {
3099				n.exec = func(f *frame) bltn {
3100					s0 := v0(f)
3101					s1 := v1(f)
3102					dest(f).SetBool(s0 == s1)
3103					return tnext
3104				}
3105			}
3106		}
3107	default:
3108		switch {
3109		case isInterface:
3110			v0 := genValue(c0)
3111			v1 := genValue(c1)
3112			n.exec = func(f *frame) bltn {
3113				i0 := v0(f).Interface()
3114				i1 := v1(f).Interface()
3115				dest(f).Set(reflect.ValueOf(i0 == i1).Convert(typ))
3116				return tnext
3117			}
3118		case c0.rval.IsValid():
3119			i0 := c0.rval.Interface()
3120			v1 := genValue(c1)
3121			if n.fnext != nil {
3122				fnext := getExec(n.fnext)
3123				n.exec = func(f *frame) bltn {
3124					i1 := v1(f).Interface()
3125					if i0 == i1 {
3126						dest(f).SetBool(true)
3127						return tnext
3128					}
3129					dest(f).SetBool(false)
3130					return fnext
3131				}
3132			} else {
3133				dest := genValue(n)
3134				n.exec = func(f *frame) bltn {
3135					i1 := v1(f).Interface()
3136					dest(f).SetBool(i0 == i1)
3137					return tnext
3138				}
3139			}
3140		case c1.rval.IsValid():
3141			i1 := c1.rval.Interface()
3142			v0 := genValue(c0)
3143			if n.fnext != nil {
3144				fnext := getExec(n.fnext)
3145				n.exec = func(f *frame) bltn {
3146					i0 := v0(f).Interface()
3147					if i0 == i1 {
3148						dest(f).SetBool(true)
3149						return tnext
3150					}
3151					dest(f).SetBool(false)
3152					return fnext
3153				}
3154			} else {
3155				dest := genValue(n)
3156				n.exec = func(f *frame) bltn {
3157					i0 := v0(f).Interface()
3158					dest(f).SetBool(i0 == i1)
3159					return tnext
3160				}
3161			}
3162		default:
3163			v0 := genValue(c0)
3164			v1 := genValue(c1)
3165			if n.fnext != nil {
3166				fnext := getExec(n.fnext)
3167				n.exec = func(f *frame) bltn {
3168					i0 := v0(f).Interface()
3169					i1 := v1(f).Interface()
3170					if i0 == i1 {
3171						dest(f).SetBool(true)
3172						return tnext
3173					}
3174					dest(f).SetBool(false)
3175					return fnext
3176				}
3177			} else {
3178				dest := genValue(n)
3179				n.exec = func(f *frame) bltn {
3180					i0 := v0(f).Interface()
3181					i1 := v1(f).Interface()
3182					dest(f).SetBool(i0 == i1)
3183					return tnext
3184				}
3185			}
3186		}
3187	}
3188}
3189
3190func greater(n *node) {
3191	tnext := getExec(n.tnext)
3192	dest := genValueOutput(n, reflect.TypeOf(true))
3193	typ := n.typ.concrete().TypeOf()
3194	isInterface := n.typ.TypeOf().Kind() == reflect.Interface
3195	c0, c1 := n.child[0], n.child[1]
3196
3197	switch t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf(); {
3198	case isString(t0) || isString(t1):
3199		switch {
3200		case isInterface:
3201			v0 := genValueString(c0)
3202			v1 := genValueString(c1)
3203			n.exec = func(f *frame) bltn {
3204				_, s0 := v0(f)
3205				_, s1 := v1(f)
3206				dest(f).Set(reflect.ValueOf(s0 > s1).Convert(typ))
3207				return tnext
3208			}
3209		case c0.rval.IsValid():
3210			s0 := vString(c0.rval)
3211			v1 := genValueString(c1)
3212			if n.fnext != nil {
3213				fnext := getExec(n.fnext)
3214				n.exec = func(f *frame) bltn {
3215					_, s1 := v1(f)
3216					if s0 > s1 {
3217						dest(f).SetBool(true)
3218						return tnext
3219					}
3220					dest(f).SetBool(false)
3221					return fnext
3222				}
3223			} else {
3224				n.exec = func(f *frame) bltn {
3225					_, s1 := v1(f)
3226					dest(f).SetBool(s0 > s1)
3227					return tnext
3228				}
3229			}
3230		case c1.rval.IsValid():
3231			s1 := vString(c1.rval)
3232			v0 := genValueString(c0)
3233			if n.fnext != nil {
3234				fnext := getExec(n.fnext)
3235				n.exec = func(f *frame) bltn {
3236					_, s0 := v0(f)
3237					if s0 > s1 {
3238						dest(f).SetBool(true)
3239						return tnext
3240					}
3241					dest(f).SetBool(false)
3242					return fnext
3243				}
3244			} else {
3245				n.exec = func(f *frame) bltn {
3246					_, s0 := v0(f)
3247					dest(f).SetBool(s0 > s1)
3248					return tnext
3249				}
3250			}
3251		default:
3252			v0 := genValueString(c0)
3253			v1 := genValueString(c1)
3254			if n.fnext != nil {
3255				fnext := getExec(n.fnext)
3256				n.exec = func(f *frame) bltn {
3257					_, s0 := v0(f)
3258					_, s1 := v1(f)
3259					if s0 > s1 {
3260						dest(f).SetBool(true)
3261						return tnext
3262					}
3263					dest(f).SetBool(false)
3264					return fnext
3265				}
3266			} else {
3267				n.exec = func(f *frame) bltn {
3268					_, s0 := v0(f)
3269					_, s1 := v1(f)
3270					dest(f).SetBool(s0 > s1)
3271					return tnext
3272				}
3273			}
3274		}
3275	case isFloat(t0) || isFloat(t1):
3276		switch {
3277		case isInterface:
3278			v0 := genValueFloat(c0)
3279			v1 := genValueFloat(c1)
3280			n.exec = func(f *frame) bltn {
3281				_, s0 := v0(f)
3282				_, s1 := v1(f)
3283				dest(f).Set(reflect.ValueOf(s0 > s1).Convert(typ))
3284				return tnext
3285			}
3286		case c0.rval.IsValid():
3287			s0 := vFloat(c0.rval)
3288			v1 := genValueFloat(c1)
3289			if n.fnext != nil {
3290				fnext := getExec(n.fnext)
3291				n.exec = func(f *frame) bltn {
3292					_, s1 := v1(f)
3293					if s0 > s1 {
3294						dest(f).SetBool(true)
3295						return tnext
3296					}
3297					dest(f).SetBool(false)
3298					return fnext
3299				}
3300			} else {
3301				n.exec = func(f *frame) bltn {
3302					_, s1 := v1(f)
3303					dest(f).SetBool(s0 > s1)
3304					return tnext
3305				}
3306			}
3307		case c1.rval.IsValid():
3308			s1 := vFloat(c1.rval)
3309			v0 := genValueFloat(c0)
3310			if n.fnext != nil {
3311				fnext := getExec(n.fnext)
3312				n.exec = func(f *frame) bltn {
3313					_, s0 := v0(f)
3314					if s0 > s1 {
3315						dest(f).SetBool(true)
3316						return tnext
3317					}
3318					dest(f).SetBool(false)
3319					return fnext
3320				}
3321			} else {
3322				dest := genValue(n)
3323				n.exec = func(f *frame) bltn {
3324					_, s0 := v0(f)
3325					dest(f).SetBool(s0 > s1)
3326					return tnext
3327				}
3328			}
3329		default:
3330			v0 := genValueFloat(c0)
3331			v1 := genValueFloat(c1)
3332			if n.fnext != nil {
3333				fnext := getExec(n.fnext)
3334				n.exec = func(f *frame) bltn {
3335					_, s0 := v0(f)
3336					_, s1 := v1(f)
3337					if s0 > s1 {
3338						dest(f).SetBool(true)
3339						return tnext
3340					}
3341					dest(f).SetBool(false)
3342					return fnext
3343				}
3344			} else {
3345				dest := genValue(n)
3346				n.exec = func(f *frame) bltn {
3347					_, s0 := v0(f)
3348					_, s1 := v1(f)
3349					dest(f).SetBool(s0 > s1)
3350					return tnext
3351				}
3352			}
3353		}
3354	case isUint(t0) || isUint(t1):
3355		switch {
3356		case isInterface:
3357			v0 := genValueUint(c0)
3358			v1 := genValueUint(c1)
3359			n.exec = func(f *frame) bltn {
3360				_, s0 := v0(f)
3361				_, s1 := v1(f)
3362				dest(f).Set(reflect.ValueOf(s0 > s1).Convert(typ))
3363				return tnext
3364			}
3365		case c0.rval.IsValid():
3366			s0 := vUint(c0.rval)
3367			v1 := genValueUint(c1)
3368			if n.fnext != nil {
3369				fnext := getExec(n.fnext)
3370				n.exec = func(f *frame) bltn {
3371					_, s1 := v1(f)
3372					if s0 > s1 {
3373						dest(f).SetBool(true)
3374						return tnext
3375					}
3376					dest(f).SetBool(false)
3377					return fnext
3378				}
3379			} else {
3380				dest := genValue(n)
3381				n.exec = func(f *frame) bltn {
3382					_, s1 := v1(f)
3383					dest(f).SetBool(s0 > s1)
3384					return tnext
3385				}
3386			}
3387		case c1.rval.IsValid():
3388			s1 := vUint(c1.rval)
3389			v0 := genValueUint(c0)
3390			if n.fnext != nil {
3391				fnext := getExec(n.fnext)
3392				n.exec = func(f *frame) bltn {
3393					_, s0 := v0(f)
3394					if s0 > s1 {
3395						dest(f).SetBool(true)
3396						return tnext
3397					}
3398					dest(f).SetBool(false)
3399					return fnext
3400				}
3401			} else {
3402				dest := genValue(n)
3403				n.exec = func(f *frame) bltn {
3404					_, s0 := v0(f)
3405					dest(f).SetBool(s0 > s1)
3406					return tnext
3407				}
3408			}
3409		default:
3410			v0 := genValueUint(c0)
3411			v1 := genValueUint(c1)
3412			if n.fnext != nil {
3413				fnext := getExec(n.fnext)
3414				n.exec = func(f *frame) bltn {
3415					_, s0 := v0(f)
3416					_, s1 := v1(f)
3417					if s0 > s1 {
3418						dest(f).SetBool(true)
3419						return tnext
3420					}
3421					dest(f).SetBool(false)
3422					return fnext
3423				}
3424			} else {
3425				dest := genValue(n)
3426				n.exec = func(f *frame) bltn {
3427					_, s0 := v0(f)
3428					_, s1 := v1(f)
3429					dest(f).SetBool(s0 > s1)
3430					return tnext
3431				}
3432			}
3433		}
3434	case isInt(t0) || isInt(t1):
3435		switch {
3436		case isInterface:
3437			v0 := genValueInt(c0)
3438			v1 := genValueInt(c1)
3439			n.exec = func(f *frame) bltn {
3440				_, s0 := v0(f)
3441				_, s1 := v1(f)
3442				dest(f).Set(reflect.ValueOf(s0 > s1).Convert(typ))
3443				return tnext
3444			}
3445		case c0.rval.IsValid():
3446			s0 := vInt(c0.rval)
3447			v1 := genValueInt(c1)
3448			if n.fnext != nil {
3449				fnext := getExec(n.fnext)
3450				n.exec = func(f *frame) bltn {
3451					_, s1 := v1(f)
3452					if s0 > s1 {
3453						dest(f).SetBool(true)
3454						return tnext
3455					}
3456					dest(f).SetBool(false)
3457					return fnext
3458				}
3459			} else {
3460				dest := genValue(n)
3461				n.exec = func(f *frame) bltn {
3462					_, s1 := v1(f)
3463					dest(f).SetBool(s0 > s1)
3464					return tnext
3465				}
3466			}
3467		case c1.rval.IsValid():
3468			s1 := vInt(c1.rval)
3469			v0 := genValueInt(c0)
3470			if n.fnext != nil {
3471				fnext := getExec(n.fnext)
3472				n.exec = func(f *frame) bltn {
3473					_, s0 := v0(f)
3474					if s0 > s1 {
3475						dest(f).SetBool(true)
3476						return tnext
3477					}
3478					dest(f).SetBool(false)
3479					return fnext
3480				}
3481			} else {
3482				dest := genValue(n)
3483				n.exec = func(f *frame) bltn {
3484					_, s0 := v0(f)
3485					dest(f).SetBool(s0 > s1)
3486					return tnext
3487				}
3488			}
3489		default:
3490			v0 := genValueInt(c0)
3491			v1 := genValueInt(c1)
3492			if n.fnext != nil {
3493				fnext := getExec(n.fnext)
3494				n.exec = func(f *frame) bltn {
3495					_, s0 := v0(f)
3496					_, s1 := v1(f)
3497					if s0 > s1 {
3498						dest(f).SetBool(true)
3499						return tnext
3500					}
3501					dest(f).SetBool(false)
3502					return fnext
3503				}
3504			} else {
3505				dest := genValue(n)
3506				n.exec = func(f *frame) bltn {
3507					_, s0 := v0(f)
3508					_, s1 := v1(f)
3509					dest(f).SetBool(s0 > s1)
3510					return tnext
3511				}
3512			}
3513		}
3514	}
3515}
3516
3517func greaterEqual(n *node) {
3518	tnext := getExec(n.tnext)
3519	dest := genValueOutput(n, reflect.TypeOf(true))
3520	typ := n.typ.concrete().TypeOf()
3521	isInterface := n.typ.TypeOf().Kind() == reflect.Interface
3522	c0, c1 := n.child[0], n.child[1]
3523
3524	switch t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf(); {
3525	case isString(t0) || isString(t1):
3526		switch {
3527		case isInterface:
3528			v0 := genValueString(c0)
3529			v1 := genValueString(c1)
3530			n.exec = func(f *frame) bltn {
3531				_, s0 := v0(f)
3532				_, s1 := v1(f)
3533				dest(f).Set(reflect.ValueOf(s0 >= s1).Convert(typ))
3534				return tnext
3535			}
3536		case c0.rval.IsValid():
3537			s0 := vString(c0.rval)
3538			v1 := genValueString(c1)
3539			if n.fnext != nil {
3540				fnext := getExec(n.fnext)
3541				n.exec = func(f *frame) bltn {
3542					_, s1 := v1(f)
3543					if s0 >= s1 {
3544						dest(f).SetBool(true)
3545						return tnext
3546					}
3547					dest(f).SetBool(false)
3548					return fnext
3549				}
3550			} else {
3551				n.exec = func(f *frame) bltn {
3552					_, s1 := v1(f)
3553					dest(f).SetBool(s0 >= s1)
3554					return tnext
3555				}
3556			}
3557		case c1.rval.IsValid():
3558			s1 := vString(c1.rval)
3559			v0 := genValueString(c0)
3560			if n.fnext != nil {
3561				fnext := getExec(n.fnext)
3562				n.exec = func(f *frame) bltn {
3563					_, s0 := v0(f)
3564					if s0 >= s1 {
3565						dest(f).SetBool(true)
3566						return tnext
3567					}
3568					dest(f).SetBool(false)
3569					return fnext
3570				}
3571			} else {
3572				n.exec = func(f *frame) bltn {
3573					_, s0 := v0(f)
3574					dest(f).SetBool(s0 >= s1)
3575					return tnext
3576				}
3577			}
3578		default:
3579			v0 := genValueString(c0)
3580			v1 := genValueString(c1)
3581			if n.fnext != nil {
3582				fnext := getExec(n.fnext)
3583				n.exec = func(f *frame) bltn {
3584					_, s0 := v0(f)
3585					_, s1 := v1(f)
3586					if s0 >= s1 {
3587						dest(f).SetBool(true)
3588						return tnext
3589					}
3590					dest(f).SetBool(false)
3591					return fnext
3592				}
3593			} else {
3594				n.exec = func(f *frame) bltn {
3595					_, s0 := v0(f)
3596					_, s1 := v1(f)
3597					dest(f).SetBool(s0 >= s1)
3598					return tnext
3599				}
3600			}
3601		}
3602	case isFloat(t0) || isFloat(t1):
3603		switch {
3604		case isInterface:
3605			v0 := genValueFloat(c0)
3606			v1 := genValueFloat(c1)
3607			n.exec = func(f *frame) bltn {
3608				_, s0 := v0(f)
3609				_, s1 := v1(f)
3610				dest(f).Set(reflect.ValueOf(s0 >= s1).Convert(typ))
3611				return tnext
3612			}
3613		case c0.rval.IsValid():
3614			s0 := vFloat(c0.rval)
3615			v1 := genValueFloat(c1)
3616			if n.fnext != nil {
3617				fnext := getExec(n.fnext)
3618				n.exec = func(f *frame) bltn {
3619					_, s1 := v1(f)
3620					if s0 >= s1 {
3621						dest(f).SetBool(true)
3622						return tnext
3623					}
3624					dest(f).SetBool(false)
3625					return fnext
3626				}
3627			} else {
3628				n.exec = func(f *frame) bltn {
3629					_, s1 := v1(f)
3630					dest(f).SetBool(s0 >= s1)
3631					return tnext
3632				}
3633			}
3634		case c1.rval.IsValid():
3635			s1 := vFloat(c1.rval)
3636			v0 := genValueFloat(c0)
3637			if n.fnext != nil {
3638				fnext := getExec(n.fnext)
3639				n.exec = func(f *frame) bltn {
3640					_, s0 := v0(f)
3641					if s0 >= s1 {
3642						dest(f).SetBool(true)
3643						return tnext
3644					}
3645					dest(f).SetBool(false)
3646					return fnext
3647				}
3648			} else {
3649				dest := genValue(n)
3650				n.exec = func(f *frame) bltn {
3651					_, s0 := v0(f)
3652					dest(f).SetBool(s0 >= s1)
3653					return tnext
3654				}
3655			}
3656		default:
3657			v0 := genValueFloat(c0)
3658			v1 := genValueFloat(c1)
3659			if n.fnext != nil {
3660				fnext := getExec(n.fnext)
3661				n.exec = func(f *frame) bltn {
3662					_, s0 := v0(f)
3663					_, s1 := v1(f)
3664					if s0 >= s1 {
3665						dest(f).SetBool(true)
3666						return tnext
3667					}
3668					dest(f).SetBool(false)
3669					return fnext
3670				}
3671			} else {
3672				dest := genValue(n)
3673				n.exec = func(f *frame) bltn {
3674					_, s0 := v0(f)
3675					_, s1 := v1(f)
3676					dest(f).SetBool(s0 >= s1)
3677					return tnext
3678				}
3679			}
3680		}
3681	case isUint(t0) || isUint(t1):
3682		switch {
3683		case isInterface:
3684			v0 := genValueUint(c0)
3685			v1 := genValueUint(c1)
3686			n.exec = func(f *frame) bltn {
3687				_, s0 := v0(f)
3688				_, s1 := v1(f)
3689				dest(f).Set(reflect.ValueOf(s0 >= s1).Convert(typ))
3690				return tnext
3691			}
3692		case c0.rval.IsValid():
3693			s0 := vUint(c0.rval)
3694			v1 := genValueUint(c1)
3695			if n.fnext != nil {
3696				fnext := getExec(n.fnext)
3697				n.exec = func(f *frame) bltn {
3698					_, s1 := v1(f)
3699					if s0 >= s1 {
3700						dest(f).SetBool(true)
3701						return tnext
3702					}
3703					dest(f).SetBool(false)
3704					return fnext
3705				}
3706			} else {
3707				dest := genValue(n)
3708				n.exec = func(f *frame) bltn {
3709					_, s1 := v1(f)
3710					dest(f).SetBool(s0 >= s1)
3711					return tnext
3712				}
3713			}
3714		case c1.rval.IsValid():
3715			s1 := vUint(c1.rval)
3716			v0 := genValueUint(c0)
3717			if n.fnext != nil {
3718				fnext := getExec(n.fnext)
3719				n.exec = func(f *frame) bltn {
3720					_, s0 := v0(f)
3721					if s0 >= s1 {
3722						dest(f).SetBool(true)
3723						return tnext
3724					}
3725					dest(f).SetBool(false)
3726					return fnext
3727				}
3728			} else {
3729				dest := genValue(n)
3730				n.exec = func(f *frame) bltn {
3731					_, s0 := v0(f)
3732					dest(f).SetBool(s0 >= s1)
3733					return tnext
3734				}
3735			}
3736		default:
3737			v0 := genValueUint(c0)
3738			v1 := genValueUint(c1)
3739			if n.fnext != nil {
3740				fnext := getExec(n.fnext)
3741				n.exec = func(f *frame) bltn {
3742					_, s0 := v0(f)
3743					_, s1 := v1(f)
3744					if s0 >= s1 {
3745						dest(f).SetBool(true)
3746						return tnext
3747					}
3748					dest(f).SetBool(false)
3749					return fnext
3750				}
3751			} else {
3752				dest := genValue(n)
3753				n.exec = func(f *frame) bltn {
3754					_, s0 := v0(f)
3755					_, s1 := v1(f)
3756					dest(f).SetBool(s0 >= s1)
3757					return tnext
3758				}
3759			}
3760		}
3761	case isInt(t0) || isInt(t1):
3762		switch {
3763		case isInterface:
3764			v0 := genValueInt(c0)
3765			v1 := genValueInt(c1)
3766			n.exec = func(f *frame) bltn {
3767				_, s0 := v0(f)
3768				_, s1 := v1(f)
3769				dest(f).Set(reflect.ValueOf(s0 >= s1).Convert(typ))
3770				return tnext
3771			}
3772		case c0.rval.IsValid():
3773			s0 := vInt(c0.rval)
3774			v1 := genValueInt(c1)
3775			if n.fnext != nil {
3776				fnext := getExec(n.fnext)
3777				n.exec = func(f *frame) bltn {
3778					_, s1 := v1(f)
3779					if s0 >= s1 {
3780						dest(f).SetBool(true)
3781						return tnext
3782					}
3783					dest(f).SetBool(false)
3784					return fnext
3785				}
3786			} else {
3787				dest := genValue(n)
3788				n.exec = func(f *frame) bltn {
3789					_, s1 := v1(f)
3790					dest(f).SetBool(s0 >= s1)
3791					return tnext
3792				}
3793			}
3794		case c1.rval.IsValid():
3795			s1 := vInt(c1.rval)
3796			v0 := genValueInt(c0)
3797			if n.fnext != nil {
3798				fnext := getExec(n.fnext)
3799				n.exec = func(f *frame) bltn {
3800					_, s0 := v0(f)
3801					if s0 >= s1 {
3802						dest(f).SetBool(true)
3803						return tnext
3804					}
3805					dest(f).SetBool(false)
3806					return fnext
3807				}
3808			} else {
3809				dest := genValue(n)
3810				n.exec = func(f *frame) bltn {
3811					_, s0 := v0(f)
3812					dest(f).SetBool(s0 >= s1)
3813					return tnext
3814				}
3815			}
3816		default:
3817			v0 := genValueInt(c0)
3818			v1 := genValueInt(c1)
3819			if n.fnext != nil {
3820				fnext := getExec(n.fnext)
3821				n.exec = func(f *frame) bltn {
3822					_, s0 := v0(f)
3823					_, s1 := v1(f)
3824					if s0 >= s1 {
3825						dest(f).SetBool(true)
3826						return tnext
3827					}
3828					dest(f).SetBool(false)
3829					return fnext
3830				}
3831			} else {
3832				dest := genValue(n)
3833				n.exec = func(f *frame) bltn {
3834					_, s0 := v0(f)
3835					_, s1 := v1(f)
3836					dest(f).SetBool(s0 >= s1)
3837					return tnext
3838				}
3839			}
3840		}
3841	}
3842}
3843
3844func lower(n *node) {
3845	tnext := getExec(n.tnext)
3846	dest := genValueOutput(n, reflect.TypeOf(true))
3847	typ := n.typ.concrete().TypeOf()
3848	isInterface := n.typ.TypeOf().Kind() == reflect.Interface
3849	c0, c1 := n.child[0], n.child[1]
3850
3851	switch t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf(); {
3852	case isString(t0) || isString(t1):
3853		switch {
3854		case isInterface:
3855			v0 := genValueString(c0)
3856			v1 := genValueString(c1)
3857			n.exec = func(f *frame) bltn {
3858				_, s0 := v0(f)
3859				_, s1 := v1(f)
3860				dest(f).Set(reflect.ValueOf(s0 < s1).Convert(typ))
3861				return tnext
3862			}
3863		case c0.rval.IsValid():
3864			s0 := vString(c0.rval)
3865			v1 := genValueString(c1)
3866			if n.fnext != nil {
3867				fnext := getExec(n.fnext)
3868				n.exec = func(f *frame) bltn {
3869					_, s1 := v1(f)
3870					if s0 < s1 {
3871						dest(f).SetBool(true)
3872						return tnext
3873					}
3874					dest(f).SetBool(false)
3875					return fnext
3876				}
3877			} else {
3878				n.exec = func(f *frame) bltn {
3879					_, s1 := v1(f)
3880					dest(f).SetBool(s0 < s1)
3881					return tnext
3882				}
3883			}
3884		case c1.rval.IsValid():
3885			s1 := vString(c1.rval)
3886			v0 := genValueString(c0)
3887			if n.fnext != nil {
3888				fnext := getExec(n.fnext)
3889				n.exec = func(f *frame) bltn {
3890					_, s0 := v0(f)
3891					if s0 < s1 {
3892						dest(f).SetBool(true)
3893						return tnext
3894					}
3895					dest(f).SetBool(false)
3896					return fnext
3897				}
3898			} else {
3899				n.exec = func(f *frame) bltn {
3900					_, s0 := v0(f)
3901					dest(f).SetBool(s0 < s1)
3902					return tnext
3903				}
3904			}
3905		default:
3906			v0 := genValueString(c0)
3907			v1 := genValueString(c1)
3908			if n.fnext != nil {
3909				fnext := getExec(n.fnext)
3910				n.exec = func(f *frame) bltn {
3911					_, s0 := v0(f)
3912					_, s1 := v1(f)
3913					if s0 < s1 {
3914						dest(f).SetBool(true)
3915						return tnext
3916					}
3917					dest(f).SetBool(false)
3918					return fnext
3919				}
3920			} else {
3921				n.exec = func(f *frame) bltn {
3922					_, s0 := v0(f)
3923					_, s1 := v1(f)
3924					dest(f).SetBool(s0 < s1)
3925					return tnext
3926				}
3927			}
3928		}
3929	case isFloat(t0) || isFloat(t1):
3930		switch {
3931		case isInterface:
3932			v0 := genValueFloat(c0)
3933			v1 := genValueFloat(c1)
3934			n.exec = func(f *frame) bltn {
3935				_, s0 := v0(f)
3936				_, s1 := v1(f)
3937				dest(f).Set(reflect.ValueOf(s0 < s1).Convert(typ))
3938				return tnext
3939			}
3940		case c0.rval.IsValid():
3941			s0 := vFloat(c0.rval)
3942			v1 := genValueFloat(c1)
3943			if n.fnext != nil {
3944				fnext := getExec(n.fnext)
3945				n.exec = func(f *frame) bltn {
3946					_, s1 := v1(f)
3947					if s0 < s1 {
3948						dest(f).SetBool(true)
3949						return tnext
3950					}
3951					dest(f).SetBool(false)
3952					return fnext
3953				}
3954			} else {
3955				n.exec = func(f *frame) bltn {
3956					_, s1 := v1(f)
3957					dest(f).SetBool(s0 < s1)
3958					return tnext
3959				}
3960			}
3961		case c1.rval.IsValid():
3962			s1 := vFloat(c1.rval)
3963			v0 := genValueFloat(c0)
3964			if n.fnext != nil {
3965				fnext := getExec(n.fnext)
3966				n.exec = func(f *frame) bltn {
3967					_, s0 := v0(f)
3968					if s0 < s1 {
3969						dest(f).SetBool(true)
3970						return tnext
3971					}
3972					dest(f).SetBool(false)
3973					return fnext
3974				}
3975			} else {
3976				dest := genValue(n)
3977				n.exec = func(f *frame) bltn {
3978					_, s0 := v0(f)
3979					dest(f).SetBool(s0 < s1)
3980					return tnext
3981				}
3982			}
3983		default:
3984			v0 := genValueFloat(c0)
3985			v1 := genValueFloat(c1)
3986			if n.fnext != nil {
3987				fnext := getExec(n.fnext)
3988				n.exec = func(f *frame) bltn {
3989					_, s0 := v0(f)
3990					_, s1 := v1(f)
3991					if s0 < s1 {
3992						dest(f).SetBool(true)
3993						return tnext
3994					}
3995					dest(f).SetBool(false)
3996					return fnext
3997				}
3998			} else {
3999				dest := genValue(n)
4000				n.exec = func(f *frame) bltn {
4001					_, s0 := v0(f)
4002					_, s1 := v1(f)
4003					dest(f).SetBool(s0 < s1)
4004					return tnext
4005				}
4006			}
4007		}
4008	case isUint(t0) || isUint(t1):
4009		switch {
4010		case isInterface:
4011			v0 := genValueUint(c0)
4012			v1 := genValueUint(c1)
4013			n.exec = func(f *frame) bltn {
4014				_, s0 := v0(f)
4015				_, s1 := v1(f)
4016				dest(f).Set(reflect.ValueOf(s0 < s1).Convert(typ))
4017				return tnext
4018			}
4019		case c0.rval.IsValid():
4020			s0 := vUint(c0.rval)
4021			v1 := genValueUint(c1)
4022			if n.fnext != nil {
4023				fnext := getExec(n.fnext)
4024				n.exec = func(f *frame) bltn {
4025					_, s1 := v1(f)
4026					if s0 < s1 {
4027						dest(f).SetBool(true)
4028						return tnext
4029					}
4030					dest(f).SetBool(false)
4031					return fnext
4032				}
4033			} else {
4034				dest := genValue(n)
4035				n.exec = func(f *frame) bltn {
4036					_, s1 := v1(f)
4037					dest(f).SetBool(s0 < s1)
4038					return tnext
4039				}
4040			}
4041		case c1.rval.IsValid():
4042			s1 := vUint(c1.rval)
4043			v0 := genValueUint(c0)
4044			if n.fnext != nil {
4045				fnext := getExec(n.fnext)
4046				n.exec = func(f *frame) bltn {
4047					_, s0 := v0(f)
4048					if s0 < s1 {
4049						dest(f).SetBool(true)
4050						return tnext
4051					}
4052					dest(f).SetBool(false)
4053					return fnext
4054				}
4055			} else {
4056				dest := genValue(n)
4057				n.exec = func(f *frame) bltn {
4058					_, s0 := v0(f)
4059					dest(f).SetBool(s0 < s1)
4060					return tnext
4061				}
4062			}
4063		default:
4064			v0 := genValueUint(c0)
4065			v1 := genValueUint(c1)
4066			if n.fnext != nil {
4067				fnext := getExec(n.fnext)
4068				n.exec = func(f *frame) bltn {
4069					_, s0 := v0(f)
4070					_, s1 := v1(f)
4071					if s0 < s1 {
4072						dest(f).SetBool(true)
4073						return tnext
4074					}
4075					dest(f).SetBool(false)
4076					return fnext
4077				}
4078			} else {
4079				dest := genValue(n)
4080				n.exec = func(f *frame) bltn {
4081					_, s0 := v0(f)
4082					_, s1 := v1(f)
4083					dest(f).SetBool(s0 < s1)
4084					return tnext
4085				}
4086			}
4087		}
4088	case isInt(t0) || isInt(t1):
4089		switch {
4090		case isInterface:
4091			v0 := genValueInt(c0)
4092			v1 := genValueInt(c1)
4093			n.exec = func(f *frame) bltn {
4094				_, s0 := v0(f)
4095				_, s1 := v1(f)
4096				dest(f).Set(reflect.ValueOf(s0 < s1).Convert(typ))
4097				return tnext
4098			}
4099		case c0.rval.IsValid():
4100			s0 := vInt(c0.rval)
4101			v1 := genValueInt(c1)
4102			if n.fnext != nil {
4103				fnext := getExec(n.fnext)
4104				n.exec = func(f *frame) bltn {
4105					_, s1 := v1(f)
4106					if s0 < s1 {
4107						dest(f).SetBool(true)
4108						return tnext
4109					}
4110					dest(f).SetBool(false)
4111					return fnext
4112				}
4113			} else {
4114				dest := genValue(n)
4115				n.exec = func(f *frame) bltn {
4116					_, s1 := v1(f)
4117					dest(f).SetBool(s0 < s1)
4118					return tnext
4119				}
4120			}
4121		case c1.rval.IsValid():
4122			s1 := vInt(c1.rval)
4123			v0 := genValueInt(c0)
4124			if n.fnext != nil {
4125				fnext := getExec(n.fnext)
4126				n.exec = func(f *frame) bltn {
4127					_, s0 := v0(f)
4128					if s0 < s1 {
4129						dest(f).SetBool(true)
4130						return tnext
4131					}
4132					dest(f).SetBool(false)
4133					return fnext
4134				}
4135			} else {
4136				dest := genValue(n)
4137				n.exec = func(f *frame) bltn {
4138					_, s0 := v0(f)
4139					dest(f).SetBool(s0 < s1)
4140					return tnext
4141				}
4142			}
4143		default:
4144			v0 := genValueInt(c0)
4145			v1 := genValueInt(c1)
4146			if n.fnext != nil {
4147				fnext := getExec(n.fnext)
4148				n.exec = func(f *frame) bltn {
4149					_, s0 := v0(f)
4150					_, s1 := v1(f)
4151					if s0 < s1 {
4152						dest(f).SetBool(true)
4153						return tnext
4154					}
4155					dest(f).SetBool(false)
4156					return fnext
4157				}
4158			} else {
4159				dest := genValue(n)
4160				n.exec = func(f *frame) bltn {
4161					_, s0 := v0(f)
4162					_, s1 := v1(f)
4163					dest(f).SetBool(s0 < s1)
4164					return tnext
4165				}
4166			}
4167		}
4168	}
4169}
4170
4171func lowerEqual(n *node) {
4172	tnext := getExec(n.tnext)
4173	dest := genValueOutput(n, reflect.TypeOf(true))
4174	typ := n.typ.concrete().TypeOf()
4175	isInterface := n.typ.TypeOf().Kind() == reflect.Interface
4176	c0, c1 := n.child[0], n.child[1]
4177
4178	switch t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf(); {
4179	case isString(t0) || isString(t1):
4180		switch {
4181		case isInterface:
4182			v0 := genValueString(c0)
4183			v1 := genValueString(c1)
4184			n.exec = func(f *frame) bltn {
4185				_, s0 := v0(f)
4186				_, s1 := v1(f)
4187				dest(f).Set(reflect.ValueOf(s0 <= s1).Convert(typ))
4188				return tnext
4189			}
4190		case c0.rval.IsValid():
4191			s0 := vString(c0.rval)
4192			v1 := genValueString(c1)
4193			if n.fnext != nil {
4194				fnext := getExec(n.fnext)
4195				n.exec = func(f *frame) bltn {
4196					_, s1 := v1(f)
4197					if s0 <= s1 {
4198						dest(f).SetBool(true)
4199						return tnext
4200					}
4201					dest(f).SetBool(false)
4202					return fnext
4203				}
4204			} else {
4205				n.exec = func(f *frame) bltn {
4206					_, s1 := v1(f)
4207					dest(f).SetBool(s0 <= s1)
4208					return tnext
4209				}
4210			}
4211		case c1.rval.IsValid():
4212			s1 := vString(c1.rval)
4213			v0 := genValueString(c0)
4214			if n.fnext != nil {
4215				fnext := getExec(n.fnext)
4216				n.exec = func(f *frame) bltn {
4217					_, s0 := v0(f)
4218					if s0 <= s1 {
4219						dest(f).SetBool(true)
4220						return tnext
4221					}
4222					dest(f).SetBool(false)
4223					return fnext
4224				}
4225			} else {
4226				n.exec = func(f *frame) bltn {
4227					_, s0 := v0(f)
4228					dest(f).SetBool(s0 <= s1)
4229					return tnext
4230				}
4231			}
4232		default:
4233			v0 := genValueString(c0)
4234			v1 := genValueString(c1)
4235			if n.fnext != nil {
4236				fnext := getExec(n.fnext)
4237				n.exec = func(f *frame) bltn {
4238					_, s0 := v0(f)
4239					_, s1 := v1(f)
4240					if s0 <= s1 {
4241						dest(f).SetBool(true)
4242						return tnext
4243					}
4244					dest(f).SetBool(false)
4245					return fnext
4246				}
4247			} else {
4248				n.exec = func(f *frame) bltn {
4249					_, s0 := v0(f)
4250					_, s1 := v1(f)
4251					dest(f).SetBool(s0 <= s1)
4252					return tnext
4253				}
4254			}
4255		}
4256	case isFloat(t0) || isFloat(t1):
4257		switch {
4258		case isInterface:
4259			v0 := genValueFloat(c0)
4260			v1 := genValueFloat(c1)
4261			n.exec = func(f *frame) bltn {
4262				_, s0 := v0(f)
4263				_, s1 := v1(f)
4264				dest(f).Set(reflect.ValueOf(s0 <= s1).Convert(typ))
4265				return tnext
4266			}
4267		case c0.rval.IsValid():
4268			s0 := vFloat(c0.rval)
4269			v1 := genValueFloat(c1)
4270			if n.fnext != nil {
4271				fnext := getExec(n.fnext)
4272				n.exec = func(f *frame) bltn {
4273					_, s1 := v1(f)
4274					if s0 <= s1 {
4275						dest(f).SetBool(true)
4276						return tnext
4277					}
4278					dest(f).SetBool(false)
4279					return fnext
4280				}
4281			} else {
4282				n.exec = func(f *frame) bltn {
4283					_, s1 := v1(f)
4284					dest(f).SetBool(s0 <= s1)
4285					return tnext
4286				}
4287			}
4288		case c1.rval.IsValid():
4289			s1 := vFloat(c1.rval)
4290			v0 := genValueFloat(c0)
4291			if n.fnext != nil {
4292				fnext := getExec(n.fnext)
4293				n.exec = func(f *frame) bltn {
4294					_, s0 := v0(f)
4295					if s0 <= s1 {
4296						dest(f).SetBool(true)
4297						return tnext
4298					}
4299					dest(f).SetBool(false)
4300					return fnext
4301				}
4302			} else {
4303				dest := genValue(n)
4304				n.exec = func(f *frame) bltn {
4305					_, s0 := v0(f)
4306					dest(f).SetBool(s0 <= s1)
4307					return tnext
4308				}
4309			}
4310		default:
4311			v0 := genValueFloat(c0)
4312			v1 := genValueFloat(c1)
4313			if n.fnext != nil {
4314				fnext := getExec(n.fnext)
4315				n.exec = func(f *frame) bltn {
4316					_, s0 := v0(f)
4317					_, s1 := v1(f)
4318					if s0 <= s1 {
4319						dest(f).SetBool(true)
4320						return tnext
4321					}
4322					dest(f).SetBool(false)
4323					return fnext
4324				}
4325			} else {
4326				dest := genValue(n)
4327				n.exec = func(f *frame) bltn {
4328					_, s0 := v0(f)
4329					_, s1 := v1(f)
4330					dest(f).SetBool(s0 <= s1)
4331					return tnext
4332				}
4333			}
4334		}
4335	case isUint(t0) || isUint(t1):
4336		switch {
4337		case isInterface:
4338			v0 := genValueUint(c0)
4339			v1 := genValueUint(c1)
4340			n.exec = func(f *frame) bltn {
4341				_, s0 := v0(f)
4342				_, s1 := v1(f)
4343				dest(f).Set(reflect.ValueOf(s0 <= s1).Convert(typ))
4344				return tnext
4345			}
4346		case c0.rval.IsValid():
4347			s0 := vUint(c0.rval)
4348			v1 := genValueUint(c1)
4349			if n.fnext != nil {
4350				fnext := getExec(n.fnext)
4351				n.exec = func(f *frame) bltn {
4352					_, s1 := v1(f)
4353					if s0 <= s1 {
4354						dest(f).SetBool(true)
4355						return tnext
4356					}
4357					dest(f).SetBool(false)
4358					return fnext
4359				}
4360			} else {
4361				dest := genValue(n)
4362				n.exec = func(f *frame) bltn {
4363					_, s1 := v1(f)
4364					dest(f).SetBool(s0 <= s1)
4365					return tnext
4366				}
4367			}
4368		case c1.rval.IsValid():
4369			s1 := vUint(c1.rval)
4370			v0 := genValueUint(c0)
4371			if n.fnext != nil {
4372				fnext := getExec(n.fnext)
4373				n.exec = func(f *frame) bltn {
4374					_, s0 := v0(f)
4375					if s0 <= s1 {
4376						dest(f).SetBool(true)
4377						return tnext
4378					}
4379					dest(f).SetBool(false)
4380					return fnext
4381				}
4382			} else {
4383				dest := genValue(n)
4384				n.exec = func(f *frame) bltn {
4385					_, s0 := v0(f)
4386					dest(f).SetBool(s0 <= s1)
4387					return tnext
4388				}
4389			}
4390		default:
4391			v0 := genValueUint(c0)
4392			v1 := genValueUint(c1)
4393			if n.fnext != nil {
4394				fnext := getExec(n.fnext)
4395				n.exec = func(f *frame) bltn {
4396					_, s0 := v0(f)
4397					_, s1 := v1(f)
4398					if s0 <= s1 {
4399						dest(f).SetBool(true)
4400						return tnext
4401					}
4402					dest(f).SetBool(false)
4403					return fnext
4404				}
4405			} else {
4406				dest := genValue(n)
4407				n.exec = func(f *frame) bltn {
4408					_, s0 := v0(f)
4409					_, s1 := v1(f)
4410					dest(f).SetBool(s0 <= s1)
4411					return tnext
4412				}
4413			}
4414		}
4415	case isInt(t0) || isInt(t1):
4416		switch {
4417		case isInterface:
4418			v0 := genValueInt(c0)
4419			v1 := genValueInt(c1)
4420			n.exec = func(f *frame) bltn {
4421				_, s0 := v0(f)
4422				_, s1 := v1(f)
4423				dest(f).Set(reflect.ValueOf(s0 <= s1).Convert(typ))
4424				return tnext
4425			}
4426		case c0.rval.IsValid():
4427			s0 := vInt(c0.rval)
4428			v1 := genValueInt(c1)
4429			if n.fnext != nil {
4430				fnext := getExec(n.fnext)
4431				n.exec = func(f *frame) bltn {
4432					_, s1 := v1(f)
4433					if s0 <= s1 {
4434						dest(f).SetBool(true)
4435						return tnext
4436					}
4437					dest(f).SetBool(false)
4438					return fnext
4439				}
4440			} else {
4441				dest := genValue(n)
4442				n.exec = func(f *frame) bltn {
4443					_, s1 := v1(f)
4444					dest(f).SetBool(s0 <= s1)
4445					return tnext
4446				}
4447			}
4448		case c1.rval.IsValid():
4449			s1 := vInt(c1.rval)
4450			v0 := genValueInt(c0)
4451			if n.fnext != nil {
4452				fnext := getExec(n.fnext)
4453				n.exec = func(f *frame) bltn {
4454					_, s0 := v0(f)
4455					if s0 <= s1 {
4456						dest(f).SetBool(true)
4457						return tnext
4458					}
4459					dest(f).SetBool(false)
4460					return fnext
4461				}
4462			} else {
4463				dest := genValue(n)
4464				n.exec = func(f *frame) bltn {
4465					_, s0 := v0(f)
4466					dest(f).SetBool(s0 <= s1)
4467					return tnext
4468				}
4469			}
4470		default:
4471			v0 := genValueInt(c0)
4472			v1 := genValueInt(c1)
4473			if n.fnext != nil {
4474				fnext := getExec(n.fnext)
4475				n.exec = func(f *frame) bltn {
4476					_, s0 := v0(f)
4477					_, s1 := v1(f)
4478					if s0 <= s1 {
4479						dest(f).SetBool(true)
4480						return tnext
4481					}
4482					dest(f).SetBool(false)
4483					return fnext
4484				}
4485			} else {
4486				dest := genValue(n)
4487				n.exec = func(f *frame) bltn {
4488					_, s0 := v0(f)
4489					_, s1 := v1(f)
4490					dest(f).SetBool(s0 <= s1)
4491					return tnext
4492				}
4493			}
4494		}
4495	}
4496}
4497
4498func notEqual(n *node) {
4499	tnext := getExec(n.tnext)
4500	dest := genValueOutput(n, reflect.TypeOf(true))
4501	typ := n.typ.concrete().TypeOf()
4502	isInterface := n.typ.TypeOf().Kind() == reflect.Interface
4503	c0, c1 := n.child[0], n.child[1]
4504
4505	if c0.typ.cat == aliasT || c1.typ.cat == aliasT {
4506		switch {
4507		case isInterface:
4508			v0 := genValue(c0)
4509			v1 := genValue(c1)
4510			dest := genValue(n)
4511			n.exec = func(f *frame) bltn {
4512				i0 := v0(f).Interface()
4513				i1 := v1(f).Interface()
4514				dest(f).Set(reflect.ValueOf(i0 != i1).Convert(typ))
4515				return tnext
4516			}
4517		case c0.rval.IsValid():
4518			i0 := c0.rval.Interface()
4519			v1 := genValue(c1)
4520			if n.fnext != nil {
4521				fnext := getExec(n.fnext)
4522				n.exec = func(f *frame) bltn {
4523					i1 := v1(f).Interface()
4524					if i0 != i1 {
4525						dest(f).SetBool(true)
4526						return tnext
4527					}
4528					dest(f).SetBool(false)
4529					return fnext
4530				}
4531			} else {
4532				dest := genValue(n)
4533				n.exec = func(f *frame) bltn {
4534					i1 := v1(f).Interface()
4535					dest(f).SetBool(i0 != i1)
4536					return tnext
4537				}
4538			}
4539		case c1.rval.IsValid():
4540			i1 := c1.rval.Interface()
4541			v0 := genValue(c0)
4542			if n.fnext != nil {
4543				fnext := getExec(n.fnext)
4544				n.exec = func(f *frame) bltn {
4545					i0 := v0(f).Interface()
4546					if i0 != i1 {
4547						dest(f).SetBool(true)
4548						return tnext
4549					}
4550					dest(f).SetBool(false)
4551					return fnext
4552				}
4553			} else {
4554				dest := genValue(n)
4555				n.exec = func(f *frame) bltn {
4556					i0 := v0(f).Interface()
4557					dest(f).SetBool(i0 != i1)
4558					return tnext
4559				}
4560			}
4561		default:
4562			v0 := genValue(c0)
4563			v1 := genValue(c1)
4564			if n.fnext != nil {
4565				fnext := getExec(n.fnext)
4566				n.exec = func(f *frame) bltn {
4567					i0 := v0(f).Interface()
4568					i1 := v1(f).Interface()
4569					if i0 != i1 {
4570						dest(f).SetBool(true)
4571						return tnext
4572					}
4573					dest(f).SetBool(false)
4574					return fnext
4575				}
4576			} else {
4577				dest := genValue(n)
4578				n.exec = func(f *frame) bltn {
4579					i0 := v0(f).Interface()
4580					i1 := v1(f).Interface()
4581					dest(f).SetBool(i0 != i1)
4582					return tnext
4583				}
4584			}
4585		}
4586		return
4587	}
4588
4589	switch t0, t1 := c0.typ.TypeOf(), c1.typ.TypeOf(); {
4590	case isString(t0) || isString(t1):
4591		switch {
4592		case isInterface:
4593			v0 := genValueString(c0)
4594			v1 := genValueString(c1)
4595			n.exec = func(f *frame) bltn {
4596				_, s0 := v0(f)
4597				_, s1 := v1(f)
4598				dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ))
4599				return tnext
4600			}
4601		case c0.rval.IsValid():
4602			s0 := vString(c0.rval)
4603			v1 := genValueString(c1)
4604			if n.fnext != nil {
4605				fnext := getExec(n.fnext)
4606				n.exec = func(f *frame) bltn {
4607					_, s1 := v1(f)
4608					if s0 != s1 {
4609						dest(f).SetBool(true)
4610						return tnext
4611					}
4612					dest(f).SetBool(false)
4613					return fnext
4614				}
4615			} else {
4616				n.exec = func(f *frame) bltn {
4617					_, s1 := v1(f)
4618					dest(f).SetBool(s0 != s1)
4619					return tnext
4620				}
4621			}
4622		case c1.rval.IsValid():
4623			s1 := vString(c1.rval)
4624			v0 := genValueString(c0)
4625			if n.fnext != nil {
4626				fnext := getExec(n.fnext)
4627				n.exec = func(f *frame) bltn {
4628					_, s0 := v0(f)
4629					if s0 != s1 {
4630						dest(f).SetBool(true)
4631						return tnext
4632					}
4633					dest(f).SetBool(false)
4634					return fnext
4635				}
4636			} else {
4637				n.exec = func(f *frame) bltn {
4638					_, s0 := v0(f)
4639					dest(f).SetBool(s0 != s1)
4640					return tnext
4641				}
4642			}
4643		default:
4644			v0 := genValueString(c0)
4645			v1 := genValueString(c1)
4646			if n.fnext != nil {
4647				fnext := getExec(n.fnext)
4648				n.exec = func(f *frame) bltn {
4649					_, s0 := v0(f)
4650					_, s1 := v1(f)
4651					if s0 != s1 {
4652						dest(f).SetBool(true)
4653						return tnext
4654					}
4655					dest(f).SetBool(false)
4656					return fnext
4657				}
4658			} else {
4659				n.exec = func(f *frame) bltn {
4660					_, s0 := v0(f)
4661					_, s1 := v1(f)
4662					dest(f).SetBool(s0 != s1)
4663					return tnext
4664				}
4665			}
4666		}
4667	case isFloat(t0) || isFloat(t1):
4668		switch {
4669		case isInterface:
4670			v0 := genValueFloat(c0)
4671			v1 := genValueFloat(c1)
4672			n.exec = func(f *frame) bltn {
4673				_, s0 := v0(f)
4674				_, s1 := v1(f)
4675				dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ))
4676				return tnext
4677			}
4678		case c0.rval.IsValid():
4679			s0 := vFloat(c0.rval)
4680			v1 := genValueFloat(c1)
4681			if n.fnext != nil {
4682				fnext := getExec(n.fnext)
4683				n.exec = func(f *frame) bltn {
4684					_, s1 := v1(f)
4685					if s0 != s1 {
4686						dest(f).SetBool(true)
4687						return tnext
4688					}
4689					dest(f).SetBool(false)
4690					return fnext
4691				}
4692			} else {
4693				n.exec = func(f *frame) bltn {
4694					_, s1 := v1(f)
4695					dest(f).SetBool(s0 != s1)
4696					return tnext
4697				}
4698			}
4699		case c1.rval.IsValid():
4700			s1 := vFloat(c1.rval)
4701			v0 := genValueFloat(c0)
4702			if n.fnext != nil {
4703				fnext := getExec(n.fnext)
4704				n.exec = func(f *frame) bltn {
4705					_, s0 := v0(f)
4706					if s0 != s1 {
4707						dest(f).SetBool(true)
4708						return tnext
4709					}
4710					dest(f).SetBool(false)
4711					return fnext
4712				}
4713			} else {
4714				dest := genValue(n)
4715				n.exec = func(f *frame) bltn {
4716					_, s0 := v0(f)
4717					dest(f).SetBool(s0 != s1)
4718					return tnext
4719				}
4720			}
4721		default:
4722			v0 := genValueFloat(c0)
4723			v1 := genValueFloat(c1)
4724			if n.fnext != nil {
4725				fnext := getExec(n.fnext)
4726				n.exec = func(f *frame) bltn {
4727					_, s0 := v0(f)
4728					_, s1 := v1(f)
4729					if s0 != s1 {
4730						dest(f).SetBool(true)
4731						return tnext
4732					}
4733					dest(f).SetBool(false)
4734					return fnext
4735				}
4736			} else {
4737				dest := genValue(n)
4738				n.exec = func(f *frame) bltn {
4739					_, s0 := v0(f)
4740					_, s1 := v1(f)
4741					dest(f).SetBool(s0 != s1)
4742					return tnext
4743				}
4744			}
4745		}
4746	case isUint(t0) || isUint(t1):
4747		switch {
4748		case isInterface:
4749			v0 := genValueUint(c0)
4750			v1 := genValueUint(c1)
4751			n.exec = func(f *frame) bltn {
4752				_, s0 := v0(f)
4753				_, s1 := v1(f)
4754				dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ))
4755				return tnext
4756			}
4757		case c0.rval.IsValid():
4758			s0 := vUint(c0.rval)
4759			v1 := genValueUint(c1)
4760			if n.fnext != nil {
4761				fnext := getExec(n.fnext)
4762				n.exec = func(f *frame) bltn {
4763					_, s1 := v1(f)
4764					if s0 != s1 {
4765						dest(f).SetBool(true)
4766						return tnext
4767					}
4768					dest(f).SetBool(false)
4769					return fnext
4770				}
4771			} else {
4772				dest := genValue(n)
4773				n.exec = func(f *frame) bltn {
4774					_, s1 := v1(f)
4775					dest(f).SetBool(s0 != s1)
4776					return tnext
4777				}
4778			}
4779		case c1.rval.IsValid():
4780			s1 := vUint(c1.rval)
4781			v0 := genValueUint(c0)
4782			if n.fnext != nil {
4783				fnext := getExec(n.fnext)
4784				n.exec = func(f *frame) bltn {
4785					_, s0 := v0(f)
4786					if s0 != s1 {
4787						dest(f).SetBool(true)
4788						return tnext
4789					}
4790					dest(f).SetBool(false)
4791					return fnext
4792				}
4793			} else {
4794				dest := genValue(n)
4795				n.exec = func(f *frame) bltn {
4796					_, s0 := v0(f)
4797					dest(f).SetBool(s0 != s1)
4798					return tnext
4799				}
4800			}
4801		default:
4802			v0 := genValueUint(c0)
4803			v1 := genValueUint(c1)
4804			if n.fnext != nil {
4805				fnext := getExec(n.fnext)
4806				n.exec = func(f *frame) bltn {
4807					_, s0 := v0(f)
4808					_, s1 := v1(f)
4809					if s0 != s1 {
4810						dest(f).SetBool(true)
4811						return tnext
4812					}
4813					dest(f).SetBool(false)
4814					return fnext
4815				}
4816			} else {
4817				dest := genValue(n)
4818				n.exec = func(f *frame) bltn {
4819					_, s0 := v0(f)
4820					_, s1 := v1(f)
4821					dest(f).SetBool(s0 != s1)
4822					return tnext
4823				}
4824			}
4825		}
4826	case isInt(t0) || isInt(t1):
4827		switch {
4828		case isInterface:
4829			v0 := genValueInt(c0)
4830			v1 := genValueInt(c1)
4831			n.exec = func(f *frame) bltn {
4832				_, s0 := v0(f)
4833				_, s1 := v1(f)
4834				dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ))
4835				return tnext
4836			}
4837		case c0.rval.IsValid():
4838			s0 := vInt(c0.rval)
4839			v1 := genValueInt(c1)
4840			if n.fnext != nil {
4841				fnext := getExec(n.fnext)
4842				n.exec = func(f *frame) bltn {
4843					_, s1 := v1(f)
4844					if s0 != s1 {
4845						dest(f).SetBool(true)
4846						return tnext
4847					}
4848					dest(f).SetBool(false)
4849					return fnext
4850				}
4851			} else {
4852				dest := genValue(n)
4853				n.exec = func(f *frame) bltn {
4854					_, s1 := v1(f)
4855					dest(f).SetBool(s0 != s1)
4856					return tnext
4857				}
4858			}
4859		case c1.rval.IsValid():
4860			s1 := vInt(c1.rval)
4861			v0 := genValueInt(c0)
4862			if n.fnext != nil {
4863				fnext := getExec(n.fnext)
4864				n.exec = func(f *frame) bltn {
4865					_, s0 := v0(f)
4866					if s0 != s1 {
4867						dest(f).SetBool(true)
4868						return tnext
4869					}
4870					dest(f).SetBool(false)
4871					return fnext
4872				}
4873			} else {
4874				dest := genValue(n)
4875				n.exec = func(f *frame) bltn {
4876					_, s0 := v0(f)
4877					dest(f).SetBool(s0 != s1)
4878					return tnext
4879				}
4880			}
4881		default:
4882			v0 := genValueInt(c0)
4883			v1 := genValueInt(c1)
4884			if n.fnext != nil {
4885				fnext := getExec(n.fnext)
4886				n.exec = func(f *frame) bltn {
4887					_, s0 := v0(f)
4888					_, s1 := v1(f)
4889					if s0 != s1 {
4890						dest(f).SetBool(true)
4891						return tnext
4892					}
4893					dest(f).SetBool(false)
4894					return fnext
4895				}
4896			} else {
4897				dest := genValue(n)
4898				n.exec = func(f *frame) bltn {
4899					_, s0 := v0(f)
4900					_, s1 := v1(f)
4901					dest(f).SetBool(s0 != s1)
4902					return tnext
4903				}
4904			}
4905		}
4906	case isComplex(t0) || isComplex(t1):
4907		switch {
4908		case isInterface:
4909			v0 := genComplex(c0)
4910			v1 := genComplex(c1)
4911			n.exec = func(f *frame) bltn {
4912				s0 := v0(f)
4913				s1 := v1(f)
4914				dest(f).Set(reflect.ValueOf(s0 != s1).Convert(typ))
4915				return tnext
4916			}
4917		case c0.rval.IsValid():
4918			s0 := vComplex(c0.rval)
4919			v1 := genComplex(c1)
4920			if n.fnext != nil {
4921				fnext := getExec(n.fnext)
4922				n.exec = func(f *frame) bltn {
4923					s1 := v1(f)
4924					if s0 != s1 {
4925						dest(f).SetBool(true)
4926						return tnext
4927					}
4928					dest(f).SetBool(false)
4929					return fnext
4930				}
4931			} else {
4932				n.exec = func(f *frame) bltn {
4933					s1 := v1(f)
4934					dest(f).SetBool(s0 != s1)
4935					return tnext
4936				}
4937			}
4938		case c1.rval.IsValid():
4939			s1 := vComplex(c1.rval)
4940			v0 := genComplex(c0)
4941			if n.fnext != nil {
4942				fnext := getExec(n.fnext)
4943				n.exec = func(f *frame) bltn {
4944					s0 := v0(f)
4945					if s0 != s1 {
4946						dest(f).SetBool(true)
4947						return tnext
4948					}
4949					dest(f).SetBool(false)
4950					return fnext
4951				}
4952			} else {
4953				dest := genValue(n)
4954				n.exec = func(f *frame) bltn {
4955					s0 := v0(f)
4956					dest(f).SetBool(s0 != s1)
4957					return tnext
4958				}
4959			}
4960		default:
4961			v0 := genComplex(c0)
4962			v1 := genComplex(c1)
4963			if n.fnext != nil {
4964				fnext := getExec(n.fnext)
4965				n.exec = func(f *frame) bltn {
4966					s0 := v0(f)
4967					s1 := v1(f)
4968					if s0 != s1 {
4969						dest(f).SetBool(true)
4970						return tnext
4971					}
4972					dest(f).SetBool(false)
4973					return fnext
4974				}
4975			} else {
4976				n.exec = func(f *frame) bltn {
4977					s0 := v0(f)
4978					s1 := v1(f)
4979					dest(f).SetBool(s0 != s1)
4980					return tnext
4981				}
4982			}
4983		}
4984	default:
4985		switch {
4986		case isInterface:
4987			v0 := genValue(c0)
4988			v1 := genValue(c1)
4989			n.exec = func(f *frame) bltn {
4990				i0 := v0(f).Interface()
4991				i1 := v1(f).Interface()
4992				dest(f).Set(reflect.ValueOf(i0 != i1).Convert(typ))
4993				return tnext
4994			}
4995		case c0.rval.IsValid():
4996			i0 := c0.rval.Interface()
4997			v1 := genValue(c1)
4998			if n.fnext != nil {
4999				fnext := getExec(n.fnext)
5000				n.exec = func(f *frame) bltn {
5001					i1 := v1(f).Interface()
5002					if i0 != i1 {
5003						dest(f).SetBool(true)
5004						return tnext
5005					}
5006					dest(f).SetBool(false)
5007					return fnext
5008				}
5009			} else {
5010				dest := genValue(n)
5011				n.exec = func(f *frame) bltn {
5012					i1 := v1(f).Interface()
5013					dest(f).SetBool(i0 != i1)
5014					return tnext
5015				}
5016			}
5017		case c1.rval.IsValid():
5018			i1 := c1.rval.Interface()
5019			v0 := genValue(c0)
5020			if n.fnext != nil {
5021				fnext := getExec(n.fnext)
5022				n.exec = func(f *frame) bltn {
5023					i0 := v0(f).Interface()
5024					if i0 != i1 {
5025						dest(f).SetBool(true)
5026						return tnext
5027					}
5028					dest(f).SetBool(false)
5029					return fnext
5030				}
5031			} else {
5032				dest := genValue(n)
5033				n.exec = func(f *frame) bltn {
5034					i0 := v0(f).Interface()
5035					dest(f).SetBool(i0 != i1)
5036					return tnext
5037				}
5038			}
5039		default:
5040			v0 := genValue(c0)
5041			v1 := genValue(c1)
5042			if n.fnext != nil {
5043				fnext := getExec(n.fnext)
5044				n.exec = func(f *frame) bltn {
5045					i0 := v0(f).Interface()
5046					i1 := v1(f).Interface()
5047					if i0 != i1 {
5048						dest(f).SetBool(true)
5049						return tnext
5050					}
5051					dest(f).SetBool(false)
5052					return fnext
5053				}
5054			} else {
5055				dest := genValue(n)
5056				n.exec = func(f *frame) bltn {
5057					i0 := v0(f).Interface()
5058					i1 := v1(f).Interface()
5059					dest(f).SetBool(i0 != i1)
5060					return tnext
5061				}
5062			}
5063		}
5064	}
5065}
5066