github.com/cloudwego/iasm@v0.2.0/x86_64/instructions_table.go (about)

     1  //
     2  // Copyright 2024 CloudWeGo Authors
     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  // Code generated by "mkasm_amd64.py", DO NOT EDIT.
    18  
    19  package x86_64
    20  
    21  const (
    22      _N_args  = 5
    23      _N_forms = 23
    24  )
    25  
    26  // Instructions maps all the instruction name to it's encoder function.
    27  var Instructions = map[string]_InstructionEncoder {
    28      "adcb"             : __asm_proxy_ADCB__,
    29      "adcl"             : __asm_proxy_ADCL__,
    30      "adcq"             : __asm_proxy_ADCQ__,
    31      "adcw"             : __asm_proxy_ADCW__,
    32      "adcxl"            : __asm_proxy_ADCXL__,
    33      "adcxq"            : __asm_proxy_ADCXQ__,
    34      "addb"             : __asm_proxy_ADDB__,
    35      "addl"             : __asm_proxy_ADDL__,
    36      "addpd"            : __asm_proxy_ADDPD__,
    37      "addps"            : __asm_proxy_ADDPS__,
    38      "addq"             : __asm_proxy_ADDQ__,
    39      "addsd"            : __asm_proxy_ADDSD__,
    40      "addss"            : __asm_proxy_ADDSS__,
    41      "addsubpd"         : __asm_proxy_ADDSUBPD__,
    42      "addsubps"         : __asm_proxy_ADDSUBPS__,
    43      "addw"             : __asm_proxy_ADDW__,
    44      "adoxl"            : __asm_proxy_ADOXL__,
    45      "adoxq"            : __asm_proxy_ADOXQ__,
    46      "aesdec"           : __asm_proxy_AESDEC__,
    47      "aesdeclast"       : __asm_proxy_AESDECLAST__,
    48      "aesenc"           : __asm_proxy_AESENC__,
    49      "aesenclast"       : __asm_proxy_AESENCLAST__,
    50      "aesimc"           : __asm_proxy_AESIMC__,
    51      "aeskeygenassist"  : __asm_proxy_AESKEYGENASSIST__,
    52      "andb"             : __asm_proxy_ANDB__,
    53      "andl"             : __asm_proxy_ANDL__,
    54      "andnl"            : __asm_proxy_ANDNL__,
    55      "andnpd"           : __asm_proxy_ANDNPD__,
    56      "andnps"           : __asm_proxy_ANDNPS__,
    57      "andnq"            : __asm_proxy_ANDNQ__,
    58      "andpd"            : __asm_proxy_ANDPD__,
    59      "andps"            : __asm_proxy_ANDPS__,
    60      "andq"             : __asm_proxy_ANDQ__,
    61      "andw"             : __asm_proxy_ANDW__,
    62      "bextr"            : __asm_proxy_BEXTR__,
    63      "blcfill"          : __asm_proxy_BLCFILL__,
    64      "blci"             : __asm_proxy_BLCI__,
    65      "blcic"            : __asm_proxy_BLCIC__,
    66      "blcmsk"           : __asm_proxy_BLCMSK__,
    67      "blcs"             : __asm_proxy_BLCS__,
    68      "blendpd"          : __asm_proxy_BLENDPD__,
    69      "blendps"          : __asm_proxy_BLENDPS__,
    70      "blendvpd"         : __asm_proxy_BLENDVPD__,
    71      "blendvps"         : __asm_proxy_BLENDVPS__,
    72      "blsfill"          : __asm_proxy_BLSFILL__,
    73      "blsi"             : __asm_proxy_BLSI__,
    74      "blsic"            : __asm_proxy_BLSIC__,
    75      "blsmsk"           : __asm_proxy_BLSMSK__,
    76      "blsr"             : __asm_proxy_BLSR__,
    77      "bsfl"             : __asm_proxy_BSFL__,
    78      "bsfq"             : __asm_proxy_BSFQ__,
    79      "bsfw"             : __asm_proxy_BSFW__,
    80      "bsrl"             : __asm_proxy_BSRL__,
    81      "bsrq"             : __asm_proxy_BSRQ__,
    82      "bsrw"             : __asm_proxy_BSRW__,
    83      "bswapl"           : __asm_proxy_BSWAPL__,
    84      "bswapq"           : __asm_proxy_BSWAPQ__,
    85      "btcl"             : __asm_proxy_BTCL__,
    86      "btcq"             : __asm_proxy_BTCQ__,
    87      "btcw"             : __asm_proxy_BTCW__,
    88      "btl"              : __asm_proxy_BTL__,
    89      "btq"              : __asm_proxy_BTQ__,
    90      "btrl"             : __asm_proxy_BTRL__,
    91      "btrq"             : __asm_proxy_BTRQ__,
    92      "btrw"             : __asm_proxy_BTRW__,
    93      "btsl"             : __asm_proxy_BTSL__,
    94      "btsq"             : __asm_proxy_BTSQ__,
    95      "btsw"             : __asm_proxy_BTSW__,
    96      "btw"              : __asm_proxy_BTW__,
    97      "bzhi"             : __asm_proxy_BZHI__,
    98      "call"             : __asm_proxy_CALL__,
    99      "callq"            : __asm_proxy_CALLQ__,
   100      "cbtw"             : __asm_proxy_CBTW__,
   101      "clc"              : __asm_proxy_CLC__,
   102      "cld"              : __asm_proxy_CLD__,
   103      "clflush"          : __asm_proxy_CLFLUSH__,
   104      "clflushopt"       : __asm_proxy_CLFLUSHOPT__,
   105      "cltd"             : __asm_proxy_CLTD__,
   106      "cltq"             : __asm_proxy_CLTQ__,
   107      "clwb"             : __asm_proxy_CLWB__,
   108      "clzero"           : __asm_proxy_CLZERO__,
   109      "cmc"              : __asm_proxy_CMC__,
   110      "cmova"            : __asm_proxy_CMOVA__,
   111      "cmovae"           : __asm_proxy_CMOVAE__,
   112      "cmovb"            : __asm_proxy_CMOVB__,
   113      "cmovbe"           : __asm_proxy_CMOVBE__,
   114      "cmovc"            : __asm_proxy_CMOVC__,
   115      "cmove"            : __asm_proxy_CMOVE__,
   116      "cmovg"            : __asm_proxy_CMOVG__,
   117      "cmovge"           : __asm_proxy_CMOVGE__,
   118      "cmovl"            : __asm_proxy_CMOVL__,
   119      "cmovle"           : __asm_proxy_CMOVLE__,
   120      "cmovna"           : __asm_proxy_CMOVNA__,
   121      "cmovnae"          : __asm_proxy_CMOVNAE__,
   122      "cmovnb"           : __asm_proxy_CMOVNB__,
   123      "cmovnbe"          : __asm_proxy_CMOVNBE__,
   124      "cmovnc"           : __asm_proxy_CMOVNC__,
   125      "cmovne"           : __asm_proxy_CMOVNE__,
   126      "cmovng"           : __asm_proxy_CMOVNG__,
   127      "cmovnge"          : __asm_proxy_CMOVNGE__,
   128      "cmovnl"           : __asm_proxy_CMOVNL__,
   129      "cmovnle"          : __asm_proxy_CMOVNLE__,
   130      "cmovno"           : __asm_proxy_CMOVNO__,
   131      "cmovnp"           : __asm_proxy_CMOVNP__,
   132      "cmovns"           : __asm_proxy_CMOVNS__,
   133      "cmovnz"           : __asm_proxy_CMOVNZ__,
   134      "cmovo"            : __asm_proxy_CMOVO__,
   135      "cmovp"            : __asm_proxy_CMOVP__,
   136      "cmovpe"           : __asm_proxy_CMOVPE__,
   137      "cmovpo"           : __asm_proxy_CMOVPO__,
   138      "cmovs"            : __asm_proxy_CMOVS__,
   139      "cmovz"            : __asm_proxy_CMOVZ__,
   140      "cmpb"             : __asm_proxy_CMPB__,
   141      "cmpl"             : __asm_proxy_CMPL__,
   142      "cmppd"            : __asm_proxy_CMPPD__,
   143      "cmpps"            : __asm_proxy_CMPPS__,
   144      "cmpq"             : __asm_proxy_CMPQ__,
   145      "cmpsd"            : __asm_proxy_CMPSD__,
   146      "cmpss"            : __asm_proxy_CMPSS__,
   147      "cmpw"             : __asm_proxy_CMPW__,
   148      "cmpxchg16b"       : __asm_proxy_CMPXCHG16B__,
   149      "cmpxchg8b"        : __asm_proxy_CMPXCHG8B__,
   150      "cmpxchgb"         : __asm_proxy_CMPXCHGB__,
   151      "cmpxchgl"         : __asm_proxy_CMPXCHGL__,
   152      "cmpxchgq"         : __asm_proxy_CMPXCHGQ__,
   153      "cmpxchgw"         : __asm_proxy_CMPXCHGW__,
   154      "comisd"           : __asm_proxy_COMISD__,
   155      "comiss"           : __asm_proxy_COMISS__,
   156      "cpuid"            : __asm_proxy_CPUID__,
   157      "cqto"             : __asm_proxy_CQTO__,
   158      "crc32b"           : __asm_proxy_CRC32B__,
   159      "crc32l"           : __asm_proxy_CRC32L__,
   160      "crc32q"           : __asm_proxy_CRC32Q__,
   161      "crc32w"           : __asm_proxy_CRC32W__,
   162      "cvtdq2pd"         : __asm_proxy_CVTDQ2PD__,
   163      "cvtdq2ps"         : __asm_proxy_CVTDQ2PS__,
   164      "cvtpd2dq"         : __asm_proxy_CVTPD2DQ__,
   165      "cvtpd2pi"         : __asm_proxy_CVTPD2PI__,
   166      "cvtpd2ps"         : __asm_proxy_CVTPD2PS__,
   167      "cvtpi2pd"         : __asm_proxy_CVTPI2PD__,
   168      "cvtpi2ps"         : __asm_proxy_CVTPI2PS__,
   169      "cvtps2dq"         : __asm_proxy_CVTPS2DQ__,
   170      "cvtps2pd"         : __asm_proxy_CVTPS2PD__,
   171      "cvtps2pi"         : __asm_proxy_CVTPS2PI__,
   172      "cvtsd2si"         : __asm_proxy_CVTSD2SI__,
   173      "cvtsd2ss"         : __asm_proxy_CVTSD2SS__,
   174      "cvtsi2sd"         : __asm_proxy_CVTSI2SD__,
   175      "cvtsi2ss"         : __asm_proxy_CVTSI2SS__,
   176      "cvtss2sd"         : __asm_proxy_CVTSS2SD__,
   177      "cvtss2si"         : __asm_proxy_CVTSS2SI__,
   178      "cvttpd2dq"        : __asm_proxy_CVTTPD2DQ__,
   179      "cvttpd2pi"        : __asm_proxy_CVTTPD2PI__,
   180      "cvttps2dq"        : __asm_proxy_CVTTPS2DQ__,
   181      "cvttps2pi"        : __asm_proxy_CVTTPS2PI__,
   182      "cvttsd2si"        : __asm_proxy_CVTTSD2SI__,
   183      "cvttss2si"        : __asm_proxy_CVTTSS2SI__,
   184      "cwtd"             : __asm_proxy_CWTD__,
   185      "cwtl"             : __asm_proxy_CWTL__,
   186      "decb"             : __asm_proxy_DECB__,
   187      "decl"             : __asm_proxy_DECL__,
   188      "decq"             : __asm_proxy_DECQ__,
   189      "decw"             : __asm_proxy_DECW__,
   190      "divb"             : __asm_proxy_DIVB__,
   191      "divl"             : __asm_proxy_DIVL__,
   192      "divpd"            : __asm_proxy_DIVPD__,
   193      "divps"            : __asm_proxy_DIVPS__,
   194      "divq"             : __asm_proxy_DIVQ__,
   195      "divsd"            : __asm_proxy_DIVSD__,
   196      "divss"            : __asm_proxy_DIVSS__,
   197      "divw"             : __asm_proxy_DIVW__,
   198      "dppd"             : __asm_proxy_DPPD__,
   199      "dpps"             : __asm_proxy_DPPS__,
   200      "emms"             : __asm_proxy_EMMS__,
   201      "extractps"        : __asm_proxy_EXTRACTPS__,
   202      "extrq"            : __asm_proxy_EXTRQ__,
   203      "femms"            : __asm_proxy_FEMMS__,
   204      "haddpd"           : __asm_proxy_HADDPD__,
   205      "haddps"           : __asm_proxy_HADDPS__,
   206      "hsubpd"           : __asm_proxy_HSUBPD__,
   207      "hsubps"           : __asm_proxy_HSUBPS__,
   208      "idivb"            : __asm_proxy_IDIVB__,
   209      "idivl"            : __asm_proxy_IDIVL__,
   210      "idivq"            : __asm_proxy_IDIVQ__,
   211      "idivw"            : __asm_proxy_IDIVW__,
   212      "imulb"            : __asm_proxy_IMULB__,
   213      "imull"            : __asm_proxy_IMULL__,
   214      "imulq"            : __asm_proxy_IMULQ__,
   215      "imulw"            : __asm_proxy_IMULW__,
   216      "incb"             : __asm_proxy_INCB__,
   217      "incl"             : __asm_proxy_INCL__,
   218      "incq"             : __asm_proxy_INCQ__,
   219      "incw"             : __asm_proxy_INCW__,
   220      "insertps"         : __asm_proxy_INSERTPS__,
   221      "insertq"          : __asm_proxy_INSERTQ__,
   222      "int"              : __asm_proxy_INT__,
   223      "ja"               : __asm_proxy_JA__,
   224      "jae"              : __asm_proxy_JAE__,
   225      "jb"               : __asm_proxy_JB__,
   226      "jbe"              : __asm_proxy_JBE__,
   227      "jc"               : __asm_proxy_JC__,
   228      "je"               : __asm_proxy_JE__,
   229      "jecxz"            : __asm_proxy_JECXZ__,
   230      "jg"               : __asm_proxy_JG__,
   231      "jge"              : __asm_proxy_JGE__,
   232      "jl"               : __asm_proxy_JL__,
   233      "jle"              : __asm_proxy_JLE__,
   234      "jmp"              : __asm_proxy_JMP__,
   235      "jmpq"             : __asm_proxy_JMPQ__,
   236      "jna"              : __asm_proxy_JNA__,
   237      "jnae"             : __asm_proxy_JNAE__,
   238      "jnb"              : __asm_proxy_JNB__,
   239      "jnbe"             : __asm_proxy_JNBE__,
   240      "jnc"              : __asm_proxy_JNC__,
   241      "jne"              : __asm_proxy_JNE__,
   242      "jng"              : __asm_proxy_JNG__,
   243      "jnge"             : __asm_proxy_JNGE__,
   244      "jnl"              : __asm_proxy_JNL__,
   245      "jnle"             : __asm_proxy_JNLE__,
   246      "jno"              : __asm_proxy_JNO__,
   247      "jnp"              : __asm_proxy_JNP__,
   248      "jns"              : __asm_proxy_JNS__,
   249      "jnz"              : __asm_proxy_JNZ__,
   250      "jo"               : __asm_proxy_JO__,
   251      "jp"               : __asm_proxy_JP__,
   252      "jpe"              : __asm_proxy_JPE__,
   253      "jpo"              : __asm_proxy_JPO__,
   254      "jrcxz"            : __asm_proxy_JRCXZ__,
   255      "js"               : __asm_proxy_JS__,
   256      "jz"               : __asm_proxy_JZ__,
   257      "kaddb"            : __asm_proxy_KADDB__,
   258      "kaddd"            : __asm_proxy_KADDD__,
   259      "kaddq"            : __asm_proxy_KADDQ__,
   260      "kaddw"            : __asm_proxy_KADDW__,
   261      "kandb"            : __asm_proxy_KANDB__,
   262      "kandd"            : __asm_proxy_KANDD__,
   263      "kandnb"           : __asm_proxy_KANDNB__,
   264      "kandnd"           : __asm_proxy_KANDND__,
   265      "kandnq"           : __asm_proxy_KANDNQ__,
   266      "kandnw"           : __asm_proxy_KANDNW__,
   267      "kandq"            : __asm_proxy_KANDQ__,
   268      "kandw"            : __asm_proxy_KANDW__,
   269      "kmovb"            : __asm_proxy_KMOVB__,
   270      "kmovd"            : __asm_proxy_KMOVD__,
   271      "kmovq"            : __asm_proxy_KMOVQ__,
   272      "kmovw"            : __asm_proxy_KMOVW__,
   273      "knotb"            : __asm_proxy_KNOTB__,
   274      "knotd"            : __asm_proxy_KNOTD__,
   275      "knotq"            : __asm_proxy_KNOTQ__,
   276      "knotw"            : __asm_proxy_KNOTW__,
   277      "korb"             : __asm_proxy_KORB__,
   278      "kord"             : __asm_proxy_KORD__,
   279      "korq"             : __asm_proxy_KORQ__,
   280      "kortestb"         : __asm_proxy_KORTESTB__,
   281      "kortestd"         : __asm_proxy_KORTESTD__,
   282      "kortestq"         : __asm_proxy_KORTESTQ__,
   283      "kortestw"         : __asm_proxy_KORTESTW__,
   284      "korw"             : __asm_proxy_KORW__,
   285      "kshiftlb"         : __asm_proxy_KSHIFTLB__,
   286      "kshiftld"         : __asm_proxy_KSHIFTLD__,
   287      "kshiftlq"         : __asm_proxy_KSHIFTLQ__,
   288      "kshiftlw"         : __asm_proxy_KSHIFTLW__,
   289      "kshiftrb"         : __asm_proxy_KSHIFTRB__,
   290      "kshiftrd"         : __asm_proxy_KSHIFTRD__,
   291      "kshiftrq"         : __asm_proxy_KSHIFTRQ__,
   292      "kshiftrw"         : __asm_proxy_KSHIFTRW__,
   293      "ktestb"           : __asm_proxy_KTESTB__,
   294      "ktestd"           : __asm_proxy_KTESTD__,
   295      "ktestq"           : __asm_proxy_KTESTQ__,
   296      "ktestw"           : __asm_proxy_KTESTW__,
   297      "kunpckbw"         : __asm_proxy_KUNPCKBW__,
   298      "kunpckdq"         : __asm_proxy_KUNPCKDQ__,
   299      "kunpckwd"         : __asm_proxy_KUNPCKWD__,
   300      "kxnorb"           : __asm_proxy_KXNORB__,
   301      "kxnord"           : __asm_proxy_KXNORD__,
   302      "kxnorq"           : __asm_proxy_KXNORQ__,
   303      "kxnorw"           : __asm_proxy_KXNORW__,
   304      "kxorb"            : __asm_proxy_KXORB__,
   305      "kxord"            : __asm_proxy_KXORD__,
   306      "kxorq"            : __asm_proxy_KXORQ__,
   307      "kxorw"            : __asm_proxy_KXORW__,
   308      "lddqu"            : __asm_proxy_LDDQU__,
   309      "ldmxcsr"          : __asm_proxy_LDMXCSR__,
   310      "leal"             : __asm_proxy_LEAL__,
   311      "leaq"             : __asm_proxy_LEAQ__,
   312      "leaw"             : __asm_proxy_LEAW__,
   313      "lfence"           : __asm_proxy_LFENCE__,
   314      "lzcntl"           : __asm_proxy_LZCNTL__,
   315      "lzcntq"           : __asm_proxy_LZCNTQ__,
   316      "lzcntw"           : __asm_proxy_LZCNTW__,
   317      "maskmovdqu"       : __asm_proxy_MASKMOVDQU__,
   318      "maskmovq"         : __asm_proxy_MASKMOVQ__,
   319      "maxpd"            : __asm_proxy_MAXPD__,
   320      "maxps"            : __asm_proxy_MAXPS__,
   321      "maxsd"            : __asm_proxy_MAXSD__,
   322      "maxss"            : __asm_proxy_MAXSS__,
   323      "mfence"           : __asm_proxy_MFENCE__,
   324      "minpd"            : __asm_proxy_MINPD__,
   325      "minps"            : __asm_proxy_MINPS__,
   326      "minsd"            : __asm_proxy_MINSD__,
   327      "minss"            : __asm_proxy_MINSS__,
   328      "monitor"          : __asm_proxy_MONITOR__,
   329      "monitorx"         : __asm_proxy_MONITORX__,
   330      "movapd"           : __asm_proxy_MOVAPD__,
   331      "movaps"           : __asm_proxy_MOVAPS__,
   332      "movb"             : __asm_proxy_MOVB__,
   333      "movbel"           : __asm_proxy_MOVBEL__,
   334      "movbeq"           : __asm_proxy_MOVBEQ__,
   335      "movbew"           : __asm_proxy_MOVBEW__,
   336      "movd"             : __asm_proxy_MOVD__,
   337      "movddup"          : __asm_proxy_MOVDDUP__,
   338      "movdq2q"          : __asm_proxy_MOVDQ2Q__,
   339      "movdqa"           : __asm_proxy_MOVDQA__,
   340      "movdqu"           : __asm_proxy_MOVDQU__,
   341      "movhlps"          : __asm_proxy_MOVHLPS__,
   342      "movhpd"           : __asm_proxy_MOVHPD__,
   343      "movhps"           : __asm_proxy_MOVHPS__,
   344      "movl"             : __asm_proxy_MOVL__,
   345      "movlhps"          : __asm_proxy_MOVLHPS__,
   346      "movlpd"           : __asm_proxy_MOVLPD__,
   347      "movlps"           : __asm_proxy_MOVLPS__,
   348      "movmskpd"         : __asm_proxy_MOVMSKPD__,
   349      "movmskps"         : __asm_proxy_MOVMSKPS__,
   350      "movntdq"          : __asm_proxy_MOVNTDQ__,
   351      "movntdqa"         : __asm_proxy_MOVNTDQA__,
   352      "movntil"          : __asm_proxy_MOVNTIL__,
   353      "movntiq"          : __asm_proxy_MOVNTIQ__,
   354      "movntpd"          : __asm_proxy_MOVNTPD__,
   355      "movntps"          : __asm_proxy_MOVNTPS__,
   356      "movntq"           : __asm_proxy_MOVNTQ__,
   357      "movntsd"          : __asm_proxy_MOVNTSD__,
   358      "movntss"          : __asm_proxy_MOVNTSS__,
   359      "movq"             : __asm_proxy_MOVQ__,
   360      "movq2dq"          : __asm_proxy_MOVQ2DQ__,
   361      "movsbl"           : __asm_proxy_MOVSBL__,
   362      "movsbq"           : __asm_proxy_MOVSBQ__,
   363      "movsbw"           : __asm_proxy_MOVSBW__,
   364      "movsd"            : __asm_proxy_MOVSD__,
   365      "movshdup"         : __asm_proxy_MOVSHDUP__,
   366      "movsldup"         : __asm_proxy_MOVSLDUP__,
   367      "movslq"           : __asm_proxy_MOVSLQ__,
   368      "movss"            : __asm_proxy_MOVSS__,
   369      "movswl"           : __asm_proxy_MOVSWL__,
   370      "movswq"           : __asm_proxy_MOVSWQ__,
   371      "movupd"           : __asm_proxy_MOVUPD__,
   372      "movups"           : __asm_proxy_MOVUPS__,
   373      "movw"             : __asm_proxy_MOVW__,
   374      "movzbl"           : __asm_proxy_MOVZBL__,
   375      "movzbq"           : __asm_proxy_MOVZBQ__,
   376      "movzbw"           : __asm_proxy_MOVZBW__,
   377      "movzwl"           : __asm_proxy_MOVZWL__,
   378      "movzwq"           : __asm_proxy_MOVZWQ__,
   379      "mpsadbw"          : __asm_proxy_MPSADBW__,
   380      "mulb"             : __asm_proxy_MULB__,
   381      "mull"             : __asm_proxy_MULL__,
   382      "mulpd"            : __asm_proxy_MULPD__,
   383      "mulps"            : __asm_proxy_MULPS__,
   384      "mulq"             : __asm_proxy_MULQ__,
   385      "mulsd"            : __asm_proxy_MULSD__,
   386      "mulss"            : __asm_proxy_MULSS__,
   387      "mulw"             : __asm_proxy_MULW__,
   388      "mulxl"            : __asm_proxy_MULXL__,
   389      "mulxq"            : __asm_proxy_MULXQ__,
   390      "mwait"            : __asm_proxy_MWAIT__,
   391      "mwaitx"           : __asm_proxy_MWAITX__,
   392      "negb"             : __asm_proxy_NEGB__,
   393      "negl"             : __asm_proxy_NEGL__,
   394      "negq"             : __asm_proxy_NEGQ__,
   395      "negw"             : __asm_proxy_NEGW__,
   396      "nop"              : __asm_proxy_NOP__,
   397      "notb"             : __asm_proxy_NOTB__,
   398      "notl"             : __asm_proxy_NOTL__,
   399      "notq"             : __asm_proxy_NOTQ__,
   400      "notw"             : __asm_proxy_NOTW__,
   401      "orb"              : __asm_proxy_ORB__,
   402      "orl"              : __asm_proxy_ORL__,
   403      "orpd"             : __asm_proxy_ORPD__,
   404      "orps"             : __asm_proxy_ORPS__,
   405      "orq"              : __asm_proxy_ORQ__,
   406      "orw"              : __asm_proxy_ORW__,
   407      "pabsb"            : __asm_proxy_PABSB__,
   408      "pabsd"            : __asm_proxy_PABSD__,
   409      "pabsw"            : __asm_proxy_PABSW__,
   410      "packssdw"         : __asm_proxy_PACKSSDW__,
   411      "packsswb"         : __asm_proxy_PACKSSWB__,
   412      "packusdw"         : __asm_proxy_PACKUSDW__,
   413      "packuswb"         : __asm_proxy_PACKUSWB__,
   414      "paddb"            : __asm_proxy_PADDB__,
   415      "paddd"            : __asm_proxy_PADDD__,
   416      "paddq"            : __asm_proxy_PADDQ__,
   417      "paddsb"           : __asm_proxy_PADDSB__,
   418      "paddsw"           : __asm_proxy_PADDSW__,
   419      "paddusb"          : __asm_proxy_PADDUSB__,
   420      "paddusw"          : __asm_proxy_PADDUSW__,
   421      "paddw"            : __asm_proxy_PADDW__,
   422      "palignr"          : __asm_proxy_PALIGNR__,
   423      "pand"             : __asm_proxy_PAND__,
   424      "pandn"            : __asm_proxy_PANDN__,
   425      "pause"            : __asm_proxy_PAUSE__,
   426      "pavgb"            : __asm_proxy_PAVGB__,
   427      "pavgusb"          : __asm_proxy_PAVGUSB__,
   428      "pavgw"            : __asm_proxy_PAVGW__,
   429      "pblendvb"         : __asm_proxy_PBLENDVB__,
   430      "pblendw"          : __asm_proxy_PBLENDW__,
   431      "pclmulqdq"        : __asm_proxy_PCLMULQDQ__,
   432      "pcmpeqb"          : __asm_proxy_PCMPEQB__,
   433      "pcmpeqd"          : __asm_proxy_PCMPEQD__,
   434      "pcmpeqq"          : __asm_proxy_PCMPEQQ__,
   435      "pcmpeqw"          : __asm_proxy_PCMPEQW__,
   436      "pcmpestri"        : __asm_proxy_PCMPESTRI__,
   437      "pcmpestrm"        : __asm_proxy_PCMPESTRM__,
   438      "pcmpgtb"          : __asm_proxy_PCMPGTB__,
   439      "pcmpgtd"          : __asm_proxy_PCMPGTD__,
   440      "pcmpgtq"          : __asm_proxy_PCMPGTQ__,
   441      "pcmpgtw"          : __asm_proxy_PCMPGTW__,
   442      "pcmpistri"        : __asm_proxy_PCMPISTRI__,
   443      "pcmpistrm"        : __asm_proxy_PCMPISTRM__,
   444      "pdep"             : __asm_proxy_PDEP__,
   445      "pext"             : __asm_proxy_PEXT__,
   446      "pextrb"           : __asm_proxy_PEXTRB__,
   447      "pextrd"           : __asm_proxy_PEXTRD__,
   448      "pextrq"           : __asm_proxy_PEXTRQ__,
   449      "pextrw"           : __asm_proxy_PEXTRW__,
   450      "pf2id"            : __asm_proxy_PF2ID__,
   451      "pf2iw"            : __asm_proxy_PF2IW__,
   452      "pfacc"            : __asm_proxy_PFACC__,
   453      "pfadd"            : __asm_proxy_PFADD__,
   454      "pfcmpeq"          : __asm_proxy_PFCMPEQ__,
   455      "pfcmpge"          : __asm_proxy_PFCMPGE__,
   456      "pfcmpgt"          : __asm_proxy_PFCMPGT__,
   457      "pfmax"            : __asm_proxy_PFMAX__,
   458      "pfmin"            : __asm_proxy_PFMIN__,
   459      "pfmul"            : __asm_proxy_PFMUL__,
   460      "pfnacc"           : __asm_proxy_PFNACC__,
   461      "pfpnacc"          : __asm_proxy_PFPNACC__,
   462      "pfrcp"            : __asm_proxy_PFRCP__,
   463      "pfrcpit1"         : __asm_proxy_PFRCPIT1__,
   464      "pfrcpit2"         : __asm_proxy_PFRCPIT2__,
   465      "pfrsqit1"         : __asm_proxy_PFRSQIT1__,
   466      "pfrsqrt"          : __asm_proxy_PFRSQRT__,
   467      "pfsub"            : __asm_proxy_PFSUB__,
   468      "pfsubr"           : __asm_proxy_PFSUBR__,
   469      "phaddd"           : __asm_proxy_PHADDD__,
   470      "phaddsw"          : __asm_proxy_PHADDSW__,
   471      "phaddw"           : __asm_proxy_PHADDW__,
   472      "phminposuw"       : __asm_proxy_PHMINPOSUW__,
   473      "phsubd"           : __asm_proxy_PHSUBD__,
   474      "phsubsw"          : __asm_proxy_PHSUBSW__,
   475      "phsubw"           : __asm_proxy_PHSUBW__,
   476      "pi2fd"            : __asm_proxy_PI2FD__,
   477      "pi2fw"            : __asm_proxy_PI2FW__,
   478      "pinsrb"           : __asm_proxy_PINSRB__,
   479      "pinsrd"           : __asm_proxy_PINSRD__,
   480      "pinsrq"           : __asm_proxy_PINSRQ__,
   481      "pinsrw"           : __asm_proxy_PINSRW__,
   482      "pmaddubsw"        : __asm_proxy_PMADDUBSW__,
   483      "pmaddwd"          : __asm_proxy_PMADDWD__,
   484      "pmaxsb"           : __asm_proxy_PMAXSB__,
   485      "pmaxsd"           : __asm_proxy_PMAXSD__,
   486      "pmaxsw"           : __asm_proxy_PMAXSW__,
   487      "pmaxub"           : __asm_proxy_PMAXUB__,
   488      "pmaxud"           : __asm_proxy_PMAXUD__,
   489      "pmaxuw"           : __asm_proxy_PMAXUW__,
   490      "pminsb"           : __asm_proxy_PMINSB__,
   491      "pminsd"           : __asm_proxy_PMINSD__,
   492      "pminsw"           : __asm_proxy_PMINSW__,
   493      "pminub"           : __asm_proxy_PMINUB__,
   494      "pminud"           : __asm_proxy_PMINUD__,
   495      "pminuw"           : __asm_proxy_PMINUW__,
   496      "pmovmskb"         : __asm_proxy_PMOVMSKB__,
   497      "pmovsxbd"         : __asm_proxy_PMOVSXBD__,
   498      "pmovsxbq"         : __asm_proxy_PMOVSXBQ__,
   499      "pmovsxbw"         : __asm_proxy_PMOVSXBW__,
   500      "pmovsxdq"         : __asm_proxy_PMOVSXDQ__,
   501      "pmovsxwd"         : __asm_proxy_PMOVSXWD__,
   502      "pmovsxwq"         : __asm_proxy_PMOVSXWQ__,
   503      "pmovzxbd"         : __asm_proxy_PMOVZXBD__,
   504      "pmovzxbq"         : __asm_proxy_PMOVZXBQ__,
   505      "pmovzxbw"         : __asm_proxy_PMOVZXBW__,
   506      "pmovzxdq"         : __asm_proxy_PMOVZXDQ__,
   507      "pmovzxwd"         : __asm_proxy_PMOVZXWD__,
   508      "pmovzxwq"         : __asm_proxy_PMOVZXWQ__,
   509      "pmuldq"           : __asm_proxy_PMULDQ__,
   510      "pmulhrsw"         : __asm_proxy_PMULHRSW__,
   511      "pmulhrw"          : __asm_proxy_PMULHRW__,
   512      "pmulhuw"          : __asm_proxy_PMULHUW__,
   513      "pmulhw"           : __asm_proxy_PMULHW__,
   514      "pmulld"           : __asm_proxy_PMULLD__,
   515      "pmullw"           : __asm_proxy_PMULLW__,
   516      "pmuludq"          : __asm_proxy_PMULUDQ__,
   517      "popcntl"          : __asm_proxy_POPCNTL__,
   518      "popcntq"          : __asm_proxy_POPCNTQ__,
   519      "popcntw"          : __asm_proxy_POPCNTW__,
   520      "popq"             : __asm_proxy_POPQ__,
   521      "popw"             : __asm_proxy_POPW__,
   522      "por"              : __asm_proxy_POR__,
   523      "prefetch"         : __asm_proxy_PREFETCH__,
   524      "prefetchnta"      : __asm_proxy_PREFETCHNTA__,
   525      "prefetcht0"       : __asm_proxy_PREFETCHT0__,
   526      "prefetcht1"       : __asm_proxy_PREFETCHT1__,
   527      "prefetcht2"       : __asm_proxy_PREFETCHT2__,
   528      "prefetchw"        : __asm_proxy_PREFETCHW__,
   529      "prefetchwt1"      : __asm_proxy_PREFETCHWT1__,
   530      "psadbw"           : __asm_proxy_PSADBW__,
   531      "pshufb"           : __asm_proxy_PSHUFB__,
   532      "pshufd"           : __asm_proxy_PSHUFD__,
   533      "pshufhw"          : __asm_proxy_PSHUFHW__,
   534      "pshuflw"          : __asm_proxy_PSHUFLW__,
   535      "pshufw"           : __asm_proxy_PSHUFW__,
   536      "psignb"           : __asm_proxy_PSIGNB__,
   537      "psignd"           : __asm_proxy_PSIGND__,
   538      "psignw"           : __asm_proxy_PSIGNW__,
   539      "pslld"            : __asm_proxy_PSLLD__,
   540      "pslldq"           : __asm_proxy_PSLLDQ__,
   541      "psllq"            : __asm_proxy_PSLLQ__,
   542      "psllw"            : __asm_proxy_PSLLW__,
   543      "psrad"            : __asm_proxy_PSRAD__,
   544      "psraw"            : __asm_proxy_PSRAW__,
   545      "psrld"            : __asm_proxy_PSRLD__,
   546      "psrldq"           : __asm_proxy_PSRLDQ__,
   547      "psrlq"            : __asm_proxy_PSRLQ__,
   548      "psrlw"            : __asm_proxy_PSRLW__,
   549      "psubb"            : __asm_proxy_PSUBB__,
   550      "psubd"            : __asm_proxy_PSUBD__,
   551      "psubq"            : __asm_proxy_PSUBQ__,
   552      "psubsb"           : __asm_proxy_PSUBSB__,
   553      "psubsw"           : __asm_proxy_PSUBSW__,
   554      "psubusb"          : __asm_proxy_PSUBUSB__,
   555      "psubusw"          : __asm_proxy_PSUBUSW__,
   556      "psubw"            : __asm_proxy_PSUBW__,
   557      "pswapd"           : __asm_proxy_PSWAPD__,
   558      "ptest"            : __asm_proxy_PTEST__,
   559      "punpckhbw"        : __asm_proxy_PUNPCKHBW__,
   560      "punpckhdq"        : __asm_proxy_PUNPCKHDQ__,
   561      "punpckhqdq"       : __asm_proxy_PUNPCKHQDQ__,
   562      "punpckhwd"        : __asm_proxy_PUNPCKHWD__,
   563      "punpcklbw"        : __asm_proxy_PUNPCKLBW__,
   564      "punpckldq"        : __asm_proxy_PUNPCKLDQ__,
   565      "punpcklqdq"       : __asm_proxy_PUNPCKLQDQ__,
   566      "punpcklwd"        : __asm_proxy_PUNPCKLWD__,
   567      "pushq"            : __asm_proxy_PUSHQ__,
   568      "pushw"            : __asm_proxy_PUSHW__,
   569      "pxor"             : __asm_proxy_PXOR__,
   570      "rclb"             : __asm_proxy_RCLB__,
   571      "rcll"             : __asm_proxy_RCLL__,
   572      "rclq"             : __asm_proxy_RCLQ__,
   573      "rclw"             : __asm_proxy_RCLW__,
   574      "rcpps"            : __asm_proxy_RCPPS__,
   575      "rcpss"            : __asm_proxy_RCPSS__,
   576      "rcrb"             : __asm_proxy_RCRB__,
   577      "rcrl"             : __asm_proxy_RCRL__,
   578      "rcrq"             : __asm_proxy_RCRQ__,
   579      "rcrw"             : __asm_proxy_RCRW__,
   580      "rdrand"           : __asm_proxy_RDRAND__,
   581      "rdseed"           : __asm_proxy_RDSEED__,
   582      "rdtsc"            : __asm_proxy_RDTSC__,
   583      "rdtscp"           : __asm_proxy_RDTSCP__,
   584      "ret"              : __asm_proxy_RET__,
   585      "rolb"             : __asm_proxy_ROLB__,
   586      "roll"             : __asm_proxy_ROLL__,
   587      "rolq"             : __asm_proxy_ROLQ__,
   588      "rolw"             : __asm_proxy_ROLW__,
   589      "rorb"             : __asm_proxy_RORB__,
   590      "rorl"             : __asm_proxy_RORL__,
   591      "rorq"             : __asm_proxy_RORQ__,
   592      "rorw"             : __asm_proxy_RORW__,
   593      "rorxl"            : __asm_proxy_RORXL__,
   594      "rorxq"            : __asm_proxy_RORXQ__,
   595      "roundpd"          : __asm_proxy_ROUNDPD__,
   596      "roundps"          : __asm_proxy_ROUNDPS__,
   597      "roundsd"          : __asm_proxy_ROUNDSD__,
   598      "roundss"          : __asm_proxy_ROUNDSS__,
   599      "rsqrtps"          : __asm_proxy_RSQRTPS__,
   600      "rsqrtss"          : __asm_proxy_RSQRTSS__,
   601      "salb"             : __asm_proxy_SALB__,
   602      "sall"             : __asm_proxy_SALL__,
   603      "salq"             : __asm_proxy_SALQ__,
   604      "salw"             : __asm_proxy_SALW__,
   605      "sarb"             : __asm_proxy_SARB__,
   606      "sarl"             : __asm_proxy_SARL__,
   607      "sarq"             : __asm_proxy_SARQ__,
   608      "sarw"             : __asm_proxy_SARW__,
   609      "sarxl"            : __asm_proxy_SARXL__,
   610      "sarxq"            : __asm_proxy_SARXQ__,
   611      "sbbb"             : __asm_proxy_SBBB__,
   612      "sbbl"             : __asm_proxy_SBBL__,
   613      "sbbq"             : __asm_proxy_SBBQ__,
   614      "sbbw"             : __asm_proxy_SBBW__,
   615      "seta"             : __asm_proxy_SETA__,
   616      "setae"            : __asm_proxy_SETAE__,
   617      "setb"             : __asm_proxy_SETB__,
   618      "setbe"            : __asm_proxy_SETBE__,
   619      "setc"             : __asm_proxy_SETC__,
   620      "sete"             : __asm_proxy_SETE__,
   621      "setg"             : __asm_proxy_SETG__,
   622      "setge"            : __asm_proxy_SETGE__,
   623      "setl"             : __asm_proxy_SETL__,
   624      "setle"            : __asm_proxy_SETLE__,
   625      "setna"            : __asm_proxy_SETNA__,
   626      "setnae"           : __asm_proxy_SETNAE__,
   627      "setnb"            : __asm_proxy_SETNB__,
   628      "setnbe"           : __asm_proxy_SETNBE__,
   629      "setnc"            : __asm_proxy_SETNC__,
   630      "setne"            : __asm_proxy_SETNE__,
   631      "setng"            : __asm_proxy_SETNG__,
   632      "setnge"           : __asm_proxy_SETNGE__,
   633      "setnl"            : __asm_proxy_SETNL__,
   634      "setnle"           : __asm_proxy_SETNLE__,
   635      "setno"            : __asm_proxy_SETNO__,
   636      "setnp"            : __asm_proxy_SETNP__,
   637      "setns"            : __asm_proxy_SETNS__,
   638      "setnz"            : __asm_proxy_SETNZ__,
   639      "seto"             : __asm_proxy_SETO__,
   640      "setp"             : __asm_proxy_SETP__,
   641      "setpe"            : __asm_proxy_SETPE__,
   642      "setpo"            : __asm_proxy_SETPO__,
   643      "sets"             : __asm_proxy_SETS__,
   644      "setz"             : __asm_proxy_SETZ__,
   645      "sfence"           : __asm_proxy_SFENCE__,
   646      "sha1msg1"         : __asm_proxy_SHA1MSG1__,
   647      "sha1msg2"         : __asm_proxy_SHA1MSG2__,
   648      "sha1nexte"        : __asm_proxy_SHA1NEXTE__,
   649      "sha1rnds4"        : __asm_proxy_SHA1RNDS4__,
   650      "sha256msg1"       : __asm_proxy_SHA256MSG1__,
   651      "sha256msg2"       : __asm_proxy_SHA256MSG2__,
   652      "sha256rnds2"      : __asm_proxy_SHA256RNDS2__,
   653      "shlb"             : __asm_proxy_SHLB__,
   654      "shldl"            : __asm_proxy_SHLDL__,
   655      "shldq"            : __asm_proxy_SHLDQ__,
   656      "shldw"            : __asm_proxy_SHLDW__,
   657      "shll"             : __asm_proxy_SHLL__,
   658      "shlq"             : __asm_proxy_SHLQ__,
   659      "shlw"             : __asm_proxy_SHLW__,
   660      "shlxl"            : __asm_proxy_SHLXL__,
   661      "shlxq"            : __asm_proxy_SHLXQ__,
   662      "shrb"             : __asm_proxy_SHRB__,
   663      "shrdl"            : __asm_proxy_SHRDL__,
   664      "shrdq"            : __asm_proxy_SHRDQ__,
   665      "shrdw"            : __asm_proxy_SHRDW__,
   666      "shrl"             : __asm_proxy_SHRL__,
   667      "shrq"             : __asm_proxy_SHRQ__,
   668      "shrw"             : __asm_proxy_SHRW__,
   669      "shrxl"            : __asm_proxy_SHRXL__,
   670      "shrxq"            : __asm_proxy_SHRXQ__,
   671      "shufpd"           : __asm_proxy_SHUFPD__,
   672      "shufps"           : __asm_proxy_SHUFPS__,
   673      "sqrtpd"           : __asm_proxy_SQRTPD__,
   674      "sqrtps"           : __asm_proxy_SQRTPS__,
   675      "sqrtsd"           : __asm_proxy_SQRTSD__,
   676      "sqrtss"           : __asm_proxy_SQRTSS__,
   677      "stc"              : __asm_proxy_STC__,
   678      "std"              : __asm_proxy_STD__,
   679      "stmxcsr"          : __asm_proxy_STMXCSR__,
   680      "subb"             : __asm_proxy_SUBB__,
   681      "subl"             : __asm_proxy_SUBL__,
   682      "subpd"            : __asm_proxy_SUBPD__,
   683      "subps"            : __asm_proxy_SUBPS__,
   684      "subq"             : __asm_proxy_SUBQ__,
   685      "subsd"            : __asm_proxy_SUBSD__,
   686      "subss"            : __asm_proxy_SUBSS__,
   687      "subw"             : __asm_proxy_SUBW__,
   688      "syscall"          : __asm_proxy_SYSCALL__,
   689      "t1mskc"           : __asm_proxy_T1MSKC__,
   690      "testb"            : __asm_proxy_TESTB__,
   691      "testl"            : __asm_proxy_TESTL__,
   692      "testq"            : __asm_proxy_TESTQ__,
   693      "testw"            : __asm_proxy_TESTW__,
   694      "tzcntl"           : __asm_proxy_TZCNTL__,
   695      "tzcntq"           : __asm_proxy_TZCNTQ__,
   696      "tzcntw"           : __asm_proxy_TZCNTW__,
   697      "tzmsk"            : __asm_proxy_TZMSK__,
   698      "ucomisd"          : __asm_proxy_UCOMISD__,
   699      "ucomiss"          : __asm_proxy_UCOMISS__,
   700      "ud2"              : __asm_proxy_UD2__,
   701      "unpckhpd"         : __asm_proxy_UNPCKHPD__,
   702      "unpckhps"         : __asm_proxy_UNPCKHPS__,
   703      "unpcklpd"         : __asm_proxy_UNPCKLPD__,
   704      "unpcklps"         : __asm_proxy_UNPCKLPS__,
   705      "vaddpd"           : __asm_proxy_VADDPD__,
   706      "vaddps"           : __asm_proxy_VADDPS__,
   707      "vaddsd"           : __asm_proxy_VADDSD__,
   708      "vaddss"           : __asm_proxy_VADDSS__,
   709      "vaddsubpd"        : __asm_proxy_VADDSUBPD__,
   710      "vaddsubps"        : __asm_proxy_VADDSUBPS__,
   711      "vaesdec"          : __asm_proxy_VAESDEC__,
   712      "vaesdeclast"      : __asm_proxy_VAESDECLAST__,
   713      "vaesenc"          : __asm_proxy_VAESENC__,
   714      "vaesenclast"      : __asm_proxy_VAESENCLAST__,
   715      "vaesimc"          : __asm_proxy_VAESIMC__,
   716      "vaeskeygenassist" : __asm_proxy_VAESKEYGENASSIST__,
   717      "valignd"          : __asm_proxy_VALIGND__,
   718      "valignq"          : __asm_proxy_VALIGNQ__,
   719      "vandnpd"          : __asm_proxy_VANDNPD__,
   720      "vandnps"          : __asm_proxy_VANDNPS__,
   721      "vandpd"           : __asm_proxy_VANDPD__,
   722      "vandps"           : __asm_proxy_VANDPS__,
   723      "vblendmpd"        : __asm_proxy_VBLENDMPD__,
   724      "vblendmps"        : __asm_proxy_VBLENDMPS__,
   725      "vblendpd"         : __asm_proxy_VBLENDPD__,
   726      "vblendps"         : __asm_proxy_VBLENDPS__,
   727      "vblendvpd"        : __asm_proxy_VBLENDVPD__,
   728      "vblendvps"        : __asm_proxy_VBLENDVPS__,
   729      "vbroadcastf128"   : __asm_proxy_VBROADCASTF128__,
   730      "vbroadcastf32x2"  : __asm_proxy_VBROADCASTF32X2__,
   731      "vbroadcastf32x4"  : __asm_proxy_VBROADCASTF32X4__,
   732      "vbroadcastf32x8"  : __asm_proxy_VBROADCASTF32X8__,
   733      "vbroadcastf64x2"  : __asm_proxy_VBROADCASTF64X2__,
   734      "vbroadcastf64x4"  : __asm_proxy_VBROADCASTF64X4__,
   735      "vbroadcasti128"   : __asm_proxy_VBROADCASTI128__,
   736      "vbroadcasti32x2"  : __asm_proxy_VBROADCASTI32X2__,
   737      "vbroadcasti32x4"  : __asm_proxy_VBROADCASTI32X4__,
   738      "vbroadcasti32x8"  : __asm_proxy_VBROADCASTI32X8__,
   739      "vbroadcasti64x2"  : __asm_proxy_VBROADCASTI64X2__,
   740      "vbroadcasti64x4"  : __asm_proxy_VBROADCASTI64X4__,
   741      "vbroadcastsd"     : __asm_proxy_VBROADCASTSD__,
   742      "vbroadcastss"     : __asm_proxy_VBROADCASTSS__,
   743      "vcmppd"           : __asm_proxy_VCMPPD__,
   744      "vcmpps"           : __asm_proxy_VCMPPS__,
   745      "vcmpsd"           : __asm_proxy_VCMPSD__,
   746      "vcmpss"           : __asm_proxy_VCMPSS__,
   747      "vcomisd"          : __asm_proxy_VCOMISD__,
   748      "vcomiss"          : __asm_proxy_VCOMISS__,
   749      "vcompresspd"      : __asm_proxy_VCOMPRESSPD__,
   750      "vcompressps"      : __asm_proxy_VCOMPRESSPS__,
   751      "vcvtdq2pd"        : __asm_proxy_VCVTDQ2PD__,
   752      "vcvtdq2ps"        : __asm_proxy_VCVTDQ2PS__,
   753      "vcvtpd2dq"        : __asm_proxy_VCVTPD2DQ__,
   754      "vcvtpd2ps"        : __asm_proxy_VCVTPD2PS__,
   755      "vcvtpd2qq"        : __asm_proxy_VCVTPD2QQ__,
   756      "vcvtpd2udq"       : __asm_proxy_VCVTPD2UDQ__,
   757      "vcvtpd2uqq"       : __asm_proxy_VCVTPD2UQQ__,
   758      "vcvtph2ps"        : __asm_proxy_VCVTPH2PS__,
   759      "vcvtps2dq"        : __asm_proxy_VCVTPS2DQ__,
   760      "vcvtps2pd"        : __asm_proxy_VCVTPS2PD__,
   761      "vcvtps2ph"        : __asm_proxy_VCVTPS2PH__,
   762      "vcvtps2qq"        : __asm_proxy_VCVTPS2QQ__,
   763      "vcvtps2udq"       : __asm_proxy_VCVTPS2UDQ__,
   764      "vcvtps2uqq"       : __asm_proxy_VCVTPS2UQQ__,
   765      "vcvtqq2pd"        : __asm_proxy_VCVTQQ2PD__,
   766      "vcvtqq2ps"        : __asm_proxy_VCVTQQ2PS__,
   767      "vcvtsd2si"        : __asm_proxy_VCVTSD2SI__,
   768      "vcvtsd2ss"        : __asm_proxy_VCVTSD2SS__,
   769      "vcvtsd2usi"       : __asm_proxy_VCVTSD2USI__,
   770      "vcvtsi2sd"        : __asm_proxy_VCVTSI2SD__,
   771      "vcvtsi2ss"        : __asm_proxy_VCVTSI2SS__,
   772      "vcvtss2sd"        : __asm_proxy_VCVTSS2SD__,
   773      "vcvtss2si"        : __asm_proxy_VCVTSS2SI__,
   774      "vcvtss2usi"       : __asm_proxy_VCVTSS2USI__,
   775      "vcvttpd2dq"       : __asm_proxy_VCVTTPD2DQ__,
   776      "vcvttpd2qq"       : __asm_proxy_VCVTTPD2QQ__,
   777      "vcvttpd2udq"      : __asm_proxy_VCVTTPD2UDQ__,
   778      "vcvttpd2uqq"      : __asm_proxy_VCVTTPD2UQQ__,
   779      "vcvttps2dq"       : __asm_proxy_VCVTTPS2DQ__,
   780      "vcvttps2qq"       : __asm_proxy_VCVTTPS2QQ__,
   781      "vcvttps2udq"      : __asm_proxy_VCVTTPS2UDQ__,
   782      "vcvttps2uqq"      : __asm_proxy_VCVTTPS2UQQ__,
   783      "vcvttsd2si"       : __asm_proxy_VCVTTSD2SI__,
   784      "vcvttsd2usi"      : __asm_proxy_VCVTTSD2USI__,
   785      "vcvttss2si"       : __asm_proxy_VCVTTSS2SI__,
   786      "vcvttss2usi"      : __asm_proxy_VCVTTSS2USI__,
   787      "vcvtudq2pd"       : __asm_proxy_VCVTUDQ2PD__,
   788      "vcvtudq2ps"       : __asm_proxy_VCVTUDQ2PS__,
   789      "vcvtuqq2pd"       : __asm_proxy_VCVTUQQ2PD__,
   790      "vcvtuqq2ps"       : __asm_proxy_VCVTUQQ2PS__,
   791      "vcvtusi2sd"       : __asm_proxy_VCVTUSI2SD__,
   792      "vcvtusi2ss"       : __asm_proxy_VCVTUSI2SS__,
   793      "vdbpsadbw"        : __asm_proxy_VDBPSADBW__,
   794      "vdivpd"           : __asm_proxy_VDIVPD__,
   795      "vdivps"           : __asm_proxy_VDIVPS__,
   796      "vdivsd"           : __asm_proxy_VDIVSD__,
   797      "vdivss"           : __asm_proxy_VDIVSS__,
   798      "vdppd"            : __asm_proxy_VDPPD__,
   799      "vdpps"            : __asm_proxy_VDPPS__,
   800      "vexp2pd"          : __asm_proxy_VEXP2PD__,
   801      "vexp2ps"          : __asm_proxy_VEXP2PS__,
   802      "vexpandpd"        : __asm_proxy_VEXPANDPD__,
   803      "vexpandps"        : __asm_proxy_VEXPANDPS__,
   804      "vextractf128"     : __asm_proxy_VEXTRACTF128__,
   805      "vextractf32x4"    : __asm_proxy_VEXTRACTF32X4__,
   806      "vextractf32x8"    : __asm_proxy_VEXTRACTF32X8__,
   807      "vextractf64x2"    : __asm_proxy_VEXTRACTF64X2__,
   808      "vextractf64x4"    : __asm_proxy_VEXTRACTF64X4__,
   809      "vextracti128"     : __asm_proxy_VEXTRACTI128__,
   810      "vextracti32x4"    : __asm_proxy_VEXTRACTI32X4__,
   811      "vextracti32x8"    : __asm_proxy_VEXTRACTI32X8__,
   812      "vextracti64x2"    : __asm_proxy_VEXTRACTI64X2__,
   813      "vextracti64x4"    : __asm_proxy_VEXTRACTI64X4__,
   814      "vextractps"       : __asm_proxy_VEXTRACTPS__,
   815      "vfixupimmpd"      : __asm_proxy_VFIXUPIMMPD__,
   816      "vfixupimmps"      : __asm_proxy_VFIXUPIMMPS__,
   817      "vfixupimmsd"      : __asm_proxy_VFIXUPIMMSD__,
   818      "vfixupimmss"      : __asm_proxy_VFIXUPIMMSS__,
   819      "vfmadd132pd"      : __asm_proxy_VFMADD132PD__,
   820      "vfmadd132ps"      : __asm_proxy_VFMADD132PS__,
   821      "vfmadd132sd"      : __asm_proxy_VFMADD132SD__,
   822      "vfmadd132ss"      : __asm_proxy_VFMADD132SS__,
   823      "vfmadd213pd"      : __asm_proxy_VFMADD213PD__,
   824      "vfmadd213ps"      : __asm_proxy_VFMADD213PS__,
   825      "vfmadd213sd"      : __asm_proxy_VFMADD213SD__,
   826      "vfmadd213ss"      : __asm_proxy_VFMADD213SS__,
   827      "vfmadd231pd"      : __asm_proxy_VFMADD231PD__,
   828      "vfmadd231ps"      : __asm_proxy_VFMADD231PS__,
   829      "vfmadd231sd"      : __asm_proxy_VFMADD231SD__,
   830      "vfmadd231ss"      : __asm_proxy_VFMADD231SS__,
   831      "vfmaddpd"         : __asm_proxy_VFMADDPD__,
   832      "vfmaddps"         : __asm_proxy_VFMADDPS__,
   833      "vfmaddsd"         : __asm_proxy_VFMADDSD__,
   834      "vfmaddss"         : __asm_proxy_VFMADDSS__,
   835      "vfmaddsub132pd"   : __asm_proxy_VFMADDSUB132PD__,
   836      "vfmaddsub132ps"   : __asm_proxy_VFMADDSUB132PS__,
   837      "vfmaddsub213pd"   : __asm_proxy_VFMADDSUB213PD__,
   838      "vfmaddsub213ps"   : __asm_proxy_VFMADDSUB213PS__,
   839      "vfmaddsub231pd"   : __asm_proxy_VFMADDSUB231PD__,
   840      "vfmaddsub231ps"   : __asm_proxy_VFMADDSUB231PS__,
   841      "vfmaddsubpd"      : __asm_proxy_VFMADDSUBPD__,
   842      "vfmaddsubps"      : __asm_proxy_VFMADDSUBPS__,
   843      "vfmsub132pd"      : __asm_proxy_VFMSUB132PD__,
   844      "vfmsub132ps"      : __asm_proxy_VFMSUB132PS__,
   845      "vfmsub132sd"      : __asm_proxy_VFMSUB132SD__,
   846      "vfmsub132ss"      : __asm_proxy_VFMSUB132SS__,
   847      "vfmsub213pd"      : __asm_proxy_VFMSUB213PD__,
   848      "vfmsub213ps"      : __asm_proxy_VFMSUB213PS__,
   849      "vfmsub213sd"      : __asm_proxy_VFMSUB213SD__,
   850      "vfmsub213ss"      : __asm_proxy_VFMSUB213SS__,
   851      "vfmsub231pd"      : __asm_proxy_VFMSUB231PD__,
   852      "vfmsub231ps"      : __asm_proxy_VFMSUB231PS__,
   853      "vfmsub231sd"      : __asm_proxy_VFMSUB231SD__,
   854      "vfmsub231ss"      : __asm_proxy_VFMSUB231SS__,
   855      "vfmsubadd132pd"   : __asm_proxy_VFMSUBADD132PD__,
   856      "vfmsubadd132ps"   : __asm_proxy_VFMSUBADD132PS__,
   857      "vfmsubadd213pd"   : __asm_proxy_VFMSUBADD213PD__,
   858      "vfmsubadd213ps"   : __asm_proxy_VFMSUBADD213PS__,
   859      "vfmsubadd231pd"   : __asm_proxy_VFMSUBADD231PD__,
   860      "vfmsubadd231ps"   : __asm_proxy_VFMSUBADD231PS__,
   861      "vfmsubaddpd"      : __asm_proxy_VFMSUBADDPD__,
   862      "vfmsubaddps"      : __asm_proxy_VFMSUBADDPS__,
   863      "vfmsubpd"         : __asm_proxy_VFMSUBPD__,
   864      "vfmsubps"         : __asm_proxy_VFMSUBPS__,
   865      "vfmsubsd"         : __asm_proxy_VFMSUBSD__,
   866      "vfmsubss"         : __asm_proxy_VFMSUBSS__,
   867      "vfnmadd132pd"     : __asm_proxy_VFNMADD132PD__,
   868      "vfnmadd132ps"     : __asm_proxy_VFNMADD132PS__,
   869      "vfnmadd132sd"     : __asm_proxy_VFNMADD132SD__,
   870      "vfnmadd132ss"     : __asm_proxy_VFNMADD132SS__,
   871      "vfnmadd213pd"     : __asm_proxy_VFNMADD213PD__,
   872      "vfnmadd213ps"     : __asm_proxy_VFNMADD213PS__,
   873      "vfnmadd213sd"     : __asm_proxy_VFNMADD213SD__,
   874      "vfnmadd213ss"     : __asm_proxy_VFNMADD213SS__,
   875      "vfnmadd231pd"     : __asm_proxy_VFNMADD231PD__,
   876      "vfnmadd231ps"     : __asm_proxy_VFNMADD231PS__,
   877      "vfnmadd231sd"     : __asm_proxy_VFNMADD231SD__,
   878      "vfnmadd231ss"     : __asm_proxy_VFNMADD231SS__,
   879      "vfnmaddpd"        : __asm_proxy_VFNMADDPD__,
   880      "vfnmaddps"        : __asm_proxy_VFNMADDPS__,
   881      "vfnmaddsd"        : __asm_proxy_VFNMADDSD__,
   882      "vfnmaddss"        : __asm_proxy_VFNMADDSS__,
   883      "vfnmsub132pd"     : __asm_proxy_VFNMSUB132PD__,
   884      "vfnmsub132ps"     : __asm_proxy_VFNMSUB132PS__,
   885      "vfnmsub132sd"     : __asm_proxy_VFNMSUB132SD__,
   886      "vfnmsub132ss"     : __asm_proxy_VFNMSUB132SS__,
   887      "vfnmsub213pd"     : __asm_proxy_VFNMSUB213PD__,
   888      "vfnmsub213ps"     : __asm_proxy_VFNMSUB213PS__,
   889      "vfnmsub213sd"     : __asm_proxy_VFNMSUB213SD__,
   890      "vfnmsub213ss"     : __asm_proxy_VFNMSUB213SS__,
   891      "vfnmsub231pd"     : __asm_proxy_VFNMSUB231PD__,
   892      "vfnmsub231ps"     : __asm_proxy_VFNMSUB231PS__,
   893      "vfnmsub231sd"     : __asm_proxy_VFNMSUB231SD__,
   894      "vfnmsub231ss"     : __asm_proxy_VFNMSUB231SS__,
   895      "vfnmsubpd"        : __asm_proxy_VFNMSUBPD__,
   896      "vfnmsubps"        : __asm_proxy_VFNMSUBPS__,
   897      "vfnmsubsd"        : __asm_proxy_VFNMSUBSD__,
   898      "vfnmsubss"        : __asm_proxy_VFNMSUBSS__,
   899      "vfpclasspd"       : __asm_proxy_VFPCLASSPD__,
   900      "vfpclassps"       : __asm_proxy_VFPCLASSPS__,
   901      "vfpclasssd"       : __asm_proxy_VFPCLASSSD__,
   902      "vfpclassss"       : __asm_proxy_VFPCLASSSS__,
   903      "vfrczpd"          : __asm_proxy_VFRCZPD__,
   904      "vfrczps"          : __asm_proxy_VFRCZPS__,
   905      "vfrczsd"          : __asm_proxy_VFRCZSD__,
   906      "vfrczss"          : __asm_proxy_VFRCZSS__,
   907      "vgatherdpd"       : __asm_proxy_VGATHERDPD__,
   908      "vgatherdps"       : __asm_proxy_VGATHERDPS__,
   909      "vgatherpf0dpd"    : __asm_proxy_VGATHERPF0DPD__,
   910      "vgatherpf0dps"    : __asm_proxy_VGATHERPF0DPS__,
   911      "vgatherpf0qpd"    : __asm_proxy_VGATHERPF0QPD__,
   912      "vgatherpf0qps"    : __asm_proxy_VGATHERPF0QPS__,
   913      "vgatherpf1dpd"    : __asm_proxy_VGATHERPF1DPD__,
   914      "vgatherpf1dps"    : __asm_proxy_VGATHERPF1DPS__,
   915      "vgatherpf1qpd"    : __asm_proxy_VGATHERPF1QPD__,
   916      "vgatherpf1qps"    : __asm_proxy_VGATHERPF1QPS__,
   917      "vgatherqpd"       : __asm_proxy_VGATHERQPD__,
   918      "vgatherqps"       : __asm_proxy_VGATHERQPS__,
   919      "vgetexppd"        : __asm_proxy_VGETEXPPD__,
   920      "vgetexpps"        : __asm_proxy_VGETEXPPS__,
   921      "vgetexpsd"        : __asm_proxy_VGETEXPSD__,
   922      "vgetexpss"        : __asm_proxy_VGETEXPSS__,
   923      "vgetmantpd"       : __asm_proxy_VGETMANTPD__,
   924      "vgetmantps"       : __asm_proxy_VGETMANTPS__,
   925      "vgetmantsd"       : __asm_proxy_VGETMANTSD__,
   926      "vgetmantss"       : __asm_proxy_VGETMANTSS__,
   927      "vhaddpd"          : __asm_proxy_VHADDPD__,
   928      "vhaddps"          : __asm_proxy_VHADDPS__,
   929      "vhsubpd"          : __asm_proxy_VHSUBPD__,
   930      "vhsubps"          : __asm_proxy_VHSUBPS__,
   931      "vinsertf128"      : __asm_proxy_VINSERTF128__,
   932      "vinsertf32x4"     : __asm_proxy_VINSERTF32X4__,
   933      "vinsertf32x8"     : __asm_proxy_VINSERTF32X8__,
   934      "vinsertf64x2"     : __asm_proxy_VINSERTF64X2__,
   935      "vinsertf64x4"     : __asm_proxy_VINSERTF64X4__,
   936      "vinserti128"      : __asm_proxy_VINSERTI128__,
   937      "vinserti32x4"     : __asm_proxy_VINSERTI32X4__,
   938      "vinserti32x8"     : __asm_proxy_VINSERTI32X8__,
   939      "vinserti64x2"     : __asm_proxy_VINSERTI64X2__,
   940      "vinserti64x4"     : __asm_proxy_VINSERTI64X4__,
   941      "vinsertps"        : __asm_proxy_VINSERTPS__,
   942      "vlddqu"           : __asm_proxy_VLDDQU__,
   943      "vldmxcsr"         : __asm_proxy_VLDMXCSR__,
   944      "vmaskmovdqu"      : __asm_proxy_VMASKMOVDQU__,
   945      "vmaskmovpd"       : __asm_proxy_VMASKMOVPD__,
   946      "vmaskmovps"       : __asm_proxy_VMASKMOVPS__,
   947      "vmaxpd"           : __asm_proxy_VMAXPD__,
   948      "vmaxps"           : __asm_proxy_VMAXPS__,
   949      "vmaxsd"           : __asm_proxy_VMAXSD__,
   950      "vmaxss"           : __asm_proxy_VMAXSS__,
   951      "vminpd"           : __asm_proxy_VMINPD__,
   952      "vminps"           : __asm_proxy_VMINPS__,
   953      "vminsd"           : __asm_proxy_VMINSD__,
   954      "vminss"           : __asm_proxy_VMINSS__,
   955      "vmovapd"          : __asm_proxy_VMOVAPD__,
   956      "vmovaps"          : __asm_proxy_VMOVAPS__,
   957      "vmovd"            : __asm_proxy_VMOVD__,
   958      "vmovddup"         : __asm_proxy_VMOVDDUP__,
   959      "vmovdqa"          : __asm_proxy_VMOVDQA__,
   960      "vmovdqa32"        : __asm_proxy_VMOVDQA32__,
   961      "vmovdqa64"        : __asm_proxy_VMOVDQA64__,
   962      "vmovdqu"          : __asm_proxy_VMOVDQU__,
   963      "vmovdqu16"        : __asm_proxy_VMOVDQU16__,
   964      "vmovdqu32"        : __asm_proxy_VMOVDQU32__,
   965      "vmovdqu64"        : __asm_proxy_VMOVDQU64__,
   966      "vmovdqu8"         : __asm_proxy_VMOVDQU8__,
   967      "vmovhlps"         : __asm_proxy_VMOVHLPS__,
   968      "vmovhpd"          : __asm_proxy_VMOVHPD__,
   969      "vmovhps"          : __asm_proxy_VMOVHPS__,
   970      "vmovlhps"         : __asm_proxy_VMOVLHPS__,
   971      "vmovlpd"          : __asm_proxy_VMOVLPD__,
   972      "vmovlps"          : __asm_proxy_VMOVLPS__,
   973      "vmovmskpd"        : __asm_proxy_VMOVMSKPD__,
   974      "vmovmskps"        : __asm_proxy_VMOVMSKPS__,
   975      "vmovntdq"         : __asm_proxy_VMOVNTDQ__,
   976      "vmovntdqa"        : __asm_proxy_VMOVNTDQA__,
   977      "vmovntpd"         : __asm_proxy_VMOVNTPD__,
   978      "vmovntps"         : __asm_proxy_VMOVNTPS__,
   979      "vmovq"            : __asm_proxy_VMOVQ__,
   980      "vmovsd"           : __asm_proxy_VMOVSD__,
   981      "vmovshdup"        : __asm_proxy_VMOVSHDUP__,
   982      "vmovsldup"        : __asm_proxy_VMOVSLDUP__,
   983      "vmovss"           : __asm_proxy_VMOVSS__,
   984      "vmovupd"          : __asm_proxy_VMOVUPD__,
   985      "vmovups"          : __asm_proxy_VMOVUPS__,
   986      "vmpsadbw"         : __asm_proxy_VMPSADBW__,
   987      "vmulpd"           : __asm_proxy_VMULPD__,
   988      "vmulps"           : __asm_proxy_VMULPS__,
   989      "vmulsd"           : __asm_proxy_VMULSD__,
   990      "vmulss"           : __asm_proxy_VMULSS__,
   991      "vorpd"            : __asm_proxy_VORPD__,
   992      "vorps"            : __asm_proxy_VORPS__,
   993      "vpabsb"           : __asm_proxy_VPABSB__,
   994      "vpabsd"           : __asm_proxy_VPABSD__,
   995      "vpabsq"           : __asm_proxy_VPABSQ__,
   996      "vpabsw"           : __asm_proxy_VPABSW__,
   997      "vpackssdw"        : __asm_proxy_VPACKSSDW__,
   998      "vpacksswb"        : __asm_proxy_VPACKSSWB__,
   999      "vpackusdw"        : __asm_proxy_VPACKUSDW__,
  1000      "vpackuswb"        : __asm_proxy_VPACKUSWB__,
  1001      "vpaddb"           : __asm_proxy_VPADDB__,
  1002      "vpaddd"           : __asm_proxy_VPADDD__,
  1003      "vpaddq"           : __asm_proxy_VPADDQ__,
  1004      "vpaddsb"          : __asm_proxy_VPADDSB__,
  1005      "vpaddsw"          : __asm_proxy_VPADDSW__,
  1006      "vpaddusb"         : __asm_proxy_VPADDUSB__,
  1007      "vpaddusw"         : __asm_proxy_VPADDUSW__,
  1008      "vpaddw"           : __asm_proxy_VPADDW__,
  1009      "vpalignr"         : __asm_proxy_VPALIGNR__,
  1010      "vpand"            : __asm_proxy_VPAND__,
  1011      "vpandd"           : __asm_proxy_VPANDD__,
  1012      "vpandn"           : __asm_proxy_VPANDN__,
  1013      "vpandnd"          : __asm_proxy_VPANDND__,
  1014      "vpandnq"          : __asm_proxy_VPANDNQ__,
  1015      "vpandq"           : __asm_proxy_VPANDQ__,
  1016      "vpavgb"           : __asm_proxy_VPAVGB__,
  1017      "vpavgw"           : __asm_proxy_VPAVGW__,
  1018      "vpblendd"         : __asm_proxy_VPBLENDD__,
  1019      "vpblendmb"        : __asm_proxy_VPBLENDMB__,
  1020      "vpblendmd"        : __asm_proxy_VPBLENDMD__,
  1021      "vpblendmq"        : __asm_proxy_VPBLENDMQ__,
  1022      "vpblendmw"        : __asm_proxy_VPBLENDMW__,
  1023      "vpblendvb"        : __asm_proxy_VPBLENDVB__,
  1024      "vpblendw"         : __asm_proxy_VPBLENDW__,
  1025      "vpbroadcastb"     : __asm_proxy_VPBROADCASTB__,
  1026      "vpbroadcastd"     : __asm_proxy_VPBROADCASTD__,
  1027      "vpbroadcastmb2q"  : __asm_proxy_VPBROADCASTMB2Q__,
  1028      "vpbroadcastmw2d"  : __asm_proxy_VPBROADCASTMW2D__,
  1029      "vpbroadcastq"     : __asm_proxy_VPBROADCASTQ__,
  1030      "vpbroadcastw"     : __asm_proxy_VPBROADCASTW__,
  1031      "vpclmulqdq"       : __asm_proxy_VPCLMULQDQ__,
  1032      "vpcmov"           : __asm_proxy_VPCMOV__,
  1033      "vpcmpb"           : __asm_proxy_VPCMPB__,
  1034      "vpcmpd"           : __asm_proxy_VPCMPD__,
  1035      "vpcmpeqb"         : __asm_proxy_VPCMPEQB__,
  1036      "vpcmpeqd"         : __asm_proxy_VPCMPEQD__,
  1037      "vpcmpeqq"         : __asm_proxy_VPCMPEQQ__,
  1038      "vpcmpeqw"         : __asm_proxy_VPCMPEQW__,
  1039      "vpcmpestri"       : __asm_proxy_VPCMPESTRI__,
  1040      "vpcmpestrm"       : __asm_proxy_VPCMPESTRM__,
  1041      "vpcmpgtb"         : __asm_proxy_VPCMPGTB__,
  1042      "vpcmpgtd"         : __asm_proxy_VPCMPGTD__,
  1043      "vpcmpgtq"         : __asm_proxy_VPCMPGTQ__,
  1044      "vpcmpgtw"         : __asm_proxy_VPCMPGTW__,
  1045      "vpcmpistri"       : __asm_proxy_VPCMPISTRI__,
  1046      "vpcmpistrm"       : __asm_proxy_VPCMPISTRM__,
  1047      "vpcmpq"           : __asm_proxy_VPCMPQ__,
  1048      "vpcmpub"          : __asm_proxy_VPCMPUB__,
  1049      "vpcmpud"          : __asm_proxy_VPCMPUD__,
  1050      "vpcmpuq"          : __asm_proxy_VPCMPUQ__,
  1051      "vpcmpuw"          : __asm_proxy_VPCMPUW__,
  1052      "vpcmpw"           : __asm_proxy_VPCMPW__,
  1053      "vpcomb"           : __asm_proxy_VPCOMB__,
  1054      "vpcomd"           : __asm_proxy_VPCOMD__,
  1055      "vpcompressd"      : __asm_proxy_VPCOMPRESSD__,
  1056      "vpcompressq"      : __asm_proxy_VPCOMPRESSQ__,
  1057      "vpcomq"           : __asm_proxy_VPCOMQ__,
  1058      "vpcomub"          : __asm_proxy_VPCOMUB__,
  1059      "vpcomud"          : __asm_proxy_VPCOMUD__,
  1060      "vpcomuq"          : __asm_proxy_VPCOMUQ__,
  1061      "vpcomuw"          : __asm_proxy_VPCOMUW__,
  1062      "vpcomw"           : __asm_proxy_VPCOMW__,
  1063      "vpconflictd"      : __asm_proxy_VPCONFLICTD__,
  1064      "vpconflictq"      : __asm_proxy_VPCONFLICTQ__,
  1065      "vperm2f128"       : __asm_proxy_VPERM2F128__,
  1066      "vperm2i128"       : __asm_proxy_VPERM2I128__,
  1067      "vpermb"           : __asm_proxy_VPERMB__,
  1068      "vpermd"           : __asm_proxy_VPERMD__,
  1069      "vpermi2b"         : __asm_proxy_VPERMI2B__,
  1070      "vpermi2d"         : __asm_proxy_VPERMI2D__,
  1071      "vpermi2pd"        : __asm_proxy_VPERMI2PD__,
  1072      "vpermi2ps"        : __asm_proxy_VPERMI2PS__,
  1073      "vpermi2q"         : __asm_proxy_VPERMI2Q__,
  1074      "vpermi2w"         : __asm_proxy_VPERMI2W__,
  1075      "vpermil2pd"       : __asm_proxy_VPERMIL2PD__,
  1076      "vpermil2ps"       : __asm_proxy_VPERMIL2PS__,
  1077      "vpermilpd"        : __asm_proxy_VPERMILPD__,
  1078      "vpermilps"        : __asm_proxy_VPERMILPS__,
  1079      "vpermpd"          : __asm_proxy_VPERMPD__,
  1080      "vpermps"          : __asm_proxy_VPERMPS__,
  1081      "vpermq"           : __asm_proxy_VPERMQ__,
  1082      "vpermt2b"         : __asm_proxy_VPERMT2B__,
  1083      "vpermt2d"         : __asm_proxy_VPERMT2D__,
  1084      "vpermt2pd"        : __asm_proxy_VPERMT2PD__,
  1085      "vpermt2ps"        : __asm_proxy_VPERMT2PS__,
  1086      "vpermt2q"         : __asm_proxy_VPERMT2Q__,
  1087      "vpermt2w"         : __asm_proxy_VPERMT2W__,
  1088      "vpermw"           : __asm_proxy_VPERMW__,
  1089      "vpexpandd"        : __asm_proxy_VPEXPANDD__,
  1090      "vpexpandq"        : __asm_proxy_VPEXPANDQ__,
  1091      "vpextrb"          : __asm_proxy_VPEXTRB__,
  1092      "vpextrd"          : __asm_proxy_VPEXTRD__,
  1093      "vpextrq"          : __asm_proxy_VPEXTRQ__,
  1094      "vpextrw"          : __asm_proxy_VPEXTRW__,
  1095      "vpgatherdd"       : __asm_proxy_VPGATHERDD__,
  1096      "vpgatherdq"       : __asm_proxy_VPGATHERDQ__,
  1097      "vpgatherqd"       : __asm_proxy_VPGATHERQD__,
  1098      "vpgatherqq"       : __asm_proxy_VPGATHERQQ__,
  1099      "vphaddbd"         : __asm_proxy_VPHADDBD__,
  1100      "vphaddbq"         : __asm_proxy_VPHADDBQ__,
  1101      "vphaddbw"         : __asm_proxy_VPHADDBW__,
  1102      "vphaddd"          : __asm_proxy_VPHADDD__,
  1103      "vphadddq"         : __asm_proxy_VPHADDDQ__,
  1104      "vphaddsw"         : __asm_proxy_VPHADDSW__,
  1105      "vphaddubd"        : __asm_proxy_VPHADDUBD__,
  1106      "vphaddubq"        : __asm_proxy_VPHADDUBQ__,
  1107      "vphaddubw"        : __asm_proxy_VPHADDUBW__,
  1108      "vphaddudq"        : __asm_proxy_VPHADDUDQ__,
  1109      "vphadduwd"        : __asm_proxy_VPHADDUWD__,
  1110      "vphadduwq"        : __asm_proxy_VPHADDUWQ__,
  1111      "vphaddw"          : __asm_proxy_VPHADDW__,
  1112      "vphaddwd"         : __asm_proxy_VPHADDWD__,
  1113      "vphaddwq"         : __asm_proxy_VPHADDWQ__,
  1114      "vphminposuw"      : __asm_proxy_VPHMINPOSUW__,
  1115      "vphsubbw"         : __asm_proxy_VPHSUBBW__,
  1116      "vphsubd"          : __asm_proxy_VPHSUBD__,
  1117      "vphsubdq"         : __asm_proxy_VPHSUBDQ__,
  1118      "vphsubsw"         : __asm_proxy_VPHSUBSW__,
  1119      "vphsubw"          : __asm_proxy_VPHSUBW__,
  1120      "vphsubwd"         : __asm_proxy_VPHSUBWD__,
  1121      "vpinsrb"          : __asm_proxy_VPINSRB__,
  1122      "vpinsrd"          : __asm_proxy_VPINSRD__,
  1123      "vpinsrq"          : __asm_proxy_VPINSRQ__,
  1124      "vpinsrw"          : __asm_proxy_VPINSRW__,
  1125      "vplzcntd"         : __asm_proxy_VPLZCNTD__,
  1126      "vplzcntq"         : __asm_proxy_VPLZCNTQ__,
  1127      "vpmacsdd"         : __asm_proxy_VPMACSDD__,
  1128      "vpmacsdqh"        : __asm_proxy_VPMACSDQH__,
  1129      "vpmacsdql"        : __asm_proxy_VPMACSDQL__,
  1130      "vpmacssdd"        : __asm_proxy_VPMACSSDD__,
  1131      "vpmacssdqh"       : __asm_proxy_VPMACSSDQH__,
  1132      "vpmacssdql"       : __asm_proxy_VPMACSSDQL__,
  1133      "vpmacsswd"        : __asm_proxy_VPMACSSWD__,
  1134      "vpmacssww"        : __asm_proxy_VPMACSSWW__,
  1135      "vpmacswd"         : __asm_proxy_VPMACSWD__,
  1136      "vpmacsww"         : __asm_proxy_VPMACSWW__,
  1137      "vpmadcsswd"       : __asm_proxy_VPMADCSSWD__,
  1138      "vpmadcswd"        : __asm_proxy_VPMADCSWD__,
  1139      "vpmadd52huq"      : __asm_proxy_VPMADD52HUQ__,
  1140      "vpmadd52luq"      : __asm_proxy_VPMADD52LUQ__,
  1141      "vpmaddubsw"       : __asm_proxy_VPMADDUBSW__,
  1142      "vpmaddwd"         : __asm_proxy_VPMADDWD__,
  1143      "vpmaskmovd"       : __asm_proxy_VPMASKMOVD__,
  1144      "vpmaskmovq"       : __asm_proxy_VPMASKMOVQ__,
  1145      "vpmaxsb"          : __asm_proxy_VPMAXSB__,
  1146      "vpmaxsd"          : __asm_proxy_VPMAXSD__,
  1147      "vpmaxsq"          : __asm_proxy_VPMAXSQ__,
  1148      "vpmaxsw"          : __asm_proxy_VPMAXSW__,
  1149      "vpmaxub"          : __asm_proxy_VPMAXUB__,
  1150      "vpmaxud"          : __asm_proxy_VPMAXUD__,
  1151      "vpmaxuq"          : __asm_proxy_VPMAXUQ__,
  1152      "vpmaxuw"          : __asm_proxy_VPMAXUW__,
  1153      "vpminsb"          : __asm_proxy_VPMINSB__,
  1154      "vpminsd"          : __asm_proxy_VPMINSD__,
  1155      "vpminsq"          : __asm_proxy_VPMINSQ__,
  1156      "vpminsw"          : __asm_proxy_VPMINSW__,
  1157      "vpminub"          : __asm_proxy_VPMINUB__,
  1158      "vpminud"          : __asm_proxy_VPMINUD__,
  1159      "vpminuq"          : __asm_proxy_VPMINUQ__,
  1160      "vpminuw"          : __asm_proxy_VPMINUW__,
  1161      "vpmovb2m"         : __asm_proxy_VPMOVB2M__,
  1162      "vpmovd2m"         : __asm_proxy_VPMOVD2M__,
  1163      "vpmovdb"          : __asm_proxy_VPMOVDB__,
  1164      "vpmovdw"          : __asm_proxy_VPMOVDW__,
  1165      "vpmovm2b"         : __asm_proxy_VPMOVM2B__,
  1166      "vpmovm2d"         : __asm_proxy_VPMOVM2D__,
  1167      "vpmovm2q"         : __asm_proxy_VPMOVM2Q__,
  1168      "vpmovm2w"         : __asm_proxy_VPMOVM2W__,
  1169      "vpmovmskb"        : __asm_proxy_VPMOVMSKB__,
  1170      "vpmovq2m"         : __asm_proxy_VPMOVQ2M__,
  1171      "vpmovqb"          : __asm_proxy_VPMOVQB__,
  1172      "vpmovqd"          : __asm_proxy_VPMOVQD__,
  1173      "vpmovqw"          : __asm_proxy_VPMOVQW__,
  1174      "vpmovsdb"         : __asm_proxy_VPMOVSDB__,
  1175      "vpmovsdw"         : __asm_proxy_VPMOVSDW__,
  1176      "vpmovsqb"         : __asm_proxy_VPMOVSQB__,
  1177      "vpmovsqd"         : __asm_proxy_VPMOVSQD__,
  1178      "vpmovsqw"         : __asm_proxy_VPMOVSQW__,
  1179      "vpmovswb"         : __asm_proxy_VPMOVSWB__,
  1180      "vpmovsxbd"        : __asm_proxy_VPMOVSXBD__,
  1181      "vpmovsxbq"        : __asm_proxy_VPMOVSXBQ__,
  1182      "vpmovsxbw"        : __asm_proxy_VPMOVSXBW__,
  1183      "vpmovsxdq"        : __asm_proxy_VPMOVSXDQ__,
  1184      "vpmovsxwd"        : __asm_proxy_VPMOVSXWD__,
  1185      "vpmovsxwq"        : __asm_proxy_VPMOVSXWQ__,
  1186      "vpmovusdb"        : __asm_proxy_VPMOVUSDB__,
  1187      "vpmovusdw"        : __asm_proxy_VPMOVUSDW__,
  1188      "vpmovusqb"        : __asm_proxy_VPMOVUSQB__,
  1189      "vpmovusqd"        : __asm_proxy_VPMOVUSQD__,
  1190      "vpmovusqw"        : __asm_proxy_VPMOVUSQW__,
  1191      "vpmovuswb"        : __asm_proxy_VPMOVUSWB__,
  1192      "vpmovw2m"         : __asm_proxy_VPMOVW2M__,
  1193      "vpmovwb"          : __asm_proxy_VPMOVWB__,
  1194      "vpmovzxbd"        : __asm_proxy_VPMOVZXBD__,
  1195      "vpmovzxbq"        : __asm_proxy_VPMOVZXBQ__,
  1196      "vpmovzxbw"        : __asm_proxy_VPMOVZXBW__,
  1197      "vpmovzxdq"        : __asm_proxy_VPMOVZXDQ__,
  1198      "vpmovzxwd"        : __asm_proxy_VPMOVZXWD__,
  1199      "vpmovzxwq"        : __asm_proxy_VPMOVZXWQ__,
  1200      "vpmuldq"          : __asm_proxy_VPMULDQ__,
  1201      "vpmulhrsw"        : __asm_proxy_VPMULHRSW__,
  1202      "vpmulhuw"         : __asm_proxy_VPMULHUW__,
  1203      "vpmulhw"          : __asm_proxy_VPMULHW__,
  1204      "vpmulld"          : __asm_proxy_VPMULLD__,
  1205      "vpmullq"          : __asm_proxy_VPMULLQ__,
  1206      "vpmullw"          : __asm_proxy_VPMULLW__,
  1207      "vpmultishiftqb"   : __asm_proxy_VPMULTISHIFTQB__,
  1208      "vpmuludq"         : __asm_proxy_VPMULUDQ__,
  1209      "vpopcntd"         : __asm_proxy_VPOPCNTD__,
  1210      "vpopcntq"         : __asm_proxy_VPOPCNTQ__,
  1211      "vpor"             : __asm_proxy_VPOR__,
  1212      "vpord"            : __asm_proxy_VPORD__,
  1213      "vporq"            : __asm_proxy_VPORQ__,
  1214      "vpperm"           : __asm_proxy_VPPERM__,
  1215      "vprold"           : __asm_proxy_VPROLD__,
  1216      "vprolq"           : __asm_proxy_VPROLQ__,
  1217      "vprolvd"          : __asm_proxy_VPROLVD__,
  1218      "vprolvq"          : __asm_proxy_VPROLVQ__,
  1219      "vprord"           : __asm_proxy_VPRORD__,
  1220      "vprorq"           : __asm_proxy_VPRORQ__,
  1221      "vprorvd"          : __asm_proxy_VPRORVD__,
  1222      "vprorvq"          : __asm_proxy_VPRORVQ__,
  1223      "vprotb"           : __asm_proxy_VPROTB__,
  1224      "vprotd"           : __asm_proxy_VPROTD__,
  1225      "vprotq"           : __asm_proxy_VPROTQ__,
  1226      "vprotw"           : __asm_proxy_VPROTW__,
  1227      "vpsadbw"          : __asm_proxy_VPSADBW__,
  1228      "vpscatterdd"      : __asm_proxy_VPSCATTERDD__,
  1229      "vpscatterdq"      : __asm_proxy_VPSCATTERDQ__,
  1230      "vpscatterqd"      : __asm_proxy_VPSCATTERQD__,
  1231      "vpscatterqq"      : __asm_proxy_VPSCATTERQQ__,
  1232      "vpshab"           : __asm_proxy_VPSHAB__,
  1233      "vpshad"           : __asm_proxy_VPSHAD__,
  1234      "vpshaq"           : __asm_proxy_VPSHAQ__,
  1235      "vpshaw"           : __asm_proxy_VPSHAW__,
  1236      "vpshlb"           : __asm_proxy_VPSHLB__,
  1237      "vpshld"           : __asm_proxy_VPSHLD__,
  1238      "vpshlq"           : __asm_proxy_VPSHLQ__,
  1239      "vpshlw"           : __asm_proxy_VPSHLW__,
  1240      "vpshufb"          : __asm_proxy_VPSHUFB__,
  1241      "vpshufd"          : __asm_proxy_VPSHUFD__,
  1242      "vpshufhw"         : __asm_proxy_VPSHUFHW__,
  1243      "vpshuflw"         : __asm_proxy_VPSHUFLW__,
  1244      "vpsignb"          : __asm_proxy_VPSIGNB__,
  1245      "vpsignd"          : __asm_proxy_VPSIGND__,
  1246      "vpsignw"          : __asm_proxy_VPSIGNW__,
  1247      "vpslld"           : __asm_proxy_VPSLLD__,
  1248      "vpslldq"          : __asm_proxy_VPSLLDQ__,
  1249      "vpsllq"           : __asm_proxy_VPSLLQ__,
  1250      "vpsllvd"          : __asm_proxy_VPSLLVD__,
  1251      "vpsllvq"          : __asm_proxy_VPSLLVQ__,
  1252      "vpsllvw"          : __asm_proxy_VPSLLVW__,
  1253      "vpsllw"           : __asm_proxy_VPSLLW__,
  1254      "vpsrad"           : __asm_proxy_VPSRAD__,
  1255      "vpsraq"           : __asm_proxy_VPSRAQ__,
  1256      "vpsravd"          : __asm_proxy_VPSRAVD__,
  1257      "vpsravq"          : __asm_proxy_VPSRAVQ__,
  1258      "vpsravw"          : __asm_proxy_VPSRAVW__,
  1259      "vpsraw"           : __asm_proxy_VPSRAW__,
  1260      "vpsrld"           : __asm_proxy_VPSRLD__,
  1261      "vpsrldq"          : __asm_proxy_VPSRLDQ__,
  1262      "vpsrlq"           : __asm_proxy_VPSRLQ__,
  1263      "vpsrlvd"          : __asm_proxy_VPSRLVD__,
  1264      "vpsrlvq"          : __asm_proxy_VPSRLVQ__,
  1265      "vpsrlvw"          : __asm_proxy_VPSRLVW__,
  1266      "vpsrlw"           : __asm_proxy_VPSRLW__,
  1267      "vpsubb"           : __asm_proxy_VPSUBB__,
  1268      "vpsubd"           : __asm_proxy_VPSUBD__,
  1269      "vpsubq"           : __asm_proxy_VPSUBQ__,
  1270      "vpsubsb"          : __asm_proxy_VPSUBSB__,
  1271      "vpsubsw"          : __asm_proxy_VPSUBSW__,
  1272      "vpsubusb"         : __asm_proxy_VPSUBUSB__,
  1273      "vpsubusw"         : __asm_proxy_VPSUBUSW__,
  1274      "vpsubw"           : __asm_proxy_VPSUBW__,
  1275      "vpternlogd"       : __asm_proxy_VPTERNLOGD__,
  1276      "vpternlogq"       : __asm_proxy_VPTERNLOGQ__,
  1277      "vptest"           : __asm_proxy_VPTEST__,
  1278      "vptestmb"         : __asm_proxy_VPTESTMB__,
  1279      "vptestmd"         : __asm_proxy_VPTESTMD__,
  1280      "vptestmq"         : __asm_proxy_VPTESTMQ__,
  1281      "vptestmw"         : __asm_proxy_VPTESTMW__,
  1282      "vptestnmb"        : __asm_proxy_VPTESTNMB__,
  1283      "vptestnmd"        : __asm_proxy_VPTESTNMD__,
  1284      "vptestnmq"        : __asm_proxy_VPTESTNMQ__,
  1285      "vptestnmw"        : __asm_proxy_VPTESTNMW__,
  1286      "vpunpckhbw"       : __asm_proxy_VPUNPCKHBW__,
  1287      "vpunpckhdq"       : __asm_proxy_VPUNPCKHDQ__,
  1288      "vpunpckhqdq"      : __asm_proxy_VPUNPCKHQDQ__,
  1289      "vpunpckhwd"       : __asm_proxy_VPUNPCKHWD__,
  1290      "vpunpcklbw"       : __asm_proxy_VPUNPCKLBW__,
  1291      "vpunpckldq"       : __asm_proxy_VPUNPCKLDQ__,
  1292      "vpunpcklqdq"      : __asm_proxy_VPUNPCKLQDQ__,
  1293      "vpunpcklwd"       : __asm_proxy_VPUNPCKLWD__,
  1294      "vpxor"            : __asm_proxy_VPXOR__,
  1295      "vpxord"           : __asm_proxy_VPXORD__,
  1296      "vpxorq"           : __asm_proxy_VPXORQ__,
  1297      "vrangepd"         : __asm_proxy_VRANGEPD__,
  1298      "vrangeps"         : __asm_proxy_VRANGEPS__,
  1299      "vrangesd"         : __asm_proxy_VRANGESD__,
  1300      "vrangess"         : __asm_proxy_VRANGESS__,
  1301      "vrcp14pd"         : __asm_proxy_VRCP14PD__,
  1302      "vrcp14ps"         : __asm_proxy_VRCP14PS__,
  1303      "vrcp14sd"         : __asm_proxy_VRCP14SD__,
  1304      "vrcp14ss"         : __asm_proxy_VRCP14SS__,
  1305      "vrcp28pd"         : __asm_proxy_VRCP28PD__,
  1306      "vrcp28ps"         : __asm_proxy_VRCP28PS__,
  1307      "vrcp28sd"         : __asm_proxy_VRCP28SD__,
  1308      "vrcp28ss"         : __asm_proxy_VRCP28SS__,
  1309      "vrcpps"           : __asm_proxy_VRCPPS__,
  1310      "vrcpss"           : __asm_proxy_VRCPSS__,
  1311      "vreducepd"        : __asm_proxy_VREDUCEPD__,
  1312      "vreduceps"        : __asm_proxy_VREDUCEPS__,
  1313      "vreducesd"        : __asm_proxy_VREDUCESD__,
  1314      "vreducess"        : __asm_proxy_VREDUCESS__,
  1315      "vrndscalepd"      : __asm_proxy_VRNDSCALEPD__,
  1316      "vrndscaleps"      : __asm_proxy_VRNDSCALEPS__,
  1317      "vrndscalesd"      : __asm_proxy_VRNDSCALESD__,
  1318      "vrndscaless"      : __asm_proxy_VRNDSCALESS__,
  1319      "vroundpd"         : __asm_proxy_VROUNDPD__,
  1320      "vroundps"         : __asm_proxy_VROUNDPS__,
  1321      "vroundsd"         : __asm_proxy_VROUNDSD__,
  1322      "vroundss"         : __asm_proxy_VROUNDSS__,
  1323      "vrsqrt14pd"       : __asm_proxy_VRSQRT14PD__,
  1324      "vrsqrt14ps"       : __asm_proxy_VRSQRT14PS__,
  1325      "vrsqrt14sd"       : __asm_proxy_VRSQRT14SD__,
  1326      "vrsqrt14ss"       : __asm_proxy_VRSQRT14SS__,
  1327      "vrsqrt28pd"       : __asm_proxy_VRSQRT28PD__,
  1328      "vrsqrt28ps"       : __asm_proxy_VRSQRT28PS__,
  1329      "vrsqrt28sd"       : __asm_proxy_VRSQRT28SD__,
  1330      "vrsqrt28ss"       : __asm_proxy_VRSQRT28SS__,
  1331      "vrsqrtps"         : __asm_proxy_VRSQRTPS__,
  1332      "vrsqrtss"         : __asm_proxy_VRSQRTSS__,
  1333      "vscalefpd"        : __asm_proxy_VSCALEFPD__,
  1334      "vscalefps"        : __asm_proxy_VSCALEFPS__,
  1335      "vscalefsd"        : __asm_proxy_VSCALEFSD__,
  1336      "vscalefss"        : __asm_proxy_VSCALEFSS__,
  1337      "vscatterdpd"      : __asm_proxy_VSCATTERDPD__,
  1338      "vscatterdps"      : __asm_proxy_VSCATTERDPS__,
  1339      "vscatterpf0dpd"   : __asm_proxy_VSCATTERPF0DPD__,
  1340      "vscatterpf0dps"   : __asm_proxy_VSCATTERPF0DPS__,
  1341      "vscatterpf0qpd"   : __asm_proxy_VSCATTERPF0QPD__,
  1342      "vscatterpf0qps"   : __asm_proxy_VSCATTERPF0QPS__,
  1343      "vscatterpf1dpd"   : __asm_proxy_VSCATTERPF1DPD__,
  1344      "vscatterpf1dps"   : __asm_proxy_VSCATTERPF1DPS__,
  1345      "vscatterpf1qpd"   : __asm_proxy_VSCATTERPF1QPD__,
  1346      "vscatterpf1qps"   : __asm_proxy_VSCATTERPF1QPS__,
  1347      "vscatterqpd"      : __asm_proxy_VSCATTERQPD__,
  1348      "vscatterqps"      : __asm_proxy_VSCATTERQPS__,
  1349      "vshuff32x4"       : __asm_proxy_VSHUFF32X4__,
  1350      "vshuff64x2"       : __asm_proxy_VSHUFF64X2__,
  1351      "vshufi32x4"       : __asm_proxy_VSHUFI32X4__,
  1352      "vshufi64x2"       : __asm_proxy_VSHUFI64X2__,
  1353      "vshufpd"          : __asm_proxy_VSHUFPD__,
  1354      "vshufps"          : __asm_proxy_VSHUFPS__,
  1355      "vsqrtpd"          : __asm_proxy_VSQRTPD__,
  1356      "vsqrtps"          : __asm_proxy_VSQRTPS__,
  1357      "vsqrtsd"          : __asm_proxy_VSQRTSD__,
  1358      "vsqrtss"          : __asm_proxy_VSQRTSS__,
  1359      "vstmxcsr"         : __asm_proxy_VSTMXCSR__,
  1360      "vsubpd"           : __asm_proxy_VSUBPD__,
  1361      "vsubps"           : __asm_proxy_VSUBPS__,
  1362      "vsubsd"           : __asm_proxy_VSUBSD__,
  1363      "vsubss"           : __asm_proxy_VSUBSS__,
  1364      "vtestpd"          : __asm_proxy_VTESTPD__,
  1365      "vtestps"          : __asm_proxy_VTESTPS__,
  1366      "vucomisd"         : __asm_proxy_VUCOMISD__,
  1367      "vucomiss"         : __asm_proxy_VUCOMISS__,
  1368      "vunpckhpd"        : __asm_proxy_VUNPCKHPD__,
  1369      "vunpckhps"        : __asm_proxy_VUNPCKHPS__,
  1370      "vunpcklpd"        : __asm_proxy_VUNPCKLPD__,
  1371      "vunpcklps"        : __asm_proxy_VUNPCKLPS__,
  1372      "vxorpd"           : __asm_proxy_VXORPD__,
  1373      "vxorps"           : __asm_proxy_VXORPS__,
  1374      "vzeroall"         : __asm_proxy_VZEROALL__,
  1375      "vzeroupper"       : __asm_proxy_VZEROUPPER__,
  1376      "xaddb"            : __asm_proxy_XADDB__,
  1377      "xaddl"            : __asm_proxy_XADDL__,
  1378      "xaddq"            : __asm_proxy_XADDQ__,
  1379      "xaddw"            : __asm_proxy_XADDW__,
  1380      "xchgb"            : __asm_proxy_XCHGB__,
  1381      "xchgl"            : __asm_proxy_XCHGL__,
  1382      "xchgq"            : __asm_proxy_XCHGQ__,
  1383      "xchgw"            : __asm_proxy_XCHGW__,
  1384      "xgetbv"           : __asm_proxy_XGETBV__,
  1385      "xlatb"            : __asm_proxy_XLATB__,
  1386      "xorb"             : __asm_proxy_XORB__,
  1387      "xorl"             : __asm_proxy_XORL__,
  1388      "xorpd"            : __asm_proxy_XORPD__,
  1389      "xorps"            : __asm_proxy_XORPS__,
  1390      "xorq"             : __asm_proxy_XORQ__,
  1391      "xorw"             : __asm_proxy_XORW__,
  1392  }
  1393  
  1394  func __asm_proxy_ADCB__(p *Program, v ...interface{}) *Instruction {
  1395      if len(v) == 2 {
  1396          return p.ADCB(v[0], v[1])
  1397      } else {
  1398          panic("instruction ADCB takes exactly 2 operands")
  1399      }
  1400  }
  1401  
  1402  func __asm_proxy_ADCL__(p *Program, v ...interface{}) *Instruction {
  1403      if len(v) == 2 {
  1404          return p.ADCL(v[0], v[1])
  1405      } else {
  1406          panic("instruction ADCL takes exactly 2 operands")
  1407      }
  1408  }
  1409  
  1410  func __asm_proxy_ADCQ__(p *Program, v ...interface{}) *Instruction {
  1411      if len(v) == 2 {
  1412          return p.ADCQ(v[0], v[1])
  1413      } else {
  1414          panic("instruction ADCQ takes exactly 2 operands")
  1415      }
  1416  }
  1417  
  1418  func __asm_proxy_ADCW__(p *Program, v ...interface{}) *Instruction {
  1419      if len(v) == 2 {
  1420          return p.ADCW(v[0], v[1])
  1421      } else {
  1422          panic("instruction ADCW takes exactly 2 operands")
  1423      }
  1424  }
  1425  
  1426  func __asm_proxy_ADCXL__(p *Program, v ...interface{}) *Instruction {
  1427      if len(v) == 2 {
  1428          return p.ADCXL(v[0], v[1])
  1429      } else {
  1430          panic("instruction ADCXL takes exactly 2 operands")
  1431      }
  1432  }
  1433  
  1434  func __asm_proxy_ADCXQ__(p *Program, v ...interface{}) *Instruction {
  1435      if len(v) == 2 {
  1436          return p.ADCXQ(v[0], v[1])
  1437      } else {
  1438          panic("instruction ADCXQ takes exactly 2 operands")
  1439      }
  1440  }
  1441  
  1442  func __asm_proxy_ADDB__(p *Program, v ...interface{}) *Instruction {
  1443      if len(v) == 2 {
  1444          return p.ADDB(v[0], v[1])
  1445      } else {
  1446          panic("instruction ADDB takes exactly 2 operands")
  1447      }
  1448  }
  1449  
  1450  func __asm_proxy_ADDL__(p *Program, v ...interface{}) *Instruction {
  1451      if len(v) == 2 {
  1452          return p.ADDL(v[0], v[1])
  1453      } else {
  1454          panic("instruction ADDL takes exactly 2 operands")
  1455      }
  1456  }
  1457  
  1458  func __asm_proxy_ADDPD__(p *Program, v ...interface{}) *Instruction {
  1459      if len(v) == 2 {
  1460          return p.ADDPD(v[0], v[1])
  1461      } else {
  1462          panic("instruction ADDPD takes exactly 2 operands")
  1463      }
  1464  }
  1465  
  1466  func __asm_proxy_ADDPS__(p *Program, v ...interface{}) *Instruction {
  1467      if len(v) == 2 {
  1468          return p.ADDPS(v[0], v[1])
  1469      } else {
  1470          panic("instruction ADDPS takes exactly 2 operands")
  1471      }
  1472  }
  1473  
  1474  func __asm_proxy_ADDQ__(p *Program, v ...interface{}) *Instruction {
  1475      if len(v) == 2 {
  1476          return p.ADDQ(v[0], v[1])
  1477      } else {
  1478          panic("instruction ADDQ takes exactly 2 operands")
  1479      }
  1480  }
  1481  
  1482  func __asm_proxy_ADDSD__(p *Program, v ...interface{}) *Instruction {
  1483      if len(v) == 2 {
  1484          return p.ADDSD(v[0], v[1])
  1485      } else {
  1486          panic("instruction ADDSD takes exactly 2 operands")
  1487      }
  1488  }
  1489  
  1490  func __asm_proxy_ADDSS__(p *Program, v ...interface{}) *Instruction {
  1491      if len(v) == 2 {
  1492          return p.ADDSS(v[0], v[1])
  1493      } else {
  1494          panic("instruction ADDSS takes exactly 2 operands")
  1495      }
  1496  }
  1497  
  1498  func __asm_proxy_ADDSUBPD__(p *Program, v ...interface{}) *Instruction {
  1499      if len(v) == 2 {
  1500          return p.ADDSUBPD(v[0], v[1])
  1501      } else {
  1502          panic("instruction ADDSUBPD takes exactly 2 operands")
  1503      }
  1504  }
  1505  
  1506  func __asm_proxy_ADDSUBPS__(p *Program, v ...interface{}) *Instruction {
  1507      if len(v) == 2 {
  1508          return p.ADDSUBPS(v[0], v[1])
  1509      } else {
  1510          panic("instruction ADDSUBPS takes exactly 2 operands")
  1511      }
  1512  }
  1513  
  1514  func __asm_proxy_ADDW__(p *Program, v ...interface{}) *Instruction {
  1515      if len(v) == 2 {
  1516          return p.ADDW(v[0], v[1])
  1517      } else {
  1518          panic("instruction ADDW takes exactly 2 operands")
  1519      }
  1520  }
  1521  
  1522  func __asm_proxy_ADOXL__(p *Program, v ...interface{}) *Instruction {
  1523      if len(v) == 2 {
  1524          return p.ADOXL(v[0], v[1])
  1525      } else {
  1526          panic("instruction ADOXL takes exactly 2 operands")
  1527      }
  1528  }
  1529  
  1530  func __asm_proxy_ADOXQ__(p *Program, v ...interface{}) *Instruction {
  1531      if len(v) == 2 {
  1532          return p.ADOXQ(v[0], v[1])
  1533      } else {
  1534          panic("instruction ADOXQ takes exactly 2 operands")
  1535      }
  1536  }
  1537  
  1538  func __asm_proxy_AESDEC__(p *Program, v ...interface{}) *Instruction {
  1539      if len(v) == 2 {
  1540          return p.AESDEC(v[0], v[1])
  1541      } else {
  1542          panic("instruction AESDEC takes exactly 2 operands")
  1543      }
  1544  }
  1545  
  1546  func __asm_proxy_AESDECLAST__(p *Program, v ...interface{}) *Instruction {
  1547      if len(v) == 2 {
  1548          return p.AESDECLAST(v[0], v[1])
  1549      } else {
  1550          panic("instruction AESDECLAST takes exactly 2 operands")
  1551      }
  1552  }
  1553  
  1554  func __asm_proxy_AESENC__(p *Program, v ...interface{}) *Instruction {
  1555      if len(v) == 2 {
  1556          return p.AESENC(v[0], v[1])
  1557      } else {
  1558          panic("instruction AESENC takes exactly 2 operands")
  1559      }
  1560  }
  1561  
  1562  func __asm_proxy_AESENCLAST__(p *Program, v ...interface{}) *Instruction {
  1563      if len(v) == 2 {
  1564          return p.AESENCLAST(v[0], v[1])
  1565      } else {
  1566          panic("instruction AESENCLAST takes exactly 2 operands")
  1567      }
  1568  }
  1569  
  1570  func __asm_proxy_AESIMC__(p *Program, v ...interface{}) *Instruction {
  1571      if len(v) == 2 {
  1572          return p.AESIMC(v[0], v[1])
  1573      } else {
  1574          panic("instruction AESIMC takes exactly 2 operands")
  1575      }
  1576  }
  1577  
  1578  func __asm_proxy_AESKEYGENASSIST__(p *Program, v ...interface{}) *Instruction {
  1579      if len(v) == 3 {
  1580          return p.AESKEYGENASSIST(v[0], v[1], v[2])
  1581      } else {
  1582          panic("instruction AESKEYGENASSIST takes exactly 3 operands")
  1583      }
  1584  }
  1585  
  1586  func __asm_proxy_ANDB__(p *Program, v ...interface{}) *Instruction {
  1587      if len(v) == 2 {
  1588          return p.ANDB(v[0], v[1])
  1589      } else {
  1590          panic("instruction ANDB takes exactly 2 operands")
  1591      }
  1592  }
  1593  
  1594  func __asm_proxy_ANDL__(p *Program, v ...interface{}) *Instruction {
  1595      if len(v) == 2 {
  1596          return p.ANDL(v[0], v[1])
  1597      } else {
  1598          panic("instruction ANDL takes exactly 2 operands")
  1599      }
  1600  }
  1601  
  1602  func __asm_proxy_ANDNL__(p *Program, v ...interface{}) *Instruction {
  1603      if len(v) == 3 {
  1604          return p.ANDNL(v[0], v[1], v[2])
  1605      } else {
  1606          panic("instruction ANDNL takes exactly 3 operands")
  1607      }
  1608  }
  1609  
  1610  func __asm_proxy_ANDNPD__(p *Program, v ...interface{}) *Instruction {
  1611      if len(v) == 2 {
  1612          return p.ANDNPD(v[0], v[1])
  1613      } else {
  1614          panic("instruction ANDNPD takes exactly 2 operands")
  1615      }
  1616  }
  1617  
  1618  func __asm_proxy_ANDNPS__(p *Program, v ...interface{}) *Instruction {
  1619      if len(v) == 2 {
  1620          return p.ANDNPS(v[0], v[1])
  1621      } else {
  1622          panic("instruction ANDNPS takes exactly 2 operands")
  1623      }
  1624  }
  1625  
  1626  func __asm_proxy_ANDNQ__(p *Program, v ...interface{}) *Instruction {
  1627      if len(v) == 3 {
  1628          return p.ANDNQ(v[0], v[1], v[2])
  1629      } else {
  1630          panic("instruction ANDNQ takes exactly 3 operands")
  1631      }
  1632  }
  1633  
  1634  func __asm_proxy_ANDPD__(p *Program, v ...interface{}) *Instruction {
  1635      if len(v) == 2 {
  1636          return p.ANDPD(v[0], v[1])
  1637      } else {
  1638          panic("instruction ANDPD takes exactly 2 operands")
  1639      }
  1640  }
  1641  
  1642  func __asm_proxy_ANDPS__(p *Program, v ...interface{}) *Instruction {
  1643      if len(v) == 2 {
  1644          return p.ANDPS(v[0], v[1])
  1645      } else {
  1646          panic("instruction ANDPS takes exactly 2 operands")
  1647      }
  1648  }
  1649  
  1650  func __asm_proxy_ANDQ__(p *Program, v ...interface{}) *Instruction {
  1651      if len(v) == 2 {
  1652          return p.ANDQ(v[0], v[1])
  1653      } else {
  1654          panic("instruction ANDQ takes exactly 2 operands")
  1655      }
  1656  }
  1657  
  1658  func __asm_proxy_ANDW__(p *Program, v ...interface{}) *Instruction {
  1659      if len(v) == 2 {
  1660          return p.ANDW(v[0], v[1])
  1661      } else {
  1662          panic("instruction ANDW takes exactly 2 operands")
  1663      }
  1664  }
  1665  
  1666  func __asm_proxy_BEXTR__(p *Program, v ...interface{}) *Instruction {
  1667      if len(v) == 3 {
  1668          return p.BEXTR(v[0], v[1], v[2])
  1669      } else {
  1670          panic("instruction BEXTR takes exactly 3 operands")
  1671      }
  1672  }
  1673  
  1674  func __asm_proxy_BLCFILL__(p *Program, v ...interface{}) *Instruction {
  1675      if len(v) == 2 {
  1676          return p.BLCFILL(v[0], v[1])
  1677      } else {
  1678          panic("instruction BLCFILL takes exactly 2 operands")
  1679      }
  1680  }
  1681  
  1682  func __asm_proxy_BLCI__(p *Program, v ...interface{}) *Instruction {
  1683      if len(v) == 2 {
  1684          return p.BLCI(v[0], v[1])
  1685      } else {
  1686          panic("instruction BLCI takes exactly 2 operands")
  1687      }
  1688  }
  1689  
  1690  func __asm_proxy_BLCIC__(p *Program, v ...interface{}) *Instruction {
  1691      if len(v) == 2 {
  1692          return p.BLCIC(v[0], v[1])
  1693      } else {
  1694          panic("instruction BLCIC takes exactly 2 operands")
  1695      }
  1696  }
  1697  
  1698  func __asm_proxy_BLCMSK__(p *Program, v ...interface{}) *Instruction {
  1699      if len(v) == 2 {
  1700          return p.BLCMSK(v[0], v[1])
  1701      } else {
  1702          panic("instruction BLCMSK takes exactly 2 operands")
  1703      }
  1704  }
  1705  
  1706  func __asm_proxy_BLCS__(p *Program, v ...interface{}) *Instruction {
  1707      if len(v) == 2 {
  1708          return p.BLCS(v[0], v[1])
  1709      } else {
  1710          panic("instruction BLCS takes exactly 2 operands")
  1711      }
  1712  }
  1713  
  1714  func __asm_proxy_BLENDPD__(p *Program, v ...interface{}) *Instruction {
  1715      if len(v) == 3 {
  1716          return p.BLENDPD(v[0], v[1], v[2])
  1717      } else {
  1718          panic("instruction BLENDPD takes exactly 3 operands")
  1719      }
  1720  }
  1721  
  1722  func __asm_proxy_BLENDPS__(p *Program, v ...interface{}) *Instruction {
  1723      if len(v) == 3 {
  1724          return p.BLENDPS(v[0], v[1], v[2])
  1725      } else {
  1726          panic("instruction BLENDPS takes exactly 3 operands")
  1727      }
  1728  }
  1729  
  1730  func __asm_proxy_BLENDVPD__(p *Program, v ...interface{}) *Instruction {
  1731      if len(v) == 3 {
  1732          return p.BLENDVPD(v[0], v[1], v[2])
  1733      } else {
  1734          panic("instruction BLENDVPD takes exactly 3 operands")
  1735      }
  1736  }
  1737  
  1738  func __asm_proxy_BLENDVPS__(p *Program, v ...interface{}) *Instruction {
  1739      if len(v) == 3 {
  1740          return p.BLENDVPS(v[0], v[1], v[2])
  1741      } else {
  1742          panic("instruction BLENDVPS takes exactly 3 operands")
  1743      }
  1744  }
  1745  
  1746  func __asm_proxy_BLSFILL__(p *Program, v ...interface{}) *Instruction {
  1747      if len(v) == 2 {
  1748          return p.BLSFILL(v[0], v[1])
  1749      } else {
  1750          panic("instruction BLSFILL takes exactly 2 operands")
  1751      }
  1752  }
  1753  
  1754  func __asm_proxy_BLSI__(p *Program, v ...interface{}) *Instruction {
  1755      if len(v) == 2 {
  1756          return p.BLSI(v[0], v[1])
  1757      } else {
  1758          panic("instruction BLSI takes exactly 2 operands")
  1759      }
  1760  }
  1761  
  1762  func __asm_proxy_BLSIC__(p *Program, v ...interface{}) *Instruction {
  1763      if len(v) == 2 {
  1764          return p.BLSIC(v[0], v[1])
  1765      } else {
  1766          panic("instruction BLSIC takes exactly 2 operands")
  1767      }
  1768  }
  1769  
  1770  func __asm_proxy_BLSMSK__(p *Program, v ...interface{}) *Instruction {
  1771      if len(v) == 2 {
  1772          return p.BLSMSK(v[0], v[1])
  1773      } else {
  1774          panic("instruction BLSMSK takes exactly 2 operands")
  1775      }
  1776  }
  1777  
  1778  func __asm_proxy_BLSR__(p *Program, v ...interface{}) *Instruction {
  1779      if len(v) == 2 {
  1780          return p.BLSR(v[0], v[1])
  1781      } else {
  1782          panic("instruction BLSR takes exactly 2 operands")
  1783      }
  1784  }
  1785  
  1786  func __asm_proxy_BSFL__(p *Program, v ...interface{}) *Instruction {
  1787      if len(v) == 2 {
  1788          return p.BSFL(v[0], v[1])
  1789      } else {
  1790          panic("instruction BSFL takes exactly 2 operands")
  1791      }
  1792  }
  1793  
  1794  func __asm_proxy_BSFQ__(p *Program, v ...interface{}) *Instruction {
  1795      if len(v) == 2 {
  1796          return p.BSFQ(v[0], v[1])
  1797      } else {
  1798          panic("instruction BSFQ takes exactly 2 operands")
  1799      }
  1800  }
  1801  
  1802  func __asm_proxy_BSFW__(p *Program, v ...interface{}) *Instruction {
  1803      if len(v) == 2 {
  1804          return p.BSFW(v[0], v[1])
  1805      } else {
  1806          panic("instruction BSFW takes exactly 2 operands")
  1807      }
  1808  }
  1809  
  1810  func __asm_proxy_BSRL__(p *Program, v ...interface{}) *Instruction {
  1811      if len(v) == 2 {
  1812          return p.BSRL(v[0], v[1])
  1813      } else {
  1814          panic("instruction BSRL takes exactly 2 operands")
  1815      }
  1816  }
  1817  
  1818  func __asm_proxy_BSRQ__(p *Program, v ...interface{}) *Instruction {
  1819      if len(v) == 2 {
  1820          return p.BSRQ(v[0], v[1])
  1821      } else {
  1822          panic("instruction BSRQ takes exactly 2 operands")
  1823      }
  1824  }
  1825  
  1826  func __asm_proxy_BSRW__(p *Program, v ...interface{}) *Instruction {
  1827      if len(v) == 2 {
  1828          return p.BSRW(v[0], v[1])
  1829      } else {
  1830          panic("instruction BSRW takes exactly 2 operands")
  1831      }
  1832  }
  1833  
  1834  func __asm_proxy_BSWAPL__(p *Program, v ...interface{}) *Instruction {
  1835      if len(v) == 1 {
  1836          return p.BSWAPL(v[0])
  1837      } else {
  1838          panic("instruction BSWAPL takes exactly 1 operand")
  1839      }
  1840  }
  1841  
  1842  func __asm_proxy_BSWAPQ__(p *Program, v ...interface{}) *Instruction {
  1843      if len(v) == 1 {
  1844          return p.BSWAPQ(v[0])
  1845      } else {
  1846          panic("instruction BSWAPQ takes exactly 1 operand")
  1847      }
  1848  }
  1849  
  1850  func __asm_proxy_BTCL__(p *Program, v ...interface{}) *Instruction {
  1851      if len(v) == 2 {
  1852          return p.BTCL(v[0], v[1])
  1853      } else {
  1854          panic("instruction BTCL takes exactly 2 operands")
  1855      }
  1856  }
  1857  
  1858  func __asm_proxy_BTCQ__(p *Program, v ...interface{}) *Instruction {
  1859      if len(v) == 2 {
  1860          return p.BTCQ(v[0], v[1])
  1861      } else {
  1862          panic("instruction BTCQ takes exactly 2 operands")
  1863      }
  1864  }
  1865  
  1866  func __asm_proxy_BTCW__(p *Program, v ...interface{}) *Instruction {
  1867      if len(v) == 2 {
  1868          return p.BTCW(v[0], v[1])
  1869      } else {
  1870          panic("instruction BTCW takes exactly 2 operands")
  1871      }
  1872  }
  1873  
  1874  func __asm_proxy_BTL__(p *Program, v ...interface{}) *Instruction {
  1875      if len(v) == 2 {
  1876          return p.BTL(v[0], v[1])
  1877      } else {
  1878          panic("instruction BTL takes exactly 2 operands")
  1879      }
  1880  }
  1881  
  1882  func __asm_proxy_BTQ__(p *Program, v ...interface{}) *Instruction {
  1883      if len(v) == 2 {
  1884          return p.BTQ(v[0], v[1])
  1885      } else {
  1886          panic("instruction BTQ takes exactly 2 operands")
  1887      }
  1888  }
  1889  
  1890  func __asm_proxy_BTRL__(p *Program, v ...interface{}) *Instruction {
  1891      if len(v) == 2 {
  1892          return p.BTRL(v[0], v[1])
  1893      } else {
  1894          panic("instruction BTRL takes exactly 2 operands")
  1895      }
  1896  }
  1897  
  1898  func __asm_proxy_BTRQ__(p *Program, v ...interface{}) *Instruction {
  1899      if len(v) == 2 {
  1900          return p.BTRQ(v[0], v[1])
  1901      } else {
  1902          panic("instruction BTRQ takes exactly 2 operands")
  1903      }
  1904  }
  1905  
  1906  func __asm_proxy_BTRW__(p *Program, v ...interface{}) *Instruction {
  1907      if len(v) == 2 {
  1908          return p.BTRW(v[0], v[1])
  1909      } else {
  1910          panic("instruction BTRW takes exactly 2 operands")
  1911      }
  1912  }
  1913  
  1914  func __asm_proxy_BTSL__(p *Program, v ...interface{}) *Instruction {
  1915      if len(v) == 2 {
  1916          return p.BTSL(v[0], v[1])
  1917      } else {
  1918          panic("instruction BTSL takes exactly 2 operands")
  1919      }
  1920  }
  1921  
  1922  func __asm_proxy_BTSQ__(p *Program, v ...interface{}) *Instruction {
  1923      if len(v) == 2 {
  1924          return p.BTSQ(v[0], v[1])
  1925      } else {
  1926          panic("instruction BTSQ takes exactly 2 operands")
  1927      }
  1928  }
  1929  
  1930  func __asm_proxy_BTSW__(p *Program, v ...interface{}) *Instruction {
  1931      if len(v) == 2 {
  1932          return p.BTSW(v[0], v[1])
  1933      } else {
  1934          panic("instruction BTSW takes exactly 2 operands")
  1935      }
  1936  }
  1937  
  1938  func __asm_proxy_BTW__(p *Program, v ...interface{}) *Instruction {
  1939      if len(v) == 2 {
  1940          return p.BTW(v[0], v[1])
  1941      } else {
  1942          panic("instruction BTW takes exactly 2 operands")
  1943      }
  1944  }
  1945  
  1946  func __asm_proxy_BZHI__(p *Program, v ...interface{}) *Instruction {
  1947      if len(v) == 3 {
  1948          return p.BZHI(v[0], v[1], v[2])
  1949      } else {
  1950          panic("instruction BZHI takes exactly 3 operands")
  1951      }
  1952  }
  1953  
  1954  func __asm_proxy_CALL__(p *Program, v ...interface{}) *Instruction {
  1955      if len(v) == 1 {
  1956          return p.CALL(v[0])
  1957      } else {
  1958          panic("instruction CALL takes exactly 1 operand")
  1959      }
  1960  }
  1961  
  1962  func __asm_proxy_CALLQ__(p *Program, v ...interface{}) *Instruction {
  1963      if len(v) == 1 {
  1964          return p.CALLQ(v[0])
  1965      } else {
  1966          panic("instruction CALLQ takes exactly 1 operand")
  1967      }
  1968  }
  1969  
  1970  func __asm_proxy_CBTW__(p *Program, v ...interface{}) *Instruction {
  1971      if len(v) == 0 {
  1972          return p.CBTW()
  1973      } else {
  1974          panic("instruction CBTW takes no operands")
  1975      }
  1976  }
  1977  
  1978  func __asm_proxy_CLC__(p *Program, v ...interface{}) *Instruction {
  1979      if len(v) == 0 {
  1980          return p.CLC()
  1981      } else {
  1982          panic("instruction CLC takes no operands")
  1983      }
  1984  }
  1985  
  1986  func __asm_proxy_CLD__(p *Program, v ...interface{}) *Instruction {
  1987      if len(v) == 0 {
  1988          return p.CLD()
  1989      } else {
  1990          panic("instruction CLD takes no operands")
  1991      }
  1992  }
  1993  
  1994  func __asm_proxy_CLFLUSH__(p *Program, v ...interface{}) *Instruction {
  1995      if len(v) == 1 {
  1996          return p.CLFLUSH(v[0])
  1997      } else {
  1998          panic("instruction CLFLUSH takes exactly 1 operand")
  1999      }
  2000  }
  2001  
  2002  func __asm_proxy_CLFLUSHOPT__(p *Program, v ...interface{}) *Instruction {
  2003      if len(v) == 1 {
  2004          return p.CLFLUSHOPT(v[0])
  2005      } else {
  2006          panic("instruction CLFLUSHOPT takes exactly 1 operand")
  2007      }
  2008  }
  2009  
  2010  func __asm_proxy_CLTD__(p *Program, v ...interface{}) *Instruction {
  2011      if len(v) == 0 {
  2012          return p.CLTD()
  2013      } else {
  2014          panic("instruction CLTD takes no operands")
  2015      }
  2016  }
  2017  
  2018  func __asm_proxy_CLTQ__(p *Program, v ...interface{}) *Instruction {
  2019      if len(v) == 0 {
  2020          return p.CLTQ()
  2021      } else {
  2022          panic("instruction CLTQ takes no operands")
  2023      }
  2024  }
  2025  
  2026  func __asm_proxy_CLWB__(p *Program, v ...interface{}) *Instruction {
  2027      if len(v) == 1 {
  2028          return p.CLWB(v[0])
  2029      } else {
  2030          panic("instruction CLWB takes exactly 1 operand")
  2031      }
  2032  }
  2033  
  2034  func __asm_proxy_CLZERO__(p *Program, v ...interface{}) *Instruction {
  2035      if len(v) == 0 {
  2036          return p.CLZERO()
  2037      } else {
  2038          panic("instruction CLZERO takes no operands")
  2039      }
  2040  }
  2041  
  2042  func __asm_proxy_CMC__(p *Program, v ...interface{}) *Instruction {
  2043      if len(v) == 0 {
  2044          return p.CMC()
  2045      } else {
  2046          panic("instruction CMC takes no operands")
  2047      }
  2048  }
  2049  
  2050  func __asm_proxy_CMOVA__(p *Program, v ...interface{}) *Instruction {
  2051      if len(v) == 2 {
  2052          return p.CMOVA(v[0], v[1])
  2053      } else {
  2054          panic("instruction CMOVA takes exactly 2 operands")
  2055      }
  2056  }
  2057  
  2058  func __asm_proxy_CMOVAE__(p *Program, v ...interface{}) *Instruction {
  2059      if len(v) == 2 {
  2060          return p.CMOVAE(v[0], v[1])
  2061      } else {
  2062          panic("instruction CMOVAE takes exactly 2 operands")
  2063      }
  2064  }
  2065  
  2066  func __asm_proxy_CMOVB__(p *Program, v ...interface{}) *Instruction {
  2067      if len(v) == 2 {
  2068          return p.CMOVB(v[0], v[1])
  2069      } else {
  2070          panic("instruction CMOVB takes exactly 2 operands")
  2071      }
  2072  }
  2073  
  2074  func __asm_proxy_CMOVBE__(p *Program, v ...interface{}) *Instruction {
  2075      if len(v) == 2 {
  2076          return p.CMOVBE(v[0], v[1])
  2077      } else {
  2078          panic("instruction CMOVBE takes exactly 2 operands")
  2079      }
  2080  }
  2081  
  2082  func __asm_proxy_CMOVC__(p *Program, v ...interface{}) *Instruction {
  2083      if len(v) == 2 {
  2084          return p.CMOVC(v[0], v[1])
  2085      } else {
  2086          panic("instruction CMOVC takes exactly 2 operands")
  2087      }
  2088  }
  2089  
  2090  func __asm_proxy_CMOVE__(p *Program, v ...interface{}) *Instruction {
  2091      if len(v) == 2 {
  2092          return p.CMOVE(v[0], v[1])
  2093      } else {
  2094          panic("instruction CMOVE takes exactly 2 operands")
  2095      }
  2096  }
  2097  
  2098  func __asm_proxy_CMOVG__(p *Program, v ...interface{}) *Instruction {
  2099      if len(v) == 2 {
  2100          return p.CMOVG(v[0], v[1])
  2101      } else {
  2102          panic("instruction CMOVG takes exactly 2 operands")
  2103      }
  2104  }
  2105  
  2106  func __asm_proxy_CMOVGE__(p *Program, v ...interface{}) *Instruction {
  2107      if len(v) == 2 {
  2108          return p.CMOVGE(v[0], v[1])
  2109      } else {
  2110          panic("instruction CMOVGE takes exactly 2 operands")
  2111      }
  2112  }
  2113  
  2114  func __asm_proxy_CMOVL__(p *Program, v ...interface{}) *Instruction {
  2115      if len(v) == 2 {
  2116          return p.CMOVL(v[0], v[1])
  2117      } else {
  2118          panic("instruction CMOVL takes exactly 2 operands")
  2119      }
  2120  }
  2121  
  2122  func __asm_proxy_CMOVLE__(p *Program, v ...interface{}) *Instruction {
  2123      if len(v) == 2 {
  2124          return p.CMOVLE(v[0], v[1])
  2125      } else {
  2126          panic("instruction CMOVLE takes exactly 2 operands")
  2127      }
  2128  }
  2129  
  2130  func __asm_proxy_CMOVNA__(p *Program, v ...interface{}) *Instruction {
  2131      if len(v) == 2 {
  2132          return p.CMOVNA(v[0], v[1])
  2133      } else {
  2134          panic("instruction CMOVNA takes exactly 2 operands")
  2135      }
  2136  }
  2137  
  2138  func __asm_proxy_CMOVNAE__(p *Program, v ...interface{}) *Instruction {
  2139      if len(v) == 2 {
  2140          return p.CMOVNAE(v[0], v[1])
  2141      } else {
  2142          panic("instruction CMOVNAE takes exactly 2 operands")
  2143      }
  2144  }
  2145  
  2146  func __asm_proxy_CMOVNB__(p *Program, v ...interface{}) *Instruction {
  2147      if len(v) == 2 {
  2148          return p.CMOVNB(v[0], v[1])
  2149      } else {
  2150          panic("instruction CMOVNB takes exactly 2 operands")
  2151      }
  2152  }
  2153  
  2154  func __asm_proxy_CMOVNBE__(p *Program, v ...interface{}) *Instruction {
  2155      if len(v) == 2 {
  2156          return p.CMOVNBE(v[0], v[1])
  2157      } else {
  2158          panic("instruction CMOVNBE takes exactly 2 operands")
  2159      }
  2160  }
  2161  
  2162  func __asm_proxy_CMOVNC__(p *Program, v ...interface{}) *Instruction {
  2163      if len(v) == 2 {
  2164          return p.CMOVNC(v[0], v[1])
  2165      } else {
  2166          panic("instruction CMOVNC takes exactly 2 operands")
  2167      }
  2168  }
  2169  
  2170  func __asm_proxy_CMOVNE__(p *Program, v ...interface{}) *Instruction {
  2171      if len(v) == 2 {
  2172          return p.CMOVNE(v[0], v[1])
  2173      } else {
  2174          panic("instruction CMOVNE takes exactly 2 operands")
  2175      }
  2176  }
  2177  
  2178  func __asm_proxy_CMOVNG__(p *Program, v ...interface{}) *Instruction {
  2179      if len(v) == 2 {
  2180          return p.CMOVNG(v[0], v[1])
  2181      } else {
  2182          panic("instruction CMOVNG takes exactly 2 operands")
  2183      }
  2184  }
  2185  
  2186  func __asm_proxy_CMOVNGE__(p *Program, v ...interface{}) *Instruction {
  2187      if len(v) == 2 {
  2188          return p.CMOVNGE(v[0], v[1])
  2189      } else {
  2190          panic("instruction CMOVNGE takes exactly 2 operands")
  2191      }
  2192  }
  2193  
  2194  func __asm_proxy_CMOVNL__(p *Program, v ...interface{}) *Instruction {
  2195      if len(v) == 2 {
  2196          return p.CMOVNL(v[0], v[1])
  2197      } else {
  2198          panic("instruction CMOVNL takes exactly 2 operands")
  2199      }
  2200  }
  2201  
  2202  func __asm_proxy_CMOVNLE__(p *Program, v ...interface{}) *Instruction {
  2203      if len(v) == 2 {
  2204          return p.CMOVNLE(v[0], v[1])
  2205      } else {
  2206          panic("instruction CMOVNLE takes exactly 2 operands")
  2207      }
  2208  }
  2209  
  2210  func __asm_proxy_CMOVNO__(p *Program, v ...interface{}) *Instruction {
  2211      if len(v) == 2 {
  2212          return p.CMOVNO(v[0], v[1])
  2213      } else {
  2214          panic("instruction CMOVNO takes exactly 2 operands")
  2215      }
  2216  }
  2217  
  2218  func __asm_proxy_CMOVNP__(p *Program, v ...interface{}) *Instruction {
  2219      if len(v) == 2 {
  2220          return p.CMOVNP(v[0], v[1])
  2221      } else {
  2222          panic("instruction CMOVNP takes exactly 2 operands")
  2223      }
  2224  }
  2225  
  2226  func __asm_proxy_CMOVNS__(p *Program, v ...interface{}) *Instruction {
  2227      if len(v) == 2 {
  2228          return p.CMOVNS(v[0], v[1])
  2229      } else {
  2230          panic("instruction CMOVNS takes exactly 2 operands")
  2231      }
  2232  }
  2233  
  2234  func __asm_proxy_CMOVNZ__(p *Program, v ...interface{}) *Instruction {
  2235      if len(v) == 2 {
  2236          return p.CMOVNZ(v[0], v[1])
  2237      } else {
  2238          panic("instruction CMOVNZ takes exactly 2 operands")
  2239      }
  2240  }
  2241  
  2242  func __asm_proxy_CMOVO__(p *Program, v ...interface{}) *Instruction {
  2243      if len(v) == 2 {
  2244          return p.CMOVO(v[0], v[1])
  2245      } else {
  2246          panic("instruction CMOVO takes exactly 2 operands")
  2247      }
  2248  }
  2249  
  2250  func __asm_proxy_CMOVP__(p *Program, v ...interface{}) *Instruction {
  2251      if len(v) == 2 {
  2252          return p.CMOVP(v[0], v[1])
  2253      } else {
  2254          panic("instruction CMOVP takes exactly 2 operands")
  2255      }
  2256  }
  2257  
  2258  func __asm_proxy_CMOVPE__(p *Program, v ...interface{}) *Instruction {
  2259      if len(v) == 2 {
  2260          return p.CMOVPE(v[0], v[1])
  2261      } else {
  2262          panic("instruction CMOVPE takes exactly 2 operands")
  2263      }
  2264  }
  2265  
  2266  func __asm_proxy_CMOVPO__(p *Program, v ...interface{}) *Instruction {
  2267      if len(v) == 2 {
  2268          return p.CMOVPO(v[0], v[1])
  2269      } else {
  2270          panic("instruction CMOVPO takes exactly 2 operands")
  2271      }
  2272  }
  2273  
  2274  func __asm_proxy_CMOVS__(p *Program, v ...interface{}) *Instruction {
  2275      if len(v) == 2 {
  2276          return p.CMOVS(v[0], v[1])
  2277      } else {
  2278          panic("instruction CMOVS takes exactly 2 operands")
  2279      }
  2280  }
  2281  
  2282  func __asm_proxy_CMOVZ__(p *Program, v ...interface{}) *Instruction {
  2283      if len(v) == 2 {
  2284          return p.CMOVZ(v[0], v[1])
  2285      } else {
  2286          panic("instruction CMOVZ takes exactly 2 operands")
  2287      }
  2288  }
  2289  
  2290  func __asm_proxy_CMPB__(p *Program, v ...interface{}) *Instruction {
  2291      if len(v) == 2 {
  2292          return p.CMPB(v[0], v[1])
  2293      } else {
  2294          panic("instruction CMPB takes exactly 2 operands")
  2295      }
  2296  }
  2297  
  2298  func __asm_proxy_CMPL__(p *Program, v ...interface{}) *Instruction {
  2299      if len(v) == 2 {
  2300          return p.CMPL(v[0], v[1])
  2301      } else {
  2302          panic("instruction CMPL takes exactly 2 operands")
  2303      }
  2304  }
  2305  
  2306  func __asm_proxy_CMPPD__(p *Program, v ...interface{}) *Instruction {
  2307      if len(v) == 3 {
  2308          return p.CMPPD(v[0], v[1], v[2])
  2309      } else {
  2310          panic("instruction CMPPD takes exactly 3 operands")
  2311      }
  2312  }
  2313  
  2314  func __asm_proxy_CMPPS__(p *Program, v ...interface{}) *Instruction {
  2315      if len(v) == 3 {
  2316          return p.CMPPS(v[0], v[1], v[2])
  2317      } else {
  2318          panic("instruction CMPPS takes exactly 3 operands")
  2319      }
  2320  }
  2321  
  2322  func __asm_proxy_CMPQ__(p *Program, v ...interface{}) *Instruction {
  2323      if len(v) == 2 {
  2324          return p.CMPQ(v[0], v[1])
  2325      } else {
  2326          panic("instruction CMPQ takes exactly 2 operands")
  2327      }
  2328  }
  2329  
  2330  func __asm_proxy_CMPSD__(p *Program, v ...interface{}) *Instruction {
  2331      if len(v) == 3 {
  2332          return p.CMPSD(v[0], v[1], v[2])
  2333      } else {
  2334          panic("instruction CMPSD takes exactly 3 operands")
  2335      }
  2336  }
  2337  
  2338  func __asm_proxy_CMPSS__(p *Program, v ...interface{}) *Instruction {
  2339      if len(v) == 3 {
  2340          return p.CMPSS(v[0], v[1], v[2])
  2341      } else {
  2342          panic("instruction CMPSS takes exactly 3 operands")
  2343      }
  2344  }
  2345  
  2346  func __asm_proxy_CMPW__(p *Program, v ...interface{}) *Instruction {
  2347      if len(v) == 2 {
  2348          return p.CMPW(v[0], v[1])
  2349      } else {
  2350          panic("instruction CMPW takes exactly 2 operands")
  2351      }
  2352  }
  2353  
  2354  func __asm_proxy_CMPXCHG16B__(p *Program, v ...interface{}) *Instruction {
  2355      if len(v) == 1 {
  2356          return p.CMPXCHG16B(v[0])
  2357      } else {
  2358          panic("instruction CMPXCHG16B takes exactly 1 operand")
  2359      }
  2360  }
  2361  
  2362  func __asm_proxy_CMPXCHG8B__(p *Program, v ...interface{}) *Instruction {
  2363      if len(v) == 1 {
  2364          return p.CMPXCHG8B(v[0])
  2365      } else {
  2366          panic("instruction CMPXCHG8B takes exactly 1 operand")
  2367      }
  2368  }
  2369  
  2370  func __asm_proxy_CMPXCHGB__(p *Program, v ...interface{}) *Instruction {
  2371      if len(v) == 2 {
  2372          return p.CMPXCHGB(v[0], v[1])
  2373      } else {
  2374          panic("instruction CMPXCHGB takes exactly 2 operands")
  2375      }
  2376  }
  2377  
  2378  func __asm_proxy_CMPXCHGL__(p *Program, v ...interface{}) *Instruction {
  2379      if len(v) == 2 {
  2380          return p.CMPXCHGL(v[0], v[1])
  2381      } else {
  2382          panic("instruction CMPXCHGL takes exactly 2 operands")
  2383      }
  2384  }
  2385  
  2386  func __asm_proxy_CMPXCHGQ__(p *Program, v ...interface{}) *Instruction {
  2387      if len(v) == 2 {
  2388          return p.CMPXCHGQ(v[0], v[1])
  2389      } else {
  2390          panic("instruction CMPXCHGQ takes exactly 2 operands")
  2391      }
  2392  }
  2393  
  2394  func __asm_proxy_CMPXCHGW__(p *Program, v ...interface{}) *Instruction {
  2395      if len(v) == 2 {
  2396          return p.CMPXCHGW(v[0], v[1])
  2397      } else {
  2398          panic("instruction CMPXCHGW takes exactly 2 operands")
  2399      }
  2400  }
  2401  
  2402  func __asm_proxy_COMISD__(p *Program, v ...interface{}) *Instruction {
  2403      if len(v) == 2 {
  2404          return p.COMISD(v[0], v[1])
  2405      } else {
  2406          panic("instruction COMISD takes exactly 2 operands")
  2407      }
  2408  }
  2409  
  2410  func __asm_proxy_COMISS__(p *Program, v ...interface{}) *Instruction {
  2411      if len(v) == 2 {
  2412          return p.COMISS(v[0], v[1])
  2413      } else {
  2414          panic("instruction COMISS takes exactly 2 operands")
  2415      }
  2416  }
  2417  
  2418  func __asm_proxy_CPUID__(p *Program, v ...interface{}) *Instruction {
  2419      if len(v) == 0 {
  2420          return p.CPUID()
  2421      } else {
  2422          panic("instruction CPUID takes no operands")
  2423      }
  2424  }
  2425  
  2426  func __asm_proxy_CQTO__(p *Program, v ...interface{}) *Instruction {
  2427      if len(v) == 0 {
  2428          return p.CQTO()
  2429      } else {
  2430          panic("instruction CQTO takes no operands")
  2431      }
  2432  }
  2433  
  2434  func __asm_proxy_CRC32B__(p *Program, v ...interface{}) *Instruction {
  2435      if len(v) == 2 {
  2436          return p.CRC32B(v[0], v[1])
  2437      } else {
  2438          panic("instruction CRC32B takes exactly 2 operands")
  2439      }
  2440  }
  2441  
  2442  func __asm_proxy_CRC32L__(p *Program, v ...interface{}) *Instruction {
  2443      if len(v) == 2 {
  2444          return p.CRC32L(v[0], v[1])
  2445      } else {
  2446          panic("instruction CRC32L takes exactly 2 operands")
  2447      }
  2448  }
  2449  
  2450  func __asm_proxy_CRC32Q__(p *Program, v ...interface{}) *Instruction {
  2451      if len(v) == 2 {
  2452          return p.CRC32Q(v[0], v[1])
  2453      } else {
  2454          panic("instruction CRC32Q takes exactly 2 operands")
  2455      }
  2456  }
  2457  
  2458  func __asm_proxy_CRC32W__(p *Program, v ...interface{}) *Instruction {
  2459      if len(v) == 2 {
  2460          return p.CRC32W(v[0], v[1])
  2461      } else {
  2462          panic("instruction CRC32W takes exactly 2 operands")
  2463      }
  2464  }
  2465  
  2466  func __asm_proxy_CVTDQ2PD__(p *Program, v ...interface{}) *Instruction {
  2467      if len(v) == 2 {
  2468          return p.CVTDQ2PD(v[0], v[1])
  2469      } else {
  2470          panic("instruction CVTDQ2PD takes exactly 2 operands")
  2471      }
  2472  }
  2473  
  2474  func __asm_proxy_CVTDQ2PS__(p *Program, v ...interface{}) *Instruction {
  2475      if len(v) == 2 {
  2476          return p.CVTDQ2PS(v[0], v[1])
  2477      } else {
  2478          panic("instruction CVTDQ2PS takes exactly 2 operands")
  2479      }
  2480  }
  2481  
  2482  func __asm_proxy_CVTPD2DQ__(p *Program, v ...interface{}) *Instruction {
  2483      if len(v) == 2 {
  2484          return p.CVTPD2DQ(v[0], v[1])
  2485      } else {
  2486          panic("instruction CVTPD2DQ takes exactly 2 operands")
  2487      }
  2488  }
  2489  
  2490  func __asm_proxy_CVTPD2PI__(p *Program, v ...interface{}) *Instruction {
  2491      if len(v) == 2 {
  2492          return p.CVTPD2PI(v[0], v[1])
  2493      } else {
  2494          panic("instruction CVTPD2PI takes exactly 2 operands")
  2495      }
  2496  }
  2497  
  2498  func __asm_proxy_CVTPD2PS__(p *Program, v ...interface{}) *Instruction {
  2499      if len(v) == 2 {
  2500          return p.CVTPD2PS(v[0], v[1])
  2501      } else {
  2502          panic("instruction CVTPD2PS takes exactly 2 operands")
  2503      }
  2504  }
  2505  
  2506  func __asm_proxy_CVTPI2PD__(p *Program, v ...interface{}) *Instruction {
  2507      if len(v) == 2 {
  2508          return p.CVTPI2PD(v[0], v[1])
  2509      } else {
  2510          panic("instruction CVTPI2PD takes exactly 2 operands")
  2511      }
  2512  }
  2513  
  2514  func __asm_proxy_CVTPI2PS__(p *Program, v ...interface{}) *Instruction {
  2515      if len(v) == 2 {
  2516          return p.CVTPI2PS(v[0], v[1])
  2517      } else {
  2518          panic("instruction CVTPI2PS takes exactly 2 operands")
  2519      }
  2520  }
  2521  
  2522  func __asm_proxy_CVTPS2DQ__(p *Program, v ...interface{}) *Instruction {
  2523      if len(v) == 2 {
  2524          return p.CVTPS2DQ(v[0], v[1])
  2525      } else {
  2526          panic("instruction CVTPS2DQ takes exactly 2 operands")
  2527      }
  2528  }
  2529  
  2530  func __asm_proxy_CVTPS2PD__(p *Program, v ...interface{}) *Instruction {
  2531      if len(v) == 2 {
  2532          return p.CVTPS2PD(v[0], v[1])
  2533      } else {
  2534          panic("instruction CVTPS2PD takes exactly 2 operands")
  2535      }
  2536  }
  2537  
  2538  func __asm_proxy_CVTPS2PI__(p *Program, v ...interface{}) *Instruction {
  2539      if len(v) == 2 {
  2540          return p.CVTPS2PI(v[0], v[1])
  2541      } else {
  2542          panic("instruction CVTPS2PI takes exactly 2 operands")
  2543      }
  2544  }
  2545  
  2546  func __asm_proxy_CVTSD2SI__(p *Program, v ...interface{}) *Instruction {
  2547      if len(v) == 2 {
  2548          return p.CVTSD2SI(v[0], v[1])
  2549      } else {
  2550          panic("instruction CVTSD2SI takes exactly 2 operands")
  2551      }
  2552  }
  2553  
  2554  func __asm_proxy_CVTSD2SS__(p *Program, v ...interface{}) *Instruction {
  2555      if len(v) == 2 {
  2556          return p.CVTSD2SS(v[0], v[1])
  2557      } else {
  2558          panic("instruction CVTSD2SS takes exactly 2 operands")
  2559      }
  2560  }
  2561  
  2562  func __asm_proxy_CVTSI2SD__(p *Program, v ...interface{}) *Instruction {
  2563      if len(v) == 2 {
  2564          return p.CVTSI2SD(v[0], v[1])
  2565      } else {
  2566          panic("instruction CVTSI2SD takes exactly 2 operands")
  2567      }
  2568  }
  2569  
  2570  func __asm_proxy_CVTSI2SS__(p *Program, v ...interface{}) *Instruction {
  2571      if len(v) == 2 {
  2572          return p.CVTSI2SS(v[0], v[1])
  2573      } else {
  2574          panic("instruction CVTSI2SS takes exactly 2 operands")
  2575      }
  2576  }
  2577  
  2578  func __asm_proxy_CVTSS2SD__(p *Program, v ...interface{}) *Instruction {
  2579      if len(v) == 2 {
  2580          return p.CVTSS2SD(v[0], v[1])
  2581      } else {
  2582          panic("instruction CVTSS2SD takes exactly 2 operands")
  2583      }
  2584  }
  2585  
  2586  func __asm_proxy_CVTSS2SI__(p *Program, v ...interface{}) *Instruction {
  2587      if len(v) == 2 {
  2588          return p.CVTSS2SI(v[0], v[1])
  2589      } else {
  2590          panic("instruction CVTSS2SI takes exactly 2 operands")
  2591      }
  2592  }
  2593  
  2594  func __asm_proxy_CVTTPD2DQ__(p *Program, v ...interface{}) *Instruction {
  2595      if len(v) == 2 {
  2596          return p.CVTTPD2DQ(v[0], v[1])
  2597      } else {
  2598          panic("instruction CVTTPD2DQ takes exactly 2 operands")
  2599      }
  2600  }
  2601  
  2602  func __asm_proxy_CVTTPD2PI__(p *Program, v ...interface{}) *Instruction {
  2603      if len(v) == 2 {
  2604          return p.CVTTPD2PI(v[0], v[1])
  2605      } else {
  2606          panic("instruction CVTTPD2PI takes exactly 2 operands")
  2607      }
  2608  }
  2609  
  2610  func __asm_proxy_CVTTPS2DQ__(p *Program, v ...interface{}) *Instruction {
  2611      if len(v) == 2 {
  2612          return p.CVTTPS2DQ(v[0], v[1])
  2613      } else {
  2614          panic("instruction CVTTPS2DQ takes exactly 2 operands")
  2615      }
  2616  }
  2617  
  2618  func __asm_proxy_CVTTPS2PI__(p *Program, v ...interface{}) *Instruction {
  2619      if len(v) == 2 {
  2620          return p.CVTTPS2PI(v[0], v[1])
  2621      } else {
  2622          panic("instruction CVTTPS2PI takes exactly 2 operands")
  2623      }
  2624  }
  2625  
  2626  func __asm_proxy_CVTTSD2SI__(p *Program, v ...interface{}) *Instruction {
  2627      if len(v) == 2 {
  2628          return p.CVTTSD2SI(v[0], v[1])
  2629      } else {
  2630          panic("instruction CVTTSD2SI takes exactly 2 operands")
  2631      }
  2632  }
  2633  
  2634  func __asm_proxy_CVTTSS2SI__(p *Program, v ...interface{}) *Instruction {
  2635      if len(v) == 2 {
  2636          return p.CVTTSS2SI(v[0], v[1])
  2637      } else {
  2638          panic("instruction CVTTSS2SI takes exactly 2 operands")
  2639      }
  2640  }
  2641  
  2642  func __asm_proxy_CWTD__(p *Program, v ...interface{}) *Instruction {
  2643      if len(v) == 0 {
  2644          return p.CWTD()
  2645      } else {
  2646          panic("instruction CWTD takes no operands")
  2647      }
  2648  }
  2649  
  2650  func __asm_proxy_CWTL__(p *Program, v ...interface{}) *Instruction {
  2651      if len(v) == 0 {
  2652          return p.CWTL()
  2653      } else {
  2654          panic("instruction CWTL takes no operands")
  2655      }
  2656  }
  2657  
  2658  func __asm_proxy_DECB__(p *Program, v ...interface{}) *Instruction {
  2659      if len(v) == 1 {
  2660          return p.DECB(v[0])
  2661      } else {
  2662          panic("instruction DECB takes exactly 1 operand")
  2663      }
  2664  }
  2665  
  2666  func __asm_proxy_DECL__(p *Program, v ...interface{}) *Instruction {
  2667      if len(v) == 1 {
  2668          return p.DECL(v[0])
  2669      } else {
  2670          panic("instruction DECL takes exactly 1 operand")
  2671      }
  2672  }
  2673  
  2674  func __asm_proxy_DECQ__(p *Program, v ...interface{}) *Instruction {
  2675      if len(v) == 1 {
  2676          return p.DECQ(v[0])
  2677      } else {
  2678          panic("instruction DECQ takes exactly 1 operand")
  2679      }
  2680  }
  2681  
  2682  func __asm_proxy_DECW__(p *Program, v ...interface{}) *Instruction {
  2683      if len(v) == 1 {
  2684          return p.DECW(v[0])
  2685      } else {
  2686          panic("instruction DECW takes exactly 1 operand")
  2687      }
  2688  }
  2689  
  2690  func __asm_proxy_DIVB__(p *Program, v ...interface{}) *Instruction {
  2691      if len(v) == 1 {
  2692          return p.DIVB(v[0])
  2693      } else {
  2694          panic("instruction DIVB takes exactly 1 operand")
  2695      }
  2696  }
  2697  
  2698  func __asm_proxy_DIVL__(p *Program, v ...interface{}) *Instruction {
  2699      if len(v) == 1 {
  2700          return p.DIVL(v[0])
  2701      } else {
  2702          panic("instruction DIVL takes exactly 1 operand")
  2703      }
  2704  }
  2705  
  2706  func __asm_proxy_DIVPD__(p *Program, v ...interface{}) *Instruction {
  2707      if len(v) == 2 {
  2708          return p.DIVPD(v[0], v[1])
  2709      } else {
  2710          panic("instruction DIVPD takes exactly 2 operands")
  2711      }
  2712  }
  2713  
  2714  func __asm_proxy_DIVPS__(p *Program, v ...interface{}) *Instruction {
  2715      if len(v) == 2 {
  2716          return p.DIVPS(v[0], v[1])
  2717      } else {
  2718          panic("instruction DIVPS takes exactly 2 operands")
  2719      }
  2720  }
  2721  
  2722  func __asm_proxy_DIVQ__(p *Program, v ...interface{}) *Instruction {
  2723      if len(v) == 1 {
  2724          return p.DIVQ(v[0])
  2725      } else {
  2726          panic("instruction DIVQ takes exactly 1 operand")
  2727      }
  2728  }
  2729  
  2730  func __asm_proxy_DIVSD__(p *Program, v ...interface{}) *Instruction {
  2731      if len(v) == 2 {
  2732          return p.DIVSD(v[0], v[1])
  2733      } else {
  2734          panic("instruction DIVSD takes exactly 2 operands")
  2735      }
  2736  }
  2737  
  2738  func __asm_proxy_DIVSS__(p *Program, v ...interface{}) *Instruction {
  2739      if len(v) == 2 {
  2740          return p.DIVSS(v[0], v[1])
  2741      } else {
  2742          panic("instruction DIVSS takes exactly 2 operands")
  2743      }
  2744  }
  2745  
  2746  func __asm_proxy_DIVW__(p *Program, v ...interface{}) *Instruction {
  2747      if len(v) == 1 {
  2748          return p.DIVW(v[0])
  2749      } else {
  2750          panic("instruction DIVW takes exactly 1 operand")
  2751      }
  2752  }
  2753  
  2754  func __asm_proxy_DPPD__(p *Program, v ...interface{}) *Instruction {
  2755      if len(v) == 3 {
  2756          return p.DPPD(v[0], v[1], v[2])
  2757      } else {
  2758          panic("instruction DPPD takes exactly 3 operands")
  2759      }
  2760  }
  2761  
  2762  func __asm_proxy_DPPS__(p *Program, v ...interface{}) *Instruction {
  2763      if len(v) == 3 {
  2764          return p.DPPS(v[0], v[1], v[2])
  2765      } else {
  2766          panic("instruction DPPS takes exactly 3 operands")
  2767      }
  2768  }
  2769  
  2770  func __asm_proxy_EMMS__(p *Program, v ...interface{}) *Instruction {
  2771      if len(v) == 0 {
  2772          return p.EMMS()
  2773      } else {
  2774          panic("instruction EMMS takes no operands")
  2775      }
  2776  }
  2777  
  2778  func __asm_proxy_EXTRACTPS__(p *Program, v ...interface{}) *Instruction {
  2779      if len(v) == 3 {
  2780          return p.EXTRACTPS(v[0], v[1], v[2])
  2781      } else {
  2782          panic("instruction EXTRACTPS takes exactly 3 operands")
  2783      }
  2784  }
  2785  
  2786  func __asm_proxy_EXTRQ__(p *Program, v ...interface{}) *Instruction {
  2787      switch len(v) {
  2788          case 2  : return p.EXTRQ(v[0], v[1])
  2789          case 3  : return p.EXTRQ(v[0], v[1], v[2])
  2790          default : panic("instruction EXTRQ takes 2 or 3 operands")
  2791      }
  2792  }
  2793  
  2794  func __asm_proxy_FEMMS__(p *Program, v ...interface{}) *Instruction {
  2795      if len(v) == 0 {
  2796          return p.FEMMS()
  2797      } else {
  2798          panic("instruction FEMMS takes no operands")
  2799      }
  2800  }
  2801  
  2802  func __asm_proxy_HADDPD__(p *Program, v ...interface{}) *Instruction {
  2803      if len(v) == 2 {
  2804          return p.HADDPD(v[0], v[1])
  2805      } else {
  2806          panic("instruction HADDPD takes exactly 2 operands")
  2807      }
  2808  }
  2809  
  2810  func __asm_proxy_HADDPS__(p *Program, v ...interface{}) *Instruction {
  2811      if len(v) == 2 {
  2812          return p.HADDPS(v[0], v[1])
  2813      } else {
  2814          panic("instruction HADDPS takes exactly 2 operands")
  2815      }
  2816  }
  2817  
  2818  func __asm_proxy_HSUBPD__(p *Program, v ...interface{}) *Instruction {
  2819      if len(v) == 2 {
  2820          return p.HSUBPD(v[0], v[1])
  2821      } else {
  2822          panic("instruction HSUBPD takes exactly 2 operands")
  2823      }
  2824  }
  2825  
  2826  func __asm_proxy_HSUBPS__(p *Program, v ...interface{}) *Instruction {
  2827      if len(v) == 2 {
  2828          return p.HSUBPS(v[0], v[1])
  2829      } else {
  2830          panic("instruction HSUBPS takes exactly 2 operands")
  2831      }
  2832  }
  2833  
  2834  func __asm_proxy_IDIVB__(p *Program, v ...interface{}) *Instruction {
  2835      if len(v) == 1 {
  2836          return p.IDIVB(v[0])
  2837      } else {
  2838          panic("instruction IDIVB takes exactly 1 operand")
  2839      }
  2840  }
  2841  
  2842  func __asm_proxy_IDIVL__(p *Program, v ...interface{}) *Instruction {
  2843      if len(v) == 1 {
  2844          return p.IDIVL(v[0])
  2845      } else {
  2846          panic("instruction IDIVL takes exactly 1 operand")
  2847      }
  2848  }
  2849  
  2850  func __asm_proxy_IDIVQ__(p *Program, v ...interface{}) *Instruction {
  2851      if len(v) == 1 {
  2852          return p.IDIVQ(v[0])
  2853      } else {
  2854          panic("instruction IDIVQ takes exactly 1 operand")
  2855      }
  2856  }
  2857  
  2858  func __asm_proxy_IDIVW__(p *Program, v ...interface{}) *Instruction {
  2859      if len(v) == 1 {
  2860          return p.IDIVW(v[0])
  2861      } else {
  2862          panic("instruction IDIVW takes exactly 1 operand")
  2863      }
  2864  }
  2865  
  2866  func __asm_proxy_IMULB__(p *Program, v ...interface{}) *Instruction {
  2867      if len(v) == 1 {
  2868          return p.IMULB(v[0])
  2869      } else {
  2870          panic("instruction IMULB takes exactly 1 operand")
  2871      }
  2872  }
  2873  
  2874  func __asm_proxy_IMULL__(p *Program, v ...interface{}) *Instruction {
  2875      switch len(v) {
  2876          case 1  : return p.IMULL(v[0])
  2877          case 2  : return p.IMULL(v[0], v[1])
  2878          case 3  : return p.IMULL(v[0], v[1], v[2])
  2879          default : panic("instruction IMULL takes 1 or 2 or 3 operands")
  2880      }
  2881  }
  2882  
  2883  func __asm_proxy_IMULQ__(p *Program, v ...interface{}) *Instruction {
  2884      switch len(v) {
  2885          case 1  : return p.IMULQ(v[0])
  2886          case 2  : return p.IMULQ(v[0], v[1])
  2887          case 3  : return p.IMULQ(v[0], v[1], v[2])
  2888          default : panic("instruction IMULQ takes 1 or 2 or 3 operands")
  2889      }
  2890  }
  2891  
  2892  func __asm_proxy_IMULW__(p *Program, v ...interface{}) *Instruction {
  2893      switch len(v) {
  2894          case 1  : return p.IMULW(v[0])
  2895          case 2  : return p.IMULW(v[0], v[1])
  2896          case 3  : return p.IMULW(v[0], v[1], v[2])
  2897          default : panic("instruction IMULW takes 1 or 2 or 3 operands")
  2898      }
  2899  }
  2900  
  2901  func __asm_proxy_INCB__(p *Program, v ...interface{}) *Instruction {
  2902      if len(v) == 1 {
  2903          return p.INCB(v[0])
  2904      } else {
  2905          panic("instruction INCB takes exactly 1 operand")
  2906      }
  2907  }
  2908  
  2909  func __asm_proxy_INCL__(p *Program, v ...interface{}) *Instruction {
  2910      if len(v) == 1 {
  2911          return p.INCL(v[0])
  2912      } else {
  2913          panic("instruction INCL takes exactly 1 operand")
  2914      }
  2915  }
  2916  
  2917  func __asm_proxy_INCQ__(p *Program, v ...interface{}) *Instruction {
  2918      if len(v) == 1 {
  2919          return p.INCQ(v[0])
  2920      } else {
  2921          panic("instruction INCQ takes exactly 1 operand")
  2922      }
  2923  }
  2924  
  2925  func __asm_proxy_INCW__(p *Program, v ...interface{}) *Instruction {
  2926      if len(v) == 1 {
  2927          return p.INCW(v[0])
  2928      } else {
  2929          panic("instruction INCW takes exactly 1 operand")
  2930      }
  2931  }
  2932  
  2933  func __asm_proxy_INSERTPS__(p *Program, v ...interface{}) *Instruction {
  2934      if len(v) == 3 {
  2935          return p.INSERTPS(v[0], v[1], v[2])
  2936      } else {
  2937          panic("instruction INSERTPS takes exactly 3 operands")
  2938      }
  2939  }
  2940  
  2941  func __asm_proxy_INSERTQ__(p *Program, v ...interface{}) *Instruction {
  2942      switch len(v) {
  2943          case 2  : return p.INSERTQ(v[0], v[1])
  2944          case 4  : return p.INSERTQ(v[0], v[1], v[2], v[3])
  2945          default : panic("instruction INSERTQ takes 2 or 4 operands")
  2946      }
  2947  }
  2948  
  2949  func __asm_proxy_INT__(p *Program, v ...interface{}) *Instruction {
  2950      if len(v) == 1 {
  2951          return p.INT(v[0])
  2952      } else {
  2953          panic("instruction INT takes exactly 1 operand")
  2954      }
  2955  }
  2956  
  2957  func __asm_proxy_JA__(p *Program, v ...interface{}) *Instruction {
  2958      if len(v) == 1 {
  2959          return p.JA(v[0])
  2960      } else {
  2961          panic("instruction JA takes exactly 1 operand")
  2962      }
  2963  }
  2964  
  2965  func __asm_proxy_JAE__(p *Program, v ...interface{}) *Instruction {
  2966      if len(v) == 1 {
  2967          return p.JAE(v[0])
  2968      } else {
  2969          panic("instruction JAE takes exactly 1 operand")
  2970      }
  2971  }
  2972  
  2973  func __asm_proxy_JB__(p *Program, v ...interface{}) *Instruction {
  2974      if len(v) == 1 {
  2975          return p.JB(v[0])
  2976      } else {
  2977          panic("instruction JB takes exactly 1 operand")
  2978      }
  2979  }
  2980  
  2981  func __asm_proxy_JBE__(p *Program, v ...interface{}) *Instruction {
  2982      if len(v) == 1 {
  2983          return p.JBE(v[0])
  2984      } else {
  2985          panic("instruction JBE takes exactly 1 operand")
  2986      }
  2987  }
  2988  
  2989  func __asm_proxy_JC__(p *Program, v ...interface{}) *Instruction {
  2990      if len(v) == 1 {
  2991          return p.JC(v[0])
  2992      } else {
  2993          panic("instruction JC takes exactly 1 operand")
  2994      }
  2995  }
  2996  
  2997  func __asm_proxy_JE__(p *Program, v ...interface{}) *Instruction {
  2998      if len(v) == 1 {
  2999          return p.JE(v[0])
  3000      } else {
  3001          panic("instruction JE takes exactly 1 operand")
  3002      }
  3003  }
  3004  
  3005  func __asm_proxy_JECXZ__(p *Program, v ...interface{}) *Instruction {
  3006      if len(v) == 1 {
  3007          return p.JECXZ(v[0])
  3008      } else {
  3009          panic("instruction JECXZ takes exactly 1 operand")
  3010      }
  3011  }
  3012  
  3013  func __asm_proxy_JG__(p *Program, v ...interface{}) *Instruction {
  3014      if len(v) == 1 {
  3015          return p.JG(v[0])
  3016      } else {
  3017          panic("instruction JG takes exactly 1 operand")
  3018      }
  3019  }
  3020  
  3021  func __asm_proxy_JGE__(p *Program, v ...interface{}) *Instruction {
  3022      if len(v) == 1 {
  3023          return p.JGE(v[0])
  3024      } else {
  3025          panic("instruction JGE takes exactly 1 operand")
  3026      }
  3027  }
  3028  
  3029  func __asm_proxy_JL__(p *Program, v ...interface{}) *Instruction {
  3030      if len(v) == 1 {
  3031          return p.JL(v[0])
  3032      } else {
  3033          panic("instruction JL takes exactly 1 operand")
  3034      }
  3035  }
  3036  
  3037  func __asm_proxy_JLE__(p *Program, v ...interface{}) *Instruction {
  3038      if len(v) == 1 {
  3039          return p.JLE(v[0])
  3040      } else {
  3041          panic("instruction JLE takes exactly 1 operand")
  3042      }
  3043  }
  3044  
  3045  func __asm_proxy_JMP__(p *Program, v ...interface{}) *Instruction {
  3046      if len(v) == 1 {
  3047          return p.JMP(v[0])
  3048      } else {
  3049          panic("instruction JMP takes exactly 1 operand")
  3050      }
  3051  }
  3052  
  3053  func __asm_proxy_JMPQ__(p *Program, v ...interface{}) *Instruction {
  3054      if len(v) == 1 {
  3055          return p.JMPQ(v[0])
  3056      } else {
  3057          panic("instruction JMPQ takes exactly 1 operand")
  3058      }
  3059  }
  3060  
  3061  func __asm_proxy_JNA__(p *Program, v ...interface{}) *Instruction {
  3062      if len(v) == 1 {
  3063          return p.JNA(v[0])
  3064      } else {
  3065          panic("instruction JNA takes exactly 1 operand")
  3066      }
  3067  }
  3068  
  3069  func __asm_proxy_JNAE__(p *Program, v ...interface{}) *Instruction {
  3070      if len(v) == 1 {
  3071          return p.JNAE(v[0])
  3072      } else {
  3073          panic("instruction JNAE takes exactly 1 operand")
  3074      }
  3075  }
  3076  
  3077  func __asm_proxy_JNB__(p *Program, v ...interface{}) *Instruction {
  3078      if len(v) == 1 {
  3079          return p.JNB(v[0])
  3080      } else {
  3081          panic("instruction JNB takes exactly 1 operand")
  3082      }
  3083  }
  3084  
  3085  func __asm_proxy_JNBE__(p *Program, v ...interface{}) *Instruction {
  3086      if len(v) == 1 {
  3087          return p.JNBE(v[0])
  3088      } else {
  3089          panic("instruction JNBE takes exactly 1 operand")
  3090      }
  3091  }
  3092  
  3093  func __asm_proxy_JNC__(p *Program, v ...interface{}) *Instruction {
  3094      if len(v) == 1 {
  3095          return p.JNC(v[0])
  3096      } else {
  3097          panic("instruction JNC takes exactly 1 operand")
  3098      }
  3099  }
  3100  
  3101  func __asm_proxy_JNE__(p *Program, v ...interface{}) *Instruction {
  3102      if len(v) == 1 {
  3103          return p.JNE(v[0])
  3104      } else {
  3105          panic("instruction JNE takes exactly 1 operand")
  3106      }
  3107  }
  3108  
  3109  func __asm_proxy_JNG__(p *Program, v ...interface{}) *Instruction {
  3110      if len(v) == 1 {
  3111          return p.JNG(v[0])
  3112      } else {
  3113          panic("instruction JNG takes exactly 1 operand")
  3114      }
  3115  }
  3116  
  3117  func __asm_proxy_JNGE__(p *Program, v ...interface{}) *Instruction {
  3118      if len(v) == 1 {
  3119          return p.JNGE(v[0])
  3120      } else {
  3121          panic("instruction JNGE takes exactly 1 operand")
  3122      }
  3123  }
  3124  
  3125  func __asm_proxy_JNL__(p *Program, v ...interface{}) *Instruction {
  3126      if len(v) == 1 {
  3127          return p.JNL(v[0])
  3128      } else {
  3129          panic("instruction JNL takes exactly 1 operand")
  3130      }
  3131  }
  3132  
  3133  func __asm_proxy_JNLE__(p *Program, v ...interface{}) *Instruction {
  3134      if len(v) == 1 {
  3135          return p.JNLE(v[0])
  3136      } else {
  3137          panic("instruction JNLE takes exactly 1 operand")
  3138      }
  3139  }
  3140  
  3141  func __asm_proxy_JNO__(p *Program, v ...interface{}) *Instruction {
  3142      if len(v) == 1 {
  3143          return p.JNO(v[0])
  3144      } else {
  3145          panic("instruction JNO takes exactly 1 operand")
  3146      }
  3147  }
  3148  
  3149  func __asm_proxy_JNP__(p *Program, v ...interface{}) *Instruction {
  3150      if len(v) == 1 {
  3151          return p.JNP(v[0])
  3152      } else {
  3153          panic("instruction JNP takes exactly 1 operand")
  3154      }
  3155  }
  3156  
  3157  func __asm_proxy_JNS__(p *Program, v ...interface{}) *Instruction {
  3158      if len(v) == 1 {
  3159          return p.JNS(v[0])
  3160      } else {
  3161          panic("instruction JNS takes exactly 1 operand")
  3162      }
  3163  }
  3164  
  3165  func __asm_proxy_JNZ__(p *Program, v ...interface{}) *Instruction {
  3166      if len(v) == 1 {
  3167          return p.JNZ(v[0])
  3168      } else {
  3169          panic("instruction JNZ takes exactly 1 operand")
  3170      }
  3171  }
  3172  
  3173  func __asm_proxy_JO__(p *Program, v ...interface{}) *Instruction {
  3174      if len(v) == 1 {
  3175          return p.JO(v[0])
  3176      } else {
  3177          panic("instruction JO takes exactly 1 operand")
  3178      }
  3179  }
  3180  
  3181  func __asm_proxy_JP__(p *Program, v ...interface{}) *Instruction {
  3182      if len(v) == 1 {
  3183          return p.JP(v[0])
  3184      } else {
  3185          panic("instruction JP takes exactly 1 operand")
  3186      }
  3187  }
  3188  
  3189  func __asm_proxy_JPE__(p *Program, v ...interface{}) *Instruction {
  3190      if len(v) == 1 {
  3191          return p.JPE(v[0])
  3192      } else {
  3193          panic("instruction JPE takes exactly 1 operand")
  3194      }
  3195  }
  3196  
  3197  func __asm_proxy_JPO__(p *Program, v ...interface{}) *Instruction {
  3198      if len(v) == 1 {
  3199          return p.JPO(v[0])
  3200      } else {
  3201          panic("instruction JPO takes exactly 1 operand")
  3202      }
  3203  }
  3204  
  3205  func __asm_proxy_JRCXZ__(p *Program, v ...interface{}) *Instruction {
  3206      if len(v) == 1 {
  3207          return p.JRCXZ(v[0])
  3208      } else {
  3209          panic("instruction JRCXZ takes exactly 1 operand")
  3210      }
  3211  }
  3212  
  3213  func __asm_proxy_JS__(p *Program, v ...interface{}) *Instruction {
  3214      if len(v) == 1 {
  3215          return p.JS(v[0])
  3216      } else {
  3217          panic("instruction JS takes exactly 1 operand")
  3218      }
  3219  }
  3220  
  3221  func __asm_proxy_JZ__(p *Program, v ...interface{}) *Instruction {
  3222      if len(v) == 1 {
  3223          return p.JZ(v[0])
  3224      } else {
  3225          panic("instruction JZ takes exactly 1 operand")
  3226      }
  3227  }
  3228  
  3229  func __asm_proxy_KADDB__(p *Program, v ...interface{}) *Instruction {
  3230      if len(v) == 3 {
  3231          return p.KADDB(v[0], v[1], v[2])
  3232      } else {
  3233          panic("instruction KADDB takes exactly 3 operands")
  3234      }
  3235  }
  3236  
  3237  func __asm_proxy_KADDD__(p *Program, v ...interface{}) *Instruction {
  3238      if len(v) == 3 {
  3239          return p.KADDD(v[0], v[1], v[2])
  3240      } else {
  3241          panic("instruction KADDD takes exactly 3 operands")
  3242      }
  3243  }
  3244  
  3245  func __asm_proxy_KADDQ__(p *Program, v ...interface{}) *Instruction {
  3246      if len(v) == 3 {
  3247          return p.KADDQ(v[0], v[1], v[2])
  3248      } else {
  3249          panic("instruction KADDQ takes exactly 3 operands")
  3250      }
  3251  }
  3252  
  3253  func __asm_proxy_KADDW__(p *Program, v ...interface{}) *Instruction {
  3254      if len(v) == 3 {
  3255          return p.KADDW(v[0], v[1], v[2])
  3256      } else {
  3257          panic("instruction KADDW takes exactly 3 operands")
  3258      }
  3259  }
  3260  
  3261  func __asm_proxy_KANDB__(p *Program, v ...interface{}) *Instruction {
  3262      if len(v) == 3 {
  3263          return p.KANDB(v[0], v[1], v[2])
  3264      } else {
  3265          panic("instruction KANDB takes exactly 3 operands")
  3266      }
  3267  }
  3268  
  3269  func __asm_proxy_KANDD__(p *Program, v ...interface{}) *Instruction {
  3270      if len(v) == 3 {
  3271          return p.KANDD(v[0], v[1], v[2])
  3272      } else {
  3273          panic("instruction KANDD takes exactly 3 operands")
  3274      }
  3275  }
  3276  
  3277  func __asm_proxy_KANDNB__(p *Program, v ...interface{}) *Instruction {
  3278      if len(v) == 3 {
  3279          return p.KANDNB(v[0], v[1], v[2])
  3280      } else {
  3281          panic("instruction KANDNB takes exactly 3 operands")
  3282      }
  3283  }
  3284  
  3285  func __asm_proxy_KANDND__(p *Program, v ...interface{}) *Instruction {
  3286      if len(v) == 3 {
  3287          return p.KANDND(v[0], v[1], v[2])
  3288      } else {
  3289          panic("instruction KANDND takes exactly 3 operands")
  3290      }
  3291  }
  3292  
  3293  func __asm_proxy_KANDNQ__(p *Program, v ...interface{}) *Instruction {
  3294      if len(v) == 3 {
  3295          return p.KANDNQ(v[0], v[1], v[2])
  3296      } else {
  3297          panic("instruction KANDNQ takes exactly 3 operands")
  3298      }
  3299  }
  3300  
  3301  func __asm_proxy_KANDNW__(p *Program, v ...interface{}) *Instruction {
  3302      if len(v) == 3 {
  3303          return p.KANDNW(v[0], v[1], v[2])
  3304      } else {
  3305          panic("instruction KANDNW takes exactly 3 operands")
  3306      }
  3307  }
  3308  
  3309  func __asm_proxy_KANDQ__(p *Program, v ...interface{}) *Instruction {
  3310      if len(v) == 3 {
  3311          return p.KANDQ(v[0], v[1], v[2])
  3312      } else {
  3313          panic("instruction KANDQ takes exactly 3 operands")
  3314      }
  3315  }
  3316  
  3317  func __asm_proxy_KANDW__(p *Program, v ...interface{}) *Instruction {
  3318      if len(v) == 3 {
  3319          return p.KANDW(v[0], v[1], v[2])
  3320      } else {
  3321          panic("instruction KANDW takes exactly 3 operands")
  3322      }
  3323  }
  3324  
  3325  func __asm_proxy_KMOVB__(p *Program, v ...interface{}) *Instruction {
  3326      if len(v) == 2 {
  3327          return p.KMOVB(v[0], v[1])
  3328      } else {
  3329          panic("instruction KMOVB takes exactly 2 operands")
  3330      }
  3331  }
  3332  
  3333  func __asm_proxy_KMOVD__(p *Program, v ...interface{}) *Instruction {
  3334      if len(v) == 2 {
  3335          return p.KMOVD(v[0], v[1])
  3336      } else {
  3337          panic("instruction KMOVD takes exactly 2 operands")
  3338      }
  3339  }
  3340  
  3341  func __asm_proxy_KMOVQ__(p *Program, v ...interface{}) *Instruction {
  3342      if len(v) == 2 {
  3343          return p.KMOVQ(v[0], v[1])
  3344      } else {
  3345          panic("instruction KMOVQ takes exactly 2 operands")
  3346      }
  3347  }
  3348  
  3349  func __asm_proxy_KMOVW__(p *Program, v ...interface{}) *Instruction {
  3350      if len(v) == 2 {
  3351          return p.KMOVW(v[0], v[1])
  3352      } else {
  3353          panic("instruction KMOVW takes exactly 2 operands")
  3354      }
  3355  }
  3356  
  3357  func __asm_proxy_KNOTB__(p *Program, v ...interface{}) *Instruction {
  3358      if len(v) == 2 {
  3359          return p.KNOTB(v[0], v[1])
  3360      } else {
  3361          panic("instruction KNOTB takes exactly 2 operands")
  3362      }
  3363  }
  3364  
  3365  func __asm_proxy_KNOTD__(p *Program, v ...interface{}) *Instruction {
  3366      if len(v) == 2 {
  3367          return p.KNOTD(v[0], v[1])
  3368      } else {
  3369          panic("instruction KNOTD takes exactly 2 operands")
  3370      }
  3371  }
  3372  
  3373  func __asm_proxy_KNOTQ__(p *Program, v ...interface{}) *Instruction {
  3374      if len(v) == 2 {
  3375          return p.KNOTQ(v[0], v[1])
  3376      } else {
  3377          panic("instruction KNOTQ takes exactly 2 operands")
  3378      }
  3379  }
  3380  
  3381  func __asm_proxy_KNOTW__(p *Program, v ...interface{}) *Instruction {
  3382      if len(v) == 2 {
  3383          return p.KNOTW(v[0], v[1])
  3384      } else {
  3385          panic("instruction KNOTW takes exactly 2 operands")
  3386      }
  3387  }
  3388  
  3389  func __asm_proxy_KORB__(p *Program, v ...interface{}) *Instruction {
  3390      if len(v) == 3 {
  3391          return p.KORB(v[0], v[1], v[2])
  3392      } else {
  3393          panic("instruction KORB takes exactly 3 operands")
  3394      }
  3395  }
  3396  
  3397  func __asm_proxy_KORD__(p *Program, v ...interface{}) *Instruction {
  3398      if len(v) == 3 {
  3399          return p.KORD(v[0], v[1], v[2])
  3400      } else {
  3401          panic("instruction KORD takes exactly 3 operands")
  3402      }
  3403  }
  3404  
  3405  func __asm_proxy_KORQ__(p *Program, v ...interface{}) *Instruction {
  3406      if len(v) == 3 {
  3407          return p.KORQ(v[0], v[1], v[2])
  3408      } else {
  3409          panic("instruction KORQ takes exactly 3 operands")
  3410      }
  3411  }
  3412  
  3413  func __asm_proxy_KORTESTB__(p *Program, v ...interface{}) *Instruction {
  3414      if len(v) == 2 {
  3415          return p.KORTESTB(v[0], v[1])
  3416      } else {
  3417          panic("instruction KORTESTB takes exactly 2 operands")
  3418      }
  3419  }
  3420  
  3421  func __asm_proxy_KORTESTD__(p *Program, v ...interface{}) *Instruction {
  3422      if len(v) == 2 {
  3423          return p.KORTESTD(v[0], v[1])
  3424      } else {
  3425          panic("instruction KORTESTD takes exactly 2 operands")
  3426      }
  3427  }
  3428  
  3429  func __asm_proxy_KORTESTQ__(p *Program, v ...interface{}) *Instruction {
  3430      if len(v) == 2 {
  3431          return p.KORTESTQ(v[0], v[1])
  3432      } else {
  3433          panic("instruction KORTESTQ takes exactly 2 operands")
  3434      }
  3435  }
  3436  
  3437  func __asm_proxy_KORTESTW__(p *Program, v ...interface{}) *Instruction {
  3438      if len(v) == 2 {
  3439          return p.KORTESTW(v[0], v[1])
  3440      } else {
  3441          panic("instruction KORTESTW takes exactly 2 operands")
  3442      }
  3443  }
  3444  
  3445  func __asm_proxy_KORW__(p *Program, v ...interface{}) *Instruction {
  3446      if len(v) == 3 {
  3447          return p.KORW(v[0], v[1], v[2])
  3448      } else {
  3449          panic("instruction KORW takes exactly 3 operands")
  3450      }
  3451  }
  3452  
  3453  func __asm_proxy_KSHIFTLB__(p *Program, v ...interface{}) *Instruction {
  3454      if len(v) == 3 {
  3455          return p.KSHIFTLB(v[0], v[1], v[2])
  3456      } else {
  3457          panic("instruction KSHIFTLB takes exactly 3 operands")
  3458      }
  3459  }
  3460  
  3461  func __asm_proxy_KSHIFTLD__(p *Program, v ...interface{}) *Instruction {
  3462      if len(v) == 3 {
  3463          return p.KSHIFTLD(v[0], v[1], v[2])
  3464      } else {
  3465          panic("instruction KSHIFTLD takes exactly 3 operands")
  3466      }
  3467  }
  3468  
  3469  func __asm_proxy_KSHIFTLQ__(p *Program, v ...interface{}) *Instruction {
  3470      if len(v) == 3 {
  3471          return p.KSHIFTLQ(v[0], v[1], v[2])
  3472      } else {
  3473          panic("instruction KSHIFTLQ takes exactly 3 operands")
  3474      }
  3475  }
  3476  
  3477  func __asm_proxy_KSHIFTLW__(p *Program, v ...interface{}) *Instruction {
  3478      if len(v) == 3 {
  3479          return p.KSHIFTLW(v[0], v[1], v[2])
  3480      } else {
  3481          panic("instruction KSHIFTLW takes exactly 3 operands")
  3482      }
  3483  }
  3484  
  3485  func __asm_proxy_KSHIFTRB__(p *Program, v ...interface{}) *Instruction {
  3486      if len(v) == 3 {
  3487          return p.KSHIFTRB(v[0], v[1], v[2])
  3488      } else {
  3489          panic("instruction KSHIFTRB takes exactly 3 operands")
  3490      }
  3491  }
  3492  
  3493  func __asm_proxy_KSHIFTRD__(p *Program, v ...interface{}) *Instruction {
  3494      if len(v) == 3 {
  3495          return p.KSHIFTRD(v[0], v[1], v[2])
  3496      } else {
  3497          panic("instruction KSHIFTRD takes exactly 3 operands")
  3498      }
  3499  }
  3500  
  3501  func __asm_proxy_KSHIFTRQ__(p *Program, v ...interface{}) *Instruction {
  3502      if len(v) == 3 {
  3503          return p.KSHIFTRQ(v[0], v[1], v[2])
  3504      } else {
  3505          panic("instruction KSHIFTRQ takes exactly 3 operands")
  3506      }
  3507  }
  3508  
  3509  func __asm_proxy_KSHIFTRW__(p *Program, v ...interface{}) *Instruction {
  3510      if len(v) == 3 {
  3511          return p.KSHIFTRW(v[0], v[1], v[2])
  3512      } else {
  3513          panic("instruction KSHIFTRW takes exactly 3 operands")
  3514      }
  3515  }
  3516  
  3517  func __asm_proxy_KTESTB__(p *Program, v ...interface{}) *Instruction {
  3518      if len(v) == 2 {
  3519          return p.KTESTB(v[0], v[1])
  3520      } else {
  3521          panic("instruction KTESTB takes exactly 2 operands")
  3522      }
  3523  }
  3524  
  3525  func __asm_proxy_KTESTD__(p *Program, v ...interface{}) *Instruction {
  3526      if len(v) == 2 {
  3527          return p.KTESTD(v[0], v[1])
  3528      } else {
  3529          panic("instruction KTESTD takes exactly 2 operands")
  3530      }
  3531  }
  3532  
  3533  func __asm_proxy_KTESTQ__(p *Program, v ...interface{}) *Instruction {
  3534      if len(v) == 2 {
  3535          return p.KTESTQ(v[0], v[1])
  3536      } else {
  3537          panic("instruction KTESTQ takes exactly 2 operands")
  3538      }
  3539  }
  3540  
  3541  func __asm_proxy_KTESTW__(p *Program, v ...interface{}) *Instruction {
  3542      if len(v) == 2 {
  3543          return p.KTESTW(v[0], v[1])
  3544      } else {
  3545          panic("instruction KTESTW takes exactly 2 operands")
  3546      }
  3547  }
  3548  
  3549  func __asm_proxy_KUNPCKBW__(p *Program, v ...interface{}) *Instruction {
  3550      if len(v) == 3 {
  3551          return p.KUNPCKBW(v[0], v[1], v[2])
  3552      } else {
  3553          panic("instruction KUNPCKBW takes exactly 3 operands")
  3554      }
  3555  }
  3556  
  3557  func __asm_proxy_KUNPCKDQ__(p *Program, v ...interface{}) *Instruction {
  3558      if len(v) == 3 {
  3559          return p.KUNPCKDQ(v[0], v[1], v[2])
  3560      } else {
  3561          panic("instruction KUNPCKDQ takes exactly 3 operands")
  3562      }
  3563  }
  3564  
  3565  func __asm_proxy_KUNPCKWD__(p *Program, v ...interface{}) *Instruction {
  3566      if len(v) == 3 {
  3567          return p.KUNPCKWD(v[0], v[1], v[2])
  3568      } else {
  3569          panic("instruction KUNPCKWD takes exactly 3 operands")
  3570      }
  3571  }
  3572  
  3573  func __asm_proxy_KXNORB__(p *Program, v ...interface{}) *Instruction {
  3574      if len(v) == 3 {
  3575          return p.KXNORB(v[0], v[1], v[2])
  3576      } else {
  3577          panic("instruction KXNORB takes exactly 3 operands")
  3578      }
  3579  }
  3580  
  3581  func __asm_proxy_KXNORD__(p *Program, v ...interface{}) *Instruction {
  3582      if len(v) == 3 {
  3583          return p.KXNORD(v[0], v[1], v[2])
  3584      } else {
  3585          panic("instruction KXNORD takes exactly 3 operands")
  3586      }
  3587  }
  3588  
  3589  func __asm_proxy_KXNORQ__(p *Program, v ...interface{}) *Instruction {
  3590      if len(v) == 3 {
  3591          return p.KXNORQ(v[0], v[1], v[2])
  3592      } else {
  3593          panic("instruction KXNORQ takes exactly 3 operands")
  3594      }
  3595  }
  3596  
  3597  func __asm_proxy_KXNORW__(p *Program, v ...interface{}) *Instruction {
  3598      if len(v) == 3 {
  3599          return p.KXNORW(v[0], v[1], v[2])
  3600      } else {
  3601          panic("instruction KXNORW takes exactly 3 operands")
  3602      }
  3603  }
  3604  
  3605  func __asm_proxy_KXORB__(p *Program, v ...interface{}) *Instruction {
  3606      if len(v) == 3 {
  3607          return p.KXORB(v[0], v[1], v[2])
  3608      } else {
  3609          panic("instruction KXORB takes exactly 3 operands")
  3610      }
  3611  }
  3612  
  3613  func __asm_proxy_KXORD__(p *Program, v ...interface{}) *Instruction {
  3614      if len(v) == 3 {
  3615          return p.KXORD(v[0], v[1], v[2])
  3616      } else {
  3617          panic("instruction KXORD takes exactly 3 operands")
  3618      }
  3619  }
  3620  
  3621  func __asm_proxy_KXORQ__(p *Program, v ...interface{}) *Instruction {
  3622      if len(v) == 3 {
  3623          return p.KXORQ(v[0], v[1], v[2])
  3624      } else {
  3625          panic("instruction KXORQ takes exactly 3 operands")
  3626      }
  3627  }
  3628  
  3629  func __asm_proxy_KXORW__(p *Program, v ...interface{}) *Instruction {
  3630      if len(v) == 3 {
  3631          return p.KXORW(v[0], v[1], v[2])
  3632      } else {
  3633          panic("instruction KXORW takes exactly 3 operands")
  3634      }
  3635  }
  3636  
  3637  func __asm_proxy_LDDQU__(p *Program, v ...interface{}) *Instruction {
  3638      if len(v) == 2 {
  3639          return p.LDDQU(v[0], v[1])
  3640      } else {
  3641          panic("instruction LDDQU takes exactly 2 operands")
  3642      }
  3643  }
  3644  
  3645  func __asm_proxy_LDMXCSR__(p *Program, v ...interface{}) *Instruction {
  3646      if len(v) == 1 {
  3647          return p.LDMXCSR(v[0])
  3648      } else {
  3649          panic("instruction LDMXCSR takes exactly 1 operand")
  3650      }
  3651  }
  3652  
  3653  func __asm_proxy_LEAL__(p *Program, v ...interface{}) *Instruction {
  3654      if len(v) == 2 {
  3655          return p.LEAL(v[0], v[1])
  3656      } else {
  3657          panic("instruction LEAL takes exactly 2 operands")
  3658      }
  3659  }
  3660  
  3661  func __asm_proxy_LEAQ__(p *Program, v ...interface{}) *Instruction {
  3662      if len(v) == 2 {
  3663          return p.LEAQ(v[0], v[1])
  3664      } else {
  3665          panic("instruction LEAQ takes exactly 2 operands")
  3666      }
  3667  }
  3668  
  3669  func __asm_proxy_LEAW__(p *Program, v ...interface{}) *Instruction {
  3670      if len(v) == 2 {
  3671          return p.LEAW(v[0], v[1])
  3672      } else {
  3673          panic("instruction LEAW takes exactly 2 operands")
  3674      }
  3675  }
  3676  
  3677  func __asm_proxy_LFENCE__(p *Program, v ...interface{}) *Instruction {
  3678      if len(v) == 0 {
  3679          return p.LFENCE()
  3680      } else {
  3681          panic("instruction LFENCE takes no operands")
  3682      }
  3683  }
  3684  
  3685  func __asm_proxy_LZCNTL__(p *Program, v ...interface{}) *Instruction {
  3686      if len(v) == 2 {
  3687          return p.LZCNTL(v[0], v[1])
  3688      } else {
  3689          panic("instruction LZCNTL takes exactly 2 operands")
  3690      }
  3691  }
  3692  
  3693  func __asm_proxy_LZCNTQ__(p *Program, v ...interface{}) *Instruction {
  3694      if len(v) == 2 {
  3695          return p.LZCNTQ(v[0], v[1])
  3696      } else {
  3697          panic("instruction LZCNTQ takes exactly 2 operands")
  3698      }
  3699  }
  3700  
  3701  func __asm_proxy_LZCNTW__(p *Program, v ...interface{}) *Instruction {
  3702      if len(v) == 2 {
  3703          return p.LZCNTW(v[0], v[1])
  3704      } else {
  3705          panic("instruction LZCNTW takes exactly 2 operands")
  3706      }
  3707  }
  3708  
  3709  func __asm_proxy_MASKMOVDQU__(p *Program, v ...interface{}) *Instruction {
  3710      if len(v) == 2 {
  3711          return p.MASKMOVDQU(v[0], v[1])
  3712      } else {
  3713          panic("instruction MASKMOVDQU takes exactly 2 operands")
  3714      }
  3715  }
  3716  
  3717  func __asm_proxy_MASKMOVQ__(p *Program, v ...interface{}) *Instruction {
  3718      if len(v) == 2 {
  3719          return p.MASKMOVQ(v[0], v[1])
  3720      } else {
  3721          panic("instruction MASKMOVQ takes exactly 2 operands")
  3722      }
  3723  }
  3724  
  3725  func __asm_proxy_MAXPD__(p *Program, v ...interface{}) *Instruction {
  3726      if len(v) == 2 {
  3727          return p.MAXPD(v[0], v[1])
  3728      } else {
  3729          panic("instruction MAXPD takes exactly 2 operands")
  3730      }
  3731  }
  3732  
  3733  func __asm_proxy_MAXPS__(p *Program, v ...interface{}) *Instruction {
  3734      if len(v) == 2 {
  3735          return p.MAXPS(v[0], v[1])
  3736      } else {
  3737          panic("instruction MAXPS takes exactly 2 operands")
  3738      }
  3739  }
  3740  
  3741  func __asm_proxy_MAXSD__(p *Program, v ...interface{}) *Instruction {
  3742      if len(v) == 2 {
  3743          return p.MAXSD(v[0], v[1])
  3744      } else {
  3745          panic("instruction MAXSD takes exactly 2 operands")
  3746      }
  3747  }
  3748  
  3749  func __asm_proxy_MAXSS__(p *Program, v ...interface{}) *Instruction {
  3750      if len(v) == 2 {
  3751          return p.MAXSS(v[0], v[1])
  3752      } else {
  3753          panic("instruction MAXSS takes exactly 2 operands")
  3754      }
  3755  }
  3756  
  3757  func __asm_proxy_MFENCE__(p *Program, v ...interface{}) *Instruction {
  3758      if len(v) == 0 {
  3759          return p.MFENCE()
  3760      } else {
  3761          panic("instruction MFENCE takes no operands")
  3762      }
  3763  }
  3764  
  3765  func __asm_proxy_MINPD__(p *Program, v ...interface{}) *Instruction {
  3766      if len(v) == 2 {
  3767          return p.MINPD(v[0], v[1])
  3768      } else {
  3769          panic("instruction MINPD takes exactly 2 operands")
  3770      }
  3771  }
  3772  
  3773  func __asm_proxy_MINPS__(p *Program, v ...interface{}) *Instruction {
  3774      if len(v) == 2 {
  3775          return p.MINPS(v[0], v[1])
  3776      } else {
  3777          panic("instruction MINPS takes exactly 2 operands")
  3778      }
  3779  }
  3780  
  3781  func __asm_proxy_MINSD__(p *Program, v ...interface{}) *Instruction {
  3782      if len(v) == 2 {
  3783          return p.MINSD(v[0], v[1])
  3784      } else {
  3785          panic("instruction MINSD takes exactly 2 operands")
  3786      }
  3787  }
  3788  
  3789  func __asm_proxy_MINSS__(p *Program, v ...interface{}) *Instruction {
  3790      if len(v) == 2 {
  3791          return p.MINSS(v[0], v[1])
  3792      } else {
  3793          panic("instruction MINSS takes exactly 2 operands")
  3794      }
  3795  }
  3796  
  3797  func __asm_proxy_MONITOR__(p *Program, v ...interface{}) *Instruction {
  3798      if len(v) == 0 {
  3799          return p.MONITOR()
  3800      } else {
  3801          panic("instruction MONITOR takes no operands")
  3802      }
  3803  }
  3804  
  3805  func __asm_proxy_MONITORX__(p *Program, v ...interface{}) *Instruction {
  3806      if len(v) == 0 {
  3807          return p.MONITORX()
  3808      } else {
  3809          panic("instruction MONITORX takes no operands")
  3810      }
  3811  }
  3812  
  3813  func __asm_proxy_MOVAPD__(p *Program, v ...interface{}) *Instruction {
  3814      if len(v) == 2 {
  3815          return p.MOVAPD(v[0], v[1])
  3816      } else {
  3817          panic("instruction MOVAPD takes exactly 2 operands")
  3818      }
  3819  }
  3820  
  3821  func __asm_proxy_MOVAPS__(p *Program, v ...interface{}) *Instruction {
  3822      if len(v) == 2 {
  3823          return p.MOVAPS(v[0], v[1])
  3824      } else {
  3825          panic("instruction MOVAPS takes exactly 2 operands")
  3826      }
  3827  }
  3828  
  3829  func __asm_proxy_MOVB__(p *Program, v ...interface{}) *Instruction {
  3830      if len(v) == 2 {
  3831          return p.MOVB(v[0], v[1])
  3832      } else {
  3833          panic("instruction MOVB takes exactly 2 operands")
  3834      }
  3835  }
  3836  
  3837  func __asm_proxy_MOVBEL__(p *Program, v ...interface{}) *Instruction {
  3838      if len(v) == 2 {
  3839          return p.MOVBEL(v[0], v[1])
  3840      } else {
  3841          panic("instruction MOVBEL takes exactly 2 operands")
  3842      }
  3843  }
  3844  
  3845  func __asm_proxy_MOVBEQ__(p *Program, v ...interface{}) *Instruction {
  3846      if len(v) == 2 {
  3847          return p.MOVBEQ(v[0], v[1])
  3848      } else {
  3849          panic("instruction MOVBEQ takes exactly 2 operands")
  3850      }
  3851  }
  3852  
  3853  func __asm_proxy_MOVBEW__(p *Program, v ...interface{}) *Instruction {
  3854      if len(v) == 2 {
  3855          return p.MOVBEW(v[0], v[1])
  3856      } else {
  3857          panic("instruction MOVBEW takes exactly 2 operands")
  3858      }
  3859  }
  3860  
  3861  func __asm_proxy_MOVD__(p *Program, v ...interface{}) *Instruction {
  3862      if len(v) == 2 {
  3863          return p.MOVD(v[0], v[1])
  3864      } else {
  3865          panic("instruction MOVD takes exactly 2 operands")
  3866      }
  3867  }
  3868  
  3869  func __asm_proxy_MOVDDUP__(p *Program, v ...interface{}) *Instruction {
  3870      if len(v) == 2 {
  3871          return p.MOVDDUP(v[0], v[1])
  3872      } else {
  3873          panic("instruction MOVDDUP takes exactly 2 operands")
  3874      }
  3875  }
  3876  
  3877  func __asm_proxy_MOVDQ2Q__(p *Program, v ...interface{}) *Instruction {
  3878      if len(v) == 2 {
  3879          return p.MOVDQ2Q(v[0], v[1])
  3880      } else {
  3881          panic("instruction MOVDQ2Q takes exactly 2 operands")
  3882      }
  3883  }
  3884  
  3885  func __asm_proxy_MOVDQA__(p *Program, v ...interface{}) *Instruction {
  3886      if len(v) == 2 {
  3887          return p.MOVDQA(v[0], v[1])
  3888      } else {
  3889          panic("instruction MOVDQA takes exactly 2 operands")
  3890      }
  3891  }
  3892  
  3893  func __asm_proxy_MOVDQU__(p *Program, v ...interface{}) *Instruction {
  3894      if len(v) == 2 {
  3895          return p.MOVDQU(v[0], v[1])
  3896      } else {
  3897          panic("instruction MOVDQU takes exactly 2 operands")
  3898      }
  3899  }
  3900  
  3901  func __asm_proxy_MOVHLPS__(p *Program, v ...interface{}) *Instruction {
  3902      if len(v) == 2 {
  3903          return p.MOVHLPS(v[0], v[1])
  3904      } else {
  3905          panic("instruction MOVHLPS takes exactly 2 operands")
  3906      }
  3907  }
  3908  
  3909  func __asm_proxy_MOVHPD__(p *Program, v ...interface{}) *Instruction {
  3910      if len(v) == 2 {
  3911          return p.MOVHPD(v[0], v[1])
  3912      } else {
  3913          panic("instruction MOVHPD takes exactly 2 operands")
  3914      }
  3915  }
  3916  
  3917  func __asm_proxy_MOVHPS__(p *Program, v ...interface{}) *Instruction {
  3918      if len(v) == 2 {
  3919          return p.MOVHPS(v[0], v[1])
  3920      } else {
  3921          panic("instruction MOVHPS takes exactly 2 operands")
  3922      }
  3923  }
  3924  
  3925  func __asm_proxy_MOVL__(p *Program, v ...interface{}) *Instruction {
  3926      if len(v) == 2 {
  3927          return p.MOVL(v[0], v[1])
  3928      } else {
  3929          panic("instruction MOVL takes exactly 2 operands")
  3930      }
  3931  }
  3932  
  3933  func __asm_proxy_MOVLHPS__(p *Program, v ...interface{}) *Instruction {
  3934      if len(v) == 2 {
  3935          return p.MOVLHPS(v[0], v[1])
  3936      } else {
  3937          panic("instruction MOVLHPS takes exactly 2 operands")
  3938      }
  3939  }
  3940  
  3941  func __asm_proxy_MOVLPD__(p *Program, v ...interface{}) *Instruction {
  3942      if len(v) == 2 {
  3943          return p.MOVLPD(v[0], v[1])
  3944      } else {
  3945          panic("instruction MOVLPD takes exactly 2 operands")
  3946      }
  3947  }
  3948  
  3949  func __asm_proxy_MOVLPS__(p *Program, v ...interface{}) *Instruction {
  3950      if len(v) == 2 {
  3951          return p.MOVLPS(v[0], v[1])
  3952      } else {
  3953          panic("instruction MOVLPS takes exactly 2 operands")
  3954      }
  3955  }
  3956  
  3957  func __asm_proxy_MOVMSKPD__(p *Program, v ...interface{}) *Instruction {
  3958      if len(v) == 2 {
  3959          return p.MOVMSKPD(v[0], v[1])
  3960      } else {
  3961          panic("instruction MOVMSKPD takes exactly 2 operands")
  3962      }
  3963  }
  3964  
  3965  func __asm_proxy_MOVMSKPS__(p *Program, v ...interface{}) *Instruction {
  3966      if len(v) == 2 {
  3967          return p.MOVMSKPS(v[0], v[1])
  3968      } else {
  3969          panic("instruction MOVMSKPS takes exactly 2 operands")
  3970      }
  3971  }
  3972  
  3973  func __asm_proxy_MOVNTDQ__(p *Program, v ...interface{}) *Instruction {
  3974      if len(v) == 2 {
  3975          return p.MOVNTDQ(v[0], v[1])
  3976      } else {
  3977          panic("instruction MOVNTDQ takes exactly 2 operands")
  3978      }
  3979  }
  3980  
  3981  func __asm_proxy_MOVNTDQA__(p *Program, v ...interface{}) *Instruction {
  3982      if len(v) == 2 {
  3983          return p.MOVNTDQA(v[0], v[1])
  3984      } else {
  3985          panic("instruction MOVNTDQA takes exactly 2 operands")
  3986      }
  3987  }
  3988  
  3989  func __asm_proxy_MOVNTIL__(p *Program, v ...interface{}) *Instruction {
  3990      if len(v) == 2 {
  3991          return p.MOVNTIL(v[0], v[1])
  3992      } else {
  3993          panic("instruction MOVNTIL takes exactly 2 operands")
  3994      }
  3995  }
  3996  
  3997  func __asm_proxy_MOVNTIQ__(p *Program, v ...interface{}) *Instruction {
  3998      if len(v) == 2 {
  3999          return p.MOVNTIQ(v[0], v[1])
  4000      } else {
  4001          panic("instruction MOVNTIQ takes exactly 2 operands")
  4002      }
  4003  }
  4004  
  4005  func __asm_proxy_MOVNTPD__(p *Program, v ...interface{}) *Instruction {
  4006      if len(v) == 2 {
  4007          return p.MOVNTPD(v[0], v[1])
  4008      } else {
  4009          panic("instruction MOVNTPD takes exactly 2 operands")
  4010      }
  4011  }
  4012  
  4013  func __asm_proxy_MOVNTPS__(p *Program, v ...interface{}) *Instruction {
  4014      if len(v) == 2 {
  4015          return p.MOVNTPS(v[0], v[1])
  4016      } else {
  4017          panic("instruction MOVNTPS takes exactly 2 operands")
  4018      }
  4019  }
  4020  
  4021  func __asm_proxy_MOVNTQ__(p *Program, v ...interface{}) *Instruction {
  4022      if len(v) == 2 {
  4023          return p.MOVNTQ(v[0], v[1])
  4024      } else {
  4025          panic("instruction MOVNTQ takes exactly 2 operands")
  4026      }
  4027  }
  4028  
  4029  func __asm_proxy_MOVNTSD__(p *Program, v ...interface{}) *Instruction {
  4030      if len(v) == 2 {
  4031          return p.MOVNTSD(v[0], v[1])
  4032      } else {
  4033          panic("instruction MOVNTSD takes exactly 2 operands")
  4034      }
  4035  }
  4036  
  4037  func __asm_proxy_MOVNTSS__(p *Program, v ...interface{}) *Instruction {
  4038      if len(v) == 2 {
  4039          return p.MOVNTSS(v[0], v[1])
  4040      } else {
  4041          panic("instruction MOVNTSS takes exactly 2 operands")
  4042      }
  4043  }
  4044  
  4045  func __asm_proxy_MOVQ__(p *Program, v ...interface{}) *Instruction {
  4046      if len(v) == 2 {
  4047          return p.MOVQ(v[0], v[1])
  4048      } else {
  4049          panic("instruction MOVQ takes exactly 2 operands")
  4050      }
  4051  }
  4052  
  4053  func __asm_proxy_MOVQ2DQ__(p *Program, v ...interface{}) *Instruction {
  4054      if len(v) == 2 {
  4055          return p.MOVQ2DQ(v[0], v[1])
  4056      } else {
  4057          panic("instruction MOVQ2DQ takes exactly 2 operands")
  4058      }
  4059  }
  4060  
  4061  func __asm_proxy_MOVSBL__(p *Program, v ...interface{}) *Instruction {
  4062      if len(v) == 2 {
  4063          return p.MOVSBL(v[0], v[1])
  4064      } else {
  4065          panic("instruction MOVSBL takes exactly 2 operands")
  4066      }
  4067  }
  4068  
  4069  func __asm_proxy_MOVSBQ__(p *Program, v ...interface{}) *Instruction {
  4070      if len(v) == 2 {
  4071          return p.MOVSBQ(v[0], v[1])
  4072      } else {
  4073          panic("instruction MOVSBQ takes exactly 2 operands")
  4074      }
  4075  }
  4076  
  4077  func __asm_proxy_MOVSBW__(p *Program, v ...interface{}) *Instruction {
  4078      if len(v) == 2 {
  4079          return p.MOVSBW(v[0], v[1])
  4080      } else {
  4081          panic("instruction MOVSBW takes exactly 2 operands")
  4082      }
  4083  }
  4084  
  4085  func __asm_proxy_MOVSD__(p *Program, v ...interface{}) *Instruction {
  4086      if len(v) == 2 {
  4087          return p.MOVSD(v[0], v[1])
  4088      } else {
  4089          panic("instruction MOVSD takes exactly 2 operands")
  4090      }
  4091  }
  4092  
  4093  func __asm_proxy_MOVSHDUP__(p *Program, v ...interface{}) *Instruction {
  4094      if len(v) == 2 {
  4095          return p.MOVSHDUP(v[0], v[1])
  4096      } else {
  4097          panic("instruction MOVSHDUP takes exactly 2 operands")
  4098      }
  4099  }
  4100  
  4101  func __asm_proxy_MOVSLDUP__(p *Program, v ...interface{}) *Instruction {
  4102      if len(v) == 2 {
  4103          return p.MOVSLDUP(v[0], v[1])
  4104      } else {
  4105          panic("instruction MOVSLDUP takes exactly 2 operands")
  4106      }
  4107  }
  4108  
  4109  func __asm_proxy_MOVSLQ__(p *Program, v ...interface{}) *Instruction {
  4110      if len(v) == 2 {
  4111          return p.MOVSLQ(v[0], v[1])
  4112      } else {
  4113          panic("instruction MOVSLQ takes exactly 2 operands")
  4114      }
  4115  }
  4116  
  4117  func __asm_proxy_MOVSS__(p *Program, v ...interface{}) *Instruction {
  4118      if len(v) == 2 {
  4119          return p.MOVSS(v[0], v[1])
  4120      } else {
  4121          panic("instruction MOVSS takes exactly 2 operands")
  4122      }
  4123  }
  4124  
  4125  func __asm_proxy_MOVSWL__(p *Program, v ...interface{}) *Instruction {
  4126      if len(v) == 2 {
  4127          return p.MOVSWL(v[0], v[1])
  4128      } else {
  4129          panic("instruction MOVSWL takes exactly 2 operands")
  4130      }
  4131  }
  4132  
  4133  func __asm_proxy_MOVSWQ__(p *Program, v ...interface{}) *Instruction {
  4134      if len(v) == 2 {
  4135          return p.MOVSWQ(v[0], v[1])
  4136      } else {
  4137          panic("instruction MOVSWQ takes exactly 2 operands")
  4138      }
  4139  }
  4140  
  4141  func __asm_proxy_MOVUPD__(p *Program, v ...interface{}) *Instruction {
  4142      if len(v) == 2 {
  4143          return p.MOVUPD(v[0], v[1])
  4144      } else {
  4145          panic("instruction MOVUPD takes exactly 2 operands")
  4146      }
  4147  }
  4148  
  4149  func __asm_proxy_MOVUPS__(p *Program, v ...interface{}) *Instruction {
  4150      if len(v) == 2 {
  4151          return p.MOVUPS(v[0], v[1])
  4152      } else {
  4153          panic("instruction MOVUPS takes exactly 2 operands")
  4154      }
  4155  }
  4156  
  4157  func __asm_proxy_MOVW__(p *Program, v ...interface{}) *Instruction {
  4158      if len(v) == 2 {
  4159          return p.MOVW(v[0], v[1])
  4160      } else {
  4161          panic("instruction MOVW takes exactly 2 operands")
  4162      }
  4163  }
  4164  
  4165  func __asm_proxy_MOVZBL__(p *Program, v ...interface{}) *Instruction {
  4166      if len(v) == 2 {
  4167          return p.MOVZBL(v[0], v[1])
  4168      } else {
  4169          panic("instruction MOVZBL takes exactly 2 operands")
  4170      }
  4171  }
  4172  
  4173  func __asm_proxy_MOVZBQ__(p *Program, v ...interface{}) *Instruction {
  4174      if len(v) == 2 {
  4175          return p.MOVZBQ(v[0], v[1])
  4176      } else {
  4177          panic("instruction MOVZBQ takes exactly 2 operands")
  4178      }
  4179  }
  4180  
  4181  func __asm_proxy_MOVZBW__(p *Program, v ...interface{}) *Instruction {
  4182      if len(v) == 2 {
  4183          return p.MOVZBW(v[0], v[1])
  4184      } else {
  4185          panic("instruction MOVZBW takes exactly 2 operands")
  4186      }
  4187  }
  4188  
  4189  func __asm_proxy_MOVZWL__(p *Program, v ...interface{}) *Instruction {
  4190      if len(v) == 2 {
  4191          return p.MOVZWL(v[0], v[1])
  4192      } else {
  4193          panic("instruction MOVZWL takes exactly 2 operands")
  4194      }
  4195  }
  4196  
  4197  func __asm_proxy_MOVZWQ__(p *Program, v ...interface{}) *Instruction {
  4198      if len(v) == 2 {
  4199          return p.MOVZWQ(v[0], v[1])
  4200      } else {
  4201          panic("instruction MOVZWQ takes exactly 2 operands")
  4202      }
  4203  }
  4204  
  4205  func __asm_proxy_MPSADBW__(p *Program, v ...interface{}) *Instruction {
  4206      if len(v) == 3 {
  4207          return p.MPSADBW(v[0], v[1], v[2])
  4208      } else {
  4209          panic("instruction MPSADBW takes exactly 3 operands")
  4210      }
  4211  }
  4212  
  4213  func __asm_proxy_MULB__(p *Program, v ...interface{}) *Instruction {
  4214      if len(v) == 1 {
  4215          return p.MULB(v[0])
  4216      } else {
  4217          panic("instruction MULB takes exactly 1 operand")
  4218      }
  4219  }
  4220  
  4221  func __asm_proxy_MULL__(p *Program, v ...interface{}) *Instruction {
  4222      if len(v) == 1 {
  4223          return p.MULL(v[0])
  4224      } else {
  4225          panic("instruction MULL takes exactly 1 operand")
  4226      }
  4227  }
  4228  
  4229  func __asm_proxy_MULPD__(p *Program, v ...interface{}) *Instruction {
  4230      if len(v) == 2 {
  4231          return p.MULPD(v[0], v[1])
  4232      } else {
  4233          panic("instruction MULPD takes exactly 2 operands")
  4234      }
  4235  }
  4236  
  4237  func __asm_proxy_MULPS__(p *Program, v ...interface{}) *Instruction {
  4238      if len(v) == 2 {
  4239          return p.MULPS(v[0], v[1])
  4240      } else {
  4241          panic("instruction MULPS takes exactly 2 operands")
  4242      }
  4243  }
  4244  
  4245  func __asm_proxy_MULQ__(p *Program, v ...interface{}) *Instruction {
  4246      if len(v) == 1 {
  4247          return p.MULQ(v[0])
  4248      } else {
  4249          panic("instruction MULQ takes exactly 1 operand")
  4250      }
  4251  }
  4252  
  4253  func __asm_proxy_MULSD__(p *Program, v ...interface{}) *Instruction {
  4254      if len(v) == 2 {
  4255          return p.MULSD(v[0], v[1])
  4256      } else {
  4257          panic("instruction MULSD takes exactly 2 operands")
  4258      }
  4259  }
  4260  
  4261  func __asm_proxy_MULSS__(p *Program, v ...interface{}) *Instruction {
  4262      if len(v) == 2 {
  4263          return p.MULSS(v[0], v[1])
  4264      } else {
  4265          panic("instruction MULSS takes exactly 2 operands")
  4266      }
  4267  }
  4268  
  4269  func __asm_proxy_MULW__(p *Program, v ...interface{}) *Instruction {
  4270      if len(v) == 1 {
  4271          return p.MULW(v[0])
  4272      } else {
  4273          panic("instruction MULW takes exactly 1 operand")
  4274      }
  4275  }
  4276  
  4277  func __asm_proxy_MULXL__(p *Program, v ...interface{}) *Instruction {
  4278      if len(v) == 3 {
  4279          return p.MULXL(v[0], v[1], v[2])
  4280      } else {
  4281          panic("instruction MULXL takes exactly 3 operands")
  4282      }
  4283  }
  4284  
  4285  func __asm_proxy_MULXQ__(p *Program, v ...interface{}) *Instruction {
  4286      if len(v) == 3 {
  4287          return p.MULXQ(v[0], v[1], v[2])
  4288      } else {
  4289          panic("instruction MULXQ takes exactly 3 operands")
  4290      }
  4291  }
  4292  
  4293  func __asm_proxy_MWAIT__(p *Program, v ...interface{}) *Instruction {
  4294      if len(v) == 0 {
  4295          return p.MWAIT()
  4296      } else {
  4297          panic("instruction MWAIT takes no operands")
  4298      }
  4299  }
  4300  
  4301  func __asm_proxy_MWAITX__(p *Program, v ...interface{}) *Instruction {
  4302      if len(v) == 0 {
  4303          return p.MWAITX()
  4304      } else {
  4305          panic("instruction MWAITX takes no operands")
  4306      }
  4307  }
  4308  
  4309  func __asm_proxy_NEGB__(p *Program, v ...interface{}) *Instruction {
  4310      if len(v) == 1 {
  4311          return p.NEGB(v[0])
  4312      } else {
  4313          panic("instruction NEGB takes exactly 1 operand")
  4314      }
  4315  }
  4316  
  4317  func __asm_proxy_NEGL__(p *Program, v ...interface{}) *Instruction {
  4318      if len(v) == 1 {
  4319          return p.NEGL(v[0])
  4320      } else {
  4321          panic("instruction NEGL takes exactly 1 operand")
  4322      }
  4323  }
  4324  
  4325  func __asm_proxy_NEGQ__(p *Program, v ...interface{}) *Instruction {
  4326      if len(v) == 1 {
  4327          return p.NEGQ(v[0])
  4328      } else {
  4329          panic("instruction NEGQ takes exactly 1 operand")
  4330      }
  4331  }
  4332  
  4333  func __asm_proxy_NEGW__(p *Program, v ...interface{}) *Instruction {
  4334      if len(v) == 1 {
  4335          return p.NEGW(v[0])
  4336      } else {
  4337          panic("instruction NEGW takes exactly 1 operand")
  4338      }
  4339  }
  4340  
  4341  func __asm_proxy_NOP__(p *Program, v ...interface{}) *Instruction {
  4342      if len(v) == 0 {
  4343          return p.NOP()
  4344      } else {
  4345          panic("instruction NOP takes no operands")
  4346      }
  4347  }
  4348  
  4349  func __asm_proxy_NOTB__(p *Program, v ...interface{}) *Instruction {
  4350      if len(v) == 1 {
  4351          return p.NOTB(v[0])
  4352      } else {
  4353          panic("instruction NOTB takes exactly 1 operand")
  4354      }
  4355  }
  4356  
  4357  func __asm_proxy_NOTL__(p *Program, v ...interface{}) *Instruction {
  4358      if len(v) == 1 {
  4359          return p.NOTL(v[0])
  4360      } else {
  4361          panic("instruction NOTL takes exactly 1 operand")
  4362      }
  4363  }
  4364  
  4365  func __asm_proxy_NOTQ__(p *Program, v ...interface{}) *Instruction {
  4366      if len(v) == 1 {
  4367          return p.NOTQ(v[0])
  4368      } else {
  4369          panic("instruction NOTQ takes exactly 1 operand")
  4370      }
  4371  }
  4372  
  4373  func __asm_proxy_NOTW__(p *Program, v ...interface{}) *Instruction {
  4374      if len(v) == 1 {
  4375          return p.NOTW(v[0])
  4376      } else {
  4377          panic("instruction NOTW takes exactly 1 operand")
  4378      }
  4379  }
  4380  
  4381  func __asm_proxy_ORB__(p *Program, v ...interface{}) *Instruction {
  4382      if len(v) == 2 {
  4383          return p.ORB(v[0], v[1])
  4384      } else {
  4385          panic("instruction ORB takes exactly 2 operands")
  4386      }
  4387  }
  4388  
  4389  func __asm_proxy_ORL__(p *Program, v ...interface{}) *Instruction {
  4390      if len(v) == 2 {
  4391          return p.ORL(v[0], v[1])
  4392      } else {
  4393          panic("instruction ORL takes exactly 2 operands")
  4394      }
  4395  }
  4396  
  4397  func __asm_proxy_ORPD__(p *Program, v ...interface{}) *Instruction {
  4398      if len(v) == 2 {
  4399          return p.ORPD(v[0], v[1])
  4400      } else {
  4401          panic("instruction ORPD takes exactly 2 operands")
  4402      }
  4403  }
  4404  
  4405  func __asm_proxy_ORPS__(p *Program, v ...interface{}) *Instruction {
  4406      if len(v) == 2 {
  4407          return p.ORPS(v[0], v[1])
  4408      } else {
  4409          panic("instruction ORPS takes exactly 2 operands")
  4410      }
  4411  }
  4412  
  4413  func __asm_proxy_ORQ__(p *Program, v ...interface{}) *Instruction {
  4414      if len(v) == 2 {
  4415          return p.ORQ(v[0], v[1])
  4416      } else {
  4417          panic("instruction ORQ takes exactly 2 operands")
  4418      }
  4419  }
  4420  
  4421  func __asm_proxy_ORW__(p *Program, v ...interface{}) *Instruction {
  4422      if len(v) == 2 {
  4423          return p.ORW(v[0], v[1])
  4424      } else {
  4425          panic("instruction ORW takes exactly 2 operands")
  4426      }
  4427  }
  4428  
  4429  func __asm_proxy_PABSB__(p *Program, v ...interface{}) *Instruction {
  4430      if len(v) == 2 {
  4431          return p.PABSB(v[0], v[1])
  4432      } else {
  4433          panic("instruction PABSB takes exactly 2 operands")
  4434      }
  4435  }
  4436  
  4437  func __asm_proxy_PABSD__(p *Program, v ...interface{}) *Instruction {
  4438      if len(v) == 2 {
  4439          return p.PABSD(v[0], v[1])
  4440      } else {
  4441          panic("instruction PABSD takes exactly 2 operands")
  4442      }
  4443  }
  4444  
  4445  func __asm_proxy_PABSW__(p *Program, v ...interface{}) *Instruction {
  4446      if len(v) == 2 {
  4447          return p.PABSW(v[0], v[1])
  4448      } else {
  4449          panic("instruction PABSW takes exactly 2 operands")
  4450      }
  4451  }
  4452  
  4453  func __asm_proxy_PACKSSDW__(p *Program, v ...interface{}) *Instruction {
  4454      if len(v) == 2 {
  4455          return p.PACKSSDW(v[0], v[1])
  4456      } else {
  4457          panic("instruction PACKSSDW takes exactly 2 operands")
  4458      }
  4459  }
  4460  
  4461  func __asm_proxy_PACKSSWB__(p *Program, v ...interface{}) *Instruction {
  4462      if len(v) == 2 {
  4463          return p.PACKSSWB(v[0], v[1])
  4464      } else {
  4465          panic("instruction PACKSSWB takes exactly 2 operands")
  4466      }
  4467  }
  4468  
  4469  func __asm_proxy_PACKUSDW__(p *Program, v ...interface{}) *Instruction {
  4470      if len(v) == 2 {
  4471          return p.PACKUSDW(v[0], v[1])
  4472      } else {
  4473          panic("instruction PACKUSDW takes exactly 2 operands")
  4474      }
  4475  }
  4476  
  4477  func __asm_proxy_PACKUSWB__(p *Program, v ...interface{}) *Instruction {
  4478      if len(v) == 2 {
  4479          return p.PACKUSWB(v[0], v[1])
  4480      } else {
  4481          panic("instruction PACKUSWB takes exactly 2 operands")
  4482      }
  4483  }
  4484  
  4485  func __asm_proxy_PADDB__(p *Program, v ...interface{}) *Instruction {
  4486      if len(v) == 2 {
  4487          return p.PADDB(v[0], v[1])
  4488      } else {
  4489          panic("instruction PADDB takes exactly 2 operands")
  4490      }
  4491  }
  4492  
  4493  func __asm_proxy_PADDD__(p *Program, v ...interface{}) *Instruction {
  4494      if len(v) == 2 {
  4495          return p.PADDD(v[0], v[1])
  4496      } else {
  4497          panic("instruction PADDD takes exactly 2 operands")
  4498      }
  4499  }
  4500  
  4501  func __asm_proxy_PADDQ__(p *Program, v ...interface{}) *Instruction {
  4502      if len(v) == 2 {
  4503          return p.PADDQ(v[0], v[1])
  4504      } else {
  4505          panic("instruction PADDQ takes exactly 2 operands")
  4506      }
  4507  }
  4508  
  4509  func __asm_proxy_PADDSB__(p *Program, v ...interface{}) *Instruction {
  4510      if len(v) == 2 {
  4511          return p.PADDSB(v[0], v[1])
  4512      } else {
  4513          panic("instruction PADDSB takes exactly 2 operands")
  4514      }
  4515  }
  4516  
  4517  func __asm_proxy_PADDSW__(p *Program, v ...interface{}) *Instruction {
  4518      if len(v) == 2 {
  4519          return p.PADDSW(v[0], v[1])
  4520      } else {
  4521          panic("instruction PADDSW takes exactly 2 operands")
  4522      }
  4523  }
  4524  
  4525  func __asm_proxy_PADDUSB__(p *Program, v ...interface{}) *Instruction {
  4526      if len(v) == 2 {
  4527          return p.PADDUSB(v[0], v[1])
  4528      } else {
  4529          panic("instruction PADDUSB takes exactly 2 operands")
  4530      }
  4531  }
  4532  
  4533  func __asm_proxy_PADDUSW__(p *Program, v ...interface{}) *Instruction {
  4534      if len(v) == 2 {
  4535          return p.PADDUSW(v[0], v[1])
  4536      } else {
  4537          panic("instruction PADDUSW takes exactly 2 operands")
  4538      }
  4539  }
  4540  
  4541  func __asm_proxy_PADDW__(p *Program, v ...interface{}) *Instruction {
  4542      if len(v) == 2 {
  4543          return p.PADDW(v[0], v[1])
  4544      } else {
  4545          panic("instruction PADDW takes exactly 2 operands")
  4546      }
  4547  }
  4548  
  4549  func __asm_proxy_PALIGNR__(p *Program, v ...interface{}) *Instruction {
  4550      if len(v) == 3 {
  4551          return p.PALIGNR(v[0], v[1], v[2])
  4552      } else {
  4553          panic("instruction PALIGNR takes exactly 3 operands")
  4554      }
  4555  }
  4556  
  4557  func __asm_proxy_PAND__(p *Program, v ...interface{}) *Instruction {
  4558      if len(v) == 2 {
  4559          return p.PAND(v[0], v[1])
  4560      } else {
  4561          panic("instruction PAND takes exactly 2 operands")
  4562      }
  4563  }
  4564  
  4565  func __asm_proxy_PANDN__(p *Program, v ...interface{}) *Instruction {
  4566      if len(v) == 2 {
  4567          return p.PANDN(v[0], v[1])
  4568      } else {
  4569          panic("instruction PANDN takes exactly 2 operands")
  4570      }
  4571  }
  4572  
  4573  func __asm_proxy_PAUSE__(p *Program, v ...interface{}) *Instruction {
  4574      if len(v) == 0 {
  4575          return p.PAUSE()
  4576      } else {
  4577          panic("instruction PAUSE takes no operands")
  4578      }
  4579  }
  4580  
  4581  func __asm_proxy_PAVGB__(p *Program, v ...interface{}) *Instruction {
  4582      if len(v) == 2 {
  4583          return p.PAVGB(v[0], v[1])
  4584      } else {
  4585          panic("instruction PAVGB takes exactly 2 operands")
  4586      }
  4587  }
  4588  
  4589  func __asm_proxy_PAVGUSB__(p *Program, v ...interface{}) *Instruction {
  4590      if len(v) == 2 {
  4591          return p.PAVGUSB(v[0], v[1])
  4592      } else {
  4593          panic("instruction PAVGUSB takes exactly 2 operands")
  4594      }
  4595  }
  4596  
  4597  func __asm_proxy_PAVGW__(p *Program, v ...interface{}) *Instruction {
  4598      if len(v) == 2 {
  4599          return p.PAVGW(v[0], v[1])
  4600      } else {
  4601          panic("instruction PAVGW takes exactly 2 operands")
  4602      }
  4603  }
  4604  
  4605  func __asm_proxy_PBLENDVB__(p *Program, v ...interface{}) *Instruction {
  4606      if len(v) == 3 {
  4607          return p.PBLENDVB(v[0], v[1], v[2])
  4608      } else {
  4609          panic("instruction PBLENDVB takes exactly 3 operands")
  4610      }
  4611  }
  4612  
  4613  func __asm_proxy_PBLENDW__(p *Program, v ...interface{}) *Instruction {
  4614      if len(v) == 3 {
  4615          return p.PBLENDW(v[0], v[1], v[2])
  4616      } else {
  4617          panic("instruction PBLENDW takes exactly 3 operands")
  4618      }
  4619  }
  4620  
  4621  func __asm_proxy_PCLMULQDQ__(p *Program, v ...interface{}) *Instruction {
  4622      if len(v) == 3 {
  4623          return p.PCLMULQDQ(v[0], v[1], v[2])
  4624      } else {
  4625          panic("instruction PCLMULQDQ takes exactly 3 operands")
  4626      }
  4627  }
  4628  
  4629  func __asm_proxy_PCMPEQB__(p *Program, v ...interface{}) *Instruction {
  4630      if len(v) == 2 {
  4631          return p.PCMPEQB(v[0], v[1])
  4632      } else {
  4633          panic("instruction PCMPEQB takes exactly 2 operands")
  4634      }
  4635  }
  4636  
  4637  func __asm_proxy_PCMPEQD__(p *Program, v ...interface{}) *Instruction {
  4638      if len(v) == 2 {
  4639          return p.PCMPEQD(v[0], v[1])
  4640      } else {
  4641          panic("instruction PCMPEQD takes exactly 2 operands")
  4642      }
  4643  }
  4644  
  4645  func __asm_proxy_PCMPEQQ__(p *Program, v ...interface{}) *Instruction {
  4646      if len(v) == 2 {
  4647          return p.PCMPEQQ(v[0], v[1])
  4648      } else {
  4649          panic("instruction PCMPEQQ takes exactly 2 operands")
  4650      }
  4651  }
  4652  
  4653  func __asm_proxy_PCMPEQW__(p *Program, v ...interface{}) *Instruction {
  4654      if len(v) == 2 {
  4655          return p.PCMPEQW(v[0], v[1])
  4656      } else {
  4657          panic("instruction PCMPEQW takes exactly 2 operands")
  4658      }
  4659  }
  4660  
  4661  func __asm_proxy_PCMPESTRI__(p *Program, v ...interface{}) *Instruction {
  4662      if len(v) == 3 {
  4663          return p.PCMPESTRI(v[0], v[1], v[2])
  4664      } else {
  4665          panic("instruction PCMPESTRI takes exactly 3 operands")
  4666      }
  4667  }
  4668  
  4669  func __asm_proxy_PCMPESTRM__(p *Program, v ...interface{}) *Instruction {
  4670      if len(v) == 3 {
  4671          return p.PCMPESTRM(v[0], v[1], v[2])
  4672      } else {
  4673          panic("instruction PCMPESTRM takes exactly 3 operands")
  4674      }
  4675  }
  4676  
  4677  func __asm_proxy_PCMPGTB__(p *Program, v ...interface{}) *Instruction {
  4678      if len(v) == 2 {
  4679          return p.PCMPGTB(v[0], v[1])
  4680      } else {
  4681          panic("instruction PCMPGTB takes exactly 2 operands")
  4682      }
  4683  }
  4684  
  4685  func __asm_proxy_PCMPGTD__(p *Program, v ...interface{}) *Instruction {
  4686      if len(v) == 2 {
  4687          return p.PCMPGTD(v[0], v[1])
  4688      } else {
  4689          panic("instruction PCMPGTD takes exactly 2 operands")
  4690      }
  4691  }
  4692  
  4693  func __asm_proxy_PCMPGTQ__(p *Program, v ...interface{}) *Instruction {
  4694      if len(v) == 2 {
  4695          return p.PCMPGTQ(v[0], v[1])
  4696      } else {
  4697          panic("instruction PCMPGTQ takes exactly 2 operands")
  4698      }
  4699  }
  4700  
  4701  func __asm_proxy_PCMPGTW__(p *Program, v ...interface{}) *Instruction {
  4702      if len(v) == 2 {
  4703          return p.PCMPGTW(v[0], v[1])
  4704      } else {
  4705          panic("instruction PCMPGTW takes exactly 2 operands")
  4706      }
  4707  }
  4708  
  4709  func __asm_proxy_PCMPISTRI__(p *Program, v ...interface{}) *Instruction {
  4710      if len(v) == 3 {
  4711          return p.PCMPISTRI(v[0], v[1], v[2])
  4712      } else {
  4713          panic("instruction PCMPISTRI takes exactly 3 operands")
  4714      }
  4715  }
  4716  
  4717  func __asm_proxy_PCMPISTRM__(p *Program, v ...interface{}) *Instruction {
  4718      if len(v) == 3 {
  4719          return p.PCMPISTRM(v[0], v[1], v[2])
  4720      } else {
  4721          panic("instruction PCMPISTRM takes exactly 3 operands")
  4722      }
  4723  }
  4724  
  4725  func __asm_proxy_PDEP__(p *Program, v ...interface{}) *Instruction {
  4726      if len(v) == 3 {
  4727          return p.PDEP(v[0], v[1], v[2])
  4728      } else {
  4729          panic("instruction PDEP takes exactly 3 operands")
  4730      }
  4731  }
  4732  
  4733  func __asm_proxy_PEXT__(p *Program, v ...interface{}) *Instruction {
  4734      if len(v) == 3 {
  4735          return p.PEXT(v[0], v[1], v[2])
  4736      } else {
  4737          panic("instruction PEXT takes exactly 3 operands")
  4738      }
  4739  }
  4740  
  4741  func __asm_proxy_PEXTRB__(p *Program, v ...interface{}) *Instruction {
  4742      if len(v) == 3 {
  4743          return p.PEXTRB(v[0], v[1], v[2])
  4744      } else {
  4745          panic("instruction PEXTRB takes exactly 3 operands")
  4746      }
  4747  }
  4748  
  4749  func __asm_proxy_PEXTRD__(p *Program, v ...interface{}) *Instruction {
  4750      if len(v) == 3 {
  4751          return p.PEXTRD(v[0], v[1], v[2])
  4752      } else {
  4753          panic("instruction PEXTRD takes exactly 3 operands")
  4754      }
  4755  }
  4756  
  4757  func __asm_proxy_PEXTRQ__(p *Program, v ...interface{}) *Instruction {
  4758      if len(v) == 3 {
  4759          return p.PEXTRQ(v[0], v[1], v[2])
  4760      } else {
  4761          panic("instruction PEXTRQ takes exactly 3 operands")
  4762      }
  4763  }
  4764  
  4765  func __asm_proxy_PEXTRW__(p *Program, v ...interface{}) *Instruction {
  4766      if len(v) == 3 {
  4767          return p.PEXTRW(v[0], v[1], v[2])
  4768      } else {
  4769          panic("instruction PEXTRW takes exactly 3 operands")
  4770      }
  4771  }
  4772  
  4773  func __asm_proxy_PF2ID__(p *Program, v ...interface{}) *Instruction {
  4774      if len(v) == 2 {
  4775          return p.PF2ID(v[0], v[1])
  4776      } else {
  4777          panic("instruction PF2ID takes exactly 2 operands")
  4778      }
  4779  }
  4780  
  4781  func __asm_proxy_PF2IW__(p *Program, v ...interface{}) *Instruction {
  4782      if len(v) == 2 {
  4783          return p.PF2IW(v[0], v[1])
  4784      } else {
  4785          panic("instruction PF2IW takes exactly 2 operands")
  4786      }
  4787  }
  4788  
  4789  func __asm_proxy_PFACC__(p *Program, v ...interface{}) *Instruction {
  4790      if len(v) == 2 {
  4791          return p.PFACC(v[0], v[1])
  4792      } else {
  4793          panic("instruction PFACC takes exactly 2 operands")
  4794      }
  4795  }
  4796  
  4797  func __asm_proxy_PFADD__(p *Program, v ...interface{}) *Instruction {
  4798      if len(v) == 2 {
  4799          return p.PFADD(v[0], v[1])
  4800      } else {
  4801          panic("instruction PFADD takes exactly 2 operands")
  4802      }
  4803  }
  4804  
  4805  func __asm_proxy_PFCMPEQ__(p *Program, v ...interface{}) *Instruction {
  4806      if len(v) == 2 {
  4807          return p.PFCMPEQ(v[0], v[1])
  4808      } else {
  4809          panic("instruction PFCMPEQ takes exactly 2 operands")
  4810      }
  4811  }
  4812  
  4813  func __asm_proxy_PFCMPGE__(p *Program, v ...interface{}) *Instruction {
  4814      if len(v) == 2 {
  4815          return p.PFCMPGE(v[0], v[1])
  4816      } else {
  4817          panic("instruction PFCMPGE takes exactly 2 operands")
  4818      }
  4819  }
  4820  
  4821  func __asm_proxy_PFCMPGT__(p *Program, v ...interface{}) *Instruction {
  4822      if len(v) == 2 {
  4823          return p.PFCMPGT(v[0], v[1])
  4824      } else {
  4825          panic("instruction PFCMPGT takes exactly 2 operands")
  4826      }
  4827  }
  4828  
  4829  func __asm_proxy_PFMAX__(p *Program, v ...interface{}) *Instruction {
  4830      if len(v) == 2 {
  4831          return p.PFMAX(v[0], v[1])
  4832      } else {
  4833          panic("instruction PFMAX takes exactly 2 operands")
  4834      }
  4835  }
  4836  
  4837  func __asm_proxy_PFMIN__(p *Program, v ...interface{}) *Instruction {
  4838      if len(v) == 2 {
  4839          return p.PFMIN(v[0], v[1])
  4840      } else {
  4841          panic("instruction PFMIN takes exactly 2 operands")
  4842      }
  4843  }
  4844  
  4845  func __asm_proxy_PFMUL__(p *Program, v ...interface{}) *Instruction {
  4846      if len(v) == 2 {
  4847          return p.PFMUL(v[0], v[1])
  4848      } else {
  4849          panic("instruction PFMUL takes exactly 2 operands")
  4850      }
  4851  }
  4852  
  4853  func __asm_proxy_PFNACC__(p *Program, v ...interface{}) *Instruction {
  4854      if len(v) == 2 {
  4855          return p.PFNACC(v[0], v[1])
  4856      } else {
  4857          panic("instruction PFNACC takes exactly 2 operands")
  4858      }
  4859  }
  4860  
  4861  func __asm_proxy_PFPNACC__(p *Program, v ...interface{}) *Instruction {
  4862      if len(v) == 2 {
  4863          return p.PFPNACC(v[0], v[1])
  4864      } else {
  4865          panic("instruction PFPNACC takes exactly 2 operands")
  4866      }
  4867  }
  4868  
  4869  func __asm_proxy_PFRCP__(p *Program, v ...interface{}) *Instruction {
  4870      if len(v) == 2 {
  4871          return p.PFRCP(v[0], v[1])
  4872      } else {
  4873          panic("instruction PFRCP takes exactly 2 operands")
  4874      }
  4875  }
  4876  
  4877  func __asm_proxy_PFRCPIT1__(p *Program, v ...interface{}) *Instruction {
  4878      if len(v) == 2 {
  4879          return p.PFRCPIT1(v[0], v[1])
  4880      } else {
  4881          panic("instruction PFRCPIT1 takes exactly 2 operands")
  4882      }
  4883  }
  4884  
  4885  func __asm_proxy_PFRCPIT2__(p *Program, v ...interface{}) *Instruction {
  4886      if len(v) == 2 {
  4887          return p.PFRCPIT2(v[0], v[1])
  4888      } else {
  4889          panic("instruction PFRCPIT2 takes exactly 2 operands")
  4890      }
  4891  }
  4892  
  4893  func __asm_proxy_PFRSQIT1__(p *Program, v ...interface{}) *Instruction {
  4894      if len(v) == 2 {
  4895          return p.PFRSQIT1(v[0], v[1])
  4896      } else {
  4897          panic("instruction PFRSQIT1 takes exactly 2 operands")
  4898      }
  4899  }
  4900  
  4901  func __asm_proxy_PFRSQRT__(p *Program, v ...interface{}) *Instruction {
  4902      if len(v) == 2 {
  4903          return p.PFRSQRT(v[0], v[1])
  4904      } else {
  4905          panic("instruction PFRSQRT takes exactly 2 operands")
  4906      }
  4907  }
  4908  
  4909  func __asm_proxy_PFSUB__(p *Program, v ...interface{}) *Instruction {
  4910      if len(v) == 2 {
  4911          return p.PFSUB(v[0], v[1])
  4912      } else {
  4913          panic("instruction PFSUB takes exactly 2 operands")
  4914      }
  4915  }
  4916  
  4917  func __asm_proxy_PFSUBR__(p *Program, v ...interface{}) *Instruction {
  4918      if len(v) == 2 {
  4919          return p.PFSUBR(v[0], v[1])
  4920      } else {
  4921          panic("instruction PFSUBR takes exactly 2 operands")
  4922      }
  4923  }
  4924  
  4925  func __asm_proxy_PHADDD__(p *Program, v ...interface{}) *Instruction {
  4926      if len(v) == 2 {
  4927          return p.PHADDD(v[0], v[1])
  4928      } else {
  4929          panic("instruction PHADDD takes exactly 2 operands")
  4930      }
  4931  }
  4932  
  4933  func __asm_proxy_PHADDSW__(p *Program, v ...interface{}) *Instruction {
  4934      if len(v) == 2 {
  4935          return p.PHADDSW(v[0], v[1])
  4936      } else {
  4937          panic("instruction PHADDSW takes exactly 2 operands")
  4938      }
  4939  }
  4940  
  4941  func __asm_proxy_PHADDW__(p *Program, v ...interface{}) *Instruction {
  4942      if len(v) == 2 {
  4943          return p.PHADDW(v[0], v[1])
  4944      } else {
  4945          panic("instruction PHADDW takes exactly 2 operands")
  4946      }
  4947  }
  4948  
  4949  func __asm_proxy_PHMINPOSUW__(p *Program, v ...interface{}) *Instruction {
  4950      if len(v) == 2 {
  4951          return p.PHMINPOSUW(v[0], v[1])
  4952      } else {
  4953          panic("instruction PHMINPOSUW takes exactly 2 operands")
  4954      }
  4955  }
  4956  
  4957  func __asm_proxy_PHSUBD__(p *Program, v ...interface{}) *Instruction {
  4958      if len(v) == 2 {
  4959          return p.PHSUBD(v[0], v[1])
  4960      } else {
  4961          panic("instruction PHSUBD takes exactly 2 operands")
  4962      }
  4963  }
  4964  
  4965  func __asm_proxy_PHSUBSW__(p *Program, v ...interface{}) *Instruction {
  4966      if len(v) == 2 {
  4967          return p.PHSUBSW(v[0], v[1])
  4968      } else {
  4969          panic("instruction PHSUBSW takes exactly 2 operands")
  4970      }
  4971  }
  4972  
  4973  func __asm_proxy_PHSUBW__(p *Program, v ...interface{}) *Instruction {
  4974      if len(v) == 2 {
  4975          return p.PHSUBW(v[0], v[1])
  4976      } else {
  4977          panic("instruction PHSUBW takes exactly 2 operands")
  4978      }
  4979  }
  4980  
  4981  func __asm_proxy_PI2FD__(p *Program, v ...interface{}) *Instruction {
  4982      if len(v) == 2 {
  4983          return p.PI2FD(v[0], v[1])
  4984      } else {
  4985          panic("instruction PI2FD takes exactly 2 operands")
  4986      }
  4987  }
  4988  
  4989  func __asm_proxy_PI2FW__(p *Program, v ...interface{}) *Instruction {
  4990      if len(v) == 2 {
  4991          return p.PI2FW(v[0], v[1])
  4992      } else {
  4993          panic("instruction PI2FW takes exactly 2 operands")
  4994      }
  4995  }
  4996  
  4997  func __asm_proxy_PINSRB__(p *Program, v ...interface{}) *Instruction {
  4998      if len(v) == 3 {
  4999          return p.PINSRB(v[0], v[1], v[2])
  5000      } else {
  5001          panic("instruction PINSRB takes exactly 3 operands")
  5002      }
  5003  }
  5004  
  5005  func __asm_proxy_PINSRD__(p *Program, v ...interface{}) *Instruction {
  5006      if len(v) == 3 {
  5007          return p.PINSRD(v[0], v[1], v[2])
  5008      } else {
  5009          panic("instruction PINSRD takes exactly 3 operands")
  5010      }
  5011  }
  5012  
  5013  func __asm_proxy_PINSRQ__(p *Program, v ...interface{}) *Instruction {
  5014      if len(v) == 3 {
  5015          return p.PINSRQ(v[0], v[1], v[2])
  5016      } else {
  5017          panic("instruction PINSRQ takes exactly 3 operands")
  5018      }
  5019  }
  5020  
  5021  func __asm_proxy_PINSRW__(p *Program, v ...interface{}) *Instruction {
  5022      if len(v) == 3 {
  5023          return p.PINSRW(v[0], v[1], v[2])
  5024      } else {
  5025          panic("instruction PINSRW takes exactly 3 operands")
  5026      }
  5027  }
  5028  
  5029  func __asm_proxy_PMADDUBSW__(p *Program, v ...interface{}) *Instruction {
  5030      if len(v) == 2 {
  5031          return p.PMADDUBSW(v[0], v[1])
  5032      } else {
  5033          panic("instruction PMADDUBSW takes exactly 2 operands")
  5034      }
  5035  }
  5036  
  5037  func __asm_proxy_PMADDWD__(p *Program, v ...interface{}) *Instruction {
  5038      if len(v) == 2 {
  5039          return p.PMADDWD(v[0], v[1])
  5040      } else {
  5041          panic("instruction PMADDWD takes exactly 2 operands")
  5042      }
  5043  }
  5044  
  5045  func __asm_proxy_PMAXSB__(p *Program, v ...interface{}) *Instruction {
  5046      if len(v) == 2 {
  5047          return p.PMAXSB(v[0], v[1])
  5048      } else {
  5049          panic("instruction PMAXSB takes exactly 2 operands")
  5050      }
  5051  }
  5052  
  5053  func __asm_proxy_PMAXSD__(p *Program, v ...interface{}) *Instruction {
  5054      if len(v) == 2 {
  5055          return p.PMAXSD(v[0], v[1])
  5056      } else {
  5057          panic("instruction PMAXSD takes exactly 2 operands")
  5058      }
  5059  }
  5060  
  5061  func __asm_proxy_PMAXSW__(p *Program, v ...interface{}) *Instruction {
  5062      if len(v) == 2 {
  5063          return p.PMAXSW(v[0], v[1])
  5064      } else {
  5065          panic("instruction PMAXSW takes exactly 2 operands")
  5066      }
  5067  }
  5068  
  5069  func __asm_proxy_PMAXUB__(p *Program, v ...interface{}) *Instruction {
  5070      if len(v) == 2 {
  5071          return p.PMAXUB(v[0], v[1])
  5072      } else {
  5073          panic("instruction PMAXUB takes exactly 2 operands")
  5074      }
  5075  }
  5076  
  5077  func __asm_proxy_PMAXUD__(p *Program, v ...interface{}) *Instruction {
  5078      if len(v) == 2 {
  5079          return p.PMAXUD(v[0], v[1])
  5080      } else {
  5081          panic("instruction PMAXUD takes exactly 2 operands")
  5082      }
  5083  }
  5084  
  5085  func __asm_proxy_PMAXUW__(p *Program, v ...interface{}) *Instruction {
  5086      if len(v) == 2 {
  5087          return p.PMAXUW(v[0], v[1])
  5088      } else {
  5089          panic("instruction PMAXUW takes exactly 2 operands")
  5090      }
  5091  }
  5092  
  5093  func __asm_proxy_PMINSB__(p *Program, v ...interface{}) *Instruction {
  5094      if len(v) == 2 {
  5095          return p.PMINSB(v[0], v[1])
  5096      } else {
  5097          panic("instruction PMINSB takes exactly 2 operands")
  5098      }
  5099  }
  5100  
  5101  func __asm_proxy_PMINSD__(p *Program, v ...interface{}) *Instruction {
  5102      if len(v) == 2 {
  5103          return p.PMINSD(v[0], v[1])
  5104      } else {
  5105          panic("instruction PMINSD takes exactly 2 operands")
  5106      }
  5107  }
  5108  
  5109  func __asm_proxy_PMINSW__(p *Program, v ...interface{}) *Instruction {
  5110      if len(v) == 2 {
  5111          return p.PMINSW(v[0], v[1])
  5112      } else {
  5113          panic("instruction PMINSW takes exactly 2 operands")
  5114      }
  5115  }
  5116  
  5117  func __asm_proxy_PMINUB__(p *Program, v ...interface{}) *Instruction {
  5118      if len(v) == 2 {
  5119          return p.PMINUB(v[0], v[1])
  5120      } else {
  5121          panic("instruction PMINUB takes exactly 2 operands")
  5122      }
  5123  }
  5124  
  5125  func __asm_proxy_PMINUD__(p *Program, v ...interface{}) *Instruction {
  5126      if len(v) == 2 {
  5127          return p.PMINUD(v[0], v[1])
  5128      } else {
  5129          panic("instruction PMINUD takes exactly 2 operands")
  5130      }
  5131  }
  5132  
  5133  func __asm_proxy_PMINUW__(p *Program, v ...interface{}) *Instruction {
  5134      if len(v) == 2 {
  5135          return p.PMINUW(v[0], v[1])
  5136      } else {
  5137          panic("instruction PMINUW takes exactly 2 operands")
  5138      }
  5139  }
  5140  
  5141  func __asm_proxy_PMOVMSKB__(p *Program, v ...interface{}) *Instruction {
  5142      if len(v) == 2 {
  5143          return p.PMOVMSKB(v[0], v[1])
  5144      } else {
  5145          panic("instruction PMOVMSKB takes exactly 2 operands")
  5146      }
  5147  }
  5148  
  5149  func __asm_proxy_PMOVSXBD__(p *Program, v ...interface{}) *Instruction {
  5150      if len(v) == 2 {
  5151          return p.PMOVSXBD(v[0], v[1])
  5152      } else {
  5153          panic("instruction PMOVSXBD takes exactly 2 operands")
  5154      }
  5155  }
  5156  
  5157  func __asm_proxy_PMOVSXBQ__(p *Program, v ...interface{}) *Instruction {
  5158      if len(v) == 2 {
  5159          return p.PMOVSXBQ(v[0], v[1])
  5160      } else {
  5161          panic("instruction PMOVSXBQ takes exactly 2 operands")
  5162      }
  5163  }
  5164  
  5165  func __asm_proxy_PMOVSXBW__(p *Program, v ...interface{}) *Instruction {
  5166      if len(v) == 2 {
  5167          return p.PMOVSXBW(v[0], v[1])
  5168      } else {
  5169          panic("instruction PMOVSXBW takes exactly 2 operands")
  5170      }
  5171  }
  5172  
  5173  func __asm_proxy_PMOVSXDQ__(p *Program, v ...interface{}) *Instruction {
  5174      if len(v) == 2 {
  5175          return p.PMOVSXDQ(v[0], v[1])
  5176      } else {
  5177          panic("instruction PMOVSXDQ takes exactly 2 operands")
  5178      }
  5179  }
  5180  
  5181  func __asm_proxy_PMOVSXWD__(p *Program, v ...interface{}) *Instruction {
  5182      if len(v) == 2 {
  5183          return p.PMOVSXWD(v[0], v[1])
  5184      } else {
  5185          panic("instruction PMOVSXWD takes exactly 2 operands")
  5186      }
  5187  }
  5188  
  5189  func __asm_proxy_PMOVSXWQ__(p *Program, v ...interface{}) *Instruction {
  5190      if len(v) == 2 {
  5191          return p.PMOVSXWQ(v[0], v[1])
  5192      } else {
  5193          panic("instruction PMOVSXWQ takes exactly 2 operands")
  5194      }
  5195  }
  5196  
  5197  func __asm_proxy_PMOVZXBD__(p *Program, v ...interface{}) *Instruction {
  5198      if len(v) == 2 {
  5199          return p.PMOVZXBD(v[0], v[1])
  5200      } else {
  5201          panic("instruction PMOVZXBD takes exactly 2 operands")
  5202      }
  5203  }
  5204  
  5205  func __asm_proxy_PMOVZXBQ__(p *Program, v ...interface{}) *Instruction {
  5206      if len(v) == 2 {
  5207          return p.PMOVZXBQ(v[0], v[1])
  5208      } else {
  5209          panic("instruction PMOVZXBQ takes exactly 2 operands")
  5210      }
  5211  }
  5212  
  5213  func __asm_proxy_PMOVZXBW__(p *Program, v ...interface{}) *Instruction {
  5214      if len(v) == 2 {
  5215          return p.PMOVZXBW(v[0], v[1])
  5216      } else {
  5217          panic("instruction PMOVZXBW takes exactly 2 operands")
  5218      }
  5219  }
  5220  
  5221  func __asm_proxy_PMOVZXDQ__(p *Program, v ...interface{}) *Instruction {
  5222      if len(v) == 2 {
  5223          return p.PMOVZXDQ(v[0], v[1])
  5224      } else {
  5225          panic("instruction PMOVZXDQ takes exactly 2 operands")
  5226      }
  5227  }
  5228  
  5229  func __asm_proxy_PMOVZXWD__(p *Program, v ...interface{}) *Instruction {
  5230      if len(v) == 2 {
  5231          return p.PMOVZXWD(v[0], v[1])
  5232      } else {
  5233          panic("instruction PMOVZXWD takes exactly 2 operands")
  5234      }
  5235  }
  5236  
  5237  func __asm_proxy_PMOVZXWQ__(p *Program, v ...interface{}) *Instruction {
  5238      if len(v) == 2 {
  5239          return p.PMOVZXWQ(v[0], v[1])
  5240      } else {
  5241          panic("instruction PMOVZXWQ takes exactly 2 operands")
  5242      }
  5243  }
  5244  
  5245  func __asm_proxy_PMULDQ__(p *Program, v ...interface{}) *Instruction {
  5246      if len(v) == 2 {
  5247          return p.PMULDQ(v[0], v[1])
  5248      } else {
  5249          panic("instruction PMULDQ takes exactly 2 operands")
  5250      }
  5251  }
  5252  
  5253  func __asm_proxy_PMULHRSW__(p *Program, v ...interface{}) *Instruction {
  5254      if len(v) == 2 {
  5255          return p.PMULHRSW(v[0], v[1])
  5256      } else {
  5257          panic("instruction PMULHRSW takes exactly 2 operands")
  5258      }
  5259  }
  5260  
  5261  func __asm_proxy_PMULHRW__(p *Program, v ...interface{}) *Instruction {
  5262      if len(v) == 2 {
  5263          return p.PMULHRW(v[0], v[1])
  5264      } else {
  5265          panic("instruction PMULHRW takes exactly 2 operands")
  5266      }
  5267  }
  5268  
  5269  func __asm_proxy_PMULHUW__(p *Program, v ...interface{}) *Instruction {
  5270      if len(v) == 2 {
  5271          return p.PMULHUW(v[0], v[1])
  5272      } else {
  5273          panic("instruction PMULHUW takes exactly 2 operands")
  5274      }
  5275  }
  5276  
  5277  func __asm_proxy_PMULHW__(p *Program, v ...interface{}) *Instruction {
  5278      if len(v) == 2 {
  5279          return p.PMULHW(v[0], v[1])
  5280      } else {
  5281          panic("instruction PMULHW takes exactly 2 operands")
  5282      }
  5283  }
  5284  
  5285  func __asm_proxy_PMULLD__(p *Program, v ...interface{}) *Instruction {
  5286      if len(v) == 2 {
  5287          return p.PMULLD(v[0], v[1])
  5288      } else {
  5289          panic("instruction PMULLD takes exactly 2 operands")
  5290      }
  5291  }
  5292  
  5293  func __asm_proxy_PMULLW__(p *Program, v ...interface{}) *Instruction {
  5294      if len(v) == 2 {
  5295          return p.PMULLW(v[0], v[1])
  5296      } else {
  5297          panic("instruction PMULLW takes exactly 2 operands")
  5298      }
  5299  }
  5300  
  5301  func __asm_proxy_PMULUDQ__(p *Program, v ...interface{}) *Instruction {
  5302      if len(v) == 2 {
  5303          return p.PMULUDQ(v[0], v[1])
  5304      } else {
  5305          panic("instruction PMULUDQ takes exactly 2 operands")
  5306      }
  5307  }
  5308  
  5309  func __asm_proxy_POPCNTL__(p *Program, v ...interface{}) *Instruction {
  5310      if len(v) == 2 {
  5311          return p.POPCNTL(v[0], v[1])
  5312      } else {
  5313          panic("instruction POPCNTL takes exactly 2 operands")
  5314      }
  5315  }
  5316  
  5317  func __asm_proxy_POPCNTQ__(p *Program, v ...interface{}) *Instruction {
  5318      if len(v) == 2 {
  5319          return p.POPCNTQ(v[0], v[1])
  5320      } else {
  5321          panic("instruction POPCNTQ takes exactly 2 operands")
  5322      }
  5323  }
  5324  
  5325  func __asm_proxy_POPCNTW__(p *Program, v ...interface{}) *Instruction {
  5326      if len(v) == 2 {
  5327          return p.POPCNTW(v[0], v[1])
  5328      } else {
  5329          panic("instruction POPCNTW takes exactly 2 operands")
  5330      }
  5331  }
  5332  
  5333  func __asm_proxy_POPQ__(p *Program, v ...interface{}) *Instruction {
  5334      if len(v) == 1 {
  5335          return p.POPQ(v[0])
  5336      } else {
  5337          panic("instruction POPQ takes exactly 1 operand")
  5338      }
  5339  }
  5340  
  5341  func __asm_proxy_POPW__(p *Program, v ...interface{}) *Instruction {
  5342      if len(v) == 1 {
  5343          return p.POPW(v[0])
  5344      } else {
  5345          panic("instruction POPW takes exactly 1 operand")
  5346      }
  5347  }
  5348  
  5349  func __asm_proxy_POR__(p *Program, v ...interface{}) *Instruction {
  5350      if len(v) == 2 {
  5351          return p.POR(v[0], v[1])
  5352      } else {
  5353          panic("instruction POR takes exactly 2 operands")
  5354      }
  5355  }
  5356  
  5357  func __asm_proxy_PREFETCH__(p *Program, v ...interface{}) *Instruction {
  5358      if len(v) == 1 {
  5359          return p.PREFETCH(v[0])
  5360      } else {
  5361          panic("instruction PREFETCH takes exactly 1 operand")
  5362      }
  5363  }
  5364  
  5365  func __asm_proxy_PREFETCHNTA__(p *Program, v ...interface{}) *Instruction {
  5366      if len(v) == 1 {
  5367          return p.PREFETCHNTA(v[0])
  5368      } else {
  5369          panic("instruction PREFETCHNTA takes exactly 1 operand")
  5370      }
  5371  }
  5372  
  5373  func __asm_proxy_PREFETCHT0__(p *Program, v ...interface{}) *Instruction {
  5374      if len(v) == 1 {
  5375          return p.PREFETCHT0(v[0])
  5376      } else {
  5377          panic("instruction PREFETCHT0 takes exactly 1 operand")
  5378      }
  5379  }
  5380  
  5381  func __asm_proxy_PREFETCHT1__(p *Program, v ...interface{}) *Instruction {
  5382      if len(v) == 1 {
  5383          return p.PREFETCHT1(v[0])
  5384      } else {
  5385          panic("instruction PREFETCHT1 takes exactly 1 operand")
  5386      }
  5387  }
  5388  
  5389  func __asm_proxy_PREFETCHT2__(p *Program, v ...interface{}) *Instruction {
  5390      if len(v) == 1 {
  5391          return p.PREFETCHT2(v[0])
  5392      } else {
  5393          panic("instruction PREFETCHT2 takes exactly 1 operand")
  5394      }
  5395  }
  5396  
  5397  func __asm_proxy_PREFETCHW__(p *Program, v ...interface{}) *Instruction {
  5398      if len(v) == 1 {
  5399          return p.PREFETCHW(v[0])
  5400      } else {
  5401          panic("instruction PREFETCHW takes exactly 1 operand")
  5402      }
  5403  }
  5404  
  5405  func __asm_proxy_PREFETCHWT1__(p *Program, v ...interface{}) *Instruction {
  5406      if len(v) == 1 {
  5407          return p.PREFETCHWT1(v[0])
  5408      } else {
  5409          panic("instruction PREFETCHWT1 takes exactly 1 operand")
  5410      }
  5411  }
  5412  
  5413  func __asm_proxy_PSADBW__(p *Program, v ...interface{}) *Instruction {
  5414      if len(v) == 2 {
  5415          return p.PSADBW(v[0], v[1])
  5416      } else {
  5417          panic("instruction PSADBW takes exactly 2 operands")
  5418      }
  5419  }
  5420  
  5421  func __asm_proxy_PSHUFB__(p *Program, v ...interface{}) *Instruction {
  5422      if len(v) == 2 {
  5423          return p.PSHUFB(v[0], v[1])
  5424      } else {
  5425          panic("instruction PSHUFB takes exactly 2 operands")
  5426      }
  5427  }
  5428  
  5429  func __asm_proxy_PSHUFD__(p *Program, v ...interface{}) *Instruction {
  5430      if len(v) == 3 {
  5431          return p.PSHUFD(v[0], v[1], v[2])
  5432      } else {
  5433          panic("instruction PSHUFD takes exactly 3 operands")
  5434      }
  5435  }
  5436  
  5437  func __asm_proxy_PSHUFHW__(p *Program, v ...interface{}) *Instruction {
  5438      if len(v) == 3 {
  5439          return p.PSHUFHW(v[0], v[1], v[2])
  5440      } else {
  5441          panic("instruction PSHUFHW takes exactly 3 operands")
  5442      }
  5443  }
  5444  
  5445  func __asm_proxy_PSHUFLW__(p *Program, v ...interface{}) *Instruction {
  5446      if len(v) == 3 {
  5447          return p.PSHUFLW(v[0], v[1], v[2])
  5448      } else {
  5449          panic("instruction PSHUFLW takes exactly 3 operands")
  5450      }
  5451  }
  5452  
  5453  func __asm_proxy_PSHUFW__(p *Program, v ...interface{}) *Instruction {
  5454      if len(v) == 3 {
  5455          return p.PSHUFW(v[0], v[1], v[2])
  5456      } else {
  5457          panic("instruction PSHUFW takes exactly 3 operands")
  5458      }
  5459  }
  5460  
  5461  func __asm_proxy_PSIGNB__(p *Program, v ...interface{}) *Instruction {
  5462      if len(v) == 2 {
  5463          return p.PSIGNB(v[0], v[1])
  5464      } else {
  5465          panic("instruction PSIGNB takes exactly 2 operands")
  5466      }
  5467  }
  5468  
  5469  func __asm_proxy_PSIGND__(p *Program, v ...interface{}) *Instruction {
  5470      if len(v) == 2 {
  5471          return p.PSIGND(v[0], v[1])
  5472      } else {
  5473          panic("instruction PSIGND takes exactly 2 operands")
  5474      }
  5475  }
  5476  
  5477  func __asm_proxy_PSIGNW__(p *Program, v ...interface{}) *Instruction {
  5478      if len(v) == 2 {
  5479          return p.PSIGNW(v[0], v[1])
  5480      } else {
  5481          panic("instruction PSIGNW takes exactly 2 operands")
  5482      }
  5483  }
  5484  
  5485  func __asm_proxy_PSLLD__(p *Program, v ...interface{}) *Instruction {
  5486      if len(v) == 2 {
  5487          return p.PSLLD(v[0], v[1])
  5488      } else {
  5489          panic("instruction PSLLD takes exactly 2 operands")
  5490      }
  5491  }
  5492  
  5493  func __asm_proxy_PSLLDQ__(p *Program, v ...interface{}) *Instruction {
  5494      if len(v) == 2 {
  5495          return p.PSLLDQ(v[0], v[1])
  5496      } else {
  5497          panic("instruction PSLLDQ takes exactly 2 operands")
  5498      }
  5499  }
  5500  
  5501  func __asm_proxy_PSLLQ__(p *Program, v ...interface{}) *Instruction {
  5502      if len(v) == 2 {
  5503          return p.PSLLQ(v[0], v[1])
  5504      } else {
  5505          panic("instruction PSLLQ takes exactly 2 operands")
  5506      }
  5507  }
  5508  
  5509  func __asm_proxy_PSLLW__(p *Program, v ...interface{}) *Instruction {
  5510      if len(v) == 2 {
  5511          return p.PSLLW(v[0], v[1])
  5512      } else {
  5513          panic("instruction PSLLW takes exactly 2 operands")
  5514      }
  5515  }
  5516  
  5517  func __asm_proxy_PSRAD__(p *Program, v ...interface{}) *Instruction {
  5518      if len(v) == 2 {
  5519          return p.PSRAD(v[0], v[1])
  5520      } else {
  5521          panic("instruction PSRAD takes exactly 2 operands")
  5522      }
  5523  }
  5524  
  5525  func __asm_proxy_PSRAW__(p *Program, v ...interface{}) *Instruction {
  5526      if len(v) == 2 {
  5527          return p.PSRAW(v[0], v[1])
  5528      } else {
  5529          panic("instruction PSRAW takes exactly 2 operands")
  5530      }
  5531  }
  5532  
  5533  func __asm_proxy_PSRLD__(p *Program, v ...interface{}) *Instruction {
  5534      if len(v) == 2 {
  5535          return p.PSRLD(v[0], v[1])
  5536      } else {
  5537          panic("instruction PSRLD takes exactly 2 operands")
  5538      }
  5539  }
  5540  
  5541  func __asm_proxy_PSRLDQ__(p *Program, v ...interface{}) *Instruction {
  5542      if len(v) == 2 {
  5543          return p.PSRLDQ(v[0], v[1])
  5544      } else {
  5545          panic("instruction PSRLDQ takes exactly 2 operands")
  5546      }
  5547  }
  5548  
  5549  func __asm_proxy_PSRLQ__(p *Program, v ...interface{}) *Instruction {
  5550      if len(v) == 2 {
  5551          return p.PSRLQ(v[0], v[1])
  5552      } else {
  5553          panic("instruction PSRLQ takes exactly 2 operands")
  5554      }
  5555  }
  5556  
  5557  func __asm_proxy_PSRLW__(p *Program, v ...interface{}) *Instruction {
  5558      if len(v) == 2 {
  5559          return p.PSRLW(v[0], v[1])
  5560      } else {
  5561          panic("instruction PSRLW takes exactly 2 operands")
  5562      }
  5563  }
  5564  
  5565  func __asm_proxy_PSUBB__(p *Program, v ...interface{}) *Instruction {
  5566      if len(v) == 2 {
  5567          return p.PSUBB(v[0], v[1])
  5568      } else {
  5569          panic("instruction PSUBB takes exactly 2 operands")
  5570      }
  5571  }
  5572  
  5573  func __asm_proxy_PSUBD__(p *Program, v ...interface{}) *Instruction {
  5574      if len(v) == 2 {
  5575          return p.PSUBD(v[0], v[1])
  5576      } else {
  5577          panic("instruction PSUBD takes exactly 2 operands")
  5578      }
  5579  }
  5580  
  5581  func __asm_proxy_PSUBQ__(p *Program, v ...interface{}) *Instruction {
  5582      if len(v) == 2 {
  5583          return p.PSUBQ(v[0], v[1])
  5584      } else {
  5585          panic("instruction PSUBQ takes exactly 2 operands")
  5586      }
  5587  }
  5588  
  5589  func __asm_proxy_PSUBSB__(p *Program, v ...interface{}) *Instruction {
  5590      if len(v) == 2 {
  5591          return p.PSUBSB(v[0], v[1])
  5592      } else {
  5593          panic("instruction PSUBSB takes exactly 2 operands")
  5594      }
  5595  }
  5596  
  5597  func __asm_proxy_PSUBSW__(p *Program, v ...interface{}) *Instruction {
  5598      if len(v) == 2 {
  5599          return p.PSUBSW(v[0], v[1])
  5600      } else {
  5601          panic("instruction PSUBSW takes exactly 2 operands")
  5602      }
  5603  }
  5604  
  5605  func __asm_proxy_PSUBUSB__(p *Program, v ...interface{}) *Instruction {
  5606      if len(v) == 2 {
  5607          return p.PSUBUSB(v[0], v[1])
  5608      } else {
  5609          panic("instruction PSUBUSB takes exactly 2 operands")
  5610      }
  5611  }
  5612  
  5613  func __asm_proxy_PSUBUSW__(p *Program, v ...interface{}) *Instruction {
  5614      if len(v) == 2 {
  5615          return p.PSUBUSW(v[0], v[1])
  5616      } else {
  5617          panic("instruction PSUBUSW takes exactly 2 operands")
  5618      }
  5619  }
  5620  
  5621  func __asm_proxy_PSUBW__(p *Program, v ...interface{}) *Instruction {
  5622      if len(v) == 2 {
  5623          return p.PSUBW(v[0], v[1])
  5624      } else {
  5625          panic("instruction PSUBW takes exactly 2 operands")
  5626      }
  5627  }
  5628  
  5629  func __asm_proxy_PSWAPD__(p *Program, v ...interface{}) *Instruction {
  5630      if len(v) == 2 {
  5631          return p.PSWAPD(v[0], v[1])
  5632      } else {
  5633          panic("instruction PSWAPD takes exactly 2 operands")
  5634      }
  5635  }
  5636  
  5637  func __asm_proxy_PTEST__(p *Program, v ...interface{}) *Instruction {
  5638      if len(v) == 2 {
  5639          return p.PTEST(v[0], v[1])
  5640      } else {
  5641          panic("instruction PTEST takes exactly 2 operands")
  5642      }
  5643  }
  5644  
  5645  func __asm_proxy_PUNPCKHBW__(p *Program, v ...interface{}) *Instruction {
  5646      if len(v) == 2 {
  5647          return p.PUNPCKHBW(v[0], v[1])
  5648      } else {
  5649          panic("instruction PUNPCKHBW takes exactly 2 operands")
  5650      }
  5651  }
  5652  
  5653  func __asm_proxy_PUNPCKHDQ__(p *Program, v ...interface{}) *Instruction {
  5654      if len(v) == 2 {
  5655          return p.PUNPCKHDQ(v[0], v[1])
  5656      } else {
  5657          panic("instruction PUNPCKHDQ takes exactly 2 operands")
  5658      }
  5659  }
  5660  
  5661  func __asm_proxy_PUNPCKHQDQ__(p *Program, v ...interface{}) *Instruction {
  5662      if len(v) == 2 {
  5663          return p.PUNPCKHQDQ(v[0], v[1])
  5664      } else {
  5665          panic("instruction PUNPCKHQDQ takes exactly 2 operands")
  5666      }
  5667  }
  5668  
  5669  func __asm_proxy_PUNPCKHWD__(p *Program, v ...interface{}) *Instruction {
  5670      if len(v) == 2 {
  5671          return p.PUNPCKHWD(v[0], v[1])
  5672      } else {
  5673          panic("instruction PUNPCKHWD takes exactly 2 operands")
  5674      }
  5675  }
  5676  
  5677  func __asm_proxy_PUNPCKLBW__(p *Program, v ...interface{}) *Instruction {
  5678      if len(v) == 2 {
  5679          return p.PUNPCKLBW(v[0], v[1])
  5680      } else {
  5681          panic("instruction PUNPCKLBW takes exactly 2 operands")
  5682      }
  5683  }
  5684  
  5685  func __asm_proxy_PUNPCKLDQ__(p *Program, v ...interface{}) *Instruction {
  5686      if len(v) == 2 {
  5687          return p.PUNPCKLDQ(v[0], v[1])
  5688      } else {
  5689          panic("instruction PUNPCKLDQ takes exactly 2 operands")
  5690      }
  5691  }
  5692  
  5693  func __asm_proxy_PUNPCKLQDQ__(p *Program, v ...interface{}) *Instruction {
  5694      if len(v) == 2 {
  5695          return p.PUNPCKLQDQ(v[0], v[1])
  5696      } else {
  5697          panic("instruction PUNPCKLQDQ takes exactly 2 operands")
  5698      }
  5699  }
  5700  
  5701  func __asm_proxy_PUNPCKLWD__(p *Program, v ...interface{}) *Instruction {
  5702      if len(v) == 2 {
  5703          return p.PUNPCKLWD(v[0], v[1])
  5704      } else {
  5705          panic("instruction PUNPCKLWD takes exactly 2 operands")
  5706      }
  5707  }
  5708  
  5709  func __asm_proxy_PUSHQ__(p *Program, v ...interface{}) *Instruction {
  5710      if len(v) == 1 {
  5711          return p.PUSHQ(v[0])
  5712      } else {
  5713          panic("instruction PUSHQ takes exactly 1 operand")
  5714      }
  5715  }
  5716  
  5717  func __asm_proxy_PUSHW__(p *Program, v ...interface{}) *Instruction {
  5718      if len(v) == 1 {
  5719          return p.PUSHW(v[0])
  5720      } else {
  5721          panic("instruction PUSHW takes exactly 1 operand")
  5722      }
  5723  }
  5724  
  5725  func __asm_proxy_PXOR__(p *Program, v ...interface{}) *Instruction {
  5726      if len(v) == 2 {
  5727          return p.PXOR(v[0], v[1])
  5728      } else {
  5729          panic("instruction PXOR takes exactly 2 operands")
  5730      }
  5731  }
  5732  
  5733  func __asm_proxy_RCLB__(p *Program, v ...interface{}) *Instruction {
  5734      if len(v) == 2 {
  5735          return p.RCLB(v[0], v[1])
  5736      } else {
  5737          panic("instruction RCLB takes exactly 2 operands")
  5738      }
  5739  }
  5740  
  5741  func __asm_proxy_RCLL__(p *Program, v ...interface{}) *Instruction {
  5742      if len(v) == 2 {
  5743          return p.RCLL(v[0], v[1])
  5744      } else {
  5745          panic("instruction RCLL takes exactly 2 operands")
  5746      }
  5747  }
  5748  
  5749  func __asm_proxy_RCLQ__(p *Program, v ...interface{}) *Instruction {
  5750      if len(v) == 2 {
  5751          return p.RCLQ(v[0], v[1])
  5752      } else {
  5753          panic("instruction RCLQ takes exactly 2 operands")
  5754      }
  5755  }
  5756  
  5757  func __asm_proxy_RCLW__(p *Program, v ...interface{}) *Instruction {
  5758      if len(v) == 2 {
  5759          return p.RCLW(v[0], v[1])
  5760      } else {
  5761          panic("instruction RCLW takes exactly 2 operands")
  5762      }
  5763  }
  5764  
  5765  func __asm_proxy_RCPPS__(p *Program, v ...interface{}) *Instruction {
  5766      if len(v) == 2 {
  5767          return p.RCPPS(v[0], v[1])
  5768      } else {
  5769          panic("instruction RCPPS takes exactly 2 operands")
  5770      }
  5771  }
  5772  
  5773  func __asm_proxy_RCPSS__(p *Program, v ...interface{}) *Instruction {
  5774      if len(v) == 2 {
  5775          return p.RCPSS(v[0], v[1])
  5776      } else {
  5777          panic("instruction RCPSS takes exactly 2 operands")
  5778      }
  5779  }
  5780  
  5781  func __asm_proxy_RCRB__(p *Program, v ...interface{}) *Instruction {
  5782      if len(v) == 2 {
  5783          return p.RCRB(v[0], v[1])
  5784      } else {
  5785          panic("instruction RCRB takes exactly 2 operands")
  5786      }
  5787  }
  5788  
  5789  func __asm_proxy_RCRL__(p *Program, v ...interface{}) *Instruction {
  5790      if len(v) == 2 {
  5791          return p.RCRL(v[0], v[1])
  5792      } else {
  5793          panic("instruction RCRL takes exactly 2 operands")
  5794      }
  5795  }
  5796  
  5797  func __asm_proxy_RCRQ__(p *Program, v ...interface{}) *Instruction {
  5798      if len(v) == 2 {
  5799          return p.RCRQ(v[0], v[1])
  5800      } else {
  5801          panic("instruction RCRQ takes exactly 2 operands")
  5802      }
  5803  }
  5804  
  5805  func __asm_proxy_RCRW__(p *Program, v ...interface{}) *Instruction {
  5806      if len(v) == 2 {
  5807          return p.RCRW(v[0], v[1])
  5808      } else {
  5809          panic("instruction RCRW takes exactly 2 operands")
  5810      }
  5811  }
  5812  
  5813  func __asm_proxy_RDRAND__(p *Program, v ...interface{}) *Instruction {
  5814      if len(v) == 1 {
  5815          return p.RDRAND(v[0])
  5816      } else {
  5817          panic("instruction RDRAND takes exactly 1 operand")
  5818      }
  5819  }
  5820  
  5821  func __asm_proxy_RDSEED__(p *Program, v ...interface{}) *Instruction {
  5822      if len(v) == 1 {
  5823          return p.RDSEED(v[0])
  5824      } else {
  5825          panic("instruction RDSEED takes exactly 1 operand")
  5826      }
  5827  }
  5828  
  5829  func __asm_proxy_RDTSC__(p *Program, v ...interface{}) *Instruction {
  5830      if len(v) == 0 {
  5831          return p.RDTSC()
  5832      } else {
  5833          panic("instruction RDTSC takes no operands")
  5834      }
  5835  }
  5836  
  5837  func __asm_proxy_RDTSCP__(p *Program, v ...interface{}) *Instruction {
  5838      if len(v) == 0 {
  5839          return p.RDTSCP()
  5840      } else {
  5841          panic("instruction RDTSCP takes no operands")
  5842      }
  5843  }
  5844  
  5845  func __asm_proxy_RET__(p *Program, v ...interface{}) *Instruction {
  5846      switch len(v) {
  5847          case 0  : return p.RET()
  5848          case 1  : return p.RET(v[0])
  5849          default : panic("instruction RET takes 0 or 1 operands")
  5850      }
  5851  }
  5852  
  5853  func __asm_proxy_ROLB__(p *Program, v ...interface{}) *Instruction {
  5854      if len(v) == 2 {
  5855          return p.ROLB(v[0], v[1])
  5856      } else {
  5857          panic("instruction ROLB takes exactly 2 operands")
  5858      }
  5859  }
  5860  
  5861  func __asm_proxy_ROLL__(p *Program, v ...interface{}) *Instruction {
  5862      if len(v) == 2 {
  5863          return p.ROLL(v[0], v[1])
  5864      } else {
  5865          panic("instruction ROLL takes exactly 2 operands")
  5866      }
  5867  }
  5868  
  5869  func __asm_proxy_ROLQ__(p *Program, v ...interface{}) *Instruction {
  5870      if len(v) == 2 {
  5871          return p.ROLQ(v[0], v[1])
  5872      } else {
  5873          panic("instruction ROLQ takes exactly 2 operands")
  5874      }
  5875  }
  5876  
  5877  func __asm_proxy_ROLW__(p *Program, v ...interface{}) *Instruction {
  5878      if len(v) == 2 {
  5879          return p.ROLW(v[0], v[1])
  5880      } else {
  5881          panic("instruction ROLW takes exactly 2 operands")
  5882      }
  5883  }
  5884  
  5885  func __asm_proxy_RORB__(p *Program, v ...interface{}) *Instruction {
  5886      if len(v) == 2 {
  5887          return p.RORB(v[0], v[1])
  5888      } else {
  5889          panic("instruction RORB takes exactly 2 operands")
  5890      }
  5891  }
  5892  
  5893  func __asm_proxy_RORL__(p *Program, v ...interface{}) *Instruction {
  5894      if len(v) == 2 {
  5895          return p.RORL(v[0], v[1])
  5896      } else {
  5897          panic("instruction RORL takes exactly 2 operands")
  5898      }
  5899  }
  5900  
  5901  func __asm_proxy_RORQ__(p *Program, v ...interface{}) *Instruction {
  5902      if len(v) == 2 {
  5903          return p.RORQ(v[0], v[1])
  5904      } else {
  5905          panic("instruction RORQ takes exactly 2 operands")
  5906      }
  5907  }
  5908  
  5909  func __asm_proxy_RORW__(p *Program, v ...interface{}) *Instruction {
  5910      if len(v) == 2 {
  5911          return p.RORW(v[0], v[1])
  5912      } else {
  5913          panic("instruction RORW takes exactly 2 operands")
  5914      }
  5915  }
  5916  
  5917  func __asm_proxy_RORXL__(p *Program, v ...interface{}) *Instruction {
  5918      if len(v) == 3 {
  5919          return p.RORXL(v[0], v[1], v[2])
  5920      } else {
  5921          panic("instruction RORXL takes exactly 3 operands")
  5922      }
  5923  }
  5924  
  5925  func __asm_proxy_RORXQ__(p *Program, v ...interface{}) *Instruction {
  5926      if len(v) == 3 {
  5927          return p.RORXQ(v[0], v[1], v[2])
  5928      } else {
  5929          panic("instruction RORXQ takes exactly 3 operands")
  5930      }
  5931  }
  5932  
  5933  func __asm_proxy_ROUNDPD__(p *Program, v ...interface{}) *Instruction {
  5934      if len(v) == 3 {
  5935          return p.ROUNDPD(v[0], v[1], v[2])
  5936      } else {
  5937          panic("instruction ROUNDPD takes exactly 3 operands")
  5938      }
  5939  }
  5940  
  5941  func __asm_proxy_ROUNDPS__(p *Program, v ...interface{}) *Instruction {
  5942      if len(v) == 3 {
  5943          return p.ROUNDPS(v[0], v[1], v[2])
  5944      } else {
  5945          panic("instruction ROUNDPS takes exactly 3 operands")
  5946      }
  5947  }
  5948  
  5949  func __asm_proxy_ROUNDSD__(p *Program, v ...interface{}) *Instruction {
  5950      if len(v) == 3 {
  5951          return p.ROUNDSD(v[0], v[1], v[2])
  5952      } else {
  5953          panic("instruction ROUNDSD takes exactly 3 operands")
  5954      }
  5955  }
  5956  
  5957  func __asm_proxy_ROUNDSS__(p *Program, v ...interface{}) *Instruction {
  5958      if len(v) == 3 {
  5959          return p.ROUNDSS(v[0], v[1], v[2])
  5960      } else {
  5961          panic("instruction ROUNDSS takes exactly 3 operands")
  5962      }
  5963  }
  5964  
  5965  func __asm_proxy_RSQRTPS__(p *Program, v ...interface{}) *Instruction {
  5966      if len(v) == 2 {
  5967          return p.RSQRTPS(v[0], v[1])
  5968      } else {
  5969          panic("instruction RSQRTPS takes exactly 2 operands")
  5970      }
  5971  }
  5972  
  5973  func __asm_proxy_RSQRTSS__(p *Program, v ...interface{}) *Instruction {
  5974      if len(v) == 2 {
  5975          return p.RSQRTSS(v[0], v[1])
  5976      } else {
  5977          panic("instruction RSQRTSS takes exactly 2 operands")
  5978      }
  5979  }
  5980  
  5981  func __asm_proxy_SALB__(p *Program, v ...interface{}) *Instruction {
  5982      if len(v) == 2 {
  5983          return p.SALB(v[0], v[1])
  5984      } else {
  5985          panic("instruction SALB takes exactly 2 operands")
  5986      }
  5987  }
  5988  
  5989  func __asm_proxy_SALL__(p *Program, v ...interface{}) *Instruction {
  5990      if len(v) == 2 {
  5991          return p.SALL(v[0], v[1])
  5992      } else {
  5993          panic("instruction SALL takes exactly 2 operands")
  5994      }
  5995  }
  5996  
  5997  func __asm_proxy_SALQ__(p *Program, v ...interface{}) *Instruction {
  5998      if len(v) == 2 {
  5999          return p.SALQ(v[0], v[1])
  6000      } else {
  6001          panic("instruction SALQ takes exactly 2 operands")
  6002      }
  6003  }
  6004  
  6005  func __asm_proxy_SALW__(p *Program, v ...interface{}) *Instruction {
  6006      if len(v) == 2 {
  6007          return p.SALW(v[0], v[1])
  6008      } else {
  6009          panic("instruction SALW takes exactly 2 operands")
  6010      }
  6011  }
  6012  
  6013  func __asm_proxy_SARB__(p *Program, v ...interface{}) *Instruction {
  6014      if len(v) == 2 {
  6015          return p.SARB(v[0], v[1])
  6016      } else {
  6017          panic("instruction SARB takes exactly 2 operands")
  6018      }
  6019  }
  6020  
  6021  func __asm_proxy_SARL__(p *Program, v ...interface{}) *Instruction {
  6022      if len(v) == 2 {
  6023          return p.SARL(v[0], v[1])
  6024      } else {
  6025          panic("instruction SARL takes exactly 2 operands")
  6026      }
  6027  }
  6028  
  6029  func __asm_proxy_SARQ__(p *Program, v ...interface{}) *Instruction {
  6030      if len(v) == 2 {
  6031          return p.SARQ(v[0], v[1])
  6032      } else {
  6033          panic("instruction SARQ takes exactly 2 operands")
  6034      }
  6035  }
  6036  
  6037  func __asm_proxy_SARW__(p *Program, v ...interface{}) *Instruction {
  6038      if len(v) == 2 {
  6039          return p.SARW(v[0], v[1])
  6040      } else {
  6041          panic("instruction SARW takes exactly 2 operands")
  6042      }
  6043  }
  6044  
  6045  func __asm_proxy_SARXL__(p *Program, v ...interface{}) *Instruction {
  6046      if len(v) == 3 {
  6047          return p.SARXL(v[0], v[1], v[2])
  6048      } else {
  6049          panic("instruction SARXL takes exactly 3 operands")
  6050      }
  6051  }
  6052  
  6053  func __asm_proxy_SARXQ__(p *Program, v ...interface{}) *Instruction {
  6054      if len(v) == 3 {
  6055          return p.SARXQ(v[0], v[1], v[2])
  6056      } else {
  6057          panic("instruction SARXQ takes exactly 3 operands")
  6058      }
  6059  }
  6060  
  6061  func __asm_proxy_SBBB__(p *Program, v ...interface{}) *Instruction {
  6062      if len(v) == 2 {
  6063          return p.SBBB(v[0], v[1])
  6064      } else {
  6065          panic("instruction SBBB takes exactly 2 operands")
  6066      }
  6067  }
  6068  
  6069  func __asm_proxy_SBBL__(p *Program, v ...interface{}) *Instruction {
  6070      if len(v) == 2 {
  6071          return p.SBBL(v[0], v[1])
  6072      } else {
  6073          panic("instruction SBBL takes exactly 2 operands")
  6074      }
  6075  }
  6076  
  6077  func __asm_proxy_SBBQ__(p *Program, v ...interface{}) *Instruction {
  6078      if len(v) == 2 {
  6079          return p.SBBQ(v[0], v[1])
  6080      } else {
  6081          panic("instruction SBBQ takes exactly 2 operands")
  6082      }
  6083  }
  6084  
  6085  func __asm_proxy_SBBW__(p *Program, v ...interface{}) *Instruction {
  6086      if len(v) == 2 {
  6087          return p.SBBW(v[0], v[1])
  6088      } else {
  6089          panic("instruction SBBW takes exactly 2 operands")
  6090      }
  6091  }
  6092  
  6093  func __asm_proxy_SETA__(p *Program, v ...interface{}) *Instruction {
  6094      if len(v) == 1 {
  6095          return p.SETA(v[0])
  6096      } else {
  6097          panic("instruction SETA takes exactly 1 operand")
  6098      }
  6099  }
  6100  
  6101  func __asm_proxy_SETAE__(p *Program, v ...interface{}) *Instruction {
  6102      if len(v) == 1 {
  6103          return p.SETAE(v[0])
  6104      } else {
  6105          panic("instruction SETAE takes exactly 1 operand")
  6106      }
  6107  }
  6108  
  6109  func __asm_proxy_SETB__(p *Program, v ...interface{}) *Instruction {
  6110      if len(v) == 1 {
  6111          return p.SETB(v[0])
  6112      } else {
  6113          panic("instruction SETB takes exactly 1 operand")
  6114      }
  6115  }
  6116  
  6117  func __asm_proxy_SETBE__(p *Program, v ...interface{}) *Instruction {
  6118      if len(v) == 1 {
  6119          return p.SETBE(v[0])
  6120      } else {
  6121          panic("instruction SETBE takes exactly 1 operand")
  6122      }
  6123  }
  6124  
  6125  func __asm_proxy_SETC__(p *Program, v ...interface{}) *Instruction {
  6126      if len(v) == 1 {
  6127          return p.SETC(v[0])
  6128      } else {
  6129          panic("instruction SETC takes exactly 1 operand")
  6130      }
  6131  }
  6132  
  6133  func __asm_proxy_SETE__(p *Program, v ...interface{}) *Instruction {
  6134      if len(v) == 1 {
  6135          return p.SETE(v[0])
  6136      } else {
  6137          panic("instruction SETE takes exactly 1 operand")
  6138      }
  6139  }
  6140  
  6141  func __asm_proxy_SETG__(p *Program, v ...interface{}) *Instruction {
  6142      if len(v) == 1 {
  6143          return p.SETG(v[0])
  6144      } else {
  6145          panic("instruction SETG takes exactly 1 operand")
  6146      }
  6147  }
  6148  
  6149  func __asm_proxy_SETGE__(p *Program, v ...interface{}) *Instruction {
  6150      if len(v) == 1 {
  6151          return p.SETGE(v[0])
  6152      } else {
  6153          panic("instruction SETGE takes exactly 1 operand")
  6154      }
  6155  }
  6156  
  6157  func __asm_proxy_SETL__(p *Program, v ...interface{}) *Instruction {
  6158      if len(v) == 1 {
  6159          return p.SETL(v[0])
  6160      } else {
  6161          panic("instruction SETL takes exactly 1 operand")
  6162      }
  6163  }
  6164  
  6165  func __asm_proxy_SETLE__(p *Program, v ...interface{}) *Instruction {
  6166      if len(v) == 1 {
  6167          return p.SETLE(v[0])
  6168      } else {
  6169          panic("instruction SETLE takes exactly 1 operand")
  6170      }
  6171  }
  6172  
  6173  func __asm_proxy_SETNA__(p *Program, v ...interface{}) *Instruction {
  6174      if len(v) == 1 {
  6175          return p.SETNA(v[0])
  6176      } else {
  6177          panic("instruction SETNA takes exactly 1 operand")
  6178      }
  6179  }
  6180  
  6181  func __asm_proxy_SETNAE__(p *Program, v ...interface{}) *Instruction {
  6182      if len(v) == 1 {
  6183          return p.SETNAE(v[0])
  6184      } else {
  6185          panic("instruction SETNAE takes exactly 1 operand")
  6186      }
  6187  }
  6188  
  6189  func __asm_proxy_SETNB__(p *Program, v ...interface{}) *Instruction {
  6190      if len(v) == 1 {
  6191          return p.SETNB(v[0])
  6192      } else {
  6193          panic("instruction SETNB takes exactly 1 operand")
  6194      }
  6195  }
  6196  
  6197  func __asm_proxy_SETNBE__(p *Program, v ...interface{}) *Instruction {
  6198      if len(v) == 1 {
  6199          return p.SETNBE(v[0])
  6200      } else {
  6201          panic("instruction SETNBE takes exactly 1 operand")
  6202      }
  6203  }
  6204  
  6205  func __asm_proxy_SETNC__(p *Program, v ...interface{}) *Instruction {
  6206      if len(v) == 1 {
  6207          return p.SETNC(v[0])
  6208      } else {
  6209          panic("instruction SETNC takes exactly 1 operand")
  6210      }
  6211  }
  6212  
  6213  func __asm_proxy_SETNE__(p *Program, v ...interface{}) *Instruction {
  6214      if len(v) == 1 {
  6215          return p.SETNE(v[0])
  6216      } else {
  6217          panic("instruction SETNE takes exactly 1 operand")
  6218      }
  6219  }
  6220  
  6221  func __asm_proxy_SETNG__(p *Program, v ...interface{}) *Instruction {
  6222      if len(v) == 1 {
  6223          return p.SETNG(v[0])
  6224      } else {
  6225          panic("instruction SETNG takes exactly 1 operand")
  6226      }
  6227  }
  6228  
  6229  func __asm_proxy_SETNGE__(p *Program, v ...interface{}) *Instruction {
  6230      if len(v) == 1 {
  6231          return p.SETNGE(v[0])
  6232      } else {
  6233          panic("instruction SETNGE takes exactly 1 operand")
  6234      }
  6235  }
  6236  
  6237  func __asm_proxy_SETNL__(p *Program, v ...interface{}) *Instruction {
  6238      if len(v) == 1 {
  6239          return p.SETNL(v[0])
  6240      } else {
  6241          panic("instruction SETNL takes exactly 1 operand")
  6242      }
  6243  }
  6244  
  6245  func __asm_proxy_SETNLE__(p *Program, v ...interface{}) *Instruction {
  6246      if len(v) == 1 {
  6247          return p.SETNLE(v[0])
  6248      } else {
  6249          panic("instruction SETNLE takes exactly 1 operand")
  6250      }
  6251  }
  6252  
  6253  func __asm_proxy_SETNO__(p *Program, v ...interface{}) *Instruction {
  6254      if len(v) == 1 {
  6255          return p.SETNO(v[0])
  6256      } else {
  6257          panic("instruction SETNO takes exactly 1 operand")
  6258      }
  6259  }
  6260  
  6261  func __asm_proxy_SETNP__(p *Program, v ...interface{}) *Instruction {
  6262      if len(v) == 1 {
  6263          return p.SETNP(v[0])
  6264      } else {
  6265          panic("instruction SETNP takes exactly 1 operand")
  6266      }
  6267  }
  6268  
  6269  func __asm_proxy_SETNS__(p *Program, v ...interface{}) *Instruction {
  6270      if len(v) == 1 {
  6271          return p.SETNS(v[0])
  6272      } else {
  6273          panic("instruction SETNS takes exactly 1 operand")
  6274      }
  6275  }
  6276  
  6277  func __asm_proxy_SETNZ__(p *Program, v ...interface{}) *Instruction {
  6278      if len(v) == 1 {
  6279          return p.SETNZ(v[0])
  6280      } else {
  6281          panic("instruction SETNZ takes exactly 1 operand")
  6282      }
  6283  }
  6284  
  6285  func __asm_proxy_SETO__(p *Program, v ...interface{}) *Instruction {
  6286      if len(v) == 1 {
  6287          return p.SETO(v[0])
  6288      } else {
  6289          panic("instruction SETO takes exactly 1 operand")
  6290      }
  6291  }
  6292  
  6293  func __asm_proxy_SETP__(p *Program, v ...interface{}) *Instruction {
  6294      if len(v) == 1 {
  6295          return p.SETP(v[0])
  6296      } else {
  6297          panic("instruction SETP takes exactly 1 operand")
  6298      }
  6299  }
  6300  
  6301  func __asm_proxy_SETPE__(p *Program, v ...interface{}) *Instruction {
  6302      if len(v) == 1 {
  6303          return p.SETPE(v[0])
  6304      } else {
  6305          panic("instruction SETPE takes exactly 1 operand")
  6306      }
  6307  }
  6308  
  6309  func __asm_proxy_SETPO__(p *Program, v ...interface{}) *Instruction {
  6310      if len(v) == 1 {
  6311          return p.SETPO(v[0])
  6312      } else {
  6313          panic("instruction SETPO takes exactly 1 operand")
  6314      }
  6315  }
  6316  
  6317  func __asm_proxy_SETS__(p *Program, v ...interface{}) *Instruction {
  6318      if len(v) == 1 {
  6319          return p.SETS(v[0])
  6320      } else {
  6321          panic("instruction SETS takes exactly 1 operand")
  6322      }
  6323  }
  6324  
  6325  func __asm_proxy_SETZ__(p *Program, v ...interface{}) *Instruction {
  6326      if len(v) == 1 {
  6327          return p.SETZ(v[0])
  6328      } else {
  6329          panic("instruction SETZ takes exactly 1 operand")
  6330      }
  6331  }
  6332  
  6333  func __asm_proxy_SFENCE__(p *Program, v ...interface{}) *Instruction {
  6334      if len(v) == 0 {
  6335          return p.SFENCE()
  6336      } else {
  6337          panic("instruction SFENCE takes no operands")
  6338      }
  6339  }
  6340  
  6341  func __asm_proxy_SHA1MSG1__(p *Program, v ...interface{}) *Instruction {
  6342      if len(v) == 2 {
  6343          return p.SHA1MSG1(v[0], v[1])
  6344      } else {
  6345          panic("instruction SHA1MSG1 takes exactly 2 operands")
  6346      }
  6347  }
  6348  
  6349  func __asm_proxy_SHA1MSG2__(p *Program, v ...interface{}) *Instruction {
  6350      if len(v) == 2 {
  6351          return p.SHA1MSG2(v[0], v[1])
  6352      } else {
  6353          panic("instruction SHA1MSG2 takes exactly 2 operands")
  6354      }
  6355  }
  6356  
  6357  func __asm_proxy_SHA1NEXTE__(p *Program, v ...interface{}) *Instruction {
  6358      if len(v) == 2 {
  6359          return p.SHA1NEXTE(v[0], v[1])
  6360      } else {
  6361          panic("instruction SHA1NEXTE takes exactly 2 operands")
  6362      }
  6363  }
  6364  
  6365  func __asm_proxy_SHA1RNDS4__(p *Program, v ...interface{}) *Instruction {
  6366      if len(v) == 3 {
  6367          return p.SHA1RNDS4(v[0], v[1], v[2])
  6368      } else {
  6369          panic("instruction SHA1RNDS4 takes exactly 3 operands")
  6370      }
  6371  }
  6372  
  6373  func __asm_proxy_SHA256MSG1__(p *Program, v ...interface{}) *Instruction {
  6374      if len(v) == 2 {
  6375          return p.SHA256MSG1(v[0], v[1])
  6376      } else {
  6377          panic("instruction SHA256MSG1 takes exactly 2 operands")
  6378      }
  6379  }
  6380  
  6381  func __asm_proxy_SHA256MSG2__(p *Program, v ...interface{}) *Instruction {
  6382      if len(v) == 2 {
  6383          return p.SHA256MSG2(v[0], v[1])
  6384      } else {
  6385          panic("instruction SHA256MSG2 takes exactly 2 operands")
  6386      }
  6387  }
  6388  
  6389  func __asm_proxy_SHA256RNDS2__(p *Program, v ...interface{}) *Instruction {
  6390      if len(v) == 3 {
  6391          return p.SHA256RNDS2(v[0], v[1], v[2])
  6392      } else {
  6393          panic("instruction SHA256RNDS2 takes exactly 3 operands")
  6394      }
  6395  }
  6396  
  6397  func __asm_proxy_SHLB__(p *Program, v ...interface{}) *Instruction {
  6398      if len(v) == 2 {
  6399          return p.SHLB(v[0], v[1])
  6400      } else {
  6401          panic("instruction SHLB takes exactly 2 operands")
  6402      }
  6403  }
  6404  
  6405  func __asm_proxy_SHLDL__(p *Program, v ...interface{}) *Instruction {
  6406      if len(v) == 3 {
  6407          return p.SHLDL(v[0], v[1], v[2])
  6408      } else {
  6409          panic("instruction SHLDL takes exactly 3 operands")
  6410      }
  6411  }
  6412  
  6413  func __asm_proxy_SHLDQ__(p *Program, v ...interface{}) *Instruction {
  6414      if len(v) == 3 {
  6415          return p.SHLDQ(v[0], v[1], v[2])
  6416      } else {
  6417          panic("instruction SHLDQ takes exactly 3 operands")
  6418      }
  6419  }
  6420  
  6421  func __asm_proxy_SHLDW__(p *Program, v ...interface{}) *Instruction {
  6422      if len(v) == 3 {
  6423          return p.SHLDW(v[0], v[1], v[2])
  6424      } else {
  6425          panic("instruction SHLDW takes exactly 3 operands")
  6426      }
  6427  }
  6428  
  6429  func __asm_proxy_SHLL__(p *Program, v ...interface{}) *Instruction {
  6430      if len(v) == 2 {
  6431          return p.SHLL(v[0], v[1])
  6432      } else {
  6433          panic("instruction SHLL takes exactly 2 operands")
  6434      }
  6435  }
  6436  
  6437  func __asm_proxy_SHLQ__(p *Program, v ...interface{}) *Instruction {
  6438      if len(v) == 2 {
  6439          return p.SHLQ(v[0], v[1])
  6440      } else {
  6441          panic("instruction SHLQ takes exactly 2 operands")
  6442      }
  6443  }
  6444  
  6445  func __asm_proxy_SHLW__(p *Program, v ...interface{}) *Instruction {
  6446      if len(v) == 2 {
  6447          return p.SHLW(v[0], v[1])
  6448      } else {
  6449          panic("instruction SHLW takes exactly 2 operands")
  6450      }
  6451  }
  6452  
  6453  func __asm_proxy_SHLXL__(p *Program, v ...interface{}) *Instruction {
  6454      if len(v) == 3 {
  6455          return p.SHLXL(v[0], v[1], v[2])
  6456      } else {
  6457          panic("instruction SHLXL takes exactly 3 operands")
  6458      }
  6459  }
  6460  
  6461  func __asm_proxy_SHLXQ__(p *Program, v ...interface{}) *Instruction {
  6462      if len(v) == 3 {
  6463          return p.SHLXQ(v[0], v[1], v[2])
  6464      } else {
  6465          panic("instruction SHLXQ takes exactly 3 operands")
  6466      }
  6467  }
  6468  
  6469  func __asm_proxy_SHRB__(p *Program, v ...interface{}) *Instruction {
  6470      if len(v) == 2 {
  6471          return p.SHRB(v[0], v[1])
  6472      } else {
  6473          panic("instruction SHRB takes exactly 2 operands")
  6474      }
  6475  }
  6476  
  6477  func __asm_proxy_SHRDL__(p *Program, v ...interface{}) *Instruction {
  6478      if len(v) == 3 {
  6479          return p.SHRDL(v[0], v[1], v[2])
  6480      } else {
  6481          panic("instruction SHRDL takes exactly 3 operands")
  6482      }
  6483  }
  6484  
  6485  func __asm_proxy_SHRDQ__(p *Program, v ...interface{}) *Instruction {
  6486      if len(v) == 3 {
  6487          return p.SHRDQ(v[0], v[1], v[2])
  6488      } else {
  6489          panic("instruction SHRDQ takes exactly 3 operands")
  6490      }
  6491  }
  6492  
  6493  func __asm_proxy_SHRDW__(p *Program, v ...interface{}) *Instruction {
  6494      if len(v) == 3 {
  6495          return p.SHRDW(v[0], v[1], v[2])
  6496      } else {
  6497          panic("instruction SHRDW takes exactly 3 operands")
  6498      }
  6499  }
  6500  
  6501  func __asm_proxy_SHRL__(p *Program, v ...interface{}) *Instruction {
  6502      if len(v) == 2 {
  6503          return p.SHRL(v[0], v[1])
  6504      } else {
  6505          panic("instruction SHRL takes exactly 2 operands")
  6506      }
  6507  }
  6508  
  6509  func __asm_proxy_SHRQ__(p *Program, v ...interface{}) *Instruction {
  6510      if len(v) == 2 {
  6511          return p.SHRQ(v[0], v[1])
  6512      } else {
  6513          panic("instruction SHRQ takes exactly 2 operands")
  6514      }
  6515  }
  6516  
  6517  func __asm_proxy_SHRW__(p *Program, v ...interface{}) *Instruction {
  6518      if len(v) == 2 {
  6519          return p.SHRW(v[0], v[1])
  6520      } else {
  6521          panic("instruction SHRW takes exactly 2 operands")
  6522      }
  6523  }
  6524  
  6525  func __asm_proxy_SHRXL__(p *Program, v ...interface{}) *Instruction {
  6526      if len(v) == 3 {
  6527          return p.SHRXL(v[0], v[1], v[2])
  6528      } else {
  6529          panic("instruction SHRXL takes exactly 3 operands")
  6530      }
  6531  }
  6532  
  6533  func __asm_proxy_SHRXQ__(p *Program, v ...interface{}) *Instruction {
  6534      if len(v) == 3 {
  6535          return p.SHRXQ(v[0], v[1], v[2])
  6536      } else {
  6537          panic("instruction SHRXQ takes exactly 3 operands")
  6538      }
  6539  }
  6540  
  6541  func __asm_proxy_SHUFPD__(p *Program, v ...interface{}) *Instruction {
  6542      if len(v) == 3 {
  6543          return p.SHUFPD(v[0], v[1], v[2])
  6544      } else {
  6545          panic("instruction SHUFPD takes exactly 3 operands")
  6546      }
  6547  }
  6548  
  6549  func __asm_proxy_SHUFPS__(p *Program, v ...interface{}) *Instruction {
  6550      if len(v) == 3 {
  6551          return p.SHUFPS(v[0], v[1], v[2])
  6552      } else {
  6553          panic("instruction SHUFPS takes exactly 3 operands")
  6554      }
  6555  }
  6556  
  6557  func __asm_proxy_SQRTPD__(p *Program, v ...interface{}) *Instruction {
  6558      if len(v) == 2 {
  6559          return p.SQRTPD(v[0], v[1])
  6560      } else {
  6561          panic("instruction SQRTPD takes exactly 2 operands")
  6562      }
  6563  }
  6564  
  6565  func __asm_proxy_SQRTPS__(p *Program, v ...interface{}) *Instruction {
  6566      if len(v) == 2 {
  6567          return p.SQRTPS(v[0], v[1])
  6568      } else {
  6569          panic("instruction SQRTPS takes exactly 2 operands")
  6570      }
  6571  }
  6572  
  6573  func __asm_proxy_SQRTSD__(p *Program, v ...interface{}) *Instruction {
  6574      if len(v) == 2 {
  6575          return p.SQRTSD(v[0], v[1])
  6576      } else {
  6577          panic("instruction SQRTSD takes exactly 2 operands")
  6578      }
  6579  }
  6580  
  6581  func __asm_proxy_SQRTSS__(p *Program, v ...interface{}) *Instruction {
  6582      if len(v) == 2 {
  6583          return p.SQRTSS(v[0], v[1])
  6584      } else {
  6585          panic("instruction SQRTSS takes exactly 2 operands")
  6586      }
  6587  }
  6588  
  6589  func __asm_proxy_STC__(p *Program, v ...interface{}) *Instruction {
  6590      if len(v) == 0 {
  6591          return p.STC()
  6592      } else {
  6593          panic("instruction STC takes no operands")
  6594      }
  6595  }
  6596  
  6597  func __asm_proxy_STD__(p *Program, v ...interface{}) *Instruction {
  6598      if len(v) == 0 {
  6599          return p.STD()
  6600      } else {
  6601          panic("instruction STD takes no operands")
  6602      }
  6603  }
  6604  
  6605  func __asm_proxy_STMXCSR__(p *Program, v ...interface{}) *Instruction {
  6606      if len(v) == 1 {
  6607          return p.STMXCSR(v[0])
  6608      } else {
  6609          panic("instruction STMXCSR takes exactly 1 operand")
  6610      }
  6611  }
  6612  
  6613  func __asm_proxy_SUBB__(p *Program, v ...interface{}) *Instruction {
  6614      if len(v) == 2 {
  6615          return p.SUBB(v[0], v[1])
  6616      } else {
  6617          panic("instruction SUBB takes exactly 2 operands")
  6618      }
  6619  }
  6620  
  6621  func __asm_proxy_SUBL__(p *Program, v ...interface{}) *Instruction {
  6622      if len(v) == 2 {
  6623          return p.SUBL(v[0], v[1])
  6624      } else {
  6625          panic("instruction SUBL takes exactly 2 operands")
  6626      }
  6627  }
  6628  
  6629  func __asm_proxy_SUBPD__(p *Program, v ...interface{}) *Instruction {
  6630      if len(v) == 2 {
  6631          return p.SUBPD(v[0], v[1])
  6632      } else {
  6633          panic("instruction SUBPD takes exactly 2 operands")
  6634      }
  6635  }
  6636  
  6637  func __asm_proxy_SUBPS__(p *Program, v ...interface{}) *Instruction {
  6638      if len(v) == 2 {
  6639          return p.SUBPS(v[0], v[1])
  6640      } else {
  6641          panic("instruction SUBPS takes exactly 2 operands")
  6642      }
  6643  }
  6644  
  6645  func __asm_proxy_SUBQ__(p *Program, v ...interface{}) *Instruction {
  6646      if len(v) == 2 {
  6647          return p.SUBQ(v[0], v[1])
  6648      } else {
  6649          panic("instruction SUBQ takes exactly 2 operands")
  6650      }
  6651  }
  6652  
  6653  func __asm_proxy_SUBSD__(p *Program, v ...interface{}) *Instruction {
  6654      if len(v) == 2 {
  6655          return p.SUBSD(v[0], v[1])
  6656      } else {
  6657          panic("instruction SUBSD takes exactly 2 operands")
  6658      }
  6659  }
  6660  
  6661  func __asm_proxy_SUBSS__(p *Program, v ...interface{}) *Instruction {
  6662      if len(v) == 2 {
  6663          return p.SUBSS(v[0], v[1])
  6664      } else {
  6665          panic("instruction SUBSS takes exactly 2 operands")
  6666      }
  6667  }
  6668  
  6669  func __asm_proxy_SUBW__(p *Program, v ...interface{}) *Instruction {
  6670      if len(v) == 2 {
  6671          return p.SUBW(v[0], v[1])
  6672      } else {
  6673          panic("instruction SUBW takes exactly 2 operands")
  6674      }
  6675  }
  6676  
  6677  func __asm_proxy_SYSCALL__(p *Program, v ...interface{}) *Instruction {
  6678      if len(v) == 0 {
  6679          return p.SYSCALL()
  6680      } else {
  6681          panic("instruction SYSCALL takes no operands")
  6682      }
  6683  }
  6684  
  6685  func __asm_proxy_T1MSKC__(p *Program, v ...interface{}) *Instruction {
  6686      if len(v) == 2 {
  6687          return p.T1MSKC(v[0], v[1])
  6688      } else {
  6689          panic("instruction T1MSKC takes exactly 2 operands")
  6690      }
  6691  }
  6692  
  6693  func __asm_proxy_TESTB__(p *Program, v ...interface{}) *Instruction {
  6694      if len(v) == 2 {
  6695          return p.TESTB(v[0], v[1])
  6696      } else {
  6697          panic("instruction TESTB takes exactly 2 operands")
  6698      }
  6699  }
  6700  
  6701  func __asm_proxy_TESTL__(p *Program, v ...interface{}) *Instruction {
  6702      if len(v) == 2 {
  6703          return p.TESTL(v[0], v[1])
  6704      } else {
  6705          panic("instruction TESTL takes exactly 2 operands")
  6706      }
  6707  }
  6708  
  6709  func __asm_proxy_TESTQ__(p *Program, v ...interface{}) *Instruction {
  6710      if len(v) == 2 {
  6711          return p.TESTQ(v[0], v[1])
  6712      } else {
  6713          panic("instruction TESTQ takes exactly 2 operands")
  6714      }
  6715  }
  6716  
  6717  func __asm_proxy_TESTW__(p *Program, v ...interface{}) *Instruction {
  6718      if len(v) == 2 {
  6719          return p.TESTW(v[0], v[1])
  6720      } else {
  6721          panic("instruction TESTW takes exactly 2 operands")
  6722      }
  6723  }
  6724  
  6725  func __asm_proxy_TZCNTL__(p *Program, v ...interface{}) *Instruction {
  6726      if len(v) == 2 {
  6727          return p.TZCNTL(v[0], v[1])
  6728      } else {
  6729          panic("instruction TZCNTL takes exactly 2 operands")
  6730      }
  6731  }
  6732  
  6733  func __asm_proxy_TZCNTQ__(p *Program, v ...interface{}) *Instruction {
  6734      if len(v) == 2 {
  6735          return p.TZCNTQ(v[0], v[1])
  6736      } else {
  6737          panic("instruction TZCNTQ takes exactly 2 operands")
  6738      }
  6739  }
  6740  
  6741  func __asm_proxy_TZCNTW__(p *Program, v ...interface{}) *Instruction {
  6742      if len(v) == 2 {
  6743          return p.TZCNTW(v[0], v[1])
  6744      } else {
  6745          panic("instruction TZCNTW takes exactly 2 operands")
  6746      }
  6747  }
  6748  
  6749  func __asm_proxy_TZMSK__(p *Program, v ...interface{}) *Instruction {
  6750      if len(v) == 2 {
  6751          return p.TZMSK(v[0], v[1])
  6752      } else {
  6753          panic("instruction TZMSK takes exactly 2 operands")
  6754      }
  6755  }
  6756  
  6757  func __asm_proxy_UCOMISD__(p *Program, v ...interface{}) *Instruction {
  6758      if len(v) == 2 {
  6759          return p.UCOMISD(v[0], v[1])
  6760      } else {
  6761          panic("instruction UCOMISD takes exactly 2 operands")
  6762      }
  6763  }
  6764  
  6765  func __asm_proxy_UCOMISS__(p *Program, v ...interface{}) *Instruction {
  6766      if len(v) == 2 {
  6767          return p.UCOMISS(v[0], v[1])
  6768      } else {
  6769          panic("instruction UCOMISS takes exactly 2 operands")
  6770      }
  6771  }
  6772  
  6773  func __asm_proxy_UD2__(p *Program, v ...interface{}) *Instruction {
  6774      if len(v) == 0 {
  6775          return p.UD2()
  6776      } else {
  6777          panic("instruction UD2 takes no operands")
  6778      }
  6779  }
  6780  
  6781  func __asm_proxy_UNPCKHPD__(p *Program, v ...interface{}) *Instruction {
  6782      if len(v) == 2 {
  6783          return p.UNPCKHPD(v[0], v[1])
  6784      } else {
  6785          panic("instruction UNPCKHPD takes exactly 2 operands")
  6786      }
  6787  }
  6788  
  6789  func __asm_proxy_UNPCKHPS__(p *Program, v ...interface{}) *Instruction {
  6790      if len(v) == 2 {
  6791          return p.UNPCKHPS(v[0], v[1])
  6792      } else {
  6793          panic("instruction UNPCKHPS takes exactly 2 operands")
  6794      }
  6795  }
  6796  
  6797  func __asm_proxy_UNPCKLPD__(p *Program, v ...interface{}) *Instruction {
  6798      if len(v) == 2 {
  6799          return p.UNPCKLPD(v[0], v[1])
  6800      } else {
  6801          panic("instruction UNPCKLPD takes exactly 2 operands")
  6802      }
  6803  }
  6804  
  6805  func __asm_proxy_UNPCKLPS__(p *Program, v ...interface{}) *Instruction {
  6806      if len(v) == 2 {
  6807          return p.UNPCKLPS(v[0], v[1])
  6808      } else {
  6809          panic("instruction UNPCKLPS takes exactly 2 operands")
  6810      }
  6811  }
  6812  
  6813  func __asm_proxy_VADDPD__(p *Program, v ...interface{}) *Instruction {
  6814      switch len(v) {
  6815          case 3  : return p.VADDPD(v[0], v[1], v[2])
  6816          case 4  : return p.VADDPD(v[0], v[1], v[2], v[3])
  6817          default : panic("instruction VADDPD takes 3 or 4 operands")
  6818      }
  6819  }
  6820  
  6821  func __asm_proxy_VADDPS__(p *Program, v ...interface{}) *Instruction {
  6822      switch len(v) {
  6823          case 3  : return p.VADDPS(v[0], v[1], v[2])
  6824          case 4  : return p.VADDPS(v[0], v[1], v[2], v[3])
  6825          default : panic("instruction VADDPS takes 3 or 4 operands")
  6826      }
  6827  }
  6828  
  6829  func __asm_proxy_VADDSD__(p *Program, v ...interface{}) *Instruction {
  6830      switch len(v) {
  6831          case 3  : return p.VADDSD(v[0], v[1], v[2])
  6832          case 4  : return p.VADDSD(v[0], v[1], v[2], v[3])
  6833          default : panic("instruction VADDSD takes 3 or 4 operands")
  6834      }
  6835  }
  6836  
  6837  func __asm_proxy_VADDSS__(p *Program, v ...interface{}) *Instruction {
  6838      switch len(v) {
  6839          case 3  : return p.VADDSS(v[0], v[1], v[2])
  6840          case 4  : return p.VADDSS(v[0], v[1], v[2], v[3])
  6841          default : panic("instruction VADDSS takes 3 or 4 operands")
  6842      }
  6843  }
  6844  
  6845  func __asm_proxy_VADDSUBPD__(p *Program, v ...interface{}) *Instruction {
  6846      if len(v) == 3 {
  6847          return p.VADDSUBPD(v[0], v[1], v[2])
  6848      } else {
  6849          panic("instruction VADDSUBPD takes exactly 3 operands")
  6850      }
  6851  }
  6852  
  6853  func __asm_proxy_VADDSUBPS__(p *Program, v ...interface{}) *Instruction {
  6854      if len(v) == 3 {
  6855          return p.VADDSUBPS(v[0], v[1], v[2])
  6856      } else {
  6857          panic("instruction VADDSUBPS takes exactly 3 operands")
  6858      }
  6859  }
  6860  
  6861  func __asm_proxy_VAESDEC__(p *Program, v ...interface{}) *Instruction {
  6862      if len(v) == 3 {
  6863          return p.VAESDEC(v[0], v[1], v[2])
  6864      } else {
  6865          panic("instruction VAESDEC takes exactly 3 operands")
  6866      }
  6867  }
  6868  
  6869  func __asm_proxy_VAESDECLAST__(p *Program, v ...interface{}) *Instruction {
  6870      if len(v) == 3 {
  6871          return p.VAESDECLAST(v[0], v[1], v[2])
  6872      } else {
  6873          panic("instruction VAESDECLAST takes exactly 3 operands")
  6874      }
  6875  }
  6876  
  6877  func __asm_proxy_VAESENC__(p *Program, v ...interface{}) *Instruction {
  6878      if len(v) == 3 {
  6879          return p.VAESENC(v[0], v[1], v[2])
  6880      } else {
  6881          panic("instruction VAESENC takes exactly 3 operands")
  6882      }
  6883  }
  6884  
  6885  func __asm_proxy_VAESENCLAST__(p *Program, v ...interface{}) *Instruction {
  6886      if len(v) == 3 {
  6887          return p.VAESENCLAST(v[0], v[1], v[2])
  6888      } else {
  6889          panic("instruction VAESENCLAST takes exactly 3 operands")
  6890      }
  6891  }
  6892  
  6893  func __asm_proxy_VAESIMC__(p *Program, v ...interface{}) *Instruction {
  6894      if len(v) == 2 {
  6895          return p.VAESIMC(v[0], v[1])
  6896      } else {
  6897          panic("instruction VAESIMC takes exactly 2 operands")
  6898      }
  6899  }
  6900  
  6901  func __asm_proxy_VAESKEYGENASSIST__(p *Program, v ...interface{}) *Instruction {
  6902      if len(v) == 3 {
  6903          return p.VAESKEYGENASSIST(v[0], v[1], v[2])
  6904      } else {
  6905          panic("instruction VAESKEYGENASSIST takes exactly 3 operands")
  6906      }
  6907  }
  6908  
  6909  func __asm_proxy_VALIGND__(p *Program, v ...interface{}) *Instruction {
  6910      if len(v) == 4 {
  6911          return p.VALIGND(v[0], v[1], v[2], v[3])
  6912      } else {
  6913          panic("instruction VALIGND takes exactly 4 operands")
  6914      }
  6915  }
  6916  
  6917  func __asm_proxy_VALIGNQ__(p *Program, v ...interface{}) *Instruction {
  6918      if len(v) == 4 {
  6919          return p.VALIGNQ(v[0], v[1], v[2], v[3])
  6920      } else {
  6921          panic("instruction VALIGNQ takes exactly 4 operands")
  6922      }
  6923  }
  6924  
  6925  func __asm_proxy_VANDNPD__(p *Program, v ...interface{}) *Instruction {
  6926      if len(v) == 3 {
  6927          return p.VANDNPD(v[0], v[1], v[2])
  6928      } else {
  6929          panic("instruction VANDNPD takes exactly 3 operands")
  6930      }
  6931  }
  6932  
  6933  func __asm_proxy_VANDNPS__(p *Program, v ...interface{}) *Instruction {
  6934      if len(v) == 3 {
  6935          return p.VANDNPS(v[0], v[1], v[2])
  6936      } else {
  6937          panic("instruction VANDNPS takes exactly 3 operands")
  6938      }
  6939  }
  6940  
  6941  func __asm_proxy_VANDPD__(p *Program, v ...interface{}) *Instruction {
  6942      if len(v) == 3 {
  6943          return p.VANDPD(v[0], v[1], v[2])
  6944      } else {
  6945          panic("instruction VANDPD takes exactly 3 operands")
  6946      }
  6947  }
  6948  
  6949  func __asm_proxy_VANDPS__(p *Program, v ...interface{}) *Instruction {
  6950      if len(v) == 3 {
  6951          return p.VANDPS(v[0], v[1], v[2])
  6952      } else {
  6953          panic("instruction VANDPS takes exactly 3 operands")
  6954      }
  6955  }
  6956  
  6957  func __asm_proxy_VBLENDMPD__(p *Program, v ...interface{}) *Instruction {
  6958      if len(v) == 3 {
  6959          return p.VBLENDMPD(v[0], v[1], v[2])
  6960      } else {
  6961          panic("instruction VBLENDMPD takes exactly 3 operands")
  6962      }
  6963  }
  6964  
  6965  func __asm_proxy_VBLENDMPS__(p *Program, v ...interface{}) *Instruction {
  6966      if len(v) == 3 {
  6967          return p.VBLENDMPS(v[0], v[1], v[2])
  6968      } else {
  6969          panic("instruction VBLENDMPS takes exactly 3 operands")
  6970      }
  6971  }
  6972  
  6973  func __asm_proxy_VBLENDPD__(p *Program, v ...interface{}) *Instruction {
  6974      if len(v) == 4 {
  6975          return p.VBLENDPD(v[0], v[1], v[2], v[3])
  6976      } else {
  6977          panic("instruction VBLENDPD takes exactly 4 operands")
  6978      }
  6979  }
  6980  
  6981  func __asm_proxy_VBLENDPS__(p *Program, v ...interface{}) *Instruction {
  6982      if len(v) == 4 {
  6983          return p.VBLENDPS(v[0], v[1], v[2], v[3])
  6984      } else {
  6985          panic("instruction VBLENDPS takes exactly 4 operands")
  6986      }
  6987  }
  6988  
  6989  func __asm_proxy_VBLENDVPD__(p *Program, v ...interface{}) *Instruction {
  6990      if len(v) == 4 {
  6991          return p.VBLENDVPD(v[0], v[1], v[2], v[3])
  6992      } else {
  6993          panic("instruction VBLENDVPD takes exactly 4 operands")
  6994      }
  6995  }
  6996  
  6997  func __asm_proxy_VBLENDVPS__(p *Program, v ...interface{}) *Instruction {
  6998      if len(v) == 4 {
  6999          return p.VBLENDVPS(v[0], v[1], v[2], v[3])
  7000      } else {
  7001          panic("instruction VBLENDVPS takes exactly 4 operands")
  7002      }
  7003  }
  7004  
  7005  func __asm_proxy_VBROADCASTF128__(p *Program, v ...interface{}) *Instruction {
  7006      if len(v) == 2 {
  7007          return p.VBROADCASTF128(v[0], v[1])
  7008      } else {
  7009          panic("instruction VBROADCASTF128 takes exactly 2 operands")
  7010      }
  7011  }
  7012  
  7013  func __asm_proxy_VBROADCASTF32X2__(p *Program, v ...interface{}) *Instruction {
  7014      if len(v) == 2 {
  7015          return p.VBROADCASTF32X2(v[0], v[1])
  7016      } else {
  7017          panic("instruction VBROADCASTF32X2 takes exactly 2 operands")
  7018      }
  7019  }
  7020  
  7021  func __asm_proxy_VBROADCASTF32X4__(p *Program, v ...interface{}) *Instruction {
  7022      if len(v) == 2 {
  7023          return p.VBROADCASTF32X4(v[0], v[1])
  7024      } else {
  7025          panic("instruction VBROADCASTF32X4 takes exactly 2 operands")
  7026      }
  7027  }
  7028  
  7029  func __asm_proxy_VBROADCASTF32X8__(p *Program, v ...interface{}) *Instruction {
  7030      if len(v) == 2 {
  7031          return p.VBROADCASTF32X8(v[0], v[1])
  7032      } else {
  7033          panic("instruction VBROADCASTF32X8 takes exactly 2 operands")
  7034      }
  7035  }
  7036  
  7037  func __asm_proxy_VBROADCASTF64X2__(p *Program, v ...interface{}) *Instruction {
  7038      if len(v) == 2 {
  7039          return p.VBROADCASTF64X2(v[0], v[1])
  7040      } else {
  7041          panic("instruction VBROADCASTF64X2 takes exactly 2 operands")
  7042      }
  7043  }
  7044  
  7045  func __asm_proxy_VBROADCASTF64X4__(p *Program, v ...interface{}) *Instruction {
  7046      if len(v) == 2 {
  7047          return p.VBROADCASTF64X4(v[0], v[1])
  7048      } else {
  7049          panic("instruction VBROADCASTF64X4 takes exactly 2 operands")
  7050      }
  7051  }
  7052  
  7053  func __asm_proxy_VBROADCASTI128__(p *Program, v ...interface{}) *Instruction {
  7054      if len(v) == 2 {
  7055          return p.VBROADCASTI128(v[0], v[1])
  7056      } else {
  7057          panic("instruction VBROADCASTI128 takes exactly 2 operands")
  7058      }
  7059  }
  7060  
  7061  func __asm_proxy_VBROADCASTI32X2__(p *Program, v ...interface{}) *Instruction {
  7062      if len(v) == 2 {
  7063          return p.VBROADCASTI32X2(v[0], v[1])
  7064      } else {
  7065          panic("instruction VBROADCASTI32X2 takes exactly 2 operands")
  7066      }
  7067  }
  7068  
  7069  func __asm_proxy_VBROADCASTI32X4__(p *Program, v ...interface{}) *Instruction {
  7070      if len(v) == 2 {
  7071          return p.VBROADCASTI32X4(v[0], v[1])
  7072      } else {
  7073          panic("instruction VBROADCASTI32X4 takes exactly 2 operands")
  7074      }
  7075  }
  7076  
  7077  func __asm_proxy_VBROADCASTI32X8__(p *Program, v ...interface{}) *Instruction {
  7078      if len(v) == 2 {
  7079          return p.VBROADCASTI32X8(v[0], v[1])
  7080      } else {
  7081          panic("instruction VBROADCASTI32X8 takes exactly 2 operands")
  7082      }
  7083  }
  7084  
  7085  func __asm_proxy_VBROADCASTI64X2__(p *Program, v ...interface{}) *Instruction {
  7086      if len(v) == 2 {
  7087          return p.VBROADCASTI64X2(v[0], v[1])
  7088      } else {
  7089          panic("instruction VBROADCASTI64X2 takes exactly 2 operands")
  7090      }
  7091  }
  7092  
  7093  func __asm_proxy_VBROADCASTI64X4__(p *Program, v ...interface{}) *Instruction {
  7094      if len(v) == 2 {
  7095          return p.VBROADCASTI64X4(v[0], v[1])
  7096      } else {
  7097          panic("instruction VBROADCASTI64X4 takes exactly 2 operands")
  7098      }
  7099  }
  7100  
  7101  func __asm_proxy_VBROADCASTSD__(p *Program, v ...interface{}) *Instruction {
  7102      if len(v) == 2 {
  7103          return p.VBROADCASTSD(v[0], v[1])
  7104      } else {
  7105          panic("instruction VBROADCASTSD takes exactly 2 operands")
  7106      }
  7107  }
  7108  
  7109  func __asm_proxy_VBROADCASTSS__(p *Program, v ...interface{}) *Instruction {
  7110      if len(v) == 2 {
  7111          return p.VBROADCASTSS(v[0], v[1])
  7112      } else {
  7113          panic("instruction VBROADCASTSS takes exactly 2 operands")
  7114      }
  7115  }
  7116  
  7117  func __asm_proxy_VCMPPD__(p *Program, v ...interface{}) *Instruction {
  7118      switch len(v) {
  7119          case 4  : return p.VCMPPD(v[0], v[1], v[2], v[3])
  7120          case 5  : return p.VCMPPD(v[0], v[1], v[2], v[3], v[4])
  7121          default : panic("instruction VCMPPD takes 4 or 5 operands")
  7122      }
  7123  }
  7124  
  7125  func __asm_proxy_VCMPPS__(p *Program, v ...interface{}) *Instruction {
  7126      switch len(v) {
  7127          case 4  : return p.VCMPPS(v[0], v[1], v[2], v[3])
  7128          case 5  : return p.VCMPPS(v[0], v[1], v[2], v[3], v[4])
  7129          default : panic("instruction VCMPPS takes 4 or 5 operands")
  7130      }
  7131  }
  7132  
  7133  func __asm_proxy_VCMPSD__(p *Program, v ...interface{}) *Instruction {
  7134      switch len(v) {
  7135          case 4  : return p.VCMPSD(v[0], v[1], v[2], v[3])
  7136          case 5  : return p.VCMPSD(v[0], v[1], v[2], v[3], v[4])
  7137          default : panic("instruction VCMPSD takes 4 or 5 operands")
  7138      }
  7139  }
  7140  
  7141  func __asm_proxy_VCMPSS__(p *Program, v ...interface{}) *Instruction {
  7142      switch len(v) {
  7143          case 4  : return p.VCMPSS(v[0], v[1], v[2], v[3])
  7144          case 5  : return p.VCMPSS(v[0], v[1], v[2], v[3], v[4])
  7145          default : panic("instruction VCMPSS takes 4 or 5 operands")
  7146      }
  7147  }
  7148  
  7149  func __asm_proxy_VCOMISD__(p *Program, v ...interface{}) *Instruction {
  7150      switch len(v) {
  7151          case 2  : return p.VCOMISD(v[0], v[1])
  7152          case 3  : return p.VCOMISD(v[0], v[1], v[2])
  7153          default : panic("instruction VCOMISD takes 2 or 3 operands")
  7154      }
  7155  }
  7156  
  7157  func __asm_proxy_VCOMISS__(p *Program, v ...interface{}) *Instruction {
  7158      switch len(v) {
  7159          case 2  : return p.VCOMISS(v[0], v[1])
  7160          case 3  : return p.VCOMISS(v[0], v[1], v[2])
  7161          default : panic("instruction VCOMISS takes 2 or 3 operands")
  7162      }
  7163  }
  7164  
  7165  func __asm_proxy_VCOMPRESSPD__(p *Program, v ...interface{}) *Instruction {
  7166      if len(v) == 2 {
  7167          return p.VCOMPRESSPD(v[0], v[1])
  7168      } else {
  7169          panic("instruction VCOMPRESSPD takes exactly 2 operands")
  7170      }
  7171  }
  7172  
  7173  func __asm_proxy_VCOMPRESSPS__(p *Program, v ...interface{}) *Instruction {
  7174      if len(v) == 2 {
  7175          return p.VCOMPRESSPS(v[0], v[1])
  7176      } else {
  7177          panic("instruction VCOMPRESSPS takes exactly 2 operands")
  7178      }
  7179  }
  7180  
  7181  func __asm_proxy_VCVTDQ2PD__(p *Program, v ...interface{}) *Instruction {
  7182      if len(v) == 2 {
  7183          return p.VCVTDQ2PD(v[0], v[1])
  7184      } else {
  7185          panic("instruction VCVTDQ2PD takes exactly 2 operands")
  7186      }
  7187  }
  7188  
  7189  func __asm_proxy_VCVTDQ2PS__(p *Program, v ...interface{}) *Instruction {
  7190      switch len(v) {
  7191          case 2  : return p.VCVTDQ2PS(v[0], v[1])
  7192          case 3  : return p.VCVTDQ2PS(v[0], v[1], v[2])
  7193          default : panic("instruction VCVTDQ2PS takes 2 or 3 operands")
  7194      }
  7195  }
  7196  
  7197  func __asm_proxy_VCVTPD2DQ__(p *Program, v ...interface{}) *Instruction {
  7198      switch len(v) {
  7199          case 2  : return p.VCVTPD2DQ(v[0], v[1])
  7200          case 3  : return p.VCVTPD2DQ(v[0], v[1], v[2])
  7201          default : panic("instruction VCVTPD2DQ takes 2 or 3 operands")
  7202      }
  7203  }
  7204  
  7205  func __asm_proxy_VCVTPD2PS__(p *Program, v ...interface{}) *Instruction {
  7206      switch len(v) {
  7207          case 2  : return p.VCVTPD2PS(v[0], v[1])
  7208          case 3  : return p.VCVTPD2PS(v[0], v[1], v[2])
  7209          default : panic("instruction VCVTPD2PS takes 2 or 3 operands")
  7210      }
  7211  }
  7212  
  7213  func __asm_proxy_VCVTPD2QQ__(p *Program, v ...interface{}) *Instruction {
  7214      switch len(v) {
  7215          case 2  : return p.VCVTPD2QQ(v[0], v[1])
  7216          case 3  : return p.VCVTPD2QQ(v[0], v[1], v[2])
  7217          default : panic("instruction VCVTPD2QQ takes 2 or 3 operands")
  7218      }
  7219  }
  7220  
  7221  func __asm_proxy_VCVTPD2UDQ__(p *Program, v ...interface{}) *Instruction {
  7222      switch len(v) {
  7223          case 2  : return p.VCVTPD2UDQ(v[0], v[1])
  7224          case 3  : return p.VCVTPD2UDQ(v[0], v[1], v[2])
  7225          default : panic("instruction VCVTPD2UDQ takes 2 or 3 operands")
  7226      }
  7227  }
  7228  
  7229  func __asm_proxy_VCVTPD2UQQ__(p *Program, v ...interface{}) *Instruction {
  7230      switch len(v) {
  7231          case 2  : return p.VCVTPD2UQQ(v[0], v[1])
  7232          case 3  : return p.VCVTPD2UQQ(v[0], v[1], v[2])
  7233          default : panic("instruction VCVTPD2UQQ takes 2 or 3 operands")
  7234      }
  7235  }
  7236  
  7237  func __asm_proxy_VCVTPH2PS__(p *Program, v ...interface{}) *Instruction {
  7238      switch len(v) {
  7239          case 2  : return p.VCVTPH2PS(v[0], v[1])
  7240          case 3  : return p.VCVTPH2PS(v[0], v[1], v[2])
  7241          default : panic("instruction VCVTPH2PS takes 2 or 3 operands")
  7242      }
  7243  }
  7244  
  7245  func __asm_proxy_VCVTPS2DQ__(p *Program, v ...interface{}) *Instruction {
  7246      switch len(v) {
  7247          case 2  : return p.VCVTPS2DQ(v[0], v[1])
  7248          case 3  : return p.VCVTPS2DQ(v[0], v[1], v[2])
  7249          default : panic("instruction VCVTPS2DQ takes 2 or 3 operands")
  7250      }
  7251  }
  7252  
  7253  func __asm_proxy_VCVTPS2PD__(p *Program, v ...interface{}) *Instruction {
  7254      switch len(v) {
  7255          case 2  : return p.VCVTPS2PD(v[0], v[1])
  7256          case 3  : return p.VCVTPS2PD(v[0], v[1], v[2])
  7257          default : panic("instruction VCVTPS2PD takes 2 or 3 operands")
  7258      }
  7259  }
  7260  
  7261  func __asm_proxy_VCVTPS2PH__(p *Program, v ...interface{}) *Instruction {
  7262      switch len(v) {
  7263          case 3  : return p.VCVTPS2PH(v[0], v[1], v[2])
  7264          case 4  : return p.VCVTPS2PH(v[0], v[1], v[2], v[3])
  7265          default : panic("instruction VCVTPS2PH takes 3 or 4 operands")
  7266      }
  7267  }
  7268  
  7269  func __asm_proxy_VCVTPS2QQ__(p *Program, v ...interface{}) *Instruction {
  7270      switch len(v) {
  7271          case 2  : return p.VCVTPS2QQ(v[0], v[1])
  7272          case 3  : return p.VCVTPS2QQ(v[0], v[1], v[2])
  7273          default : panic("instruction VCVTPS2QQ takes 2 or 3 operands")
  7274      }
  7275  }
  7276  
  7277  func __asm_proxy_VCVTPS2UDQ__(p *Program, v ...interface{}) *Instruction {
  7278      switch len(v) {
  7279          case 2  : return p.VCVTPS2UDQ(v[0], v[1])
  7280          case 3  : return p.VCVTPS2UDQ(v[0], v[1], v[2])
  7281          default : panic("instruction VCVTPS2UDQ takes 2 or 3 operands")
  7282      }
  7283  }
  7284  
  7285  func __asm_proxy_VCVTPS2UQQ__(p *Program, v ...interface{}) *Instruction {
  7286      switch len(v) {
  7287          case 2  : return p.VCVTPS2UQQ(v[0], v[1])
  7288          case 3  : return p.VCVTPS2UQQ(v[0], v[1], v[2])
  7289          default : panic("instruction VCVTPS2UQQ takes 2 or 3 operands")
  7290      }
  7291  }
  7292  
  7293  func __asm_proxy_VCVTQQ2PD__(p *Program, v ...interface{}) *Instruction {
  7294      switch len(v) {
  7295          case 2  : return p.VCVTQQ2PD(v[0], v[1])
  7296          case 3  : return p.VCVTQQ2PD(v[0], v[1], v[2])
  7297          default : panic("instruction VCVTQQ2PD takes 2 or 3 operands")
  7298      }
  7299  }
  7300  
  7301  func __asm_proxy_VCVTQQ2PS__(p *Program, v ...interface{}) *Instruction {
  7302      switch len(v) {
  7303          case 2  : return p.VCVTQQ2PS(v[0], v[1])
  7304          case 3  : return p.VCVTQQ2PS(v[0], v[1], v[2])
  7305          default : panic("instruction VCVTQQ2PS takes 2 or 3 operands")
  7306      }
  7307  }
  7308  
  7309  func __asm_proxy_VCVTSD2SI__(p *Program, v ...interface{}) *Instruction {
  7310      switch len(v) {
  7311          case 2  : return p.VCVTSD2SI(v[0], v[1])
  7312          case 3  : return p.VCVTSD2SI(v[0], v[1], v[2])
  7313          default : panic("instruction VCVTSD2SI takes 2 or 3 operands")
  7314      }
  7315  }
  7316  
  7317  func __asm_proxy_VCVTSD2SS__(p *Program, v ...interface{}) *Instruction {
  7318      switch len(v) {
  7319          case 3  : return p.VCVTSD2SS(v[0], v[1], v[2])
  7320          case 4  : return p.VCVTSD2SS(v[0], v[1], v[2], v[3])
  7321          default : panic("instruction VCVTSD2SS takes 3 or 4 operands")
  7322      }
  7323  }
  7324  
  7325  func __asm_proxy_VCVTSD2USI__(p *Program, v ...interface{}) *Instruction {
  7326      switch len(v) {
  7327          case 2  : return p.VCVTSD2USI(v[0], v[1])
  7328          case 3  : return p.VCVTSD2USI(v[0], v[1], v[2])
  7329          default : panic("instruction VCVTSD2USI takes 2 or 3 operands")
  7330      }
  7331  }
  7332  
  7333  func __asm_proxy_VCVTSI2SD__(p *Program, v ...interface{}) *Instruction {
  7334      switch len(v) {
  7335          case 3  : return p.VCVTSI2SD(v[0], v[1], v[2])
  7336          case 4  : return p.VCVTSI2SD(v[0], v[1], v[2], v[3])
  7337          default : panic("instruction VCVTSI2SD takes 3 or 4 operands")
  7338      }
  7339  }
  7340  
  7341  func __asm_proxy_VCVTSI2SS__(p *Program, v ...interface{}) *Instruction {
  7342      switch len(v) {
  7343          case 3  : return p.VCVTSI2SS(v[0], v[1], v[2])
  7344          case 4  : return p.VCVTSI2SS(v[0], v[1], v[2], v[3])
  7345          default : panic("instruction VCVTSI2SS takes 3 or 4 operands")
  7346      }
  7347  }
  7348  
  7349  func __asm_proxy_VCVTSS2SD__(p *Program, v ...interface{}) *Instruction {
  7350      switch len(v) {
  7351          case 3  : return p.VCVTSS2SD(v[0], v[1], v[2])
  7352          case 4  : return p.VCVTSS2SD(v[0], v[1], v[2], v[3])
  7353          default : panic("instruction VCVTSS2SD takes 3 or 4 operands")
  7354      }
  7355  }
  7356  
  7357  func __asm_proxy_VCVTSS2SI__(p *Program, v ...interface{}) *Instruction {
  7358      switch len(v) {
  7359          case 2  : return p.VCVTSS2SI(v[0], v[1])
  7360          case 3  : return p.VCVTSS2SI(v[0], v[1], v[2])
  7361          default : panic("instruction VCVTSS2SI takes 2 or 3 operands")
  7362      }
  7363  }
  7364  
  7365  func __asm_proxy_VCVTSS2USI__(p *Program, v ...interface{}) *Instruction {
  7366      switch len(v) {
  7367          case 2  : return p.VCVTSS2USI(v[0], v[1])
  7368          case 3  : return p.VCVTSS2USI(v[0], v[1], v[2])
  7369          default : panic("instruction VCVTSS2USI takes 2 or 3 operands")
  7370      }
  7371  }
  7372  
  7373  func __asm_proxy_VCVTTPD2DQ__(p *Program, v ...interface{}) *Instruction {
  7374      switch len(v) {
  7375          case 2  : return p.VCVTTPD2DQ(v[0], v[1])
  7376          case 3  : return p.VCVTTPD2DQ(v[0], v[1], v[2])
  7377          default : panic("instruction VCVTTPD2DQ takes 2 or 3 operands")
  7378      }
  7379  }
  7380  
  7381  func __asm_proxy_VCVTTPD2QQ__(p *Program, v ...interface{}) *Instruction {
  7382      switch len(v) {
  7383          case 2  : return p.VCVTTPD2QQ(v[0], v[1])
  7384          case 3  : return p.VCVTTPD2QQ(v[0], v[1], v[2])
  7385          default : panic("instruction VCVTTPD2QQ takes 2 or 3 operands")
  7386      }
  7387  }
  7388  
  7389  func __asm_proxy_VCVTTPD2UDQ__(p *Program, v ...interface{}) *Instruction {
  7390      switch len(v) {
  7391          case 2  : return p.VCVTTPD2UDQ(v[0], v[1])
  7392          case 3  : return p.VCVTTPD2UDQ(v[0], v[1], v[2])
  7393          default : panic("instruction VCVTTPD2UDQ takes 2 or 3 operands")
  7394      }
  7395  }
  7396  
  7397  func __asm_proxy_VCVTTPD2UQQ__(p *Program, v ...interface{}) *Instruction {
  7398      switch len(v) {
  7399          case 2  : return p.VCVTTPD2UQQ(v[0], v[1])
  7400          case 3  : return p.VCVTTPD2UQQ(v[0], v[1], v[2])
  7401          default : panic("instruction VCVTTPD2UQQ takes 2 or 3 operands")
  7402      }
  7403  }
  7404  
  7405  func __asm_proxy_VCVTTPS2DQ__(p *Program, v ...interface{}) *Instruction {
  7406      switch len(v) {
  7407          case 2  : return p.VCVTTPS2DQ(v[0], v[1])
  7408          case 3  : return p.VCVTTPS2DQ(v[0], v[1], v[2])
  7409          default : panic("instruction VCVTTPS2DQ takes 2 or 3 operands")
  7410      }
  7411  }
  7412  
  7413  func __asm_proxy_VCVTTPS2QQ__(p *Program, v ...interface{}) *Instruction {
  7414      switch len(v) {
  7415          case 2  : return p.VCVTTPS2QQ(v[0], v[1])
  7416          case 3  : return p.VCVTTPS2QQ(v[0], v[1], v[2])
  7417          default : panic("instruction VCVTTPS2QQ takes 2 or 3 operands")
  7418      }
  7419  }
  7420  
  7421  func __asm_proxy_VCVTTPS2UDQ__(p *Program, v ...interface{}) *Instruction {
  7422      switch len(v) {
  7423          case 2  : return p.VCVTTPS2UDQ(v[0], v[1])
  7424          case 3  : return p.VCVTTPS2UDQ(v[0], v[1], v[2])
  7425          default : panic("instruction VCVTTPS2UDQ takes 2 or 3 operands")
  7426      }
  7427  }
  7428  
  7429  func __asm_proxy_VCVTTPS2UQQ__(p *Program, v ...interface{}) *Instruction {
  7430      switch len(v) {
  7431          case 2  : return p.VCVTTPS2UQQ(v[0], v[1])
  7432          case 3  : return p.VCVTTPS2UQQ(v[0], v[1], v[2])
  7433          default : panic("instruction VCVTTPS2UQQ takes 2 or 3 operands")
  7434      }
  7435  }
  7436  
  7437  func __asm_proxy_VCVTTSD2SI__(p *Program, v ...interface{}) *Instruction {
  7438      switch len(v) {
  7439          case 2  : return p.VCVTTSD2SI(v[0], v[1])
  7440          case 3  : return p.VCVTTSD2SI(v[0], v[1], v[2])
  7441          default : panic("instruction VCVTTSD2SI takes 2 or 3 operands")
  7442      }
  7443  }
  7444  
  7445  func __asm_proxy_VCVTTSD2USI__(p *Program, v ...interface{}) *Instruction {
  7446      switch len(v) {
  7447          case 2  : return p.VCVTTSD2USI(v[0], v[1])
  7448          case 3  : return p.VCVTTSD2USI(v[0], v[1], v[2])
  7449          default : panic("instruction VCVTTSD2USI takes 2 or 3 operands")
  7450      }
  7451  }
  7452  
  7453  func __asm_proxy_VCVTTSS2SI__(p *Program, v ...interface{}) *Instruction {
  7454      switch len(v) {
  7455          case 2  : return p.VCVTTSS2SI(v[0], v[1])
  7456          case 3  : return p.VCVTTSS2SI(v[0], v[1], v[2])
  7457          default : panic("instruction VCVTTSS2SI takes 2 or 3 operands")
  7458      }
  7459  }
  7460  
  7461  func __asm_proxy_VCVTTSS2USI__(p *Program, v ...interface{}) *Instruction {
  7462      switch len(v) {
  7463          case 2  : return p.VCVTTSS2USI(v[0], v[1])
  7464          case 3  : return p.VCVTTSS2USI(v[0], v[1], v[2])
  7465          default : panic("instruction VCVTTSS2USI takes 2 or 3 operands")
  7466      }
  7467  }
  7468  
  7469  func __asm_proxy_VCVTUDQ2PD__(p *Program, v ...interface{}) *Instruction {
  7470      if len(v) == 2 {
  7471          return p.VCVTUDQ2PD(v[0], v[1])
  7472      } else {
  7473          panic("instruction VCVTUDQ2PD takes exactly 2 operands")
  7474      }
  7475  }
  7476  
  7477  func __asm_proxy_VCVTUDQ2PS__(p *Program, v ...interface{}) *Instruction {
  7478      switch len(v) {
  7479          case 2  : return p.VCVTUDQ2PS(v[0], v[1])
  7480          case 3  : return p.VCVTUDQ2PS(v[0], v[1], v[2])
  7481          default : panic("instruction VCVTUDQ2PS takes 2 or 3 operands")
  7482      }
  7483  }
  7484  
  7485  func __asm_proxy_VCVTUQQ2PD__(p *Program, v ...interface{}) *Instruction {
  7486      switch len(v) {
  7487          case 2  : return p.VCVTUQQ2PD(v[0], v[1])
  7488          case 3  : return p.VCVTUQQ2PD(v[0], v[1], v[2])
  7489          default : panic("instruction VCVTUQQ2PD takes 2 or 3 operands")
  7490      }
  7491  }
  7492  
  7493  func __asm_proxy_VCVTUQQ2PS__(p *Program, v ...interface{}) *Instruction {
  7494      switch len(v) {
  7495          case 2  : return p.VCVTUQQ2PS(v[0], v[1])
  7496          case 3  : return p.VCVTUQQ2PS(v[0], v[1], v[2])
  7497          default : panic("instruction VCVTUQQ2PS takes 2 or 3 operands")
  7498      }
  7499  }
  7500  
  7501  func __asm_proxy_VCVTUSI2SD__(p *Program, v ...interface{}) *Instruction {
  7502      switch len(v) {
  7503          case 3  : return p.VCVTUSI2SD(v[0], v[1], v[2])
  7504          case 4  : return p.VCVTUSI2SD(v[0], v[1], v[2], v[3])
  7505          default : panic("instruction VCVTUSI2SD takes 3 or 4 operands")
  7506      }
  7507  }
  7508  
  7509  func __asm_proxy_VCVTUSI2SS__(p *Program, v ...interface{}) *Instruction {
  7510      switch len(v) {
  7511          case 3  : return p.VCVTUSI2SS(v[0], v[1], v[2])
  7512          case 4  : return p.VCVTUSI2SS(v[0], v[1], v[2], v[3])
  7513          default : panic("instruction VCVTUSI2SS takes 3 or 4 operands")
  7514      }
  7515  }
  7516  
  7517  func __asm_proxy_VDBPSADBW__(p *Program, v ...interface{}) *Instruction {
  7518      if len(v) == 4 {
  7519          return p.VDBPSADBW(v[0], v[1], v[2], v[3])
  7520      } else {
  7521          panic("instruction VDBPSADBW takes exactly 4 operands")
  7522      }
  7523  }
  7524  
  7525  func __asm_proxy_VDIVPD__(p *Program, v ...interface{}) *Instruction {
  7526      switch len(v) {
  7527          case 3  : return p.VDIVPD(v[0], v[1], v[2])
  7528          case 4  : return p.VDIVPD(v[0], v[1], v[2], v[3])
  7529          default : panic("instruction VDIVPD takes 3 or 4 operands")
  7530      }
  7531  }
  7532  
  7533  func __asm_proxy_VDIVPS__(p *Program, v ...interface{}) *Instruction {
  7534      switch len(v) {
  7535          case 3  : return p.VDIVPS(v[0], v[1], v[2])
  7536          case 4  : return p.VDIVPS(v[0], v[1], v[2], v[3])
  7537          default : panic("instruction VDIVPS takes 3 or 4 operands")
  7538      }
  7539  }
  7540  
  7541  func __asm_proxy_VDIVSD__(p *Program, v ...interface{}) *Instruction {
  7542      switch len(v) {
  7543          case 3  : return p.VDIVSD(v[0], v[1], v[2])
  7544          case 4  : return p.VDIVSD(v[0], v[1], v[2], v[3])
  7545          default : panic("instruction VDIVSD takes 3 or 4 operands")
  7546      }
  7547  }
  7548  
  7549  func __asm_proxy_VDIVSS__(p *Program, v ...interface{}) *Instruction {
  7550      switch len(v) {
  7551          case 3  : return p.VDIVSS(v[0], v[1], v[2])
  7552          case 4  : return p.VDIVSS(v[0], v[1], v[2], v[3])
  7553          default : panic("instruction VDIVSS takes 3 or 4 operands")
  7554      }
  7555  }
  7556  
  7557  func __asm_proxy_VDPPD__(p *Program, v ...interface{}) *Instruction {
  7558      if len(v) == 4 {
  7559          return p.VDPPD(v[0], v[1], v[2], v[3])
  7560      } else {
  7561          panic("instruction VDPPD takes exactly 4 operands")
  7562      }
  7563  }
  7564  
  7565  func __asm_proxy_VDPPS__(p *Program, v ...interface{}) *Instruction {
  7566      if len(v) == 4 {
  7567          return p.VDPPS(v[0], v[1], v[2], v[3])
  7568      } else {
  7569          panic("instruction VDPPS takes exactly 4 operands")
  7570      }
  7571  }
  7572  
  7573  func __asm_proxy_VEXP2PD__(p *Program, v ...interface{}) *Instruction {
  7574      switch len(v) {
  7575          case 2  : return p.VEXP2PD(v[0], v[1])
  7576          case 3  : return p.VEXP2PD(v[0], v[1], v[2])
  7577          default : panic("instruction VEXP2PD takes 2 or 3 operands")
  7578      }
  7579  }
  7580  
  7581  func __asm_proxy_VEXP2PS__(p *Program, v ...interface{}) *Instruction {
  7582      switch len(v) {
  7583          case 2  : return p.VEXP2PS(v[0], v[1])
  7584          case 3  : return p.VEXP2PS(v[0], v[1], v[2])
  7585          default : panic("instruction VEXP2PS takes 2 or 3 operands")
  7586      }
  7587  }
  7588  
  7589  func __asm_proxy_VEXPANDPD__(p *Program, v ...interface{}) *Instruction {
  7590      if len(v) == 2 {
  7591          return p.VEXPANDPD(v[0], v[1])
  7592      } else {
  7593          panic("instruction VEXPANDPD takes exactly 2 operands")
  7594      }
  7595  }
  7596  
  7597  func __asm_proxy_VEXPANDPS__(p *Program, v ...interface{}) *Instruction {
  7598      if len(v) == 2 {
  7599          return p.VEXPANDPS(v[0], v[1])
  7600      } else {
  7601          panic("instruction VEXPANDPS takes exactly 2 operands")
  7602      }
  7603  }
  7604  
  7605  func __asm_proxy_VEXTRACTF128__(p *Program, v ...interface{}) *Instruction {
  7606      if len(v) == 3 {
  7607          return p.VEXTRACTF128(v[0], v[1], v[2])
  7608      } else {
  7609          panic("instruction VEXTRACTF128 takes exactly 3 operands")
  7610      }
  7611  }
  7612  
  7613  func __asm_proxy_VEXTRACTF32X4__(p *Program, v ...interface{}) *Instruction {
  7614      if len(v) == 3 {
  7615          return p.VEXTRACTF32X4(v[0], v[1], v[2])
  7616      } else {
  7617          panic("instruction VEXTRACTF32X4 takes exactly 3 operands")
  7618      }
  7619  }
  7620  
  7621  func __asm_proxy_VEXTRACTF32X8__(p *Program, v ...interface{}) *Instruction {
  7622      if len(v) == 3 {
  7623          return p.VEXTRACTF32X8(v[0], v[1], v[2])
  7624      } else {
  7625          panic("instruction VEXTRACTF32X8 takes exactly 3 operands")
  7626      }
  7627  }
  7628  
  7629  func __asm_proxy_VEXTRACTF64X2__(p *Program, v ...interface{}) *Instruction {
  7630      if len(v) == 3 {
  7631          return p.VEXTRACTF64X2(v[0], v[1], v[2])
  7632      } else {
  7633          panic("instruction VEXTRACTF64X2 takes exactly 3 operands")
  7634      }
  7635  }
  7636  
  7637  func __asm_proxy_VEXTRACTF64X4__(p *Program, v ...interface{}) *Instruction {
  7638      if len(v) == 3 {
  7639          return p.VEXTRACTF64X4(v[0], v[1], v[2])
  7640      } else {
  7641          panic("instruction VEXTRACTF64X4 takes exactly 3 operands")
  7642      }
  7643  }
  7644  
  7645  func __asm_proxy_VEXTRACTI128__(p *Program, v ...interface{}) *Instruction {
  7646      if len(v) == 3 {
  7647          return p.VEXTRACTI128(v[0], v[1], v[2])
  7648      } else {
  7649          panic("instruction VEXTRACTI128 takes exactly 3 operands")
  7650      }
  7651  }
  7652  
  7653  func __asm_proxy_VEXTRACTI32X4__(p *Program, v ...interface{}) *Instruction {
  7654      if len(v) == 3 {
  7655          return p.VEXTRACTI32X4(v[0], v[1], v[2])
  7656      } else {
  7657          panic("instruction VEXTRACTI32X4 takes exactly 3 operands")
  7658      }
  7659  }
  7660  
  7661  func __asm_proxy_VEXTRACTI32X8__(p *Program, v ...interface{}) *Instruction {
  7662      if len(v) == 3 {
  7663          return p.VEXTRACTI32X8(v[0], v[1], v[2])
  7664      } else {
  7665          panic("instruction VEXTRACTI32X8 takes exactly 3 operands")
  7666      }
  7667  }
  7668  
  7669  func __asm_proxy_VEXTRACTI64X2__(p *Program, v ...interface{}) *Instruction {
  7670      if len(v) == 3 {
  7671          return p.VEXTRACTI64X2(v[0], v[1], v[2])
  7672      } else {
  7673          panic("instruction VEXTRACTI64X2 takes exactly 3 operands")
  7674      }
  7675  }
  7676  
  7677  func __asm_proxy_VEXTRACTI64X4__(p *Program, v ...interface{}) *Instruction {
  7678      if len(v) == 3 {
  7679          return p.VEXTRACTI64X4(v[0], v[1], v[2])
  7680      } else {
  7681          panic("instruction VEXTRACTI64X4 takes exactly 3 operands")
  7682      }
  7683  }
  7684  
  7685  func __asm_proxy_VEXTRACTPS__(p *Program, v ...interface{}) *Instruction {
  7686      if len(v) == 3 {
  7687          return p.VEXTRACTPS(v[0], v[1], v[2])
  7688      } else {
  7689          panic("instruction VEXTRACTPS takes exactly 3 operands")
  7690      }
  7691  }
  7692  
  7693  func __asm_proxy_VFIXUPIMMPD__(p *Program, v ...interface{}) *Instruction {
  7694      switch len(v) {
  7695          case 4  : return p.VFIXUPIMMPD(v[0], v[1], v[2], v[3])
  7696          case 5  : return p.VFIXUPIMMPD(v[0], v[1], v[2], v[3], v[4])
  7697          default : panic("instruction VFIXUPIMMPD takes 4 or 5 operands")
  7698      }
  7699  }
  7700  
  7701  func __asm_proxy_VFIXUPIMMPS__(p *Program, v ...interface{}) *Instruction {
  7702      switch len(v) {
  7703          case 4  : return p.VFIXUPIMMPS(v[0], v[1], v[2], v[3])
  7704          case 5  : return p.VFIXUPIMMPS(v[0], v[1], v[2], v[3], v[4])
  7705          default : panic("instruction VFIXUPIMMPS takes 4 or 5 operands")
  7706      }
  7707  }
  7708  
  7709  func __asm_proxy_VFIXUPIMMSD__(p *Program, v ...interface{}) *Instruction {
  7710      switch len(v) {
  7711          case 4  : return p.VFIXUPIMMSD(v[0], v[1], v[2], v[3])
  7712          case 5  : return p.VFIXUPIMMSD(v[0], v[1], v[2], v[3], v[4])
  7713          default : panic("instruction VFIXUPIMMSD takes 4 or 5 operands")
  7714      }
  7715  }
  7716  
  7717  func __asm_proxy_VFIXUPIMMSS__(p *Program, v ...interface{}) *Instruction {
  7718      switch len(v) {
  7719          case 4  : return p.VFIXUPIMMSS(v[0], v[1], v[2], v[3])
  7720          case 5  : return p.VFIXUPIMMSS(v[0], v[1], v[2], v[3], v[4])
  7721          default : panic("instruction VFIXUPIMMSS takes 4 or 5 operands")
  7722      }
  7723  }
  7724  
  7725  func __asm_proxy_VFMADD132PD__(p *Program, v ...interface{}) *Instruction {
  7726      switch len(v) {
  7727          case 3  : return p.VFMADD132PD(v[0], v[1], v[2])
  7728          case 4  : return p.VFMADD132PD(v[0], v[1], v[2], v[3])
  7729          default : panic("instruction VFMADD132PD takes 3 or 4 operands")
  7730      }
  7731  }
  7732  
  7733  func __asm_proxy_VFMADD132PS__(p *Program, v ...interface{}) *Instruction {
  7734      switch len(v) {
  7735          case 3  : return p.VFMADD132PS(v[0], v[1], v[2])
  7736          case 4  : return p.VFMADD132PS(v[0], v[1], v[2], v[3])
  7737          default : panic("instruction VFMADD132PS takes 3 or 4 operands")
  7738      }
  7739  }
  7740  
  7741  func __asm_proxy_VFMADD132SD__(p *Program, v ...interface{}) *Instruction {
  7742      switch len(v) {
  7743          case 3  : return p.VFMADD132SD(v[0], v[1], v[2])
  7744          case 4  : return p.VFMADD132SD(v[0], v[1], v[2], v[3])
  7745          default : panic("instruction VFMADD132SD takes 3 or 4 operands")
  7746      }
  7747  }
  7748  
  7749  func __asm_proxy_VFMADD132SS__(p *Program, v ...interface{}) *Instruction {
  7750      switch len(v) {
  7751          case 3  : return p.VFMADD132SS(v[0], v[1], v[2])
  7752          case 4  : return p.VFMADD132SS(v[0], v[1], v[2], v[3])
  7753          default : panic("instruction VFMADD132SS takes 3 or 4 operands")
  7754      }
  7755  }
  7756  
  7757  func __asm_proxy_VFMADD213PD__(p *Program, v ...interface{}) *Instruction {
  7758      switch len(v) {
  7759          case 3  : return p.VFMADD213PD(v[0], v[1], v[2])
  7760          case 4  : return p.VFMADD213PD(v[0], v[1], v[2], v[3])
  7761          default : panic("instruction VFMADD213PD takes 3 or 4 operands")
  7762      }
  7763  }
  7764  
  7765  func __asm_proxy_VFMADD213PS__(p *Program, v ...interface{}) *Instruction {
  7766      switch len(v) {
  7767          case 3  : return p.VFMADD213PS(v[0], v[1], v[2])
  7768          case 4  : return p.VFMADD213PS(v[0], v[1], v[2], v[3])
  7769          default : panic("instruction VFMADD213PS takes 3 or 4 operands")
  7770      }
  7771  }
  7772  
  7773  func __asm_proxy_VFMADD213SD__(p *Program, v ...interface{}) *Instruction {
  7774      switch len(v) {
  7775          case 3  : return p.VFMADD213SD(v[0], v[1], v[2])
  7776          case 4  : return p.VFMADD213SD(v[0], v[1], v[2], v[3])
  7777          default : panic("instruction VFMADD213SD takes 3 or 4 operands")
  7778      }
  7779  }
  7780  
  7781  func __asm_proxy_VFMADD213SS__(p *Program, v ...interface{}) *Instruction {
  7782      switch len(v) {
  7783          case 3  : return p.VFMADD213SS(v[0], v[1], v[2])
  7784          case 4  : return p.VFMADD213SS(v[0], v[1], v[2], v[3])
  7785          default : panic("instruction VFMADD213SS takes 3 or 4 operands")
  7786      }
  7787  }
  7788  
  7789  func __asm_proxy_VFMADD231PD__(p *Program, v ...interface{}) *Instruction {
  7790      switch len(v) {
  7791          case 3  : return p.VFMADD231PD(v[0], v[1], v[2])
  7792          case 4  : return p.VFMADD231PD(v[0], v[1], v[2], v[3])
  7793          default : panic("instruction VFMADD231PD takes 3 or 4 operands")
  7794      }
  7795  }
  7796  
  7797  func __asm_proxy_VFMADD231PS__(p *Program, v ...interface{}) *Instruction {
  7798      switch len(v) {
  7799          case 3  : return p.VFMADD231PS(v[0], v[1], v[2])
  7800          case 4  : return p.VFMADD231PS(v[0], v[1], v[2], v[3])
  7801          default : panic("instruction VFMADD231PS takes 3 or 4 operands")
  7802      }
  7803  }
  7804  
  7805  func __asm_proxy_VFMADD231SD__(p *Program, v ...interface{}) *Instruction {
  7806      switch len(v) {
  7807          case 3  : return p.VFMADD231SD(v[0], v[1], v[2])
  7808          case 4  : return p.VFMADD231SD(v[0], v[1], v[2], v[3])
  7809          default : panic("instruction VFMADD231SD takes 3 or 4 operands")
  7810      }
  7811  }
  7812  
  7813  func __asm_proxy_VFMADD231SS__(p *Program, v ...interface{}) *Instruction {
  7814      switch len(v) {
  7815          case 3  : return p.VFMADD231SS(v[0], v[1], v[2])
  7816          case 4  : return p.VFMADD231SS(v[0], v[1], v[2], v[3])
  7817          default : panic("instruction VFMADD231SS takes 3 or 4 operands")
  7818      }
  7819  }
  7820  
  7821  func __asm_proxy_VFMADDPD__(p *Program, v ...interface{}) *Instruction {
  7822      if len(v) == 4 {
  7823          return p.VFMADDPD(v[0], v[1], v[2], v[3])
  7824      } else {
  7825          panic("instruction VFMADDPD takes exactly 4 operands")
  7826      }
  7827  }
  7828  
  7829  func __asm_proxy_VFMADDPS__(p *Program, v ...interface{}) *Instruction {
  7830      if len(v) == 4 {
  7831          return p.VFMADDPS(v[0], v[1], v[2], v[3])
  7832      } else {
  7833          panic("instruction VFMADDPS takes exactly 4 operands")
  7834      }
  7835  }
  7836  
  7837  func __asm_proxy_VFMADDSD__(p *Program, v ...interface{}) *Instruction {
  7838      if len(v) == 4 {
  7839          return p.VFMADDSD(v[0], v[1], v[2], v[3])
  7840      } else {
  7841          panic("instruction VFMADDSD takes exactly 4 operands")
  7842      }
  7843  }
  7844  
  7845  func __asm_proxy_VFMADDSS__(p *Program, v ...interface{}) *Instruction {
  7846      if len(v) == 4 {
  7847          return p.VFMADDSS(v[0], v[1], v[2], v[3])
  7848      } else {
  7849          panic("instruction VFMADDSS takes exactly 4 operands")
  7850      }
  7851  }
  7852  
  7853  func __asm_proxy_VFMADDSUB132PD__(p *Program, v ...interface{}) *Instruction {
  7854      switch len(v) {
  7855          case 3  : return p.VFMADDSUB132PD(v[0], v[1], v[2])
  7856          case 4  : return p.VFMADDSUB132PD(v[0], v[1], v[2], v[3])
  7857          default : panic("instruction VFMADDSUB132PD takes 3 or 4 operands")
  7858      }
  7859  }
  7860  
  7861  func __asm_proxy_VFMADDSUB132PS__(p *Program, v ...interface{}) *Instruction {
  7862      switch len(v) {
  7863          case 3  : return p.VFMADDSUB132PS(v[0], v[1], v[2])
  7864          case 4  : return p.VFMADDSUB132PS(v[0], v[1], v[2], v[3])
  7865          default : panic("instruction VFMADDSUB132PS takes 3 or 4 operands")
  7866      }
  7867  }
  7868  
  7869  func __asm_proxy_VFMADDSUB213PD__(p *Program, v ...interface{}) *Instruction {
  7870      switch len(v) {
  7871          case 3  : return p.VFMADDSUB213PD(v[0], v[1], v[2])
  7872          case 4  : return p.VFMADDSUB213PD(v[0], v[1], v[2], v[3])
  7873          default : panic("instruction VFMADDSUB213PD takes 3 or 4 operands")
  7874      }
  7875  }
  7876  
  7877  func __asm_proxy_VFMADDSUB213PS__(p *Program, v ...interface{}) *Instruction {
  7878      switch len(v) {
  7879          case 3  : return p.VFMADDSUB213PS(v[0], v[1], v[2])
  7880          case 4  : return p.VFMADDSUB213PS(v[0], v[1], v[2], v[3])
  7881          default : panic("instruction VFMADDSUB213PS takes 3 or 4 operands")
  7882      }
  7883  }
  7884  
  7885  func __asm_proxy_VFMADDSUB231PD__(p *Program, v ...interface{}) *Instruction {
  7886      switch len(v) {
  7887          case 3  : return p.VFMADDSUB231PD(v[0], v[1], v[2])
  7888          case 4  : return p.VFMADDSUB231PD(v[0], v[1], v[2], v[3])
  7889          default : panic("instruction VFMADDSUB231PD takes 3 or 4 operands")
  7890      }
  7891  }
  7892  
  7893  func __asm_proxy_VFMADDSUB231PS__(p *Program, v ...interface{}) *Instruction {
  7894      switch len(v) {
  7895          case 3  : return p.VFMADDSUB231PS(v[0], v[1], v[2])
  7896          case 4  : return p.VFMADDSUB231PS(v[0], v[1], v[2], v[3])
  7897          default : panic("instruction VFMADDSUB231PS takes 3 or 4 operands")
  7898      }
  7899  }
  7900  
  7901  func __asm_proxy_VFMADDSUBPD__(p *Program, v ...interface{}) *Instruction {
  7902      if len(v) == 4 {
  7903          return p.VFMADDSUBPD(v[0], v[1], v[2], v[3])
  7904      } else {
  7905          panic("instruction VFMADDSUBPD takes exactly 4 operands")
  7906      }
  7907  }
  7908  
  7909  func __asm_proxy_VFMADDSUBPS__(p *Program, v ...interface{}) *Instruction {
  7910      if len(v) == 4 {
  7911          return p.VFMADDSUBPS(v[0], v[1], v[2], v[3])
  7912      } else {
  7913          panic("instruction VFMADDSUBPS takes exactly 4 operands")
  7914      }
  7915  }
  7916  
  7917  func __asm_proxy_VFMSUB132PD__(p *Program, v ...interface{}) *Instruction {
  7918      switch len(v) {
  7919          case 3  : return p.VFMSUB132PD(v[0], v[1], v[2])
  7920          case 4  : return p.VFMSUB132PD(v[0], v[1], v[2], v[3])
  7921          default : panic("instruction VFMSUB132PD takes 3 or 4 operands")
  7922      }
  7923  }
  7924  
  7925  func __asm_proxy_VFMSUB132PS__(p *Program, v ...interface{}) *Instruction {
  7926      switch len(v) {
  7927          case 3  : return p.VFMSUB132PS(v[0], v[1], v[2])
  7928          case 4  : return p.VFMSUB132PS(v[0], v[1], v[2], v[3])
  7929          default : panic("instruction VFMSUB132PS takes 3 or 4 operands")
  7930      }
  7931  }
  7932  
  7933  func __asm_proxy_VFMSUB132SD__(p *Program, v ...interface{}) *Instruction {
  7934      switch len(v) {
  7935          case 3  : return p.VFMSUB132SD(v[0], v[1], v[2])
  7936          case 4  : return p.VFMSUB132SD(v[0], v[1], v[2], v[3])
  7937          default : panic("instruction VFMSUB132SD takes 3 or 4 operands")
  7938      }
  7939  }
  7940  
  7941  func __asm_proxy_VFMSUB132SS__(p *Program, v ...interface{}) *Instruction {
  7942      switch len(v) {
  7943          case 3  : return p.VFMSUB132SS(v[0], v[1], v[2])
  7944          case 4  : return p.VFMSUB132SS(v[0], v[1], v[2], v[3])
  7945          default : panic("instruction VFMSUB132SS takes 3 or 4 operands")
  7946      }
  7947  }
  7948  
  7949  func __asm_proxy_VFMSUB213PD__(p *Program, v ...interface{}) *Instruction {
  7950      switch len(v) {
  7951          case 3  : return p.VFMSUB213PD(v[0], v[1], v[2])
  7952          case 4  : return p.VFMSUB213PD(v[0], v[1], v[2], v[3])
  7953          default : panic("instruction VFMSUB213PD takes 3 or 4 operands")
  7954      }
  7955  }
  7956  
  7957  func __asm_proxy_VFMSUB213PS__(p *Program, v ...interface{}) *Instruction {
  7958      switch len(v) {
  7959          case 3  : return p.VFMSUB213PS(v[0], v[1], v[2])
  7960          case 4  : return p.VFMSUB213PS(v[0], v[1], v[2], v[3])
  7961          default : panic("instruction VFMSUB213PS takes 3 or 4 operands")
  7962      }
  7963  }
  7964  
  7965  func __asm_proxy_VFMSUB213SD__(p *Program, v ...interface{}) *Instruction {
  7966      switch len(v) {
  7967          case 3  : return p.VFMSUB213SD(v[0], v[1], v[2])
  7968          case 4  : return p.VFMSUB213SD(v[0], v[1], v[2], v[3])
  7969          default : panic("instruction VFMSUB213SD takes 3 or 4 operands")
  7970      }
  7971  }
  7972  
  7973  func __asm_proxy_VFMSUB213SS__(p *Program, v ...interface{}) *Instruction {
  7974      switch len(v) {
  7975          case 3  : return p.VFMSUB213SS(v[0], v[1], v[2])
  7976          case 4  : return p.VFMSUB213SS(v[0], v[1], v[2], v[3])
  7977          default : panic("instruction VFMSUB213SS takes 3 or 4 operands")
  7978      }
  7979  }
  7980  
  7981  func __asm_proxy_VFMSUB231PD__(p *Program, v ...interface{}) *Instruction {
  7982      switch len(v) {
  7983          case 3  : return p.VFMSUB231PD(v[0], v[1], v[2])
  7984          case 4  : return p.VFMSUB231PD(v[0], v[1], v[2], v[3])
  7985          default : panic("instruction VFMSUB231PD takes 3 or 4 operands")
  7986      }
  7987  }
  7988  
  7989  func __asm_proxy_VFMSUB231PS__(p *Program, v ...interface{}) *Instruction {
  7990      switch len(v) {
  7991          case 3  : return p.VFMSUB231PS(v[0], v[1], v[2])
  7992          case 4  : return p.VFMSUB231PS(v[0], v[1], v[2], v[3])
  7993          default : panic("instruction VFMSUB231PS takes 3 or 4 operands")
  7994      }
  7995  }
  7996  
  7997  func __asm_proxy_VFMSUB231SD__(p *Program, v ...interface{}) *Instruction {
  7998      switch len(v) {
  7999          case 3  : return p.VFMSUB231SD(v[0], v[1], v[2])
  8000          case 4  : return p.VFMSUB231SD(v[0], v[1], v[2], v[3])
  8001          default : panic("instruction VFMSUB231SD takes 3 or 4 operands")
  8002      }
  8003  }
  8004  
  8005  func __asm_proxy_VFMSUB231SS__(p *Program, v ...interface{}) *Instruction {
  8006      switch len(v) {
  8007          case 3  : return p.VFMSUB231SS(v[0], v[1], v[2])
  8008          case 4  : return p.VFMSUB231SS(v[0], v[1], v[2], v[3])
  8009          default : panic("instruction VFMSUB231SS takes 3 or 4 operands")
  8010      }
  8011  }
  8012  
  8013  func __asm_proxy_VFMSUBADD132PD__(p *Program, v ...interface{}) *Instruction {
  8014      switch len(v) {
  8015          case 3  : return p.VFMSUBADD132PD(v[0], v[1], v[2])
  8016          case 4  : return p.VFMSUBADD132PD(v[0], v[1], v[2], v[3])
  8017          default : panic("instruction VFMSUBADD132PD takes 3 or 4 operands")
  8018      }
  8019  }
  8020  
  8021  func __asm_proxy_VFMSUBADD132PS__(p *Program, v ...interface{}) *Instruction {
  8022      switch len(v) {
  8023          case 3  : return p.VFMSUBADD132PS(v[0], v[1], v[2])
  8024          case 4  : return p.VFMSUBADD132PS(v[0], v[1], v[2], v[3])
  8025          default : panic("instruction VFMSUBADD132PS takes 3 or 4 operands")
  8026      }
  8027  }
  8028  
  8029  func __asm_proxy_VFMSUBADD213PD__(p *Program, v ...interface{}) *Instruction {
  8030      switch len(v) {
  8031          case 3  : return p.VFMSUBADD213PD(v[0], v[1], v[2])
  8032          case 4  : return p.VFMSUBADD213PD(v[0], v[1], v[2], v[3])
  8033          default : panic("instruction VFMSUBADD213PD takes 3 or 4 operands")
  8034      }
  8035  }
  8036  
  8037  func __asm_proxy_VFMSUBADD213PS__(p *Program, v ...interface{}) *Instruction {
  8038      switch len(v) {
  8039          case 3  : return p.VFMSUBADD213PS(v[0], v[1], v[2])
  8040          case 4  : return p.VFMSUBADD213PS(v[0], v[1], v[2], v[3])
  8041          default : panic("instruction VFMSUBADD213PS takes 3 or 4 operands")
  8042      }
  8043  }
  8044  
  8045  func __asm_proxy_VFMSUBADD231PD__(p *Program, v ...interface{}) *Instruction {
  8046      switch len(v) {
  8047          case 3  : return p.VFMSUBADD231PD(v[0], v[1], v[2])
  8048          case 4  : return p.VFMSUBADD231PD(v[0], v[1], v[2], v[3])
  8049          default : panic("instruction VFMSUBADD231PD takes 3 or 4 operands")
  8050      }
  8051  }
  8052  
  8053  func __asm_proxy_VFMSUBADD231PS__(p *Program, v ...interface{}) *Instruction {
  8054      switch len(v) {
  8055          case 3  : return p.VFMSUBADD231PS(v[0], v[1], v[2])
  8056          case 4  : return p.VFMSUBADD231PS(v[0], v[1], v[2], v[3])
  8057          default : panic("instruction VFMSUBADD231PS takes 3 or 4 operands")
  8058      }
  8059  }
  8060  
  8061  func __asm_proxy_VFMSUBADDPD__(p *Program, v ...interface{}) *Instruction {
  8062      if len(v) == 4 {
  8063          return p.VFMSUBADDPD(v[0], v[1], v[2], v[3])
  8064      } else {
  8065          panic("instruction VFMSUBADDPD takes exactly 4 operands")
  8066      }
  8067  }
  8068  
  8069  func __asm_proxy_VFMSUBADDPS__(p *Program, v ...interface{}) *Instruction {
  8070      if len(v) == 4 {
  8071          return p.VFMSUBADDPS(v[0], v[1], v[2], v[3])
  8072      } else {
  8073          panic("instruction VFMSUBADDPS takes exactly 4 operands")
  8074      }
  8075  }
  8076  
  8077  func __asm_proxy_VFMSUBPD__(p *Program, v ...interface{}) *Instruction {
  8078      if len(v) == 4 {
  8079          return p.VFMSUBPD(v[0], v[1], v[2], v[3])
  8080      } else {
  8081          panic("instruction VFMSUBPD takes exactly 4 operands")
  8082      }
  8083  }
  8084  
  8085  func __asm_proxy_VFMSUBPS__(p *Program, v ...interface{}) *Instruction {
  8086      if len(v) == 4 {
  8087          return p.VFMSUBPS(v[0], v[1], v[2], v[3])
  8088      } else {
  8089          panic("instruction VFMSUBPS takes exactly 4 operands")
  8090      }
  8091  }
  8092  
  8093  func __asm_proxy_VFMSUBSD__(p *Program, v ...interface{}) *Instruction {
  8094      if len(v) == 4 {
  8095          return p.VFMSUBSD(v[0], v[1], v[2], v[3])
  8096      } else {
  8097          panic("instruction VFMSUBSD takes exactly 4 operands")
  8098      }
  8099  }
  8100  
  8101  func __asm_proxy_VFMSUBSS__(p *Program, v ...interface{}) *Instruction {
  8102      if len(v) == 4 {
  8103          return p.VFMSUBSS(v[0], v[1], v[2], v[3])
  8104      } else {
  8105          panic("instruction VFMSUBSS takes exactly 4 operands")
  8106      }
  8107  }
  8108  
  8109  func __asm_proxy_VFNMADD132PD__(p *Program, v ...interface{}) *Instruction {
  8110      switch len(v) {
  8111          case 3  : return p.VFNMADD132PD(v[0], v[1], v[2])
  8112          case 4  : return p.VFNMADD132PD(v[0], v[1], v[2], v[3])
  8113          default : panic("instruction VFNMADD132PD takes 3 or 4 operands")
  8114      }
  8115  }
  8116  
  8117  func __asm_proxy_VFNMADD132PS__(p *Program, v ...interface{}) *Instruction {
  8118      switch len(v) {
  8119          case 3  : return p.VFNMADD132PS(v[0], v[1], v[2])
  8120          case 4  : return p.VFNMADD132PS(v[0], v[1], v[2], v[3])
  8121          default : panic("instruction VFNMADD132PS takes 3 or 4 operands")
  8122      }
  8123  }
  8124  
  8125  func __asm_proxy_VFNMADD132SD__(p *Program, v ...interface{}) *Instruction {
  8126      switch len(v) {
  8127          case 3  : return p.VFNMADD132SD(v[0], v[1], v[2])
  8128          case 4  : return p.VFNMADD132SD(v[0], v[1], v[2], v[3])
  8129          default : panic("instruction VFNMADD132SD takes 3 or 4 operands")
  8130      }
  8131  }
  8132  
  8133  func __asm_proxy_VFNMADD132SS__(p *Program, v ...interface{}) *Instruction {
  8134      switch len(v) {
  8135          case 3  : return p.VFNMADD132SS(v[0], v[1], v[2])
  8136          case 4  : return p.VFNMADD132SS(v[0], v[1], v[2], v[3])
  8137          default : panic("instruction VFNMADD132SS takes 3 or 4 operands")
  8138      }
  8139  }
  8140  
  8141  func __asm_proxy_VFNMADD213PD__(p *Program, v ...interface{}) *Instruction {
  8142      switch len(v) {
  8143          case 3  : return p.VFNMADD213PD(v[0], v[1], v[2])
  8144          case 4  : return p.VFNMADD213PD(v[0], v[1], v[2], v[3])
  8145          default : panic("instruction VFNMADD213PD takes 3 or 4 operands")
  8146      }
  8147  }
  8148  
  8149  func __asm_proxy_VFNMADD213PS__(p *Program, v ...interface{}) *Instruction {
  8150      switch len(v) {
  8151          case 3  : return p.VFNMADD213PS(v[0], v[1], v[2])
  8152          case 4  : return p.VFNMADD213PS(v[0], v[1], v[2], v[3])
  8153          default : panic("instruction VFNMADD213PS takes 3 or 4 operands")
  8154      }
  8155  }
  8156  
  8157  func __asm_proxy_VFNMADD213SD__(p *Program, v ...interface{}) *Instruction {
  8158      switch len(v) {
  8159          case 3  : return p.VFNMADD213SD(v[0], v[1], v[2])
  8160          case 4  : return p.VFNMADD213SD(v[0], v[1], v[2], v[3])
  8161          default : panic("instruction VFNMADD213SD takes 3 or 4 operands")
  8162      }
  8163  }
  8164  
  8165  func __asm_proxy_VFNMADD213SS__(p *Program, v ...interface{}) *Instruction {
  8166      switch len(v) {
  8167          case 3  : return p.VFNMADD213SS(v[0], v[1], v[2])
  8168          case 4  : return p.VFNMADD213SS(v[0], v[1], v[2], v[3])
  8169          default : panic("instruction VFNMADD213SS takes 3 or 4 operands")
  8170      }
  8171  }
  8172  
  8173  func __asm_proxy_VFNMADD231PD__(p *Program, v ...interface{}) *Instruction {
  8174      switch len(v) {
  8175          case 3  : return p.VFNMADD231PD(v[0], v[1], v[2])
  8176          case 4  : return p.VFNMADD231PD(v[0], v[1], v[2], v[3])
  8177          default : panic("instruction VFNMADD231PD takes 3 or 4 operands")
  8178      }
  8179  }
  8180  
  8181  func __asm_proxy_VFNMADD231PS__(p *Program, v ...interface{}) *Instruction {
  8182      switch len(v) {
  8183          case 3  : return p.VFNMADD231PS(v[0], v[1], v[2])
  8184          case 4  : return p.VFNMADD231PS(v[0], v[1], v[2], v[3])
  8185          default : panic("instruction VFNMADD231PS takes 3 or 4 operands")
  8186      }
  8187  }
  8188  
  8189  func __asm_proxy_VFNMADD231SD__(p *Program, v ...interface{}) *Instruction {
  8190      switch len(v) {
  8191          case 3  : return p.VFNMADD231SD(v[0], v[1], v[2])
  8192          case 4  : return p.VFNMADD231SD(v[0], v[1], v[2], v[3])
  8193          default : panic("instruction VFNMADD231SD takes 3 or 4 operands")
  8194      }
  8195  }
  8196  
  8197  func __asm_proxy_VFNMADD231SS__(p *Program, v ...interface{}) *Instruction {
  8198      switch len(v) {
  8199          case 3  : return p.VFNMADD231SS(v[0], v[1], v[2])
  8200          case 4  : return p.VFNMADD231SS(v[0], v[1], v[2], v[3])
  8201          default : panic("instruction VFNMADD231SS takes 3 or 4 operands")
  8202      }
  8203  }
  8204  
  8205  func __asm_proxy_VFNMADDPD__(p *Program, v ...interface{}) *Instruction {
  8206      if len(v) == 4 {
  8207          return p.VFNMADDPD(v[0], v[1], v[2], v[3])
  8208      } else {
  8209          panic("instruction VFNMADDPD takes exactly 4 operands")
  8210      }
  8211  }
  8212  
  8213  func __asm_proxy_VFNMADDPS__(p *Program, v ...interface{}) *Instruction {
  8214      if len(v) == 4 {
  8215          return p.VFNMADDPS(v[0], v[1], v[2], v[3])
  8216      } else {
  8217          panic("instruction VFNMADDPS takes exactly 4 operands")
  8218      }
  8219  }
  8220  
  8221  func __asm_proxy_VFNMADDSD__(p *Program, v ...interface{}) *Instruction {
  8222      if len(v) == 4 {
  8223          return p.VFNMADDSD(v[0], v[1], v[2], v[3])
  8224      } else {
  8225          panic("instruction VFNMADDSD takes exactly 4 operands")
  8226      }
  8227  }
  8228  
  8229  func __asm_proxy_VFNMADDSS__(p *Program, v ...interface{}) *Instruction {
  8230      if len(v) == 4 {
  8231          return p.VFNMADDSS(v[0], v[1], v[2], v[3])
  8232      } else {
  8233          panic("instruction VFNMADDSS takes exactly 4 operands")
  8234      }
  8235  }
  8236  
  8237  func __asm_proxy_VFNMSUB132PD__(p *Program, v ...interface{}) *Instruction {
  8238      switch len(v) {
  8239          case 3  : return p.VFNMSUB132PD(v[0], v[1], v[2])
  8240          case 4  : return p.VFNMSUB132PD(v[0], v[1], v[2], v[3])
  8241          default : panic("instruction VFNMSUB132PD takes 3 or 4 operands")
  8242      }
  8243  }
  8244  
  8245  func __asm_proxy_VFNMSUB132PS__(p *Program, v ...interface{}) *Instruction {
  8246      switch len(v) {
  8247          case 3  : return p.VFNMSUB132PS(v[0], v[1], v[2])
  8248          case 4  : return p.VFNMSUB132PS(v[0], v[1], v[2], v[3])
  8249          default : panic("instruction VFNMSUB132PS takes 3 or 4 operands")
  8250      }
  8251  }
  8252  
  8253  func __asm_proxy_VFNMSUB132SD__(p *Program, v ...interface{}) *Instruction {
  8254      switch len(v) {
  8255          case 3  : return p.VFNMSUB132SD(v[0], v[1], v[2])
  8256          case 4  : return p.VFNMSUB132SD(v[0], v[1], v[2], v[3])
  8257          default : panic("instruction VFNMSUB132SD takes 3 or 4 operands")
  8258      }
  8259  }
  8260  
  8261  func __asm_proxy_VFNMSUB132SS__(p *Program, v ...interface{}) *Instruction {
  8262      switch len(v) {
  8263          case 3  : return p.VFNMSUB132SS(v[0], v[1], v[2])
  8264          case 4  : return p.VFNMSUB132SS(v[0], v[1], v[2], v[3])
  8265          default : panic("instruction VFNMSUB132SS takes 3 or 4 operands")
  8266      }
  8267  }
  8268  
  8269  func __asm_proxy_VFNMSUB213PD__(p *Program, v ...interface{}) *Instruction {
  8270      switch len(v) {
  8271          case 3  : return p.VFNMSUB213PD(v[0], v[1], v[2])
  8272          case 4  : return p.VFNMSUB213PD(v[0], v[1], v[2], v[3])
  8273          default : panic("instruction VFNMSUB213PD takes 3 or 4 operands")
  8274      }
  8275  }
  8276  
  8277  func __asm_proxy_VFNMSUB213PS__(p *Program, v ...interface{}) *Instruction {
  8278      switch len(v) {
  8279          case 3  : return p.VFNMSUB213PS(v[0], v[1], v[2])
  8280          case 4  : return p.VFNMSUB213PS(v[0], v[1], v[2], v[3])
  8281          default : panic("instruction VFNMSUB213PS takes 3 or 4 operands")
  8282      }
  8283  }
  8284  
  8285  func __asm_proxy_VFNMSUB213SD__(p *Program, v ...interface{}) *Instruction {
  8286      switch len(v) {
  8287          case 3  : return p.VFNMSUB213SD(v[0], v[1], v[2])
  8288          case 4  : return p.VFNMSUB213SD(v[0], v[1], v[2], v[3])
  8289          default : panic("instruction VFNMSUB213SD takes 3 or 4 operands")
  8290      }
  8291  }
  8292  
  8293  func __asm_proxy_VFNMSUB213SS__(p *Program, v ...interface{}) *Instruction {
  8294      switch len(v) {
  8295          case 3  : return p.VFNMSUB213SS(v[0], v[1], v[2])
  8296          case 4  : return p.VFNMSUB213SS(v[0], v[1], v[2], v[3])
  8297          default : panic("instruction VFNMSUB213SS takes 3 or 4 operands")
  8298      }
  8299  }
  8300  
  8301  func __asm_proxy_VFNMSUB231PD__(p *Program, v ...interface{}) *Instruction {
  8302      switch len(v) {
  8303          case 3  : return p.VFNMSUB231PD(v[0], v[1], v[2])
  8304          case 4  : return p.VFNMSUB231PD(v[0], v[1], v[2], v[3])
  8305          default : panic("instruction VFNMSUB231PD takes 3 or 4 operands")
  8306      }
  8307  }
  8308  
  8309  func __asm_proxy_VFNMSUB231PS__(p *Program, v ...interface{}) *Instruction {
  8310      switch len(v) {
  8311          case 3  : return p.VFNMSUB231PS(v[0], v[1], v[2])
  8312          case 4  : return p.VFNMSUB231PS(v[0], v[1], v[2], v[3])
  8313          default : panic("instruction VFNMSUB231PS takes 3 or 4 operands")
  8314      }
  8315  }
  8316  
  8317  func __asm_proxy_VFNMSUB231SD__(p *Program, v ...interface{}) *Instruction {
  8318      switch len(v) {
  8319          case 3  : return p.VFNMSUB231SD(v[0], v[1], v[2])
  8320          case 4  : return p.VFNMSUB231SD(v[0], v[1], v[2], v[3])
  8321          default : panic("instruction VFNMSUB231SD takes 3 or 4 operands")
  8322      }
  8323  }
  8324  
  8325  func __asm_proxy_VFNMSUB231SS__(p *Program, v ...interface{}) *Instruction {
  8326      switch len(v) {
  8327          case 3  : return p.VFNMSUB231SS(v[0], v[1], v[2])
  8328          case 4  : return p.VFNMSUB231SS(v[0], v[1], v[2], v[3])
  8329          default : panic("instruction VFNMSUB231SS takes 3 or 4 operands")
  8330      }
  8331  }
  8332  
  8333  func __asm_proxy_VFNMSUBPD__(p *Program, v ...interface{}) *Instruction {
  8334      if len(v) == 4 {
  8335          return p.VFNMSUBPD(v[0], v[1], v[2], v[3])
  8336      } else {
  8337          panic("instruction VFNMSUBPD takes exactly 4 operands")
  8338      }
  8339  }
  8340  
  8341  func __asm_proxy_VFNMSUBPS__(p *Program, v ...interface{}) *Instruction {
  8342      if len(v) == 4 {
  8343          return p.VFNMSUBPS(v[0], v[1], v[2], v[3])
  8344      } else {
  8345          panic("instruction VFNMSUBPS takes exactly 4 operands")
  8346      }
  8347  }
  8348  
  8349  func __asm_proxy_VFNMSUBSD__(p *Program, v ...interface{}) *Instruction {
  8350      if len(v) == 4 {
  8351          return p.VFNMSUBSD(v[0], v[1], v[2], v[3])
  8352      } else {
  8353          panic("instruction VFNMSUBSD takes exactly 4 operands")
  8354      }
  8355  }
  8356  
  8357  func __asm_proxy_VFNMSUBSS__(p *Program, v ...interface{}) *Instruction {
  8358      if len(v) == 4 {
  8359          return p.VFNMSUBSS(v[0], v[1], v[2], v[3])
  8360      } else {
  8361          panic("instruction VFNMSUBSS takes exactly 4 operands")
  8362      }
  8363  }
  8364  
  8365  func __asm_proxy_VFPCLASSPD__(p *Program, v ...interface{}) *Instruction {
  8366      if len(v) == 3 {
  8367          return p.VFPCLASSPD(v[0], v[1], v[2])
  8368      } else {
  8369          panic("instruction VFPCLASSPD takes exactly 3 operands")
  8370      }
  8371  }
  8372  
  8373  func __asm_proxy_VFPCLASSPS__(p *Program, v ...interface{}) *Instruction {
  8374      if len(v) == 3 {
  8375          return p.VFPCLASSPS(v[0], v[1], v[2])
  8376      } else {
  8377          panic("instruction VFPCLASSPS takes exactly 3 operands")
  8378      }
  8379  }
  8380  
  8381  func __asm_proxy_VFPCLASSSD__(p *Program, v ...interface{}) *Instruction {
  8382      if len(v) == 3 {
  8383          return p.VFPCLASSSD(v[0], v[1], v[2])
  8384      } else {
  8385          panic("instruction VFPCLASSSD takes exactly 3 operands")
  8386      }
  8387  }
  8388  
  8389  func __asm_proxy_VFPCLASSSS__(p *Program, v ...interface{}) *Instruction {
  8390      if len(v) == 3 {
  8391          return p.VFPCLASSSS(v[0], v[1], v[2])
  8392      } else {
  8393          panic("instruction VFPCLASSSS takes exactly 3 operands")
  8394      }
  8395  }
  8396  
  8397  func __asm_proxy_VFRCZPD__(p *Program, v ...interface{}) *Instruction {
  8398      if len(v) == 2 {
  8399          return p.VFRCZPD(v[0], v[1])
  8400      } else {
  8401          panic("instruction VFRCZPD takes exactly 2 operands")
  8402      }
  8403  }
  8404  
  8405  func __asm_proxy_VFRCZPS__(p *Program, v ...interface{}) *Instruction {
  8406      if len(v) == 2 {
  8407          return p.VFRCZPS(v[0], v[1])
  8408      } else {
  8409          panic("instruction VFRCZPS takes exactly 2 operands")
  8410      }
  8411  }
  8412  
  8413  func __asm_proxy_VFRCZSD__(p *Program, v ...interface{}) *Instruction {
  8414      if len(v) == 2 {
  8415          return p.VFRCZSD(v[0], v[1])
  8416      } else {
  8417          panic("instruction VFRCZSD takes exactly 2 operands")
  8418      }
  8419  }
  8420  
  8421  func __asm_proxy_VFRCZSS__(p *Program, v ...interface{}) *Instruction {
  8422      if len(v) == 2 {
  8423          return p.VFRCZSS(v[0], v[1])
  8424      } else {
  8425          panic("instruction VFRCZSS takes exactly 2 operands")
  8426      }
  8427  }
  8428  
  8429  func __asm_proxy_VGATHERDPD__(p *Program, v ...interface{}) *Instruction {
  8430      switch len(v) {
  8431          case 2  : return p.VGATHERDPD(v[0], v[1])
  8432          case 3  : return p.VGATHERDPD(v[0], v[1], v[2])
  8433          default : panic("instruction VGATHERDPD takes 2 or 3 operands")
  8434      }
  8435  }
  8436  
  8437  func __asm_proxy_VGATHERDPS__(p *Program, v ...interface{}) *Instruction {
  8438      switch len(v) {
  8439          case 2  : return p.VGATHERDPS(v[0], v[1])
  8440          case 3  : return p.VGATHERDPS(v[0], v[1], v[2])
  8441          default : panic("instruction VGATHERDPS takes 2 or 3 operands")
  8442      }
  8443  }
  8444  
  8445  func __asm_proxy_VGATHERPF0DPD__(p *Program, v ...interface{}) *Instruction {
  8446      if len(v) == 1 {
  8447          return p.VGATHERPF0DPD(v[0])
  8448      } else {
  8449          panic("instruction VGATHERPF0DPD takes exactly 1 operand")
  8450      }
  8451  }
  8452  
  8453  func __asm_proxy_VGATHERPF0DPS__(p *Program, v ...interface{}) *Instruction {
  8454      if len(v) == 1 {
  8455          return p.VGATHERPF0DPS(v[0])
  8456      } else {
  8457          panic("instruction VGATHERPF0DPS takes exactly 1 operand")
  8458      }
  8459  }
  8460  
  8461  func __asm_proxy_VGATHERPF0QPD__(p *Program, v ...interface{}) *Instruction {
  8462      if len(v) == 1 {
  8463          return p.VGATHERPF0QPD(v[0])
  8464      } else {
  8465          panic("instruction VGATHERPF0QPD takes exactly 1 operand")
  8466      }
  8467  }
  8468  
  8469  func __asm_proxy_VGATHERPF0QPS__(p *Program, v ...interface{}) *Instruction {
  8470      if len(v) == 1 {
  8471          return p.VGATHERPF0QPS(v[0])
  8472      } else {
  8473          panic("instruction VGATHERPF0QPS takes exactly 1 operand")
  8474      }
  8475  }
  8476  
  8477  func __asm_proxy_VGATHERPF1DPD__(p *Program, v ...interface{}) *Instruction {
  8478      if len(v) == 1 {
  8479          return p.VGATHERPF1DPD(v[0])
  8480      } else {
  8481          panic("instruction VGATHERPF1DPD takes exactly 1 operand")
  8482      }
  8483  }
  8484  
  8485  func __asm_proxy_VGATHERPF1DPS__(p *Program, v ...interface{}) *Instruction {
  8486      if len(v) == 1 {
  8487          return p.VGATHERPF1DPS(v[0])
  8488      } else {
  8489          panic("instruction VGATHERPF1DPS takes exactly 1 operand")
  8490      }
  8491  }
  8492  
  8493  func __asm_proxy_VGATHERPF1QPD__(p *Program, v ...interface{}) *Instruction {
  8494      if len(v) == 1 {
  8495          return p.VGATHERPF1QPD(v[0])
  8496      } else {
  8497          panic("instruction VGATHERPF1QPD takes exactly 1 operand")
  8498      }
  8499  }
  8500  
  8501  func __asm_proxy_VGATHERPF1QPS__(p *Program, v ...interface{}) *Instruction {
  8502      if len(v) == 1 {
  8503          return p.VGATHERPF1QPS(v[0])
  8504      } else {
  8505          panic("instruction VGATHERPF1QPS takes exactly 1 operand")
  8506      }
  8507  }
  8508  
  8509  func __asm_proxy_VGATHERQPD__(p *Program, v ...interface{}) *Instruction {
  8510      switch len(v) {
  8511          case 2  : return p.VGATHERQPD(v[0], v[1])
  8512          case 3  : return p.VGATHERQPD(v[0], v[1], v[2])
  8513          default : panic("instruction VGATHERQPD takes 2 or 3 operands")
  8514      }
  8515  }
  8516  
  8517  func __asm_proxy_VGATHERQPS__(p *Program, v ...interface{}) *Instruction {
  8518      switch len(v) {
  8519          case 2  : return p.VGATHERQPS(v[0], v[1])
  8520          case 3  : return p.VGATHERQPS(v[0], v[1], v[2])
  8521          default : panic("instruction VGATHERQPS takes 2 or 3 operands")
  8522      }
  8523  }
  8524  
  8525  func __asm_proxy_VGETEXPPD__(p *Program, v ...interface{}) *Instruction {
  8526      switch len(v) {
  8527          case 2  : return p.VGETEXPPD(v[0], v[1])
  8528          case 3  : return p.VGETEXPPD(v[0], v[1], v[2])
  8529          default : panic("instruction VGETEXPPD takes 2 or 3 operands")
  8530      }
  8531  }
  8532  
  8533  func __asm_proxy_VGETEXPPS__(p *Program, v ...interface{}) *Instruction {
  8534      switch len(v) {
  8535          case 2  : return p.VGETEXPPS(v[0], v[1])
  8536          case 3  : return p.VGETEXPPS(v[0], v[1], v[2])
  8537          default : panic("instruction VGETEXPPS takes 2 or 3 operands")
  8538      }
  8539  }
  8540  
  8541  func __asm_proxy_VGETEXPSD__(p *Program, v ...interface{}) *Instruction {
  8542      switch len(v) {
  8543          case 3  : return p.VGETEXPSD(v[0], v[1], v[2])
  8544          case 4  : return p.VGETEXPSD(v[0], v[1], v[2], v[3])
  8545          default : panic("instruction VGETEXPSD takes 3 or 4 operands")
  8546      }
  8547  }
  8548  
  8549  func __asm_proxy_VGETEXPSS__(p *Program, v ...interface{}) *Instruction {
  8550      switch len(v) {
  8551          case 3  : return p.VGETEXPSS(v[0], v[1], v[2])
  8552          case 4  : return p.VGETEXPSS(v[0], v[1], v[2], v[3])
  8553          default : panic("instruction VGETEXPSS takes 3 or 4 operands")
  8554      }
  8555  }
  8556  
  8557  func __asm_proxy_VGETMANTPD__(p *Program, v ...interface{}) *Instruction {
  8558      switch len(v) {
  8559          case 3  : return p.VGETMANTPD(v[0], v[1], v[2])
  8560          case 4  : return p.VGETMANTPD(v[0], v[1], v[2], v[3])
  8561          default : panic("instruction VGETMANTPD takes 3 or 4 operands")
  8562      }
  8563  }
  8564  
  8565  func __asm_proxy_VGETMANTPS__(p *Program, v ...interface{}) *Instruction {
  8566      switch len(v) {
  8567          case 3  : return p.VGETMANTPS(v[0], v[1], v[2])
  8568          case 4  : return p.VGETMANTPS(v[0], v[1], v[2], v[3])
  8569          default : panic("instruction VGETMANTPS takes 3 or 4 operands")
  8570      }
  8571  }
  8572  
  8573  func __asm_proxy_VGETMANTSD__(p *Program, v ...interface{}) *Instruction {
  8574      switch len(v) {
  8575          case 4  : return p.VGETMANTSD(v[0], v[1], v[2], v[3])
  8576          case 5  : return p.VGETMANTSD(v[0], v[1], v[2], v[3], v[4])
  8577          default : panic("instruction VGETMANTSD takes 4 or 5 operands")
  8578      }
  8579  }
  8580  
  8581  func __asm_proxy_VGETMANTSS__(p *Program, v ...interface{}) *Instruction {
  8582      switch len(v) {
  8583          case 4  : return p.VGETMANTSS(v[0], v[1], v[2], v[3])
  8584          case 5  : return p.VGETMANTSS(v[0], v[1], v[2], v[3], v[4])
  8585          default : panic("instruction VGETMANTSS takes 4 or 5 operands")
  8586      }
  8587  }
  8588  
  8589  func __asm_proxy_VHADDPD__(p *Program, v ...interface{}) *Instruction {
  8590      if len(v) == 3 {
  8591          return p.VHADDPD(v[0], v[1], v[2])
  8592      } else {
  8593          panic("instruction VHADDPD takes exactly 3 operands")
  8594      }
  8595  }
  8596  
  8597  func __asm_proxy_VHADDPS__(p *Program, v ...interface{}) *Instruction {
  8598      if len(v) == 3 {
  8599          return p.VHADDPS(v[0], v[1], v[2])
  8600      } else {
  8601          panic("instruction VHADDPS takes exactly 3 operands")
  8602      }
  8603  }
  8604  
  8605  func __asm_proxy_VHSUBPD__(p *Program, v ...interface{}) *Instruction {
  8606      if len(v) == 3 {
  8607          return p.VHSUBPD(v[0], v[1], v[2])
  8608      } else {
  8609          panic("instruction VHSUBPD takes exactly 3 operands")
  8610      }
  8611  }
  8612  
  8613  func __asm_proxy_VHSUBPS__(p *Program, v ...interface{}) *Instruction {
  8614      if len(v) == 3 {
  8615          return p.VHSUBPS(v[0], v[1], v[2])
  8616      } else {
  8617          panic("instruction VHSUBPS takes exactly 3 operands")
  8618      }
  8619  }
  8620  
  8621  func __asm_proxy_VINSERTF128__(p *Program, v ...interface{}) *Instruction {
  8622      if len(v) == 4 {
  8623          return p.VINSERTF128(v[0], v[1], v[2], v[3])
  8624      } else {
  8625          panic("instruction VINSERTF128 takes exactly 4 operands")
  8626      }
  8627  }
  8628  
  8629  func __asm_proxy_VINSERTF32X4__(p *Program, v ...interface{}) *Instruction {
  8630      if len(v) == 4 {
  8631          return p.VINSERTF32X4(v[0], v[1], v[2], v[3])
  8632      } else {
  8633          panic("instruction VINSERTF32X4 takes exactly 4 operands")
  8634      }
  8635  }
  8636  
  8637  func __asm_proxy_VINSERTF32X8__(p *Program, v ...interface{}) *Instruction {
  8638      if len(v) == 4 {
  8639          return p.VINSERTF32X8(v[0], v[1], v[2], v[3])
  8640      } else {
  8641          panic("instruction VINSERTF32X8 takes exactly 4 operands")
  8642      }
  8643  }
  8644  
  8645  func __asm_proxy_VINSERTF64X2__(p *Program, v ...interface{}) *Instruction {
  8646      if len(v) == 4 {
  8647          return p.VINSERTF64X2(v[0], v[1], v[2], v[3])
  8648      } else {
  8649          panic("instruction VINSERTF64X2 takes exactly 4 operands")
  8650      }
  8651  }
  8652  
  8653  func __asm_proxy_VINSERTF64X4__(p *Program, v ...interface{}) *Instruction {
  8654      if len(v) == 4 {
  8655          return p.VINSERTF64X4(v[0], v[1], v[2], v[3])
  8656      } else {
  8657          panic("instruction VINSERTF64X4 takes exactly 4 operands")
  8658      }
  8659  }
  8660  
  8661  func __asm_proxy_VINSERTI128__(p *Program, v ...interface{}) *Instruction {
  8662      if len(v) == 4 {
  8663          return p.VINSERTI128(v[0], v[1], v[2], v[3])
  8664      } else {
  8665          panic("instruction VINSERTI128 takes exactly 4 operands")
  8666      }
  8667  }
  8668  
  8669  func __asm_proxy_VINSERTI32X4__(p *Program, v ...interface{}) *Instruction {
  8670      if len(v) == 4 {
  8671          return p.VINSERTI32X4(v[0], v[1], v[2], v[3])
  8672      } else {
  8673          panic("instruction VINSERTI32X4 takes exactly 4 operands")
  8674      }
  8675  }
  8676  
  8677  func __asm_proxy_VINSERTI32X8__(p *Program, v ...interface{}) *Instruction {
  8678      if len(v) == 4 {
  8679          return p.VINSERTI32X8(v[0], v[1], v[2], v[3])
  8680      } else {
  8681          panic("instruction VINSERTI32X8 takes exactly 4 operands")
  8682      }
  8683  }
  8684  
  8685  func __asm_proxy_VINSERTI64X2__(p *Program, v ...interface{}) *Instruction {
  8686      if len(v) == 4 {
  8687          return p.VINSERTI64X2(v[0], v[1], v[2], v[3])
  8688      } else {
  8689          panic("instruction VINSERTI64X2 takes exactly 4 operands")
  8690      }
  8691  }
  8692  
  8693  func __asm_proxy_VINSERTI64X4__(p *Program, v ...interface{}) *Instruction {
  8694      if len(v) == 4 {
  8695          return p.VINSERTI64X4(v[0], v[1], v[2], v[3])
  8696      } else {
  8697          panic("instruction VINSERTI64X4 takes exactly 4 operands")
  8698      }
  8699  }
  8700  
  8701  func __asm_proxy_VINSERTPS__(p *Program, v ...interface{}) *Instruction {
  8702      if len(v) == 4 {
  8703          return p.VINSERTPS(v[0], v[1], v[2], v[3])
  8704      } else {
  8705          panic("instruction VINSERTPS takes exactly 4 operands")
  8706      }
  8707  }
  8708  
  8709  func __asm_proxy_VLDDQU__(p *Program, v ...interface{}) *Instruction {
  8710      if len(v) == 2 {
  8711          return p.VLDDQU(v[0], v[1])
  8712      } else {
  8713          panic("instruction VLDDQU takes exactly 2 operands")
  8714      }
  8715  }
  8716  
  8717  func __asm_proxy_VLDMXCSR__(p *Program, v ...interface{}) *Instruction {
  8718      if len(v) == 1 {
  8719          return p.VLDMXCSR(v[0])
  8720      } else {
  8721          panic("instruction VLDMXCSR takes exactly 1 operand")
  8722      }
  8723  }
  8724  
  8725  func __asm_proxy_VMASKMOVDQU__(p *Program, v ...interface{}) *Instruction {
  8726      if len(v) == 2 {
  8727          return p.VMASKMOVDQU(v[0], v[1])
  8728      } else {
  8729          panic("instruction VMASKMOVDQU takes exactly 2 operands")
  8730      }
  8731  }
  8732  
  8733  func __asm_proxy_VMASKMOVPD__(p *Program, v ...interface{}) *Instruction {
  8734      if len(v) == 3 {
  8735          return p.VMASKMOVPD(v[0], v[1], v[2])
  8736      } else {
  8737          panic("instruction VMASKMOVPD takes exactly 3 operands")
  8738      }
  8739  }
  8740  
  8741  func __asm_proxy_VMASKMOVPS__(p *Program, v ...interface{}) *Instruction {
  8742      if len(v) == 3 {
  8743          return p.VMASKMOVPS(v[0], v[1], v[2])
  8744      } else {
  8745          panic("instruction VMASKMOVPS takes exactly 3 operands")
  8746      }
  8747  }
  8748  
  8749  func __asm_proxy_VMAXPD__(p *Program, v ...interface{}) *Instruction {
  8750      switch len(v) {
  8751          case 3  : return p.VMAXPD(v[0], v[1], v[2])
  8752          case 4  : return p.VMAXPD(v[0], v[1], v[2], v[3])
  8753          default : panic("instruction VMAXPD takes 3 or 4 operands")
  8754      }
  8755  }
  8756  
  8757  func __asm_proxy_VMAXPS__(p *Program, v ...interface{}) *Instruction {
  8758      switch len(v) {
  8759          case 3  : return p.VMAXPS(v[0], v[1], v[2])
  8760          case 4  : return p.VMAXPS(v[0], v[1], v[2], v[3])
  8761          default : panic("instruction VMAXPS takes 3 or 4 operands")
  8762      }
  8763  }
  8764  
  8765  func __asm_proxy_VMAXSD__(p *Program, v ...interface{}) *Instruction {
  8766      switch len(v) {
  8767          case 3  : return p.VMAXSD(v[0], v[1], v[2])
  8768          case 4  : return p.VMAXSD(v[0], v[1], v[2], v[3])
  8769          default : panic("instruction VMAXSD takes 3 or 4 operands")
  8770      }
  8771  }
  8772  
  8773  func __asm_proxy_VMAXSS__(p *Program, v ...interface{}) *Instruction {
  8774      switch len(v) {
  8775          case 3  : return p.VMAXSS(v[0], v[1], v[2])
  8776          case 4  : return p.VMAXSS(v[0], v[1], v[2], v[3])
  8777          default : panic("instruction VMAXSS takes 3 or 4 operands")
  8778      }
  8779  }
  8780  
  8781  func __asm_proxy_VMINPD__(p *Program, v ...interface{}) *Instruction {
  8782      switch len(v) {
  8783          case 3  : return p.VMINPD(v[0], v[1], v[2])
  8784          case 4  : return p.VMINPD(v[0], v[1], v[2], v[3])
  8785          default : panic("instruction VMINPD takes 3 or 4 operands")
  8786      }
  8787  }
  8788  
  8789  func __asm_proxy_VMINPS__(p *Program, v ...interface{}) *Instruction {
  8790      switch len(v) {
  8791          case 3  : return p.VMINPS(v[0], v[1], v[2])
  8792          case 4  : return p.VMINPS(v[0], v[1], v[2], v[3])
  8793          default : panic("instruction VMINPS takes 3 or 4 operands")
  8794      }
  8795  }
  8796  
  8797  func __asm_proxy_VMINSD__(p *Program, v ...interface{}) *Instruction {
  8798      switch len(v) {
  8799          case 3  : return p.VMINSD(v[0], v[1], v[2])
  8800          case 4  : return p.VMINSD(v[0], v[1], v[2], v[3])
  8801          default : panic("instruction VMINSD takes 3 or 4 operands")
  8802      }
  8803  }
  8804  
  8805  func __asm_proxy_VMINSS__(p *Program, v ...interface{}) *Instruction {
  8806      switch len(v) {
  8807          case 3  : return p.VMINSS(v[0], v[1], v[2])
  8808          case 4  : return p.VMINSS(v[0], v[1], v[2], v[3])
  8809          default : panic("instruction VMINSS takes 3 or 4 operands")
  8810      }
  8811  }
  8812  
  8813  func __asm_proxy_VMOVAPD__(p *Program, v ...interface{}) *Instruction {
  8814      if len(v) == 2 {
  8815          return p.VMOVAPD(v[0], v[1])
  8816      } else {
  8817          panic("instruction VMOVAPD takes exactly 2 operands")
  8818      }
  8819  }
  8820  
  8821  func __asm_proxy_VMOVAPS__(p *Program, v ...interface{}) *Instruction {
  8822      if len(v) == 2 {
  8823          return p.VMOVAPS(v[0], v[1])
  8824      } else {
  8825          panic("instruction VMOVAPS takes exactly 2 operands")
  8826      }
  8827  }
  8828  
  8829  func __asm_proxy_VMOVD__(p *Program, v ...interface{}) *Instruction {
  8830      if len(v) == 2 {
  8831          return p.VMOVD(v[0], v[1])
  8832      } else {
  8833          panic("instruction VMOVD takes exactly 2 operands")
  8834      }
  8835  }
  8836  
  8837  func __asm_proxy_VMOVDDUP__(p *Program, v ...interface{}) *Instruction {
  8838      if len(v) == 2 {
  8839          return p.VMOVDDUP(v[0], v[1])
  8840      } else {
  8841          panic("instruction VMOVDDUP takes exactly 2 operands")
  8842      }
  8843  }
  8844  
  8845  func __asm_proxy_VMOVDQA__(p *Program, v ...interface{}) *Instruction {
  8846      if len(v) == 2 {
  8847          return p.VMOVDQA(v[0], v[1])
  8848      } else {
  8849          panic("instruction VMOVDQA takes exactly 2 operands")
  8850      }
  8851  }
  8852  
  8853  func __asm_proxy_VMOVDQA32__(p *Program, v ...interface{}) *Instruction {
  8854      if len(v) == 2 {
  8855          return p.VMOVDQA32(v[0], v[1])
  8856      } else {
  8857          panic("instruction VMOVDQA32 takes exactly 2 operands")
  8858      }
  8859  }
  8860  
  8861  func __asm_proxy_VMOVDQA64__(p *Program, v ...interface{}) *Instruction {
  8862      if len(v) == 2 {
  8863          return p.VMOVDQA64(v[0], v[1])
  8864      } else {
  8865          panic("instruction VMOVDQA64 takes exactly 2 operands")
  8866      }
  8867  }
  8868  
  8869  func __asm_proxy_VMOVDQU__(p *Program, v ...interface{}) *Instruction {
  8870      if len(v) == 2 {
  8871          return p.VMOVDQU(v[0], v[1])
  8872      } else {
  8873          panic("instruction VMOVDQU takes exactly 2 operands")
  8874      }
  8875  }
  8876  
  8877  func __asm_proxy_VMOVDQU16__(p *Program, v ...interface{}) *Instruction {
  8878      if len(v) == 2 {
  8879          return p.VMOVDQU16(v[0], v[1])
  8880      } else {
  8881          panic("instruction VMOVDQU16 takes exactly 2 operands")
  8882      }
  8883  }
  8884  
  8885  func __asm_proxy_VMOVDQU32__(p *Program, v ...interface{}) *Instruction {
  8886      if len(v) == 2 {
  8887          return p.VMOVDQU32(v[0], v[1])
  8888      } else {
  8889          panic("instruction VMOVDQU32 takes exactly 2 operands")
  8890      }
  8891  }
  8892  
  8893  func __asm_proxy_VMOVDQU64__(p *Program, v ...interface{}) *Instruction {
  8894      if len(v) == 2 {
  8895          return p.VMOVDQU64(v[0], v[1])
  8896      } else {
  8897          panic("instruction VMOVDQU64 takes exactly 2 operands")
  8898      }
  8899  }
  8900  
  8901  func __asm_proxy_VMOVDQU8__(p *Program, v ...interface{}) *Instruction {
  8902      if len(v) == 2 {
  8903          return p.VMOVDQU8(v[0], v[1])
  8904      } else {
  8905          panic("instruction VMOVDQU8 takes exactly 2 operands")
  8906      }
  8907  }
  8908  
  8909  func __asm_proxy_VMOVHLPS__(p *Program, v ...interface{}) *Instruction {
  8910      if len(v) == 3 {
  8911          return p.VMOVHLPS(v[0], v[1], v[2])
  8912      } else {
  8913          panic("instruction VMOVHLPS takes exactly 3 operands")
  8914      }
  8915  }
  8916  
  8917  func __asm_proxy_VMOVHPD__(p *Program, v ...interface{}) *Instruction {
  8918      switch len(v) {
  8919          case 2  : return p.VMOVHPD(v[0], v[1])
  8920          case 3  : return p.VMOVHPD(v[0], v[1], v[2])
  8921          default : panic("instruction VMOVHPD takes 2 or 3 operands")
  8922      }
  8923  }
  8924  
  8925  func __asm_proxy_VMOVHPS__(p *Program, v ...interface{}) *Instruction {
  8926      switch len(v) {
  8927          case 2  : return p.VMOVHPS(v[0], v[1])
  8928          case 3  : return p.VMOVHPS(v[0], v[1], v[2])
  8929          default : panic("instruction VMOVHPS takes 2 or 3 operands")
  8930      }
  8931  }
  8932  
  8933  func __asm_proxy_VMOVLHPS__(p *Program, v ...interface{}) *Instruction {
  8934      if len(v) == 3 {
  8935          return p.VMOVLHPS(v[0], v[1], v[2])
  8936      } else {
  8937          panic("instruction VMOVLHPS takes exactly 3 operands")
  8938      }
  8939  }
  8940  
  8941  func __asm_proxy_VMOVLPD__(p *Program, v ...interface{}) *Instruction {
  8942      switch len(v) {
  8943          case 2  : return p.VMOVLPD(v[0], v[1])
  8944          case 3  : return p.VMOVLPD(v[0], v[1], v[2])
  8945          default : panic("instruction VMOVLPD takes 2 or 3 operands")
  8946      }
  8947  }
  8948  
  8949  func __asm_proxy_VMOVLPS__(p *Program, v ...interface{}) *Instruction {
  8950      switch len(v) {
  8951          case 2  : return p.VMOVLPS(v[0], v[1])
  8952          case 3  : return p.VMOVLPS(v[0], v[1], v[2])
  8953          default : panic("instruction VMOVLPS takes 2 or 3 operands")
  8954      }
  8955  }
  8956  
  8957  func __asm_proxy_VMOVMSKPD__(p *Program, v ...interface{}) *Instruction {
  8958      if len(v) == 2 {
  8959          return p.VMOVMSKPD(v[0], v[1])
  8960      } else {
  8961          panic("instruction VMOVMSKPD takes exactly 2 operands")
  8962      }
  8963  }
  8964  
  8965  func __asm_proxy_VMOVMSKPS__(p *Program, v ...interface{}) *Instruction {
  8966      if len(v) == 2 {
  8967          return p.VMOVMSKPS(v[0], v[1])
  8968      } else {
  8969          panic("instruction VMOVMSKPS takes exactly 2 operands")
  8970      }
  8971  }
  8972  
  8973  func __asm_proxy_VMOVNTDQ__(p *Program, v ...interface{}) *Instruction {
  8974      if len(v) == 2 {
  8975          return p.VMOVNTDQ(v[0], v[1])
  8976      } else {
  8977          panic("instruction VMOVNTDQ takes exactly 2 operands")
  8978      }
  8979  }
  8980  
  8981  func __asm_proxy_VMOVNTDQA__(p *Program, v ...interface{}) *Instruction {
  8982      if len(v) == 2 {
  8983          return p.VMOVNTDQA(v[0], v[1])
  8984      } else {
  8985          panic("instruction VMOVNTDQA takes exactly 2 operands")
  8986      }
  8987  }
  8988  
  8989  func __asm_proxy_VMOVNTPD__(p *Program, v ...interface{}) *Instruction {
  8990      if len(v) == 2 {
  8991          return p.VMOVNTPD(v[0], v[1])
  8992      } else {
  8993          panic("instruction VMOVNTPD takes exactly 2 operands")
  8994      }
  8995  }
  8996  
  8997  func __asm_proxy_VMOVNTPS__(p *Program, v ...interface{}) *Instruction {
  8998      if len(v) == 2 {
  8999          return p.VMOVNTPS(v[0], v[1])
  9000      } else {
  9001          panic("instruction VMOVNTPS takes exactly 2 operands")
  9002      }
  9003  }
  9004  
  9005  func __asm_proxy_VMOVQ__(p *Program, v ...interface{}) *Instruction {
  9006      if len(v) == 2 {
  9007          return p.VMOVQ(v[0], v[1])
  9008      } else {
  9009          panic("instruction VMOVQ takes exactly 2 operands")
  9010      }
  9011  }
  9012  
  9013  func __asm_proxy_VMOVSD__(p *Program, v ...interface{}) *Instruction {
  9014      switch len(v) {
  9015          case 2  : return p.VMOVSD(v[0], v[1])
  9016          case 3  : return p.VMOVSD(v[0], v[1], v[2])
  9017          default : panic("instruction VMOVSD takes 2 or 3 operands")
  9018      }
  9019  }
  9020  
  9021  func __asm_proxy_VMOVSHDUP__(p *Program, v ...interface{}) *Instruction {
  9022      if len(v) == 2 {
  9023          return p.VMOVSHDUP(v[0], v[1])
  9024      } else {
  9025          panic("instruction VMOVSHDUP takes exactly 2 operands")
  9026      }
  9027  }
  9028  
  9029  func __asm_proxy_VMOVSLDUP__(p *Program, v ...interface{}) *Instruction {
  9030      if len(v) == 2 {
  9031          return p.VMOVSLDUP(v[0], v[1])
  9032      } else {
  9033          panic("instruction VMOVSLDUP takes exactly 2 operands")
  9034      }
  9035  }
  9036  
  9037  func __asm_proxy_VMOVSS__(p *Program, v ...interface{}) *Instruction {
  9038      switch len(v) {
  9039          case 2  : return p.VMOVSS(v[0], v[1])
  9040          case 3  : return p.VMOVSS(v[0], v[1], v[2])
  9041          default : panic("instruction VMOVSS takes 2 or 3 operands")
  9042      }
  9043  }
  9044  
  9045  func __asm_proxy_VMOVUPD__(p *Program, v ...interface{}) *Instruction {
  9046      if len(v) == 2 {
  9047          return p.VMOVUPD(v[0], v[1])
  9048      } else {
  9049          panic("instruction VMOVUPD takes exactly 2 operands")
  9050      }
  9051  }
  9052  
  9053  func __asm_proxy_VMOVUPS__(p *Program, v ...interface{}) *Instruction {
  9054      if len(v) == 2 {
  9055          return p.VMOVUPS(v[0], v[1])
  9056      } else {
  9057          panic("instruction VMOVUPS takes exactly 2 operands")
  9058      }
  9059  }
  9060  
  9061  func __asm_proxy_VMPSADBW__(p *Program, v ...interface{}) *Instruction {
  9062      if len(v) == 4 {
  9063          return p.VMPSADBW(v[0], v[1], v[2], v[3])
  9064      } else {
  9065          panic("instruction VMPSADBW takes exactly 4 operands")
  9066      }
  9067  }
  9068  
  9069  func __asm_proxy_VMULPD__(p *Program, v ...interface{}) *Instruction {
  9070      switch len(v) {
  9071          case 3  : return p.VMULPD(v[0], v[1], v[2])
  9072          case 4  : return p.VMULPD(v[0], v[1], v[2], v[3])
  9073          default : panic("instruction VMULPD takes 3 or 4 operands")
  9074      }
  9075  }
  9076  
  9077  func __asm_proxy_VMULPS__(p *Program, v ...interface{}) *Instruction {
  9078      switch len(v) {
  9079          case 3  : return p.VMULPS(v[0], v[1], v[2])
  9080          case 4  : return p.VMULPS(v[0], v[1], v[2], v[3])
  9081          default : panic("instruction VMULPS takes 3 or 4 operands")
  9082      }
  9083  }
  9084  
  9085  func __asm_proxy_VMULSD__(p *Program, v ...interface{}) *Instruction {
  9086      switch len(v) {
  9087          case 3  : return p.VMULSD(v[0], v[1], v[2])
  9088          case 4  : return p.VMULSD(v[0], v[1], v[2], v[3])
  9089          default : panic("instruction VMULSD takes 3 or 4 operands")
  9090      }
  9091  }
  9092  
  9093  func __asm_proxy_VMULSS__(p *Program, v ...interface{}) *Instruction {
  9094      switch len(v) {
  9095          case 3  : return p.VMULSS(v[0], v[1], v[2])
  9096          case 4  : return p.VMULSS(v[0], v[1], v[2], v[3])
  9097          default : panic("instruction VMULSS takes 3 or 4 operands")
  9098      }
  9099  }
  9100  
  9101  func __asm_proxy_VORPD__(p *Program, v ...interface{}) *Instruction {
  9102      if len(v) == 3 {
  9103          return p.VORPD(v[0], v[1], v[2])
  9104      } else {
  9105          panic("instruction VORPD takes exactly 3 operands")
  9106      }
  9107  }
  9108  
  9109  func __asm_proxy_VORPS__(p *Program, v ...interface{}) *Instruction {
  9110      if len(v) == 3 {
  9111          return p.VORPS(v[0], v[1], v[2])
  9112      } else {
  9113          panic("instruction VORPS takes exactly 3 operands")
  9114      }
  9115  }
  9116  
  9117  func __asm_proxy_VPABSB__(p *Program, v ...interface{}) *Instruction {
  9118      if len(v) == 2 {
  9119          return p.VPABSB(v[0], v[1])
  9120      } else {
  9121          panic("instruction VPABSB takes exactly 2 operands")
  9122      }
  9123  }
  9124  
  9125  func __asm_proxy_VPABSD__(p *Program, v ...interface{}) *Instruction {
  9126      if len(v) == 2 {
  9127          return p.VPABSD(v[0], v[1])
  9128      } else {
  9129          panic("instruction VPABSD takes exactly 2 operands")
  9130      }
  9131  }
  9132  
  9133  func __asm_proxy_VPABSQ__(p *Program, v ...interface{}) *Instruction {
  9134      if len(v) == 2 {
  9135          return p.VPABSQ(v[0], v[1])
  9136      } else {
  9137          panic("instruction VPABSQ takes exactly 2 operands")
  9138      }
  9139  }
  9140  
  9141  func __asm_proxy_VPABSW__(p *Program, v ...interface{}) *Instruction {
  9142      if len(v) == 2 {
  9143          return p.VPABSW(v[0], v[1])
  9144      } else {
  9145          panic("instruction VPABSW takes exactly 2 operands")
  9146      }
  9147  }
  9148  
  9149  func __asm_proxy_VPACKSSDW__(p *Program, v ...interface{}) *Instruction {
  9150      if len(v) == 3 {
  9151          return p.VPACKSSDW(v[0], v[1], v[2])
  9152      } else {
  9153          panic("instruction VPACKSSDW takes exactly 3 operands")
  9154      }
  9155  }
  9156  
  9157  func __asm_proxy_VPACKSSWB__(p *Program, v ...interface{}) *Instruction {
  9158      if len(v) == 3 {
  9159          return p.VPACKSSWB(v[0], v[1], v[2])
  9160      } else {
  9161          panic("instruction VPACKSSWB takes exactly 3 operands")
  9162      }
  9163  }
  9164  
  9165  func __asm_proxy_VPACKUSDW__(p *Program, v ...interface{}) *Instruction {
  9166      if len(v) == 3 {
  9167          return p.VPACKUSDW(v[0], v[1], v[2])
  9168      } else {
  9169          panic("instruction VPACKUSDW takes exactly 3 operands")
  9170      }
  9171  }
  9172  
  9173  func __asm_proxy_VPACKUSWB__(p *Program, v ...interface{}) *Instruction {
  9174      if len(v) == 3 {
  9175          return p.VPACKUSWB(v[0], v[1], v[2])
  9176      } else {
  9177          panic("instruction VPACKUSWB takes exactly 3 operands")
  9178      }
  9179  }
  9180  
  9181  func __asm_proxy_VPADDB__(p *Program, v ...interface{}) *Instruction {
  9182      if len(v) == 3 {
  9183          return p.VPADDB(v[0], v[1], v[2])
  9184      } else {
  9185          panic("instruction VPADDB takes exactly 3 operands")
  9186      }
  9187  }
  9188  
  9189  func __asm_proxy_VPADDD__(p *Program, v ...interface{}) *Instruction {
  9190      if len(v) == 3 {
  9191          return p.VPADDD(v[0], v[1], v[2])
  9192      } else {
  9193          panic("instruction VPADDD takes exactly 3 operands")
  9194      }
  9195  }
  9196  
  9197  func __asm_proxy_VPADDQ__(p *Program, v ...interface{}) *Instruction {
  9198      if len(v) == 3 {
  9199          return p.VPADDQ(v[0], v[1], v[2])
  9200      } else {
  9201          panic("instruction VPADDQ takes exactly 3 operands")
  9202      }
  9203  }
  9204  
  9205  func __asm_proxy_VPADDSB__(p *Program, v ...interface{}) *Instruction {
  9206      if len(v) == 3 {
  9207          return p.VPADDSB(v[0], v[1], v[2])
  9208      } else {
  9209          panic("instruction VPADDSB takes exactly 3 operands")
  9210      }
  9211  }
  9212  
  9213  func __asm_proxy_VPADDSW__(p *Program, v ...interface{}) *Instruction {
  9214      if len(v) == 3 {
  9215          return p.VPADDSW(v[0], v[1], v[2])
  9216      } else {
  9217          panic("instruction VPADDSW takes exactly 3 operands")
  9218      }
  9219  }
  9220  
  9221  func __asm_proxy_VPADDUSB__(p *Program, v ...interface{}) *Instruction {
  9222      if len(v) == 3 {
  9223          return p.VPADDUSB(v[0], v[1], v[2])
  9224      } else {
  9225          panic("instruction VPADDUSB takes exactly 3 operands")
  9226      }
  9227  }
  9228  
  9229  func __asm_proxy_VPADDUSW__(p *Program, v ...interface{}) *Instruction {
  9230      if len(v) == 3 {
  9231          return p.VPADDUSW(v[0], v[1], v[2])
  9232      } else {
  9233          panic("instruction VPADDUSW takes exactly 3 operands")
  9234      }
  9235  }
  9236  
  9237  func __asm_proxy_VPADDW__(p *Program, v ...interface{}) *Instruction {
  9238      if len(v) == 3 {
  9239          return p.VPADDW(v[0], v[1], v[2])
  9240      } else {
  9241          panic("instruction VPADDW takes exactly 3 operands")
  9242      }
  9243  }
  9244  
  9245  func __asm_proxy_VPALIGNR__(p *Program, v ...interface{}) *Instruction {
  9246      if len(v) == 4 {
  9247          return p.VPALIGNR(v[0], v[1], v[2], v[3])
  9248      } else {
  9249          panic("instruction VPALIGNR takes exactly 4 operands")
  9250      }
  9251  }
  9252  
  9253  func __asm_proxy_VPAND__(p *Program, v ...interface{}) *Instruction {
  9254      if len(v) == 3 {
  9255          return p.VPAND(v[0], v[1], v[2])
  9256      } else {
  9257          panic("instruction VPAND takes exactly 3 operands")
  9258      }
  9259  }
  9260  
  9261  func __asm_proxy_VPANDD__(p *Program, v ...interface{}) *Instruction {
  9262      if len(v) == 3 {
  9263          return p.VPANDD(v[0], v[1], v[2])
  9264      } else {
  9265          panic("instruction VPANDD takes exactly 3 operands")
  9266      }
  9267  }
  9268  
  9269  func __asm_proxy_VPANDN__(p *Program, v ...interface{}) *Instruction {
  9270      if len(v) == 3 {
  9271          return p.VPANDN(v[0], v[1], v[2])
  9272      } else {
  9273          panic("instruction VPANDN takes exactly 3 operands")
  9274      }
  9275  }
  9276  
  9277  func __asm_proxy_VPANDND__(p *Program, v ...interface{}) *Instruction {
  9278      if len(v) == 3 {
  9279          return p.VPANDND(v[0], v[1], v[2])
  9280      } else {
  9281          panic("instruction VPANDND takes exactly 3 operands")
  9282      }
  9283  }
  9284  
  9285  func __asm_proxy_VPANDNQ__(p *Program, v ...interface{}) *Instruction {
  9286      if len(v) == 3 {
  9287          return p.VPANDNQ(v[0], v[1], v[2])
  9288      } else {
  9289          panic("instruction VPANDNQ takes exactly 3 operands")
  9290      }
  9291  }
  9292  
  9293  func __asm_proxy_VPANDQ__(p *Program, v ...interface{}) *Instruction {
  9294      if len(v) == 3 {
  9295          return p.VPANDQ(v[0], v[1], v[2])
  9296      } else {
  9297          panic("instruction VPANDQ takes exactly 3 operands")
  9298      }
  9299  }
  9300  
  9301  func __asm_proxy_VPAVGB__(p *Program, v ...interface{}) *Instruction {
  9302      if len(v) == 3 {
  9303          return p.VPAVGB(v[0], v[1], v[2])
  9304      } else {
  9305          panic("instruction VPAVGB takes exactly 3 operands")
  9306      }
  9307  }
  9308  
  9309  func __asm_proxy_VPAVGW__(p *Program, v ...interface{}) *Instruction {
  9310      if len(v) == 3 {
  9311          return p.VPAVGW(v[0], v[1], v[2])
  9312      } else {
  9313          panic("instruction VPAVGW takes exactly 3 operands")
  9314      }
  9315  }
  9316  
  9317  func __asm_proxy_VPBLENDD__(p *Program, v ...interface{}) *Instruction {
  9318      if len(v) == 4 {
  9319          return p.VPBLENDD(v[0], v[1], v[2], v[3])
  9320      } else {
  9321          panic("instruction VPBLENDD takes exactly 4 operands")
  9322      }
  9323  }
  9324  
  9325  func __asm_proxy_VPBLENDMB__(p *Program, v ...interface{}) *Instruction {
  9326      if len(v) == 3 {
  9327          return p.VPBLENDMB(v[0], v[1], v[2])
  9328      } else {
  9329          panic("instruction VPBLENDMB takes exactly 3 operands")
  9330      }
  9331  }
  9332  
  9333  func __asm_proxy_VPBLENDMD__(p *Program, v ...interface{}) *Instruction {
  9334      if len(v) == 3 {
  9335          return p.VPBLENDMD(v[0], v[1], v[2])
  9336      } else {
  9337          panic("instruction VPBLENDMD takes exactly 3 operands")
  9338      }
  9339  }
  9340  
  9341  func __asm_proxy_VPBLENDMQ__(p *Program, v ...interface{}) *Instruction {
  9342      if len(v) == 3 {
  9343          return p.VPBLENDMQ(v[0], v[1], v[2])
  9344      } else {
  9345          panic("instruction VPBLENDMQ takes exactly 3 operands")
  9346      }
  9347  }
  9348  
  9349  func __asm_proxy_VPBLENDMW__(p *Program, v ...interface{}) *Instruction {
  9350      if len(v) == 3 {
  9351          return p.VPBLENDMW(v[0], v[1], v[2])
  9352      } else {
  9353          panic("instruction VPBLENDMW takes exactly 3 operands")
  9354      }
  9355  }
  9356  
  9357  func __asm_proxy_VPBLENDVB__(p *Program, v ...interface{}) *Instruction {
  9358      if len(v) == 4 {
  9359          return p.VPBLENDVB(v[0], v[1], v[2], v[3])
  9360      } else {
  9361          panic("instruction VPBLENDVB takes exactly 4 operands")
  9362      }
  9363  }
  9364  
  9365  func __asm_proxy_VPBLENDW__(p *Program, v ...interface{}) *Instruction {
  9366      if len(v) == 4 {
  9367          return p.VPBLENDW(v[0], v[1], v[2], v[3])
  9368      } else {
  9369          panic("instruction VPBLENDW takes exactly 4 operands")
  9370      }
  9371  }
  9372  
  9373  func __asm_proxy_VPBROADCASTB__(p *Program, v ...interface{}) *Instruction {
  9374      if len(v) == 2 {
  9375          return p.VPBROADCASTB(v[0], v[1])
  9376      } else {
  9377          panic("instruction VPBROADCASTB takes exactly 2 operands")
  9378      }
  9379  }
  9380  
  9381  func __asm_proxy_VPBROADCASTD__(p *Program, v ...interface{}) *Instruction {
  9382      if len(v) == 2 {
  9383          return p.VPBROADCASTD(v[0], v[1])
  9384      } else {
  9385          panic("instruction VPBROADCASTD takes exactly 2 operands")
  9386      }
  9387  }
  9388  
  9389  func __asm_proxy_VPBROADCASTMB2Q__(p *Program, v ...interface{}) *Instruction {
  9390      if len(v) == 2 {
  9391          return p.VPBROADCASTMB2Q(v[0], v[1])
  9392      } else {
  9393          panic("instruction VPBROADCASTMB2Q takes exactly 2 operands")
  9394      }
  9395  }
  9396  
  9397  func __asm_proxy_VPBROADCASTMW2D__(p *Program, v ...interface{}) *Instruction {
  9398      if len(v) == 2 {
  9399          return p.VPBROADCASTMW2D(v[0], v[1])
  9400      } else {
  9401          panic("instruction VPBROADCASTMW2D takes exactly 2 operands")
  9402      }
  9403  }
  9404  
  9405  func __asm_proxy_VPBROADCASTQ__(p *Program, v ...interface{}) *Instruction {
  9406      if len(v) == 2 {
  9407          return p.VPBROADCASTQ(v[0], v[1])
  9408      } else {
  9409          panic("instruction VPBROADCASTQ takes exactly 2 operands")
  9410      }
  9411  }
  9412  
  9413  func __asm_proxy_VPBROADCASTW__(p *Program, v ...interface{}) *Instruction {
  9414      if len(v) == 2 {
  9415          return p.VPBROADCASTW(v[0], v[1])
  9416      } else {
  9417          panic("instruction VPBROADCASTW takes exactly 2 operands")
  9418      }
  9419  }
  9420  
  9421  func __asm_proxy_VPCLMULQDQ__(p *Program, v ...interface{}) *Instruction {
  9422      if len(v) == 4 {
  9423          return p.VPCLMULQDQ(v[0], v[1], v[2], v[3])
  9424      } else {
  9425          panic("instruction VPCLMULQDQ takes exactly 4 operands")
  9426      }
  9427  }
  9428  
  9429  func __asm_proxy_VPCMOV__(p *Program, v ...interface{}) *Instruction {
  9430      if len(v) == 4 {
  9431          return p.VPCMOV(v[0], v[1], v[2], v[3])
  9432      } else {
  9433          panic("instruction VPCMOV takes exactly 4 operands")
  9434      }
  9435  }
  9436  
  9437  func __asm_proxy_VPCMPB__(p *Program, v ...interface{}) *Instruction {
  9438      if len(v) == 4 {
  9439          return p.VPCMPB(v[0], v[1], v[2], v[3])
  9440      } else {
  9441          panic("instruction VPCMPB takes exactly 4 operands")
  9442      }
  9443  }
  9444  
  9445  func __asm_proxy_VPCMPD__(p *Program, v ...interface{}) *Instruction {
  9446      if len(v) == 4 {
  9447          return p.VPCMPD(v[0], v[1], v[2], v[3])
  9448      } else {
  9449          panic("instruction VPCMPD takes exactly 4 operands")
  9450      }
  9451  }
  9452  
  9453  func __asm_proxy_VPCMPEQB__(p *Program, v ...interface{}) *Instruction {
  9454      if len(v) == 3 {
  9455          return p.VPCMPEQB(v[0], v[1], v[2])
  9456      } else {
  9457          panic("instruction VPCMPEQB takes exactly 3 operands")
  9458      }
  9459  }
  9460  
  9461  func __asm_proxy_VPCMPEQD__(p *Program, v ...interface{}) *Instruction {
  9462      if len(v) == 3 {
  9463          return p.VPCMPEQD(v[0], v[1], v[2])
  9464      } else {
  9465          panic("instruction VPCMPEQD takes exactly 3 operands")
  9466      }
  9467  }
  9468  
  9469  func __asm_proxy_VPCMPEQQ__(p *Program, v ...interface{}) *Instruction {
  9470      if len(v) == 3 {
  9471          return p.VPCMPEQQ(v[0], v[1], v[2])
  9472      } else {
  9473          panic("instruction VPCMPEQQ takes exactly 3 operands")
  9474      }
  9475  }
  9476  
  9477  func __asm_proxy_VPCMPEQW__(p *Program, v ...interface{}) *Instruction {
  9478      if len(v) == 3 {
  9479          return p.VPCMPEQW(v[0], v[1], v[2])
  9480      } else {
  9481          panic("instruction VPCMPEQW takes exactly 3 operands")
  9482      }
  9483  }
  9484  
  9485  func __asm_proxy_VPCMPESTRI__(p *Program, v ...interface{}) *Instruction {
  9486      if len(v) == 3 {
  9487          return p.VPCMPESTRI(v[0], v[1], v[2])
  9488      } else {
  9489          panic("instruction VPCMPESTRI takes exactly 3 operands")
  9490      }
  9491  }
  9492  
  9493  func __asm_proxy_VPCMPESTRM__(p *Program, v ...interface{}) *Instruction {
  9494      if len(v) == 3 {
  9495          return p.VPCMPESTRM(v[0], v[1], v[2])
  9496      } else {
  9497          panic("instruction VPCMPESTRM takes exactly 3 operands")
  9498      }
  9499  }
  9500  
  9501  func __asm_proxy_VPCMPGTB__(p *Program, v ...interface{}) *Instruction {
  9502      if len(v) == 3 {
  9503          return p.VPCMPGTB(v[0], v[1], v[2])
  9504      } else {
  9505          panic("instruction VPCMPGTB takes exactly 3 operands")
  9506      }
  9507  }
  9508  
  9509  func __asm_proxy_VPCMPGTD__(p *Program, v ...interface{}) *Instruction {
  9510      if len(v) == 3 {
  9511          return p.VPCMPGTD(v[0], v[1], v[2])
  9512      } else {
  9513          panic("instruction VPCMPGTD takes exactly 3 operands")
  9514      }
  9515  }
  9516  
  9517  func __asm_proxy_VPCMPGTQ__(p *Program, v ...interface{}) *Instruction {
  9518      if len(v) == 3 {
  9519          return p.VPCMPGTQ(v[0], v[1], v[2])
  9520      } else {
  9521          panic("instruction VPCMPGTQ takes exactly 3 operands")
  9522      }
  9523  }
  9524  
  9525  func __asm_proxy_VPCMPGTW__(p *Program, v ...interface{}) *Instruction {
  9526      if len(v) == 3 {
  9527          return p.VPCMPGTW(v[0], v[1], v[2])
  9528      } else {
  9529          panic("instruction VPCMPGTW takes exactly 3 operands")
  9530      }
  9531  }
  9532  
  9533  func __asm_proxy_VPCMPISTRI__(p *Program, v ...interface{}) *Instruction {
  9534      if len(v) == 3 {
  9535          return p.VPCMPISTRI(v[0], v[1], v[2])
  9536      } else {
  9537          panic("instruction VPCMPISTRI takes exactly 3 operands")
  9538      }
  9539  }
  9540  
  9541  func __asm_proxy_VPCMPISTRM__(p *Program, v ...interface{}) *Instruction {
  9542      if len(v) == 3 {
  9543          return p.VPCMPISTRM(v[0], v[1], v[2])
  9544      } else {
  9545          panic("instruction VPCMPISTRM takes exactly 3 operands")
  9546      }
  9547  }
  9548  
  9549  func __asm_proxy_VPCMPQ__(p *Program, v ...interface{}) *Instruction {
  9550      if len(v) == 4 {
  9551          return p.VPCMPQ(v[0], v[1], v[2], v[3])
  9552      } else {
  9553          panic("instruction VPCMPQ takes exactly 4 operands")
  9554      }
  9555  }
  9556  
  9557  func __asm_proxy_VPCMPUB__(p *Program, v ...interface{}) *Instruction {
  9558      if len(v) == 4 {
  9559          return p.VPCMPUB(v[0], v[1], v[2], v[3])
  9560      } else {
  9561          panic("instruction VPCMPUB takes exactly 4 operands")
  9562      }
  9563  }
  9564  
  9565  func __asm_proxy_VPCMPUD__(p *Program, v ...interface{}) *Instruction {
  9566      if len(v) == 4 {
  9567          return p.VPCMPUD(v[0], v[1], v[2], v[3])
  9568      } else {
  9569          panic("instruction VPCMPUD takes exactly 4 operands")
  9570      }
  9571  }
  9572  
  9573  func __asm_proxy_VPCMPUQ__(p *Program, v ...interface{}) *Instruction {
  9574      if len(v) == 4 {
  9575          return p.VPCMPUQ(v[0], v[1], v[2], v[3])
  9576      } else {
  9577          panic("instruction VPCMPUQ takes exactly 4 operands")
  9578      }
  9579  }
  9580  
  9581  func __asm_proxy_VPCMPUW__(p *Program, v ...interface{}) *Instruction {
  9582      if len(v) == 4 {
  9583          return p.VPCMPUW(v[0], v[1], v[2], v[3])
  9584      } else {
  9585          panic("instruction VPCMPUW takes exactly 4 operands")
  9586      }
  9587  }
  9588  
  9589  func __asm_proxy_VPCMPW__(p *Program, v ...interface{}) *Instruction {
  9590      if len(v) == 4 {
  9591          return p.VPCMPW(v[0], v[1], v[2], v[3])
  9592      } else {
  9593          panic("instruction VPCMPW takes exactly 4 operands")
  9594      }
  9595  }
  9596  
  9597  func __asm_proxy_VPCOMB__(p *Program, v ...interface{}) *Instruction {
  9598      if len(v) == 4 {
  9599          return p.VPCOMB(v[0], v[1], v[2], v[3])
  9600      } else {
  9601          panic("instruction VPCOMB takes exactly 4 operands")
  9602      }
  9603  }
  9604  
  9605  func __asm_proxy_VPCOMD__(p *Program, v ...interface{}) *Instruction {
  9606      if len(v) == 4 {
  9607          return p.VPCOMD(v[0], v[1], v[2], v[3])
  9608      } else {
  9609          panic("instruction VPCOMD takes exactly 4 operands")
  9610      }
  9611  }
  9612  
  9613  func __asm_proxy_VPCOMPRESSD__(p *Program, v ...interface{}) *Instruction {
  9614      if len(v) == 2 {
  9615          return p.VPCOMPRESSD(v[0], v[1])
  9616      } else {
  9617          panic("instruction VPCOMPRESSD takes exactly 2 operands")
  9618      }
  9619  }
  9620  
  9621  func __asm_proxy_VPCOMPRESSQ__(p *Program, v ...interface{}) *Instruction {
  9622      if len(v) == 2 {
  9623          return p.VPCOMPRESSQ(v[0], v[1])
  9624      } else {
  9625          panic("instruction VPCOMPRESSQ takes exactly 2 operands")
  9626      }
  9627  }
  9628  
  9629  func __asm_proxy_VPCOMQ__(p *Program, v ...interface{}) *Instruction {
  9630      if len(v) == 4 {
  9631          return p.VPCOMQ(v[0], v[1], v[2], v[3])
  9632      } else {
  9633          panic("instruction VPCOMQ takes exactly 4 operands")
  9634      }
  9635  }
  9636  
  9637  func __asm_proxy_VPCOMUB__(p *Program, v ...interface{}) *Instruction {
  9638      if len(v) == 4 {
  9639          return p.VPCOMUB(v[0], v[1], v[2], v[3])
  9640      } else {
  9641          panic("instruction VPCOMUB takes exactly 4 operands")
  9642      }
  9643  }
  9644  
  9645  func __asm_proxy_VPCOMUD__(p *Program, v ...interface{}) *Instruction {
  9646      if len(v) == 4 {
  9647          return p.VPCOMUD(v[0], v[1], v[2], v[3])
  9648      } else {
  9649          panic("instruction VPCOMUD takes exactly 4 operands")
  9650      }
  9651  }
  9652  
  9653  func __asm_proxy_VPCOMUQ__(p *Program, v ...interface{}) *Instruction {
  9654      if len(v) == 4 {
  9655          return p.VPCOMUQ(v[0], v[1], v[2], v[3])
  9656      } else {
  9657          panic("instruction VPCOMUQ takes exactly 4 operands")
  9658      }
  9659  }
  9660  
  9661  func __asm_proxy_VPCOMUW__(p *Program, v ...interface{}) *Instruction {
  9662      if len(v) == 4 {
  9663          return p.VPCOMUW(v[0], v[1], v[2], v[3])
  9664      } else {
  9665          panic("instruction VPCOMUW takes exactly 4 operands")
  9666      }
  9667  }
  9668  
  9669  func __asm_proxy_VPCOMW__(p *Program, v ...interface{}) *Instruction {
  9670      if len(v) == 4 {
  9671          return p.VPCOMW(v[0], v[1], v[2], v[3])
  9672      } else {
  9673          panic("instruction VPCOMW takes exactly 4 operands")
  9674      }
  9675  }
  9676  
  9677  func __asm_proxy_VPCONFLICTD__(p *Program, v ...interface{}) *Instruction {
  9678      if len(v) == 2 {
  9679          return p.VPCONFLICTD(v[0], v[1])
  9680      } else {
  9681          panic("instruction VPCONFLICTD takes exactly 2 operands")
  9682      }
  9683  }
  9684  
  9685  func __asm_proxy_VPCONFLICTQ__(p *Program, v ...interface{}) *Instruction {
  9686      if len(v) == 2 {
  9687          return p.VPCONFLICTQ(v[0], v[1])
  9688      } else {
  9689          panic("instruction VPCONFLICTQ takes exactly 2 operands")
  9690      }
  9691  }
  9692  
  9693  func __asm_proxy_VPERM2F128__(p *Program, v ...interface{}) *Instruction {
  9694      if len(v) == 4 {
  9695          return p.VPERM2F128(v[0], v[1], v[2], v[3])
  9696      } else {
  9697          panic("instruction VPERM2F128 takes exactly 4 operands")
  9698      }
  9699  }
  9700  
  9701  func __asm_proxy_VPERM2I128__(p *Program, v ...interface{}) *Instruction {
  9702      if len(v) == 4 {
  9703          return p.VPERM2I128(v[0], v[1], v[2], v[3])
  9704      } else {
  9705          panic("instruction VPERM2I128 takes exactly 4 operands")
  9706      }
  9707  }
  9708  
  9709  func __asm_proxy_VPERMB__(p *Program, v ...interface{}) *Instruction {
  9710      if len(v) == 3 {
  9711          return p.VPERMB(v[0], v[1], v[2])
  9712      } else {
  9713          panic("instruction VPERMB takes exactly 3 operands")
  9714      }
  9715  }
  9716  
  9717  func __asm_proxy_VPERMD__(p *Program, v ...interface{}) *Instruction {
  9718      if len(v) == 3 {
  9719          return p.VPERMD(v[0], v[1], v[2])
  9720      } else {
  9721          panic("instruction VPERMD takes exactly 3 operands")
  9722      }
  9723  }
  9724  
  9725  func __asm_proxy_VPERMI2B__(p *Program, v ...interface{}) *Instruction {
  9726      if len(v) == 3 {
  9727          return p.VPERMI2B(v[0], v[1], v[2])
  9728      } else {
  9729          panic("instruction VPERMI2B takes exactly 3 operands")
  9730      }
  9731  }
  9732  
  9733  func __asm_proxy_VPERMI2D__(p *Program, v ...interface{}) *Instruction {
  9734      if len(v) == 3 {
  9735          return p.VPERMI2D(v[0], v[1], v[2])
  9736      } else {
  9737          panic("instruction VPERMI2D takes exactly 3 operands")
  9738      }
  9739  }
  9740  
  9741  func __asm_proxy_VPERMI2PD__(p *Program, v ...interface{}) *Instruction {
  9742      if len(v) == 3 {
  9743          return p.VPERMI2PD(v[0], v[1], v[2])
  9744      } else {
  9745          panic("instruction VPERMI2PD takes exactly 3 operands")
  9746      }
  9747  }
  9748  
  9749  func __asm_proxy_VPERMI2PS__(p *Program, v ...interface{}) *Instruction {
  9750      if len(v) == 3 {
  9751          return p.VPERMI2PS(v[0], v[1], v[2])
  9752      } else {
  9753          panic("instruction VPERMI2PS takes exactly 3 operands")
  9754      }
  9755  }
  9756  
  9757  func __asm_proxy_VPERMI2Q__(p *Program, v ...interface{}) *Instruction {
  9758      if len(v) == 3 {
  9759          return p.VPERMI2Q(v[0], v[1], v[2])
  9760      } else {
  9761          panic("instruction VPERMI2Q takes exactly 3 operands")
  9762      }
  9763  }
  9764  
  9765  func __asm_proxy_VPERMI2W__(p *Program, v ...interface{}) *Instruction {
  9766      if len(v) == 3 {
  9767          return p.VPERMI2W(v[0], v[1], v[2])
  9768      } else {
  9769          panic("instruction VPERMI2W takes exactly 3 operands")
  9770      }
  9771  }
  9772  
  9773  func __asm_proxy_VPERMIL2PD__(p *Program, v ...interface{}) *Instruction {
  9774      if len(v) == 5 {
  9775          return p.VPERMIL2PD(v[0], v[1], v[2], v[3], v[4])
  9776      } else {
  9777          panic("instruction VPERMIL2PD takes exactly 5 operands")
  9778      }
  9779  }
  9780  
  9781  func __asm_proxy_VPERMIL2PS__(p *Program, v ...interface{}) *Instruction {
  9782      if len(v) == 5 {
  9783          return p.VPERMIL2PS(v[0], v[1], v[2], v[3], v[4])
  9784      } else {
  9785          panic("instruction VPERMIL2PS takes exactly 5 operands")
  9786      }
  9787  }
  9788  
  9789  func __asm_proxy_VPERMILPD__(p *Program, v ...interface{}) *Instruction {
  9790      if len(v) == 3 {
  9791          return p.VPERMILPD(v[0], v[1], v[2])
  9792      } else {
  9793          panic("instruction VPERMILPD takes exactly 3 operands")
  9794      }
  9795  }
  9796  
  9797  func __asm_proxy_VPERMILPS__(p *Program, v ...interface{}) *Instruction {
  9798      if len(v) == 3 {
  9799          return p.VPERMILPS(v[0], v[1], v[2])
  9800      } else {
  9801          panic("instruction VPERMILPS takes exactly 3 operands")
  9802      }
  9803  }
  9804  
  9805  func __asm_proxy_VPERMPD__(p *Program, v ...interface{}) *Instruction {
  9806      if len(v) == 3 {
  9807          return p.VPERMPD(v[0], v[1], v[2])
  9808      } else {
  9809          panic("instruction VPERMPD takes exactly 3 operands")
  9810      }
  9811  }
  9812  
  9813  func __asm_proxy_VPERMPS__(p *Program, v ...interface{}) *Instruction {
  9814      if len(v) == 3 {
  9815          return p.VPERMPS(v[0], v[1], v[2])
  9816      } else {
  9817          panic("instruction VPERMPS takes exactly 3 operands")
  9818      }
  9819  }
  9820  
  9821  func __asm_proxy_VPERMQ__(p *Program, v ...interface{}) *Instruction {
  9822      if len(v) == 3 {
  9823          return p.VPERMQ(v[0], v[1], v[2])
  9824      } else {
  9825          panic("instruction VPERMQ takes exactly 3 operands")
  9826      }
  9827  }
  9828  
  9829  func __asm_proxy_VPERMT2B__(p *Program, v ...interface{}) *Instruction {
  9830      if len(v) == 3 {
  9831          return p.VPERMT2B(v[0], v[1], v[2])
  9832      } else {
  9833          panic("instruction VPERMT2B takes exactly 3 operands")
  9834      }
  9835  }
  9836  
  9837  func __asm_proxy_VPERMT2D__(p *Program, v ...interface{}) *Instruction {
  9838      if len(v) == 3 {
  9839          return p.VPERMT2D(v[0], v[1], v[2])
  9840      } else {
  9841          panic("instruction VPERMT2D takes exactly 3 operands")
  9842      }
  9843  }
  9844  
  9845  func __asm_proxy_VPERMT2PD__(p *Program, v ...interface{}) *Instruction {
  9846      if len(v) == 3 {
  9847          return p.VPERMT2PD(v[0], v[1], v[2])
  9848      } else {
  9849          panic("instruction VPERMT2PD takes exactly 3 operands")
  9850      }
  9851  }
  9852  
  9853  func __asm_proxy_VPERMT2PS__(p *Program, v ...interface{}) *Instruction {
  9854      if len(v) == 3 {
  9855          return p.VPERMT2PS(v[0], v[1], v[2])
  9856      } else {
  9857          panic("instruction VPERMT2PS takes exactly 3 operands")
  9858      }
  9859  }
  9860  
  9861  func __asm_proxy_VPERMT2Q__(p *Program, v ...interface{}) *Instruction {
  9862      if len(v) == 3 {
  9863          return p.VPERMT2Q(v[0], v[1], v[2])
  9864      } else {
  9865          panic("instruction VPERMT2Q takes exactly 3 operands")
  9866      }
  9867  }
  9868  
  9869  func __asm_proxy_VPERMT2W__(p *Program, v ...interface{}) *Instruction {
  9870      if len(v) == 3 {
  9871          return p.VPERMT2W(v[0], v[1], v[2])
  9872      } else {
  9873          panic("instruction VPERMT2W takes exactly 3 operands")
  9874      }
  9875  }
  9876  
  9877  func __asm_proxy_VPERMW__(p *Program, v ...interface{}) *Instruction {
  9878      if len(v) == 3 {
  9879          return p.VPERMW(v[0], v[1], v[2])
  9880      } else {
  9881          panic("instruction VPERMW takes exactly 3 operands")
  9882      }
  9883  }
  9884  
  9885  func __asm_proxy_VPEXPANDD__(p *Program, v ...interface{}) *Instruction {
  9886      if len(v) == 2 {
  9887          return p.VPEXPANDD(v[0], v[1])
  9888      } else {
  9889          panic("instruction VPEXPANDD takes exactly 2 operands")
  9890      }
  9891  }
  9892  
  9893  func __asm_proxy_VPEXPANDQ__(p *Program, v ...interface{}) *Instruction {
  9894      if len(v) == 2 {
  9895          return p.VPEXPANDQ(v[0], v[1])
  9896      } else {
  9897          panic("instruction VPEXPANDQ takes exactly 2 operands")
  9898      }
  9899  }
  9900  
  9901  func __asm_proxy_VPEXTRB__(p *Program, v ...interface{}) *Instruction {
  9902      if len(v) == 3 {
  9903          return p.VPEXTRB(v[0], v[1], v[2])
  9904      } else {
  9905          panic("instruction VPEXTRB takes exactly 3 operands")
  9906      }
  9907  }
  9908  
  9909  func __asm_proxy_VPEXTRD__(p *Program, v ...interface{}) *Instruction {
  9910      if len(v) == 3 {
  9911          return p.VPEXTRD(v[0], v[1], v[2])
  9912      } else {
  9913          panic("instruction VPEXTRD takes exactly 3 operands")
  9914      }
  9915  }
  9916  
  9917  func __asm_proxy_VPEXTRQ__(p *Program, v ...interface{}) *Instruction {
  9918      if len(v) == 3 {
  9919          return p.VPEXTRQ(v[0], v[1], v[2])
  9920      } else {
  9921          panic("instruction VPEXTRQ takes exactly 3 operands")
  9922      }
  9923  }
  9924  
  9925  func __asm_proxy_VPEXTRW__(p *Program, v ...interface{}) *Instruction {
  9926      if len(v) == 3 {
  9927          return p.VPEXTRW(v[0], v[1], v[2])
  9928      } else {
  9929          panic("instruction VPEXTRW takes exactly 3 operands")
  9930      }
  9931  }
  9932  
  9933  func __asm_proxy_VPGATHERDD__(p *Program, v ...interface{}) *Instruction {
  9934      switch len(v) {
  9935          case 2  : return p.VPGATHERDD(v[0], v[1])
  9936          case 3  : return p.VPGATHERDD(v[0], v[1], v[2])
  9937          default : panic("instruction VPGATHERDD takes 2 or 3 operands")
  9938      }
  9939  }
  9940  
  9941  func __asm_proxy_VPGATHERDQ__(p *Program, v ...interface{}) *Instruction {
  9942      switch len(v) {
  9943          case 2  : return p.VPGATHERDQ(v[0], v[1])
  9944          case 3  : return p.VPGATHERDQ(v[0], v[1], v[2])
  9945          default : panic("instruction VPGATHERDQ takes 2 or 3 operands")
  9946      }
  9947  }
  9948  
  9949  func __asm_proxy_VPGATHERQD__(p *Program, v ...interface{}) *Instruction {
  9950      switch len(v) {
  9951          case 2  : return p.VPGATHERQD(v[0], v[1])
  9952          case 3  : return p.VPGATHERQD(v[0], v[1], v[2])
  9953          default : panic("instruction VPGATHERQD takes 2 or 3 operands")
  9954      }
  9955  }
  9956  
  9957  func __asm_proxy_VPGATHERQQ__(p *Program, v ...interface{}) *Instruction {
  9958      switch len(v) {
  9959          case 2  : return p.VPGATHERQQ(v[0], v[1])
  9960          case 3  : return p.VPGATHERQQ(v[0], v[1], v[2])
  9961          default : panic("instruction VPGATHERQQ takes 2 or 3 operands")
  9962      }
  9963  }
  9964  
  9965  func __asm_proxy_VPHADDBD__(p *Program, v ...interface{}) *Instruction {
  9966      if len(v) == 2 {
  9967          return p.VPHADDBD(v[0], v[1])
  9968      } else {
  9969          panic("instruction VPHADDBD takes exactly 2 operands")
  9970      }
  9971  }
  9972  
  9973  func __asm_proxy_VPHADDBQ__(p *Program, v ...interface{}) *Instruction {
  9974      if len(v) == 2 {
  9975          return p.VPHADDBQ(v[0], v[1])
  9976      } else {
  9977          panic("instruction VPHADDBQ takes exactly 2 operands")
  9978      }
  9979  }
  9980  
  9981  func __asm_proxy_VPHADDBW__(p *Program, v ...interface{}) *Instruction {
  9982      if len(v) == 2 {
  9983          return p.VPHADDBW(v[0], v[1])
  9984      } else {
  9985          panic("instruction VPHADDBW takes exactly 2 operands")
  9986      }
  9987  }
  9988  
  9989  func __asm_proxy_VPHADDD__(p *Program, v ...interface{}) *Instruction {
  9990      if len(v) == 3 {
  9991          return p.VPHADDD(v[0], v[1], v[2])
  9992      } else {
  9993          panic("instruction VPHADDD takes exactly 3 operands")
  9994      }
  9995  }
  9996  
  9997  func __asm_proxy_VPHADDDQ__(p *Program, v ...interface{}) *Instruction {
  9998      if len(v) == 2 {
  9999          return p.VPHADDDQ(v[0], v[1])
 10000      } else {
 10001          panic("instruction VPHADDDQ takes exactly 2 operands")
 10002      }
 10003  }
 10004  
 10005  func __asm_proxy_VPHADDSW__(p *Program, v ...interface{}) *Instruction {
 10006      if len(v) == 3 {
 10007          return p.VPHADDSW(v[0], v[1], v[2])
 10008      } else {
 10009          panic("instruction VPHADDSW takes exactly 3 operands")
 10010      }
 10011  }
 10012  
 10013  func __asm_proxy_VPHADDUBD__(p *Program, v ...interface{}) *Instruction {
 10014      if len(v) == 2 {
 10015          return p.VPHADDUBD(v[0], v[1])
 10016      } else {
 10017          panic("instruction VPHADDUBD takes exactly 2 operands")
 10018      }
 10019  }
 10020  
 10021  func __asm_proxy_VPHADDUBQ__(p *Program, v ...interface{}) *Instruction {
 10022      if len(v) == 2 {
 10023          return p.VPHADDUBQ(v[0], v[1])
 10024      } else {
 10025          panic("instruction VPHADDUBQ takes exactly 2 operands")
 10026      }
 10027  }
 10028  
 10029  func __asm_proxy_VPHADDUBW__(p *Program, v ...interface{}) *Instruction {
 10030      if len(v) == 2 {
 10031          return p.VPHADDUBW(v[0], v[1])
 10032      } else {
 10033          panic("instruction VPHADDUBW takes exactly 2 operands")
 10034      }
 10035  }
 10036  
 10037  func __asm_proxy_VPHADDUDQ__(p *Program, v ...interface{}) *Instruction {
 10038      if len(v) == 2 {
 10039          return p.VPHADDUDQ(v[0], v[1])
 10040      } else {
 10041          panic("instruction VPHADDUDQ takes exactly 2 operands")
 10042      }
 10043  }
 10044  
 10045  func __asm_proxy_VPHADDUWD__(p *Program, v ...interface{}) *Instruction {
 10046      if len(v) == 2 {
 10047          return p.VPHADDUWD(v[0], v[1])
 10048      } else {
 10049          panic("instruction VPHADDUWD takes exactly 2 operands")
 10050      }
 10051  }
 10052  
 10053  func __asm_proxy_VPHADDUWQ__(p *Program, v ...interface{}) *Instruction {
 10054      if len(v) == 2 {
 10055          return p.VPHADDUWQ(v[0], v[1])
 10056      } else {
 10057          panic("instruction VPHADDUWQ takes exactly 2 operands")
 10058      }
 10059  }
 10060  
 10061  func __asm_proxy_VPHADDW__(p *Program, v ...interface{}) *Instruction {
 10062      if len(v) == 3 {
 10063          return p.VPHADDW(v[0], v[1], v[2])
 10064      } else {
 10065          panic("instruction VPHADDW takes exactly 3 operands")
 10066      }
 10067  }
 10068  
 10069  func __asm_proxy_VPHADDWD__(p *Program, v ...interface{}) *Instruction {
 10070      if len(v) == 2 {
 10071          return p.VPHADDWD(v[0], v[1])
 10072      } else {
 10073          panic("instruction VPHADDWD takes exactly 2 operands")
 10074      }
 10075  }
 10076  
 10077  func __asm_proxy_VPHADDWQ__(p *Program, v ...interface{}) *Instruction {
 10078      if len(v) == 2 {
 10079          return p.VPHADDWQ(v[0], v[1])
 10080      } else {
 10081          panic("instruction VPHADDWQ takes exactly 2 operands")
 10082      }
 10083  }
 10084  
 10085  func __asm_proxy_VPHMINPOSUW__(p *Program, v ...interface{}) *Instruction {
 10086      if len(v) == 2 {
 10087          return p.VPHMINPOSUW(v[0], v[1])
 10088      } else {
 10089          panic("instruction VPHMINPOSUW takes exactly 2 operands")
 10090      }
 10091  }
 10092  
 10093  func __asm_proxy_VPHSUBBW__(p *Program, v ...interface{}) *Instruction {
 10094      if len(v) == 2 {
 10095          return p.VPHSUBBW(v[0], v[1])
 10096      } else {
 10097          panic("instruction VPHSUBBW takes exactly 2 operands")
 10098      }
 10099  }
 10100  
 10101  func __asm_proxy_VPHSUBD__(p *Program, v ...interface{}) *Instruction {
 10102      if len(v) == 3 {
 10103          return p.VPHSUBD(v[0], v[1], v[2])
 10104      } else {
 10105          panic("instruction VPHSUBD takes exactly 3 operands")
 10106      }
 10107  }
 10108  
 10109  func __asm_proxy_VPHSUBDQ__(p *Program, v ...interface{}) *Instruction {
 10110      if len(v) == 2 {
 10111          return p.VPHSUBDQ(v[0], v[1])
 10112      } else {
 10113          panic("instruction VPHSUBDQ takes exactly 2 operands")
 10114      }
 10115  }
 10116  
 10117  func __asm_proxy_VPHSUBSW__(p *Program, v ...interface{}) *Instruction {
 10118      if len(v) == 3 {
 10119          return p.VPHSUBSW(v[0], v[1], v[2])
 10120      } else {
 10121          panic("instruction VPHSUBSW takes exactly 3 operands")
 10122      }
 10123  }
 10124  
 10125  func __asm_proxy_VPHSUBW__(p *Program, v ...interface{}) *Instruction {
 10126      if len(v) == 3 {
 10127          return p.VPHSUBW(v[0], v[1], v[2])
 10128      } else {
 10129          panic("instruction VPHSUBW takes exactly 3 operands")
 10130      }
 10131  }
 10132  
 10133  func __asm_proxy_VPHSUBWD__(p *Program, v ...interface{}) *Instruction {
 10134      if len(v) == 2 {
 10135          return p.VPHSUBWD(v[0], v[1])
 10136      } else {
 10137          panic("instruction VPHSUBWD takes exactly 2 operands")
 10138      }
 10139  }
 10140  
 10141  func __asm_proxy_VPINSRB__(p *Program, v ...interface{}) *Instruction {
 10142      if len(v) == 4 {
 10143          return p.VPINSRB(v[0], v[1], v[2], v[3])
 10144      } else {
 10145          panic("instruction VPINSRB takes exactly 4 operands")
 10146      }
 10147  }
 10148  
 10149  func __asm_proxy_VPINSRD__(p *Program, v ...interface{}) *Instruction {
 10150      if len(v) == 4 {
 10151          return p.VPINSRD(v[0], v[1], v[2], v[3])
 10152      } else {
 10153          panic("instruction VPINSRD takes exactly 4 operands")
 10154      }
 10155  }
 10156  
 10157  func __asm_proxy_VPINSRQ__(p *Program, v ...interface{}) *Instruction {
 10158      if len(v) == 4 {
 10159          return p.VPINSRQ(v[0], v[1], v[2], v[3])
 10160      } else {
 10161          panic("instruction VPINSRQ takes exactly 4 operands")
 10162      }
 10163  }
 10164  
 10165  func __asm_proxy_VPINSRW__(p *Program, v ...interface{}) *Instruction {
 10166      if len(v) == 4 {
 10167          return p.VPINSRW(v[0], v[1], v[2], v[3])
 10168      } else {
 10169          panic("instruction VPINSRW takes exactly 4 operands")
 10170      }
 10171  }
 10172  
 10173  func __asm_proxy_VPLZCNTD__(p *Program, v ...interface{}) *Instruction {
 10174      if len(v) == 2 {
 10175          return p.VPLZCNTD(v[0], v[1])
 10176      } else {
 10177          panic("instruction VPLZCNTD takes exactly 2 operands")
 10178      }
 10179  }
 10180  
 10181  func __asm_proxy_VPLZCNTQ__(p *Program, v ...interface{}) *Instruction {
 10182      if len(v) == 2 {
 10183          return p.VPLZCNTQ(v[0], v[1])
 10184      } else {
 10185          panic("instruction VPLZCNTQ takes exactly 2 operands")
 10186      }
 10187  }
 10188  
 10189  func __asm_proxy_VPMACSDD__(p *Program, v ...interface{}) *Instruction {
 10190      if len(v) == 4 {
 10191          return p.VPMACSDD(v[0], v[1], v[2], v[3])
 10192      } else {
 10193          panic("instruction VPMACSDD takes exactly 4 operands")
 10194      }
 10195  }
 10196  
 10197  func __asm_proxy_VPMACSDQH__(p *Program, v ...interface{}) *Instruction {
 10198      if len(v) == 4 {
 10199          return p.VPMACSDQH(v[0], v[1], v[2], v[3])
 10200      } else {
 10201          panic("instruction VPMACSDQH takes exactly 4 operands")
 10202      }
 10203  }
 10204  
 10205  func __asm_proxy_VPMACSDQL__(p *Program, v ...interface{}) *Instruction {
 10206      if len(v) == 4 {
 10207          return p.VPMACSDQL(v[0], v[1], v[2], v[3])
 10208      } else {
 10209          panic("instruction VPMACSDQL takes exactly 4 operands")
 10210      }
 10211  }
 10212  
 10213  func __asm_proxy_VPMACSSDD__(p *Program, v ...interface{}) *Instruction {
 10214      if len(v) == 4 {
 10215          return p.VPMACSSDD(v[0], v[1], v[2], v[3])
 10216      } else {
 10217          panic("instruction VPMACSSDD takes exactly 4 operands")
 10218      }
 10219  }
 10220  
 10221  func __asm_proxy_VPMACSSDQH__(p *Program, v ...interface{}) *Instruction {
 10222      if len(v) == 4 {
 10223          return p.VPMACSSDQH(v[0], v[1], v[2], v[3])
 10224      } else {
 10225          panic("instruction VPMACSSDQH takes exactly 4 operands")
 10226      }
 10227  }
 10228  
 10229  func __asm_proxy_VPMACSSDQL__(p *Program, v ...interface{}) *Instruction {
 10230      if len(v) == 4 {
 10231          return p.VPMACSSDQL(v[0], v[1], v[2], v[3])
 10232      } else {
 10233          panic("instruction VPMACSSDQL takes exactly 4 operands")
 10234      }
 10235  }
 10236  
 10237  func __asm_proxy_VPMACSSWD__(p *Program, v ...interface{}) *Instruction {
 10238      if len(v) == 4 {
 10239          return p.VPMACSSWD(v[0], v[1], v[2], v[3])
 10240      } else {
 10241          panic("instruction VPMACSSWD takes exactly 4 operands")
 10242      }
 10243  }
 10244  
 10245  func __asm_proxy_VPMACSSWW__(p *Program, v ...interface{}) *Instruction {
 10246      if len(v) == 4 {
 10247          return p.VPMACSSWW(v[0], v[1], v[2], v[3])
 10248      } else {
 10249          panic("instruction VPMACSSWW takes exactly 4 operands")
 10250      }
 10251  }
 10252  
 10253  func __asm_proxy_VPMACSWD__(p *Program, v ...interface{}) *Instruction {
 10254      if len(v) == 4 {
 10255          return p.VPMACSWD(v[0], v[1], v[2], v[3])
 10256      } else {
 10257          panic("instruction VPMACSWD takes exactly 4 operands")
 10258      }
 10259  }
 10260  
 10261  func __asm_proxy_VPMACSWW__(p *Program, v ...interface{}) *Instruction {
 10262      if len(v) == 4 {
 10263          return p.VPMACSWW(v[0], v[1], v[2], v[3])
 10264      } else {
 10265          panic("instruction VPMACSWW takes exactly 4 operands")
 10266      }
 10267  }
 10268  
 10269  func __asm_proxy_VPMADCSSWD__(p *Program, v ...interface{}) *Instruction {
 10270      if len(v) == 4 {
 10271          return p.VPMADCSSWD(v[0], v[1], v[2], v[3])
 10272      } else {
 10273          panic("instruction VPMADCSSWD takes exactly 4 operands")
 10274      }
 10275  }
 10276  
 10277  func __asm_proxy_VPMADCSWD__(p *Program, v ...interface{}) *Instruction {
 10278      if len(v) == 4 {
 10279          return p.VPMADCSWD(v[0], v[1], v[2], v[3])
 10280      } else {
 10281          panic("instruction VPMADCSWD takes exactly 4 operands")
 10282      }
 10283  }
 10284  
 10285  func __asm_proxy_VPMADD52HUQ__(p *Program, v ...interface{}) *Instruction {
 10286      if len(v) == 3 {
 10287          return p.VPMADD52HUQ(v[0], v[1], v[2])
 10288      } else {
 10289          panic("instruction VPMADD52HUQ takes exactly 3 operands")
 10290      }
 10291  }
 10292  
 10293  func __asm_proxy_VPMADD52LUQ__(p *Program, v ...interface{}) *Instruction {
 10294      if len(v) == 3 {
 10295          return p.VPMADD52LUQ(v[0], v[1], v[2])
 10296      } else {
 10297          panic("instruction VPMADD52LUQ takes exactly 3 operands")
 10298      }
 10299  }
 10300  
 10301  func __asm_proxy_VPMADDUBSW__(p *Program, v ...interface{}) *Instruction {
 10302      if len(v) == 3 {
 10303          return p.VPMADDUBSW(v[0], v[1], v[2])
 10304      } else {
 10305          panic("instruction VPMADDUBSW takes exactly 3 operands")
 10306      }
 10307  }
 10308  
 10309  func __asm_proxy_VPMADDWD__(p *Program, v ...interface{}) *Instruction {
 10310      if len(v) == 3 {
 10311          return p.VPMADDWD(v[0], v[1], v[2])
 10312      } else {
 10313          panic("instruction VPMADDWD takes exactly 3 operands")
 10314      }
 10315  }
 10316  
 10317  func __asm_proxy_VPMASKMOVD__(p *Program, v ...interface{}) *Instruction {
 10318      if len(v) == 3 {
 10319          return p.VPMASKMOVD(v[0], v[1], v[2])
 10320      } else {
 10321          panic("instruction VPMASKMOVD takes exactly 3 operands")
 10322      }
 10323  }
 10324  
 10325  func __asm_proxy_VPMASKMOVQ__(p *Program, v ...interface{}) *Instruction {
 10326      if len(v) == 3 {
 10327          return p.VPMASKMOVQ(v[0], v[1], v[2])
 10328      } else {
 10329          panic("instruction VPMASKMOVQ takes exactly 3 operands")
 10330      }
 10331  }
 10332  
 10333  func __asm_proxy_VPMAXSB__(p *Program, v ...interface{}) *Instruction {
 10334      if len(v) == 3 {
 10335          return p.VPMAXSB(v[0], v[1], v[2])
 10336      } else {
 10337          panic("instruction VPMAXSB takes exactly 3 operands")
 10338      }
 10339  }
 10340  
 10341  func __asm_proxy_VPMAXSD__(p *Program, v ...interface{}) *Instruction {
 10342      if len(v) == 3 {
 10343          return p.VPMAXSD(v[0], v[1], v[2])
 10344      } else {
 10345          panic("instruction VPMAXSD takes exactly 3 operands")
 10346      }
 10347  }
 10348  
 10349  func __asm_proxy_VPMAXSQ__(p *Program, v ...interface{}) *Instruction {
 10350      if len(v) == 3 {
 10351          return p.VPMAXSQ(v[0], v[1], v[2])
 10352      } else {
 10353          panic("instruction VPMAXSQ takes exactly 3 operands")
 10354      }
 10355  }
 10356  
 10357  func __asm_proxy_VPMAXSW__(p *Program, v ...interface{}) *Instruction {
 10358      if len(v) == 3 {
 10359          return p.VPMAXSW(v[0], v[1], v[2])
 10360      } else {
 10361          panic("instruction VPMAXSW takes exactly 3 operands")
 10362      }
 10363  }
 10364  
 10365  func __asm_proxy_VPMAXUB__(p *Program, v ...interface{}) *Instruction {
 10366      if len(v) == 3 {
 10367          return p.VPMAXUB(v[0], v[1], v[2])
 10368      } else {
 10369          panic("instruction VPMAXUB takes exactly 3 operands")
 10370      }
 10371  }
 10372  
 10373  func __asm_proxy_VPMAXUD__(p *Program, v ...interface{}) *Instruction {
 10374      if len(v) == 3 {
 10375          return p.VPMAXUD(v[0], v[1], v[2])
 10376      } else {
 10377          panic("instruction VPMAXUD takes exactly 3 operands")
 10378      }
 10379  }
 10380  
 10381  func __asm_proxy_VPMAXUQ__(p *Program, v ...interface{}) *Instruction {
 10382      if len(v) == 3 {
 10383          return p.VPMAXUQ(v[0], v[1], v[2])
 10384      } else {
 10385          panic("instruction VPMAXUQ takes exactly 3 operands")
 10386      }
 10387  }
 10388  
 10389  func __asm_proxy_VPMAXUW__(p *Program, v ...interface{}) *Instruction {
 10390      if len(v) == 3 {
 10391          return p.VPMAXUW(v[0], v[1], v[2])
 10392      } else {
 10393          panic("instruction VPMAXUW takes exactly 3 operands")
 10394      }
 10395  }
 10396  
 10397  func __asm_proxy_VPMINSB__(p *Program, v ...interface{}) *Instruction {
 10398      if len(v) == 3 {
 10399          return p.VPMINSB(v[0], v[1], v[2])
 10400      } else {
 10401          panic("instruction VPMINSB takes exactly 3 operands")
 10402      }
 10403  }
 10404  
 10405  func __asm_proxy_VPMINSD__(p *Program, v ...interface{}) *Instruction {
 10406      if len(v) == 3 {
 10407          return p.VPMINSD(v[0], v[1], v[2])
 10408      } else {
 10409          panic("instruction VPMINSD takes exactly 3 operands")
 10410      }
 10411  }
 10412  
 10413  func __asm_proxy_VPMINSQ__(p *Program, v ...interface{}) *Instruction {
 10414      if len(v) == 3 {
 10415          return p.VPMINSQ(v[0], v[1], v[2])
 10416      } else {
 10417          panic("instruction VPMINSQ takes exactly 3 operands")
 10418      }
 10419  }
 10420  
 10421  func __asm_proxy_VPMINSW__(p *Program, v ...interface{}) *Instruction {
 10422      if len(v) == 3 {
 10423          return p.VPMINSW(v[0], v[1], v[2])
 10424      } else {
 10425          panic("instruction VPMINSW takes exactly 3 operands")
 10426      }
 10427  }
 10428  
 10429  func __asm_proxy_VPMINUB__(p *Program, v ...interface{}) *Instruction {
 10430      if len(v) == 3 {
 10431          return p.VPMINUB(v[0], v[1], v[2])
 10432      } else {
 10433          panic("instruction VPMINUB takes exactly 3 operands")
 10434      }
 10435  }
 10436  
 10437  func __asm_proxy_VPMINUD__(p *Program, v ...interface{}) *Instruction {
 10438      if len(v) == 3 {
 10439          return p.VPMINUD(v[0], v[1], v[2])
 10440      } else {
 10441          panic("instruction VPMINUD takes exactly 3 operands")
 10442      }
 10443  }
 10444  
 10445  func __asm_proxy_VPMINUQ__(p *Program, v ...interface{}) *Instruction {
 10446      if len(v) == 3 {
 10447          return p.VPMINUQ(v[0], v[1], v[2])
 10448      } else {
 10449          panic("instruction VPMINUQ takes exactly 3 operands")
 10450      }
 10451  }
 10452  
 10453  func __asm_proxy_VPMINUW__(p *Program, v ...interface{}) *Instruction {
 10454      if len(v) == 3 {
 10455          return p.VPMINUW(v[0], v[1], v[2])
 10456      } else {
 10457          panic("instruction VPMINUW takes exactly 3 operands")
 10458      }
 10459  }
 10460  
 10461  func __asm_proxy_VPMOVB2M__(p *Program, v ...interface{}) *Instruction {
 10462      if len(v) == 2 {
 10463          return p.VPMOVB2M(v[0], v[1])
 10464      } else {
 10465          panic("instruction VPMOVB2M takes exactly 2 operands")
 10466      }
 10467  }
 10468  
 10469  func __asm_proxy_VPMOVD2M__(p *Program, v ...interface{}) *Instruction {
 10470      if len(v) == 2 {
 10471          return p.VPMOVD2M(v[0], v[1])
 10472      } else {
 10473          panic("instruction VPMOVD2M takes exactly 2 operands")
 10474      }
 10475  }
 10476  
 10477  func __asm_proxy_VPMOVDB__(p *Program, v ...interface{}) *Instruction {
 10478      if len(v) == 2 {
 10479          return p.VPMOVDB(v[0], v[1])
 10480      } else {
 10481          panic("instruction VPMOVDB takes exactly 2 operands")
 10482      }
 10483  }
 10484  
 10485  func __asm_proxy_VPMOVDW__(p *Program, v ...interface{}) *Instruction {
 10486      if len(v) == 2 {
 10487          return p.VPMOVDW(v[0], v[1])
 10488      } else {
 10489          panic("instruction VPMOVDW takes exactly 2 operands")
 10490      }
 10491  }
 10492  
 10493  func __asm_proxy_VPMOVM2B__(p *Program, v ...interface{}) *Instruction {
 10494      if len(v) == 2 {
 10495          return p.VPMOVM2B(v[0], v[1])
 10496      } else {
 10497          panic("instruction VPMOVM2B takes exactly 2 operands")
 10498      }
 10499  }
 10500  
 10501  func __asm_proxy_VPMOVM2D__(p *Program, v ...interface{}) *Instruction {
 10502      if len(v) == 2 {
 10503          return p.VPMOVM2D(v[0], v[1])
 10504      } else {
 10505          panic("instruction VPMOVM2D takes exactly 2 operands")
 10506      }
 10507  }
 10508  
 10509  func __asm_proxy_VPMOVM2Q__(p *Program, v ...interface{}) *Instruction {
 10510      if len(v) == 2 {
 10511          return p.VPMOVM2Q(v[0], v[1])
 10512      } else {
 10513          panic("instruction VPMOVM2Q takes exactly 2 operands")
 10514      }
 10515  }
 10516  
 10517  func __asm_proxy_VPMOVM2W__(p *Program, v ...interface{}) *Instruction {
 10518      if len(v) == 2 {
 10519          return p.VPMOVM2W(v[0], v[1])
 10520      } else {
 10521          panic("instruction VPMOVM2W takes exactly 2 operands")
 10522      }
 10523  }
 10524  
 10525  func __asm_proxy_VPMOVMSKB__(p *Program, v ...interface{}) *Instruction {
 10526      if len(v) == 2 {
 10527          return p.VPMOVMSKB(v[0], v[1])
 10528      } else {
 10529          panic("instruction VPMOVMSKB takes exactly 2 operands")
 10530      }
 10531  }
 10532  
 10533  func __asm_proxy_VPMOVQ2M__(p *Program, v ...interface{}) *Instruction {
 10534      if len(v) == 2 {
 10535          return p.VPMOVQ2M(v[0], v[1])
 10536      } else {
 10537          panic("instruction VPMOVQ2M takes exactly 2 operands")
 10538      }
 10539  }
 10540  
 10541  func __asm_proxy_VPMOVQB__(p *Program, v ...interface{}) *Instruction {
 10542      if len(v) == 2 {
 10543          return p.VPMOVQB(v[0], v[1])
 10544      } else {
 10545          panic("instruction VPMOVQB takes exactly 2 operands")
 10546      }
 10547  }
 10548  
 10549  func __asm_proxy_VPMOVQD__(p *Program, v ...interface{}) *Instruction {
 10550      if len(v) == 2 {
 10551          return p.VPMOVQD(v[0], v[1])
 10552      } else {
 10553          panic("instruction VPMOVQD takes exactly 2 operands")
 10554      }
 10555  }
 10556  
 10557  func __asm_proxy_VPMOVQW__(p *Program, v ...interface{}) *Instruction {
 10558      if len(v) == 2 {
 10559          return p.VPMOVQW(v[0], v[1])
 10560      } else {
 10561          panic("instruction VPMOVQW takes exactly 2 operands")
 10562      }
 10563  }
 10564  
 10565  func __asm_proxy_VPMOVSDB__(p *Program, v ...interface{}) *Instruction {
 10566      if len(v) == 2 {
 10567          return p.VPMOVSDB(v[0], v[1])
 10568      } else {
 10569          panic("instruction VPMOVSDB takes exactly 2 operands")
 10570      }
 10571  }
 10572  
 10573  func __asm_proxy_VPMOVSDW__(p *Program, v ...interface{}) *Instruction {
 10574      if len(v) == 2 {
 10575          return p.VPMOVSDW(v[0], v[1])
 10576      } else {
 10577          panic("instruction VPMOVSDW takes exactly 2 operands")
 10578      }
 10579  }
 10580  
 10581  func __asm_proxy_VPMOVSQB__(p *Program, v ...interface{}) *Instruction {
 10582      if len(v) == 2 {
 10583          return p.VPMOVSQB(v[0], v[1])
 10584      } else {
 10585          panic("instruction VPMOVSQB takes exactly 2 operands")
 10586      }
 10587  }
 10588  
 10589  func __asm_proxy_VPMOVSQD__(p *Program, v ...interface{}) *Instruction {
 10590      if len(v) == 2 {
 10591          return p.VPMOVSQD(v[0], v[1])
 10592      } else {
 10593          panic("instruction VPMOVSQD takes exactly 2 operands")
 10594      }
 10595  }
 10596  
 10597  func __asm_proxy_VPMOVSQW__(p *Program, v ...interface{}) *Instruction {
 10598      if len(v) == 2 {
 10599          return p.VPMOVSQW(v[0], v[1])
 10600      } else {
 10601          panic("instruction VPMOVSQW takes exactly 2 operands")
 10602      }
 10603  }
 10604  
 10605  func __asm_proxy_VPMOVSWB__(p *Program, v ...interface{}) *Instruction {
 10606      if len(v) == 2 {
 10607          return p.VPMOVSWB(v[0], v[1])
 10608      } else {
 10609          panic("instruction VPMOVSWB takes exactly 2 operands")
 10610      }
 10611  }
 10612  
 10613  func __asm_proxy_VPMOVSXBD__(p *Program, v ...interface{}) *Instruction {
 10614      if len(v) == 2 {
 10615          return p.VPMOVSXBD(v[0], v[1])
 10616      } else {
 10617          panic("instruction VPMOVSXBD takes exactly 2 operands")
 10618      }
 10619  }
 10620  
 10621  func __asm_proxy_VPMOVSXBQ__(p *Program, v ...interface{}) *Instruction {
 10622      if len(v) == 2 {
 10623          return p.VPMOVSXBQ(v[0], v[1])
 10624      } else {
 10625          panic("instruction VPMOVSXBQ takes exactly 2 operands")
 10626      }
 10627  }
 10628  
 10629  func __asm_proxy_VPMOVSXBW__(p *Program, v ...interface{}) *Instruction {
 10630      if len(v) == 2 {
 10631          return p.VPMOVSXBW(v[0], v[1])
 10632      } else {
 10633          panic("instruction VPMOVSXBW takes exactly 2 operands")
 10634      }
 10635  }
 10636  
 10637  func __asm_proxy_VPMOVSXDQ__(p *Program, v ...interface{}) *Instruction {
 10638      if len(v) == 2 {
 10639          return p.VPMOVSXDQ(v[0], v[1])
 10640      } else {
 10641          panic("instruction VPMOVSXDQ takes exactly 2 operands")
 10642      }
 10643  }
 10644  
 10645  func __asm_proxy_VPMOVSXWD__(p *Program, v ...interface{}) *Instruction {
 10646      if len(v) == 2 {
 10647          return p.VPMOVSXWD(v[0], v[1])
 10648      } else {
 10649          panic("instruction VPMOVSXWD takes exactly 2 operands")
 10650      }
 10651  }
 10652  
 10653  func __asm_proxy_VPMOVSXWQ__(p *Program, v ...interface{}) *Instruction {
 10654      if len(v) == 2 {
 10655          return p.VPMOVSXWQ(v[0], v[1])
 10656      } else {
 10657          panic("instruction VPMOVSXWQ takes exactly 2 operands")
 10658      }
 10659  }
 10660  
 10661  func __asm_proxy_VPMOVUSDB__(p *Program, v ...interface{}) *Instruction {
 10662      if len(v) == 2 {
 10663          return p.VPMOVUSDB(v[0], v[1])
 10664      } else {
 10665          panic("instruction VPMOVUSDB takes exactly 2 operands")
 10666      }
 10667  }
 10668  
 10669  func __asm_proxy_VPMOVUSDW__(p *Program, v ...interface{}) *Instruction {
 10670      if len(v) == 2 {
 10671          return p.VPMOVUSDW(v[0], v[1])
 10672      } else {
 10673          panic("instruction VPMOVUSDW takes exactly 2 operands")
 10674      }
 10675  }
 10676  
 10677  func __asm_proxy_VPMOVUSQB__(p *Program, v ...interface{}) *Instruction {
 10678      if len(v) == 2 {
 10679          return p.VPMOVUSQB(v[0], v[1])
 10680      } else {
 10681          panic("instruction VPMOVUSQB takes exactly 2 operands")
 10682      }
 10683  }
 10684  
 10685  func __asm_proxy_VPMOVUSQD__(p *Program, v ...interface{}) *Instruction {
 10686      if len(v) == 2 {
 10687          return p.VPMOVUSQD(v[0], v[1])
 10688      } else {
 10689          panic("instruction VPMOVUSQD takes exactly 2 operands")
 10690      }
 10691  }
 10692  
 10693  func __asm_proxy_VPMOVUSQW__(p *Program, v ...interface{}) *Instruction {
 10694      if len(v) == 2 {
 10695          return p.VPMOVUSQW(v[0], v[1])
 10696      } else {
 10697          panic("instruction VPMOVUSQW takes exactly 2 operands")
 10698      }
 10699  }
 10700  
 10701  func __asm_proxy_VPMOVUSWB__(p *Program, v ...interface{}) *Instruction {
 10702      if len(v) == 2 {
 10703          return p.VPMOVUSWB(v[0], v[1])
 10704      } else {
 10705          panic("instruction VPMOVUSWB takes exactly 2 operands")
 10706      }
 10707  }
 10708  
 10709  func __asm_proxy_VPMOVW2M__(p *Program, v ...interface{}) *Instruction {
 10710      if len(v) == 2 {
 10711          return p.VPMOVW2M(v[0], v[1])
 10712      } else {
 10713          panic("instruction VPMOVW2M takes exactly 2 operands")
 10714      }
 10715  }
 10716  
 10717  func __asm_proxy_VPMOVWB__(p *Program, v ...interface{}) *Instruction {
 10718      if len(v) == 2 {
 10719          return p.VPMOVWB(v[0], v[1])
 10720      } else {
 10721          panic("instruction VPMOVWB takes exactly 2 operands")
 10722      }
 10723  }
 10724  
 10725  func __asm_proxy_VPMOVZXBD__(p *Program, v ...interface{}) *Instruction {
 10726      if len(v) == 2 {
 10727          return p.VPMOVZXBD(v[0], v[1])
 10728      } else {
 10729          panic("instruction VPMOVZXBD takes exactly 2 operands")
 10730      }
 10731  }
 10732  
 10733  func __asm_proxy_VPMOVZXBQ__(p *Program, v ...interface{}) *Instruction {
 10734      if len(v) == 2 {
 10735          return p.VPMOVZXBQ(v[0], v[1])
 10736      } else {
 10737          panic("instruction VPMOVZXBQ takes exactly 2 operands")
 10738      }
 10739  }
 10740  
 10741  func __asm_proxy_VPMOVZXBW__(p *Program, v ...interface{}) *Instruction {
 10742      if len(v) == 2 {
 10743          return p.VPMOVZXBW(v[0], v[1])
 10744      } else {
 10745          panic("instruction VPMOVZXBW takes exactly 2 operands")
 10746      }
 10747  }
 10748  
 10749  func __asm_proxy_VPMOVZXDQ__(p *Program, v ...interface{}) *Instruction {
 10750      if len(v) == 2 {
 10751          return p.VPMOVZXDQ(v[0], v[1])
 10752      } else {
 10753          panic("instruction VPMOVZXDQ takes exactly 2 operands")
 10754      }
 10755  }
 10756  
 10757  func __asm_proxy_VPMOVZXWD__(p *Program, v ...interface{}) *Instruction {
 10758      if len(v) == 2 {
 10759          return p.VPMOVZXWD(v[0], v[1])
 10760      } else {
 10761          panic("instruction VPMOVZXWD takes exactly 2 operands")
 10762      }
 10763  }
 10764  
 10765  func __asm_proxy_VPMOVZXWQ__(p *Program, v ...interface{}) *Instruction {
 10766      if len(v) == 2 {
 10767          return p.VPMOVZXWQ(v[0], v[1])
 10768      } else {
 10769          panic("instruction VPMOVZXWQ takes exactly 2 operands")
 10770      }
 10771  }
 10772  
 10773  func __asm_proxy_VPMULDQ__(p *Program, v ...interface{}) *Instruction {
 10774      if len(v) == 3 {
 10775          return p.VPMULDQ(v[0], v[1], v[2])
 10776      } else {
 10777          panic("instruction VPMULDQ takes exactly 3 operands")
 10778      }
 10779  }
 10780  
 10781  func __asm_proxy_VPMULHRSW__(p *Program, v ...interface{}) *Instruction {
 10782      if len(v) == 3 {
 10783          return p.VPMULHRSW(v[0], v[1], v[2])
 10784      } else {
 10785          panic("instruction VPMULHRSW takes exactly 3 operands")
 10786      }
 10787  }
 10788  
 10789  func __asm_proxy_VPMULHUW__(p *Program, v ...interface{}) *Instruction {
 10790      if len(v) == 3 {
 10791          return p.VPMULHUW(v[0], v[1], v[2])
 10792      } else {
 10793          panic("instruction VPMULHUW takes exactly 3 operands")
 10794      }
 10795  }
 10796  
 10797  func __asm_proxy_VPMULHW__(p *Program, v ...interface{}) *Instruction {
 10798      if len(v) == 3 {
 10799          return p.VPMULHW(v[0], v[1], v[2])
 10800      } else {
 10801          panic("instruction VPMULHW takes exactly 3 operands")
 10802      }
 10803  }
 10804  
 10805  func __asm_proxy_VPMULLD__(p *Program, v ...interface{}) *Instruction {
 10806      if len(v) == 3 {
 10807          return p.VPMULLD(v[0], v[1], v[2])
 10808      } else {
 10809          panic("instruction VPMULLD takes exactly 3 operands")
 10810      }
 10811  }
 10812  
 10813  func __asm_proxy_VPMULLQ__(p *Program, v ...interface{}) *Instruction {
 10814      if len(v) == 3 {
 10815          return p.VPMULLQ(v[0], v[1], v[2])
 10816      } else {
 10817          panic("instruction VPMULLQ takes exactly 3 operands")
 10818      }
 10819  }
 10820  
 10821  func __asm_proxy_VPMULLW__(p *Program, v ...interface{}) *Instruction {
 10822      if len(v) == 3 {
 10823          return p.VPMULLW(v[0], v[1], v[2])
 10824      } else {
 10825          panic("instruction VPMULLW takes exactly 3 operands")
 10826      }
 10827  }
 10828  
 10829  func __asm_proxy_VPMULTISHIFTQB__(p *Program, v ...interface{}) *Instruction {
 10830      if len(v) == 3 {
 10831          return p.VPMULTISHIFTQB(v[0], v[1], v[2])
 10832      } else {
 10833          panic("instruction VPMULTISHIFTQB takes exactly 3 operands")
 10834      }
 10835  }
 10836  
 10837  func __asm_proxy_VPMULUDQ__(p *Program, v ...interface{}) *Instruction {
 10838      if len(v) == 3 {
 10839          return p.VPMULUDQ(v[0], v[1], v[2])
 10840      } else {
 10841          panic("instruction VPMULUDQ takes exactly 3 operands")
 10842      }
 10843  }
 10844  
 10845  func __asm_proxy_VPOPCNTD__(p *Program, v ...interface{}) *Instruction {
 10846      if len(v) == 2 {
 10847          return p.VPOPCNTD(v[0], v[1])
 10848      } else {
 10849          panic("instruction VPOPCNTD takes exactly 2 operands")
 10850      }
 10851  }
 10852  
 10853  func __asm_proxy_VPOPCNTQ__(p *Program, v ...interface{}) *Instruction {
 10854      if len(v) == 2 {
 10855          return p.VPOPCNTQ(v[0], v[1])
 10856      } else {
 10857          panic("instruction VPOPCNTQ takes exactly 2 operands")
 10858      }
 10859  }
 10860  
 10861  func __asm_proxy_VPOR__(p *Program, v ...interface{}) *Instruction {
 10862      if len(v) == 3 {
 10863          return p.VPOR(v[0], v[1], v[2])
 10864      } else {
 10865          panic("instruction VPOR takes exactly 3 operands")
 10866      }
 10867  }
 10868  
 10869  func __asm_proxy_VPORD__(p *Program, v ...interface{}) *Instruction {
 10870      if len(v) == 3 {
 10871          return p.VPORD(v[0], v[1], v[2])
 10872      } else {
 10873          panic("instruction VPORD takes exactly 3 operands")
 10874      }
 10875  }
 10876  
 10877  func __asm_proxy_VPORQ__(p *Program, v ...interface{}) *Instruction {
 10878      if len(v) == 3 {
 10879          return p.VPORQ(v[0], v[1], v[2])
 10880      } else {
 10881          panic("instruction VPORQ takes exactly 3 operands")
 10882      }
 10883  }
 10884  
 10885  func __asm_proxy_VPPERM__(p *Program, v ...interface{}) *Instruction {
 10886      if len(v) == 4 {
 10887          return p.VPPERM(v[0], v[1], v[2], v[3])
 10888      } else {
 10889          panic("instruction VPPERM takes exactly 4 operands")
 10890      }
 10891  }
 10892  
 10893  func __asm_proxy_VPROLD__(p *Program, v ...interface{}) *Instruction {
 10894      if len(v) == 3 {
 10895          return p.VPROLD(v[0], v[1], v[2])
 10896      } else {
 10897          panic("instruction VPROLD takes exactly 3 operands")
 10898      }
 10899  }
 10900  
 10901  func __asm_proxy_VPROLQ__(p *Program, v ...interface{}) *Instruction {
 10902      if len(v) == 3 {
 10903          return p.VPROLQ(v[0], v[1], v[2])
 10904      } else {
 10905          panic("instruction VPROLQ takes exactly 3 operands")
 10906      }
 10907  }
 10908  
 10909  func __asm_proxy_VPROLVD__(p *Program, v ...interface{}) *Instruction {
 10910      if len(v) == 3 {
 10911          return p.VPROLVD(v[0], v[1], v[2])
 10912      } else {
 10913          panic("instruction VPROLVD takes exactly 3 operands")
 10914      }
 10915  }
 10916  
 10917  func __asm_proxy_VPROLVQ__(p *Program, v ...interface{}) *Instruction {
 10918      if len(v) == 3 {
 10919          return p.VPROLVQ(v[0], v[1], v[2])
 10920      } else {
 10921          panic("instruction VPROLVQ takes exactly 3 operands")
 10922      }
 10923  }
 10924  
 10925  func __asm_proxy_VPRORD__(p *Program, v ...interface{}) *Instruction {
 10926      if len(v) == 3 {
 10927          return p.VPRORD(v[0], v[1], v[2])
 10928      } else {
 10929          panic("instruction VPRORD takes exactly 3 operands")
 10930      }
 10931  }
 10932  
 10933  func __asm_proxy_VPRORQ__(p *Program, v ...interface{}) *Instruction {
 10934      if len(v) == 3 {
 10935          return p.VPRORQ(v[0], v[1], v[2])
 10936      } else {
 10937          panic("instruction VPRORQ takes exactly 3 operands")
 10938      }
 10939  }
 10940  
 10941  func __asm_proxy_VPRORVD__(p *Program, v ...interface{}) *Instruction {
 10942      if len(v) == 3 {
 10943          return p.VPRORVD(v[0], v[1], v[2])
 10944      } else {
 10945          panic("instruction VPRORVD takes exactly 3 operands")
 10946      }
 10947  }
 10948  
 10949  func __asm_proxy_VPRORVQ__(p *Program, v ...interface{}) *Instruction {
 10950      if len(v) == 3 {
 10951          return p.VPRORVQ(v[0], v[1], v[2])
 10952      } else {
 10953          panic("instruction VPRORVQ takes exactly 3 operands")
 10954      }
 10955  }
 10956  
 10957  func __asm_proxy_VPROTB__(p *Program, v ...interface{}) *Instruction {
 10958      if len(v) == 3 {
 10959          return p.VPROTB(v[0], v[1], v[2])
 10960      } else {
 10961          panic("instruction VPROTB takes exactly 3 operands")
 10962      }
 10963  }
 10964  
 10965  func __asm_proxy_VPROTD__(p *Program, v ...interface{}) *Instruction {
 10966      if len(v) == 3 {
 10967          return p.VPROTD(v[0], v[1], v[2])
 10968      } else {
 10969          panic("instruction VPROTD takes exactly 3 operands")
 10970      }
 10971  }
 10972  
 10973  func __asm_proxy_VPROTQ__(p *Program, v ...interface{}) *Instruction {
 10974      if len(v) == 3 {
 10975          return p.VPROTQ(v[0], v[1], v[2])
 10976      } else {
 10977          panic("instruction VPROTQ takes exactly 3 operands")
 10978      }
 10979  }
 10980  
 10981  func __asm_proxy_VPROTW__(p *Program, v ...interface{}) *Instruction {
 10982      if len(v) == 3 {
 10983          return p.VPROTW(v[0], v[1], v[2])
 10984      } else {
 10985          panic("instruction VPROTW takes exactly 3 operands")
 10986      }
 10987  }
 10988  
 10989  func __asm_proxy_VPSADBW__(p *Program, v ...interface{}) *Instruction {
 10990      if len(v) == 3 {
 10991          return p.VPSADBW(v[0], v[1], v[2])
 10992      } else {
 10993          panic("instruction VPSADBW takes exactly 3 operands")
 10994      }
 10995  }
 10996  
 10997  func __asm_proxy_VPSCATTERDD__(p *Program, v ...interface{}) *Instruction {
 10998      if len(v) == 2 {
 10999          return p.VPSCATTERDD(v[0], v[1])
 11000      } else {
 11001          panic("instruction VPSCATTERDD takes exactly 2 operands")
 11002      }
 11003  }
 11004  
 11005  func __asm_proxy_VPSCATTERDQ__(p *Program, v ...interface{}) *Instruction {
 11006      if len(v) == 2 {
 11007          return p.VPSCATTERDQ(v[0], v[1])
 11008      } else {
 11009          panic("instruction VPSCATTERDQ takes exactly 2 operands")
 11010      }
 11011  }
 11012  
 11013  func __asm_proxy_VPSCATTERQD__(p *Program, v ...interface{}) *Instruction {
 11014      if len(v) == 2 {
 11015          return p.VPSCATTERQD(v[0], v[1])
 11016      } else {
 11017          panic("instruction VPSCATTERQD takes exactly 2 operands")
 11018      }
 11019  }
 11020  
 11021  func __asm_proxy_VPSCATTERQQ__(p *Program, v ...interface{}) *Instruction {
 11022      if len(v) == 2 {
 11023          return p.VPSCATTERQQ(v[0], v[1])
 11024      } else {
 11025          panic("instruction VPSCATTERQQ takes exactly 2 operands")
 11026      }
 11027  }
 11028  
 11029  func __asm_proxy_VPSHAB__(p *Program, v ...interface{}) *Instruction {
 11030      if len(v) == 3 {
 11031          return p.VPSHAB(v[0], v[1], v[2])
 11032      } else {
 11033          panic("instruction VPSHAB takes exactly 3 operands")
 11034      }
 11035  }
 11036  
 11037  func __asm_proxy_VPSHAD__(p *Program, v ...interface{}) *Instruction {
 11038      if len(v) == 3 {
 11039          return p.VPSHAD(v[0], v[1], v[2])
 11040      } else {
 11041          panic("instruction VPSHAD takes exactly 3 operands")
 11042      }
 11043  }
 11044  
 11045  func __asm_proxy_VPSHAQ__(p *Program, v ...interface{}) *Instruction {
 11046      if len(v) == 3 {
 11047          return p.VPSHAQ(v[0], v[1], v[2])
 11048      } else {
 11049          panic("instruction VPSHAQ takes exactly 3 operands")
 11050      }
 11051  }
 11052  
 11053  func __asm_proxy_VPSHAW__(p *Program, v ...interface{}) *Instruction {
 11054      if len(v) == 3 {
 11055          return p.VPSHAW(v[0], v[1], v[2])
 11056      } else {
 11057          panic("instruction VPSHAW takes exactly 3 operands")
 11058      }
 11059  }
 11060  
 11061  func __asm_proxy_VPSHLB__(p *Program, v ...interface{}) *Instruction {
 11062      if len(v) == 3 {
 11063          return p.VPSHLB(v[0], v[1], v[2])
 11064      } else {
 11065          panic("instruction VPSHLB takes exactly 3 operands")
 11066      }
 11067  }
 11068  
 11069  func __asm_proxy_VPSHLD__(p *Program, v ...interface{}) *Instruction {
 11070      if len(v) == 3 {
 11071          return p.VPSHLD(v[0], v[1], v[2])
 11072      } else {
 11073          panic("instruction VPSHLD takes exactly 3 operands")
 11074      }
 11075  }
 11076  
 11077  func __asm_proxy_VPSHLQ__(p *Program, v ...interface{}) *Instruction {
 11078      if len(v) == 3 {
 11079          return p.VPSHLQ(v[0], v[1], v[2])
 11080      } else {
 11081          panic("instruction VPSHLQ takes exactly 3 operands")
 11082      }
 11083  }
 11084  
 11085  func __asm_proxy_VPSHLW__(p *Program, v ...interface{}) *Instruction {
 11086      if len(v) == 3 {
 11087          return p.VPSHLW(v[0], v[1], v[2])
 11088      } else {
 11089          panic("instruction VPSHLW takes exactly 3 operands")
 11090      }
 11091  }
 11092  
 11093  func __asm_proxy_VPSHUFB__(p *Program, v ...interface{}) *Instruction {
 11094      if len(v) == 3 {
 11095          return p.VPSHUFB(v[0], v[1], v[2])
 11096      } else {
 11097          panic("instruction VPSHUFB takes exactly 3 operands")
 11098      }
 11099  }
 11100  
 11101  func __asm_proxy_VPSHUFD__(p *Program, v ...interface{}) *Instruction {
 11102      if len(v) == 3 {
 11103          return p.VPSHUFD(v[0], v[1], v[2])
 11104      } else {
 11105          panic("instruction VPSHUFD takes exactly 3 operands")
 11106      }
 11107  }
 11108  
 11109  func __asm_proxy_VPSHUFHW__(p *Program, v ...interface{}) *Instruction {
 11110      if len(v) == 3 {
 11111          return p.VPSHUFHW(v[0], v[1], v[2])
 11112      } else {
 11113          panic("instruction VPSHUFHW takes exactly 3 operands")
 11114      }
 11115  }
 11116  
 11117  func __asm_proxy_VPSHUFLW__(p *Program, v ...interface{}) *Instruction {
 11118      if len(v) == 3 {
 11119          return p.VPSHUFLW(v[0], v[1], v[2])
 11120      } else {
 11121          panic("instruction VPSHUFLW takes exactly 3 operands")
 11122      }
 11123  }
 11124  
 11125  func __asm_proxy_VPSIGNB__(p *Program, v ...interface{}) *Instruction {
 11126      if len(v) == 3 {
 11127          return p.VPSIGNB(v[0], v[1], v[2])
 11128      } else {
 11129          panic("instruction VPSIGNB takes exactly 3 operands")
 11130      }
 11131  }
 11132  
 11133  func __asm_proxy_VPSIGND__(p *Program, v ...interface{}) *Instruction {
 11134      if len(v) == 3 {
 11135          return p.VPSIGND(v[0], v[1], v[2])
 11136      } else {
 11137          panic("instruction VPSIGND takes exactly 3 operands")
 11138      }
 11139  }
 11140  
 11141  func __asm_proxy_VPSIGNW__(p *Program, v ...interface{}) *Instruction {
 11142      if len(v) == 3 {
 11143          return p.VPSIGNW(v[0], v[1], v[2])
 11144      } else {
 11145          panic("instruction VPSIGNW takes exactly 3 operands")
 11146      }
 11147  }
 11148  
 11149  func __asm_proxy_VPSLLD__(p *Program, v ...interface{}) *Instruction {
 11150      if len(v) == 3 {
 11151          return p.VPSLLD(v[0], v[1], v[2])
 11152      } else {
 11153          panic("instruction VPSLLD takes exactly 3 operands")
 11154      }
 11155  }
 11156  
 11157  func __asm_proxy_VPSLLDQ__(p *Program, v ...interface{}) *Instruction {
 11158      if len(v) == 3 {
 11159          return p.VPSLLDQ(v[0], v[1], v[2])
 11160      } else {
 11161          panic("instruction VPSLLDQ takes exactly 3 operands")
 11162      }
 11163  }
 11164  
 11165  func __asm_proxy_VPSLLQ__(p *Program, v ...interface{}) *Instruction {
 11166      if len(v) == 3 {
 11167          return p.VPSLLQ(v[0], v[1], v[2])
 11168      } else {
 11169          panic("instruction VPSLLQ takes exactly 3 operands")
 11170      }
 11171  }
 11172  
 11173  func __asm_proxy_VPSLLVD__(p *Program, v ...interface{}) *Instruction {
 11174      if len(v) == 3 {
 11175          return p.VPSLLVD(v[0], v[1], v[2])
 11176      } else {
 11177          panic("instruction VPSLLVD takes exactly 3 operands")
 11178      }
 11179  }
 11180  
 11181  func __asm_proxy_VPSLLVQ__(p *Program, v ...interface{}) *Instruction {
 11182      if len(v) == 3 {
 11183          return p.VPSLLVQ(v[0], v[1], v[2])
 11184      } else {
 11185          panic("instruction VPSLLVQ takes exactly 3 operands")
 11186      }
 11187  }
 11188  
 11189  func __asm_proxy_VPSLLVW__(p *Program, v ...interface{}) *Instruction {
 11190      if len(v) == 3 {
 11191          return p.VPSLLVW(v[0], v[1], v[2])
 11192      } else {
 11193          panic("instruction VPSLLVW takes exactly 3 operands")
 11194      }
 11195  }
 11196  
 11197  func __asm_proxy_VPSLLW__(p *Program, v ...interface{}) *Instruction {
 11198      if len(v) == 3 {
 11199          return p.VPSLLW(v[0], v[1], v[2])
 11200      } else {
 11201          panic("instruction VPSLLW takes exactly 3 operands")
 11202      }
 11203  }
 11204  
 11205  func __asm_proxy_VPSRAD__(p *Program, v ...interface{}) *Instruction {
 11206      if len(v) == 3 {
 11207          return p.VPSRAD(v[0], v[1], v[2])
 11208      } else {
 11209          panic("instruction VPSRAD takes exactly 3 operands")
 11210      }
 11211  }
 11212  
 11213  func __asm_proxy_VPSRAQ__(p *Program, v ...interface{}) *Instruction {
 11214      if len(v) == 3 {
 11215          return p.VPSRAQ(v[0], v[1], v[2])
 11216      } else {
 11217          panic("instruction VPSRAQ takes exactly 3 operands")
 11218      }
 11219  }
 11220  
 11221  func __asm_proxy_VPSRAVD__(p *Program, v ...interface{}) *Instruction {
 11222      if len(v) == 3 {
 11223          return p.VPSRAVD(v[0], v[1], v[2])
 11224      } else {
 11225          panic("instruction VPSRAVD takes exactly 3 operands")
 11226      }
 11227  }
 11228  
 11229  func __asm_proxy_VPSRAVQ__(p *Program, v ...interface{}) *Instruction {
 11230      if len(v) == 3 {
 11231          return p.VPSRAVQ(v[0], v[1], v[2])
 11232      } else {
 11233          panic("instruction VPSRAVQ takes exactly 3 operands")
 11234      }
 11235  }
 11236  
 11237  func __asm_proxy_VPSRAVW__(p *Program, v ...interface{}) *Instruction {
 11238      if len(v) == 3 {
 11239          return p.VPSRAVW(v[0], v[1], v[2])
 11240      } else {
 11241          panic("instruction VPSRAVW takes exactly 3 operands")
 11242      }
 11243  }
 11244  
 11245  func __asm_proxy_VPSRAW__(p *Program, v ...interface{}) *Instruction {
 11246      if len(v) == 3 {
 11247          return p.VPSRAW(v[0], v[1], v[2])
 11248      } else {
 11249          panic("instruction VPSRAW takes exactly 3 operands")
 11250      }
 11251  }
 11252  
 11253  func __asm_proxy_VPSRLD__(p *Program, v ...interface{}) *Instruction {
 11254      if len(v) == 3 {
 11255          return p.VPSRLD(v[0], v[1], v[2])
 11256      } else {
 11257          panic("instruction VPSRLD takes exactly 3 operands")
 11258      }
 11259  }
 11260  
 11261  func __asm_proxy_VPSRLDQ__(p *Program, v ...interface{}) *Instruction {
 11262      if len(v) == 3 {
 11263          return p.VPSRLDQ(v[0], v[1], v[2])
 11264      } else {
 11265          panic("instruction VPSRLDQ takes exactly 3 operands")
 11266      }
 11267  }
 11268  
 11269  func __asm_proxy_VPSRLQ__(p *Program, v ...interface{}) *Instruction {
 11270      if len(v) == 3 {
 11271          return p.VPSRLQ(v[0], v[1], v[2])
 11272      } else {
 11273          panic("instruction VPSRLQ takes exactly 3 operands")
 11274      }
 11275  }
 11276  
 11277  func __asm_proxy_VPSRLVD__(p *Program, v ...interface{}) *Instruction {
 11278      if len(v) == 3 {
 11279          return p.VPSRLVD(v[0], v[1], v[2])
 11280      } else {
 11281          panic("instruction VPSRLVD takes exactly 3 operands")
 11282      }
 11283  }
 11284  
 11285  func __asm_proxy_VPSRLVQ__(p *Program, v ...interface{}) *Instruction {
 11286      if len(v) == 3 {
 11287          return p.VPSRLVQ(v[0], v[1], v[2])
 11288      } else {
 11289          panic("instruction VPSRLVQ takes exactly 3 operands")
 11290      }
 11291  }
 11292  
 11293  func __asm_proxy_VPSRLVW__(p *Program, v ...interface{}) *Instruction {
 11294      if len(v) == 3 {
 11295          return p.VPSRLVW(v[0], v[1], v[2])
 11296      } else {
 11297          panic("instruction VPSRLVW takes exactly 3 operands")
 11298      }
 11299  }
 11300  
 11301  func __asm_proxy_VPSRLW__(p *Program, v ...interface{}) *Instruction {
 11302      if len(v) == 3 {
 11303          return p.VPSRLW(v[0], v[1], v[2])
 11304      } else {
 11305          panic("instruction VPSRLW takes exactly 3 operands")
 11306      }
 11307  }
 11308  
 11309  func __asm_proxy_VPSUBB__(p *Program, v ...interface{}) *Instruction {
 11310      if len(v) == 3 {
 11311          return p.VPSUBB(v[0], v[1], v[2])
 11312      } else {
 11313          panic("instruction VPSUBB takes exactly 3 operands")
 11314      }
 11315  }
 11316  
 11317  func __asm_proxy_VPSUBD__(p *Program, v ...interface{}) *Instruction {
 11318      if len(v) == 3 {
 11319          return p.VPSUBD(v[0], v[1], v[2])
 11320      } else {
 11321          panic("instruction VPSUBD takes exactly 3 operands")
 11322      }
 11323  }
 11324  
 11325  func __asm_proxy_VPSUBQ__(p *Program, v ...interface{}) *Instruction {
 11326      if len(v) == 3 {
 11327          return p.VPSUBQ(v[0], v[1], v[2])
 11328      } else {
 11329          panic("instruction VPSUBQ takes exactly 3 operands")
 11330      }
 11331  }
 11332  
 11333  func __asm_proxy_VPSUBSB__(p *Program, v ...interface{}) *Instruction {
 11334      if len(v) == 3 {
 11335          return p.VPSUBSB(v[0], v[1], v[2])
 11336      } else {
 11337          panic("instruction VPSUBSB takes exactly 3 operands")
 11338      }
 11339  }
 11340  
 11341  func __asm_proxy_VPSUBSW__(p *Program, v ...interface{}) *Instruction {
 11342      if len(v) == 3 {
 11343          return p.VPSUBSW(v[0], v[1], v[2])
 11344      } else {
 11345          panic("instruction VPSUBSW takes exactly 3 operands")
 11346      }
 11347  }
 11348  
 11349  func __asm_proxy_VPSUBUSB__(p *Program, v ...interface{}) *Instruction {
 11350      if len(v) == 3 {
 11351          return p.VPSUBUSB(v[0], v[1], v[2])
 11352      } else {
 11353          panic("instruction VPSUBUSB takes exactly 3 operands")
 11354      }
 11355  }
 11356  
 11357  func __asm_proxy_VPSUBUSW__(p *Program, v ...interface{}) *Instruction {
 11358      if len(v) == 3 {
 11359          return p.VPSUBUSW(v[0], v[1], v[2])
 11360      } else {
 11361          panic("instruction VPSUBUSW takes exactly 3 operands")
 11362      }
 11363  }
 11364  
 11365  func __asm_proxy_VPSUBW__(p *Program, v ...interface{}) *Instruction {
 11366      if len(v) == 3 {
 11367          return p.VPSUBW(v[0], v[1], v[2])
 11368      } else {
 11369          panic("instruction VPSUBW takes exactly 3 operands")
 11370      }
 11371  }
 11372  
 11373  func __asm_proxy_VPTERNLOGD__(p *Program, v ...interface{}) *Instruction {
 11374      if len(v) == 4 {
 11375          return p.VPTERNLOGD(v[0], v[1], v[2], v[3])
 11376      } else {
 11377          panic("instruction VPTERNLOGD takes exactly 4 operands")
 11378      }
 11379  }
 11380  
 11381  func __asm_proxy_VPTERNLOGQ__(p *Program, v ...interface{}) *Instruction {
 11382      if len(v) == 4 {
 11383          return p.VPTERNLOGQ(v[0], v[1], v[2], v[3])
 11384      } else {
 11385          panic("instruction VPTERNLOGQ takes exactly 4 operands")
 11386      }
 11387  }
 11388  
 11389  func __asm_proxy_VPTEST__(p *Program, v ...interface{}) *Instruction {
 11390      if len(v) == 2 {
 11391          return p.VPTEST(v[0], v[1])
 11392      } else {
 11393          panic("instruction VPTEST takes exactly 2 operands")
 11394      }
 11395  }
 11396  
 11397  func __asm_proxy_VPTESTMB__(p *Program, v ...interface{}) *Instruction {
 11398      if len(v) == 3 {
 11399          return p.VPTESTMB(v[0], v[1], v[2])
 11400      } else {
 11401          panic("instruction VPTESTMB takes exactly 3 operands")
 11402      }
 11403  }
 11404  
 11405  func __asm_proxy_VPTESTMD__(p *Program, v ...interface{}) *Instruction {
 11406      if len(v) == 3 {
 11407          return p.VPTESTMD(v[0], v[1], v[2])
 11408      } else {
 11409          panic("instruction VPTESTMD takes exactly 3 operands")
 11410      }
 11411  }
 11412  
 11413  func __asm_proxy_VPTESTMQ__(p *Program, v ...interface{}) *Instruction {
 11414      if len(v) == 3 {
 11415          return p.VPTESTMQ(v[0], v[1], v[2])
 11416      } else {
 11417          panic("instruction VPTESTMQ takes exactly 3 operands")
 11418      }
 11419  }
 11420  
 11421  func __asm_proxy_VPTESTMW__(p *Program, v ...interface{}) *Instruction {
 11422      if len(v) == 3 {
 11423          return p.VPTESTMW(v[0], v[1], v[2])
 11424      } else {
 11425          panic("instruction VPTESTMW takes exactly 3 operands")
 11426      }
 11427  }
 11428  
 11429  func __asm_proxy_VPTESTNMB__(p *Program, v ...interface{}) *Instruction {
 11430      if len(v) == 3 {
 11431          return p.VPTESTNMB(v[0], v[1], v[2])
 11432      } else {
 11433          panic("instruction VPTESTNMB takes exactly 3 operands")
 11434      }
 11435  }
 11436  
 11437  func __asm_proxy_VPTESTNMD__(p *Program, v ...interface{}) *Instruction {
 11438      if len(v) == 3 {
 11439          return p.VPTESTNMD(v[0], v[1], v[2])
 11440      } else {
 11441          panic("instruction VPTESTNMD takes exactly 3 operands")
 11442      }
 11443  }
 11444  
 11445  func __asm_proxy_VPTESTNMQ__(p *Program, v ...interface{}) *Instruction {
 11446      if len(v) == 3 {
 11447          return p.VPTESTNMQ(v[0], v[1], v[2])
 11448      } else {
 11449          panic("instruction VPTESTNMQ takes exactly 3 operands")
 11450      }
 11451  }
 11452  
 11453  func __asm_proxy_VPTESTNMW__(p *Program, v ...interface{}) *Instruction {
 11454      if len(v) == 3 {
 11455          return p.VPTESTNMW(v[0], v[1], v[2])
 11456      } else {
 11457          panic("instruction VPTESTNMW takes exactly 3 operands")
 11458      }
 11459  }
 11460  
 11461  func __asm_proxy_VPUNPCKHBW__(p *Program, v ...interface{}) *Instruction {
 11462      if len(v) == 3 {
 11463          return p.VPUNPCKHBW(v[0], v[1], v[2])
 11464      } else {
 11465          panic("instruction VPUNPCKHBW takes exactly 3 operands")
 11466      }
 11467  }
 11468  
 11469  func __asm_proxy_VPUNPCKHDQ__(p *Program, v ...interface{}) *Instruction {
 11470      if len(v) == 3 {
 11471          return p.VPUNPCKHDQ(v[0], v[1], v[2])
 11472      } else {
 11473          panic("instruction VPUNPCKHDQ takes exactly 3 operands")
 11474      }
 11475  }
 11476  
 11477  func __asm_proxy_VPUNPCKHQDQ__(p *Program, v ...interface{}) *Instruction {
 11478      if len(v) == 3 {
 11479          return p.VPUNPCKHQDQ(v[0], v[1], v[2])
 11480      } else {
 11481          panic("instruction VPUNPCKHQDQ takes exactly 3 operands")
 11482      }
 11483  }
 11484  
 11485  func __asm_proxy_VPUNPCKHWD__(p *Program, v ...interface{}) *Instruction {
 11486      if len(v) == 3 {
 11487          return p.VPUNPCKHWD(v[0], v[1], v[2])
 11488      } else {
 11489          panic("instruction VPUNPCKHWD takes exactly 3 operands")
 11490      }
 11491  }
 11492  
 11493  func __asm_proxy_VPUNPCKLBW__(p *Program, v ...interface{}) *Instruction {
 11494      if len(v) == 3 {
 11495          return p.VPUNPCKLBW(v[0], v[1], v[2])
 11496      } else {
 11497          panic("instruction VPUNPCKLBW takes exactly 3 operands")
 11498      }
 11499  }
 11500  
 11501  func __asm_proxy_VPUNPCKLDQ__(p *Program, v ...interface{}) *Instruction {
 11502      if len(v) == 3 {
 11503          return p.VPUNPCKLDQ(v[0], v[1], v[2])
 11504      } else {
 11505          panic("instruction VPUNPCKLDQ takes exactly 3 operands")
 11506      }
 11507  }
 11508  
 11509  func __asm_proxy_VPUNPCKLQDQ__(p *Program, v ...interface{}) *Instruction {
 11510      if len(v) == 3 {
 11511          return p.VPUNPCKLQDQ(v[0], v[1], v[2])
 11512      } else {
 11513          panic("instruction VPUNPCKLQDQ takes exactly 3 operands")
 11514      }
 11515  }
 11516  
 11517  func __asm_proxy_VPUNPCKLWD__(p *Program, v ...interface{}) *Instruction {
 11518      if len(v) == 3 {
 11519          return p.VPUNPCKLWD(v[0], v[1], v[2])
 11520      } else {
 11521          panic("instruction VPUNPCKLWD takes exactly 3 operands")
 11522      }
 11523  }
 11524  
 11525  func __asm_proxy_VPXOR__(p *Program, v ...interface{}) *Instruction {
 11526      if len(v) == 3 {
 11527          return p.VPXOR(v[0], v[1], v[2])
 11528      } else {
 11529          panic("instruction VPXOR takes exactly 3 operands")
 11530      }
 11531  }
 11532  
 11533  func __asm_proxy_VPXORD__(p *Program, v ...interface{}) *Instruction {
 11534      if len(v) == 3 {
 11535          return p.VPXORD(v[0], v[1], v[2])
 11536      } else {
 11537          panic("instruction VPXORD takes exactly 3 operands")
 11538      }
 11539  }
 11540  
 11541  func __asm_proxy_VPXORQ__(p *Program, v ...interface{}) *Instruction {
 11542      if len(v) == 3 {
 11543          return p.VPXORQ(v[0], v[1], v[2])
 11544      } else {
 11545          panic("instruction VPXORQ takes exactly 3 operands")
 11546      }
 11547  }
 11548  
 11549  func __asm_proxy_VRANGEPD__(p *Program, v ...interface{}) *Instruction {
 11550      switch len(v) {
 11551          case 4  : return p.VRANGEPD(v[0], v[1], v[2], v[3])
 11552          case 5  : return p.VRANGEPD(v[0], v[1], v[2], v[3], v[4])
 11553          default : panic("instruction VRANGEPD takes 4 or 5 operands")
 11554      }
 11555  }
 11556  
 11557  func __asm_proxy_VRANGEPS__(p *Program, v ...interface{}) *Instruction {
 11558      switch len(v) {
 11559          case 4  : return p.VRANGEPS(v[0], v[1], v[2], v[3])
 11560          case 5  : return p.VRANGEPS(v[0], v[1], v[2], v[3], v[4])
 11561          default : panic("instruction VRANGEPS takes 4 or 5 operands")
 11562      }
 11563  }
 11564  
 11565  func __asm_proxy_VRANGESD__(p *Program, v ...interface{}) *Instruction {
 11566      switch len(v) {
 11567          case 4  : return p.VRANGESD(v[0], v[1], v[2], v[3])
 11568          case 5  : return p.VRANGESD(v[0], v[1], v[2], v[3], v[4])
 11569          default : panic("instruction VRANGESD takes 4 or 5 operands")
 11570      }
 11571  }
 11572  
 11573  func __asm_proxy_VRANGESS__(p *Program, v ...interface{}) *Instruction {
 11574      switch len(v) {
 11575          case 4  : return p.VRANGESS(v[0], v[1], v[2], v[3])
 11576          case 5  : return p.VRANGESS(v[0], v[1], v[2], v[3], v[4])
 11577          default : panic("instruction VRANGESS takes 4 or 5 operands")
 11578      }
 11579  }
 11580  
 11581  func __asm_proxy_VRCP14PD__(p *Program, v ...interface{}) *Instruction {
 11582      if len(v) == 2 {
 11583          return p.VRCP14PD(v[0], v[1])
 11584      } else {
 11585          panic("instruction VRCP14PD takes exactly 2 operands")
 11586      }
 11587  }
 11588  
 11589  func __asm_proxy_VRCP14PS__(p *Program, v ...interface{}) *Instruction {
 11590      if len(v) == 2 {
 11591          return p.VRCP14PS(v[0], v[1])
 11592      } else {
 11593          panic("instruction VRCP14PS takes exactly 2 operands")
 11594      }
 11595  }
 11596  
 11597  func __asm_proxy_VRCP14SD__(p *Program, v ...interface{}) *Instruction {
 11598      if len(v) == 3 {
 11599          return p.VRCP14SD(v[0], v[1], v[2])
 11600      } else {
 11601          panic("instruction VRCP14SD takes exactly 3 operands")
 11602      }
 11603  }
 11604  
 11605  func __asm_proxy_VRCP14SS__(p *Program, v ...interface{}) *Instruction {
 11606      if len(v) == 3 {
 11607          return p.VRCP14SS(v[0], v[1], v[2])
 11608      } else {
 11609          panic("instruction VRCP14SS takes exactly 3 operands")
 11610      }
 11611  }
 11612  
 11613  func __asm_proxy_VRCP28PD__(p *Program, v ...interface{}) *Instruction {
 11614      switch len(v) {
 11615          case 2  : return p.VRCP28PD(v[0], v[1])
 11616          case 3  : return p.VRCP28PD(v[0], v[1], v[2])
 11617          default : panic("instruction VRCP28PD takes 2 or 3 operands")
 11618      }
 11619  }
 11620  
 11621  func __asm_proxy_VRCP28PS__(p *Program, v ...interface{}) *Instruction {
 11622      switch len(v) {
 11623          case 2  : return p.VRCP28PS(v[0], v[1])
 11624          case 3  : return p.VRCP28PS(v[0], v[1], v[2])
 11625          default : panic("instruction VRCP28PS takes 2 or 3 operands")
 11626      }
 11627  }
 11628  
 11629  func __asm_proxy_VRCP28SD__(p *Program, v ...interface{}) *Instruction {
 11630      switch len(v) {
 11631          case 3  : return p.VRCP28SD(v[0], v[1], v[2])
 11632          case 4  : return p.VRCP28SD(v[0], v[1], v[2], v[3])
 11633          default : panic("instruction VRCP28SD takes 3 or 4 operands")
 11634      }
 11635  }
 11636  
 11637  func __asm_proxy_VRCP28SS__(p *Program, v ...interface{}) *Instruction {
 11638      switch len(v) {
 11639          case 3  : return p.VRCP28SS(v[0], v[1], v[2])
 11640          case 4  : return p.VRCP28SS(v[0], v[1], v[2], v[3])
 11641          default : panic("instruction VRCP28SS takes 3 or 4 operands")
 11642      }
 11643  }
 11644  
 11645  func __asm_proxy_VRCPPS__(p *Program, v ...interface{}) *Instruction {
 11646      if len(v) == 2 {
 11647          return p.VRCPPS(v[0], v[1])
 11648      } else {
 11649          panic("instruction VRCPPS takes exactly 2 operands")
 11650      }
 11651  }
 11652  
 11653  func __asm_proxy_VRCPSS__(p *Program, v ...interface{}) *Instruction {
 11654      if len(v) == 3 {
 11655          return p.VRCPSS(v[0], v[1], v[2])
 11656      } else {
 11657          panic("instruction VRCPSS takes exactly 3 operands")
 11658      }
 11659  }
 11660  
 11661  func __asm_proxy_VREDUCEPD__(p *Program, v ...interface{}) *Instruction {
 11662      if len(v) == 3 {
 11663          return p.VREDUCEPD(v[0], v[1], v[2])
 11664      } else {
 11665          panic("instruction VREDUCEPD takes exactly 3 operands")
 11666      }
 11667  }
 11668  
 11669  func __asm_proxy_VREDUCEPS__(p *Program, v ...interface{}) *Instruction {
 11670      if len(v) == 3 {
 11671          return p.VREDUCEPS(v[0], v[1], v[2])
 11672      } else {
 11673          panic("instruction VREDUCEPS takes exactly 3 operands")
 11674      }
 11675  }
 11676  
 11677  func __asm_proxy_VREDUCESD__(p *Program, v ...interface{}) *Instruction {
 11678      if len(v) == 4 {
 11679          return p.VREDUCESD(v[0], v[1], v[2], v[3])
 11680      } else {
 11681          panic("instruction VREDUCESD takes exactly 4 operands")
 11682      }
 11683  }
 11684  
 11685  func __asm_proxy_VREDUCESS__(p *Program, v ...interface{}) *Instruction {
 11686      if len(v) == 4 {
 11687          return p.VREDUCESS(v[0], v[1], v[2], v[3])
 11688      } else {
 11689          panic("instruction VREDUCESS takes exactly 4 operands")
 11690      }
 11691  }
 11692  
 11693  func __asm_proxy_VRNDSCALEPD__(p *Program, v ...interface{}) *Instruction {
 11694      switch len(v) {
 11695          case 3  : return p.VRNDSCALEPD(v[0], v[1], v[2])
 11696          case 4  : return p.VRNDSCALEPD(v[0], v[1], v[2], v[3])
 11697          default : panic("instruction VRNDSCALEPD takes 3 or 4 operands")
 11698      }
 11699  }
 11700  
 11701  func __asm_proxy_VRNDSCALEPS__(p *Program, v ...interface{}) *Instruction {
 11702      switch len(v) {
 11703          case 3  : return p.VRNDSCALEPS(v[0], v[1], v[2])
 11704          case 4  : return p.VRNDSCALEPS(v[0], v[1], v[2], v[3])
 11705          default : panic("instruction VRNDSCALEPS takes 3 or 4 operands")
 11706      }
 11707  }
 11708  
 11709  func __asm_proxy_VRNDSCALESD__(p *Program, v ...interface{}) *Instruction {
 11710      switch len(v) {
 11711          case 4  : return p.VRNDSCALESD(v[0], v[1], v[2], v[3])
 11712          case 5  : return p.VRNDSCALESD(v[0], v[1], v[2], v[3], v[4])
 11713          default : panic("instruction VRNDSCALESD takes 4 or 5 operands")
 11714      }
 11715  }
 11716  
 11717  func __asm_proxy_VRNDSCALESS__(p *Program, v ...interface{}) *Instruction {
 11718      switch len(v) {
 11719          case 4  : return p.VRNDSCALESS(v[0], v[1], v[2], v[3])
 11720          case 5  : return p.VRNDSCALESS(v[0], v[1], v[2], v[3], v[4])
 11721          default : panic("instruction VRNDSCALESS takes 4 or 5 operands")
 11722      }
 11723  }
 11724  
 11725  func __asm_proxy_VROUNDPD__(p *Program, v ...interface{}) *Instruction {
 11726      if len(v) == 3 {
 11727          return p.VROUNDPD(v[0], v[1], v[2])
 11728      } else {
 11729          panic("instruction VROUNDPD takes exactly 3 operands")
 11730      }
 11731  }
 11732  
 11733  func __asm_proxy_VROUNDPS__(p *Program, v ...interface{}) *Instruction {
 11734      if len(v) == 3 {
 11735          return p.VROUNDPS(v[0], v[1], v[2])
 11736      } else {
 11737          panic("instruction VROUNDPS takes exactly 3 operands")
 11738      }
 11739  }
 11740  
 11741  func __asm_proxy_VROUNDSD__(p *Program, v ...interface{}) *Instruction {
 11742      if len(v) == 4 {
 11743          return p.VROUNDSD(v[0], v[1], v[2], v[3])
 11744      } else {
 11745          panic("instruction VROUNDSD takes exactly 4 operands")
 11746      }
 11747  }
 11748  
 11749  func __asm_proxy_VROUNDSS__(p *Program, v ...interface{}) *Instruction {
 11750      if len(v) == 4 {
 11751          return p.VROUNDSS(v[0], v[1], v[2], v[3])
 11752      } else {
 11753          panic("instruction VROUNDSS takes exactly 4 operands")
 11754      }
 11755  }
 11756  
 11757  func __asm_proxy_VRSQRT14PD__(p *Program, v ...interface{}) *Instruction {
 11758      if len(v) == 2 {
 11759          return p.VRSQRT14PD(v[0], v[1])
 11760      } else {
 11761          panic("instruction VRSQRT14PD takes exactly 2 operands")
 11762      }
 11763  }
 11764  
 11765  func __asm_proxy_VRSQRT14PS__(p *Program, v ...interface{}) *Instruction {
 11766      if len(v) == 2 {
 11767          return p.VRSQRT14PS(v[0], v[1])
 11768      } else {
 11769          panic("instruction VRSQRT14PS takes exactly 2 operands")
 11770      }
 11771  }
 11772  
 11773  func __asm_proxy_VRSQRT14SD__(p *Program, v ...interface{}) *Instruction {
 11774      if len(v) == 3 {
 11775          return p.VRSQRT14SD(v[0], v[1], v[2])
 11776      } else {
 11777          panic("instruction VRSQRT14SD takes exactly 3 operands")
 11778      }
 11779  }
 11780  
 11781  func __asm_proxy_VRSQRT14SS__(p *Program, v ...interface{}) *Instruction {
 11782      if len(v) == 3 {
 11783          return p.VRSQRT14SS(v[0], v[1], v[2])
 11784      } else {
 11785          panic("instruction VRSQRT14SS takes exactly 3 operands")
 11786      }
 11787  }
 11788  
 11789  func __asm_proxy_VRSQRT28PD__(p *Program, v ...interface{}) *Instruction {
 11790      switch len(v) {
 11791          case 2  : return p.VRSQRT28PD(v[0], v[1])
 11792          case 3  : return p.VRSQRT28PD(v[0], v[1], v[2])
 11793          default : panic("instruction VRSQRT28PD takes 2 or 3 operands")
 11794      }
 11795  }
 11796  
 11797  func __asm_proxy_VRSQRT28PS__(p *Program, v ...interface{}) *Instruction {
 11798      switch len(v) {
 11799          case 2  : return p.VRSQRT28PS(v[0], v[1])
 11800          case 3  : return p.VRSQRT28PS(v[0], v[1], v[2])
 11801          default : panic("instruction VRSQRT28PS takes 2 or 3 operands")
 11802      }
 11803  }
 11804  
 11805  func __asm_proxy_VRSQRT28SD__(p *Program, v ...interface{}) *Instruction {
 11806      switch len(v) {
 11807          case 3  : return p.VRSQRT28SD(v[0], v[1], v[2])
 11808          case 4  : return p.VRSQRT28SD(v[0], v[1], v[2], v[3])
 11809          default : panic("instruction VRSQRT28SD takes 3 or 4 operands")
 11810      }
 11811  }
 11812  
 11813  func __asm_proxy_VRSQRT28SS__(p *Program, v ...interface{}) *Instruction {
 11814      switch len(v) {
 11815          case 3  : return p.VRSQRT28SS(v[0], v[1], v[2])
 11816          case 4  : return p.VRSQRT28SS(v[0], v[1], v[2], v[3])
 11817          default : panic("instruction VRSQRT28SS takes 3 or 4 operands")
 11818      }
 11819  }
 11820  
 11821  func __asm_proxy_VRSQRTPS__(p *Program, v ...interface{}) *Instruction {
 11822      if len(v) == 2 {
 11823          return p.VRSQRTPS(v[0], v[1])
 11824      } else {
 11825          panic("instruction VRSQRTPS takes exactly 2 operands")
 11826      }
 11827  }
 11828  
 11829  func __asm_proxy_VRSQRTSS__(p *Program, v ...interface{}) *Instruction {
 11830      if len(v) == 3 {
 11831          return p.VRSQRTSS(v[0], v[1], v[2])
 11832      } else {
 11833          panic("instruction VRSQRTSS takes exactly 3 operands")
 11834      }
 11835  }
 11836  
 11837  func __asm_proxy_VSCALEFPD__(p *Program, v ...interface{}) *Instruction {
 11838      switch len(v) {
 11839          case 3  : return p.VSCALEFPD(v[0], v[1], v[2])
 11840          case 4  : return p.VSCALEFPD(v[0], v[1], v[2], v[3])
 11841          default : panic("instruction VSCALEFPD takes 3 or 4 operands")
 11842      }
 11843  }
 11844  
 11845  func __asm_proxy_VSCALEFPS__(p *Program, v ...interface{}) *Instruction {
 11846      switch len(v) {
 11847          case 3  : return p.VSCALEFPS(v[0], v[1], v[2])
 11848          case 4  : return p.VSCALEFPS(v[0], v[1], v[2], v[3])
 11849          default : panic("instruction VSCALEFPS takes 3 or 4 operands")
 11850      }
 11851  }
 11852  
 11853  func __asm_proxy_VSCALEFSD__(p *Program, v ...interface{}) *Instruction {
 11854      switch len(v) {
 11855          case 3  : return p.VSCALEFSD(v[0], v[1], v[2])
 11856          case 4  : return p.VSCALEFSD(v[0], v[1], v[2], v[3])
 11857          default : panic("instruction VSCALEFSD takes 3 or 4 operands")
 11858      }
 11859  }
 11860  
 11861  func __asm_proxy_VSCALEFSS__(p *Program, v ...interface{}) *Instruction {
 11862      switch len(v) {
 11863          case 3  : return p.VSCALEFSS(v[0], v[1], v[2])
 11864          case 4  : return p.VSCALEFSS(v[0], v[1], v[2], v[3])
 11865          default : panic("instruction VSCALEFSS takes 3 or 4 operands")
 11866      }
 11867  }
 11868  
 11869  func __asm_proxy_VSCATTERDPD__(p *Program, v ...interface{}) *Instruction {
 11870      if len(v) == 2 {
 11871          return p.VSCATTERDPD(v[0], v[1])
 11872      } else {
 11873          panic("instruction VSCATTERDPD takes exactly 2 operands")
 11874      }
 11875  }
 11876  
 11877  func __asm_proxy_VSCATTERDPS__(p *Program, v ...interface{}) *Instruction {
 11878      if len(v) == 2 {
 11879          return p.VSCATTERDPS(v[0], v[1])
 11880      } else {
 11881          panic("instruction VSCATTERDPS takes exactly 2 operands")
 11882      }
 11883  }
 11884  
 11885  func __asm_proxy_VSCATTERPF0DPD__(p *Program, v ...interface{}) *Instruction {
 11886      if len(v) == 1 {
 11887          return p.VSCATTERPF0DPD(v[0])
 11888      } else {
 11889          panic("instruction VSCATTERPF0DPD takes exactly 1 operand")
 11890      }
 11891  }
 11892  
 11893  func __asm_proxy_VSCATTERPF0DPS__(p *Program, v ...interface{}) *Instruction {
 11894      if len(v) == 1 {
 11895          return p.VSCATTERPF0DPS(v[0])
 11896      } else {
 11897          panic("instruction VSCATTERPF0DPS takes exactly 1 operand")
 11898      }
 11899  }
 11900  
 11901  func __asm_proxy_VSCATTERPF0QPD__(p *Program, v ...interface{}) *Instruction {
 11902      if len(v) == 1 {
 11903          return p.VSCATTERPF0QPD(v[0])
 11904      } else {
 11905          panic("instruction VSCATTERPF0QPD takes exactly 1 operand")
 11906      }
 11907  }
 11908  
 11909  func __asm_proxy_VSCATTERPF0QPS__(p *Program, v ...interface{}) *Instruction {
 11910      if len(v) == 1 {
 11911          return p.VSCATTERPF0QPS(v[0])
 11912      } else {
 11913          panic("instruction VSCATTERPF0QPS takes exactly 1 operand")
 11914      }
 11915  }
 11916  
 11917  func __asm_proxy_VSCATTERPF1DPD__(p *Program, v ...interface{}) *Instruction {
 11918      if len(v) == 1 {
 11919          return p.VSCATTERPF1DPD(v[0])
 11920      } else {
 11921          panic("instruction VSCATTERPF1DPD takes exactly 1 operand")
 11922      }
 11923  }
 11924  
 11925  func __asm_proxy_VSCATTERPF1DPS__(p *Program, v ...interface{}) *Instruction {
 11926      if len(v) == 1 {
 11927          return p.VSCATTERPF1DPS(v[0])
 11928      } else {
 11929          panic("instruction VSCATTERPF1DPS takes exactly 1 operand")
 11930      }
 11931  }
 11932  
 11933  func __asm_proxy_VSCATTERPF1QPD__(p *Program, v ...interface{}) *Instruction {
 11934      if len(v) == 1 {
 11935          return p.VSCATTERPF1QPD(v[0])
 11936      } else {
 11937          panic("instruction VSCATTERPF1QPD takes exactly 1 operand")
 11938      }
 11939  }
 11940  
 11941  func __asm_proxy_VSCATTERPF1QPS__(p *Program, v ...interface{}) *Instruction {
 11942      if len(v) == 1 {
 11943          return p.VSCATTERPF1QPS(v[0])
 11944      } else {
 11945          panic("instruction VSCATTERPF1QPS takes exactly 1 operand")
 11946      }
 11947  }
 11948  
 11949  func __asm_proxy_VSCATTERQPD__(p *Program, v ...interface{}) *Instruction {
 11950      if len(v) == 2 {
 11951          return p.VSCATTERQPD(v[0], v[1])
 11952      } else {
 11953          panic("instruction VSCATTERQPD takes exactly 2 operands")
 11954      }
 11955  }
 11956  
 11957  func __asm_proxy_VSCATTERQPS__(p *Program, v ...interface{}) *Instruction {
 11958      if len(v) == 2 {
 11959          return p.VSCATTERQPS(v[0], v[1])
 11960      } else {
 11961          panic("instruction VSCATTERQPS takes exactly 2 operands")
 11962      }
 11963  }
 11964  
 11965  func __asm_proxy_VSHUFF32X4__(p *Program, v ...interface{}) *Instruction {
 11966      if len(v) == 4 {
 11967          return p.VSHUFF32X4(v[0], v[1], v[2], v[3])
 11968      } else {
 11969          panic("instruction VSHUFF32X4 takes exactly 4 operands")
 11970      }
 11971  }
 11972  
 11973  func __asm_proxy_VSHUFF64X2__(p *Program, v ...interface{}) *Instruction {
 11974      if len(v) == 4 {
 11975          return p.VSHUFF64X2(v[0], v[1], v[2], v[3])
 11976      } else {
 11977          panic("instruction VSHUFF64X2 takes exactly 4 operands")
 11978      }
 11979  }
 11980  
 11981  func __asm_proxy_VSHUFI32X4__(p *Program, v ...interface{}) *Instruction {
 11982      if len(v) == 4 {
 11983          return p.VSHUFI32X4(v[0], v[1], v[2], v[3])
 11984      } else {
 11985          panic("instruction VSHUFI32X4 takes exactly 4 operands")
 11986      }
 11987  }
 11988  
 11989  func __asm_proxy_VSHUFI64X2__(p *Program, v ...interface{}) *Instruction {
 11990      if len(v) == 4 {
 11991          return p.VSHUFI64X2(v[0], v[1], v[2], v[3])
 11992      } else {
 11993          panic("instruction VSHUFI64X2 takes exactly 4 operands")
 11994      }
 11995  }
 11996  
 11997  func __asm_proxy_VSHUFPD__(p *Program, v ...interface{}) *Instruction {
 11998      if len(v) == 4 {
 11999          return p.VSHUFPD(v[0], v[1], v[2], v[3])
 12000      } else {
 12001          panic("instruction VSHUFPD takes exactly 4 operands")
 12002      }
 12003  }
 12004  
 12005  func __asm_proxy_VSHUFPS__(p *Program, v ...interface{}) *Instruction {
 12006      if len(v) == 4 {
 12007          return p.VSHUFPS(v[0], v[1], v[2], v[3])
 12008      } else {
 12009          panic("instruction VSHUFPS takes exactly 4 operands")
 12010      }
 12011  }
 12012  
 12013  func __asm_proxy_VSQRTPD__(p *Program, v ...interface{}) *Instruction {
 12014      switch len(v) {
 12015          case 2  : return p.VSQRTPD(v[0], v[1])
 12016          case 3  : return p.VSQRTPD(v[0], v[1], v[2])
 12017          default : panic("instruction VSQRTPD takes 2 or 3 operands")
 12018      }
 12019  }
 12020  
 12021  func __asm_proxy_VSQRTPS__(p *Program, v ...interface{}) *Instruction {
 12022      switch len(v) {
 12023          case 2  : return p.VSQRTPS(v[0], v[1])
 12024          case 3  : return p.VSQRTPS(v[0], v[1], v[2])
 12025          default : panic("instruction VSQRTPS takes 2 or 3 operands")
 12026      }
 12027  }
 12028  
 12029  func __asm_proxy_VSQRTSD__(p *Program, v ...interface{}) *Instruction {
 12030      switch len(v) {
 12031          case 3  : return p.VSQRTSD(v[0], v[1], v[2])
 12032          case 4  : return p.VSQRTSD(v[0], v[1], v[2], v[3])
 12033          default : panic("instruction VSQRTSD takes 3 or 4 operands")
 12034      }
 12035  }
 12036  
 12037  func __asm_proxy_VSQRTSS__(p *Program, v ...interface{}) *Instruction {
 12038      switch len(v) {
 12039          case 3  : return p.VSQRTSS(v[0], v[1], v[2])
 12040          case 4  : return p.VSQRTSS(v[0], v[1], v[2], v[3])
 12041          default : panic("instruction VSQRTSS takes 3 or 4 operands")
 12042      }
 12043  }
 12044  
 12045  func __asm_proxy_VSTMXCSR__(p *Program, v ...interface{}) *Instruction {
 12046      if len(v) == 1 {
 12047          return p.VSTMXCSR(v[0])
 12048      } else {
 12049          panic("instruction VSTMXCSR takes exactly 1 operand")
 12050      }
 12051  }
 12052  
 12053  func __asm_proxy_VSUBPD__(p *Program, v ...interface{}) *Instruction {
 12054      switch len(v) {
 12055          case 3  : return p.VSUBPD(v[0], v[1], v[2])
 12056          case 4  : return p.VSUBPD(v[0], v[1], v[2], v[3])
 12057          default : panic("instruction VSUBPD takes 3 or 4 operands")
 12058      }
 12059  }
 12060  
 12061  func __asm_proxy_VSUBPS__(p *Program, v ...interface{}) *Instruction {
 12062      switch len(v) {
 12063          case 3  : return p.VSUBPS(v[0], v[1], v[2])
 12064          case 4  : return p.VSUBPS(v[0], v[1], v[2], v[3])
 12065          default : panic("instruction VSUBPS takes 3 or 4 operands")
 12066      }
 12067  }
 12068  
 12069  func __asm_proxy_VSUBSD__(p *Program, v ...interface{}) *Instruction {
 12070      switch len(v) {
 12071          case 3  : return p.VSUBSD(v[0], v[1], v[2])
 12072          case 4  : return p.VSUBSD(v[0], v[1], v[2], v[3])
 12073          default : panic("instruction VSUBSD takes 3 or 4 operands")
 12074      }
 12075  }
 12076  
 12077  func __asm_proxy_VSUBSS__(p *Program, v ...interface{}) *Instruction {
 12078      switch len(v) {
 12079          case 3  : return p.VSUBSS(v[0], v[1], v[2])
 12080          case 4  : return p.VSUBSS(v[0], v[1], v[2], v[3])
 12081          default : panic("instruction VSUBSS takes 3 or 4 operands")
 12082      }
 12083  }
 12084  
 12085  func __asm_proxy_VTESTPD__(p *Program, v ...interface{}) *Instruction {
 12086      if len(v) == 2 {
 12087          return p.VTESTPD(v[0], v[1])
 12088      } else {
 12089          panic("instruction VTESTPD takes exactly 2 operands")
 12090      }
 12091  }
 12092  
 12093  func __asm_proxy_VTESTPS__(p *Program, v ...interface{}) *Instruction {
 12094      if len(v) == 2 {
 12095          return p.VTESTPS(v[0], v[1])
 12096      } else {
 12097          panic("instruction VTESTPS takes exactly 2 operands")
 12098      }
 12099  }
 12100  
 12101  func __asm_proxy_VUCOMISD__(p *Program, v ...interface{}) *Instruction {
 12102      switch len(v) {
 12103          case 2  : return p.VUCOMISD(v[0], v[1])
 12104          case 3  : return p.VUCOMISD(v[0], v[1], v[2])
 12105          default : panic("instruction VUCOMISD takes 2 or 3 operands")
 12106      }
 12107  }
 12108  
 12109  func __asm_proxy_VUCOMISS__(p *Program, v ...interface{}) *Instruction {
 12110      switch len(v) {
 12111          case 2  : return p.VUCOMISS(v[0], v[1])
 12112          case 3  : return p.VUCOMISS(v[0], v[1], v[2])
 12113          default : panic("instruction VUCOMISS takes 2 or 3 operands")
 12114      }
 12115  }
 12116  
 12117  func __asm_proxy_VUNPCKHPD__(p *Program, v ...interface{}) *Instruction {
 12118      if len(v) == 3 {
 12119          return p.VUNPCKHPD(v[0], v[1], v[2])
 12120      } else {
 12121          panic("instruction VUNPCKHPD takes exactly 3 operands")
 12122      }
 12123  }
 12124  
 12125  func __asm_proxy_VUNPCKHPS__(p *Program, v ...interface{}) *Instruction {
 12126      if len(v) == 3 {
 12127          return p.VUNPCKHPS(v[0], v[1], v[2])
 12128      } else {
 12129          panic("instruction VUNPCKHPS takes exactly 3 operands")
 12130      }
 12131  }
 12132  
 12133  func __asm_proxy_VUNPCKLPD__(p *Program, v ...interface{}) *Instruction {
 12134      if len(v) == 3 {
 12135          return p.VUNPCKLPD(v[0], v[1], v[2])
 12136      } else {
 12137          panic("instruction VUNPCKLPD takes exactly 3 operands")
 12138      }
 12139  }
 12140  
 12141  func __asm_proxy_VUNPCKLPS__(p *Program, v ...interface{}) *Instruction {
 12142      if len(v) == 3 {
 12143          return p.VUNPCKLPS(v[0], v[1], v[2])
 12144      } else {
 12145          panic("instruction VUNPCKLPS takes exactly 3 operands")
 12146      }
 12147  }
 12148  
 12149  func __asm_proxy_VXORPD__(p *Program, v ...interface{}) *Instruction {
 12150      if len(v) == 3 {
 12151          return p.VXORPD(v[0], v[1], v[2])
 12152      } else {
 12153          panic("instruction VXORPD takes exactly 3 operands")
 12154      }
 12155  }
 12156  
 12157  func __asm_proxy_VXORPS__(p *Program, v ...interface{}) *Instruction {
 12158      if len(v) == 3 {
 12159          return p.VXORPS(v[0], v[1], v[2])
 12160      } else {
 12161          panic("instruction VXORPS takes exactly 3 operands")
 12162      }
 12163  }
 12164  
 12165  func __asm_proxy_VZEROALL__(p *Program, v ...interface{}) *Instruction {
 12166      if len(v) == 0 {
 12167          return p.VZEROALL()
 12168      } else {
 12169          panic("instruction VZEROALL takes no operands")
 12170      }
 12171  }
 12172  
 12173  func __asm_proxy_VZEROUPPER__(p *Program, v ...interface{}) *Instruction {
 12174      if len(v) == 0 {
 12175          return p.VZEROUPPER()
 12176      } else {
 12177          panic("instruction VZEROUPPER takes no operands")
 12178      }
 12179  }
 12180  
 12181  func __asm_proxy_XADDB__(p *Program, v ...interface{}) *Instruction {
 12182      if len(v) == 2 {
 12183          return p.XADDB(v[0], v[1])
 12184      } else {
 12185          panic("instruction XADDB takes exactly 2 operands")
 12186      }
 12187  }
 12188  
 12189  func __asm_proxy_XADDL__(p *Program, v ...interface{}) *Instruction {
 12190      if len(v) == 2 {
 12191          return p.XADDL(v[0], v[1])
 12192      } else {
 12193          panic("instruction XADDL takes exactly 2 operands")
 12194      }
 12195  }
 12196  
 12197  func __asm_proxy_XADDQ__(p *Program, v ...interface{}) *Instruction {
 12198      if len(v) == 2 {
 12199          return p.XADDQ(v[0], v[1])
 12200      } else {
 12201          panic("instruction XADDQ takes exactly 2 operands")
 12202      }
 12203  }
 12204  
 12205  func __asm_proxy_XADDW__(p *Program, v ...interface{}) *Instruction {
 12206      if len(v) == 2 {
 12207          return p.XADDW(v[0], v[1])
 12208      } else {
 12209          panic("instruction XADDW takes exactly 2 operands")
 12210      }
 12211  }
 12212  
 12213  func __asm_proxy_XCHGB__(p *Program, v ...interface{}) *Instruction {
 12214      if len(v) == 2 {
 12215          return p.XCHGB(v[0], v[1])
 12216      } else {
 12217          panic("instruction XCHGB takes exactly 2 operands")
 12218      }
 12219  }
 12220  
 12221  func __asm_proxy_XCHGL__(p *Program, v ...interface{}) *Instruction {
 12222      if len(v) == 2 {
 12223          return p.XCHGL(v[0], v[1])
 12224      } else {
 12225          panic("instruction XCHGL takes exactly 2 operands")
 12226      }
 12227  }
 12228  
 12229  func __asm_proxy_XCHGQ__(p *Program, v ...interface{}) *Instruction {
 12230      if len(v) == 2 {
 12231          return p.XCHGQ(v[0], v[1])
 12232      } else {
 12233          panic("instruction XCHGQ takes exactly 2 operands")
 12234      }
 12235  }
 12236  
 12237  func __asm_proxy_XCHGW__(p *Program, v ...interface{}) *Instruction {
 12238      if len(v) == 2 {
 12239          return p.XCHGW(v[0], v[1])
 12240      } else {
 12241          panic("instruction XCHGW takes exactly 2 operands")
 12242      }
 12243  }
 12244  
 12245  func __asm_proxy_XGETBV__(p *Program, v ...interface{}) *Instruction {
 12246      if len(v) == 0 {
 12247          return p.XGETBV()
 12248      } else {
 12249          panic("instruction XGETBV takes no operands")
 12250      }
 12251  }
 12252  
 12253  func __asm_proxy_XLATB__(p *Program, v ...interface{}) *Instruction {
 12254      if len(v) == 0 {
 12255          return p.XLATB()
 12256      } else {
 12257          panic("instruction XLATB takes no operands")
 12258      }
 12259  }
 12260  
 12261  func __asm_proxy_XORB__(p *Program, v ...interface{}) *Instruction {
 12262      if len(v) == 2 {
 12263          return p.XORB(v[0], v[1])
 12264      } else {
 12265          panic("instruction XORB takes exactly 2 operands")
 12266      }
 12267  }
 12268  
 12269  func __asm_proxy_XORL__(p *Program, v ...interface{}) *Instruction {
 12270      if len(v) == 2 {
 12271          return p.XORL(v[0], v[1])
 12272      } else {
 12273          panic("instruction XORL takes exactly 2 operands")
 12274      }
 12275  }
 12276  
 12277  func __asm_proxy_XORPD__(p *Program, v ...interface{}) *Instruction {
 12278      if len(v) == 2 {
 12279          return p.XORPD(v[0], v[1])
 12280      } else {
 12281          panic("instruction XORPD takes exactly 2 operands")
 12282      }
 12283  }
 12284  
 12285  func __asm_proxy_XORPS__(p *Program, v ...interface{}) *Instruction {
 12286      if len(v) == 2 {
 12287          return p.XORPS(v[0], v[1])
 12288      } else {
 12289          panic("instruction XORPS takes exactly 2 operands")
 12290      }
 12291  }
 12292  
 12293  func __asm_proxy_XORQ__(p *Program, v ...interface{}) *Instruction {
 12294      if len(v) == 2 {
 12295          return p.XORQ(v[0], v[1])
 12296      } else {
 12297          panic("instruction XORQ takes exactly 2 operands")
 12298      }
 12299  }
 12300  
 12301  func __asm_proxy_XORW__(p *Program, v ...interface{}) *Instruction {
 12302      if len(v) == 2 {
 12303          return p.XORW(v[0], v[1])
 12304      } else {
 12305          panic("instruction XORW takes exactly 2 operands")
 12306      }
 12307  }