github.com/goplus/igop@v0.25.0/binop.go (about)

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