github.com/switchupcb/yaegi@v0.10.2/interp/op.go (about)

     1  package interp
     2  
     3  // Code generated by 'go run ../internal/cmd/genop/genop.go'. DO NOT EDIT.
     4  
     5  import (
     6  	"go/constant"
     7  	"go/token"
     8  	"reflect"
     9  )
    10  
    11  // Arithmetic operators
    12  
    13  func 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  
   197  func 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  
   222  func 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  
   307  func 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  
   326  func 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  
   411  func 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  
   430  func 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  
   583  func 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  
   606  func 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  
   691  func 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  
   710  func 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  
   863  func 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  
   895  func 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  
   980  func 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  
   999  func 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  
  1084  func 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  
  1103  func 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  
  1188  func 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  
  1207  func 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  
  1360  func 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  
  1383  func 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  
  1468  func 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  
  1489  func 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  
  1623  func 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  
  1690  func 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  
  1757  func 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  
  1869  func 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  
  1936  func 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  
  2048  func 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  
  2115  func 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  
  2182  func 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  
  2249  func 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  
  2361  func 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  
  2428  func 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  
  2484  func 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  
  2540  func 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  
  2559  func 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  
  2582  func 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  
  2598  func 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  
  2621  func 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  
  3190  func 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  
  3517  func 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  
  3844  func 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  
  4171  func 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  
  4498  func 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  }