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 }