1
2
3 package x86_64
4
5 const (
6 _N_args = 5
7 _N_forms = 23
8 )
9
10
11 var Instructions = map[string]_InstructionEncoder {
12 "adcb" : __asm_proxy_ADCB__,
13 "adcl" : __asm_proxy_ADCL__,
14 "adcq" : __asm_proxy_ADCQ__,
15 "adcw" : __asm_proxy_ADCW__,
16 "adcxl" : __asm_proxy_ADCXL__,
17 "adcxq" : __asm_proxy_ADCXQ__,
18 "addb" : __asm_proxy_ADDB__,
19 "addl" : __asm_proxy_ADDL__,
20 "addpd" : __asm_proxy_ADDPD__,
21 "addps" : __asm_proxy_ADDPS__,
22 "addq" : __asm_proxy_ADDQ__,
23 "addsd" : __asm_proxy_ADDSD__,
24 "addss" : __asm_proxy_ADDSS__,
25 "addsubpd" : __asm_proxy_ADDSUBPD__,
26 "addsubps" : __asm_proxy_ADDSUBPS__,
27 "addw" : __asm_proxy_ADDW__,
28 "adoxl" : __asm_proxy_ADOXL__,
29 "adoxq" : __asm_proxy_ADOXQ__,
30 "aesdec" : __asm_proxy_AESDEC__,
31 "aesdeclast" : __asm_proxy_AESDECLAST__,
32 "aesenc" : __asm_proxy_AESENC__,
33 "aesenclast" : __asm_proxy_AESENCLAST__,
34 "aesimc" : __asm_proxy_AESIMC__,
35 "aeskeygenassist" : __asm_proxy_AESKEYGENASSIST__,
36 "andb" : __asm_proxy_ANDB__,
37 "andl" : __asm_proxy_ANDL__,
38 "andnl" : __asm_proxy_ANDNL__,
39 "andnpd" : __asm_proxy_ANDNPD__,
40 "andnps" : __asm_proxy_ANDNPS__,
41 "andnq" : __asm_proxy_ANDNQ__,
42 "andpd" : __asm_proxy_ANDPD__,
43 "andps" : __asm_proxy_ANDPS__,
44 "andq" : __asm_proxy_ANDQ__,
45 "andw" : __asm_proxy_ANDW__,
46 "bextr" : __asm_proxy_BEXTR__,
47 "blcfill" : __asm_proxy_BLCFILL__,
48 "blci" : __asm_proxy_BLCI__,
49 "blcic" : __asm_proxy_BLCIC__,
50 "blcmsk" : __asm_proxy_BLCMSK__,
51 "blcs" : __asm_proxy_BLCS__,
52 "blendpd" : __asm_proxy_BLENDPD__,
53 "blendps" : __asm_proxy_BLENDPS__,
54 "blendvpd" : __asm_proxy_BLENDVPD__,
55 "blendvps" : __asm_proxy_BLENDVPS__,
56 "blsfill" : __asm_proxy_BLSFILL__,
57 "blsi" : __asm_proxy_BLSI__,
58 "blsic" : __asm_proxy_BLSIC__,
59 "blsmsk" : __asm_proxy_BLSMSK__,
60 "blsr" : __asm_proxy_BLSR__,
61 "bsfl" : __asm_proxy_BSFL__,
62 "bsfq" : __asm_proxy_BSFQ__,
63 "bsfw" : __asm_proxy_BSFW__,
64 "bsrl" : __asm_proxy_BSRL__,
65 "bsrq" : __asm_proxy_BSRQ__,
66 "bsrw" : __asm_proxy_BSRW__,
67 "bswapl" : __asm_proxy_BSWAPL__,
68 "bswapq" : __asm_proxy_BSWAPQ__,
69 "btcl" : __asm_proxy_BTCL__,
70 "btcq" : __asm_proxy_BTCQ__,
71 "btcw" : __asm_proxy_BTCW__,
72 "btl" : __asm_proxy_BTL__,
73 "btq" : __asm_proxy_BTQ__,
74 "btrl" : __asm_proxy_BTRL__,
75 "btrq" : __asm_proxy_BTRQ__,
76 "btrw" : __asm_proxy_BTRW__,
77 "btsl" : __asm_proxy_BTSL__,
78 "btsq" : __asm_proxy_BTSQ__,
79 "btsw" : __asm_proxy_BTSW__,
80 "btw" : __asm_proxy_BTW__,
81 "bzhi" : __asm_proxy_BZHI__,
82 "call" : __asm_proxy_CALL__,
83 "callq" : __asm_proxy_CALLQ__,
84 "cbtw" : __asm_proxy_CBTW__,
85 "clc" : __asm_proxy_CLC__,
86 "cld" : __asm_proxy_CLD__,
87 "clflush" : __asm_proxy_CLFLUSH__,
88 "clflushopt" : __asm_proxy_CLFLUSHOPT__,
89 "cltd" : __asm_proxy_CLTD__,
90 "cltq" : __asm_proxy_CLTQ__,
91 "clwb" : __asm_proxy_CLWB__,
92 "clzero" : __asm_proxy_CLZERO__,
93 "cmc" : __asm_proxy_CMC__,
94 "cmova" : __asm_proxy_CMOVA__,
95 "cmovae" : __asm_proxy_CMOVAE__,
96 "cmovb" : __asm_proxy_CMOVB__,
97 "cmovbe" : __asm_proxy_CMOVBE__,
98 "cmovc" : __asm_proxy_CMOVC__,
99 "cmove" : __asm_proxy_CMOVE__,
100 "cmovg" : __asm_proxy_CMOVG__,
101 "cmovge" : __asm_proxy_CMOVGE__,
102 "cmovl" : __asm_proxy_CMOVL__,
103 "cmovle" : __asm_proxy_CMOVLE__,
104 "cmovna" : __asm_proxy_CMOVNA__,
105 "cmovnae" : __asm_proxy_CMOVNAE__,
106 "cmovnb" : __asm_proxy_CMOVNB__,
107 "cmovnbe" : __asm_proxy_CMOVNBE__,
108 "cmovnc" : __asm_proxy_CMOVNC__,
109 "cmovne" : __asm_proxy_CMOVNE__,
110 "cmovng" : __asm_proxy_CMOVNG__,
111 "cmovnge" : __asm_proxy_CMOVNGE__,
112 "cmovnl" : __asm_proxy_CMOVNL__,
113 "cmovnle" : __asm_proxy_CMOVNLE__,
114 "cmovno" : __asm_proxy_CMOVNO__,
115 "cmovnp" : __asm_proxy_CMOVNP__,
116 "cmovns" : __asm_proxy_CMOVNS__,
117 "cmovnz" : __asm_proxy_CMOVNZ__,
118 "cmovo" : __asm_proxy_CMOVO__,
119 "cmovp" : __asm_proxy_CMOVP__,
120 "cmovpe" : __asm_proxy_CMOVPE__,
121 "cmovpo" : __asm_proxy_CMOVPO__,
122 "cmovs" : __asm_proxy_CMOVS__,
123 "cmovz" : __asm_proxy_CMOVZ__,
124 "cmpb" : __asm_proxy_CMPB__,
125 "cmpl" : __asm_proxy_CMPL__,
126 "cmppd" : __asm_proxy_CMPPD__,
127 "cmpps" : __asm_proxy_CMPPS__,
128 "cmpq" : __asm_proxy_CMPQ__,
129 "cmpsd" : __asm_proxy_CMPSD__,
130 "cmpss" : __asm_proxy_CMPSS__,
131 "cmpw" : __asm_proxy_CMPW__,
132 "cmpxchg16b" : __asm_proxy_CMPXCHG16B__,
133 "cmpxchg8b" : __asm_proxy_CMPXCHG8B__,
134 "cmpxchgb" : __asm_proxy_CMPXCHGB__,
135 "cmpxchgl" : __asm_proxy_CMPXCHGL__,
136 "cmpxchgq" : __asm_proxy_CMPXCHGQ__,
137 "cmpxchgw" : __asm_proxy_CMPXCHGW__,
138 "comisd" : __asm_proxy_COMISD__,
139 "comiss" : __asm_proxy_COMISS__,
140 "cpuid" : __asm_proxy_CPUID__,
141 "cqto" : __asm_proxy_CQTO__,
142 "crc32b" : __asm_proxy_CRC32B__,
143 "crc32l" : __asm_proxy_CRC32L__,
144 "crc32q" : __asm_proxy_CRC32Q__,
145 "crc32w" : __asm_proxy_CRC32W__,
146 "cvtdq2pd" : __asm_proxy_CVTDQ2PD__,
147 "cvtdq2ps" : __asm_proxy_CVTDQ2PS__,
148 "cvtpd2dq" : __asm_proxy_CVTPD2DQ__,
149 "cvtpd2pi" : __asm_proxy_CVTPD2PI__,
150 "cvtpd2ps" : __asm_proxy_CVTPD2PS__,
151 "cvtpi2pd" : __asm_proxy_CVTPI2PD__,
152 "cvtpi2ps" : __asm_proxy_CVTPI2PS__,
153 "cvtps2dq" : __asm_proxy_CVTPS2DQ__,
154 "cvtps2pd" : __asm_proxy_CVTPS2PD__,
155 "cvtps2pi" : __asm_proxy_CVTPS2PI__,
156 "cvtsd2si" : __asm_proxy_CVTSD2SI__,
157 "cvtsd2ss" : __asm_proxy_CVTSD2SS__,
158 "cvtsi2sd" : __asm_proxy_CVTSI2SD__,
159 "cvtsi2ss" : __asm_proxy_CVTSI2SS__,
160 "cvtss2sd" : __asm_proxy_CVTSS2SD__,
161 "cvtss2si" : __asm_proxy_CVTSS2SI__,
162 "cvttpd2dq" : __asm_proxy_CVTTPD2DQ__,
163 "cvttpd2pi" : __asm_proxy_CVTTPD2PI__,
164 "cvttps2dq" : __asm_proxy_CVTTPS2DQ__,
165 "cvttps2pi" : __asm_proxy_CVTTPS2PI__,
166 "cvttsd2si" : __asm_proxy_CVTTSD2SI__,
167 "cvttss2si" : __asm_proxy_CVTTSS2SI__,
168 "cwtd" : __asm_proxy_CWTD__,
169 "cwtl" : __asm_proxy_CWTL__,
170 "decb" : __asm_proxy_DECB__,
171 "decl" : __asm_proxy_DECL__,
172 "decq" : __asm_proxy_DECQ__,
173 "decw" : __asm_proxy_DECW__,
174 "divb" : __asm_proxy_DIVB__,
175 "divl" : __asm_proxy_DIVL__,
176 "divpd" : __asm_proxy_DIVPD__,
177 "divps" : __asm_proxy_DIVPS__,
178 "divq" : __asm_proxy_DIVQ__,
179 "divsd" : __asm_proxy_DIVSD__,
180 "divss" : __asm_proxy_DIVSS__,
181 "divw" : __asm_proxy_DIVW__,
182 "dppd" : __asm_proxy_DPPD__,
183 "dpps" : __asm_proxy_DPPS__,
184 "emms" : __asm_proxy_EMMS__,
185 "extractps" : __asm_proxy_EXTRACTPS__,
186 "extrq" : __asm_proxy_EXTRQ__,
187 "femms" : __asm_proxy_FEMMS__,
188 "haddpd" : __asm_proxy_HADDPD__,
189 "haddps" : __asm_proxy_HADDPS__,
190 "hsubpd" : __asm_proxy_HSUBPD__,
191 "hsubps" : __asm_proxy_HSUBPS__,
192 "idivb" : __asm_proxy_IDIVB__,
193 "idivl" : __asm_proxy_IDIVL__,
194 "idivq" : __asm_proxy_IDIVQ__,
195 "idivw" : __asm_proxy_IDIVW__,
196 "imulb" : __asm_proxy_IMULB__,
197 "imull" : __asm_proxy_IMULL__,
198 "imulq" : __asm_proxy_IMULQ__,
199 "imulw" : __asm_proxy_IMULW__,
200 "incb" : __asm_proxy_INCB__,
201 "incl" : __asm_proxy_INCL__,
202 "incq" : __asm_proxy_INCQ__,
203 "incw" : __asm_proxy_INCW__,
204 "insertps" : __asm_proxy_INSERTPS__,
205 "insertq" : __asm_proxy_INSERTQ__,
206 "int" : __asm_proxy_INT__,
207 "ja" : __asm_proxy_JA__,
208 "jae" : __asm_proxy_JAE__,
209 "jb" : __asm_proxy_JB__,
210 "jbe" : __asm_proxy_JBE__,
211 "jc" : __asm_proxy_JC__,
212 "je" : __asm_proxy_JE__,
213 "jecxz" : __asm_proxy_JECXZ__,
214 "jg" : __asm_proxy_JG__,
215 "jge" : __asm_proxy_JGE__,
216 "jl" : __asm_proxy_JL__,
217 "jle" : __asm_proxy_JLE__,
218 "jmp" : __asm_proxy_JMP__,
219 "jmpq" : __asm_proxy_JMPQ__,
220 "jna" : __asm_proxy_JNA__,
221 "jnae" : __asm_proxy_JNAE__,
222 "jnb" : __asm_proxy_JNB__,
223 "jnbe" : __asm_proxy_JNBE__,
224 "jnc" : __asm_proxy_JNC__,
225 "jne" : __asm_proxy_JNE__,
226 "jng" : __asm_proxy_JNG__,
227 "jnge" : __asm_proxy_JNGE__,
228 "jnl" : __asm_proxy_JNL__,
229 "jnle" : __asm_proxy_JNLE__,
230 "jno" : __asm_proxy_JNO__,
231 "jnp" : __asm_proxy_JNP__,
232 "jns" : __asm_proxy_JNS__,
233 "jnz" : __asm_proxy_JNZ__,
234 "jo" : __asm_proxy_JO__,
235 "jp" : __asm_proxy_JP__,
236 "jpe" : __asm_proxy_JPE__,
237 "jpo" : __asm_proxy_JPO__,
238 "jrcxz" : __asm_proxy_JRCXZ__,
239 "js" : __asm_proxy_JS__,
240 "jz" : __asm_proxy_JZ__,
241 "kaddb" : __asm_proxy_KADDB__,
242 "kaddd" : __asm_proxy_KADDD__,
243 "kaddq" : __asm_proxy_KADDQ__,
244 "kaddw" : __asm_proxy_KADDW__,
245 "kandb" : __asm_proxy_KANDB__,
246 "kandd" : __asm_proxy_KANDD__,
247 "kandnb" : __asm_proxy_KANDNB__,
248 "kandnd" : __asm_proxy_KANDND__,
249 "kandnq" : __asm_proxy_KANDNQ__,
250 "kandnw" : __asm_proxy_KANDNW__,
251 "kandq" : __asm_proxy_KANDQ__,
252 "kandw" : __asm_proxy_KANDW__,
253 "kmovb" : __asm_proxy_KMOVB__,
254 "kmovd" : __asm_proxy_KMOVD__,
255 "kmovq" : __asm_proxy_KMOVQ__,
256 "kmovw" : __asm_proxy_KMOVW__,
257 "knotb" : __asm_proxy_KNOTB__,
258 "knotd" : __asm_proxy_KNOTD__,
259 "knotq" : __asm_proxy_KNOTQ__,
260 "knotw" : __asm_proxy_KNOTW__,
261 "korb" : __asm_proxy_KORB__,
262 "kord" : __asm_proxy_KORD__,
263 "korq" : __asm_proxy_KORQ__,
264 "kortestb" : __asm_proxy_KORTESTB__,
265 "kortestd" : __asm_proxy_KORTESTD__,
266 "kortestq" : __asm_proxy_KORTESTQ__,
267 "kortestw" : __asm_proxy_KORTESTW__,
268 "korw" : __asm_proxy_KORW__,
269 "kshiftlb" : __asm_proxy_KSHIFTLB__,
270 "kshiftld" : __asm_proxy_KSHIFTLD__,
271 "kshiftlq" : __asm_proxy_KSHIFTLQ__,
272 "kshiftlw" : __asm_proxy_KSHIFTLW__,
273 "kshiftrb" : __asm_proxy_KSHIFTRB__,
274 "kshiftrd" : __asm_proxy_KSHIFTRD__,
275 "kshiftrq" : __asm_proxy_KSHIFTRQ__,
276 "kshiftrw" : __asm_proxy_KSHIFTRW__,
277 "ktestb" : __asm_proxy_KTESTB__,
278 "ktestd" : __asm_proxy_KTESTD__,
279 "ktestq" : __asm_proxy_KTESTQ__,
280 "ktestw" : __asm_proxy_KTESTW__,
281 "kunpckbw" : __asm_proxy_KUNPCKBW__,
282 "kunpckdq" : __asm_proxy_KUNPCKDQ__,
283 "kunpckwd" : __asm_proxy_KUNPCKWD__,
284 "kxnorb" : __asm_proxy_KXNORB__,
285 "kxnord" : __asm_proxy_KXNORD__,
286 "kxnorq" : __asm_proxy_KXNORQ__,
287 "kxnorw" : __asm_proxy_KXNORW__,
288 "kxorb" : __asm_proxy_KXORB__,
289 "kxord" : __asm_proxy_KXORD__,
290 "kxorq" : __asm_proxy_KXORQ__,
291 "kxorw" : __asm_proxy_KXORW__,
292 "lddqu" : __asm_proxy_LDDQU__,
293 "ldmxcsr" : __asm_proxy_LDMXCSR__,
294 "leal" : __asm_proxy_LEAL__,
295 "leaq" : __asm_proxy_LEAQ__,
296 "leaw" : __asm_proxy_LEAW__,
297 "lfence" : __asm_proxy_LFENCE__,
298 "lzcntl" : __asm_proxy_LZCNTL__,
299 "lzcntq" : __asm_proxy_LZCNTQ__,
300 "lzcntw" : __asm_proxy_LZCNTW__,
301 "maskmovdqu" : __asm_proxy_MASKMOVDQU__,
302 "maskmovq" : __asm_proxy_MASKMOVQ__,
303 "maxpd" : __asm_proxy_MAXPD__,
304 "maxps" : __asm_proxy_MAXPS__,
305 "maxsd" : __asm_proxy_MAXSD__,
306 "maxss" : __asm_proxy_MAXSS__,
307 "mfence" : __asm_proxy_MFENCE__,
308 "minpd" : __asm_proxy_MINPD__,
309 "minps" : __asm_proxy_MINPS__,
310 "minsd" : __asm_proxy_MINSD__,
311 "minss" : __asm_proxy_MINSS__,
312 "monitor" : __asm_proxy_MONITOR__,
313 "monitorx" : __asm_proxy_MONITORX__,
314 "movapd" : __asm_proxy_MOVAPD__,
315 "movaps" : __asm_proxy_MOVAPS__,
316 "movb" : __asm_proxy_MOVB__,
317 "movbel" : __asm_proxy_MOVBEL__,
318 "movbeq" : __asm_proxy_MOVBEQ__,
319 "movbew" : __asm_proxy_MOVBEW__,
320 "movd" : __asm_proxy_MOVD__,
321 "movddup" : __asm_proxy_MOVDDUP__,
322 "movdq2q" : __asm_proxy_MOVDQ2Q__,
323 "movdqa" : __asm_proxy_MOVDQA__,
324 "movdqu" : __asm_proxy_MOVDQU__,
325 "movhlps" : __asm_proxy_MOVHLPS__,
326 "movhpd" : __asm_proxy_MOVHPD__,
327 "movhps" : __asm_proxy_MOVHPS__,
328 "movl" : __asm_proxy_MOVL__,
329 "movlhps" : __asm_proxy_MOVLHPS__,
330 "movlpd" : __asm_proxy_MOVLPD__,
331 "movlps" : __asm_proxy_MOVLPS__,
332 "movmskpd" : __asm_proxy_MOVMSKPD__,
333 "movmskps" : __asm_proxy_MOVMSKPS__,
334 "movntdq" : __asm_proxy_MOVNTDQ__,
335 "movntdqa" : __asm_proxy_MOVNTDQA__,
336 "movntil" : __asm_proxy_MOVNTIL__,
337 "movntiq" : __asm_proxy_MOVNTIQ__,
338 "movntpd" : __asm_proxy_MOVNTPD__,
339 "movntps" : __asm_proxy_MOVNTPS__,
340 "movntq" : __asm_proxy_MOVNTQ__,
341 "movntsd" : __asm_proxy_MOVNTSD__,
342 "movntss" : __asm_proxy_MOVNTSS__,
343 "movq" : __asm_proxy_MOVQ__,
344 "movq2dq" : __asm_proxy_MOVQ2DQ__,
345 "movsbl" : __asm_proxy_MOVSBL__,
346 "movsbq" : __asm_proxy_MOVSBQ__,
347 "movsbw" : __asm_proxy_MOVSBW__,
348 "movsd" : __asm_proxy_MOVSD__,
349 "movshdup" : __asm_proxy_MOVSHDUP__,
350 "movsldup" : __asm_proxy_MOVSLDUP__,
351 "movslq" : __asm_proxy_MOVSLQ__,
352 "movss" : __asm_proxy_MOVSS__,
353 "movswl" : __asm_proxy_MOVSWL__,
354 "movswq" : __asm_proxy_MOVSWQ__,
355 "movupd" : __asm_proxy_MOVUPD__,
356 "movups" : __asm_proxy_MOVUPS__,
357 "movw" : __asm_proxy_MOVW__,
358 "movzbl" : __asm_proxy_MOVZBL__,
359 "movzbq" : __asm_proxy_MOVZBQ__,
360 "movzbw" : __asm_proxy_MOVZBW__,
361 "movzwl" : __asm_proxy_MOVZWL__,
362 "movzwq" : __asm_proxy_MOVZWQ__,
363 "mpsadbw" : __asm_proxy_MPSADBW__,
364 "mulb" : __asm_proxy_MULB__,
365 "mull" : __asm_proxy_MULL__,
366 "mulpd" : __asm_proxy_MULPD__,
367 "mulps" : __asm_proxy_MULPS__,
368 "mulq" : __asm_proxy_MULQ__,
369 "mulsd" : __asm_proxy_MULSD__,
370 "mulss" : __asm_proxy_MULSS__,
371 "mulw" : __asm_proxy_MULW__,
372 "mulxl" : __asm_proxy_MULXL__,
373 "mulxq" : __asm_proxy_MULXQ__,
374 "mwait" : __asm_proxy_MWAIT__,
375 "mwaitx" : __asm_proxy_MWAITX__,
376 "negb" : __asm_proxy_NEGB__,
377 "negl" : __asm_proxy_NEGL__,
378 "negq" : __asm_proxy_NEGQ__,
379 "negw" : __asm_proxy_NEGW__,
380 "nop" : __asm_proxy_NOP__,
381 "notb" : __asm_proxy_NOTB__,
382 "notl" : __asm_proxy_NOTL__,
383 "notq" : __asm_proxy_NOTQ__,
384 "notw" : __asm_proxy_NOTW__,
385 "orb" : __asm_proxy_ORB__,
386 "orl" : __asm_proxy_ORL__,
387 "orpd" : __asm_proxy_ORPD__,
388 "orps" : __asm_proxy_ORPS__,
389 "orq" : __asm_proxy_ORQ__,
390 "orw" : __asm_proxy_ORW__,
391 "pabsb" : __asm_proxy_PABSB__,
392 "pabsd" : __asm_proxy_PABSD__,
393 "pabsw" : __asm_proxy_PABSW__,
394 "packssdw" : __asm_proxy_PACKSSDW__,
395 "packsswb" : __asm_proxy_PACKSSWB__,
396 "packusdw" : __asm_proxy_PACKUSDW__,
397 "packuswb" : __asm_proxy_PACKUSWB__,
398 "paddb" : __asm_proxy_PADDB__,
399 "paddd" : __asm_proxy_PADDD__,
400 "paddq" : __asm_proxy_PADDQ__,
401 "paddsb" : __asm_proxy_PADDSB__,
402 "paddsw" : __asm_proxy_PADDSW__,
403 "paddusb" : __asm_proxy_PADDUSB__,
404 "paddusw" : __asm_proxy_PADDUSW__,
405 "paddw" : __asm_proxy_PADDW__,
406 "palignr" : __asm_proxy_PALIGNR__,
407 "pand" : __asm_proxy_PAND__,
408 "pandn" : __asm_proxy_PANDN__,
409 "pause" : __asm_proxy_PAUSE__,
410 "pavgb" : __asm_proxy_PAVGB__,
411 "pavgusb" : __asm_proxy_PAVGUSB__,
412 "pavgw" : __asm_proxy_PAVGW__,
413 "pblendvb" : __asm_proxy_PBLENDVB__,
414 "pblendw" : __asm_proxy_PBLENDW__,
415 "pclmulqdq" : __asm_proxy_PCLMULQDQ__,
416 "pcmpeqb" : __asm_proxy_PCMPEQB__,
417 "pcmpeqd" : __asm_proxy_PCMPEQD__,
418 "pcmpeqq" : __asm_proxy_PCMPEQQ__,
419 "pcmpeqw" : __asm_proxy_PCMPEQW__,
420 "pcmpestri" : __asm_proxy_PCMPESTRI__,
421 "pcmpestrm" : __asm_proxy_PCMPESTRM__,
422 "pcmpgtb" : __asm_proxy_PCMPGTB__,
423 "pcmpgtd" : __asm_proxy_PCMPGTD__,
424 "pcmpgtq" : __asm_proxy_PCMPGTQ__,
425 "pcmpgtw" : __asm_proxy_PCMPGTW__,
426 "pcmpistri" : __asm_proxy_PCMPISTRI__,
427 "pcmpistrm" : __asm_proxy_PCMPISTRM__,
428 "pdep" : __asm_proxy_PDEP__,
429 "pext" : __asm_proxy_PEXT__,
430 "pextrb" : __asm_proxy_PEXTRB__,
431 "pextrd" : __asm_proxy_PEXTRD__,
432 "pextrq" : __asm_proxy_PEXTRQ__,
433 "pextrw" : __asm_proxy_PEXTRW__,
434 "pf2id" : __asm_proxy_PF2ID__,
435 "pf2iw" : __asm_proxy_PF2IW__,
436 "pfacc" : __asm_proxy_PFACC__,
437 "pfadd" : __asm_proxy_PFADD__,
438 "pfcmpeq" : __asm_proxy_PFCMPEQ__,
439 "pfcmpge" : __asm_proxy_PFCMPGE__,
440 "pfcmpgt" : __asm_proxy_PFCMPGT__,
441 "pfmax" : __asm_proxy_PFMAX__,
442 "pfmin" : __asm_proxy_PFMIN__,
443 "pfmul" : __asm_proxy_PFMUL__,
444 "pfnacc" : __asm_proxy_PFNACC__,
445 "pfpnacc" : __asm_proxy_PFPNACC__,
446 "pfrcp" : __asm_proxy_PFRCP__,
447 "pfrcpit1" : __asm_proxy_PFRCPIT1__,
448 "pfrcpit2" : __asm_proxy_PFRCPIT2__,
449 "pfrsqit1" : __asm_proxy_PFRSQIT1__,
450 "pfrsqrt" : __asm_proxy_PFRSQRT__,
451 "pfsub" : __asm_proxy_PFSUB__,
452 "pfsubr" : __asm_proxy_PFSUBR__,
453 "phaddd" : __asm_proxy_PHADDD__,
454 "phaddsw" : __asm_proxy_PHADDSW__,
455 "phaddw" : __asm_proxy_PHADDW__,
456 "phminposuw" : __asm_proxy_PHMINPOSUW__,
457 "phsubd" : __asm_proxy_PHSUBD__,
458 "phsubsw" : __asm_proxy_PHSUBSW__,
459 "phsubw" : __asm_proxy_PHSUBW__,
460 "pi2fd" : __asm_proxy_PI2FD__,
461 "pi2fw" : __asm_proxy_PI2FW__,
462 "pinsrb" : __asm_proxy_PINSRB__,
463 "pinsrd" : __asm_proxy_PINSRD__,
464 "pinsrq" : __asm_proxy_PINSRQ__,
465 "pinsrw" : __asm_proxy_PINSRW__,
466 "pmaddubsw" : __asm_proxy_PMADDUBSW__,
467 "pmaddwd" : __asm_proxy_PMADDWD__,
468 "pmaxsb" : __asm_proxy_PMAXSB__,
469 "pmaxsd" : __asm_proxy_PMAXSD__,
470 "pmaxsw" : __asm_proxy_PMAXSW__,
471 "pmaxub" : __asm_proxy_PMAXUB__,
472 "pmaxud" : __asm_proxy_PMAXUD__,
473 "pmaxuw" : __asm_proxy_PMAXUW__,
474 "pminsb" : __asm_proxy_PMINSB__,
475 "pminsd" : __asm_proxy_PMINSD__,
476 "pminsw" : __asm_proxy_PMINSW__,
477 "pminub" : __asm_proxy_PMINUB__,
478 "pminud" : __asm_proxy_PMINUD__,
479 "pminuw" : __asm_proxy_PMINUW__,
480 "pmovmskb" : __asm_proxy_PMOVMSKB__,
481 "pmovsxbd" : __asm_proxy_PMOVSXBD__,
482 "pmovsxbq" : __asm_proxy_PMOVSXBQ__,
483 "pmovsxbw" : __asm_proxy_PMOVSXBW__,
484 "pmovsxdq" : __asm_proxy_PMOVSXDQ__,
485 "pmovsxwd" : __asm_proxy_PMOVSXWD__,
486 "pmovsxwq" : __asm_proxy_PMOVSXWQ__,
487 "pmovzxbd" : __asm_proxy_PMOVZXBD__,
488 "pmovzxbq" : __asm_proxy_PMOVZXBQ__,
489 "pmovzxbw" : __asm_proxy_PMOVZXBW__,
490 "pmovzxdq" : __asm_proxy_PMOVZXDQ__,
491 "pmovzxwd" : __asm_proxy_PMOVZXWD__,
492 "pmovzxwq" : __asm_proxy_PMOVZXWQ__,
493 "pmuldq" : __asm_proxy_PMULDQ__,
494 "pmulhrsw" : __asm_proxy_PMULHRSW__,
495 "pmulhrw" : __asm_proxy_PMULHRW__,
496 "pmulhuw" : __asm_proxy_PMULHUW__,
497 "pmulhw" : __asm_proxy_PMULHW__,
498 "pmulld" : __asm_proxy_PMULLD__,
499 "pmullw" : __asm_proxy_PMULLW__,
500 "pmuludq" : __asm_proxy_PMULUDQ__,
501 "popcntl" : __asm_proxy_POPCNTL__,
502 "popcntq" : __asm_proxy_POPCNTQ__,
503 "popcntw" : __asm_proxy_POPCNTW__,
504 "popq" : __asm_proxy_POPQ__,
505 "popw" : __asm_proxy_POPW__,
506 "por" : __asm_proxy_POR__,
507 "prefetch" : __asm_proxy_PREFETCH__,
508 "prefetchnta" : __asm_proxy_PREFETCHNTA__,
509 "prefetcht0" : __asm_proxy_PREFETCHT0__,
510 "prefetcht1" : __asm_proxy_PREFETCHT1__,
511 "prefetcht2" : __asm_proxy_PREFETCHT2__,
512 "prefetchw" : __asm_proxy_PREFETCHW__,
513 "prefetchwt1" : __asm_proxy_PREFETCHWT1__,
514 "psadbw" : __asm_proxy_PSADBW__,
515 "pshufb" : __asm_proxy_PSHUFB__,
516 "pshufd" : __asm_proxy_PSHUFD__,
517 "pshufhw" : __asm_proxy_PSHUFHW__,
518 "pshuflw" : __asm_proxy_PSHUFLW__,
519 "pshufw" : __asm_proxy_PSHUFW__,
520 "psignb" : __asm_proxy_PSIGNB__,
521 "psignd" : __asm_proxy_PSIGND__,
522 "psignw" : __asm_proxy_PSIGNW__,
523 "pslld" : __asm_proxy_PSLLD__,
524 "pslldq" : __asm_proxy_PSLLDQ__,
525 "psllq" : __asm_proxy_PSLLQ__,
526 "psllw" : __asm_proxy_PSLLW__,
527 "psrad" : __asm_proxy_PSRAD__,
528 "psraw" : __asm_proxy_PSRAW__,
529 "psrld" : __asm_proxy_PSRLD__,
530 "psrldq" : __asm_proxy_PSRLDQ__,
531 "psrlq" : __asm_proxy_PSRLQ__,
532 "psrlw" : __asm_proxy_PSRLW__,
533 "psubb" : __asm_proxy_PSUBB__,
534 "psubd" : __asm_proxy_PSUBD__,
535 "psubq" : __asm_proxy_PSUBQ__,
536 "psubsb" : __asm_proxy_PSUBSB__,
537 "psubsw" : __asm_proxy_PSUBSW__,
538 "psubusb" : __asm_proxy_PSUBUSB__,
539 "psubusw" : __asm_proxy_PSUBUSW__,
540 "psubw" : __asm_proxy_PSUBW__,
541 "pswapd" : __asm_proxy_PSWAPD__,
542 "ptest" : __asm_proxy_PTEST__,
543 "punpckhbw" : __asm_proxy_PUNPCKHBW__,
544 "punpckhdq" : __asm_proxy_PUNPCKHDQ__,
545 "punpckhqdq" : __asm_proxy_PUNPCKHQDQ__,
546 "punpckhwd" : __asm_proxy_PUNPCKHWD__,
547 "punpcklbw" : __asm_proxy_PUNPCKLBW__,
548 "punpckldq" : __asm_proxy_PUNPCKLDQ__,
549 "punpcklqdq" : __asm_proxy_PUNPCKLQDQ__,
550 "punpcklwd" : __asm_proxy_PUNPCKLWD__,
551 "pushq" : __asm_proxy_PUSHQ__,
552 "pushw" : __asm_proxy_PUSHW__,
553 "pxor" : __asm_proxy_PXOR__,
554 "rclb" : __asm_proxy_RCLB__,
555 "rcll" : __asm_proxy_RCLL__,
556 "rclq" : __asm_proxy_RCLQ__,
557 "rclw" : __asm_proxy_RCLW__,
558 "rcpps" : __asm_proxy_RCPPS__,
559 "rcpss" : __asm_proxy_RCPSS__,
560 "rcrb" : __asm_proxy_RCRB__,
561 "rcrl" : __asm_proxy_RCRL__,
562 "rcrq" : __asm_proxy_RCRQ__,
563 "rcrw" : __asm_proxy_RCRW__,
564 "rdrand" : __asm_proxy_RDRAND__,
565 "rdseed" : __asm_proxy_RDSEED__,
566 "rdtsc" : __asm_proxy_RDTSC__,
567 "rdtscp" : __asm_proxy_RDTSCP__,
568 "ret" : __asm_proxy_RET__,
569 "rolb" : __asm_proxy_ROLB__,
570 "roll" : __asm_proxy_ROLL__,
571 "rolq" : __asm_proxy_ROLQ__,
572 "rolw" : __asm_proxy_ROLW__,
573 "rorb" : __asm_proxy_RORB__,
574 "rorl" : __asm_proxy_RORL__,
575 "rorq" : __asm_proxy_RORQ__,
576 "rorw" : __asm_proxy_RORW__,
577 "rorxl" : __asm_proxy_RORXL__,
578 "rorxq" : __asm_proxy_RORXQ__,
579 "roundpd" : __asm_proxy_ROUNDPD__,
580 "roundps" : __asm_proxy_ROUNDPS__,
581 "roundsd" : __asm_proxy_ROUNDSD__,
582 "roundss" : __asm_proxy_ROUNDSS__,
583 "rsqrtps" : __asm_proxy_RSQRTPS__,
584 "rsqrtss" : __asm_proxy_RSQRTSS__,
585 "salb" : __asm_proxy_SALB__,
586 "sall" : __asm_proxy_SALL__,
587 "salq" : __asm_proxy_SALQ__,
588 "salw" : __asm_proxy_SALW__,
589 "sarb" : __asm_proxy_SARB__,
590 "sarl" : __asm_proxy_SARL__,
591 "sarq" : __asm_proxy_SARQ__,
592 "sarw" : __asm_proxy_SARW__,
593 "sarxl" : __asm_proxy_SARXL__,
594 "sarxq" : __asm_proxy_SARXQ__,
595 "sbbb" : __asm_proxy_SBBB__,
596 "sbbl" : __asm_proxy_SBBL__,
597 "sbbq" : __asm_proxy_SBBQ__,
598 "sbbw" : __asm_proxy_SBBW__,
599 "seta" : __asm_proxy_SETA__,
600 "setae" : __asm_proxy_SETAE__,
601 "setb" : __asm_proxy_SETB__,
602 "setbe" : __asm_proxy_SETBE__,
603 "setc" : __asm_proxy_SETC__,
604 "sete" : __asm_proxy_SETE__,
605 "setg" : __asm_proxy_SETG__,
606 "setge" : __asm_proxy_SETGE__,
607 "setl" : __asm_proxy_SETL__,
608 "setle" : __asm_proxy_SETLE__,
609 "setna" : __asm_proxy_SETNA__,
610 "setnae" : __asm_proxy_SETNAE__,
611 "setnb" : __asm_proxy_SETNB__,
612 "setnbe" : __asm_proxy_SETNBE__,
613 "setnc" : __asm_proxy_SETNC__,
614 "setne" : __asm_proxy_SETNE__,
615 "setng" : __asm_proxy_SETNG__,
616 "setnge" : __asm_proxy_SETNGE__,
617 "setnl" : __asm_proxy_SETNL__,
618 "setnle" : __asm_proxy_SETNLE__,
619 "setno" : __asm_proxy_SETNO__,
620 "setnp" : __asm_proxy_SETNP__,
621 "setns" : __asm_proxy_SETNS__,
622 "setnz" : __asm_proxy_SETNZ__,
623 "seto" : __asm_proxy_SETO__,
624 "setp" : __asm_proxy_SETP__,
625 "setpe" : __asm_proxy_SETPE__,
626 "setpo" : __asm_proxy_SETPO__,
627 "sets" : __asm_proxy_SETS__,
628 "setz" : __asm_proxy_SETZ__,
629 "sfence" : __asm_proxy_SFENCE__,
630 "sha1msg1" : __asm_proxy_SHA1MSG1__,
631 "sha1msg2" : __asm_proxy_SHA1MSG2__,
632 "sha1nexte" : __asm_proxy_SHA1NEXTE__,
633 "sha1rnds4" : __asm_proxy_SHA1RNDS4__,
634 "sha256msg1" : __asm_proxy_SHA256MSG1__,
635 "sha256msg2" : __asm_proxy_SHA256MSG2__,
636 "sha256rnds2" : __asm_proxy_SHA256RNDS2__,
637 "shlb" : __asm_proxy_SHLB__,
638 "shldl" : __asm_proxy_SHLDL__,
639 "shldq" : __asm_proxy_SHLDQ__,
640 "shldw" : __asm_proxy_SHLDW__,
641 "shll" : __asm_proxy_SHLL__,
642 "shlq" : __asm_proxy_SHLQ__,
643 "shlw" : __asm_proxy_SHLW__,
644 "shlxl" : __asm_proxy_SHLXL__,
645 "shlxq" : __asm_proxy_SHLXQ__,
646 "shrb" : __asm_proxy_SHRB__,
647 "shrdl" : __asm_proxy_SHRDL__,
648 "shrdq" : __asm_proxy_SHRDQ__,
649 "shrdw" : __asm_proxy_SHRDW__,
650 "shrl" : __asm_proxy_SHRL__,
651 "shrq" : __asm_proxy_SHRQ__,
652 "shrw" : __asm_proxy_SHRW__,
653 "shrxl" : __asm_proxy_SHRXL__,
654 "shrxq" : __asm_proxy_SHRXQ__,
655 "shufpd" : __asm_proxy_SHUFPD__,
656 "shufps" : __asm_proxy_SHUFPS__,
657 "sqrtpd" : __asm_proxy_SQRTPD__,
658 "sqrtps" : __asm_proxy_SQRTPS__,
659 "sqrtsd" : __asm_proxy_SQRTSD__,
660 "sqrtss" : __asm_proxy_SQRTSS__,
661 "stc" : __asm_proxy_STC__,
662 "std" : __asm_proxy_STD__,
663 "stmxcsr" : __asm_proxy_STMXCSR__,
664 "subb" : __asm_proxy_SUBB__,
665 "subl" : __asm_proxy_SUBL__,
666 "subpd" : __asm_proxy_SUBPD__,
667 "subps" : __asm_proxy_SUBPS__,
668 "subq" : __asm_proxy_SUBQ__,
669 "subsd" : __asm_proxy_SUBSD__,
670 "subss" : __asm_proxy_SUBSS__,
671 "subw" : __asm_proxy_SUBW__,
672 "syscall" : __asm_proxy_SYSCALL__,
673 "t1mskc" : __asm_proxy_T1MSKC__,
674 "testb" : __asm_proxy_TESTB__,
675 "testl" : __asm_proxy_TESTL__,
676 "testq" : __asm_proxy_TESTQ__,
677 "testw" : __asm_proxy_TESTW__,
678 "tzcntl" : __asm_proxy_TZCNTL__,
679 "tzcntq" : __asm_proxy_TZCNTQ__,
680 "tzcntw" : __asm_proxy_TZCNTW__,
681 "tzmsk" : __asm_proxy_TZMSK__,
682 "ucomisd" : __asm_proxy_UCOMISD__,
683 "ucomiss" : __asm_proxy_UCOMISS__,
684 "ud2" : __asm_proxy_UD2__,
685 "unpckhpd" : __asm_proxy_UNPCKHPD__,
686 "unpckhps" : __asm_proxy_UNPCKHPS__,
687 "unpcklpd" : __asm_proxy_UNPCKLPD__,
688 "unpcklps" : __asm_proxy_UNPCKLPS__,
689 "vaddpd" : __asm_proxy_VADDPD__,
690 "vaddps" : __asm_proxy_VADDPS__,
691 "vaddsd" : __asm_proxy_VADDSD__,
692 "vaddss" : __asm_proxy_VADDSS__,
693 "vaddsubpd" : __asm_proxy_VADDSUBPD__,
694 "vaddsubps" : __asm_proxy_VADDSUBPS__,
695 "vaesdec" : __asm_proxy_VAESDEC__,
696 "vaesdeclast" : __asm_proxy_VAESDECLAST__,
697 "vaesenc" : __asm_proxy_VAESENC__,
698 "vaesenclast" : __asm_proxy_VAESENCLAST__,
699 "vaesimc" : __asm_proxy_VAESIMC__,
700 "vaeskeygenassist" : __asm_proxy_VAESKEYGENASSIST__,
701 "valignd" : __asm_proxy_VALIGND__,
702 "valignq" : __asm_proxy_VALIGNQ__,
703 "vandnpd" : __asm_proxy_VANDNPD__,
704 "vandnps" : __asm_proxy_VANDNPS__,
705 "vandpd" : __asm_proxy_VANDPD__,
706 "vandps" : __asm_proxy_VANDPS__,
707 "vblendmpd" : __asm_proxy_VBLENDMPD__,
708 "vblendmps" : __asm_proxy_VBLENDMPS__,
709 "vblendpd" : __asm_proxy_VBLENDPD__,
710 "vblendps" : __asm_proxy_VBLENDPS__,
711 "vblendvpd" : __asm_proxy_VBLENDVPD__,
712 "vblendvps" : __asm_proxy_VBLENDVPS__,
713 "vbroadcastf128" : __asm_proxy_VBROADCASTF128__,
714 "vbroadcastf32x2" : __asm_proxy_VBROADCASTF32X2__,
715 "vbroadcastf32x4" : __asm_proxy_VBROADCASTF32X4__,
716 "vbroadcastf32x8" : __asm_proxy_VBROADCASTF32X8__,
717 "vbroadcastf64x2" : __asm_proxy_VBROADCASTF64X2__,
718 "vbroadcastf64x4" : __asm_proxy_VBROADCASTF64X4__,
719 "vbroadcasti128" : __asm_proxy_VBROADCASTI128__,
720 "vbroadcasti32x2" : __asm_proxy_VBROADCASTI32X2__,
721 "vbroadcasti32x4" : __asm_proxy_VBROADCASTI32X4__,
722 "vbroadcasti32x8" : __asm_proxy_VBROADCASTI32X8__,
723 "vbroadcasti64x2" : __asm_proxy_VBROADCASTI64X2__,
724 "vbroadcasti64x4" : __asm_proxy_VBROADCASTI64X4__,
725 "vbroadcastsd" : __asm_proxy_VBROADCASTSD__,
726 "vbroadcastss" : __asm_proxy_VBROADCASTSS__,
727 "vcmppd" : __asm_proxy_VCMPPD__,
728 "vcmpps" : __asm_proxy_VCMPPS__,
729 "vcmpsd" : __asm_proxy_VCMPSD__,
730 "vcmpss" : __asm_proxy_VCMPSS__,
731 "vcomisd" : __asm_proxy_VCOMISD__,
732 "vcomiss" : __asm_proxy_VCOMISS__,
733 "vcompresspd" : __asm_proxy_VCOMPRESSPD__,
734 "vcompressps" : __asm_proxy_VCOMPRESSPS__,
735 "vcvtdq2pd" : __asm_proxy_VCVTDQ2PD__,
736 "vcvtdq2ps" : __asm_proxy_VCVTDQ2PS__,
737 "vcvtpd2dq" : __asm_proxy_VCVTPD2DQ__,
738 "vcvtpd2ps" : __asm_proxy_VCVTPD2PS__,
739 "vcvtpd2qq" : __asm_proxy_VCVTPD2QQ__,
740 "vcvtpd2udq" : __asm_proxy_VCVTPD2UDQ__,
741 "vcvtpd2uqq" : __asm_proxy_VCVTPD2UQQ__,
742 "vcvtph2ps" : __asm_proxy_VCVTPH2PS__,
743 "vcvtps2dq" : __asm_proxy_VCVTPS2DQ__,
744 "vcvtps2pd" : __asm_proxy_VCVTPS2PD__,
745 "vcvtps2ph" : __asm_proxy_VCVTPS2PH__,
746 "vcvtps2qq" : __asm_proxy_VCVTPS2QQ__,
747 "vcvtps2udq" : __asm_proxy_VCVTPS2UDQ__,
748 "vcvtps2uqq" : __asm_proxy_VCVTPS2UQQ__,
749 "vcvtqq2pd" : __asm_proxy_VCVTQQ2PD__,
750 "vcvtqq2ps" : __asm_proxy_VCVTQQ2PS__,
751 "vcvtsd2si" : __asm_proxy_VCVTSD2SI__,
752 "vcvtsd2ss" : __asm_proxy_VCVTSD2SS__,
753 "vcvtsd2usi" : __asm_proxy_VCVTSD2USI__,
754 "vcvtsi2sd" : __asm_proxy_VCVTSI2SD__,
755 "vcvtsi2ss" : __asm_proxy_VCVTSI2SS__,
756 "vcvtss2sd" : __asm_proxy_VCVTSS2SD__,
757 "vcvtss2si" : __asm_proxy_VCVTSS2SI__,
758 "vcvtss2usi" : __asm_proxy_VCVTSS2USI__,
759 "vcvttpd2dq" : __asm_proxy_VCVTTPD2DQ__,
760 "vcvttpd2qq" : __asm_proxy_VCVTTPD2QQ__,
761 "vcvttpd2udq" : __asm_proxy_VCVTTPD2UDQ__,
762 "vcvttpd2uqq" : __asm_proxy_VCVTTPD2UQQ__,
763 "vcvttps2dq" : __asm_proxy_VCVTTPS2DQ__,
764 "vcvttps2qq" : __asm_proxy_VCVTTPS2QQ__,
765 "vcvttps2udq" : __asm_proxy_VCVTTPS2UDQ__,
766 "vcvttps2uqq" : __asm_proxy_VCVTTPS2UQQ__,
767 "vcvttsd2si" : __asm_proxy_VCVTTSD2SI__,
768 "vcvttsd2usi" : __asm_proxy_VCVTTSD2USI__,
769 "vcvttss2si" : __asm_proxy_VCVTTSS2SI__,
770 "vcvttss2usi" : __asm_proxy_VCVTTSS2USI__,
771 "vcvtudq2pd" : __asm_proxy_VCVTUDQ2PD__,
772 "vcvtudq2ps" : __asm_proxy_VCVTUDQ2PS__,
773 "vcvtuqq2pd" : __asm_proxy_VCVTUQQ2PD__,
774 "vcvtuqq2ps" : __asm_proxy_VCVTUQQ2PS__,
775 "vcvtusi2sd" : __asm_proxy_VCVTUSI2SD__,
776 "vcvtusi2ss" : __asm_proxy_VCVTUSI2SS__,
777 "vdbpsadbw" : __asm_proxy_VDBPSADBW__,
778 "vdivpd" : __asm_proxy_VDIVPD__,
779 "vdivps" : __asm_proxy_VDIVPS__,
780 "vdivsd" : __asm_proxy_VDIVSD__,
781 "vdivss" : __asm_proxy_VDIVSS__,
782 "vdppd" : __asm_proxy_VDPPD__,
783 "vdpps" : __asm_proxy_VDPPS__,
784 "vexp2pd" : __asm_proxy_VEXP2PD__,
785 "vexp2ps" : __asm_proxy_VEXP2PS__,
786 "vexpandpd" : __asm_proxy_VEXPANDPD__,
787 "vexpandps" : __asm_proxy_VEXPANDPS__,
788 "vextractf128" : __asm_proxy_VEXTRACTF128__,
789 "vextractf32x4" : __asm_proxy_VEXTRACTF32X4__,
790 "vextractf32x8" : __asm_proxy_VEXTRACTF32X8__,
791 "vextractf64x2" : __asm_proxy_VEXTRACTF64X2__,
792 "vextractf64x4" : __asm_proxy_VEXTRACTF64X4__,
793 "vextracti128" : __asm_proxy_VEXTRACTI128__,
794 "vextracti32x4" : __asm_proxy_VEXTRACTI32X4__,
795 "vextracti32x8" : __asm_proxy_VEXTRACTI32X8__,
796 "vextracti64x2" : __asm_proxy_VEXTRACTI64X2__,
797 "vextracti64x4" : __asm_proxy_VEXTRACTI64X4__,
798 "vextractps" : __asm_proxy_VEXTRACTPS__,
799 "vfixupimmpd" : __asm_proxy_VFIXUPIMMPD__,
800 "vfixupimmps" : __asm_proxy_VFIXUPIMMPS__,
801 "vfixupimmsd" : __asm_proxy_VFIXUPIMMSD__,
802 "vfixupimmss" : __asm_proxy_VFIXUPIMMSS__,
803 "vfmadd132pd" : __asm_proxy_VFMADD132PD__,
804 "vfmadd132ps" : __asm_proxy_VFMADD132PS__,
805 "vfmadd132sd" : __asm_proxy_VFMADD132SD__,
806 "vfmadd132ss" : __asm_proxy_VFMADD132SS__,
807 "vfmadd213pd" : __asm_proxy_VFMADD213PD__,
808 "vfmadd213ps" : __asm_proxy_VFMADD213PS__,
809 "vfmadd213sd" : __asm_proxy_VFMADD213SD__,
810 "vfmadd213ss" : __asm_proxy_VFMADD213SS__,
811 "vfmadd231pd" : __asm_proxy_VFMADD231PD__,
812 "vfmadd231ps" : __asm_proxy_VFMADD231PS__,
813 "vfmadd231sd" : __asm_proxy_VFMADD231SD__,
814 "vfmadd231ss" : __asm_proxy_VFMADD231SS__,
815 "vfmaddpd" : __asm_proxy_VFMADDPD__,
816 "vfmaddps" : __asm_proxy_VFMADDPS__,
817 "vfmaddsd" : __asm_proxy_VFMADDSD__,
818 "vfmaddss" : __asm_proxy_VFMADDSS__,
819 "vfmaddsub132pd" : __asm_proxy_VFMADDSUB132PD__,
820 "vfmaddsub132ps" : __asm_proxy_VFMADDSUB132PS__,
821 "vfmaddsub213pd" : __asm_proxy_VFMADDSUB213PD__,
822 "vfmaddsub213ps" : __asm_proxy_VFMADDSUB213PS__,
823 "vfmaddsub231pd" : __asm_proxy_VFMADDSUB231PD__,
824 "vfmaddsub231ps" : __asm_proxy_VFMADDSUB231PS__,
825 "vfmaddsubpd" : __asm_proxy_VFMADDSUBPD__,
826 "vfmaddsubps" : __asm_proxy_VFMADDSUBPS__,
827 "vfmsub132pd" : __asm_proxy_VFMSUB132PD__,
828 "vfmsub132ps" : __asm_proxy_VFMSUB132PS__,
829 "vfmsub132sd" : __asm_proxy_VFMSUB132SD__,
830 "vfmsub132ss" : __asm_proxy_VFMSUB132SS__,
831 "vfmsub213pd" : __asm_proxy_VFMSUB213PD__,
832 "vfmsub213ps" : __asm_proxy_VFMSUB213PS__,
833 "vfmsub213sd" : __asm_proxy_VFMSUB213SD__,
834 "vfmsub213ss" : __asm_proxy_VFMSUB213SS__,
835 "vfmsub231pd" : __asm_proxy_VFMSUB231PD__,
836 "vfmsub231ps" : __asm_proxy_VFMSUB231PS__,
837 "vfmsub231sd" : __asm_proxy_VFMSUB231SD__,
838 "vfmsub231ss" : __asm_proxy_VFMSUB231SS__,
839 "vfmsubadd132pd" : __asm_proxy_VFMSUBADD132PD__,
840 "vfmsubadd132ps" : __asm_proxy_VFMSUBADD132PS__,
841 "vfmsubadd213pd" : __asm_proxy_VFMSUBADD213PD__,
842 "vfmsubadd213ps" : __asm_proxy_VFMSUBADD213PS__,
843 "vfmsubadd231pd" : __asm_proxy_VFMSUBADD231PD__,
844 "vfmsubadd231ps" : __asm_proxy_VFMSUBADD231PS__,
845 "vfmsubaddpd" : __asm_proxy_VFMSUBADDPD__,
846 "vfmsubaddps" : __asm_proxy_VFMSUBADDPS__,
847 "vfmsubpd" : __asm_proxy_VFMSUBPD__,
848 "vfmsubps" : __asm_proxy_VFMSUBPS__,
849 "vfmsubsd" : __asm_proxy_VFMSUBSD__,
850 "vfmsubss" : __asm_proxy_VFMSUBSS__,
851 "vfnmadd132pd" : __asm_proxy_VFNMADD132PD__,
852 "vfnmadd132ps" : __asm_proxy_VFNMADD132PS__,
853 "vfnmadd132sd" : __asm_proxy_VFNMADD132SD__,
854 "vfnmadd132ss" : __asm_proxy_VFNMADD132SS__,
855 "vfnmadd213pd" : __asm_proxy_VFNMADD213PD__,
856 "vfnmadd213ps" : __asm_proxy_VFNMADD213PS__,
857 "vfnmadd213sd" : __asm_proxy_VFNMADD213SD__,
858 "vfnmadd213ss" : __asm_proxy_VFNMADD213SS__,
859 "vfnmadd231pd" : __asm_proxy_VFNMADD231PD__,
860 "vfnmadd231ps" : __asm_proxy_VFNMADD231PS__,
861 "vfnmadd231sd" : __asm_proxy_VFNMADD231SD__,
862 "vfnmadd231ss" : __asm_proxy_VFNMADD231SS__,
863 "vfnmaddpd" : __asm_proxy_VFNMADDPD__,
864 "vfnmaddps" : __asm_proxy_VFNMADDPS__,
865 "vfnmaddsd" : __asm_proxy_VFNMADDSD__,
866 "vfnmaddss" : __asm_proxy_VFNMADDSS__,
867 "vfnmsub132pd" : __asm_proxy_VFNMSUB132PD__,
868 "vfnmsub132ps" : __asm_proxy_VFNMSUB132PS__,
869 "vfnmsub132sd" : __asm_proxy_VFNMSUB132SD__,
870 "vfnmsub132ss" : __asm_proxy_VFNMSUB132SS__,
871 "vfnmsub213pd" : __asm_proxy_VFNMSUB213PD__,
872 "vfnmsub213ps" : __asm_proxy_VFNMSUB213PS__,
873 "vfnmsub213sd" : __asm_proxy_VFNMSUB213SD__,
874 "vfnmsub213ss" : __asm_proxy_VFNMSUB213SS__,
875 "vfnmsub231pd" : __asm_proxy_VFNMSUB231PD__,
876 "vfnmsub231ps" : __asm_proxy_VFNMSUB231PS__,
877 "vfnmsub231sd" : __asm_proxy_VFNMSUB231SD__,
878 "vfnmsub231ss" : __asm_proxy_VFNMSUB231SS__,
879 "vfnmsubpd" : __asm_proxy_VFNMSUBPD__,
880 "vfnmsubps" : __asm_proxy_VFNMSUBPS__,
881 "vfnmsubsd" : __asm_proxy_VFNMSUBSD__,
882 "vfnmsubss" : __asm_proxy_VFNMSUBSS__,
883 "vfpclasspd" : __asm_proxy_VFPCLASSPD__,
884 "vfpclassps" : __asm_proxy_VFPCLASSPS__,
885 "vfpclasssd" : __asm_proxy_VFPCLASSSD__,
886 "vfpclassss" : __asm_proxy_VFPCLASSSS__,
887 "vfrczpd" : __asm_proxy_VFRCZPD__,
888 "vfrczps" : __asm_proxy_VFRCZPS__,
889 "vfrczsd" : __asm_proxy_VFRCZSD__,
890 "vfrczss" : __asm_proxy_VFRCZSS__,
891 "vgatherdpd" : __asm_proxy_VGATHERDPD__,
892 "vgatherdps" : __asm_proxy_VGATHERDPS__,
893 "vgatherpf0dpd" : __asm_proxy_VGATHERPF0DPD__,
894 "vgatherpf0dps" : __asm_proxy_VGATHERPF0DPS__,
895 "vgatherpf0qpd" : __asm_proxy_VGATHERPF0QPD__,
896 "vgatherpf0qps" : __asm_proxy_VGATHERPF0QPS__,
897 "vgatherpf1dpd" : __asm_proxy_VGATHERPF1DPD__,
898 "vgatherpf1dps" : __asm_proxy_VGATHERPF1DPS__,
899 "vgatherpf1qpd" : __asm_proxy_VGATHERPF1QPD__,
900 "vgatherpf1qps" : __asm_proxy_VGATHERPF1QPS__,
901 "vgatherqpd" : __asm_proxy_VGATHERQPD__,
902 "vgatherqps" : __asm_proxy_VGATHERQPS__,
903 "vgetexppd" : __asm_proxy_VGETEXPPD__,
904 "vgetexpps" : __asm_proxy_VGETEXPPS__,
905 "vgetexpsd" : __asm_proxy_VGETEXPSD__,
906 "vgetexpss" : __asm_proxy_VGETEXPSS__,
907 "vgetmantpd" : __asm_proxy_VGETMANTPD__,
908 "vgetmantps" : __asm_proxy_VGETMANTPS__,
909 "vgetmantsd" : __asm_proxy_VGETMANTSD__,
910 "vgetmantss" : __asm_proxy_VGETMANTSS__,
911 "vhaddpd" : __asm_proxy_VHADDPD__,
912 "vhaddps" : __asm_proxy_VHADDPS__,
913 "vhsubpd" : __asm_proxy_VHSUBPD__,
914 "vhsubps" : __asm_proxy_VHSUBPS__,
915 "vinsertf128" : __asm_proxy_VINSERTF128__,
916 "vinsertf32x4" : __asm_proxy_VINSERTF32X4__,
917 "vinsertf32x8" : __asm_proxy_VINSERTF32X8__,
918 "vinsertf64x2" : __asm_proxy_VINSERTF64X2__,
919 "vinsertf64x4" : __asm_proxy_VINSERTF64X4__,
920 "vinserti128" : __asm_proxy_VINSERTI128__,
921 "vinserti32x4" : __asm_proxy_VINSERTI32X4__,
922 "vinserti32x8" : __asm_proxy_VINSERTI32X8__,
923 "vinserti64x2" : __asm_proxy_VINSERTI64X2__,
924 "vinserti64x4" : __asm_proxy_VINSERTI64X4__,
925 "vinsertps" : __asm_proxy_VINSERTPS__,
926 "vlddqu" : __asm_proxy_VLDDQU__,
927 "vldmxcsr" : __asm_proxy_VLDMXCSR__,
928 "vmaskmovdqu" : __asm_proxy_VMASKMOVDQU__,
929 "vmaskmovpd" : __asm_proxy_VMASKMOVPD__,
930 "vmaskmovps" : __asm_proxy_VMASKMOVPS__,
931 "vmaxpd" : __asm_proxy_VMAXPD__,
932 "vmaxps" : __asm_proxy_VMAXPS__,
933 "vmaxsd" : __asm_proxy_VMAXSD__,
934 "vmaxss" : __asm_proxy_VMAXSS__,
935 "vminpd" : __asm_proxy_VMINPD__,
936 "vminps" : __asm_proxy_VMINPS__,
937 "vminsd" : __asm_proxy_VMINSD__,
938 "vminss" : __asm_proxy_VMINSS__,
939 "vmovapd" : __asm_proxy_VMOVAPD__,
940 "vmovaps" : __asm_proxy_VMOVAPS__,
941 "vmovd" : __asm_proxy_VMOVD__,
942 "vmovddup" : __asm_proxy_VMOVDDUP__,
943 "vmovdqa" : __asm_proxy_VMOVDQA__,
944 "vmovdqa32" : __asm_proxy_VMOVDQA32__,
945 "vmovdqa64" : __asm_proxy_VMOVDQA64__,
946 "vmovdqu" : __asm_proxy_VMOVDQU__,
947 "vmovdqu16" : __asm_proxy_VMOVDQU16__,
948 "vmovdqu32" : __asm_proxy_VMOVDQU32__,
949 "vmovdqu64" : __asm_proxy_VMOVDQU64__,
950 "vmovdqu8" : __asm_proxy_VMOVDQU8__,
951 "vmovhlps" : __asm_proxy_VMOVHLPS__,
952 "vmovhpd" : __asm_proxy_VMOVHPD__,
953 "vmovhps" : __asm_proxy_VMOVHPS__,
954 "vmovlhps" : __asm_proxy_VMOVLHPS__,
955 "vmovlpd" : __asm_proxy_VMOVLPD__,
956 "vmovlps" : __asm_proxy_VMOVLPS__,
957 "vmovmskpd" : __asm_proxy_VMOVMSKPD__,
958 "vmovmskps" : __asm_proxy_VMOVMSKPS__,
959 "vmovntdq" : __asm_proxy_VMOVNTDQ__,
960 "vmovntdqa" : __asm_proxy_VMOVNTDQA__,
961 "vmovntpd" : __asm_proxy_VMOVNTPD__,
962 "vmovntps" : __asm_proxy_VMOVNTPS__,
963 "vmovq" : __asm_proxy_VMOVQ__,
964 "vmovsd" : __asm_proxy_VMOVSD__,
965 "vmovshdup" : __asm_proxy_VMOVSHDUP__,
966 "vmovsldup" : __asm_proxy_VMOVSLDUP__,
967 "vmovss" : __asm_proxy_VMOVSS__,
968 "vmovupd" : __asm_proxy_VMOVUPD__,
969 "vmovups" : __asm_proxy_VMOVUPS__,
970 "vmpsadbw" : __asm_proxy_VMPSADBW__,
971 "vmulpd" : __asm_proxy_VMULPD__,
972 "vmulps" : __asm_proxy_VMULPS__,
973 "vmulsd" : __asm_proxy_VMULSD__,
974 "vmulss" : __asm_proxy_VMULSS__,
975 "vorpd" : __asm_proxy_VORPD__,
976 "vorps" : __asm_proxy_VORPS__,
977 "vpabsb" : __asm_proxy_VPABSB__,
978 "vpabsd" : __asm_proxy_VPABSD__,
979 "vpabsq" : __asm_proxy_VPABSQ__,
980 "vpabsw" : __asm_proxy_VPABSW__,
981 "vpackssdw" : __asm_proxy_VPACKSSDW__,
982 "vpacksswb" : __asm_proxy_VPACKSSWB__,
983 "vpackusdw" : __asm_proxy_VPACKUSDW__,
984 "vpackuswb" : __asm_proxy_VPACKUSWB__,
985 "vpaddb" : __asm_proxy_VPADDB__,
986 "vpaddd" : __asm_proxy_VPADDD__,
987 "vpaddq" : __asm_proxy_VPADDQ__,
988 "vpaddsb" : __asm_proxy_VPADDSB__,
989 "vpaddsw" : __asm_proxy_VPADDSW__,
990 "vpaddusb" : __asm_proxy_VPADDUSB__,
991 "vpaddusw" : __asm_proxy_VPADDUSW__,
992 "vpaddw" : __asm_proxy_VPADDW__,
993 "vpalignr" : __asm_proxy_VPALIGNR__,
994 "vpand" : __asm_proxy_VPAND__,
995 "vpandd" : __asm_proxy_VPANDD__,
996 "vpandn" : __asm_proxy_VPANDN__,
997 "vpandnd" : __asm_proxy_VPANDND__,
998 "vpandnq" : __asm_proxy_VPANDNQ__,
999 "vpandq" : __asm_proxy_VPANDQ__,
1000 "vpavgb" : __asm_proxy_VPAVGB__,
1001 "vpavgw" : __asm_proxy_VPAVGW__,
1002 "vpblendd" : __asm_proxy_VPBLENDD__,
1003 "vpblendmb" : __asm_proxy_VPBLENDMB__,
1004 "vpblendmd" : __asm_proxy_VPBLENDMD__,
1005 "vpblendmq" : __asm_proxy_VPBLENDMQ__,
1006 "vpblendmw" : __asm_proxy_VPBLENDMW__,
1007 "vpblendvb" : __asm_proxy_VPBLENDVB__,
1008 "vpblendw" : __asm_proxy_VPBLENDW__,
1009 "vpbroadcastb" : __asm_proxy_VPBROADCASTB__,
1010 "vpbroadcastd" : __asm_proxy_VPBROADCASTD__,
1011 "vpbroadcastmb2q" : __asm_proxy_VPBROADCASTMB2Q__,
1012 "vpbroadcastmw2d" : __asm_proxy_VPBROADCASTMW2D__,
1013 "vpbroadcastq" : __asm_proxy_VPBROADCASTQ__,
1014 "vpbroadcastw" : __asm_proxy_VPBROADCASTW__,
1015 "vpclmulqdq" : __asm_proxy_VPCLMULQDQ__,
1016 "vpcmov" : __asm_proxy_VPCMOV__,
1017 "vpcmpb" : __asm_proxy_VPCMPB__,
1018 "vpcmpd" : __asm_proxy_VPCMPD__,
1019 "vpcmpeqb" : __asm_proxy_VPCMPEQB__,
1020 "vpcmpeqd" : __asm_proxy_VPCMPEQD__,
1021 "vpcmpeqq" : __asm_proxy_VPCMPEQQ__,
1022 "vpcmpeqw" : __asm_proxy_VPCMPEQW__,
1023 "vpcmpestri" : __asm_proxy_VPCMPESTRI__,
1024 "vpcmpestrm" : __asm_proxy_VPCMPESTRM__,
1025 "vpcmpgtb" : __asm_proxy_VPCMPGTB__,
1026 "vpcmpgtd" : __asm_proxy_VPCMPGTD__,
1027 "vpcmpgtq" : __asm_proxy_VPCMPGTQ__,
1028 "vpcmpgtw" : __asm_proxy_VPCMPGTW__,
1029 "vpcmpistri" : __asm_proxy_VPCMPISTRI__,
1030 "vpcmpistrm" : __asm_proxy_VPCMPISTRM__,
1031 "vpcmpq" : __asm_proxy_VPCMPQ__,
1032 "vpcmpub" : __asm_proxy_VPCMPUB__,
1033 "vpcmpud" : __asm_proxy_VPCMPUD__,
1034 "vpcmpuq" : __asm_proxy_VPCMPUQ__,
1035 "vpcmpuw" : __asm_proxy_VPCMPUW__,
1036 "vpcmpw" : __asm_proxy_VPCMPW__,
1037 "vpcomb" : __asm_proxy_VPCOMB__,
1038 "vpcomd" : __asm_proxy_VPCOMD__,
1039 "vpcompressd" : __asm_proxy_VPCOMPRESSD__,
1040 "vpcompressq" : __asm_proxy_VPCOMPRESSQ__,
1041 "vpcomq" : __asm_proxy_VPCOMQ__,
1042 "vpcomub" : __asm_proxy_VPCOMUB__,
1043 "vpcomud" : __asm_proxy_VPCOMUD__,
1044 "vpcomuq" : __asm_proxy_VPCOMUQ__,
1045 "vpcomuw" : __asm_proxy_VPCOMUW__,
1046 "vpcomw" : __asm_proxy_VPCOMW__,
1047 "vpconflictd" : __asm_proxy_VPCONFLICTD__,
1048 "vpconflictq" : __asm_proxy_VPCONFLICTQ__,
1049 "vperm2f128" : __asm_proxy_VPERM2F128__,
1050 "vperm2i128" : __asm_proxy_VPERM2I128__,
1051 "vpermb" : __asm_proxy_VPERMB__,
1052 "vpermd" : __asm_proxy_VPERMD__,
1053 "vpermi2b" : __asm_proxy_VPERMI2B__,
1054 "vpermi2d" : __asm_proxy_VPERMI2D__,
1055 "vpermi2pd" : __asm_proxy_VPERMI2PD__,
1056 "vpermi2ps" : __asm_proxy_VPERMI2PS__,
1057 "vpermi2q" : __asm_proxy_VPERMI2Q__,
1058 "vpermi2w" : __asm_proxy_VPERMI2W__,
1059 "vpermil2pd" : __asm_proxy_VPERMIL2PD__,
1060 "vpermil2ps" : __asm_proxy_VPERMIL2PS__,
1061 "vpermilpd" : __asm_proxy_VPERMILPD__,
1062 "vpermilps" : __asm_proxy_VPERMILPS__,
1063 "vpermpd" : __asm_proxy_VPERMPD__,
1064 "vpermps" : __asm_proxy_VPERMPS__,
1065 "vpermq" : __asm_proxy_VPERMQ__,
1066 "vpermt2b" : __asm_proxy_VPERMT2B__,
1067 "vpermt2d" : __asm_proxy_VPERMT2D__,
1068 "vpermt2pd" : __asm_proxy_VPERMT2PD__,
1069 "vpermt2ps" : __asm_proxy_VPERMT2PS__,
1070 "vpermt2q" : __asm_proxy_VPERMT2Q__,
1071 "vpermt2w" : __asm_proxy_VPERMT2W__,
1072 "vpermw" : __asm_proxy_VPERMW__,
1073 "vpexpandd" : __asm_proxy_VPEXPANDD__,
1074 "vpexpandq" : __asm_proxy_VPEXPANDQ__,
1075 "vpextrb" : __asm_proxy_VPEXTRB__,
1076 "vpextrd" : __asm_proxy_VPEXTRD__,
1077 "vpextrq" : __asm_proxy_VPEXTRQ__,
1078 "vpextrw" : __asm_proxy_VPEXTRW__,
1079 "vpgatherdd" : __asm_proxy_VPGATHERDD__,
1080 "vpgatherdq" : __asm_proxy_VPGATHERDQ__,
1081 "vpgatherqd" : __asm_proxy_VPGATHERQD__,
1082 "vpgatherqq" : __asm_proxy_VPGATHERQQ__,
1083 "vphaddbd" : __asm_proxy_VPHADDBD__,
1084 "vphaddbq" : __asm_proxy_VPHADDBQ__,
1085 "vphaddbw" : __asm_proxy_VPHADDBW__,
1086 "vphaddd" : __asm_proxy_VPHADDD__,
1087 "vphadddq" : __asm_proxy_VPHADDDQ__,
1088 "vphaddsw" : __asm_proxy_VPHADDSW__,
1089 "vphaddubd" : __asm_proxy_VPHADDUBD__,
1090 "vphaddubq" : __asm_proxy_VPHADDUBQ__,
1091 "vphaddubw" : __asm_proxy_VPHADDUBW__,
1092 "vphaddudq" : __asm_proxy_VPHADDUDQ__,
1093 "vphadduwd" : __asm_proxy_VPHADDUWD__,
1094 "vphadduwq" : __asm_proxy_VPHADDUWQ__,
1095 "vphaddw" : __asm_proxy_VPHADDW__,
1096 "vphaddwd" : __asm_proxy_VPHADDWD__,
1097 "vphaddwq" : __asm_proxy_VPHADDWQ__,
1098 "vphminposuw" : __asm_proxy_VPHMINPOSUW__,
1099 "vphsubbw" : __asm_proxy_VPHSUBBW__,
1100 "vphsubd" : __asm_proxy_VPHSUBD__,
1101 "vphsubdq" : __asm_proxy_VPHSUBDQ__,
1102 "vphsubsw" : __asm_proxy_VPHSUBSW__,
1103 "vphsubw" : __asm_proxy_VPHSUBW__,
1104 "vphsubwd" : __asm_proxy_VPHSUBWD__,
1105 "vpinsrb" : __asm_proxy_VPINSRB__,
1106 "vpinsrd" : __asm_proxy_VPINSRD__,
1107 "vpinsrq" : __asm_proxy_VPINSRQ__,
1108 "vpinsrw" : __asm_proxy_VPINSRW__,
1109 "vplzcntd" : __asm_proxy_VPLZCNTD__,
1110 "vplzcntq" : __asm_proxy_VPLZCNTQ__,
1111 "vpmacsdd" : __asm_proxy_VPMACSDD__,
1112 "vpmacsdqh" : __asm_proxy_VPMACSDQH__,
1113 "vpmacsdql" : __asm_proxy_VPMACSDQL__,
1114 "vpmacssdd" : __asm_proxy_VPMACSSDD__,
1115 "vpmacssdqh" : __asm_proxy_VPMACSSDQH__,
1116 "vpmacssdql" : __asm_proxy_VPMACSSDQL__,
1117 "vpmacsswd" : __asm_proxy_VPMACSSWD__,
1118 "vpmacssww" : __asm_proxy_VPMACSSWW__,
1119 "vpmacswd" : __asm_proxy_VPMACSWD__,
1120 "vpmacsww" : __asm_proxy_VPMACSWW__,
1121 "vpmadcsswd" : __asm_proxy_VPMADCSSWD__,
1122 "vpmadcswd" : __asm_proxy_VPMADCSWD__,
1123 "vpmadd52huq" : __asm_proxy_VPMADD52HUQ__,
1124 "vpmadd52luq" : __asm_proxy_VPMADD52LUQ__,
1125 "vpmaddubsw" : __asm_proxy_VPMADDUBSW__,
1126 "vpmaddwd" : __asm_proxy_VPMADDWD__,
1127 "vpmaskmovd" : __asm_proxy_VPMASKMOVD__,
1128 "vpmaskmovq" : __asm_proxy_VPMASKMOVQ__,
1129 "vpmaxsb" : __asm_proxy_VPMAXSB__,
1130 "vpmaxsd" : __asm_proxy_VPMAXSD__,
1131 "vpmaxsq" : __asm_proxy_VPMAXSQ__,
1132 "vpmaxsw" : __asm_proxy_VPMAXSW__,
1133 "vpmaxub" : __asm_proxy_VPMAXUB__,
1134 "vpmaxud" : __asm_proxy_VPMAXUD__,
1135 "vpmaxuq" : __asm_proxy_VPMAXUQ__,
1136 "vpmaxuw" : __asm_proxy_VPMAXUW__,
1137 "vpminsb" : __asm_proxy_VPMINSB__,
1138 "vpminsd" : __asm_proxy_VPMINSD__,
1139 "vpminsq" : __asm_proxy_VPMINSQ__,
1140 "vpminsw" : __asm_proxy_VPMINSW__,
1141 "vpminub" : __asm_proxy_VPMINUB__,
1142 "vpminud" : __asm_proxy_VPMINUD__,
1143 "vpminuq" : __asm_proxy_VPMINUQ__,
1144 "vpminuw" : __asm_proxy_VPMINUW__,
1145 "vpmovb2m" : __asm_proxy_VPMOVB2M__,
1146 "vpmovd2m" : __asm_proxy_VPMOVD2M__,
1147 "vpmovdb" : __asm_proxy_VPMOVDB__,
1148 "vpmovdw" : __asm_proxy_VPMOVDW__,
1149 "vpmovm2b" : __asm_proxy_VPMOVM2B__,
1150 "vpmovm2d" : __asm_proxy_VPMOVM2D__,
1151 "vpmovm2q" : __asm_proxy_VPMOVM2Q__,
1152 "vpmovm2w" : __asm_proxy_VPMOVM2W__,
1153 "vpmovmskb" : __asm_proxy_VPMOVMSKB__,
1154 "vpmovq2m" : __asm_proxy_VPMOVQ2M__,
1155 "vpmovqb" : __asm_proxy_VPMOVQB__,
1156 "vpmovqd" : __asm_proxy_VPMOVQD__,
1157 "vpmovqw" : __asm_proxy_VPMOVQW__,
1158 "vpmovsdb" : __asm_proxy_VPMOVSDB__,
1159 "vpmovsdw" : __asm_proxy_VPMOVSDW__,
1160 "vpmovsqb" : __asm_proxy_VPMOVSQB__,
1161 "vpmovsqd" : __asm_proxy_VPMOVSQD__,
1162 "vpmovsqw" : __asm_proxy_VPMOVSQW__,
1163 "vpmovswb" : __asm_proxy_VPMOVSWB__,
1164 "vpmovsxbd" : __asm_proxy_VPMOVSXBD__,
1165 "vpmovsxbq" : __asm_proxy_VPMOVSXBQ__,
1166 "vpmovsxbw" : __asm_proxy_VPMOVSXBW__,
1167 "vpmovsxdq" : __asm_proxy_VPMOVSXDQ__,
1168 "vpmovsxwd" : __asm_proxy_VPMOVSXWD__,
1169 "vpmovsxwq" : __asm_proxy_VPMOVSXWQ__,
1170 "vpmovusdb" : __asm_proxy_VPMOVUSDB__,
1171 "vpmovusdw" : __asm_proxy_VPMOVUSDW__,
1172 "vpmovusqb" : __asm_proxy_VPMOVUSQB__,
1173 "vpmovusqd" : __asm_proxy_VPMOVUSQD__,
1174 "vpmovusqw" : __asm_proxy_VPMOVUSQW__,
1175 "vpmovuswb" : __asm_proxy_VPMOVUSWB__,
1176 "vpmovw2m" : __asm_proxy_VPMOVW2M__,
1177 "vpmovwb" : __asm_proxy_VPMOVWB__,
1178 "vpmovzxbd" : __asm_proxy_VPMOVZXBD__,
1179 "vpmovzxbq" : __asm_proxy_VPMOVZXBQ__,
1180 "vpmovzxbw" : __asm_proxy_VPMOVZXBW__,
1181 "vpmovzxdq" : __asm_proxy_VPMOVZXDQ__,
1182 "vpmovzxwd" : __asm_proxy_VPMOVZXWD__,
1183 "vpmovzxwq" : __asm_proxy_VPMOVZXWQ__,
1184 "vpmuldq" : __asm_proxy_VPMULDQ__,
1185 "vpmulhrsw" : __asm_proxy_VPMULHRSW__,
1186 "vpmulhuw" : __asm_proxy_VPMULHUW__,
1187 "vpmulhw" : __asm_proxy_VPMULHW__,
1188 "vpmulld" : __asm_proxy_VPMULLD__,
1189 "vpmullq" : __asm_proxy_VPMULLQ__,
1190 "vpmullw" : __asm_proxy_VPMULLW__,
1191 "vpmultishiftqb" : __asm_proxy_VPMULTISHIFTQB__,
1192 "vpmuludq" : __asm_proxy_VPMULUDQ__,
1193 "vpopcntd" : __asm_proxy_VPOPCNTD__,
1194 "vpopcntq" : __asm_proxy_VPOPCNTQ__,
1195 "vpor" : __asm_proxy_VPOR__,
1196 "vpord" : __asm_proxy_VPORD__,
1197 "vporq" : __asm_proxy_VPORQ__,
1198 "vpperm" : __asm_proxy_VPPERM__,
1199 "vprold" : __asm_proxy_VPROLD__,
1200 "vprolq" : __asm_proxy_VPROLQ__,
1201 "vprolvd" : __asm_proxy_VPROLVD__,
1202 "vprolvq" : __asm_proxy_VPROLVQ__,
1203 "vprord" : __asm_proxy_VPRORD__,
1204 "vprorq" : __asm_proxy_VPRORQ__,
1205 "vprorvd" : __asm_proxy_VPRORVD__,
1206 "vprorvq" : __asm_proxy_VPRORVQ__,
1207 "vprotb" : __asm_proxy_VPROTB__,
1208 "vprotd" : __asm_proxy_VPROTD__,
1209 "vprotq" : __asm_proxy_VPROTQ__,
1210 "vprotw" : __asm_proxy_VPROTW__,
1211 "vpsadbw" : __asm_proxy_VPSADBW__,
1212 "vpscatterdd" : __asm_proxy_VPSCATTERDD__,
1213 "vpscatterdq" : __asm_proxy_VPSCATTERDQ__,
1214 "vpscatterqd" : __asm_proxy_VPSCATTERQD__,
1215 "vpscatterqq" : __asm_proxy_VPSCATTERQQ__,
1216 "vpshab" : __asm_proxy_VPSHAB__,
1217 "vpshad" : __asm_proxy_VPSHAD__,
1218 "vpshaq" : __asm_proxy_VPSHAQ__,
1219 "vpshaw" : __asm_proxy_VPSHAW__,
1220 "vpshlb" : __asm_proxy_VPSHLB__,
1221 "vpshld" : __asm_proxy_VPSHLD__,
1222 "vpshlq" : __asm_proxy_VPSHLQ__,
1223 "vpshlw" : __asm_proxy_VPSHLW__,
1224 "vpshufb" : __asm_proxy_VPSHUFB__,
1225 "vpshufd" : __asm_proxy_VPSHUFD__,
1226 "vpshufhw" : __asm_proxy_VPSHUFHW__,
1227 "vpshuflw" : __asm_proxy_VPSHUFLW__,
1228 "vpsignb" : __asm_proxy_VPSIGNB__,
1229 "vpsignd" : __asm_proxy_VPSIGND__,
1230 "vpsignw" : __asm_proxy_VPSIGNW__,
1231 "vpslld" : __asm_proxy_VPSLLD__,
1232 "vpslldq" : __asm_proxy_VPSLLDQ__,
1233 "vpsllq" : __asm_proxy_VPSLLQ__,
1234 "vpsllvd" : __asm_proxy_VPSLLVD__,
1235 "vpsllvq" : __asm_proxy_VPSLLVQ__,
1236 "vpsllvw" : __asm_proxy_VPSLLVW__,
1237 "vpsllw" : __asm_proxy_VPSLLW__,
1238 "vpsrad" : __asm_proxy_VPSRAD__,
1239 "vpsraq" : __asm_proxy_VPSRAQ__,
1240 "vpsravd" : __asm_proxy_VPSRAVD__,
1241 "vpsravq" : __asm_proxy_VPSRAVQ__,
1242 "vpsravw" : __asm_proxy_VPSRAVW__,
1243 "vpsraw" : __asm_proxy_VPSRAW__,
1244 "vpsrld" : __asm_proxy_VPSRLD__,
1245 "vpsrldq" : __asm_proxy_VPSRLDQ__,
1246 "vpsrlq" : __asm_proxy_VPSRLQ__,
1247 "vpsrlvd" : __asm_proxy_VPSRLVD__,
1248 "vpsrlvq" : __asm_proxy_VPSRLVQ__,
1249 "vpsrlvw" : __asm_proxy_VPSRLVW__,
1250 "vpsrlw" : __asm_proxy_VPSRLW__,
1251 "vpsubb" : __asm_proxy_VPSUBB__,
1252 "vpsubd" : __asm_proxy_VPSUBD__,
1253 "vpsubq" : __asm_proxy_VPSUBQ__,
1254 "vpsubsb" : __asm_proxy_VPSUBSB__,
1255 "vpsubsw" : __asm_proxy_VPSUBSW__,
1256 "vpsubusb" : __asm_proxy_VPSUBUSB__,
1257 "vpsubusw" : __asm_proxy_VPSUBUSW__,
1258 "vpsubw" : __asm_proxy_VPSUBW__,
1259 "vpternlogd" : __asm_proxy_VPTERNLOGD__,
1260 "vpternlogq" : __asm_proxy_VPTERNLOGQ__,
1261 "vptest" : __asm_proxy_VPTEST__,
1262 "vptestmb" : __asm_proxy_VPTESTMB__,
1263 "vptestmd" : __asm_proxy_VPTESTMD__,
1264 "vptestmq" : __asm_proxy_VPTESTMQ__,
1265 "vptestmw" : __asm_proxy_VPTESTMW__,
1266 "vptestnmb" : __asm_proxy_VPTESTNMB__,
1267 "vptestnmd" : __asm_proxy_VPTESTNMD__,
1268 "vptestnmq" : __asm_proxy_VPTESTNMQ__,
1269 "vptestnmw" : __asm_proxy_VPTESTNMW__,
1270 "vpunpckhbw" : __asm_proxy_VPUNPCKHBW__,
1271 "vpunpckhdq" : __asm_proxy_VPUNPCKHDQ__,
1272 "vpunpckhqdq" : __asm_proxy_VPUNPCKHQDQ__,
1273 "vpunpckhwd" : __asm_proxy_VPUNPCKHWD__,
1274 "vpunpcklbw" : __asm_proxy_VPUNPCKLBW__,
1275 "vpunpckldq" : __asm_proxy_VPUNPCKLDQ__,
1276 "vpunpcklqdq" : __asm_proxy_VPUNPCKLQDQ__,
1277 "vpunpcklwd" : __asm_proxy_VPUNPCKLWD__,
1278 "vpxor" : __asm_proxy_VPXOR__,
1279 "vpxord" : __asm_proxy_VPXORD__,
1280 "vpxorq" : __asm_proxy_VPXORQ__,
1281 "vrangepd" : __asm_proxy_VRANGEPD__,
1282 "vrangeps" : __asm_proxy_VRANGEPS__,
1283 "vrangesd" : __asm_proxy_VRANGESD__,
1284 "vrangess" : __asm_proxy_VRANGESS__,
1285 "vrcp14pd" : __asm_proxy_VRCP14PD__,
1286 "vrcp14ps" : __asm_proxy_VRCP14PS__,
1287 "vrcp14sd" : __asm_proxy_VRCP14SD__,
1288 "vrcp14ss" : __asm_proxy_VRCP14SS__,
1289 "vrcp28pd" : __asm_proxy_VRCP28PD__,
1290 "vrcp28ps" : __asm_proxy_VRCP28PS__,
1291 "vrcp28sd" : __asm_proxy_VRCP28SD__,
1292 "vrcp28ss" : __asm_proxy_VRCP28SS__,
1293 "vrcpps" : __asm_proxy_VRCPPS__,
1294 "vrcpss" : __asm_proxy_VRCPSS__,
1295 "vreducepd" : __asm_proxy_VREDUCEPD__,
1296 "vreduceps" : __asm_proxy_VREDUCEPS__,
1297 "vreducesd" : __asm_proxy_VREDUCESD__,
1298 "vreducess" : __asm_proxy_VREDUCESS__,
1299 "vrndscalepd" : __asm_proxy_VRNDSCALEPD__,
1300 "vrndscaleps" : __asm_proxy_VRNDSCALEPS__,
1301 "vrndscalesd" : __asm_proxy_VRNDSCALESD__,
1302 "vrndscaless" : __asm_proxy_VRNDSCALESS__,
1303 "vroundpd" : __asm_proxy_VROUNDPD__,
1304 "vroundps" : __asm_proxy_VROUNDPS__,
1305 "vroundsd" : __asm_proxy_VROUNDSD__,
1306 "vroundss" : __asm_proxy_VROUNDSS__,
1307 "vrsqrt14pd" : __asm_proxy_VRSQRT14PD__,
1308 "vrsqrt14ps" : __asm_proxy_VRSQRT14PS__,
1309 "vrsqrt14sd" : __asm_proxy_VRSQRT14SD__,
1310 "vrsqrt14ss" : __asm_proxy_VRSQRT14SS__,
1311 "vrsqrt28pd" : __asm_proxy_VRSQRT28PD__,
1312 "vrsqrt28ps" : __asm_proxy_VRSQRT28PS__,
1313 "vrsqrt28sd" : __asm_proxy_VRSQRT28SD__,
1314 "vrsqrt28ss" : __asm_proxy_VRSQRT28SS__,
1315 "vrsqrtps" : __asm_proxy_VRSQRTPS__,
1316 "vrsqrtss" : __asm_proxy_VRSQRTSS__,
1317 "vscalefpd" : __asm_proxy_VSCALEFPD__,
1318 "vscalefps" : __asm_proxy_VSCALEFPS__,
1319 "vscalefsd" : __asm_proxy_VSCALEFSD__,
1320 "vscalefss" : __asm_proxy_VSCALEFSS__,
1321 "vscatterdpd" : __asm_proxy_VSCATTERDPD__,
1322 "vscatterdps" : __asm_proxy_VSCATTERDPS__,
1323 "vscatterpf0dpd" : __asm_proxy_VSCATTERPF0DPD__,
1324 "vscatterpf0dps" : __asm_proxy_VSCATTERPF0DPS__,
1325 "vscatterpf0qpd" : __asm_proxy_VSCATTERPF0QPD__,
1326 "vscatterpf0qps" : __asm_proxy_VSCATTERPF0QPS__,
1327 "vscatterpf1dpd" : __asm_proxy_VSCATTERPF1DPD__,
1328 "vscatterpf1dps" : __asm_proxy_VSCATTERPF1DPS__,
1329 "vscatterpf1qpd" : __asm_proxy_VSCATTERPF1QPD__,
1330 "vscatterpf1qps" : __asm_proxy_VSCATTERPF1QPS__,
1331 "vscatterqpd" : __asm_proxy_VSCATTERQPD__,
1332 "vscatterqps" : __asm_proxy_VSCATTERQPS__,
1333 "vshuff32x4" : __asm_proxy_VSHUFF32X4__,
1334 "vshuff64x2" : __asm_proxy_VSHUFF64X2__,
1335 "vshufi32x4" : __asm_proxy_VSHUFI32X4__,
1336 "vshufi64x2" : __asm_proxy_VSHUFI64X2__,
1337 "vshufpd" : __asm_proxy_VSHUFPD__,
1338 "vshufps" : __asm_proxy_VSHUFPS__,
1339 "vsqrtpd" : __asm_proxy_VSQRTPD__,
1340 "vsqrtps" : __asm_proxy_VSQRTPS__,
1341 "vsqrtsd" : __asm_proxy_VSQRTSD__,
1342 "vsqrtss" : __asm_proxy_VSQRTSS__,
1343 "vstmxcsr" : __asm_proxy_VSTMXCSR__,
1344 "vsubpd" : __asm_proxy_VSUBPD__,
1345 "vsubps" : __asm_proxy_VSUBPS__,
1346 "vsubsd" : __asm_proxy_VSUBSD__,
1347 "vsubss" : __asm_proxy_VSUBSS__,
1348 "vtestpd" : __asm_proxy_VTESTPD__,
1349 "vtestps" : __asm_proxy_VTESTPS__,
1350 "vucomisd" : __asm_proxy_VUCOMISD__,
1351 "vucomiss" : __asm_proxy_VUCOMISS__,
1352 "vunpckhpd" : __asm_proxy_VUNPCKHPD__,
1353 "vunpckhps" : __asm_proxy_VUNPCKHPS__,
1354 "vunpcklpd" : __asm_proxy_VUNPCKLPD__,
1355 "vunpcklps" : __asm_proxy_VUNPCKLPS__,
1356 "vxorpd" : __asm_proxy_VXORPD__,
1357 "vxorps" : __asm_proxy_VXORPS__,
1358 "vzeroall" : __asm_proxy_VZEROALL__,
1359 "vzeroupper" : __asm_proxy_VZEROUPPER__,
1360 "xaddb" : __asm_proxy_XADDB__,
1361 "xaddl" : __asm_proxy_XADDL__,
1362 "xaddq" : __asm_proxy_XADDQ__,
1363 "xaddw" : __asm_proxy_XADDW__,
1364 "xchgb" : __asm_proxy_XCHGB__,
1365 "xchgl" : __asm_proxy_XCHGL__,
1366 "xchgq" : __asm_proxy_XCHGQ__,
1367 "xchgw" : __asm_proxy_XCHGW__,
1368 "xgetbv" : __asm_proxy_XGETBV__,
1369 "xlatb" : __asm_proxy_XLATB__,
1370 "xorb" : __asm_proxy_XORB__,
1371 "xorl" : __asm_proxy_XORL__,
1372 "xorpd" : __asm_proxy_XORPD__,
1373 "xorps" : __asm_proxy_XORPS__,
1374 "xorq" : __asm_proxy_XORQ__,
1375 "xorw" : __asm_proxy_XORW__,
1376 }
1377
1378 func __asm_proxy_ADCB__(p *Program, v ...interface{}) *Instruction {
1379 if len(v) == 2 {
1380 return p.ADCB(v[0], v[1])
1381 } else {
1382 panic("instruction ADCB takes exactly 2 operands")
1383 }
1384 }
1385
1386 func __asm_proxy_ADCL__(p *Program, v ...interface{}) *Instruction {
1387 if len(v) == 2 {
1388 return p.ADCL(v[0], v[1])
1389 } else {
1390 panic("instruction ADCL takes exactly 2 operands")
1391 }
1392 }
1393
1394 func __asm_proxy_ADCQ__(p *Program, v ...interface{}) *Instruction {
1395 if len(v) == 2 {
1396 return p.ADCQ(v[0], v[1])
1397 } else {
1398 panic("instruction ADCQ takes exactly 2 operands")
1399 }
1400 }
1401
1402 func __asm_proxy_ADCW__(p *Program, v ...interface{}) *Instruction {
1403 if len(v) == 2 {
1404 return p.ADCW(v[0], v[1])
1405 } else {
1406 panic("instruction ADCW takes exactly 2 operands")
1407 }
1408 }
1409
1410 func __asm_proxy_ADCXL__(p *Program, v ...interface{}) *Instruction {
1411 if len(v) == 2 {
1412 return p.ADCXL(v[0], v[1])
1413 } else {
1414 panic("instruction ADCXL takes exactly 2 operands")
1415 }
1416 }
1417
1418 func __asm_proxy_ADCXQ__(p *Program, v ...interface{}) *Instruction {
1419 if len(v) == 2 {
1420 return p.ADCXQ(v[0], v[1])
1421 } else {
1422 panic("instruction ADCXQ takes exactly 2 operands")
1423 }
1424 }
1425
1426 func __asm_proxy_ADDB__(p *Program, v ...interface{}) *Instruction {
1427 if len(v) == 2 {
1428 return p.ADDB(v[0], v[1])
1429 } else {
1430 panic("instruction ADDB takes exactly 2 operands")
1431 }
1432 }
1433
1434 func __asm_proxy_ADDL__(p *Program, v ...interface{}) *Instruction {
1435 if len(v) == 2 {
1436 return p.ADDL(v[0], v[1])
1437 } else {
1438 panic("instruction ADDL takes exactly 2 operands")
1439 }
1440 }
1441
1442 func __asm_proxy_ADDPD__(p *Program, v ...interface{}) *Instruction {
1443 if len(v) == 2 {
1444 return p.ADDPD(v[0], v[1])
1445 } else {
1446 panic("instruction ADDPD takes exactly 2 operands")
1447 }
1448 }
1449
1450 func __asm_proxy_ADDPS__(p *Program, v ...interface{}) *Instruction {
1451 if len(v) == 2 {
1452 return p.ADDPS(v[0], v[1])
1453 } else {
1454 panic("instruction ADDPS takes exactly 2 operands")
1455 }
1456 }
1457
1458 func __asm_proxy_ADDQ__(p *Program, v ...interface{}) *Instruction {
1459 if len(v) == 2 {
1460 return p.ADDQ(v[0], v[1])
1461 } else {
1462 panic("instruction ADDQ takes exactly 2 operands")
1463 }
1464 }
1465
1466 func __asm_proxy_ADDSD__(p *Program, v ...interface{}) *Instruction {
1467 if len(v) == 2 {
1468 return p.ADDSD(v[0], v[1])
1469 } else {
1470 panic("instruction ADDSD takes exactly 2 operands")
1471 }
1472 }
1473
1474 func __asm_proxy_ADDSS__(p *Program, v ...interface{}) *Instruction {
1475 if len(v) == 2 {
1476 return p.ADDSS(v[0], v[1])
1477 } else {
1478 panic("instruction ADDSS takes exactly 2 operands")
1479 }
1480 }
1481
1482 func __asm_proxy_ADDSUBPD__(p *Program, v ...interface{}) *Instruction {
1483 if len(v) == 2 {
1484 return p.ADDSUBPD(v[0], v[1])
1485 } else {
1486 panic("instruction ADDSUBPD takes exactly 2 operands")
1487 }
1488 }
1489
1490 func __asm_proxy_ADDSUBPS__(p *Program, v ...interface{}) *Instruction {
1491 if len(v) == 2 {
1492 return p.ADDSUBPS(v[0], v[1])
1493 } else {
1494 panic("instruction ADDSUBPS takes exactly 2 operands")
1495 }
1496 }
1497
1498 func __asm_proxy_ADDW__(p *Program, v ...interface{}) *Instruction {
1499 if len(v) == 2 {
1500 return p.ADDW(v[0], v[1])
1501 } else {
1502 panic("instruction ADDW takes exactly 2 operands")
1503 }
1504 }
1505
1506 func __asm_proxy_ADOXL__(p *Program, v ...interface{}) *Instruction {
1507 if len(v) == 2 {
1508 return p.ADOXL(v[0], v[1])
1509 } else {
1510 panic("instruction ADOXL takes exactly 2 operands")
1511 }
1512 }
1513
1514 func __asm_proxy_ADOXQ__(p *Program, v ...interface{}) *Instruction {
1515 if len(v) == 2 {
1516 return p.ADOXQ(v[0], v[1])
1517 } else {
1518 panic("instruction ADOXQ takes exactly 2 operands")
1519 }
1520 }
1521
1522 func __asm_proxy_AESDEC__(p *Program, v ...interface{}) *Instruction {
1523 if len(v) == 2 {
1524 return p.AESDEC(v[0], v[1])
1525 } else {
1526 panic("instruction AESDEC takes exactly 2 operands")
1527 }
1528 }
1529
1530 func __asm_proxy_AESDECLAST__(p *Program, v ...interface{}) *Instruction {
1531 if len(v) == 2 {
1532 return p.AESDECLAST(v[0], v[1])
1533 } else {
1534 panic("instruction AESDECLAST takes exactly 2 operands")
1535 }
1536 }
1537
1538 func __asm_proxy_AESENC__(p *Program, v ...interface{}) *Instruction {
1539 if len(v) == 2 {
1540 return p.AESENC(v[0], v[1])
1541 } else {
1542 panic("instruction AESENC takes exactly 2 operands")
1543 }
1544 }
1545
1546 func __asm_proxy_AESENCLAST__(p *Program, v ...interface{}) *Instruction {
1547 if len(v) == 2 {
1548 return p.AESENCLAST(v[0], v[1])
1549 } else {
1550 panic("instruction AESENCLAST takes exactly 2 operands")
1551 }
1552 }
1553
1554 func __asm_proxy_AESIMC__(p *Program, v ...interface{}) *Instruction {
1555 if len(v) == 2 {
1556 return p.AESIMC(v[0], v[1])
1557 } else {
1558 panic("instruction AESIMC takes exactly 2 operands")
1559 }
1560 }
1561
1562 func __asm_proxy_AESKEYGENASSIST__(p *Program, v ...interface{}) *Instruction {
1563 if len(v) == 3 {
1564 return p.AESKEYGENASSIST(v[0], v[1], v[2])
1565 } else {
1566 panic("instruction AESKEYGENASSIST takes exactly 3 operands")
1567 }
1568 }
1569
1570 func __asm_proxy_ANDB__(p *Program, v ...interface{}) *Instruction {
1571 if len(v) == 2 {
1572 return p.ANDB(v[0], v[1])
1573 } else {
1574 panic("instruction ANDB takes exactly 2 operands")
1575 }
1576 }
1577
1578 func __asm_proxy_ANDL__(p *Program, v ...interface{}) *Instruction {
1579 if len(v) == 2 {
1580 return p.ANDL(v[0], v[1])
1581 } else {
1582 panic("instruction ANDL takes exactly 2 operands")
1583 }
1584 }
1585
1586 func __asm_proxy_ANDNL__(p *Program, v ...interface{}) *Instruction {
1587 if len(v) == 3 {
1588 return p.ANDNL(v[0], v[1], v[2])
1589 } else {
1590 panic("instruction ANDNL takes exactly 3 operands")
1591 }
1592 }
1593
1594 func __asm_proxy_ANDNPD__(p *Program, v ...interface{}) *Instruction {
1595 if len(v) == 2 {
1596 return p.ANDNPD(v[0], v[1])
1597 } else {
1598 panic("instruction ANDNPD takes exactly 2 operands")
1599 }
1600 }
1601
1602 func __asm_proxy_ANDNPS__(p *Program, v ...interface{}) *Instruction {
1603 if len(v) == 2 {
1604 return p.ANDNPS(v[0], v[1])
1605 } else {
1606 panic("instruction ANDNPS takes exactly 2 operands")
1607 }
1608 }
1609
1610 func __asm_proxy_ANDNQ__(p *Program, v ...interface{}) *Instruction {
1611 if len(v) == 3 {
1612 return p.ANDNQ(v[0], v[1], v[2])
1613 } else {
1614 panic("instruction ANDNQ takes exactly 3 operands")
1615 }
1616 }
1617
1618 func __asm_proxy_ANDPD__(p *Program, v ...interface{}) *Instruction {
1619 if len(v) == 2 {
1620 return p.ANDPD(v[0], v[1])
1621 } else {
1622 panic("instruction ANDPD takes exactly 2 operands")
1623 }
1624 }
1625
1626 func __asm_proxy_ANDPS__(p *Program, v ...interface{}) *Instruction {
1627 if len(v) == 2 {
1628 return p.ANDPS(v[0], v[1])
1629 } else {
1630 panic("instruction ANDPS takes exactly 2 operands")
1631 }
1632 }
1633
1634 func __asm_proxy_ANDQ__(p *Program, v ...interface{}) *Instruction {
1635 if len(v) == 2 {
1636 return p.ANDQ(v[0], v[1])
1637 } else {
1638 panic("instruction ANDQ takes exactly 2 operands")
1639 }
1640 }
1641
1642 func __asm_proxy_ANDW__(p *Program, v ...interface{}) *Instruction {
1643 if len(v) == 2 {
1644 return p.ANDW(v[0], v[1])
1645 } else {
1646 panic("instruction ANDW takes exactly 2 operands")
1647 }
1648 }
1649
1650 func __asm_proxy_BEXTR__(p *Program, v ...interface{}) *Instruction {
1651 if len(v) == 3 {
1652 return p.BEXTR(v[0], v[1], v[2])
1653 } else {
1654 panic("instruction BEXTR takes exactly 3 operands")
1655 }
1656 }
1657
1658 func __asm_proxy_BLCFILL__(p *Program, v ...interface{}) *Instruction {
1659 if len(v) == 2 {
1660 return p.BLCFILL(v[0], v[1])
1661 } else {
1662 panic("instruction BLCFILL takes exactly 2 operands")
1663 }
1664 }
1665
1666 func __asm_proxy_BLCI__(p *Program, v ...interface{}) *Instruction {
1667 if len(v) == 2 {
1668 return p.BLCI(v[0], v[1])
1669 } else {
1670 panic("instruction BLCI takes exactly 2 operands")
1671 }
1672 }
1673
1674 func __asm_proxy_BLCIC__(p *Program, v ...interface{}) *Instruction {
1675 if len(v) == 2 {
1676 return p.BLCIC(v[0], v[1])
1677 } else {
1678 panic("instruction BLCIC takes exactly 2 operands")
1679 }
1680 }
1681
1682 func __asm_proxy_BLCMSK__(p *Program, v ...interface{}) *Instruction {
1683 if len(v) == 2 {
1684 return p.BLCMSK(v[0], v[1])
1685 } else {
1686 panic("instruction BLCMSK takes exactly 2 operands")
1687 }
1688 }
1689
1690 func __asm_proxy_BLCS__(p *Program, v ...interface{}) *Instruction {
1691 if len(v) == 2 {
1692 return p.BLCS(v[0], v[1])
1693 } else {
1694 panic("instruction BLCS takes exactly 2 operands")
1695 }
1696 }
1697
1698 func __asm_proxy_BLENDPD__(p *Program, v ...interface{}) *Instruction {
1699 if len(v) == 3 {
1700 return p.BLENDPD(v[0], v[1], v[2])
1701 } else {
1702 panic("instruction BLENDPD takes exactly 3 operands")
1703 }
1704 }
1705
1706 func __asm_proxy_BLENDPS__(p *Program, v ...interface{}) *Instruction {
1707 if len(v) == 3 {
1708 return p.BLENDPS(v[0], v[1], v[2])
1709 } else {
1710 panic("instruction BLENDPS takes exactly 3 operands")
1711 }
1712 }
1713
1714 func __asm_proxy_BLENDVPD__(p *Program, v ...interface{}) *Instruction {
1715 if len(v) == 3 {
1716 return p.BLENDVPD(v[0], v[1], v[2])
1717 } else {
1718 panic("instruction BLENDVPD takes exactly 3 operands")
1719 }
1720 }
1721
1722 func __asm_proxy_BLENDVPS__(p *Program, v ...interface{}) *Instruction {
1723 if len(v) == 3 {
1724 return p.BLENDVPS(v[0], v[1], v[2])
1725 } else {
1726 panic("instruction BLENDVPS takes exactly 3 operands")
1727 }
1728 }
1729
1730 func __asm_proxy_BLSFILL__(p *Program, v ...interface{}) *Instruction {
1731 if len(v) == 2 {
1732 return p.BLSFILL(v[0], v[1])
1733 } else {
1734 panic("instruction BLSFILL takes exactly 2 operands")
1735 }
1736 }
1737
1738 func __asm_proxy_BLSI__(p *Program, v ...interface{}) *Instruction {
1739 if len(v) == 2 {
1740 return p.BLSI(v[0], v[1])
1741 } else {
1742 panic("instruction BLSI takes exactly 2 operands")
1743 }
1744 }
1745
1746 func __asm_proxy_BLSIC__(p *Program, v ...interface{}) *Instruction {
1747 if len(v) == 2 {
1748 return p.BLSIC(v[0], v[1])
1749 } else {
1750 panic("instruction BLSIC takes exactly 2 operands")
1751 }
1752 }
1753
1754 func __asm_proxy_BLSMSK__(p *Program, v ...interface{}) *Instruction {
1755 if len(v) == 2 {
1756 return p.BLSMSK(v[0], v[1])
1757 } else {
1758 panic("instruction BLSMSK takes exactly 2 operands")
1759 }
1760 }
1761
1762 func __asm_proxy_BLSR__(p *Program, v ...interface{}) *Instruction {
1763 if len(v) == 2 {
1764 return p.BLSR(v[0], v[1])
1765 } else {
1766 panic("instruction BLSR takes exactly 2 operands")
1767 }
1768 }
1769
1770 func __asm_proxy_BSFL__(p *Program, v ...interface{}) *Instruction {
1771 if len(v) == 2 {
1772 return p.BSFL(v[0], v[1])
1773 } else {
1774 panic("instruction BSFL takes exactly 2 operands")
1775 }
1776 }
1777
1778 func __asm_proxy_BSFQ__(p *Program, v ...interface{}) *Instruction {
1779 if len(v) == 2 {
1780 return p.BSFQ(v[0], v[1])
1781 } else {
1782 panic("instruction BSFQ takes exactly 2 operands")
1783 }
1784 }
1785
1786 func __asm_proxy_BSFW__(p *Program, v ...interface{}) *Instruction {
1787 if len(v) == 2 {
1788 return p.BSFW(v[0], v[1])
1789 } else {
1790 panic("instruction BSFW takes exactly 2 operands")
1791 }
1792 }
1793
1794 func __asm_proxy_BSRL__(p *Program, v ...interface{}) *Instruction {
1795 if len(v) == 2 {
1796 return p.BSRL(v[0], v[1])
1797 } else {
1798 panic("instruction BSRL takes exactly 2 operands")
1799 }
1800 }
1801
1802 func __asm_proxy_BSRQ__(p *Program, v ...interface{}) *Instruction {
1803 if len(v) == 2 {
1804 return p.BSRQ(v[0], v[1])
1805 } else {
1806 panic("instruction BSRQ takes exactly 2 operands")
1807 }
1808 }
1809
1810 func __asm_proxy_BSRW__(p *Program, v ...interface{}) *Instruction {
1811 if len(v) == 2 {
1812 return p.BSRW(v[0], v[1])
1813 } else {
1814 panic("instruction BSRW takes exactly 2 operands")
1815 }
1816 }
1817
1818 func __asm_proxy_BSWAPL__(p *Program, v ...interface{}) *Instruction {
1819 if len(v) == 1 {
1820 return p.BSWAPL(v[0])
1821 } else {
1822 panic("instruction BSWAPL takes exactly 1 operand")
1823 }
1824 }
1825
1826 func __asm_proxy_BSWAPQ__(p *Program, v ...interface{}) *Instruction {
1827 if len(v) == 1 {
1828 return p.BSWAPQ(v[0])
1829 } else {
1830 panic("instruction BSWAPQ takes exactly 1 operand")
1831 }
1832 }
1833
1834 func __asm_proxy_BTCL__(p *Program, v ...interface{}) *Instruction {
1835 if len(v) == 2 {
1836 return p.BTCL(v[0], v[1])
1837 } else {
1838 panic("instruction BTCL takes exactly 2 operands")
1839 }
1840 }
1841
1842 func __asm_proxy_BTCQ__(p *Program, v ...interface{}) *Instruction {
1843 if len(v) == 2 {
1844 return p.BTCQ(v[0], v[1])
1845 } else {
1846 panic("instruction BTCQ takes exactly 2 operands")
1847 }
1848 }
1849
1850 func __asm_proxy_BTCW__(p *Program, v ...interface{}) *Instruction {
1851 if len(v) == 2 {
1852 return p.BTCW(v[0], v[1])
1853 } else {
1854 panic("instruction BTCW takes exactly 2 operands")
1855 }
1856 }
1857
1858 func __asm_proxy_BTL__(p *Program, v ...interface{}) *Instruction {
1859 if len(v) == 2 {
1860 return p.BTL(v[0], v[1])
1861 } else {
1862 panic("instruction BTL takes exactly 2 operands")
1863 }
1864 }
1865
1866 func __asm_proxy_BTQ__(p *Program, v ...interface{}) *Instruction {
1867 if len(v) == 2 {
1868 return p.BTQ(v[0], v[1])
1869 } else {
1870 panic("instruction BTQ takes exactly 2 operands")
1871 }
1872 }
1873
1874 func __asm_proxy_BTRL__(p *Program, v ...interface{}) *Instruction {
1875 if len(v) == 2 {
1876 return p.BTRL(v[0], v[1])
1877 } else {
1878 panic("instruction BTRL takes exactly 2 operands")
1879 }
1880 }
1881
1882 func __asm_proxy_BTRQ__(p *Program, v ...interface{}) *Instruction {
1883 if len(v) == 2 {
1884 return p.BTRQ(v[0], v[1])
1885 } else {
1886 panic("instruction BTRQ takes exactly 2 operands")
1887 }
1888 }
1889
1890 func __asm_proxy_BTRW__(p *Program, v ...interface{}) *Instruction {
1891 if len(v) == 2 {
1892 return p.BTRW(v[0], v[1])
1893 } else {
1894 panic("instruction BTRW takes exactly 2 operands")
1895 }
1896 }
1897
1898 func __asm_proxy_BTSL__(p *Program, v ...interface{}) *Instruction {
1899 if len(v) == 2 {
1900 return p.BTSL(v[0], v[1])
1901 } else {
1902 panic("instruction BTSL takes exactly 2 operands")
1903 }
1904 }
1905
1906 func __asm_proxy_BTSQ__(p *Program, v ...interface{}) *Instruction {
1907 if len(v) == 2 {
1908 return p.BTSQ(v[0], v[1])
1909 } else {
1910 panic("instruction BTSQ takes exactly 2 operands")
1911 }
1912 }
1913
1914 func __asm_proxy_BTSW__(p *Program, v ...interface{}) *Instruction {
1915 if len(v) == 2 {
1916 return p.BTSW(v[0], v[1])
1917 } else {
1918 panic("instruction BTSW takes exactly 2 operands")
1919 }
1920 }
1921
1922 func __asm_proxy_BTW__(p *Program, v ...interface{}) *Instruction {
1923 if len(v) == 2 {
1924 return p.BTW(v[0], v[1])
1925 } else {
1926 panic("instruction BTW takes exactly 2 operands")
1927 }
1928 }
1929
1930 func __asm_proxy_BZHI__(p *Program, v ...interface{}) *Instruction {
1931 if len(v) == 3 {
1932 return p.BZHI(v[0], v[1], v[2])
1933 } else {
1934 panic("instruction BZHI takes exactly 3 operands")
1935 }
1936 }
1937
1938 func __asm_proxy_CALL__(p *Program, v ...interface{}) *Instruction {
1939 if len(v) == 1 {
1940 return p.CALL(v[0])
1941 } else {
1942 panic("instruction CALL takes exactly 1 operand")
1943 }
1944 }
1945
1946 func __asm_proxy_CALLQ__(p *Program, v ...interface{}) *Instruction {
1947 if len(v) == 1 {
1948 return p.CALLQ(v[0])
1949 } else {
1950 panic("instruction CALLQ takes exactly 1 operand")
1951 }
1952 }
1953
1954 func __asm_proxy_CBTW__(p *Program, v ...interface{}) *Instruction {
1955 if len(v) == 0 {
1956 return p.CBTW()
1957 } else {
1958 panic("instruction CBTW takes no operands")
1959 }
1960 }
1961
1962 func __asm_proxy_CLC__(p *Program, v ...interface{}) *Instruction {
1963 if len(v) == 0 {
1964 return p.CLC()
1965 } else {
1966 panic("instruction CLC takes no operands")
1967 }
1968 }
1969
1970 func __asm_proxy_CLD__(p *Program, v ...interface{}) *Instruction {
1971 if len(v) == 0 {
1972 return p.CLD()
1973 } else {
1974 panic("instruction CLD takes no operands")
1975 }
1976 }
1977
1978 func __asm_proxy_CLFLUSH__(p *Program, v ...interface{}) *Instruction {
1979 if len(v) == 1 {
1980 return p.CLFLUSH(v[0])
1981 } else {
1982 panic("instruction CLFLUSH takes exactly 1 operand")
1983 }
1984 }
1985
1986 func __asm_proxy_CLFLUSHOPT__(p *Program, v ...interface{}) *Instruction {
1987 if len(v) == 1 {
1988 return p.CLFLUSHOPT(v[0])
1989 } else {
1990 panic("instruction CLFLUSHOPT takes exactly 1 operand")
1991 }
1992 }
1993
1994 func __asm_proxy_CLTD__(p *Program, v ...interface{}) *Instruction {
1995 if len(v) == 0 {
1996 return p.CLTD()
1997 } else {
1998 panic("instruction CLTD takes no operands")
1999 }
2000 }
2001
2002 func __asm_proxy_CLTQ__(p *Program, v ...interface{}) *Instruction {
2003 if len(v) == 0 {
2004 return p.CLTQ()
2005 } else {
2006 panic("instruction CLTQ takes no operands")
2007 }
2008 }
2009
2010 func __asm_proxy_CLWB__(p *Program, v ...interface{}) *Instruction {
2011 if len(v) == 1 {
2012 return p.CLWB(v[0])
2013 } else {
2014 panic("instruction CLWB takes exactly 1 operand")
2015 }
2016 }
2017
2018 func __asm_proxy_CLZERO__(p *Program, v ...interface{}) *Instruction {
2019 if len(v) == 0 {
2020 return p.CLZERO()
2021 } else {
2022 panic("instruction CLZERO takes no operands")
2023 }
2024 }
2025
2026 func __asm_proxy_CMC__(p *Program, v ...interface{}) *Instruction {
2027 if len(v) == 0 {
2028 return p.CMC()
2029 } else {
2030 panic("instruction CMC takes no operands")
2031 }
2032 }
2033
2034 func __asm_proxy_CMOVA__(p *Program, v ...interface{}) *Instruction {
2035 if len(v) == 2 {
2036 return p.CMOVA(v[0], v[1])
2037 } else {
2038 panic("instruction CMOVA takes exactly 2 operands")
2039 }
2040 }
2041
2042 func __asm_proxy_CMOVAE__(p *Program, v ...interface{}) *Instruction {
2043 if len(v) == 2 {
2044 return p.CMOVAE(v[0], v[1])
2045 } else {
2046 panic("instruction CMOVAE takes exactly 2 operands")
2047 }
2048 }
2049
2050 func __asm_proxy_CMOVB__(p *Program, v ...interface{}) *Instruction {
2051 if len(v) == 2 {
2052 return p.CMOVB(v[0], v[1])
2053 } else {
2054 panic("instruction CMOVB takes exactly 2 operands")
2055 }
2056 }
2057
2058 func __asm_proxy_CMOVBE__(p *Program, v ...interface{}) *Instruction {
2059 if len(v) == 2 {
2060 return p.CMOVBE(v[0], v[1])
2061 } else {
2062 panic("instruction CMOVBE takes exactly 2 operands")
2063 }
2064 }
2065
2066 func __asm_proxy_CMOVC__(p *Program, v ...interface{}) *Instruction {
2067 if len(v) == 2 {
2068 return p.CMOVC(v[0], v[1])
2069 } else {
2070 panic("instruction CMOVC takes exactly 2 operands")
2071 }
2072 }
2073
2074 func __asm_proxy_CMOVE__(p *Program, v ...interface{}) *Instruction {
2075 if len(v) == 2 {
2076 return p.CMOVE(v[0], v[1])
2077 } else {
2078 panic("instruction CMOVE takes exactly 2 operands")
2079 }
2080 }
2081
2082 func __asm_proxy_CMOVG__(p *Program, v ...interface{}) *Instruction {
2083 if len(v) == 2 {
2084 return p.CMOVG(v[0], v[1])
2085 } else {
2086 panic("instruction CMOVG takes exactly 2 operands")
2087 }
2088 }
2089
2090 func __asm_proxy_CMOVGE__(p *Program, v ...interface{}) *Instruction {
2091 if len(v) == 2 {
2092 return p.CMOVGE(v[0], v[1])
2093 } else {
2094 panic("instruction CMOVGE takes exactly 2 operands")
2095 }
2096 }
2097
2098 func __asm_proxy_CMOVL__(p *Program, v ...interface{}) *Instruction {
2099 if len(v) == 2 {
2100 return p.CMOVL(v[0], v[1])
2101 } else {
2102 panic("instruction CMOVL takes exactly 2 operands")
2103 }
2104 }
2105
2106 func __asm_proxy_CMOVLE__(p *Program, v ...interface{}) *Instruction {
2107 if len(v) == 2 {
2108 return p.CMOVLE(v[0], v[1])
2109 } else {
2110 panic("instruction CMOVLE takes exactly 2 operands")
2111 }
2112 }
2113
2114 func __asm_proxy_CMOVNA__(p *Program, v ...interface{}) *Instruction {
2115 if len(v) == 2 {
2116 return p.CMOVNA(v[0], v[1])
2117 } else {
2118 panic("instruction CMOVNA takes exactly 2 operands")
2119 }
2120 }
2121
2122 func __asm_proxy_CMOVNAE__(p *Program, v ...interface{}) *Instruction {
2123 if len(v) == 2 {
2124 return p.CMOVNAE(v[0], v[1])
2125 } else {
2126 panic("instruction CMOVNAE takes exactly 2 operands")
2127 }
2128 }
2129
2130 func __asm_proxy_CMOVNB__(p *Program, v ...interface{}) *Instruction {
2131 if len(v) == 2 {
2132 return p.CMOVNB(v[0], v[1])
2133 } else {
2134 panic("instruction CMOVNB takes exactly 2 operands")
2135 }
2136 }
2137
2138 func __asm_proxy_CMOVNBE__(p *Program, v ...interface{}) *Instruction {
2139 if len(v) == 2 {
2140 return p.CMOVNBE(v[0], v[1])
2141 } else {
2142 panic("instruction CMOVNBE takes exactly 2 operands")
2143 }
2144 }
2145
2146 func __asm_proxy_CMOVNC__(p *Program, v ...interface{}) *Instruction {
2147 if len(v) == 2 {
2148 return p.CMOVNC(v[0], v[1])
2149 } else {
2150 panic("instruction CMOVNC takes exactly 2 operands")
2151 }
2152 }
2153
2154 func __asm_proxy_CMOVNE__(p *Program, v ...interface{}) *Instruction {
2155 if len(v) == 2 {
2156 return p.CMOVNE(v[0], v[1])
2157 } else {
2158 panic("instruction CMOVNE takes exactly 2 operands")
2159 }
2160 }
2161
2162 func __asm_proxy_CMOVNG__(p *Program, v ...interface{}) *Instruction {
2163 if len(v) == 2 {
2164 return p.CMOVNG(v[0], v[1])
2165 } else {
2166 panic("instruction CMOVNG takes exactly 2 operands")
2167 }
2168 }
2169
2170 func __asm_proxy_CMOVNGE__(p *Program, v ...interface{}) *Instruction {
2171 if len(v) == 2 {
2172 return p.CMOVNGE(v[0], v[1])
2173 } else {
2174 panic("instruction CMOVNGE takes exactly 2 operands")
2175 }
2176 }
2177
2178 func __asm_proxy_CMOVNL__(p *Program, v ...interface{}) *Instruction {
2179 if len(v) == 2 {
2180 return p.CMOVNL(v[0], v[1])
2181 } else {
2182 panic("instruction CMOVNL takes exactly 2 operands")
2183 }
2184 }
2185
2186 func __asm_proxy_CMOVNLE__(p *Program, v ...interface{}) *Instruction {
2187 if len(v) == 2 {
2188 return p.CMOVNLE(v[0], v[1])
2189 } else {
2190 panic("instruction CMOVNLE takes exactly 2 operands")
2191 }
2192 }
2193
2194 func __asm_proxy_CMOVNO__(p *Program, v ...interface{}) *Instruction {
2195 if len(v) == 2 {
2196 return p.CMOVNO(v[0], v[1])
2197 } else {
2198 panic("instruction CMOVNO takes exactly 2 operands")
2199 }
2200 }
2201
2202 func __asm_proxy_CMOVNP__(p *Program, v ...interface{}) *Instruction {
2203 if len(v) == 2 {
2204 return p.CMOVNP(v[0], v[1])
2205 } else {
2206 panic("instruction CMOVNP takes exactly 2 operands")
2207 }
2208 }
2209
2210 func __asm_proxy_CMOVNS__(p *Program, v ...interface{}) *Instruction {
2211 if len(v) == 2 {
2212 return p.CMOVNS(v[0], v[1])
2213 } else {
2214 panic("instruction CMOVNS takes exactly 2 operands")
2215 }
2216 }
2217
2218 func __asm_proxy_CMOVNZ__(p *Program, v ...interface{}) *Instruction {
2219 if len(v) == 2 {
2220 return p.CMOVNZ(v[0], v[1])
2221 } else {
2222 panic("instruction CMOVNZ takes exactly 2 operands")
2223 }
2224 }
2225
2226 func __asm_proxy_CMOVO__(p *Program, v ...interface{}) *Instruction {
2227 if len(v) == 2 {
2228 return p.CMOVO(v[0], v[1])
2229 } else {
2230 panic("instruction CMOVO takes exactly 2 operands")
2231 }
2232 }
2233
2234 func __asm_proxy_CMOVP__(p *Program, v ...interface{}) *Instruction {
2235 if len(v) == 2 {
2236 return p.CMOVP(v[0], v[1])
2237 } else {
2238 panic("instruction CMOVP takes exactly 2 operands")
2239 }
2240 }
2241
2242 func __asm_proxy_CMOVPE__(p *Program, v ...interface{}) *Instruction {
2243 if len(v) == 2 {
2244 return p.CMOVPE(v[0], v[1])
2245 } else {
2246 panic("instruction CMOVPE takes exactly 2 operands")
2247 }
2248 }
2249
2250 func __asm_proxy_CMOVPO__(p *Program, v ...interface{}) *Instruction {
2251 if len(v) == 2 {
2252 return p.CMOVPO(v[0], v[1])
2253 } else {
2254 panic("instruction CMOVPO takes exactly 2 operands")
2255 }
2256 }
2257
2258 func __asm_proxy_CMOVS__(p *Program, v ...interface{}) *Instruction {
2259 if len(v) == 2 {
2260 return p.CMOVS(v[0], v[1])
2261 } else {
2262 panic("instruction CMOVS takes exactly 2 operands")
2263 }
2264 }
2265
2266 func __asm_proxy_CMOVZ__(p *Program, v ...interface{}) *Instruction {
2267 if len(v) == 2 {
2268 return p.CMOVZ(v[0], v[1])
2269 } else {
2270 panic("instruction CMOVZ takes exactly 2 operands")
2271 }
2272 }
2273
2274 func __asm_proxy_CMPB__(p *Program, v ...interface{}) *Instruction {
2275 if len(v) == 2 {
2276 return p.CMPB(v[0], v[1])
2277 } else {
2278 panic("instruction CMPB takes exactly 2 operands")
2279 }
2280 }
2281
2282 func __asm_proxy_CMPL__(p *Program, v ...interface{}) *Instruction {
2283 if len(v) == 2 {
2284 return p.CMPL(v[0], v[1])
2285 } else {
2286 panic("instruction CMPL takes exactly 2 operands")
2287 }
2288 }
2289
2290 func __asm_proxy_CMPPD__(p *Program, v ...interface{}) *Instruction {
2291 if len(v) == 3 {
2292 return p.CMPPD(v[0], v[1], v[2])
2293 } else {
2294 panic("instruction CMPPD takes exactly 3 operands")
2295 }
2296 }
2297
2298 func __asm_proxy_CMPPS__(p *Program, v ...interface{}) *Instruction {
2299 if len(v) == 3 {
2300 return p.CMPPS(v[0], v[1], v[2])
2301 } else {
2302 panic("instruction CMPPS takes exactly 3 operands")
2303 }
2304 }
2305
2306 func __asm_proxy_CMPQ__(p *Program, v ...interface{}) *Instruction {
2307 if len(v) == 2 {
2308 return p.CMPQ(v[0], v[1])
2309 } else {
2310 panic("instruction CMPQ takes exactly 2 operands")
2311 }
2312 }
2313
2314 func __asm_proxy_CMPSD__(p *Program, v ...interface{}) *Instruction {
2315 if len(v) == 3 {
2316 return p.CMPSD(v[0], v[1], v[2])
2317 } else {
2318 panic("instruction CMPSD takes exactly 3 operands")
2319 }
2320 }
2321
2322 func __asm_proxy_CMPSS__(p *Program, v ...interface{}) *Instruction {
2323 if len(v) == 3 {
2324 return p.CMPSS(v[0], v[1], v[2])
2325 } else {
2326 panic("instruction CMPSS takes exactly 3 operands")
2327 }
2328 }
2329
2330 func __asm_proxy_CMPW__(p *Program, v ...interface{}) *Instruction {
2331 if len(v) == 2 {
2332 return p.CMPW(v[0], v[1])
2333 } else {
2334 panic("instruction CMPW takes exactly 2 operands")
2335 }
2336 }
2337
2338 func __asm_proxy_CMPXCHG16B__(p *Program, v ...interface{}) *Instruction {
2339 if len(v) == 1 {
2340 return p.CMPXCHG16B(v[0])
2341 } else {
2342 panic("instruction CMPXCHG16B takes exactly 1 operand")
2343 }
2344 }
2345
2346 func __asm_proxy_CMPXCHG8B__(p *Program, v ...interface{}) *Instruction {
2347 if len(v) == 1 {
2348 return p.CMPXCHG8B(v[0])
2349 } else {
2350 panic("instruction CMPXCHG8B takes exactly 1 operand")
2351 }
2352 }
2353
2354 func __asm_proxy_CMPXCHGB__(p *Program, v ...interface{}) *Instruction {
2355 if len(v) == 2 {
2356 return p.CMPXCHGB(v[0], v[1])
2357 } else {
2358 panic("instruction CMPXCHGB takes exactly 2 operands")
2359 }
2360 }
2361
2362 func __asm_proxy_CMPXCHGL__(p *Program, v ...interface{}) *Instruction {
2363 if len(v) == 2 {
2364 return p.CMPXCHGL(v[0], v[1])
2365 } else {
2366 panic("instruction CMPXCHGL takes exactly 2 operands")
2367 }
2368 }
2369
2370 func __asm_proxy_CMPXCHGQ__(p *Program, v ...interface{}) *Instruction {
2371 if len(v) == 2 {
2372 return p.CMPXCHGQ(v[0], v[1])
2373 } else {
2374 panic("instruction CMPXCHGQ takes exactly 2 operands")
2375 }
2376 }
2377
2378 func __asm_proxy_CMPXCHGW__(p *Program, v ...interface{}) *Instruction {
2379 if len(v) == 2 {
2380 return p.CMPXCHGW(v[0], v[1])
2381 } else {
2382 panic("instruction CMPXCHGW takes exactly 2 operands")
2383 }
2384 }
2385
2386 func __asm_proxy_COMISD__(p *Program, v ...interface{}) *Instruction {
2387 if len(v) == 2 {
2388 return p.COMISD(v[0], v[1])
2389 } else {
2390 panic("instruction COMISD takes exactly 2 operands")
2391 }
2392 }
2393
2394 func __asm_proxy_COMISS__(p *Program, v ...interface{}) *Instruction {
2395 if len(v) == 2 {
2396 return p.COMISS(v[0], v[1])
2397 } else {
2398 panic("instruction COMISS takes exactly 2 operands")
2399 }
2400 }
2401
2402 func __asm_proxy_CPUID__(p *Program, v ...interface{}) *Instruction {
2403 if len(v) == 0 {
2404 return p.CPUID()
2405 } else {
2406 panic("instruction CPUID takes no operands")
2407 }
2408 }
2409
2410 func __asm_proxy_CQTO__(p *Program, v ...interface{}) *Instruction {
2411 if len(v) == 0 {
2412 return p.CQTO()
2413 } else {
2414 panic("instruction CQTO takes no operands")
2415 }
2416 }
2417
2418 func __asm_proxy_CRC32B__(p *Program, v ...interface{}) *Instruction {
2419 if len(v) == 2 {
2420 return p.CRC32B(v[0], v[1])
2421 } else {
2422 panic("instruction CRC32B takes exactly 2 operands")
2423 }
2424 }
2425
2426 func __asm_proxy_CRC32L__(p *Program, v ...interface{}) *Instruction {
2427 if len(v) == 2 {
2428 return p.CRC32L(v[0], v[1])
2429 } else {
2430 panic("instruction CRC32L takes exactly 2 operands")
2431 }
2432 }
2433
2434 func __asm_proxy_CRC32Q__(p *Program, v ...interface{}) *Instruction {
2435 if len(v) == 2 {
2436 return p.CRC32Q(v[0], v[1])
2437 } else {
2438 panic("instruction CRC32Q takes exactly 2 operands")
2439 }
2440 }
2441
2442 func __asm_proxy_CRC32W__(p *Program, v ...interface{}) *Instruction {
2443 if len(v) == 2 {
2444 return p.CRC32W(v[0], v[1])
2445 } else {
2446 panic("instruction CRC32W takes exactly 2 operands")
2447 }
2448 }
2449
2450 func __asm_proxy_CVTDQ2PD__(p *Program, v ...interface{}) *Instruction {
2451 if len(v) == 2 {
2452 return p.CVTDQ2PD(v[0], v[1])
2453 } else {
2454 panic("instruction CVTDQ2PD takes exactly 2 operands")
2455 }
2456 }
2457
2458 func __asm_proxy_CVTDQ2PS__(p *Program, v ...interface{}) *Instruction {
2459 if len(v) == 2 {
2460 return p.CVTDQ2PS(v[0], v[1])
2461 } else {
2462 panic("instruction CVTDQ2PS takes exactly 2 operands")
2463 }
2464 }
2465
2466 func __asm_proxy_CVTPD2DQ__(p *Program, v ...interface{}) *Instruction {
2467 if len(v) == 2 {
2468 return p.CVTPD2DQ(v[0], v[1])
2469 } else {
2470 panic("instruction CVTPD2DQ takes exactly 2 operands")
2471 }
2472 }
2473
2474 func __asm_proxy_CVTPD2PI__(p *Program, v ...interface{}) *Instruction {
2475 if len(v) == 2 {
2476 return p.CVTPD2PI(v[0], v[1])
2477 } else {
2478 panic("instruction CVTPD2PI takes exactly 2 operands")
2479 }
2480 }
2481
2482 func __asm_proxy_CVTPD2PS__(p *Program, v ...interface{}) *Instruction {
2483 if len(v) == 2 {
2484 return p.CVTPD2PS(v[0], v[1])
2485 } else {
2486 panic("instruction CVTPD2PS takes exactly 2 operands")
2487 }
2488 }
2489
2490 func __asm_proxy_CVTPI2PD__(p *Program, v ...interface{}) *Instruction {
2491 if len(v) == 2 {
2492 return p.CVTPI2PD(v[0], v[1])
2493 } else {
2494 panic("instruction CVTPI2PD takes exactly 2 operands")
2495 }
2496 }
2497
2498 func __asm_proxy_CVTPI2PS__(p *Program, v ...interface{}) *Instruction {
2499 if len(v) == 2 {
2500 return p.CVTPI2PS(v[0], v[1])
2501 } else {
2502 panic("instruction CVTPI2PS takes exactly 2 operands")
2503 }
2504 }
2505
2506 func __asm_proxy_CVTPS2DQ__(p *Program, v ...interface{}) *Instruction {
2507 if len(v) == 2 {
2508 return p.CVTPS2DQ(v[0], v[1])
2509 } else {
2510 panic("instruction CVTPS2DQ takes exactly 2 operands")
2511 }
2512 }
2513
2514 func __asm_proxy_CVTPS2PD__(p *Program, v ...interface{}) *Instruction {
2515 if len(v) == 2 {
2516 return p.CVTPS2PD(v[0], v[1])
2517 } else {
2518 panic("instruction CVTPS2PD takes exactly 2 operands")
2519 }
2520 }
2521
2522 func __asm_proxy_CVTPS2PI__(p *Program, v ...interface{}) *Instruction {
2523 if len(v) == 2 {
2524 return p.CVTPS2PI(v[0], v[1])
2525 } else {
2526 panic("instruction CVTPS2PI takes exactly 2 operands")
2527 }
2528 }
2529
2530 func __asm_proxy_CVTSD2SI__(p *Program, v ...interface{}) *Instruction {
2531 if len(v) == 2 {
2532 return p.CVTSD2SI(v[0], v[1])
2533 } else {
2534 panic("instruction CVTSD2SI takes exactly 2 operands")
2535 }
2536 }
2537
2538 func __asm_proxy_CVTSD2SS__(p *Program, v ...interface{}) *Instruction {
2539 if len(v) == 2 {
2540 return p.CVTSD2SS(v[0], v[1])
2541 } else {
2542 panic("instruction CVTSD2SS takes exactly 2 operands")
2543 }
2544 }
2545
2546 func __asm_proxy_CVTSI2SD__(p *Program, v ...interface{}) *Instruction {
2547 if len(v) == 2 {
2548 return p.CVTSI2SD(v[0], v[1])
2549 } else {
2550 panic("instruction CVTSI2SD takes exactly 2 operands")
2551 }
2552 }
2553
2554 func __asm_proxy_CVTSI2SS__(p *Program, v ...interface{}) *Instruction {
2555 if len(v) == 2 {
2556 return p.CVTSI2SS(v[0], v[1])
2557 } else {
2558 panic("instruction CVTSI2SS takes exactly 2 operands")
2559 }
2560 }
2561
2562 func __asm_proxy_CVTSS2SD__(p *Program, v ...interface{}) *Instruction {
2563 if len(v) == 2 {
2564 return p.CVTSS2SD(v[0], v[1])
2565 } else {
2566 panic("instruction CVTSS2SD takes exactly 2 operands")
2567 }
2568 }
2569
2570 func __asm_proxy_CVTSS2SI__(p *Program, v ...interface{}) *Instruction {
2571 if len(v) == 2 {
2572 return p.CVTSS2SI(v[0], v[1])
2573 } else {
2574 panic("instruction CVTSS2SI takes exactly 2 operands")
2575 }
2576 }
2577
2578 func __asm_proxy_CVTTPD2DQ__(p *Program, v ...interface{}) *Instruction {
2579 if len(v) == 2 {
2580 return p.CVTTPD2DQ(v[0], v[1])
2581 } else {
2582 panic("instruction CVTTPD2DQ takes exactly 2 operands")
2583 }
2584 }
2585
2586 func __asm_proxy_CVTTPD2PI__(p *Program, v ...interface{}) *Instruction {
2587 if len(v) == 2 {
2588 return p.CVTTPD2PI(v[0], v[1])
2589 } else {
2590 panic("instruction CVTTPD2PI takes exactly 2 operands")
2591 }
2592 }
2593
2594 func __asm_proxy_CVTTPS2DQ__(p *Program, v ...interface{}) *Instruction {
2595 if len(v) == 2 {
2596 return p.CVTTPS2DQ(v[0], v[1])
2597 } else {
2598 panic("instruction CVTTPS2DQ takes exactly 2 operands")
2599 }
2600 }
2601
2602 func __asm_proxy_CVTTPS2PI__(p *Program, v ...interface{}) *Instruction {
2603 if len(v) == 2 {
2604 return p.CVTTPS2PI(v[0], v[1])
2605 } else {
2606 panic("instruction CVTTPS2PI takes exactly 2 operands")
2607 }
2608 }
2609
2610 func __asm_proxy_CVTTSD2SI__(p *Program, v ...interface{}) *Instruction {
2611 if len(v) == 2 {
2612 return p.CVTTSD2SI(v[0], v[1])
2613 } else {
2614 panic("instruction CVTTSD2SI takes exactly 2 operands")
2615 }
2616 }
2617
2618 func __asm_proxy_CVTTSS2SI__(p *Program, v ...interface{}) *Instruction {
2619 if len(v) == 2 {
2620 return p.CVTTSS2SI(v[0], v[1])
2621 } else {
2622 panic("instruction CVTTSS2SI takes exactly 2 operands")
2623 }
2624 }
2625
2626 func __asm_proxy_CWTD__(p *Program, v ...interface{}) *Instruction {
2627 if len(v) == 0 {
2628 return p.CWTD()
2629 } else {
2630 panic("instruction CWTD takes no operands")
2631 }
2632 }
2633
2634 func __asm_proxy_CWTL__(p *Program, v ...interface{}) *Instruction {
2635 if len(v) == 0 {
2636 return p.CWTL()
2637 } else {
2638 panic("instruction CWTL takes no operands")
2639 }
2640 }
2641
2642 func __asm_proxy_DECB__(p *Program, v ...interface{}) *Instruction {
2643 if len(v) == 1 {
2644 return p.DECB(v[0])
2645 } else {
2646 panic("instruction DECB takes exactly 1 operand")
2647 }
2648 }
2649
2650 func __asm_proxy_DECL__(p *Program, v ...interface{}) *Instruction {
2651 if len(v) == 1 {
2652 return p.DECL(v[0])
2653 } else {
2654 panic("instruction DECL takes exactly 1 operand")
2655 }
2656 }
2657
2658 func __asm_proxy_DECQ__(p *Program, v ...interface{}) *Instruction {
2659 if len(v) == 1 {
2660 return p.DECQ(v[0])
2661 } else {
2662 panic("instruction DECQ takes exactly 1 operand")
2663 }
2664 }
2665
2666 func __asm_proxy_DECW__(p *Program, v ...interface{}) *Instruction {
2667 if len(v) == 1 {
2668 return p.DECW(v[0])
2669 } else {
2670 panic("instruction DECW takes exactly 1 operand")
2671 }
2672 }
2673
2674 func __asm_proxy_DIVB__(p *Program, v ...interface{}) *Instruction {
2675 if len(v) == 1 {
2676 return p.DIVB(v[0])
2677 } else {
2678 panic("instruction DIVB takes exactly 1 operand")
2679 }
2680 }
2681
2682 func __asm_proxy_DIVL__(p *Program, v ...interface{}) *Instruction {
2683 if len(v) == 1 {
2684 return p.DIVL(v[0])
2685 } else {
2686 panic("instruction DIVL takes exactly 1 operand")
2687 }
2688 }
2689
2690 func __asm_proxy_DIVPD__(p *Program, v ...interface{}) *Instruction {
2691 if len(v) == 2 {
2692 return p.DIVPD(v[0], v[1])
2693 } else {
2694 panic("instruction DIVPD takes exactly 2 operands")
2695 }
2696 }
2697
2698 func __asm_proxy_DIVPS__(p *Program, v ...interface{}) *Instruction {
2699 if len(v) == 2 {
2700 return p.DIVPS(v[0], v[1])
2701 } else {
2702 panic("instruction DIVPS takes exactly 2 operands")
2703 }
2704 }
2705
2706 func __asm_proxy_DIVQ__(p *Program, v ...interface{}) *Instruction {
2707 if len(v) == 1 {
2708 return p.DIVQ(v[0])
2709 } else {
2710 panic("instruction DIVQ takes exactly 1 operand")
2711 }
2712 }
2713
2714 func __asm_proxy_DIVSD__(p *Program, v ...interface{}) *Instruction {
2715 if len(v) == 2 {
2716 return p.DIVSD(v[0], v[1])
2717 } else {
2718 panic("instruction DIVSD takes exactly 2 operands")
2719 }
2720 }
2721
2722 func __asm_proxy_DIVSS__(p *Program, v ...interface{}) *Instruction {
2723 if len(v) == 2 {
2724 return p.DIVSS(v[0], v[1])
2725 } else {
2726 panic("instruction DIVSS takes exactly 2 operands")
2727 }
2728 }
2729
2730 func __asm_proxy_DIVW__(p *Program, v ...interface{}) *Instruction {
2731 if len(v) == 1 {
2732 return p.DIVW(v[0])
2733 } else {
2734 panic("instruction DIVW takes exactly 1 operand")
2735 }
2736 }
2737
2738 func __asm_proxy_DPPD__(p *Program, v ...interface{}) *Instruction {
2739 if len(v) == 3 {
2740 return p.DPPD(v[0], v[1], v[2])
2741 } else {
2742 panic("instruction DPPD takes exactly 3 operands")
2743 }
2744 }
2745
2746 func __asm_proxy_DPPS__(p *Program, v ...interface{}) *Instruction {
2747 if len(v) == 3 {
2748 return p.DPPS(v[0], v[1], v[2])
2749 } else {
2750 panic("instruction DPPS takes exactly 3 operands")
2751 }
2752 }
2753
2754 func __asm_proxy_EMMS__(p *Program, v ...interface{}) *Instruction {
2755 if len(v) == 0 {
2756 return p.EMMS()
2757 } else {
2758 panic("instruction EMMS takes no operands")
2759 }
2760 }
2761
2762 func __asm_proxy_EXTRACTPS__(p *Program, v ...interface{}) *Instruction {
2763 if len(v) == 3 {
2764 return p.EXTRACTPS(v[0], v[1], v[2])
2765 } else {
2766 panic("instruction EXTRACTPS takes exactly 3 operands")
2767 }
2768 }
2769
2770 func __asm_proxy_EXTRQ__(p *Program, v ...interface{}) *Instruction {
2771 switch len(v) {
2772 case 2 : return p.EXTRQ(v[0], v[1])
2773 case 3 : return p.EXTRQ(v[0], v[1], v[2])
2774 default : panic("instruction EXTRQ takes 2 or 3 operands")
2775 }
2776 }
2777
2778 func __asm_proxy_FEMMS__(p *Program, v ...interface{}) *Instruction {
2779 if len(v) == 0 {
2780 return p.FEMMS()
2781 } else {
2782 panic("instruction FEMMS takes no operands")
2783 }
2784 }
2785
2786 func __asm_proxy_HADDPD__(p *Program, v ...interface{}) *Instruction {
2787 if len(v) == 2 {
2788 return p.HADDPD(v[0], v[1])
2789 } else {
2790 panic("instruction HADDPD takes exactly 2 operands")
2791 }
2792 }
2793
2794 func __asm_proxy_HADDPS__(p *Program, v ...interface{}) *Instruction {
2795 if len(v) == 2 {
2796 return p.HADDPS(v[0], v[1])
2797 } else {
2798 panic("instruction HADDPS takes exactly 2 operands")
2799 }
2800 }
2801
2802 func __asm_proxy_HSUBPD__(p *Program, v ...interface{}) *Instruction {
2803 if len(v) == 2 {
2804 return p.HSUBPD(v[0], v[1])
2805 } else {
2806 panic("instruction HSUBPD takes exactly 2 operands")
2807 }
2808 }
2809
2810 func __asm_proxy_HSUBPS__(p *Program, v ...interface{}) *Instruction {
2811 if len(v) == 2 {
2812 return p.HSUBPS(v[0], v[1])
2813 } else {
2814 panic("instruction HSUBPS takes exactly 2 operands")
2815 }
2816 }
2817
2818 func __asm_proxy_IDIVB__(p *Program, v ...interface{}) *Instruction {
2819 if len(v) == 1 {
2820 return p.IDIVB(v[0])
2821 } else {
2822 panic("instruction IDIVB takes exactly 1 operand")
2823 }
2824 }
2825
2826 func __asm_proxy_IDIVL__(p *Program, v ...interface{}) *Instruction {
2827 if len(v) == 1 {
2828 return p.IDIVL(v[0])
2829 } else {
2830 panic("instruction IDIVL takes exactly 1 operand")
2831 }
2832 }
2833
2834 func __asm_proxy_IDIVQ__(p *Program, v ...interface{}) *Instruction {
2835 if len(v) == 1 {
2836 return p.IDIVQ(v[0])
2837 } else {
2838 panic("instruction IDIVQ takes exactly 1 operand")
2839 }
2840 }
2841
2842 func __asm_proxy_IDIVW__(p *Program, v ...interface{}) *Instruction {
2843 if len(v) == 1 {
2844 return p.IDIVW(v[0])
2845 } else {
2846 panic("instruction IDIVW takes exactly 1 operand")
2847 }
2848 }
2849
2850 func __asm_proxy_IMULB__(p *Program, v ...interface{}) *Instruction {
2851 if len(v) == 1 {
2852 return p.IMULB(v[0])
2853 } else {
2854 panic("instruction IMULB takes exactly 1 operand")
2855 }
2856 }
2857
2858 func __asm_proxy_IMULL__(p *Program, v ...interface{}) *Instruction {
2859 switch len(v) {
2860 case 1 : return p.IMULL(v[0])
2861 case 2 : return p.IMULL(v[0], v[1])
2862 case 3 : return p.IMULL(v[0], v[1], v[2])
2863 default : panic("instruction IMULL takes 1 or 2 or 3 operands")
2864 }
2865 }
2866
2867 func __asm_proxy_IMULQ__(p *Program, v ...interface{}) *Instruction {
2868 switch len(v) {
2869 case 1 : return p.IMULQ(v[0])
2870 case 2 : return p.IMULQ(v[0], v[1])
2871 case 3 : return p.IMULQ(v[0], v[1], v[2])
2872 default : panic("instruction IMULQ takes 1 or 2 or 3 operands")
2873 }
2874 }
2875
2876 func __asm_proxy_IMULW__(p *Program, v ...interface{}) *Instruction {
2877 switch len(v) {
2878 case 1 : return p.IMULW(v[0])
2879 case 2 : return p.IMULW(v[0], v[1])
2880 case 3 : return p.IMULW(v[0], v[1], v[2])
2881 default : panic("instruction IMULW takes 1 or 2 or 3 operands")
2882 }
2883 }
2884
2885 func __asm_proxy_INCB__(p *Program, v ...interface{}) *Instruction {
2886 if len(v) == 1 {
2887 return p.INCB(v[0])
2888 } else {
2889 panic("instruction INCB takes exactly 1 operand")
2890 }
2891 }
2892
2893 func __asm_proxy_INCL__(p *Program, v ...interface{}) *Instruction {
2894 if len(v) == 1 {
2895 return p.INCL(v[0])
2896 } else {
2897 panic("instruction INCL takes exactly 1 operand")
2898 }
2899 }
2900
2901 func __asm_proxy_INCQ__(p *Program, v ...interface{}) *Instruction {
2902 if len(v) == 1 {
2903 return p.INCQ(v[0])
2904 } else {
2905 panic("instruction INCQ takes exactly 1 operand")
2906 }
2907 }
2908
2909 func __asm_proxy_INCW__(p *Program, v ...interface{}) *Instruction {
2910 if len(v) == 1 {
2911 return p.INCW(v[0])
2912 } else {
2913 panic("instruction INCW takes exactly 1 operand")
2914 }
2915 }
2916
2917 func __asm_proxy_INSERTPS__(p *Program, v ...interface{}) *Instruction {
2918 if len(v) == 3 {
2919 return p.INSERTPS(v[0], v[1], v[2])
2920 } else {
2921 panic("instruction INSERTPS takes exactly 3 operands")
2922 }
2923 }
2924
2925 func __asm_proxy_INSERTQ__(p *Program, v ...interface{}) *Instruction {
2926 switch len(v) {
2927 case 2 : return p.INSERTQ(v[0], v[1])
2928 case 4 : return p.INSERTQ(v[0], v[1], v[2], v[3])
2929 default : panic("instruction INSERTQ takes 2 or 4 operands")
2930 }
2931 }
2932
2933 func __asm_proxy_INT__(p *Program, v ...interface{}) *Instruction {
2934 if len(v) == 1 {
2935 return p.INT(v[0])
2936 } else {
2937 panic("instruction INT takes exactly 1 operand")
2938 }
2939 }
2940
2941 func __asm_proxy_JA__(p *Program, v ...interface{}) *Instruction {
2942 if len(v) == 1 {
2943 return p.JA(v[0])
2944 } else {
2945 panic("instruction JA takes exactly 1 operand")
2946 }
2947 }
2948
2949 func __asm_proxy_JAE__(p *Program, v ...interface{}) *Instruction {
2950 if len(v) == 1 {
2951 return p.JAE(v[0])
2952 } else {
2953 panic("instruction JAE takes exactly 1 operand")
2954 }
2955 }
2956
2957 func __asm_proxy_JB__(p *Program, v ...interface{}) *Instruction {
2958 if len(v) == 1 {
2959 return p.JB(v[0])
2960 } else {
2961 panic("instruction JB takes exactly 1 operand")
2962 }
2963 }
2964
2965 func __asm_proxy_JBE__(p *Program, v ...interface{}) *Instruction {
2966 if len(v) == 1 {
2967 return p.JBE(v[0])
2968 } else {
2969 panic("instruction JBE takes exactly 1 operand")
2970 }
2971 }
2972
2973 func __asm_proxy_JC__(p *Program, v ...interface{}) *Instruction {
2974 if len(v) == 1 {
2975 return p.JC(v[0])
2976 } else {
2977 panic("instruction JC takes exactly 1 operand")
2978 }
2979 }
2980
2981 func __asm_proxy_JE__(p *Program, v ...interface{}) *Instruction {
2982 if len(v) == 1 {
2983 return p.JE(v[0])
2984 } else {
2985 panic("instruction JE takes exactly 1 operand")
2986 }
2987 }
2988
2989 func __asm_proxy_JECXZ__(p *Program, v ...interface{}) *Instruction {
2990 if len(v) == 1 {
2991 return p.JECXZ(v[0])
2992 } else {
2993 panic("instruction JECXZ takes exactly 1 operand")
2994 }
2995 }
2996
2997 func __asm_proxy_JG__(p *Program, v ...interface{}) *Instruction {
2998 if len(v) == 1 {
2999 return p.JG(v[0])
3000 } else {
3001 panic("instruction JG takes exactly 1 operand")
3002 }
3003 }
3004
3005 func __asm_proxy_JGE__(p *Program, v ...interface{}) *Instruction {
3006 if len(v) == 1 {
3007 return p.JGE(v[0])
3008 } else {
3009 panic("instruction JGE takes exactly 1 operand")
3010 }
3011 }
3012
3013 func __asm_proxy_JL__(p *Program, v ...interface{}) *Instruction {
3014 if len(v) == 1 {
3015 return p.JL(v[0])
3016 } else {
3017 panic("instruction JL takes exactly 1 operand")
3018 }
3019 }
3020
3021 func __asm_proxy_JLE__(p *Program, v ...interface{}) *Instruction {
3022 if len(v) == 1 {
3023 return p.JLE(v[0])
3024 } else {
3025 panic("instruction JLE takes exactly 1 operand")
3026 }
3027 }
3028
3029 func __asm_proxy_JMP__(p *Program, v ...interface{}) *Instruction {
3030 if len(v) == 1 {
3031 return p.JMP(v[0])
3032 } else {
3033 panic("instruction JMP takes exactly 1 operand")
3034 }
3035 }
3036
3037 func __asm_proxy_JMPQ__(p *Program, v ...interface{}) *Instruction {
3038 if len(v) == 1 {
3039 return p.JMPQ(v[0])
3040 } else {
3041 panic("instruction JMPQ takes exactly 1 operand")
3042 }
3043 }
3044
3045 func __asm_proxy_JNA__(p *Program, v ...interface{}) *Instruction {
3046 if len(v) == 1 {
3047 return p.JNA(v[0])
3048 } else {
3049 panic("instruction JNA takes exactly 1 operand")
3050 }
3051 }
3052
3053 func __asm_proxy_JNAE__(p *Program, v ...interface{}) *Instruction {
3054 if len(v) == 1 {
3055 return p.JNAE(v[0])
3056 } else {
3057 panic("instruction JNAE takes exactly 1 operand")
3058 }
3059 }
3060
3061 func __asm_proxy_JNB__(p *Program, v ...interface{}) *Instruction {
3062 if len(v) == 1 {
3063 return p.JNB(v[0])
3064 } else {
3065 panic("instruction JNB takes exactly 1 operand")
3066 }
3067 }
3068
3069 func __asm_proxy_JNBE__(p *Program, v ...interface{}) *Instruction {
3070 if len(v) == 1 {
3071 return p.JNBE(v[0])
3072 } else {
3073 panic("instruction JNBE takes exactly 1 operand")
3074 }
3075 }
3076
3077 func __asm_proxy_JNC__(p *Program, v ...interface{}) *Instruction {
3078 if len(v) == 1 {
3079 return p.JNC(v[0])
3080 } else {
3081 panic("instruction JNC takes exactly 1 operand")
3082 }
3083 }
3084
3085 func __asm_proxy_JNE__(p *Program, v ...interface{}) *Instruction {
3086 if len(v) == 1 {
3087 return p.JNE(v[0])
3088 } else {
3089 panic("instruction JNE takes exactly 1 operand")
3090 }
3091 }
3092
3093 func __asm_proxy_JNG__(p *Program, v ...interface{}) *Instruction {
3094 if len(v) == 1 {
3095 return p.JNG(v[0])
3096 } else {
3097 panic("instruction JNG takes exactly 1 operand")
3098 }
3099 }
3100
3101 func __asm_proxy_JNGE__(p *Program, v ...interface{}) *Instruction {
3102 if len(v) == 1 {
3103 return p.JNGE(v[0])
3104 } else {
3105 panic("instruction JNGE takes exactly 1 operand")
3106 }
3107 }
3108
3109 func __asm_proxy_JNL__(p *Program, v ...interface{}) *Instruction {
3110 if len(v) == 1 {
3111 return p.JNL(v[0])
3112 } else {
3113 panic("instruction JNL takes exactly 1 operand")
3114 }
3115 }
3116
3117 func __asm_proxy_JNLE__(p *Program, v ...interface{}) *Instruction {
3118 if len(v) == 1 {
3119 return p.JNLE(v[0])
3120 } else {
3121 panic("instruction JNLE takes exactly 1 operand")
3122 }
3123 }
3124
3125 func __asm_proxy_JNO__(p *Program, v ...interface{}) *Instruction {
3126 if len(v) == 1 {
3127 return p.JNO(v[0])
3128 } else {
3129 panic("instruction JNO takes exactly 1 operand")
3130 }
3131 }
3132
3133 func __asm_proxy_JNP__(p *Program, v ...interface{}) *Instruction {
3134 if len(v) == 1 {
3135 return p.JNP(v[0])
3136 } else {
3137 panic("instruction JNP takes exactly 1 operand")
3138 }
3139 }
3140
3141 func __asm_proxy_JNS__(p *Program, v ...interface{}) *Instruction {
3142 if len(v) == 1 {
3143 return p.JNS(v[0])
3144 } else {
3145 panic("instruction JNS takes exactly 1 operand")
3146 }
3147 }
3148
3149 func __asm_proxy_JNZ__(p *Program, v ...interface{}) *Instruction {
3150 if len(v) == 1 {
3151 return p.JNZ(v[0])
3152 } else {
3153 panic("instruction JNZ takes exactly 1 operand")
3154 }
3155 }
3156
3157 func __asm_proxy_JO__(p *Program, v ...interface{}) *Instruction {
3158 if len(v) == 1 {
3159 return p.JO(v[0])
3160 } else {
3161 panic("instruction JO takes exactly 1 operand")
3162 }
3163 }
3164
3165 func __asm_proxy_JP__(p *Program, v ...interface{}) *Instruction {
3166 if len(v) == 1 {
3167 return p.JP(v[0])
3168 } else {
3169 panic("instruction JP takes exactly 1 operand")
3170 }
3171 }
3172
3173 func __asm_proxy_JPE__(p *Program, v ...interface{}) *Instruction {
3174 if len(v) == 1 {
3175 return p.JPE(v[0])
3176 } else {
3177 panic("instruction JPE takes exactly 1 operand")
3178 }
3179 }
3180
3181 func __asm_proxy_JPO__(p *Program, v ...interface{}) *Instruction {
3182 if len(v) == 1 {
3183 return p.JPO(v[0])
3184 } else {
3185 panic("instruction JPO takes exactly 1 operand")
3186 }
3187 }
3188
3189 func __asm_proxy_JRCXZ__(p *Program, v ...interface{}) *Instruction {
3190 if len(v) == 1 {
3191 return p.JRCXZ(v[0])
3192 } else {
3193 panic("instruction JRCXZ takes exactly 1 operand")
3194 }
3195 }
3196
3197 func __asm_proxy_JS__(p *Program, v ...interface{}) *Instruction {
3198 if len(v) == 1 {
3199 return p.JS(v[0])
3200 } else {
3201 panic("instruction JS takes exactly 1 operand")
3202 }
3203 }
3204
3205 func __asm_proxy_JZ__(p *Program, v ...interface{}) *Instruction {
3206 if len(v) == 1 {
3207 return p.JZ(v[0])
3208 } else {
3209 panic("instruction JZ takes exactly 1 operand")
3210 }
3211 }
3212
3213 func __asm_proxy_KADDB__(p *Program, v ...interface{}) *Instruction {
3214 if len(v) == 3 {
3215 return p.KADDB(v[0], v[1], v[2])
3216 } else {
3217 panic("instruction KADDB takes exactly 3 operands")
3218 }
3219 }
3220
3221 func __asm_proxy_KADDD__(p *Program, v ...interface{}) *Instruction {
3222 if len(v) == 3 {
3223 return p.KADDD(v[0], v[1], v[2])
3224 } else {
3225 panic("instruction KADDD takes exactly 3 operands")
3226 }
3227 }
3228
3229 func __asm_proxy_KADDQ__(p *Program, v ...interface{}) *Instruction {
3230 if len(v) == 3 {
3231 return p.KADDQ(v[0], v[1], v[2])
3232 } else {
3233 panic("instruction KADDQ takes exactly 3 operands")
3234 }
3235 }
3236
3237 func __asm_proxy_KADDW__(p *Program, v ...interface{}) *Instruction {
3238 if len(v) == 3 {
3239 return p.KADDW(v[0], v[1], v[2])
3240 } else {
3241 panic("instruction KADDW takes exactly 3 operands")
3242 }
3243 }
3244
3245 func __asm_proxy_KANDB__(p *Program, v ...interface{}) *Instruction {
3246 if len(v) == 3 {
3247 return p.KANDB(v[0], v[1], v[2])
3248 } else {
3249 panic("instruction KANDB takes exactly 3 operands")
3250 }
3251 }
3252
3253 func __asm_proxy_KANDD__(p *Program, v ...interface{}) *Instruction {
3254 if len(v) == 3 {
3255 return p.KANDD(v[0], v[1], v[2])
3256 } else {
3257 panic("instruction KANDD takes exactly 3 operands")
3258 }
3259 }
3260
3261 func __asm_proxy_KANDNB__(p *Program, v ...interface{}) *Instruction {
3262 if len(v) == 3 {
3263 return p.KANDNB(v[0], v[1], v[2])
3264 } else {
3265 panic("instruction KANDNB takes exactly 3 operands")
3266 }
3267 }
3268
3269 func __asm_proxy_KANDND__(p *Program, v ...interface{}) *Instruction {
3270 if len(v) == 3 {
3271 return p.KANDND(v[0], v[1], v[2])
3272 } else {
3273 panic("instruction KANDND takes exactly 3 operands")
3274 }
3275 }
3276
3277 func __asm_proxy_KANDNQ__(p *Program, v ...interface{}) *Instruction {
3278 if len(v) == 3 {
3279 return p.KANDNQ(v[0], v[1], v[2])
3280 } else {
3281 panic("instruction KANDNQ takes exactly 3 operands")
3282 }
3283 }
3284
3285 func __asm_proxy_KANDNW__(p *Program, v ...interface{}) *Instruction {
3286 if len(v) == 3 {
3287 return p.KANDNW(v[0], v[1], v[2])
3288 } else {
3289 panic("instruction KANDNW takes exactly 3 operands")
3290 }
3291 }
3292
3293 func __asm_proxy_KANDQ__(p *Program, v ...interface{}) *Instruction {
3294 if len(v) == 3 {
3295 return p.KANDQ(v[0], v[1], v[2])
3296 } else {
3297 panic("instruction KANDQ takes exactly 3 operands")
3298 }
3299 }
3300
3301 func __asm_proxy_KANDW__(p *Program, v ...interface{}) *Instruction {
3302 if len(v) == 3 {
3303 return p.KANDW(v[0], v[1], v[2])
3304 } else {
3305 panic("instruction KANDW takes exactly 3 operands")
3306 }
3307 }
3308
3309 func __asm_proxy_KMOVB__(p *Program, v ...interface{}) *Instruction {
3310 if len(v) == 2 {
3311 return p.KMOVB(v[0], v[1])
3312 } else {
3313 panic("instruction KMOVB takes exactly 2 operands")
3314 }
3315 }
3316
3317 func __asm_proxy_KMOVD__(p *Program, v ...interface{}) *Instruction {
3318 if len(v) == 2 {
3319 return p.KMOVD(v[0], v[1])
3320 } else {
3321 panic("instruction KMOVD takes exactly 2 operands")
3322 }
3323 }
3324
3325 func __asm_proxy_KMOVQ__(p *Program, v ...interface{}) *Instruction {
3326 if len(v) == 2 {
3327 return p.KMOVQ(v[0], v[1])
3328 } else {
3329 panic("instruction KMOVQ takes exactly 2 operands")
3330 }
3331 }
3332
3333 func __asm_proxy_KMOVW__(p *Program, v ...interface{}) *Instruction {
3334 if len(v) == 2 {
3335 return p.KMOVW(v[0], v[1])
3336 } else {
3337 panic("instruction KMOVW takes exactly 2 operands")
3338 }
3339 }
3340
3341 func __asm_proxy_KNOTB__(p *Program, v ...interface{}) *Instruction {
3342 if len(v) == 2 {
3343 return p.KNOTB(v[0], v[1])
3344 } else {
3345 panic("instruction KNOTB takes exactly 2 operands")
3346 }
3347 }
3348
3349 func __asm_proxy_KNOTD__(p *Program, v ...interface{}) *Instruction {
3350 if len(v) == 2 {
3351 return p.KNOTD(v[0], v[1])
3352 } else {
3353 panic("instruction KNOTD takes exactly 2 operands")
3354 }
3355 }
3356
3357 func __asm_proxy_KNOTQ__(p *Program, v ...interface{}) *Instruction {
3358 if len(v) == 2 {
3359 return p.KNOTQ(v[0], v[1])
3360 } else {
3361 panic("instruction KNOTQ takes exactly 2 operands")
3362 }
3363 }
3364
3365 func __asm_proxy_KNOTW__(p *Program, v ...interface{}) *Instruction {
3366 if len(v) == 2 {
3367 return p.KNOTW(v[0], v[1])
3368 } else {
3369 panic("instruction KNOTW takes exactly 2 operands")
3370 }
3371 }
3372
3373 func __asm_proxy_KORB__(p *Program, v ...interface{}) *Instruction {
3374 if len(v) == 3 {
3375 return p.KORB(v[0], v[1], v[2])
3376 } else {
3377 panic("instruction KORB takes exactly 3 operands")
3378 }
3379 }
3380
3381 func __asm_proxy_KORD__(p *Program, v ...interface{}) *Instruction {
3382 if len(v) == 3 {
3383 return p.KORD(v[0], v[1], v[2])
3384 } else {
3385 panic("instruction KORD takes exactly 3 operands")
3386 }
3387 }
3388
3389 func __asm_proxy_KORQ__(p *Program, v ...interface{}) *Instruction {
3390 if len(v) == 3 {
3391 return p.KORQ(v[0], v[1], v[2])
3392 } else {
3393 panic("instruction KORQ takes exactly 3 operands")
3394 }
3395 }
3396
3397 func __asm_proxy_KORTESTB__(p *Program, v ...interface{}) *Instruction {
3398 if len(v) == 2 {
3399 return p.KORTESTB(v[0], v[1])
3400 } else {
3401 panic("instruction KORTESTB takes exactly 2 operands")
3402 }
3403 }
3404
3405 func __asm_proxy_KORTESTD__(p *Program, v ...interface{}) *Instruction {
3406 if len(v) == 2 {
3407 return p.KORTESTD(v[0], v[1])
3408 } else {
3409 panic("instruction KORTESTD takes exactly 2 operands")
3410 }
3411 }
3412
3413 func __asm_proxy_KORTESTQ__(p *Program, v ...interface{}) *Instruction {
3414 if len(v) == 2 {
3415 return p.KORTESTQ(v[0], v[1])
3416 } else {
3417 panic("instruction KORTESTQ takes exactly 2 operands")
3418 }
3419 }
3420
3421 func __asm_proxy_KORTESTW__(p *Program, v ...interface{}) *Instruction {
3422 if len(v) == 2 {
3423 return p.KORTESTW(v[0], v[1])
3424 } else {
3425 panic("instruction KORTESTW takes exactly 2 operands")
3426 }
3427 }
3428
3429 func __asm_proxy_KORW__(p *Program, v ...interface{}) *Instruction {
3430 if len(v) == 3 {
3431 return p.KORW(v[0], v[1], v[2])
3432 } else {
3433 panic("instruction KORW takes exactly 3 operands")
3434 }
3435 }
3436
3437 func __asm_proxy_KSHIFTLB__(p *Program, v ...interface{}) *Instruction {
3438 if len(v) == 3 {
3439 return p.KSHIFTLB(v[0], v[1], v[2])
3440 } else {
3441 panic("instruction KSHIFTLB takes exactly 3 operands")
3442 }
3443 }
3444
3445 func __asm_proxy_KSHIFTLD__(p *Program, v ...interface{}) *Instruction {
3446 if len(v) == 3 {
3447 return p.KSHIFTLD(v[0], v[1], v[2])
3448 } else {
3449 panic("instruction KSHIFTLD takes exactly 3 operands")
3450 }
3451 }
3452
3453 func __asm_proxy_KSHIFTLQ__(p *Program, v ...interface{}) *Instruction {
3454 if len(v) == 3 {
3455 return p.KSHIFTLQ(v[0], v[1], v[2])
3456 } else {
3457 panic("instruction KSHIFTLQ takes exactly 3 operands")
3458 }
3459 }
3460
3461 func __asm_proxy_KSHIFTLW__(p *Program, v ...interface{}) *Instruction {
3462 if len(v) == 3 {
3463 return p.KSHIFTLW(v[0], v[1], v[2])
3464 } else {
3465 panic("instruction KSHIFTLW takes exactly 3 operands")
3466 }
3467 }
3468
3469 func __asm_proxy_KSHIFTRB__(p *Program, v ...interface{}) *Instruction {
3470 if len(v) == 3 {
3471 return p.KSHIFTRB(v[0], v[1], v[2])
3472 } else {
3473 panic("instruction KSHIFTRB takes exactly 3 operands")
3474 }
3475 }
3476
3477 func __asm_proxy_KSHIFTRD__(p *Program, v ...interface{}) *Instruction {
3478 if len(v) == 3 {
3479 return p.KSHIFTRD(v[0], v[1], v[2])
3480 } else {
3481 panic("instruction KSHIFTRD takes exactly 3 operands")
3482 }
3483 }
3484
3485 func __asm_proxy_KSHIFTRQ__(p *Program, v ...interface{}) *Instruction {
3486 if len(v) == 3 {
3487 return p.KSHIFTRQ(v[0], v[1], v[2])
3488 } else {
3489 panic("instruction KSHIFTRQ takes exactly 3 operands")
3490 }
3491 }
3492
3493 func __asm_proxy_KSHIFTRW__(p *Program, v ...interface{}) *Instruction {
3494 if len(v) == 3 {
3495 return p.KSHIFTRW(v[0], v[1], v[2])
3496 } else {
3497 panic("instruction KSHIFTRW takes exactly 3 operands")
3498 }
3499 }
3500
3501 func __asm_proxy_KTESTB__(p *Program, v ...interface{}) *Instruction {
3502 if len(v) == 2 {
3503 return p.KTESTB(v[0], v[1])
3504 } else {
3505 panic("instruction KTESTB takes exactly 2 operands")
3506 }
3507 }
3508
3509 func __asm_proxy_KTESTD__(p *Program, v ...interface{}) *Instruction {
3510 if len(v) == 2 {
3511 return p.KTESTD(v[0], v[1])
3512 } else {
3513 panic("instruction KTESTD takes exactly 2 operands")
3514 }
3515 }
3516
3517 func __asm_proxy_KTESTQ__(p *Program, v ...interface{}) *Instruction {
3518 if len(v) == 2 {
3519 return p.KTESTQ(v[0], v[1])
3520 } else {
3521 panic("instruction KTESTQ takes exactly 2 operands")
3522 }
3523 }
3524
3525 func __asm_proxy_KTESTW__(p *Program, v ...interface{}) *Instruction {
3526 if len(v) == 2 {
3527 return p.KTESTW(v[0], v[1])
3528 } else {
3529 panic("instruction KTESTW takes exactly 2 operands")
3530 }
3531 }
3532
3533 func __asm_proxy_KUNPCKBW__(p *Program, v ...interface{}) *Instruction {
3534 if len(v) == 3 {
3535 return p.KUNPCKBW(v[0], v[1], v[2])
3536 } else {
3537 panic("instruction KUNPCKBW takes exactly 3 operands")
3538 }
3539 }
3540
3541 func __asm_proxy_KUNPCKDQ__(p *Program, v ...interface{}) *Instruction {
3542 if len(v) == 3 {
3543 return p.KUNPCKDQ(v[0], v[1], v[2])
3544 } else {
3545 panic("instruction KUNPCKDQ takes exactly 3 operands")
3546 }
3547 }
3548
3549 func __asm_proxy_KUNPCKWD__(p *Program, v ...interface{}) *Instruction {
3550 if len(v) == 3 {
3551 return p.KUNPCKWD(v[0], v[1], v[2])
3552 } else {
3553 panic("instruction KUNPCKWD takes exactly 3 operands")
3554 }
3555 }
3556
3557 func __asm_proxy_KXNORB__(p *Program, v ...interface{}) *Instruction {
3558 if len(v) == 3 {
3559 return p.KXNORB(v[0], v[1], v[2])
3560 } else {
3561 panic("instruction KXNORB takes exactly 3 operands")
3562 }
3563 }
3564
3565 func __asm_proxy_KXNORD__(p *Program, v ...interface{}) *Instruction {
3566 if len(v) == 3 {
3567 return p.KXNORD(v[0], v[1], v[2])
3568 } else {
3569 panic("instruction KXNORD takes exactly 3 operands")
3570 }
3571 }
3572
3573 func __asm_proxy_KXNORQ__(p *Program, v ...interface{}) *Instruction {
3574 if len(v) == 3 {
3575 return p.KXNORQ(v[0], v[1], v[2])
3576 } else {
3577 panic("instruction KXNORQ takes exactly 3 operands")
3578 }
3579 }
3580
3581 func __asm_proxy_KXNORW__(p *Program, v ...interface{}) *Instruction {
3582 if len(v) == 3 {
3583 return p.KXNORW(v[0], v[1], v[2])
3584 } else {
3585 panic("instruction KXNORW takes exactly 3 operands")
3586 }
3587 }
3588
3589 func __asm_proxy_KXORB__(p *Program, v ...interface{}) *Instruction {
3590 if len(v) == 3 {
3591 return p.KXORB(v[0], v[1], v[2])
3592 } else {
3593 panic("instruction KXORB takes exactly 3 operands")
3594 }
3595 }
3596
3597 func __asm_proxy_KXORD__(p *Program, v ...interface{}) *Instruction {
3598 if len(v) == 3 {
3599 return p.KXORD(v[0], v[1], v[2])
3600 } else {
3601 panic("instruction KXORD takes exactly 3 operands")
3602 }
3603 }
3604
3605 func __asm_proxy_KXORQ__(p *Program, v ...interface{}) *Instruction {
3606 if len(v) == 3 {
3607 return p.KXORQ(v[0], v[1], v[2])
3608 } else {
3609 panic("instruction KXORQ takes exactly 3 operands")
3610 }
3611 }
3612
3613 func __asm_proxy_KXORW__(p *Program, v ...interface{}) *Instruction {
3614 if len(v) == 3 {
3615 return p.KXORW(v[0], v[1], v[2])
3616 } else {
3617 panic("instruction KXORW takes exactly 3 operands")
3618 }
3619 }
3620
3621 func __asm_proxy_LDDQU__(p *Program, v ...interface{}) *Instruction {
3622 if len(v) == 2 {
3623 return p.LDDQU(v[0], v[1])
3624 } else {
3625 panic("instruction LDDQU takes exactly 2 operands")
3626 }
3627 }
3628
3629 func __asm_proxy_LDMXCSR__(p *Program, v ...interface{}) *Instruction {
3630 if len(v) == 1 {
3631 return p.LDMXCSR(v[0])
3632 } else {
3633 panic("instruction LDMXCSR takes exactly 1 operand")
3634 }
3635 }
3636
3637 func __asm_proxy_LEAL__(p *Program, v ...interface{}) *Instruction {
3638 if len(v) == 2 {
3639 return p.LEAL(v[0], v[1])
3640 } else {
3641 panic("instruction LEAL takes exactly 2 operands")
3642 }
3643 }
3644
3645 func __asm_proxy_LEAQ__(p *Program, v ...interface{}) *Instruction {
3646 if len(v) == 2 {
3647 return p.LEAQ(v[0], v[1])
3648 } else {
3649 panic("instruction LEAQ takes exactly 2 operands")
3650 }
3651 }
3652
3653 func __asm_proxy_LEAW__(p *Program, v ...interface{}) *Instruction {
3654 if len(v) == 2 {
3655 return p.LEAW(v[0], v[1])
3656 } else {
3657 panic("instruction LEAW takes exactly 2 operands")
3658 }
3659 }
3660
3661 func __asm_proxy_LFENCE__(p *Program, v ...interface{}) *Instruction {
3662 if len(v) == 0 {
3663 return p.LFENCE()
3664 } else {
3665 panic("instruction LFENCE takes no operands")
3666 }
3667 }
3668
3669 func __asm_proxy_LZCNTL__(p *Program, v ...interface{}) *Instruction {
3670 if len(v) == 2 {
3671 return p.LZCNTL(v[0], v[1])
3672 } else {
3673 panic("instruction LZCNTL takes exactly 2 operands")
3674 }
3675 }
3676
3677 func __asm_proxy_LZCNTQ__(p *Program, v ...interface{}) *Instruction {
3678 if len(v) == 2 {
3679 return p.LZCNTQ(v[0], v[1])
3680 } else {
3681 panic("instruction LZCNTQ takes exactly 2 operands")
3682 }
3683 }
3684
3685 func __asm_proxy_LZCNTW__(p *Program, v ...interface{}) *Instruction {
3686 if len(v) == 2 {
3687 return p.LZCNTW(v[0], v[1])
3688 } else {
3689 panic("instruction LZCNTW takes exactly 2 operands")
3690 }
3691 }
3692
3693 func __asm_proxy_MASKMOVDQU__(p *Program, v ...interface{}) *Instruction {
3694 if len(v) == 2 {
3695 return p.MASKMOVDQU(v[0], v[1])
3696 } else {
3697 panic("instruction MASKMOVDQU takes exactly 2 operands")
3698 }
3699 }
3700
3701 func __asm_proxy_MASKMOVQ__(p *Program, v ...interface{}) *Instruction {
3702 if len(v) == 2 {
3703 return p.MASKMOVQ(v[0], v[1])
3704 } else {
3705 panic("instruction MASKMOVQ takes exactly 2 operands")
3706 }
3707 }
3708
3709 func __asm_proxy_MAXPD__(p *Program, v ...interface{}) *Instruction {
3710 if len(v) == 2 {
3711 return p.MAXPD(v[0], v[1])
3712 } else {
3713 panic("instruction MAXPD takes exactly 2 operands")
3714 }
3715 }
3716
3717 func __asm_proxy_MAXPS__(p *Program, v ...interface{}) *Instruction {
3718 if len(v) == 2 {
3719 return p.MAXPS(v[0], v[1])
3720 } else {
3721 panic("instruction MAXPS takes exactly 2 operands")
3722 }
3723 }
3724
3725 func __asm_proxy_MAXSD__(p *Program, v ...interface{}) *Instruction {
3726 if len(v) == 2 {
3727 return p.MAXSD(v[0], v[1])
3728 } else {
3729 panic("instruction MAXSD takes exactly 2 operands")
3730 }
3731 }
3732
3733 func __asm_proxy_MAXSS__(p *Program, v ...interface{}) *Instruction {
3734 if len(v) == 2 {
3735 return p.MAXSS(v[0], v[1])
3736 } else {
3737 panic("instruction MAXSS takes exactly 2 operands")
3738 }
3739 }
3740
3741 func __asm_proxy_MFENCE__(p *Program, v ...interface{}) *Instruction {
3742 if len(v) == 0 {
3743 return p.MFENCE()
3744 } else {
3745 panic("instruction MFENCE takes no operands")
3746 }
3747 }
3748
3749 func __asm_proxy_MINPD__(p *Program, v ...interface{}) *Instruction {
3750 if len(v) == 2 {
3751 return p.MINPD(v[0], v[1])
3752 } else {
3753 panic("instruction MINPD takes exactly 2 operands")
3754 }
3755 }
3756
3757 func __asm_proxy_MINPS__(p *Program, v ...interface{}) *Instruction {
3758 if len(v) == 2 {
3759 return p.MINPS(v[0], v[1])
3760 } else {
3761 panic("instruction MINPS takes exactly 2 operands")
3762 }
3763 }
3764
3765 func __asm_proxy_MINSD__(p *Program, v ...interface{}) *Instruction {
3766 if len(v) == 2 {
3767 return p.MINSD(v[0], v[1])
3768 } else {
3769 panic("instruction MINSD takes exactly 2 operands")
3770 }
3771 }
3772
3773 func __asm_proxy_MINSS__(p *Program, v ...interface{}) *Instruction {
3774 if len(v) == 2 {
3775 return p.MINSS(v[0], v[1])
3776 } else {
3777 panic("instruction MINSS takes exactly 2 operands")
3778 }
3779 }
3780
3781 func __asm_proxy_MONITOR__(p *Program, v ...interface{}) *Instruction {
3782 if len(v) == 0 {
3783 return p.MONITOR()
3784 } else {
3785 panic("instruction MONITOR takes no operands")
3786 }
3787 }
3788
3789 func __asm_proxy_MONITORX__(p *Program, v ...interface{}) *Instruction {
3790 if len(v) == 0 {
3791 return p.MONITORX()
3792 } else {
3793 panic("instruction MONITORX takes no operands")
3794 }
3795 }
3796
3797 func __asm_proxy_MOVAPD__(p *Program, v ...interface{}) *Instruction {
3798 if len(v) == 2 {
3799 return p.MOVAPD(v[0], v[1])
3800 } else {
3801 panic("instruction MOVAPD takes exactly 2 operands")
3802 }
3803 }
3804
3805 func __asm_proxy_MOVAPS__(p *Program, v ...interface{}) *Instruction {
3806 if len(v) == 2 {
3807 return p.MOVAPS(v[0], v[1])
3808 } else {
3809 panic("instruction MOVAPS takes exactly 2 operands")
3810 }
3811 }
3812
3813 func __asm_proxy_MOVB__(p *Program, v ...interface{}) *Instruction {
3814 if len(v) == 2 {
3815 return p.MOVB(v[0], v[1])
3816 } else {
3817 panic("instruction MOVB takes exactly 2 operands")
3818 }
3819 }
3820
3821 func __asm_proxy_MOVBEL__(p *Program, v ...interface{}) *Instruction {
3822 if len(v) == 2 {
3823 return p.MOVBEL(v[0], v[1])
3824 } else {
3825 panic("instruction MOVBEL takes exactly 2 operands")
3826 }
3827 }
3828
3829 func __asm_proxy_MOVBEQ__(p *Program, v ...interface{}) *Instruction {
3830 if len(v) == 2 {
3831 return p.MOVBEQ(v[0], v[1])
3832 } else {
3833 panic("instruction MOVBEQ takes exactly 2 operands")
3834 }
3835 }
3836
3837 func __asm_proxy_MOVBEW__(p *Program, v ...interface{}) *Instruction {
3838 if len(v) == 2 {
3839 return p.MOVBEW(v[0], v[1])
3840 } else {
3841 panic("instruction MOVBEW takes exactly 2 operands")
3842 }
3843 }
3844
3845 func __asm_proxy_MOVD__(p *Program, v ...interface{}) *Instruction {
3846 if len(v) == 2 {
3847 return p.MOVD(v[0], v[1])
3848 } else {
3849 panic("instruction MOVD takes exactly 2 operands")
3850 }
3851 }
3852
3853 func __asm_proxy_MOVDDUP__(p *Program, v ...interface{}) *Instruction {
3854 if len(v) == 2 {
3855 return p.MOVDDUP(v[0], v[1])
3856 } else {
3857 panic("instruction MOVDDUP takes exactly 2 operands")
3858 }
3859 }
3860
3861 func __asm_proxy_MOVDQ2Q__(p *Program, v ...interface{}) *Instruction {
3862 if len(v) == 2 {
3863 return p.MOVDQ2Q(v[0], v[1])
3864 } else {
3865 panic("instruction MOVDQ2Q takes exactly 2 operands")
3866 }
3867 }
3868
3869 func __asm_proxy_MOVDQA__(p *Program, v ...interface{}) *Instruction {
3870 if len(v) == 2 {
3871 return p.MOVDQA(v[0], v[1])
3872 } else {
3873 panic("instruction MOVDQA takes exactly 2 operands")
3874 }
3875 }
3876
3877 func __asm_proxy_MOVDQU__(p *Program, v ...interface{}) *Instruction {
3878 if len(v) == 2 {
3879 return p.MOVDQU(v[0], v[1])
3880 } else {
3881 panic("instruction MOVDQU takes exactly 2 operands")
3882 }
3883 }
3884
3885 func __asm_proxy_MOVHLPS__(p *Program, v ...interface{}) *Instruction {
3886 if len(v) == 2 {
3887 return p.MOVHLPS(v[0], v[1])
3888 } else {
3889 panic("instruction MOVHLPS takes exactly 2 operands")
3890 }
3891 }
3892
3893 func __asm_proxy_MOVHPD__(p *Program, v ...interface{}) *Instruction {
3894 if len(v) == 2 {
3895 return p.MOVHPD(v[0], v[1])
3896 } else {
3897 panic("instruction MOVHPD takes exactly 2 operands")
3898 }
3899 }
3900
3901 func __asm_proxy_MOVHPS__(p *Program, v ...interface{}) *Instruction {
3902 if len(v) == 2 {
3903 return p.MOVHPS(v[0], v[1])
3904 } else {
3905 panic("instruction MOVHPS takes exactly 2 operands")
3906 }
3907 }
3908
3909 func __asm_proxy_MOVL__(p *Program, v ...interface{}) *Instruction {
3910 if len(v) == 2 {
3911 return p.MOVL(v[0], v[1])
3912 } else {
3913 panic("instruction MOVL takes exactly 2 operands")
3914 }
3915 }
3916
3917 func __asm_proxy_MOVLHPS__(p *Program, v ...interface{}) *Instruction {
3918 if len(v) == 2 {
3919 return p.MOVLHPS(v[0], v[1])
3920 } else {
3921 panic("instruction MOVLHPS takes exactly 2 operands")
3922 }
3923 }
3924
3925 func __asm_proxy_MOVLPD__(p *Program, v ...interface{}) *Instruction {
3926 if len(v) == 2 {
3927 return p.MOVLPD(v[0], v[1])
3928 } else {
3929 panic("instruction MOVLPD takes exactly 2 operands")
3930 }
3931 }
3932
3933 func __asm_proxy_MOVLPS__(p *Program, v ...interface{}) *Instruction {
3934 if len(v) == 2 {
3935 return p.MOVLPS(v[0], v[1])
3936 } else {
3937 panic("instruction MOVLPS takes exactly 2 operands")
3938 }
3939 }
3940
3941 func __asm_proxy_MOVMSKPD__(p *Program, v ...interface{}) *Instruction {
3942 if len(v) == 2 {
3943 return p.MOVMSKPD(v[0], v[1])
3944 } else {
3945 panic("instruction MOVMSKPD takes exactly 2 operands")
3946 }
3947 }
3948
3949 func __asm_proxy_MOVMSKPS__(p *Program, v ...interface{}) *Instruction {
3950 if len(v) == 2 {
3951 return p.MOVMSKPS(v[0], v[1])
3952 } else {
3953 panic("instruction MOVMSKPS takes exactly 2 operands")
3954 }
3955 }
3956
3957 func __asm_proxy_MOVNTDQ__(p *Program, v ...interface{}) *Instruction {
3958 if len(v) == 2 {
3959 return p.MOVNTDQ(v[0], v[1])
3960 } else {
3961 panic("instruction MOVNTDQ takes exactly 2 operands")
3962 }
3963 }
3964
3965 func __asm_proxy_MOVNTDQA__(p *Program, v ...interface{}) *Instruction {
3966 if len(v) == 2 {
3967 return p.MOVNTDQA(v[0], v[1])
3968 } else {
3969 panic("instruction MOVNTDQA takes exactly 2 operands")
3970 }
3971 }
3972
3973 func __asm_proxy_MOVNTIL__(p *Program, v ...interface{}) *Instruction {
3974 if len(v) == 2 {
3975 return p.MOVNTIL(v[0], v[1])
3976 } else {
3977 panic("instruction MOVNTIL takes exactly 2 operands")
3978 }
3979 }
3980
3981 func __asm_proxy_MOVNTIQ__(p *Program, v ...interface{}) *Instruction {
3982 if len(v) == 2 {
3983 return p.MOVNTIQ(v[0], v[1])
3984 } else {
3985 panic("instruction MOVNTIQ takes exactly 2 operands")
3986 }
3987 }
3988
3989 func __asm_proxy_MOVNTPD__(p *Program, v ...interface{}) *Instruction {
3990 if len(v) == 2 {
3991 return p.MOVNTPD(v[0], v[1])
3992 } else {
3993 panic("instruction MOVNTPD takes exactly 2 operands")
3994 }
3995 }
3996
3997 func __asm_proxy_MOVNTPS__(p *Program, v ...interface{}) *Instruction {
3998 if len(v) == 2 {
3999 return p.MOVNTPS(v[0], v[1])
4000 } else {
4001 panic("instruction MOVNTPS takes exactly 2 operands")
4002 }
4003 }
4004
4005 func __asm_proxy_MOVNTQ__(p *Program, v ...interface{}) *Instruction {
4006 if len(v) == 2 {
4007 return p.MOVNTQ(v[0], v[1])
4008 } else {
4009 panic("instruction MOVNTQ takes exactly 2 operands")
4010 }
4011 }
4012
4013 func __asm_proxy_MOVNTSD__(p *Program, v ...interface{}) *Instruction {
4014 if len(v) == 2 {
4015 return p.MOVNTSD(v[0], v[1])
4016 } else {
4017 panic("instruction MOVNTSD takes exactly 2 operands")
4018 }
4019 }
4020
4021 func __asm_proxy_MOVNTSS__(p *Program, v ...interface{}) *Instruction {
4022 if len(v) == 2 {
4023 return p.MOVNTSS(v[0], v[1])
4024 } else {
4025 panic("instruction MOVNTSS takes exactly 2 operands")
4026 }
4027 }
4028
4029 func __asm_proxy_MOVQ__(p *Program, v ...interface{}) *Instruction {
4030 if len(v) == 2 {
4031 return p.MOVQ(v[0], v[1])
4032 } else {
4033 panic("instruction MOVQ takes exactly 2 operands")
4034 }
4035 }
4036
4037 func __asm_proxy_MOVQ2DQ__(p *Program, v ...interface{}) *Instruction {
4038 if len(v) == 2 {
4039 return p.MOVQ2DQ(v[0], v[1])
4040 } else {
4041 panic("instruction MOVQ2DQ takes exactly 2 operands")
4042 }
4043 }
4044
4045 func __asm_proxy_MOVSBL__(p *Program, v ...interface{}) *Instruction {
4046 if len(v) == 2 {
4047 return p.MOVSBL(v[0], v[1])
4048 } else {
4049 panic("instruction MOVSBL takes exactly 2 operands")
4050 }
4051 }
4052
4053 func __asm_proxy_MOVSBQ__(p *Program, v ...interface{}) *Instruction {
4054 if len(v) == 2 {
4055 return p.MOVSBQ(v[0], v[1])
4056 } else {
4057 panic("instruction MOVSBQ takes exactly 2 operands")
4058 }
4059 }
4060
4061 func __asm_proxy_MOVSBW__(p *Program, v ...interface{}) *Instruction {
4062 if len(v) == 2 {
4063 return p.MOVSBW(v[0], v[1])
4064 } else {
4065 panic("instruction MOVSBW takes exactly 2 operands")
4066 }
4067 }
4068
4069 func __asm_proxy_MOVSD__(p *Program, v ...interface{}) *Instruction {
4070 if len(v) == 2 {
4071 return p.MOVSD(v[0], v[1])
4072 } else {
4073 panic("instruction MOVSD takes exactly 2 operands")
4074 }
4075 }
4076
4077 func __asm_proxy_MOVSHDUP__(p *Program, v ...interface{}) *Instruction {
4078 if len(v) == 2 {
4079 return p.MOVSHDUP(v[0], v[1])
4080 } else {
4081 panic("instruction MOVSHDUP takes exactly 2 operands")
4082 }
4083 }
4084
4085 func __asm_proxy_MOVSLDUP__(p *Program, v ...interface{}) *Instruction {
4086 if len(v) == 2 {
4087 return p.MOVSLDUP(v[0], v[1])
4088 } else {
4089 panic("instruction MOVSLDUP takes exactly 2 operands")
4090 }
4091 }
4092
4093 func __asm_proxy_MOVSLQ__(p *Program, v ...interface{}) *Instruction {
4094 if len(v) == 2 {
4095 return p.MOVSLQ(v[0], v[1])
4096 } else {
4097 panic("instruction MOVSLQ takes exactly 2 operands")
4098 }
4099 }
4100
4101 func __asm_proxy_MOVSS__(p *Program, v ...interface{}) *Instruction {
4102 if len(v) == 2 {
4103 return p.MOVSS(v[0], v[1])
4104 } else {
4105 panic("instruction MOVSS takes exactly 2 operands")
4106 }
4107 }
4108
4109 func __asm_proxy_MOVSWL__(p *Program, v ...interface{}) *Instruction {
4110 if len(v) == 2 {
4111 return p.MOVSWL(v[0], v[1])
4112 } else {
4113 panic("instruction MOVSWL takes exactly 2 operands")
4114 }
4115 }
4116
4117 func __asm_proxy_MOVSWQ__(p *Program, v ...interface{}) *Instruction {
4118 if len(v) == 2 {
4119 return p.MOVSWQ(v[0], v[1])
4120 } else {
4121 panic("instruction MOVSWQ takes exactly 2 operands")
4122 }
4123 }
4124
4125 func __asm_proxy_MOVUPD__(p *Program, v ...interface{}) *Instruction {
4126 if len(v) == 2 {
4127 return p.MOVUPD(v[0], v[1])
4128 } else {
4129 panic("instruction MOVUPD takes exactly 2 operands")
4130 }
4131 }
4132
4133 func __asm_proxy_MOVUPS__(p *Program, v ...interface{}) *Instruction {
4134 if len(v) == 2 {
4135 return p.MOVUPS(v[0], v[1])
4136 } else {
4137 panic("instruction MOVUPS takes exactly 2 operands")
4138 }
4139 }
4140
4141 func __asm_proxy_MOVW__(p *Program, v ...interface{}) *Instruction {
4142 if len(v) == 2 {
4143 return p.MOVW(v[0], v[1])
4144 } else {
4145 panic("instruction MOVW takes exactly 2 operands")
4146 }
4147 }
4148
4149 func __asm_proxy_MOVZBL__(p *Program, v ...interface{}) *Instruction {
4150 if len(v) == 2 {
4151 return p.MOVZBL(v[0], v[1])
4152 } else {
4153 panic("instruction MOVZBL takes exactly 2 operands")
4154 }
4155 }
4156
4157 func __asm_proxy_MOVZBQ__(p *Program, v ...interface{}) *Instruction {
4158 if len(v) == 2 {
4159 return p.MOVZBQ(v[0], v[1])
4160 } else {
4161 panic("instruction MOVZBQ takes exactly 2 operands")
4162 }
4163 }
4164
4165 func __asm_proxy_MOVZBW__(p *Program, v ...interface{}) *Instruction {
4166 if len(v) == 2 {
4167 return p.MOVZBW(v[0], v[1])
4168 } else {
4169 panic("instruction MOVZBW takes exactly 2 operands")
4170 }
4171 }
4172
4173 func __asm_proxy_MOVZWL__(p *Program, v ...interface{}) *Instruction {
4174 if len(v) == 2 {
4175 return p.MOVZWL(v[0], v[1])
4176 } else {
4177 panic("instruction MOVZWL takes exactly 2 operands")
4178 }
4179 }
4180
4181 func __asm_proxy_MOVZWQ__(p *Program, v ...interface{}) *Instruction {
4182 if len(v) == 2 {
4183 return p.MOVZWQ(v[0], v[1])
4184 } else {
4185 panic("instruction MOVZWQ takes exactly 2 operands")
4186 }
4187 }
4188
4189 func __asm_proxy_MPSADBW__(p *Program, v ...interface{}) *Instruction {
4190 if len(v) == 3 {
4191 return p.MPSADBW(v[0], v[1], v[2])
4192 } else {
4193 panic("instruction MPSADBW takes exactly 3 operands")
4194 }
4195 }
4196
4197 func __asm_proxy_MULB__(p *Program, v ...interface{}) *Instruction {
4198 if len(v) == 1 {
4199 return p.MULB(v[0])
4200 } else {
4201 panic("instruction MULB takes exactly 1 operand")
4202 }
4203 }
4204
4205 func __asm_proxy_MULL__(p *Program, v ...interface{}) *Instruction {
4206 if len(v) == 1 {
4207 return p.MULL(v[0])
4208 } else {
4209 panic("instruction MULL takes exactly 1 operand")
4210 }
4211 }
4212
4213 func __asm_proxy_MULPD__(p *Program, v ...interface{}) *Instruction {
4214 if len(v) == 2 {
4215 return p.MULPD(v[0], v[1])
4216 } else {
4217 panic("instruction MULPD takes exactly 2 operands")
4218 }
4219 }
4220
4221 func __asm_proxy_MULPS__(p *Program, v ...interface{}) *Instruction {
4222 if len(v) == 2 {
4223 return p.MULPS(v[0], v[1])
4224 } else {
4225 panic("instruction MULPS takes exactly 2 operands")
4226 }
4227 }
4228
4229 func __asm_proxy_MULQ__(p *Program, v ...interface{}) *Instruction {
4230 if len(v) == 1 {
4231 return p.MULQ(v[0])
4232 } else {
4233 panic("instruction MULQ takes exactly 1 operand")
4234 }
4235 }
4236
4237 func __asm_proxy_MULSD__(p *Program, v ...interface{}) *Instruction {
4238 if len(v) == 2 {
4239 return p.MULSD(v[0], v[1])
4240 } else {
4241 panic("instruction MULSD takes exactly 2 operands")
4242 }
4243 }
4244
4245 func __asm_proxy_MULSS__(p *Program, v ...interface{}) *Instruction {
4246 if len(v) == 2 {
4247 return p.MULSS(v[0], v[1])
4248 } else {
4249 panic("instruction MULSS takes exactly 2 operands")
4250 }
4251 }
4252
4253 func __asm_proxy_MULW__(p *Program, v ...interface{}) *Instruction {
4254 if len(v) == 1 {
4255 return p.MULW(v[0])
4256 } else {
4257 panic("instruction MULW takes exactly 1 operand")
4258 }
4259 }
4260
4261 func __asm_proxy_MULXL__(p *Program, v ...interface{}) *Instruction {
4262 if len(v) == 3 {
4263 return p.MULXL(v[0], v[1], v[2])
4264 } else {
4265 panic("instruction MULXL takes exactly 3 operands")
4266 }
4267 }
4268
4269 func __asm_proxy_MULXQ__(p *Program, v ...interface{}) *Instruction {
4270 if len(v) == 3 {
4271 return p.MULXQ(v[0], v[1], v[2])
4272 } else {
4273 panic("instruction MULXQ takes exactly 3 operands")
4274 }
4275 }
4276
4277 func __asm_proxy_MWAIT__(p *Program, v ...interface{}) *Instruction {
4278 if len(v) == 0 {
4279 return p.MWAIT()
4280 } else {
4281 panic("instruction MWAIT takes no operands")
4282 }
4283 }
4284
4285 func __asm_proxy_MWAITX__(p *Program, v ...interface{}) *Instruction {
4286 if len(v) == 0 {
4287 return p.MWAITX()
4288 } else {
4289 panic("instruction MWAITX takes no operands")
4290 }
4291 }
4292
4293 func __asm_proxy_NEGB__(p *Program, v ...interface{}) *Instruction {
4294 if len(v) == 1 {
4295 return p.NEGB(v[0])
4296 } else {
4297 panic("instruction NEGB takes exactly 1 operand")
4298 }
4299 }
4300
4301 func __asm_proxy_NEGL__(p *Program, v ...interface{}) *Instruction {
4302 if len(v) == 1 {
4303 return p.NEGL(v[0])
4304 } else {
4305 panic("instruction NEGL takes exactly 1 operand")
4306 }
4307 }
4308
4309 func __asm_proxy_NEGQ__(p *Program, v ...interface{}) *Instruction {
4310 if len(v) == 1 {
4311 return p.NEGQ(v[0])
4312 } else {
4313 panic("instruction NEGQ takes exactly 1 operand")
4314 }
4315 }
4316
4317 func __asm_proxy_NEGW__(p *Program, v ...interface{}) *Instruction {
4318 if len(v) == 1 {
4319 return p.NEGW(v[0])
4320 } else {
4321 panic("instruction NEGW takes exactly 1 operand")
4322 }
4323 }
4324
4325 func __asm_proxy_NOP__(p *Program, v ...interface{}) *Instruction {
4326 if len(v) == 0 {
4327 return p.NOP()
4328 } else {
4329 panic("instruction NOP takes no operands")
4330 }
4331 }
4332
4333 func __asm_proxy_NOTB__(p *Program, v ...interface{}) *Instruction {
4334 if len(v) == 1 {
4335 return p.NOTB(v[0])
4336 } else {
4337 panic("instruction NOTB takes exactly 1 operand")
4338 }
4339 }
4340
4341 func __asm_proxy_NOTL__(p *Program, v ...interface{}) *Instruction {
4342 if len(v) == 1 {
4343 return p.NOTL(v[0])
4344 } else {
4345 panic("instruction NOTL takes exactly 1 operand")
4346 }
4347 }
4348
4349 func __asm_proxy_NOTQ__(p *Program, v ...interface{}) *Instruction {
4350 if len(v) == 1 {
4351 return p.NOTQ(v[0])
4352 } else {
4353 panic("instruction NOTQ takes exactly 1 operand")
4354 }
4355 }
4356
4357 func __asm_proxy_NOTW__(p *Program, v ...interface{}) *Instruction {
4358 if len(v) == 1 {
4359 return p.NOTW(v[0])
4360 } else {
4361 panic("instruction NOTW takes exactly 1 operand")
4362 }
4363 }
4364
4365 func __asm_proxy_ORB__(p *Program, v ...interface{}) *Instruction {
4366 if len(v) == 2 {
4367 return p.ORB(v[0], v[1])
4368 } else {
4369 panic("instruction ORB takes exactly 2 operands")
4370 }
4371 }
4372
4373 func __asm_proxy_ORL__(p *Program, v ...interface{}) *Instruction {
4374 if len(v) == 2 {
4375 return p.ORL(v[0], v[1])
4376 } else {
4377 panic("instruction ORL takes exactly 2 operands")
4378 }
4379 }
4380
4381 func __asm_proxy_ORPD__(p *Program, v ...interface{}) *Instruction {
4382 if len(v) == 2 {
4383 return p.ORPD(v[0], v[1])
4384 } else {
4385 panic("instruction ORPD takes exactly 2 operands")
4386 }
4387 }
4388
4389 func __asm_proxy_ORPS__(p *Program, v ...interface{}) *Instruction {
4390 if len(v) == 2 {
4391 return p.ORPS(v[0], v[1])
4392 } else {
4393 panic("instruction ORPS takes exactly 2 operands")
4394 }
4395 }
4396
4397 func __asm_proxy_ORQ__(p *Program, v ...interface{}) *Instruction {
4398 if len(v) == 2 {
4399 return p.ORQ(v[0], v[1])
4400 } else {
4401 panic("instruction ORQ takes exactly 2 operands")
4402 }
4403 }
4404
4405 func __asm_proxy_ORW__(p *Program, v ...interface{}) *Instruction {
4406 if len(v) == 2 {
4407 return p.ORW(v[0], v[1])
4408 } else {
4409 panic("instruction ORW takes exactly 2 operands")
4410 }
4411 }
4412
4413 func __asm_proxy_PABSB__(p *Program, v ...interface{}) *Instruction {
4414 if len(v) == 2 {
4415 return p.PABSB(v[0], v[1])
4416 } else {
4417 panic("instruction PABSB takes exactly 2 operands")
4418 }
4419 }
4420
4421 func __asm_proxy_PABSD__(p *Program, v ...interface{}) *Instruction {
4422 if len(v) == 2 {
4423 return p.PABSD(v[0], v[1])
4424 } else {
4425 panic("instruction PABSD takes exactly 2 operands")
4426 }
4427 }
4428
4429 func __asm_proxy_PABSW__(p *Program, v ...interface{}) *Instruction {
4430 if len(v) == 2 {
4431 return p.PABSW(v[0], v[1])
4432 } else {
4433 panic("instruction PABSW takes exactly 2 operands")
4434 }
4435 }
4436
4437 func __asm_proxy_PACKSSDW__(p *Program, v ...interface{}) *Instruction {
4438 if len(v) == 2 {
4439 return p.PACKSSDW(v[0], v[1])
4440 } else {
4441 panic("instruction PACKSSDW takes exactly 2 operands")
4442 }
4443 }
4444
4445 func __asm_proxy_PACKSSWB__(p *Program, v ...interface{}) *Instruction {
4446 if len(v) == 2 {
4447 return p.PACKSSWB(v[0], v[1])
4448 } else {
4449 panic("instruction PACKSSWB takes exactly 2 operands")
4450 }
4451 }
4452
4453 func __asm_proxy_PACKUSDW__(p *Program, v ...interface{}) *Instruction {
4454 if len(v) == 2 {
4455 return p.PACKUSDW(v[0], v[1])
4456 } else {
4457 panic("instruction PACKUSDW takes exactly 2 operands")
4458 }
4459 }
4460
4461 func __asm_proxy_PACKUSWB__(p *Program, v ...interface{}) *Instruction {
4462 if len(v) == 2 {
4463 return p.PACKUSWB(v[0], v[1])
4464 } else {
4465 panic("instruction PACKUSWB takes exactly 2 operands")
4466 }
4467 }
4468
4469 func __asm_proxy_PADDB__(p *Program, v ...interface{}) *Instruction {
4470 if len(v) == 2 {
4471 return p.PADDB(v[0], v[1])
4472 } else {
4473 panic("instruction PADDB takes exactly 2 operands")
4474 }
4475 }
4476
4477 func __asm_proxy_PADDD__(p *Program, v ...interface{}) *Instruction {
4478 if len(v) == 2 {
4479 return p.PADDD(v[0], v[1])
4480 } else {
4481 panic("instruction PADDD takes exactly 2 operands")
4482 }
4483 }
4484
4485 func __asm_proxy_PADDQ__(p *Program, v ...interface{}) *Instruction {
4486 if len(v) == 2 {
4487 return p.PADDQ(v[0], v[1])
4488 } else {
4489 panic("instruction PADDQ takes exactly 2 operands")
4490 }
4491 }
4492
4493 func __asm_proxy_PADDSB__(p *Program, v ...interface{}) *Instruction {
4494 if len(v) == 2 {
4495 return p.PADDSB(v[0], v[1])
4496 } else {
4497 panic("instruction PADDSB takes exactly 2 operands")
4498 }
4499 }
4500
4501 func __asm_proxy_PADDSW__(p *Program, v ...interface{}) *Instruction {
4502 if len(v) == 2 {
4503 return p.PADDSW(v[0], v[1])
4504 } else {
4505 panic("instruction PADDSW takes exactly 2 operands")
4506 }
4507 }
4508
4509 func __asm_proxy_PADDUSB__(p *Program, v ...interface{}) *Instruction {
4510 if len(v) == 2 {
4511 return p.PADDUSB(v[0], v[1])
4512 } else {
4513 panic("instruction PADDUSB takes exactly 2 operands")
4514 }
4515 }
4516
4517 func __asm_proxy_PADDUSW__(p *Program, v ...interface{}) *Instruction {
4518 if len(v) == 2 {
4519 return p.PADDUSW(v[0], v[1])
4520 } else {
4521 panic("instruction PADDUSW takes exactly 2 operands")
4522 }
4523 }
4524
4525 func __asm_proxy_PADDW__(p *Program, v ...interface{}) *Instruction {
4526 if len(v) == 2 {
4527 return p.PADDW(v[0], v[1])
4528 } else {
4529 panic("instruction PADDW takes exactly 2 operands")
4530 }
4531 }
4532
4533 func __asm_proxy_PALIGNR__(p *Program, v ...interface{}) *Instruction {
4534 if len(v) == 3 {
4535 return p.PALIGNR(v[0], v[1], v[2])
4536 } else {
4537 panic("instruction PALIGNR takes exactly 3 operands")
4538 }
4539 }
4540
4541 func __asm_proxy_PAND__(p *Program, v ...interface{}) *Instruction {
4542 if len(v) == 2 {
4543 return p.PAND(v[0], v[1])
4544 } else {
4545 panic("instruction PAND takes exactly 2 operands")
4546 }
4547 }
4548
4549 func __asm_proxy_PANDN__(p *Program, v ...interface{}) *Instruction {
4550 if len(v) == 2 {
4551 return p.PANDN(v[0], v[1])
4552 } else {
4553 panic("instruction PANDN takes exactly 2 operands")
4554 }
4555 }
4556
4557 func __asm_proxy_PAUSE__(p *Program, v ...interface{}) *Instruction {
4558 if len(v) == 0 {
4559 return p.PAUSE()
4560 } else {
4561 panic("instruction PAUSE takes no operands")
4562 }
4563 }
4564
4565 func __asm_proxy_PAVGB__(p *Program, v ...interface{}) *Instruction {
4566 if len(v) == 2 {
4567 return p.PAVGB(v[0], v[1])
4568 } else {
4569 panic("instruction PAVGB takes exactly 2 operands")
4570 }
4571 }
4572
4573 func __asm_proxy_PAVGUSB__(p *Program, v ...interface{}) *Instruction {
4574 if len(v) == 2 {
4575 return p.PAVGUSB(v[0], v[1])
4576 } else {
4577 panic("instruction PAVGUSB takes exactly 2 operands")
4578 }
4579 }
4580
4581 func __asm_proxy_PAVGW__(p *Program, v ...interface{}) *Instruction {
4582 if len(v) == 2 {
4583 return p.PAVGW(v[0], v[1])
4584 } else {
4585 panic("instruction PAVGW takes exactly 2 operands")
4586 }
4587 }
4588
4589 func __asm_proxy_PBLENDVB__(p *Program, v ...interface{}) *Instruction {
4590 if len(v) == 3 {
4591 return p.PBLENDVB(v[0], v[1], v[2])
4592 } else {
4593 panic("instruction PBLENDVB takes exactly 3 operands")
4594 }
4595 }
4596
4597 func __asm_proxy_PBLENDW__(p *Program, v ...interface{}) *Instruction {
4598 if len(v) == 3 {
4599 return p.PBLENDW(v[0], v[1], v[2])
4600 } else {
4601 panic("instruction PBLENDW takes exactly 3 operands")
4602 }
4603 }
4604
4605 func __asm_proxy_PCLMULQDQ__(p *Program, v ...interface{}) *Instruction {
4606 if len(v) == 3 {
4607 return p.PCLMULQDQ(v[0], v[1], v[2])
4608 } else {
4609 panic("instruction PCLMULQDQ takes exactly 3 operands")
4610 }
4611 }
4612
4613 func __asm_proxy_PCMPEQB__(p *Program, v ...interface{}) *Instruction {
4614 if len(v) == 2 {
4615 return p.PCMPEQB(v[0], v[1])
4616 } else {
4617 panic("instruction PCMPEQB takes exactly 2 operands")
4618 }
4619 }
4620
4621 func __asm_proxy_PCMPEQD__(p *Program, v ...interface{}) *Instruction {
4622 if len(v) == 2 {
4623 return p.PCMPEQD(v[0], v[1])
4624 } else {
4625 panic("instruction PCMPEQD takes exactly 2 operands")
4626 }
4627 }
4628
4629 func __asm_proxy_PCMPEQQ__(p *Program, v ...interface{}) *Instruction {
4630 if len(v) == 2 {
4631 return p.PCMPEQQ(v[0], v[1])
4632 } else {
4633 panic("instruction PCMPEQQ takes exactly 2 operands")
4634 }
4635 }
4636
4637 func __asm_proxy_PCMPEQW__(p *Program, v ...interface{}) *Instruction {
4638 if len(v) == 2 {
4639 return p.PCMPEQW(v[0], v[1])
4640 } else {
4641 panic("instruction PCMPEQW takes exactly 2 operands")
4642 }
4643 }
4644
4645 func __asm_proxy_PCMPESTRI__(p *Program, v ...interface{}) *Instruction {
4646 if len(v) == 3 {
4647 return p.PCMPESTRI(v[0], v[1], v[2])
4648 } else {
4649 panic("instruction PCMPESTRI takes exactly 3 operands")
4650 }
4651 }
4652
4653 func __asm_proxy_PCMPESTRM__(p *Program, v ...interface{}) *Instruction {
4654 if len(v) == 3 {
4655 return p.PCMPESTRM(v[0], v[1], v[2])
4656 } else {
4657 panic("instruction PCMPESTRM takes exactly 3 operands")
4658 }
4659 }
4660
4661 func __asm_proxy_PCMPGTB__(p *Program, v ...interface{}) *Instruction {
4662 if len(v) == 2 {
4663 return p.PCMPGTB(v[0], v[1])
4664 } else {
4665 panic("instruction PCMPGTB takes exactly 2 operands")
4666 }
4667 }
4668
4669 func __asm_proxy_PCMPGTD__(p *Program, v ...interface{}) *Instruction {
4670 if len(v) == 2 {
4671 return p.PCMPGTD(v[0], v[1])
4672 } else {
4673 panic("instruction PCMPGTD takes exactly 2 operands")
4674 }
4675 }
4676
4677 func __asm_proxy_PCMPGTQ__(p *Program, v ...interface{}) *Instruction {
4678 if len(v) == 2 {
4679 return p.PCMPGTQ(v[0], v[1])
4680 } else {
4681 panic("instruction PCMPGTQ takes exactly 2 operands")
4682 }
4683 }
4684
4685 func __asm_proxy_PCMPGTW__(p *Program, v ...interface{}) *Instruction {
4686 if len(v) == 2 {
4687 return p.PCMPGTW(v[0], v[1])
4688 } else {
4689 panic("instruction PCMPGTW takes exactly 2 operands")
4690 }
4691 }
4692
4693 func __asm_proxy_PCMPISTRI__(p *Program, v ...interface{}) *Instruction {
4694 if len(v) == 3 {
4695 return p.PCMPISTRI(v[0], v[1], v[2])
4696 } else {
4697 panic("instruction PCMPISTRI takes exactly 3 operands")
4698 }
4699 }
4700
4701 func __asm_proxy_PCMPISTRM__(p *Program, v ...interface{}) *Instruction {
4702 if len(v) == 3 {
4703 return p.PCMPISTRM(v[0], v[1], v[2])
4704 } else {
4705 panic("instruction PCMPISTRM takes exactly 3 operands")
4706 }
4707 }
4708
4709 func __asm_proxy_PDEP__(p *Program, v ...interface{}) *Instruction {
4710 if len(v) == 3 {
4711 return p.PDEP(v[0], v[1], v[2])
4712 } else {
4713 panic("instruction PDEP takes exactly 3 operands")
4714 }
4715 }
4716
4717 func __asm_proxy_PEXT__(p *Program, v ...interface{}) *Instruction {
4718 if len(v) == 3 {
4719 return p.PEXT(v[0], v[1], v[2])
4720 } else {
4721 panic("instruction PEXT takes exactly 3 operands")
4722 }
4723 }
4724
4725 func __asm_proxy_PEXTRB__(p *Program, v ...interface{}) *Instruction {
4726 if len(v) == 3 {
4727 return p.PEXTRB(v[0], v[1], v[2])
4728 } else {
4729 panic("instruction PEXTRB takes exactly 3 operands")
4730 }
4731 }
4732
4733 func __asm_proxy_PEXTRD__(p *Program, v ...interface{}) *Instruction {
4734 if len(v) == 3 {
4735 return p.PEXTRD(v[0], v[1], v[2])
4736 } else {
4737 panic("instruction PEXTRD takes exactly 3 operands")
4738 }
4739 }
4740
4741 func __asm_proxy_PEXTRQ__(p *Program, v ...interface{}) *Instruction {
4742 if len(v) == 3 {
4743 return p.PEXTRQ(v[0], v[1], v[2])
4744 } else {
4745 panic("instruction PEXTRQ takes exactly 3 operands")
4746 }
4747 }
4748
4749 func __asm_proxy_PEXTRW__(p *Program, v ...interface{}) *Instruction {
4750 if len(v) == 3 {
4751 return p.PEXTRW(v[0], v[1], v[2])
4752 } else {
4753 panic("instruction PEXTRW takes exactly 3 operands")
4754 }
4755 }
4756
4757 func __asm_proxy_PF2ID__(p *Program, v ...interface{}) *Instruction {
4758 if len(v) == 2 {
4759 return p.PF2ID(v[0], v[1])
4760 } else {
4761 panic("instruction PF2ID takes exactly 2 operands")
4762 }
4763 }
4764
4765 func __asm_proxy_PF2IW__(p *Program, v ...interface{}) *Instruction {
4766 if len(v) == 2 {
4767 return p.PF2IW(v[0], v[1])
4768 } else {
4769 panic("instruction PF2IW takes exactly 2 operands")
4770 }
4771 }
4772
4773 func __asm_proxy_PFACC__(p *Program, v ...interface{}) *Instruction {
4774 if len(v) == 2 {
4775 return p.PFACC(v[0], v[1])
4776 } else {
4777 panic("instruction PFACC takes exactly 2 operands")
4778 }
4779 }
4780
4781 func __asm_proxy_PFADD__(p *Program, v ...interface{}) *Instruction {
4782 if len(v) == 2 {
4783 return p.PFADD(v[0], v[1])
4784 } else {
4785 panic("instruction PFADD takes exactly 2 operands")
4786 }
4787 }
4788
4789 func __asm_proxy_PFCMPEQ__(p *Program, v ...interface{}) *Instruction {
4790 if len(v) == 2 {
4791 return p.PFCMPEQ(v[0], v[1])
4792 } else {
4793 panic("instruction PFCMPEQ takes exactly 2 operands")
4794 }
4795 }
4796
4797 func __asm_proxy_PFCMPGE__(p *Program, v ...interface{}) *Instruction {
4798 if len(v) == 2 {
4799 return p.PFCMPGE(v[0], v[1])
4800 } else {
4801 panic("instruction PFCMPGE takes exactly 2 operands")
4802 }
4803 }
4804
4805 func __asm_proxy_PFCMPGT__(p *Program, v ...interface{}) *Instruction {
4806 if len(v) == 2 {
4807 return p.PFCMPGT(v[0], v[1])
4808 } else {
4809 panic("instruction PFCMPGT takes exactly 2 operands")
4810 }
4811 }
4812
4813 func __asm_proxy_PFMAX__(p *Program, v ...interface{}) *Instruction {
4814 if len(v) == 2 {
4815 return p.PFMAX(v[0], v[1])
4816 } else {
4817 panic("instruction PFMAX takes exactly 2 operands")
4818 }
4819 }
4820
4821 func __asm_proxy_PFMIN__(p *Program, v ...interface{}) *Instruction {
4822 if len(v) == 2 {
4823 return p.PFMIN(v[0], v[1])
4824 } else {
4825 panic("instruction PFMIN takes exactly 2 operands")
4826 }
4827 }
4828
4829 func __asm_proxy_PFMUL__(p *Program, v ...interface{}) *Instruction {
4830 if len(v) == 2 {
4831 return p.PFMUL(v[0], v[1])
4832 } else {
4833 panic("instruction PFMUL takes exactly 2 operands")
4834 }
4835 }
4836
4837 func __asm_proxy_PFNACC__(p *Program, v ...interface{}) *Instruction {
4838 if len(v) == 2 {
4839 return p.PFNACC(v[0], v[1])
4840 } else {
4841 panic("instruction PFNACC takes exactly 2 operands")
4842 }
4843 }
4844
4845 func __asm_proxy_PFPNACC__(p *Program, v ...interface{}) *Instruction {
4846 if len(v) == 2 {
4847 return p.PFPNACC(v[0], v[1])
4848 } else {
4849 panic("instruction PFPNACC takes exactly 2 operands")
4850 }
4851 }
4852
4853 func __asm_proxy_PFRCP__(p *Program, v ...interface{}) *Instruction {
4854 if len(v) == 2 {
4855 return p.PFRCP(v[0], v[1])
4856 } else {
4857 panic("instruction PFRCP takes exactly 2 operands")
4858 }
4859 }
4860
4861 func __asm_proxy_PFRCPIT1__(p *Program, v ...interface{}) *Instruction {
4862 if len(v) == 2 {
4863 return p.PFRCPIT1(v[0], v[1])
4864 } else {
4865 panic("instruction PFRCPIT1 takes exactly 2 operands")
4866 }
4867 }
4868
4869 func __asm_proxy_PFRCPIT2__(p *Program, v ...interface{}) *Instruction {
4870 if len(v) == 2 {
4871 return p.PFRCPIT2(v[0], v[1])
4872 } else {
4873 panic("instruction PFRCPIT2 takes exactly 2 operands")
4874 }
4875 }
4876
4877 func __asm_proxy_PFRSQIT1__(p *Program, v ...interface{}) *Instruction {
4878 if len(v) == 2 {
4879 return p.PFRSQIT1(v[0], v[1])
4880 } else {
4881 panic("instruction PFRSQIT1 takes exactly 2 operands")
4882 }
4883 }
4884
4885 func __asm_proxy_PFRSQRT__(p *Program, v ...interface{}) *Instruction {
4886 if len(v) == 2 {
4887 return p.PFRSQRT(v[0], v[1])
4888 } else {
4889 panic("instruction PFRSQRT takes exactly 2 operands")
4890 }
4891 }
4892
4893 func __asm_proxy_PFSUB__(p *Program, v ...interface{}) *Instruction {
4894 if len(v) == 2 {
4895 return p.PFSUB(v[0], v[1])
4896 } else {
4897 panic("instruction PFSUB takes exactly 2 operands")
4898 }
4899 }
4900
4901 func __asm_proxy_PFSUBR__(p *Program, v ...interface{}) *Instruction {
4902 if len(v) == 2 {
4903 return p.PFSUBR(v[0], v[1])
4904 } else {
4905 panic("instruction PFSUBR takes exactly 2 operands")
4906 }
4907 }
4908
4909 func __asm_proxy_PHADDD__(p *Program, v ...interface{}) *Instruction {
4910 if len(v) == 2 {
4911 return p.PHADDD(v[0], v[1])
4912 } else {
4913 panic("instruction PHADDD takes exactly 2 operands")
4914 }
4915 }
4916
4917 func __asm_proxy_PHADDSW__(p *Program, v ...interface{}) *Instruction {
4918 if len(v) == 2 {
4919 return p.PHADDSW(v[0], v[1])
4920 } else {
4921 panic("instruction PHADDSW takes exactly 2 operands")
4922 }
4923 }
4924
4925 func __asm_proxy_PHADDW__(p *Program, v ...interface{}) *Instruction {
4926 if len(v) == 2 {
4927 return p.PHADDW(v[0], v[1])
4928 } else {
4929 panic("instruction PHADDW takes exactly 2 operands")
4930 }
4931 }
4932
4933 func __asm_proxy_PHMINPOSUW__(p *Program, v ...interface{}) *Instruction {
4934 if len(v) == 2 {
4935 return p.PHMINPOSUW(v[0], v[1])
4936 } else {
4937 panic("instruction PHMINPOSUW takes exactly 2 operands")
4938 }
4939 }
4940
4941 func __asm_proxy_PHSUBD__(p *Program, v ...interface{}) *Instruction {
4942 if len(v) == 2 {
4943 return p.PHSUBD(v[0], v[1])
4944 } else {
4945 panic("instruction PHSUBD takes exactly 2 operands")
4946 }
4947 }
4948
4949 func __asm_proxy_PHSUBSW__(p *Program, v ...interface{}) *Instruction {
4950 if len(v) == 2 {
4951 return p.PHSUBSW(v[0], v[1])
4952 } else {
4953 panic("instruction PHSUBSW takes exactly 2 operands")
4954 }
4955 }
4956
4957 func __asm_proxy_PHSUBW__(p *Program, v ...interface{}) *Instruction {
4958 if len(v) == 2 {
4959 return p.PHSUBW(v[0], v[1])
4960 } else {
4961 panic("instruction PHSUBW takes exactly 2 operands")
4962 }
4963 }
4964
4965 func __asm_proxy_PI2FD__(p *Program, v ...interface{}) *Instruction {
4966 if len(v) == 2 {
4967 return p.PI2FD(v[0], v[1])
4968 } else {
4969 panic("instruction PI2FD takes exactly 2 operands")
4970 }
4971 }
4972
4973 func __asm_proxy_PI2FW__(p *Program, v ...interface{}) *Instruction {
4974 if len(v) == 2 {
4975 return p.PI2FW(v[0], v[1])
4976 } else {
4977 panic("instruction PI2FW takes exactly 2 operands")
4978 }
4979 }
4980
4981 func __asm_proxy_PINSRB__(p *Program, v ...interface{}) *Instruction {
4982 if len(v) == 3 {
4983 return p.PINSRB(v[0], v[1], v[2])
4984 } else {
4985 panic("instruction PINSRB takes exactly 3 operands")
4986 }
4987 }
4988
4989 func __asm_proxy_PINSRD__(p *Program, v ...interface{}) *Instruction {
4990 if len(v) == 3 {
4991 return p.PINSRD(v[0], v[1], v[2])
4992 } else {
4993 panic("instruction PINSRD takes exactly 3 operands")
4994 }
4995 }
4996
4997 func __asm_proxy_PINSRQ__(p *Program, v ...interface{}) *Instruction {
4998 if len(v) == 3 {
4999 return p.PINSRQ(v[0], v[1], v[2])
5000 } else {
5001 panic("instruction PINSRQ takes exactly 3 operands")
5002 }
5003 }
5004
5005 func __asm_proxy_PINSRW__(p *Program, v ...interface{}) *Instruction {
5006 if len(v) == 3 {
5007 return p.PINSRW(v[0], v[1], v[2])
5008 } else {
5009 panic("instruction PINSRW takes exactly 3 operands")
5010 }
5011 }
5012
5013 func __asm_proxy_PMADDUBSW__(p *Program, v ...interface{}) *Instruction {
5014 if len(v) == 2 {
5015 return p.PMADDUBSW(v[0], v[1])
5016 } else {
5017 panic("instruction PMADDUBSW takes exactly 2 operands")
5018 }
5019 }
5020
5021 func __asm_proxy_PMADDWD__(p *Program, v ...interface{}) *Instruction {
5022 if len(v) == 2 {
5023 return p.PMADDWD(v[0], v[1])
5024 } else {
5025 panic("instruction PMADDWD takes exactly 2 operands")
5026 }
5027 }
5028
5029 func __asm_proxy_PMAXSB__(p *Program, v ...interface{}) *Instruction {
5030 if len(v) == 2 {
5031 return p.PMAXSB(v[0], v[1])
5032 } else {
5033 panic("instruction PMAXSB takes exactly 2 operands")
5034 }
5035 }
5036
5037 func __asm_proxy_PMAXSD__(p *Program, v ...interface{}) *Instruction {
5038 if len(v) == 2 {
5039 return p.PMAXSD(v[0], v[1])
5040 } else {
5041 panic("instruction PMAXSD takes exactly 2 operands")
5042 }
5043 }
5044
5045 func __asm_proxy_PMAXSW__(p *Program, v ...interface{}) *Instruction {
5046 if len(v) == 2 {
5047 return p.PMAXSW(v[0], v[1])
5048 } else {
5049 panic("instruction PMAXSW takes exactly 2 operands")
5050 }
5051 }
5052
5053 func __asm_proxy_PMAXUB__(p *Program, v ...interface{}) *Instruction {
5054 if len(v) == 2 {
5055 return p.PMAXUB(v[0], v[1])
5056 } else {
5057 panic("instruction PMAXUB takes exactly 2 operands")
5058 }
5059 }
5060
5061 func __asm_proxy_PMAXUD__(p *Program, v ...interface{}) *Instruction {
5062 if len(v) == 2 {
5063 return p.PMAXUD(v[0], v[1])
5064 } else {
5065 panic("instruction PMAXUD takes exactly 2 operands")
5066 }
5067 }
5068
5069 func __asm_proxy_PMAXUW__(p *Program, v ...interface{}) *Instruction {
5070 if len(v) == 2 {
5071 return p.PMAXUW(v[0], v[1])
5072 } else {
5073 panic("instruction PMAXUW takes exactly 2 operands")
5074 }
5075 }
5076
5077 func __asm_proxy_PMINSB__(p *Program, v ...interface{}) *Instruction {
5078 if len(v) == 2 {
5079 return p.PMINSB(v[0], v[1])
5080 } else {
5081 panic("instruction PMINSB takes exactly 2 operands")
5082 }
5083 }
5084
5085 func __asm_proxy_PMINSD__(p *Program, v ...interface{}) *Instruction {
5086 if len(v) == 2 {
5087 return p.PMINSD(v[0], v[1])
5088 } else {
5089 panic("instruction PMINSD takes exactly 2 operands")
5090 }
5091 }
5092
5093 func __asm_proxy_PMINSW__(p *Program, v ...interface{}) *Instruction {
5094 if len(v) == 2 {
5095 return p.PMINSW(v[0], v[1])
5096 } else {
5097 panic("instruction PMINSW takes exactly 2 operands")
5098 }
5099 }
5100
5101 func __asm_proxy_PMINUB__(p *Program, v ...interface{}) *Instruction {
5102 if len(v) == 2 {
5103 return p.PMINUB(v[0], v[1])
5104 } else {
5105 panic("instruction PMINUB takes exactly 2 operands")
5106 }
5107 }
5108
5109 func __asm_proxy_PMINUD__(p *Program, v ...interface{}) *Instruction {
5110 if len(v) == 2 {
5111 return p.PMINUD(v[0], v[1])
5112 } else {
5113 panic("instruction PMINUD takes exactly 2 operands")
5114 }
5115 }
5116
5117 func __asm_proxy_PMINUW__(p *Program, v ...interface{}) *Instruction {
5118 if len(v) == 2 {
5119 return p.PMINUW(v[0], v[1])
5120 } else {
5121 panic("instruction PMINUW takes exactly 2 operands")
5122 }
5123 }
5124
5125 func __asm_proxy_PMOVMSKB__(p *Program, v ...interface{}) *Instruction {
5126 if len(v) == 2 {
5127 return p.PMOVMSKB(v[0], v[1])
5128 } else {
5129 panic("instruction PMOVMSKB takes exactly 2 operands")
5130 }
5131 }
5132
5133 func __asm_proxy_PMOVSXBD__(p *Program, v ...interface{}) *Instruction {
5134 if len(v) == 2 {
5135 return p.PMOVSXBD(v[0], v[1])
5136 } else {
5137 panic("instruction PMOVSXBD takes exactly 2 operands")
5138 }
5139 }
5140
5141 func __asm_proxy_PMOVSXBQ__(p *Program, v ...interface{}) *Instruction {
5142 if len(v) == 2 {
5143 return p.PMOVSXBQ(v[0], v[1])
5144 } else {
5145 panic("instruction PMOVSXBQ takes exactly 2 operands")
5146 }
5147 }
5148
5149 func __asm_proxy_PMOVSXBW__(p *Program, v ...interface{}) *Instruction {
5150 if len(v) == 2 {
5151 return p.PMOVSXBW(v[0], v[1])
5152 } else {
5153 panic("instruction PMOVSXBW takes exactly 2 operands")
5154 }
5155 }
5156
5157 func __asm_proxy_PMOVSXDQ__(p *Program, v ...interface{}) *Instruction {
5158 if len(v) == 2 {
5159 return p.PMOVSXDQ(v[0], v[1])
5160 } else {
5161 panic("instruction PMOVSXDQ takes exactly 2 operands")
5162 }
5163 }
5164
5165 func __asm_proxy_PMOVSXWD__(p *Program, v ...interface{}) *Instruction {
5166 if len(v) == 2 {
5167 return p.PMOVSXWD(v[0], v[1])
5168 } else {
5169 panic("instruction PMOVSXWD takes exactly 2 operands")
5170 }
5171 }
5172
5173 func __asm_proxy_PMOVSXWQ__(p *Program, v ...interface{}) *Instruction {
5174 if len(v) == 2 {
5175 return p.PMOVSXWQ(v[0], v[1])
5176 } else {
5177 panic("instruction PMOVSXWQ takes exactly 2 operands")
5178 }
5179 }
5180
5181 func __asm_proxy_PMOVZXBD__(p *Program, v ...interface{}) *Instruction {
5182 if len(v) == 2 {
5183 return p.PMOVZXBD(v[0], v[1])
5184 } else {
5185 panic("instruction PMOVZXBD takes exactly 2 operands")
5186 }
5187 }
5188
5189 func __asm_proxy_PMOVZXBQ__(p *Program, v ...interface{}) *Instruction {
5190 if len(v) == 2 {
5191 return p.PMOVZXBQ(v[0], v[1])
5192 } else {
5193 panic("instruction PMOVZXBQ takes exactly 2 operands")
5194 }
5195 }
5196
5197 func __asm_proxy_PMOVZXBW__(p *Program, v ...interface{}) *Instruction {
5198 if len(v) == 2 {
5199 return p.PMOVZXBW(v[0], v[1])
5200 } else {
5201 panic("instruction PMOVZXBW takes exactly 2 operands")
5202 }
5203 }
5204
5205 func __asm_proxy_PMOVZXDQ__(p *Program, v ...interface{}) *Instruction {
5206 if len(v) == 2 {
5207 return p.PMOVZXDQ(v[0], v[1])
5208 } else {
5209 panic("instruction PMOVZXDQ takes exactly 2 operands")
5210 }
5211 }
5212
5213 func __asm_proxy_PMOVZXWD__(p *Program, v ...interface{}) *Instruction {
5214 if len(v) == 2 {
5215 return p.PMOVZXWD(v[0], v[1])
5216 } else {
5217 panic("instruction PMOVZXWD takes exactly 2 operands")
5218 }
5219 }
5220
5221 func __asm_proxy_PMOVZXWQ__(p *Program, v ...interface{}) *Instruction {
5222 if len(v) == 2 {
5223 return p.PMOVZXWQ(v[0], v[1])
5224 } else {
5225 panic("instruction PMOVZXWQ takes exactly 2 operands")
5226 }
5227 }
5228
5229 func __asm_proxy_PMULDQ__(p *Program, v ...interface{}) *Instruction {
5230 if len(v) == 2 {
5231 return p.PMULDQ(v[0], v[1])
5232 } else {
5233 panic("instruction PMULDQ takes exactly 2 operands")
5234 }
5235 }
5236
5237 func __asm_proxy_PMULHRSW__(p *Program, v ...interface{}) *Instruction {
5238 if len(v) == 2 {
5239 return p.PMULHRSW(v[0], v[1])
5240 } else {
5241 panic("instruction PMULHRSW takes exactly 2 operands")
5242 }
5243 }
5244
5245 func __asm_proxy_PMULHRW__(p *Program, v ...interface{}) *Instruction {
5246 if len(v) == 2 {
5247 return p.PMULHRW(v[0], v[1])
5248 } else {
5249 panic("instruction PMULHRW takes exactly 2 operands")
5250 }
5251 }
5252
5253 func __asm_proxy_PMULHUW__(p *Program, v ...interface{}) *Instruction {
5254 if len(v) == 2 {
5255 return p.PMULHUW(v[0], v[1])
5256 } else {
5257 panic("instruction PMULHUW takes exactly 2 operands")
5258 }
5259 }
5260
5261 func __asm_proxy_PMULHW__(p *Program, v ...interface{}) *Instruction {
5262 if len(v) == 2 {
5263 return p.PMULHW(v[0], v[1])
5264 } else {
5265 panic("instruction PMULHW takes exactly 2 operands")
5266 }
5267 }
5268
5269 func __asm_proxy_PMULLD__(p *Program, v ...interface{}) *Instruction {
5270 if len(v) == 2 {
5271 return p.PMULLD(v[0], v[1])
5272 } else {
5273 panic("instruction PMULLD takes exactly 2 operands")
5274 }
5275 }
5276
5277 func __asm_proxy_PMULLW__(p *Program, v ...interface{}) *Instruction {
5278 if len(v) == 2 {
5279 return p.PMULLW(v[0], v[1])
5280 } else {
5281 panic("instruction PMULLW takes exactly 2 operands")
5282 }
5283 }
5284
5285 func __asm_proxy_PMULUDQ__(p *Program, v ...interface{}) *Instruction {
5286 if len(v) == 2 {
5287 return p.PMULUDQ(v[0], v[1])
5288 } else {
5289 panic("instruction PMULUDQ takes exactly 2 operands")
5290 }
5291 }
5292
5293 func __asm_proxy_POPCNTL__(p *Program, v ...interface{}) *Instruction {
5294 if len(v) == 2 {
5295 return p.POPCNTL(v[0], v[1])
5296 } else {
5297 panic("instruction POPCNTL takes exactly 2 operands")
5298 }
5299 }
5300
5301 func __asm_proxy_POPCNTQ__(p *Program, v ...interface{}) *Instruction {
5302 if len(v) == 2 {
5303 return p.POPCNTQ(v[0], v[1])
5304 } else {
5305 panic("instruction POPCNTQ takes exactly 2 operands")
5306 }
5307 }
5308
5309 func __asm_proxy_POPCNTW__(p *Program, v ...interface{}) *Instruction {
5310 if len(v) == 2 {
5311 return p.POPCNTW(v[0], v[1])
5312 } else {
5313 panic("instruction POPCNTW takes exactly 2 operands")
5314 }
5315 }
5316
5317 func __asm_proxy_POPQ__(p *Program, v ...interface{}) *Instruction {
5318 if len(v) == 1 {
5319 return p.POPQ(v[0])
5320 } else {
5321 panic("instruction POPQ takes exactly 1 operand")
5322 }
5323 }
5324
5325 func __asm_proxy_POPW__(p *Program, v ...interface{}) *Instruction {
5326 if len(v) == 1 {
5327 return p.POPW(v[0])
5328 } else {
5329 panic("instruction POPW takes exactly 1 operand")
5330 }
5331 }
5332
5333 func __asm_proxy_POR__(p *Program, v ...interface{}) *Instruction {
5334 if len(v) == 2 {
5335 return p.POR(v[0], v[1])
5336 } else {
5337 panic("instruction POR takes exactly 2 operands")
5338 }
5339 }
5340
5341 func __asm_proxy_PREFETCH__(p *Program, v ...interface{}) *Instruction {
5342 if len(v) == 1 {
5343 return p.PREFETCH(v[0])
5344 } else {
5345 panic("instruction PREFETCH takes exactly 1 operand")
5346 }
5347 }
5348
5349 func __asm_proxy_PREFETCHNTA__(p *Program, v ...interface{}) *Instruction {
5350 if len(v) == 1 {
5351 return p.PREFETCHNTA(v[0])
5352 } else {
5353 panic("instruction PREFETCHNTA takes exactly 1 operand")
5354 }
5355 }
5356
5357 func __asm_proxy_PREFETCHT0__(p *Program, v ...interface{}) *Instruction {
5358 if len(v) == 1 {
5359 return p.PREFETCHT0(v[0])
5360 } else {
5361 panic("instruction PREFETCHT0 takes exactly 1 operand")
5362 }
5363 }
5364
5365 func __asm_proxy_PREFETCHT1__(p *Program, v ...interface{}) *Instruction {
5366 if len(v) == 1 {
5367 return p.PREFETCHT1(v[0])
5368 } else {
5369 panic("instruction PREFETCHT1 takes exactly 1 operand")
5370 }
5371 }
5372
5373 func __asm_proxy_PREFETCHT2__(p *Program, v ...interface{}) *Instruction {
5374 if len(v) == 1 {
5375 return p.PREFETCHT2(v[0])
5376 } else {
5377 panic("instruction PREFETCHT2 takes exactly 1 operand")
5378 }
5379 }
5380
5381 func __asm_proxy_PREFETCHW__(p *Program, v ...interface{}) *Instruction {
5382 if len(v) == 1 {
5383 return p.PREFETCHW(v[0])
5384 } else {
5385 panic("instruction PREFETCHW takes exactly 1 operand")
5386 }
5387 }
5388
5389 func __asm_proxy_PREFETCHWT1__(p *Program, v ...interface{}) *Instruction {
5390 if len(v) == 1 {
5391 return p.PREFETCHWT1(v[0])
5392 } else {
5393 panic("instruction PREFETCHWT1 takes exactly 1 operand")
5394 }
5395 }
5396
5397 func __asm_proxy_PSADBW__(p *Program, v ...interface{}) *Instruction {
5398 if len(v) == 2 {
5399 return p.PSADBW(v[0], v[1])
5400 } else {
5401 panic("instruction PSADBW takes exactly 2 operands")
5402 }
5403 }
5404
5405 func __asm_proxy_PSHUFB__(p *Program, v ...interface{}) *Instruction {
5406 if len(v) == 2 {
5407 return p.PSHUFB(v[0], v[1])
5408 } else {
5409 panic("instruction PSHUFB takes exactly 2 operands")
5410 }
5411 }
5412
5413 func __asm_proxy_PSHUFD__(p *Program, v ...interface{}) *Instruction {
5414 if len(v) == 3 {
5415 return p.PSHUFD(v[0], v[1], v[2])
5416 } else {
5417 panic("instruction PSHUFD takes exactly 3 operands")
5418 }
5419 }
5420
5421 func __asm_proxy_PSHUFHW__(p *Program, v ...interface{}) *Instruction {
5422 if len(v) == 3 {
5423 return p.PSHUFHW(v[0], v[1], v[2])
5424 } else {
5425 panic("instruction PSHUFHW takes exactly 3 operands")
5426 }
5427 }
5428
5429 func __asm_proxy_PSHUFLW__(p *Program, v ...interface{}) *Instruction {
5430 if len(v) == 3 {
5431 return p.PSHUFLW(v[0], v[1], v[2])
5432 } else {
5433 panic("instruction PSHUFLW takes exactly 3 operands")
5434 }
5435 }
5436
5437 func __asm_proxy_PSHUFW__(p *Program, v ...interface{}) *Instruction {
5438 if len(v) == 3 {
5439 return p.PSHUFW(v[0], v[1], v[2])
5440 } else {
5441 panic("instruction PSHUFW takes exactly 3 operands")
5442 }
5443 }
5444
5445 func __asm_proxy_PSIGNB__(p *Program, v ...interface{}) *Instruction {
5446 if len(v) == 2 {
5447 return p.PSIGNB(v[0], v[1])
5448 } else {
5449 panic("instruction PSIGNB takes exactly 2 operands")
5450 }
5451 }
5452
5453 func __asm_proxy_PSIGND__(p *Program, v ...interface{}) *Instruction {
5454 if len(v) == 2 {
5455 return p.PSIGND(v[0], v[1])
5456 } else {
5457 panic("instruction PSIGND takes exactly 2 operands")
5458 }
5459 }
5460
5461 func __asm_proxy_PSIGNW__(p *Program, v ...interface{}) *Instruction {
5462 if len(v) == 2 {
5463 return p.PSIGNW(v[0], v[1])
5464 } else {
5465 panic("instruction PSIGNW takes exactly 2 operands")
5466 }
5467 }
5468
5469 func __asm_proxy_PSLLD__(p *Program, v ...interface{}) *Instruction {
5470 if len(v) == 2 {
5471 return p.PSLLD(v[0], v[1])
5472 } else {
5473 panic("instruction PSLLD takes exactly 2 operands")
5474 }
5475 }
5476
5477 func __asm_proxy_PSLLDQ__(p *Program, v ...interface{}) *Instruction {
5478 if len(v) == 2 {
5479 return p.PSLLDQ(v[0], v[1])
5480 } else {
5481 panic("instruction PSLLDQ takes exactly 2 operands")
5482 }
5483 }
5484
5485 func __asm_proxy_PSLLQ__(p *Program, v ...interface{}) *Instruction {
5486 if len(v) == 2 {
5487 return p.PSLLQ(v[0], v[1])
5488 } else {
5489 panic("instruction PSLLQ takes exactly 2 operands")
5490 }
5491 }
5492
5493 func __asm_proxy_PSLLW__(p *Program, v ...interface{}) *Instruction {
5494 if len(v) == 2 {
5495 return p.PSLLW(v[0], v[1])
5496 } else {
5497 panic("instruction PSLLW takes exactly 2 operands")
5498 }
5499 }
5500
5501 func __asm_proxy_PSRAD__(p *Program, v ...interface{}) *Instruction {
5502 if len(v) == 2 {
5503 return p.PSRAD(v[0], v[1])
5504 } else {
5505 panic("instruction PSRAD takes exactly 2 operands")
5506 }
5507 }
5508
5509 func __asm_proxy_PSRAW__(p *Program, v ...interface{}) *Instruction {
5510 if len(v) == 2 {
5511 return p.PSRAW(v[0], v[1])
5512 } else {
5513 panic("instruction PSRAW takes exactly 2 operands")
5514 }
5515 }
5516
5517 func __asm_proxy_PSRLD__(p *Program, v ...interface{}) *Instruction {
5518 if len(v) == 2 {
5519 return p.PSRLD(v[0], v[1])
5520 } else {
5521 panic("instruction PSRLD takes exactly 2 operands")
5522 }
5523 }
5524
5525 func __asm_proxy_PSRLDQ__(p *Program, v ...interface{}) *Instruction {
5526 if len(v) == 2 {
5527 return p.PSRLDQ(v[0], v[1])
5528 } else {
5529 panic("instruction PSRLDQ takes exactly 2 operands")
5530 }
5531 }
5532
5533 func __asm_proxy_PSRLQ__(p *Program, v ...interface{}) *Instruction {
5534 if len(v) == 2 {
5535 return p.PSRLQ(v[0], v[1])
5536 } else {
5537 panic("instruction PSRLQ takes exactly 2 operands")
5538 }
5539 }
5540
5541 func __asm_proxy_PSRLW__(p *Program, v ...interface{}) *Instruction {
5542 if len(v) == 2 {
5543 return p.PSRLW(v[0], v[1])
5544 } else {
5545 panic("instruction PSRLW takes exactly 2 operands")
5546 }
5547 }
5548
5549 func __asm_proxy_PSUBB__(p *Program, v ...interface{}) *Instruction {
5550 if len(v) == 2 {
5551 return p.PSUBB(v[0], v[1])
5552 } else {
5553 panic("instruction PSUBB takes exactly 2 operands")
5554 }
5555 }
5556
5557 func __asm_proxy_PSUBD__(p *Program, v ...interface{}) *Instruction {
5558 if len(v) == 2 {
5559 return p.PSUBD(v[0], v[1])
5560 } else {
5561 panic("instruction PSUBD takes exactly 2 operands")
5562 }
5563 }
5564
5565 func __asm_proxy_PSUBQ__(p *Program, v ...interface{}) *Instruction {
5566 if len(v) == 2 {
5567 return p.PSUBQ(v[0], v[1])
5568 } else {
5569 panic("instruction PSUBQ takes exactly 2 operands")
5570 }
5571 }
5572
5573 func __asm_proxy_PSUBSB__(p *Program, v ...interface{}) *Instruction {
5574 if len(v) == 2 {
5575 return p.PSUBSB(v[0], v[1])
5576 } else {
5577 panic("instruction PSUBSB takes exactly 2 operands")
5578 }
5579 }
5580
5581 func __asm_proxy_PSUBSW__(p *Program, v ...interface{}) *Instruction {
5582 if len(v) == 2 {
5583 return p.PSUBSW(v[0], v[1])
5584 } else {
5585 panic("instruction PSUBSW takes exactly 2 operands")
5586 }
5587 }
5588
5589 func __asm_proxy_PSUBUSB__(p *Program, v ...interface{}) *Instruction {
5590 if len(v) == 2 {
5591 return p.PSUBUSB(v[0], v[1])
5592 } else {
5593 panic("instruction PSUBUSB takes exactly 2 operands")
5594 }
5595 }
5596
5597 func __asm_proxy_PSUBUSW__(p *Program, v ...interface{}) *Instruction {
5598 if len(v) == 2 {
5599 return p.PSUBUSW(v[0], v[1])
5600 } else {
5601 panic("instruction PSUBUSW takes exactly 2 operands")
5602 }
5603 }
5604
5605 func __asm_proxy_PSUBW__(p *Program, v ...interface{}) *Instruction {
5606 if len(v) == 2 {
5607 return p.PSUBW(v[0], v[1])
5608 } else {
5609 panic("instruction PSUBW takes exactly 2 operands")
5610 }
5611 }
5612
5613 func __asm_proxy_PSWAPD__(p *Program, v ...interface{}) *Instruction {
5614 if len(v) == 2 {
5615 return p.PSWAPD(v[0], v[1])
5616 } else {
5617 panic("instruction PSWAPD takes exactly 2 operands")
5618 }
5619 }
5620
5621 func __asm_proxy_PTEST__(p *Program, v ...interface{}) *Instruction {
5622 if len(v) == 2 {
5623 return p.PTEST(v[0], v[1])
5624 } else {
5625 panic("instruction PTEST takes exactly 2 operands")
5626 }
5627 }
5628
5629 func __asm_proxy_PUNPCKHBW__(p *Program, v ...interface{}) *Instruction {
5630 if len(v) == 2 {
5631 return p.PUNPCKHBW(v[0], v[1])
5632 } else {
5633 panic("instruction PUNPCKHBW takes exactly 2 operands")
5634 }
5635 }
5636
5637 func __asm_proxy_PUNPCKHDQ__(p *Program, v ...interface{}) *Instruction {
5638 if len(v) == 2 {
5639 return p.PUNPCKHDQ(v[0], v[1])
5640 } else {
5641 panic("instruction PUNPCKHDQ takes exactly 2 operands")
5642 }
5643 }
5644
5645 func __asm_proxy_PUNPCKHQDQ__(p *Program, v ...interface{}) *Instruction {
5646 if len(v) == 2 {
5647 return p.PUNPCKHQDQ(v[0], v[1])
5648 } else {
5649 panic("instruction PUNPCKHQDQ takes exactly 2 operands")
5650 }
5651 }
5652
5653 func __asm_proxy_PUNPCKHWD__(p *Program, v ...interface{}) *Instruction {
5654 if len(v) == 2 {
5655 return p.PUNPCKHWD(v[0], v[1])
5656 } else {
5657 panic("instruction PUNPCKHWD takes exactly 2 operands")
5658 }
5659 }
5660
5661 func __asm_proxy_PUNPCKLBW__(p *Program, v ...interface{}) *Instruction {
5662 if len(v) == 2 {
5663 return p.PUNPCKLBW(v[0], v[1])
5664 } else {
5665 panic("instruction PUNPCKLBW takes exactly 2 operands")
5666 }
5667 }
5668
5669 func __asm_proxy_PUNPCKLDQ__(p *Program, v ...interface{}) *Instruction {
5670 if len(v) == 2 {
5671 return p.PUNPCKLDQ(v[0], v[1])
5672 } else {
5673 panic("instruction PUNPCKLDQ takes exactly 2 operands")
5674 }
5675 }
5676
5677 func __asm_proxy_PUNPCKLQDQ__(p *Program, v ...interface{}) *Instruction {
5678 if len(v) == 2 {
5679 return p.PUNPCKLQDQ(v[0], v[1])
5680 } else {
5681 panic("instruction PUNPCKLQDQ takes exactly 2 operands")
5682 }
5683 }
5684
5685 func __asm_proxy_PUNPCKLWD__(p *Program, v ...interface{}) *Instruction {
5686 if len(v) == 2 {
5687 return p.PUNPCKLWD(v[0], v[1])
5688 } else {
5689 panic("instruction PUNPCKLWD takes exactly 2 operands")
5690 }
5691 }
5692
5693 func __asm_proxy_PUSHQ__(p *Program, v ...interface{}) *Instruction {
5694 if len(v) == 1 {
5695 return p.PUSHQ(v[0])
5696 } else {
5697 panic("instruction PUSHQ takes exactly 1 operand")
5698 }
5699 }
5700
5701 func __asm_proxy_PUSHW__(p *Program, v ...interface{}) *Instruction {
5702 if len(v) == 1 {
5703 return p.PUSHW(v[0])
5704 } else {
5705 panic("instruction PUSHW takes exactly 1 operand")
5706 }
5707 }
5708
5709 func __asm_proxy_PXOR__(p *Program, v ...interface{}) *Instruction {
5710 if len(v) == 2 {
5711 return p.PXOR(v[0], v[1])
5712 } else {
5713 panic("instruction PXOR takes exactly 2 operands")
5714 }
5715 }
5716
5717 func __asm_proxy_RCLB__(p *Program, v ...interface{}) *Instruction {
5718 if len(v) == 2 {
5719 return p.RCLB(v[0], v[1])
5720 } else {
5721 panic("instruction RCLB takes exactly 2 operands")
5722 }
5723 }
5724
5725 func __asm_proxy_RCLL__(p *Program, v ...interface{}) *Instruction {
5726 if len(v) == 2 {
5727 return p.RCLL(v[0], v[1])
5728 } else {
5729 panic("instruction RCLL takes exactly 2 operands")
5730 }
5731 }
5732
5733 func __asm_proxy_RCLQ__(p *Program, v ...interface{}) *Instruction {
5734 if len(v) == 2 {
5735 return p.RCLQ(v[0], v[1])
5736 } else {
5737 panic("instruction RCLQ takes exactly 2 operands")
5738 }
5739 }
5740
5741 func __asm_proxy_RCLW__(p *Program, v ...interface{}) *Instruction {
5742 if len(v) == 2 {
5743 return p.RCLW(v[0], v[1])
5744 } else {
5745 panic("instruction RCLW takes exactly 2 operands")
5746 }
5747 }
5748
5749 func __asm_proxy_RCPPS__(p *Program, v ...interface{}) *Instruction {
5750 if len(v) == 2 {
5751 return p.RCPPS(v[0], v[1])
5752 } else {
5753 panic("instruction RCPPS takes exactly 2 operands")
5754 }
5755 }
5756
5757 func __asm_proxy_RCPSS__(p *Program, v ...interface{}) *Instruction {
5758 if len(v) == 2 {
5759 return p.RCPSS(v[0], v[1])
5760 } else {
5761 panic("instruction RCPSS takes exactly 2 operands")
5762 }
5763 }
5764
5765 func __asm_proxy_RCRB__(p *Program, v ...interface{}) *Instruction {
5766 if len(v) == 2 {
5767 return p.RCRB(v[0], v[1])
5768 } else {
5769 panic("instruction RCRB takes exactly 2 operands")
5770 }
5771 }
5772
5773 func __asm_proxy_RCRL__(p *Program, v ...interface{}) *Instruction {
5774 if len(v) == 2 {
5775 return p.RCRL(v[0], v[1])
5776 } else {
5777 panic("instruction RCRL takes exactly 2 operands")
5778 }
5779 }
5780
5781 func __asm_proxy_RCRQ__(p *Program, v ...interface{}) *Instruction {
5782 if len(v) == 2 {
5783 return p.RCRQ(v[0], v[1])
5784 } else {
5785 panic("instruction RCRQ takes exactly 2 operands")
5786 }
5787 }
5788
5789 func __asm_proxy_RCRW__(p *Program, v ...interface{}) *Instruction {
5790 if len(v) == 2 {
5791 return p.RCRW(v[0], v[1])
5792 } else {
5793 panic("instruction RCRW takes exactly 2 operands")
5794 }
5795 }
5796
5797 func __asm_proxy_RDRAND__(p *Program, v ...interface{}) *Instruction {
5798 if len(v) == 1 {
5799 return p.RDRAND(v[0])
5800 } else {
5801 panic("instruction RDRAND takes exactly 1 operand")
5802 }
5803 }
5804
5805 func __asm_proxy_RDSEED__(p *Program, v ...interface{}) *Instruction {
5806 if len(v) == 1 {
5807 return p.RDSEED(v[0])
5808 } else {
5809 panic("instruction RDSEED takes exactly 1 operand")
5810 }
5811 }
5812
5813 func __asm_proxy_RDTSC__(p *Program, v ...interface{}) *Instruction {
5814 if len(v) == 0 {
5815 return p.RDTSC()
5816 } else {
5817 panic("instruction RDTSC takes no operands")
5818 }
5819 }
5820
5821 func __asm_proxy_RDTSCP__(p *Program, v ...interface{}) *Instruction {
5822 if len(v) == 0 {
5823 return p.RDTSCP()
5824 } else {
5825 panic("instruction RDTSCP takes no operands")
5826 }
5827 }
5828
5829 func __asm_proxy_RET__(p *Program, v ...interface{}) *Instruction {
5830 switch len(v) {
5831 case 0 : return p.RET()
5832 case 1 : return p.RET(v[0])
5833 default : panic("instruction RET takes 0 or 1 operands")
5834 }
5835 }
5836
5837 func __asm_proxy_ROLB__(p *Program, v ...interface{}) *Instruction {
5838 if len(v) == 2 {
5839 return p.ROLB(v[0], v[1])
5840 } else {
5841 panic("instruction ROLB takes exactly 2 operands")
5842 }
5843 }
5844
5845 func __asm_proxy_ROLL__(p *Program, v ...interface{}) *Instruction {
5846 if len(v) == 2 {
5847 return p.ROLL(v[0], v[1])
5848 } else {
5849 panic("instruction ROLL takes exactly 2 operands")
5850 }
5851 }
5852
5853 func __asm_proxy_ROLQ__(p *Program, v ...interface{}) *Instruction {
5854 if len(v) == 2 {
5855 return p.ROLQ(v[0], v[1])
5856 } else {
5857 panic("instruction ROLQ takes exactly 2 operands")
5858 }
5859 }
5860
5861 func __asm_proxy_ROLW__(p *Program, v ...interface{}) *Instruction {
5862 if len(v) == 2 {
5863 return p.ROLW(v[0], v[1])
5864 } else {
5865 panic("instruction ROLW takes exactly 2 operands")
5866 }
5867 }
5868
5869 func __asm_proxy_RORB__(p *Program, v ...interface{}) *Instruction {
5870 if len(v) == 2 {
5871 return p.RORB(v[0], v[1])
5872 } else {
5873 panic("instruction RORB takes exactly 2 operands")
5874 }
5875 }
5876
5877 func __asm_proxy_RORL__(p *Program, v ...interface{}) *Instruction {
5878 if len(v) == 2 {
5879 return p.RORL(v[0], v[1])
5880 } else {
5881 panic("instruction RORL takes exactly 2 operands")
5882 }
5883 }
5884
5885 func __asm_proxy_RORQ__(p *Program, v ...interface{}) *Instruction {
5886 if len(v) == 2 {
5887 return p.RORQ(v[0], v[1])
5888 } else {
5889 panic("instruction RORQ takes exactly 2 operands")
5890 }
5891 }
5892
5893 func __asm_proxy_RORW__(p *Program, v ...interface{}) *Instruction {
5894 if len(v) == 2 {
5895 return p.RORW(v[0], v[1])
5896 } else {
5897 panic("instruction RORW takes exactly 2 operands")
5898 }
5899 }
5900
5901 func __asm_proxy_RORXL__(p *Program, v ...interface{}) *Instruction {
5902 if len(v) == 3 {
5903 return p.RORXL(v[0], v[1], v[2])
5904 } else {
5905 panic("instruction RORXL takes exactly 3 operands")
5906 }
5907 }
5908
5909 func __asm_proxy_RORXQ__(p *Program, v ...interface{}) *Instruction {
5910 if len(v) == 3 {
5911 return p.RORXQ(v[0], v[1], v[2])
5912 } else {
5913 panic("instruction RORXQ takes exactly 3 operands")
5914 }
5915 }
5916
5917 func __asm_proxy_ROUNDPD__(p *Program, v ...interface{}) *Instruction {
5918 if len(v) == 3 {
5919 return p.ROUNDPD(v[0], v[1], v[2])
5920 } else {
5921 panic("instruction ROUNDPD takes exactly 3 operands")
5922 }
5923 }
5924
5925 func __asm_proxy_ROUNDPS__(p *Program, v ...interface{}) *Instruction {
5926 if len(v) == 3 {
5927 return p.ROUNDPS(v[0], v[1], v[2])
5928 } else {
5929 panic("instruction ROUNDPS takes exactly 3 operands")
5930 }
5931 }
5932
5933 func __asm_proxy_ROUNDSD__(p *Program, v ...interface{}) *Instruction {
5934 if len(v) == 3 {
5935 return p.ROUNDSD(v[0], v[1], v[2])
5936 } else {
5937 panic("instruction ROUNDSD takes exactly 3 operands")
5938 }
5939 }
5940
5941 func __asm_proxy_ROUNDSS__(p *Program, v ...interface{}) *Instruction {
5942 if len(v) == 3 {
5943 return p.ROUNDSS(v[0], v[1], v[2])
5944 } else {
5945 panic("instruction ROUNDSS takes exactly 3 operands")
5946 }
5947 }
5948
5949 func __asm_proxy_RSQRTPS__(p *Program, v ...interface{}) *Instruction {
5950 if len(v) == 2 {
5951 return p.RSQRTPS(v[0], v[1])
5952 } else {
5953 panic("instruction RSQRTPS takes exactly 2 operands")
5954 }
5955 }
5956
5957 func __asm_proxy_RSQRTSS__(p *Program, v ...interface{}) *Instruction {
5958 if len(v) == 2 {
5959 return p.RSQRTSS(v[0], v[1])
5960 } else {
5961 panic("instruction RSQRTSS takes exactly 2 operands")
5962 }
5963 }
5964
5965 func __asm_proxy_SALB__(p *Program, v ...interface{}) *Instruction {
5966 if len(v) == 2 {
5967 return p.SALB(v[0], v[1])
5968 } else {
5969 panic("instruction SALB takes exactly 2 operands")
5970 }
5971 }
5972
5973 func __asm_proxy_SALL__(p *Program, v ...interface{}) *Instruction {
5974 if len(v) == 2 {
5975 return p.SALL(v[0], v[1])
5976 } else {
5977 panic("instruction SALL takes exactly 2 operands")
5978 }
5979 }
5980
5981 func __asm_proxy_SALQ__(p *Program, v ...interface{}) *Instruction {
5982 if len(v) == 2 {
5983 return p.SALQ(v[0], v[1])
5984 } else {
5985 panic("instruction SALQ takes exactly 2 operands")
5986 }
5987 }
5988
5989 func __asm_proxy_SALW__(p *Program, v ...interface{}) *Instruction {
5990 if len(v) == 2 {
5991 return p.SALW(v[0], v[1])
5992 } else {
5993 panic("instruction SALW takes exactly 2 operands")
5994 }
5995 }
5996
5997 func __asm_proxy_SARB__(p *Program, v ...interface{}) *Instruction {
5998 if len(v) == 2 {
5999 return p.SARB(v[0], v[1])
6000 } else {
6001 panic("instruction SARB takes exactly 2 operands")
6002 }
6003 }
6004
6005 func __asm_proxy_SARL__(p *Program, v ...interface{}) *Instruction {
6006 if len(v) == 2 {
6007 return p.SARL(v[0], v[1])
6008 } else {
6009 panic("instruction SARL takes exactly 2 operands")
6010 }
6011 }
6012
6013 func __asm_proxy_SARQ__(p *Program, v ...interface{}) *Instruction {
6014 if len(v) == 2 {
6015 return p.SARQ(v[0], v[1])
6016 } else {
6017 panic("instruction SARQ takes exactly 2 operands")
6018 }
6019 }
6020
6021 func __asm_proxy_SARW__(p *Program, v ...interface{}) *Instruction {
6022 if len(v) == 2 {
6023 return p.SARW(v[0], v[1])
6024 } else {
6025 panic("instruction SARW takes exactly 2 operands")
6026 }
6027 }
6028
6029 func __asm_proxy_SARXL__(p *Program, v ...interface{}) *Instruction {
6030 if len(v) == 3 {
6031 return p.SARXL(v[0], v[1], v[2])
6032 } else {
6033 panic("instruction SARXL takes exactly 3 operands")
6034 }
6035 }
6036
6037 func __asm_proxy_SARXQ__(p *Program, v ...interface{}) *Instruction {
6038 if len(v) == 3 {
6039 return p.SARXQ(v[0], v[1], v[2])
6040 } else {
6041 panic("instruction SARXQ takes exactly 3 operands")
6042 }
6043 }
6044
6045 func __asm_proxy_SBBB__(p *Program, v ...interface{}) *Instruction {
6046 if len(v) == 2 {
6047 return p.SBBB(v[0], v[1])
6048 } else {
6049 panic("instruction SBBB takes exactly 2 operands")
6050 }
6051 }
6052
6053 func __asm_proxy_SBBL__(p *Program, v ...interface{}) *Instruction {
6054 if len(v) == 2 {
6055 return p.SBBL(v[0], v[1])
6056 } else {
6057 panic("instruction SBBL takes exactly 2 operands")
6058 }
6059 }
6060
6061 func __asm_proxy_SBBQ__(p *Program, v ...interface{}) *Instruction {
6062 if len(v) == 2 {
6063 return p.SBBQ(v[0], v[1])
6064 } else {
6065 panic("instruction SBBQ takes exactly 2 operands")
6066 }
6067 }
6068
6069 func __asm_proxy_SBBW__(p *Program, v ...interface{}) *Instruction {
6070 if len(v) == 2 {
6071 return p.SBBW(v[0], v[1])
6072 } else {
6073 panic("instruction SBBW takes exactly 2 operands")
6074 }
6075 }
6076
6077 func __asm_proxy_SETA__(p *Program, v ...interface{}) *Instruction {
6078 if len(v) == 1 {
6079 return p.SETA(v[0])
6080 } else {
6081 panic("instruction SETA takes exactly 1 operand")
6082 }
6083 }
6084
6085 func __asm_proxy_SETAE__(p *Program, v ...interface{}) *Instruction {
6086 if len(v) == 1 {
6087 return p.SETAE(v[0])
6088 } else {
6089 panic("instruction SETAE takes exactly 1 operand")
6090 }
6091 }
6092
6093 func __asm_proxy_SETB__(p *Program, v ...interface{}) *Instruction {
6094 if len(v) == 1 {
6095 return p.SETB(v[0])
6096 } else {
6097 panic("instruction SETB takes exactly 1 operand")
6098 }
6099 }
6100
6101 func __asm_proxy_SETBE__(p *Program, v ...interface{}) *Instruction {
6102 if len(v) == 1 {
6103 return p.SETBE(v[0])
6104 } else {
6105 panic("instruction SETBE takes exactly 1 operand")
6106 }
6107 }
6108
6109 func __asm_proxy_SETC__(p *Program, v ...interface{}) *Instruction {
6110 if len(v) == 1 {
6111 return p.SETC(v[0])
6112 } else {
6113 panic("instruction SETC takes exactly 1 operand")
6114 }
6115 }
6116
6117 func __asm_proxy_SETE__(p *Program, v ...interface{}) *Instruction {
6118 if len(v) == 1 {
6119 return p.SETE(v[0])
6120 } else {
6121 panic("instruction SETE takes exactly 1 operand")
6122 }
6123 }
6124
6125 func __asm_proxy_SETG__(p *Program, v ...interface{}) *Instruction {
6126 if len(v) == 1 {
6127 return p.SETG(v[0])
6128 } else {
6129 panic("instruction SETG takes exactly 1 operand")
6130 }
6131 }
6132
6133 func __asm_proxy_SETGE__(p *Program, v ...interface{}) *Instruction {
6134 if len(v) == 1 {
6135 return p.SETGE(v[0])
6136 } else {
6137 panic("instruction SETGE takes exactly 1 operand")
6138 }
6139 }
6140
6141 func __asm_proxy_SETL__(p *Program, v ...interface{}) *Instruction {
6142 if len(v) == 1 {
6143 return p.SETL(v[0])
6144 } else {
6145 panic("instruction SETL takes exactly 1 operand")
6146 }
6147 }
6148
6149 func __asm_proxy_SETLE__(p *Program, v ...interface{}) *Instruction {
6150 if len(v) == 1 {
6151 return p.SETLE(v[0])
6152 } else {
6153 panic("instruction SETLE takes exactly 1 operand")
6154 }
6155 }
6156
6157 func __asm_proxy_SETNA__(p *Program, v ...interface{}) *Instruction {
6158 if len(v) == 1 {
6159 return p.SETNA(v[0])
6160 } else {
6161 panic("instruction SETNA takes exactly 1 operand")
6162 }
6163 }
6164
6165 func __asm_proxy_SETNAE__(p *Program, v ...interface{}) *Instruction {
6166 if len(v) == 1 {
6167 return p.SETNAE(v[0])
6168 } else {
6169 panic("instruction SETNAE takes exactly 1 operand")
6170 }
6171 }
6172
6173 func __asm_proxy_SETNB__(p *Program, v ...interface{}) *Instruction {
6174 if len(v) == 1 {
6175 return p.SETNB(v[0])
6176 } else {
6177 panic("instruction SETNB takes exactly 1 operand")
6178 }
6179 }
6180
6181 func __asm_proxy_SETNBE__(p *Program, v ...interface{}) *Instruction {
6182 if len(v) == 1 {
6183 return p.SETNBE(v[0])
6184 } else {
6185 panic("instruction SETNBE takes exactly 1 operand")
6186 }
6187 }
6188
6189 func __asm_proxy_SETNC__(p *Program, v ...interface{}) *Instruction {
6190 if len(v) == 1 {
6191 return p.SETNC(v[0])
6192 } else {
6193 panic("instruction SETNC takes exactly 1 operand")
6194 }
6195 }
6196
6197 func __asm_proxy_SETNE__(p *Program, v ...interface{}) *Instruction {
6198 if len(v) == 1 {
6199 return p.SETNE(v[0])
6200 } else {
6201 panic("instruction SETNE takes exactly 1 operand")
6202 }
6203 }
6204
6205 func __asm_proxy_SETNG__(p *Program, v ...interface{}) *Instruction {
6206 if len(v) == 1 {
6207 return p.SETNG(v[0])
6208 } else {
6209 panic("instruction SETNG takes exactly 1 operand")
6210 }
6211 }
6212
6213 func __asm_proxy_SETNGE__(p *Program, v ...interface{}) *Instruction {
6214 if len(v) == 1 {
6215 return p.SETNGE(v[0])
6216 } else {
6217 panic("instruction SETNGE takes exactly 1 operand")
6218 }
6219 }
6220
6221 func __asm_proxy_SETNL__(p *Program, v ...interface{}) *Instruction {
6222 if len(v) == 1 {
6223 return p.SETNL(v[0])
6224 } else {
6225 panic("instruction SETNL takes exactly 1 operand")
6226 }
6227 }
6228
6229 func __asm_proxy_SETNLE__(p *Program, v ...interface{}) *Instruction {
6230 if len(v) == 1 {
6231 return p.SETNLE(v[0])
6232 } else {
6233 panic("instruction SETNLE takes exactly 1 operand")
6234 }
6235 }
6236
6237 func __asm_proxy_SETNO__(p *Program, v ...interface{}) *Instruction {
6238 if len(v) == 1 {
6239 return p.SETNO(v[0])
6240 } else {
6241 panic("instruction SETNO takes exactly 1 operand")
6242 }
6243 }
6244
6245 func __asm_proxy_SETNP__(p *Program, v ...interface{}) *Instruction {
6246 if len(v) == 1 {
6247 return p.SETNP(v[0])
6248 } else {
6249 panic("instruction SETNP takes exactly 1 operand")
6250 }
6251 }
6252
6253 func __asm_proxy_SETNS__(p *Program, v ...interface{}) *Instruction {
6254 if len(v) == 1 {
6255 return p.SETNS(v[0])
6256 } else {
6257 panic("instruction SETNS takes exactly 1 operand")
6258 }
6259 }
6260
6261 func __asm_proxy_SETNZ__(p *Program, v ...interface{}) *Instruction {
6262 if len(v) == 1 {
6263 return p.SETNZ(v[0])
6264 } else {
6265 panic("instruction SETNZ takes exactly 1 operand")
6266 }
6267 }
6268
6269 func __asm_proxy_SETO__(p *Program, v ...interface{}) *Instruction {
6270 if len(v) == 1 {
6271 return p.SETO(v[0])
6272 } else {
6273 panic("instruction SETO takes exactly 1 operand")
6274 }
6275 }
6276
6277 func __asm_proxy_SETP__(p *Program, v ...interface{}) *Instruction {
6278 if len(v) == 1 {
6279 return p.SETP(v[0])
6280 } else {
6281 panic("instruction SETP takes exactly 1 operand")
6282 }
6283 }
6284
6285 func __asm_proxy_SETPE__(p *Program, v ...interface{}) *Instruction {
6286 if len(v) == 1 {
6287 return p.SETPE(v[0])
6288 } else {
6289 panic("instruction SETPE takes exactly 1 operand")
6290 }
6291 }
6292
6293 func __asm_proxy_SETPO__(p *Program, v ...interface{}) *Instruction {
6294 if len(v) == 1 {
6295 return p.SETPO(v[0])
6296 } else {
6297 panic("instruction SETPO takes exactly 1 operand")
6298 }
6299 }
6300
6301 func __asm_proxy_SETS__(p *Program, v ...interface{}) *Instruction {
6302 if len(v) == 1 {
6303 return p.SETS(v[0])
6304 } else {
6305 panic("instruction SETS takes exactly 1 operand")
6306 }
6307 }
6308
6309 func __asm_proxy_SETZ__(p *Program, v ...interface{}) *Instruction {
6310 if len(v) == 1 {
6311 return p.SETZ(v[0])
6312 } else {
6313 panic("instruction SETZ takes exactly 1 operand")
6314 }
6315 }
6316
6317 func __asm_proxy_SFENCE__(p *Program, v ...interface{}) *Instruction {
6318 if len(v) == 0 {
6319 return p.SFENCE()
6320 } else {
6321 panic("instruction SFENCE takes no operands")
6322 }
6323 }
6324
6325 func __asm_proxy_SHA1MSG1__(p *Program, v ...interface{}) *Instruction {
6326 if len(v) == 2 {
6327 return p.SHA1MSG1(v[0], v[1])
6328 } else {
6329 panic("instruction SHA1MSG1 takes exactly 2 operands")
6330 }
6331 }
6332
6333 func __asm_proxy_SHA1MSG2__(p *Program, v ...interface{}) *Instruction {
6334 if len(v) == 2 {
6335 return p.SHA1MSG2(v[0], v[1])
6336 } else {
6337 panic("instruction SHA1MSG2 takes exactly 2 operands")
6338 }
6339 }
6340
6341 func __asm_proxy_SHA1NEXTE__(p *Program, v ...interface{}) *Instruction {
6342 if len(v) == 2 {
6343 return p.SHA1NEXTE(v[0], v[1])
6344 } else {
6345 panic("instruction SHA1NEXTE takes exactly 2 operands")
6346 }
6347 }
6348
6349 func __asm_proxy_SHA1RNDS4__(p *Program, v ...interface{}) *Instruction {
6350 if len(v) == 3 {
6351 return p.SHA1RNDS4(v[0], v[1], v[2])
6352 } else {
6353 panic("instruction SHA1RNDS4 takes exactly 3 operands")
6354 }
6355 }
6356
6357 func __asm_proxy_SHA256MSG1__(p *Program, v ...interface{}) *Instruction {
6358 if len(v) == 2 {
6359 return p.SHA256MSG1(v[0], v[1])
6360 } else {
6361 panic("instruction SHA256MSG1 takes exactly 2 operands")
6362 }
6363 }
6364
6365 func __asm_proxy_SHA256MSG2__(p *Program, v ...interface{}) *Instruction {
6366 if len(v) == 2 {
6367 return p.SHA256MSG2(v[0], v[1])
6368 } else {
6369 panic("instruction SHA256MSG2 takes exactly 2 operands")
6370 }
6371 }
6372
6373 func __asm_proxy_SHA256RNDS2__(p *Program, v ...interface{}) *Instruction {
6374 if len(v) == 3 {
6375 return p.SHA256RNDS2(v[0], v[1], v[2])
6376 } else {
6377 panic("instruction SHA256RNDS2 takes exactly 3 operands")
6378 }
6379 }
6380
6381 func __asm_proxy_SHLB__(p *Program, v ...interface{}) *Instruction {
6382 if len(v) == 2 {
6383 return p.SHLB(v[0], v[1])
6384 } else {
6385 panic("instruction SHLB takes exactly 2 operands")
6386 }
6387 }
6388
6389 func __asm_proxy_SHLDL__(p *Program, v ...interface{}) *Instruction {
6390 if len(v) == 3 {
6391 return p.SHLDL(v[0], v[1], v[2])
6392 } else {
6393 panic("instruction SHLDL takes exactly 3 operands")
6394 }
6395 }
6396
6397 func __asm_proxy_SHLDQ__(p *Program, v ...interface{}) *Instruction {
6398 if len(v) == 3 {
6399 return p.SHLDQ(v[0], v[1], v[2])
6400 } else {
6401 panic("instruction SHLDQ takes exactly 3 operands")
6402 }
6403 }
6404
6405 func __asm_proxy_SHLDW__(p *Program, v ...interface{}) *Instruction {
6406 if len(v) == 3 {
6407 return p.SHLDW(v[0], v[1], v[2])
6408 } else {
6409 panic("instruction SHLDW takes exactly 3 operands")
6410 }
6411 }
6412
6413 func __asm_proxy_SHLL__(p *Program, v ...interface{}) *Instruction {
6414 if len(v) == 2 {
6415 return p.SHLL(v[0], v[1])
6416 } else {
6417 panic("instruction SHLL takes exactly 2 operands")
6418 }
6419 }
6420
6421 func __asm_proxy_SHLQ__(p *Program, v ...interface{}) *Instruction {
6422 if len(v) == 2 {
6423 return p.SHLQ(v[0], v[1])
6424 } else {
6425 panic("instruction SHLQ takes exactly 2 operands")
6426 }
6427 }
6428
6429 func __asm_proxy_SHLW__(p *Program, v ...interface{}) *Instruction {
6430 if len(v) == 2 {
6431 return p.SHLW(v[0], v[1])
6432 } else {
6433 panic("instruction SHLW takes exactly 2 operands")
6434 }
6435 }
6436
6437 func __asm_proxy_SHLXL__(p *Program, v ...interface{}) *Instruction {
6438 if len(v) == 3 {
6439 return p.SHLXL(v[0], v[1], v[2])
6440 } else {
6441 panic("instruction SHLXL takes exactly 3 operands")
6442 }
6443 }
6444
6445 func __asm_proxy_SHLXQ__(p *Program, v ...interface{}) *Instruction {
6446 if len(v) == 3 {
6447 return p.SHLXQ(v[0], v[1], v[2])
6448 } else {
6449 panic("instruction SHLXQ takes exactly 3 operands")
6450 }
6451 }
6452
6453 func __asm_proxy_SHRB__(p *Program, v ...interface{}) *Instruction {
6454 if len(v) == 2 {
6455 return p.SHRB(v[0], v[1])
6456 } else {
6457 panic("instruction SHRB takes exactly 2 operands")
6458 }
6459 }
6460
6461 func __asm_proxy_SHRDL__(p *Program, v ...interface{}) *Instruction {
6462 if len(v) == 3 {
6463 return p.SHRDL(v[0], v[1], v[2])
6464 } else {
6465 panic("instruction SHRDL takes exactly 3 operands")
6466 }
6467 }
6468
6469 func __asm_proxy_SHRDQ__(p *Program, v ...interface{}) *Instruction {
6470 if len(v) == 3 {
6471 return p.SHRDQ(v[0], v[1], v[2])
6472 } else {
6473 panic("instruction SHRDQ takes exactly 3 operands")
6474 }
6475 }
6476
6477 func __asm_proxy_SHRDW__(p *Program, v ...interface{}) *Instruction {
6478 if len(v) == 3 {
6479 return p.SHRDW(v[0], v[1], v[2])
6480 } else {
6481 panic("instruction SHRDW takes exactly 3 operands")
6482 }
6483 }
6484
6485 func __asm_proxy_SHRL__(p *Program, v ...interface{}) *Instruction {
6486 if len(v) == 2 {
6487 return p.SHRL(v[0], v[1])
6488 } else {
6489 panic("instruction SHRL takes exactly 2 operands")
6490 }
6491 }
6492
6493 func __asm_proxy_SHRQ__(p *Program, v ...interface{}) *Instruction {
6494 if len(v) == 2 {
6495 return p.SHRQ(v[0], v[1])
6496 } else {
6497 panic("instruction SHRQ takes exactly 2 operands")
6498 }
6499 }
6500
6501 func __asm_proxy_SHRW__(p *Program, v ...interface{}) *Instruction {
6502 if len(v) == 2 {
6503 return p.SHRW(v[0], v[1])
6504 } else {
6505 panic("instruction SHRW takes exactly 2 operands")
6506 }
6507 }
6508
6509 func __asm_proxy_SHRXL__(p *Program, v ...interface{}) *Instruction {
6510 if len(v) == 3 {
6511 return p.SHRXL(v[0], v[1], v[2])
6512 } else {
6513 panic("instruction SHRXL takes exactly 3 operands")
6514 }
6515 }
6516
6517 func __asm_proxy_SHRXQ__(p *Program, v ...interface{}) *Instruction {
6518 if len(v) == 3 {
6519 return p.SHRXQ(v[0], v[1], v[2])
6520 } else {
6521 panic("instruction SHRXQ takes exactly 3 operands")
6522 }
6523 }
6524
6525 func __asm_proxy_SHUFPD__(p *Program, v ...interface{}) *Instruction {
6526 if len(v) == 3 {
6527 return p.SHUFPD(v[0], v[1], v[2])
6528 } else {
6529 panic("instruction SHUFPD takes exactly 3 operands")
6530 }
6531 }
6532
6533 func __asm_proxy_SHUFPS__(p *Program, v ...interface{}) *Instruction {
6534 if len(v) == 3 {
6535 return p.SHUFPS(v[0], v[1], v[2])
6536 } else {
6537 panic("instruction SHUFPS takes exactly 3 operands")
6538 }
6539 }
6540
6541 func __asm_proxy_SQRTPD__(p *Program, v ...interface{}) *Instruction {
6542 if len(v) == 2 {
6543 return p.SQRTPD(v[0], v[1])
6544 } else {
6545 panic("instruction SQRTPD takes exactly 2 operands")
6546 }
6547 }
6548
6549 func __asm_proxy_SQRTPS__(p *Program, v ...interface{}) *Instruction {
6550 if len(v) == 2 {
6551 return p.SQRTPS(v[0], v[1])
6552 } else {
6553 panic("instruction SQRTPS takes exactly 2 operands")
6554 }
6555 }
6556
6557 func __asm_proxy_SQRTSD__(p *Program, v ...interface{}) *Instruction {
6558 if len(v) == 2 {
6559 return p.SQRTSD(v[0], v[1])
6560 } else {
6561 panic("instruction SQRTSD takes exactly 2 operands")
6562 }
6563 }
6564
6565 func __asm_proxy_SQRTSS__(p *Program, v ...interface{}) *Instruction {
6566 if len(v) == 2 {
6567 return p.SQRTSS(v[0], v[1])
6568 } else {
6569 panic("instruction SQRTSS takes exactly 2 operands")
6570 }
6571 }
6572
6573 func __asm_proxy_STC__(p *Program, v ...interface{}) *Instruction {
6574 if len(v) == 0 {
6575 return p.STC()
6576 } else {
6577 panic("instruction STC takes no operands")
6578 }
6579 }
6580
6581 func __asm_proxy_STD__(p *Program, v ...interface{}) *Instruction {
6582 if len(v) == 0 {
6583 return p.STD()
6584 } else {
6585 panic("instruction STD takes no operands")
6586 }
6587 }
6588
6589 func __asm_proxy_STMXCSR__(p *Program, v ...interface{}) *Instruction {
6590 if len(v) == 1 {
6591 return p.STMXCSR(v[0])
6592 } else {
6593 panic("instruction STMXCSR takes exactly 1 operand")
6594 }
6595 }
6596
6597 func __asm_proxy_SUBB__(p *Program, v ...interface{}) *Instruction {
6598 if len(v) == 2 {
6599 return p.SUBB(v[0], v[1])
6600 } else {
6601 panic("instruction SUBB takes exactly 2 operands")
6602 }
6603 }
6604
6605 func __asm_proxy_SUBL__(p *Program, v ...interface{}) *Instruction {
6606 if len(v) == 2 {
6607 return p.SUBL(v[0], v[1])
6608 } else {
6609 panic("instruction SUBL takes exactly 2 operands")
6610 }
6611 }
6612
6613 func __asm_proxy_SUBPD__(p *Program, v ...interface{}) *Instruction {
6614 if len(v) == 2 {
6615 return p.SUBPD(v[0], v[1])
6616 } else {
6617 panic("instruction SUBPD takes exactly 2 operands")
6618 }
6619 }
6620
6621 func __asm_proxy_SUBPS__(p *Program, v ...interface{}) *Instruction {
6622 if len(v) == 2 {
6623 return p.SUBPS(v[0], v[1])
6624 } else {
6625 panic("instruction SUBPS takes exactly 2 operands")
6626 }
6627 }
6628
6629 func __asm_proxy_SUBQ__(p *Program, v ...interface{}) *Instruction {
6630 if len(v) == 2 {
6631 return p.SUBQ(v[0], v[1])
6632 } else {
6633 panic("instruction SUBQ takes exactly 2 operands")
6634 }
6635 }
6636
6637 func __asm_proxy_SUBSD__(p *Program, v ...interface{}) *Instruction {
6638 if len(v) == 2 {
6639 return p.SUBSD(v[0], v[1])
6640 } else {
6641 panic("instruction SUBSD takes exactly 2 operands")
6642 }
6643 }
6644
6645 func __asm_proxy_SUBSS__(p *Program, v ...interface{}) *Instruction {
6646 if len(v) == 2 {
6647 return p.SUBSS(v[0], v[1])
6648 } else {
6649 panic("instruction SUBSS takes exactly 2 operands")
6650 }
6651 }
6652
6653 func __asm_proxy_SUBW__(p *Program, v ...interface{}) *Instruction {
6654 if len(v) == 2 {
6655 return p.SUBW(v[0], v[1])
6656 } else {
6657 panic("instruction SUBW takes exactly 2 operands")
6658 }
6659 }
6660
6661 func __asm_proxy_SYSCALL__(p *Program, v ...interface{}) *Instruction {
6662 if len(v) == 0 {
6663 return p.SYSCALL()
6664 } else {
6665 panic("instruction SYSCALL takes no operands")
6666 }
6667 }
6668
6669 func __asm_proxy_T1MSKC__(p *Program, v ...interface{}) *Instruction {
6670 if len(v) == 2 {
6671 return p.T1MSKC(v[0], v[1])
6672 } else {
6673 panic("instruction T1MSKC takes exactly 2 operands")
6674 }
6675 }
6676
6677 func __asm_proxy_TESTB__(p *Program, v ...interface{}) *Instruction {
6678 if len(v) == 2 {
6679 return p.TESTB(v[0], v[1])
6680 } else {
6681 panic("instruction TESTB takes exactly 2 operands")
6682 }
6683 }
6684
6685 func __asm_proxy_TESTL__(p *Program, v ...interface{}) *Instruction {
6686 if len(v) == 2 {
6687 return p.TESTL(v[0], v[1])
6688 } else {
6689 panic("instruction TESTL takes exactly 2 operands")
6690 }
6691 }
6692
6693 func __asm_proxy_TESTQ__(p *Program, v ...interface{}) *Instruction {
6694 if len(v) == 2 {
6695 return p.TESTQ(v[0], v[1])
6696 } else {
6697 panic("instruction TESTQ takes exactly 2 operands")
6698 }
6699 }
6700
6701 func __asm_proxy_TESTW__(p *Program, v ...interface{}) *Instruction {
6702 if len(v) == 2 {
6703 return p.TESTW(v[0], v[1])
6704 } else {
6705 panic("instruction TESTW takes exactly 2 operands")
6706 }
6707 }
6708
6709 func __asm_proxy_TZCNTL__(p *Program, v ...interface{}) *Instruction {
6710 if len(v) == 2 {
6711 return p.TZCNTL(v[0], v[1])
6712 } else {
6713 panic("instruction TZCNTL takes exactly 2 operands")
6714 }
6715 }
6716
6717 func __asm_proxy_TZCNTQ__(p *Program, v ...interface{}) *Instruction {
6718 if len(v) == 2 {
6719 return p.TZCNTQ(v[0], v[1])
6720 } else {
6721 panic("instruction TZCNTQ takes exactly 2 operands")
6722 }
6723 }
6724
6725 func __asm_proxy_TZCNTW__(p *Program, v ...interface{}) *Instruction {
6726 if len(v) == 2 {
6727 return p.TZCNTW(v[0], v[1])
6728 } else {
6729 panic("instruction TZCNTW takes exactly 2 operands")
6730 }
6731 }
6732
6733 func __asm_proxy_TZMSK__(p *Program, v ...interface{}) *Instruction {
6734 if len(v) == 2 {
6735 return p.TZMSK(v[0], v[1])
6736 } else {
6737 panic("instruction TZMSK takes exactly 2 operands")
6738 }
6739 }
6740
6741 func __asm_proxy_UCOMISD__(p *Program, v ...interface{}) *Instruction {
6742 if len(v) == 2 {
6743 return p.UCOMISD(v[0], v[1])
6744 } else {
6745 panic("instruction UCOMISD takes exactly 2 operands")
6746 }
6747 }
6748
6749 func __asm_proxy_UCOMISS__(p *Program, v ...interface{}) *Instruction {
6750 if len(v) == 2 {
6751 return p.UCOMISS(v[0], v[1])
6752 } else {
6753 panic("instruction UCOMISS takes exactly 2 operands")
6754 }
6755 }
6756
6757 func __asm_proxy_UD2__(p *Program, v ...interface{}) *Instruction {
6758 if len(v) == 0 {
6759 return p.UD2()
6760 } else {
6761 panic("instruction UD2 takes no operands")
6762 }
6763 }
6764
6765 func __asm_proxy_UNPCKHPD__(p *Program, v ...interface{}) *Instruction {
6766 if len(v) == 2 {
6767 return p.UNPCKHPD(v[0], v[1])
6768 } else {
6769 panic("instruction UNPCKHPD takes exactly 2 operands")
6770 }
6771 }
6772
6773 func __asm_proxy_UNPCKHPS__(p *Program, v ...interface{}) *Instruction {
6774 if len(v) == 2 {
6775 return p.UNPCKHPS(v[0], v[1])
6776 } else {
6777 panic("instruction UNPCKHPS takes exactly 2 operands")
6778 }
6779 }
6780
6781 func __asm_proxy_UNPCKLPD__(p *Program, v ...interface{}) *Instruction {
6782 if len(v) == 2 {
6783 return p.UNPCKLPD(v[0], v[1])
6784 } else {
6785 panic("instruction UNPCKLPD takes exactly 2 operands")
6786 }
6787 }
6788
6789 func __asm_proxy_UNPCKLPS__(p *Program, v ...interface{}) *Instruction {
6790 if len(v) == 2 {
6791 return p.UNPCKLPS(v[0], v[1])
6792 } else {
6793 panic("instruction UNPCKLPS takes exactly 2 operands")
6794 }
6795 }
6796
6797 func __asm_proxy_VADDPD__(p *Program, v ...interface{}) *Instruction {
6798 switch len(v) {
6799 case 3 : return p.VADDPD(v[0], v[1], v[2])
6800 case 4 : return p.VADDPD(v[0], v[1], v[2], v[3])
6801 default : panic("instruction VADDPD takes 3 or 4 operands")
6802 }
6803 }
6804
6805 func __asm_proxy_VADDPS__(p *Program, v ...interface{}) *Instruction {
6806 switch len(v) {
6807 case 3 : return p.VADDPS(v[0], v[1], v[2])
6808 case 4 : return p.VADDPS(v[0], v[1], v[2], v[3])
6809 default : panic("instruction VADDPS takes 3 or 4 operands")
6810 }
6811 }
6812
6813 func __asm_proxy_VADDSD__(p *Program, v ...interface{}) *Instruction {
6814 switch len(v) {
6815 case 3 : return p.VADDSD(v[0], v[1], v[2])
6816 case 4 : return p.VADDSD(v[0], v[1], v[2], v[3])
6817 default : panic("instruction VADDSD takes 3 or 4 operands")
6818 }
6819 }
6820
6821 func __asm_proxy_VADDSS__(p *Program, v ...interface{}) *Instruction {
6822 switch len(v) {
6823 case 3 : return p.VADDSS(v[0], v[1], v[2])
6824 case 4 : return p.VADDSS(v[0], v[1], v[2], v[3])
6825 default : panic("instruction VADDSS takes 3 or 4 operands")
6826 }
6827 }
6828
6829 func __asm_proxy_VADDSUBPD__(p *Program, v ...interface{}) *Instruction {
6830 if len(v) == 3 {
6831 return p.VADDSUBPD(v[0], v[1], v[2])
6832 } else {
6833 panic("instruction VADDSUBPD takes exactly 3 operands")
6834 }
6835 }
6836
6837 func __asm_proxy_VADDSUBPS__(p *Program, v ...interface{}) *Instruction {
6838 if len(v) == 3 {
6839 return p.VADDSUBPS(v[0], v[1], v[2])
6840 } else {
6841 panic("instruction VADDSUBPS takes exactly 3 operands")
6842 }
6843 }
6844
6845 func __asm_proxy_VAESDEC__(p *Program, v ...interface{}) *Instruction {
6846 if len(v) == 3 {
6847 return p.VAESDEC(v[0], v[1], v[2])
6848 } else {
6849 panic("instruction VAESDEC takes exactly 3 operands")
6850 }
6851 }
6852
6853 func __asm_proxy_VAESDECLAST__(p *Program, v ...interface{}) *Instruction {
6854 if len(v) == 3 {
6855 return p.VAESDECLAST(v[0], v[1], v[2])
6856 } else {
6857 panic("instruction VAESDECLAST takes exactly 3 operands")
6858 }
6859 }
6860
6861 func __asm_proxy_VAESENC__(p *Program, v ...interface{}) *Instruction {
6862 if len(v) == 3 {
6863 return p.VAESENC(v[0], v[1], v[2])
6864 } else {
6865 panic("instruction VAESENC takes exactly 3 operands")
6866 }
6867 }
6868
6869 func __asm_proxy_VAESENCLAST__(p *Program, v ...interface{}) *Instruction {
6870 if len(v) == 3 {
6871 return p.VAESENCLAST(v[0], v[1], v[2])
6872 } else {
6873 panic("instruction VAESENCLAST takes exactly 3 operands")
6874 }
6875 }
6876
6877 func __asm_proxy_VAESIMC__(p *Program, v ...interface{}) *Instruction {
6878 if len(v) == 2 {
6879 return p.VAESIMC(v[0], v[1])
6880 } else {
6881 panic("instruction VAESIMC takes exactly 2 operands")
6882 }
6883 }
6884
6885 func __asm_proxy_VAESKEYGENASSIST__(p *Program, v ...interface{}) *Instruction {
6886 if len(v) == 3 {
6887 return p.VAESKEYGENASSIST(v[0], v[1], v[2])
6888 } else {
6889 panic("instruction VAESKEYGENASSIST takes exactly 3 operands")
6890 }
6891 }
6892
6893 func __asm_proxy_VALIGND__(p *Program, v ...interface{}) *Instruction {
6894 if len(v) == 4 {
6895 return p.VALIGND(v[0], v[1], v[2], v[3])
6896 } else {
6897 panic("instruction VALIGND takes exactly 4 operands")
6898 }
6899 }
6900
6901 func __asm_proxy_VALIGNQ__(p *Program, v ...interface{}) *Instruction {
6902 if len(v) == 4 {
6903 return p.VALIGNQ(v[0], v[1], v[2], v[3])
6904 } else {
6905 panic("instruction VALIGNQ takes exactly 4 operands")
6906 }
6907 }
6908
6909 func __asm_proxy_VANDNPD__(p *Program, v ...interface{}) *Instruction {
6910 if len(v) == 3 {
6911 return p.VANDNPD(v[0], v[1], v[2])
6912 } else {
6913 panic("instruction VANDNPD takes exactly 3 operands")
6914 }
6915 }
6916
6917 func __asm_proxy_VANDNPS__(p *Program, v ...interface{}) *Instruction {
6918 if len(v) == 3 {
6919 return p.VANDNPS(v[0], v[1], v[2])
6920 } else {
6921 panic("instruction VANDNPS takes exactly 3 operands")
6922 }
6923 }
6924
6925 func __asm_proxy_VANDPD__(p *Program, v ...interface{}) *Instruction {
6926 if len(v) == 3 {
6927 return p.VANDPD(v[0], v[1], v[2])
6928 } else {
6929 panic("instruction VANDPD takes exactly 3 operands")
6930 }
6931 }
6932
6933 func __asm_proxy_VANDPS__(p *Program, v ...interface{}) *Instruction {
6934 if len(v) == 3 {
6935 return p.VANDPS(v[0], v[1], v[2])
6936 } else {
6937 panic("instruction VANDPS takes exactly 3 operands")
6938 }
6939 }
6940
6941 func __asm_proxy_VBLENDMPD__(p *Program, v ...interface{}) *Instruction {
6942 if len(v) == 3 {
6943 return p.VBLENDMPD(v[0], v[1], v[2])
6944 } else {
6945 panic("instruction VBLENDMPD takes exactly 3 operands")
6946 }
6947 }
6948
6949 func __asm_proxy_VBLENDMPS__(p *Program, v ...interface{}) *Instruction {
6950 if len(v) == 3 {
6951 return p.VBLENDMPS(v[0], v[1], v[2])
6952 } else {
6953 panic("instruction VBLENDMPS takes exactly 3 operands")
6954 }
6955 }
6956
6957 func __asm_proxy_VBLENDPD__(p *Program, v ...interface{}) *Instruction {
6958 if len(v) == 4 {
6959 return p.VBLENDPD(v[0], v[1], v[2], v[3])
6960 } else {
6961 panic("instruction VBLENDPD takes exactly 4 operands")
6962 }
6963 }
6964
6965 func __asm_proxy_VBLENDPS__(p *Program, v ...interface{}) *Instruction {
6966 if len(v) == 4 {
6967 return p.VBLENDPS(v[0], v[1], v[2], v[3])
6968 } else {
6969 panic("instruction VBLENDPS takes exactly 4 operands")
6970 }
6971 }
6972
6973 func __asm_proxy_VBLENDVPD__(p *Program, v ...interface{}) *Instruction {
6974 if len(v) == 4 {
6975 return p.VBLENDVPD(v[0], v[1], v[2], v[3])
6976 } else {
6977 panic("instruction VBLENDVPD takes exactly 4 operands")
6978 }
6979 }
6980
6981 func __asm_proxy_VBLENDVPS__(p *Program, v ...interface{}) *Instruction {
6982 if len(v) == 4 {
6983 return p.VBLENDVPS(v[0], v[1], v[2], v[3])
6984 } else {
6985 panic("instruction VBLENDVPS takes exactly 4 operands")
6986 }
6987 }
6988
6989 func __asm_proxy_VBROADCASTF128__(p *Program, v ...interface{}) *Instruction {
6990 if len(v) == 2 {
6991 return p.VBROADCASTF128(v[0], v[1])
6992 } else {
6993 panic("instruction VBROADCASTF128 takes exactly 2 operands")
6994 }
6995 }
6996
6997 func __asm_proxy_VBROADCASTF32X2__(p *Program, v ...interface{}) *Instruction {
6998 if len(v) == 2 {
6999 return p.VBROADCASTF32X2(v[0], v[1])
7000 } else {
7001 panic("instruction VBROADCASTF32X2 takes exactly 2 operands")
7002 }
7003 }
7004
7005 func __asm_proxy_VBROADCASTF32X4__(p *Program, v ...interface{}) *Instruction {
7006 if len(v) == 2 {
7007 return p.VBROADCASTF32X4(v[0], v[1])
7008 } else {
7009 panic("instruction VBROADCASTF32X4 takes exactly 2 operands")
7010 }
7011 }
7012
7013 func __asm_proxy_VBROADCASTF32X8__(p *Program, v ...interface{}) *Instruction {
7014 if len(v) == 2 {
7015 return p.VBROADCASTF32X8(v[0], v[1])
7016 } else {
7017 panic("instruction VBROADCASTF32X8 takes exactly 2 operands")
7018 }
7019 }
7020
7021 func __asm_proxy_VBROADCASTF64X2__(p *Program, v ...interface{}) *Instruction {
7022 if len(v) == 2 {
7023 return p.VBROADCASTF64X2(v[0], v[1])
7024 } else {
7025 panic("instruction VBROADCASTF64X2 takes exactly 2 operands")
7026 }
7027 }
7028
7029 func __asm_proxy_VBROADCASTF64X4__(p *Program, v ...interface{}) *Instruction {
7030 if len(v) == 2 {
7031 return p.VBROADCASTF64X4(v[0], v[1])
7032 } else {
7033 panic("instruction VBROADCASTF64X4 takes exactly 2 operands")
7034 }
7035 }
7036
7037 func __asm_proxy_VBROADCASTI128__(p *Program, v ...interface{}) *Instruction {
7038 if len(v) == 2 {
7039 return p.VBROADCASTI128(v[0], v[1])
7040 } else {
7041 panic("instruction VBROADCASTI128 takes exactly 2 operands")
7042 }
7043 }
7044
7045 func __asm_proxy_VBROADCASTI32X2__(p *Program, v ...interface{}) *Instruction {
7046 if len(v) == 2 {
7047 return p.VBROADCASTI32X2(v[0], v[1])
7048 } else {
7049 panic("instruction VBROADCASTI32X2 takes exactly 2 operands")
7050 }
7051 }
7052
7053 func __asm_proxy_VBROADCASTI32X4__(p *Program, v ...interface{}) *Instruction {
7054 if len(v) == 2 {
7055 return p.VBROADCASTI32X4(v[0], v[1])
7056 } else {
7057 panic("instruction VBROADCASTI32X4 takes exactly 2 operands")
7058 }
7059 }
7060
7061 func __asm_proxy_VBROADCASTI32X8__(p *Program, v ...interface{}) *Instruction {
7062 if len(v) == 2 {
7063 return p.VBROADCASTI32X8(v[0], v[1])
7064 } else {
7065 panic("instruction VBROADCASTI32X8 takes exactly 2 operands")
7066 }
7067 }
7068
7069 func __asm_proxy_VBROADCASTI64X2__(p *Program, v ...interface{}) *Instruction {
7070 if len(v) == 2 {
7071 return p.VBROADCASTI64X2(v[0], v[1])
7072 } else {
7073 panic("instruction VBROADCASTI64X2 takes exactly 2 operands")
7074 }
7075 }
7076
7077 func __asm_proxy_VBROADCASTI64X4__(p *Program, v ...interface{}) *Instruction {
7078 if len(v) == 2 {
7079 return p.VBROADCASTI64X4(v[0], v[1])
7080 } else {
7081 panic("instruction VBROADCASTI64X4 takes exactly 2 operands")
7082 }
7083 }
7084
7085 func __asm_proxy_VBROADCASTSD__(p *Program, v ...interface{}) *Instruction {
7086 if len(v) == 2 {
7087 return p.VBROADCASTSD(v[0], v[1])
7088 } else {
7089 panic("instruction VBROADCASTSD takes exactly 2 operands")
7090 }
7091 }
7092
7093 func __asm_proxy_VBROADCASTSS__(p *Program, v ...interface{}) *Instruction {
7094 if len(v) == 2 {
7095 return p.VBROADCASTSS(v[0], v[1])
7096 } else {
7097 panic("instruction VBROADCASTSS takes exactly 2 operands")
7098 }
7099 }
7100
7101 func __asm_proxy_VCMPPD__(p *Program, v ...interface{}) *Instruction {
7102 switch len(v) {
7103 case 4 : return p.VCMPPD(v[0], v[1], v[2], v[3])
7104 case 5 : return p.VCMPPD(v[0], v[1], v[2], v[3], v[4])
7105 default : panic("instruction VCMPPD takes 4 or 5 operands")
7106 }
7107 }
7108
7109 func __asm_proxy_VCMPPS__(p *Program, v ...interface{}) *Instruction {
7110 switch len(v) {
7111 case 4 : return p.VCMPPS(v[0], v[1], v[2], v[3])
7112 case 5 : return p.VCMPPS(v[0], v[1], v[2], v[3], v[4])
7113 default : panic("instruction VCMPPS takes 4 or 5 operands")
7114 }
7115 }
7116
7117 func __asm_proxy_VCMPSD__(p *Program, v ...interface{}) *Instruction {
7118 switch len(v) {
7119 case 4 : return p.VCMPSD(v[0], v[1], v[2], v[3])
7120 case 5 : return p.VCMPSD(v[0], v[1], v[2], v[3], v[4])
7121 default : panic("instruction VCMPSD takes 4 or 5 operands")
7122 }
7123 }
7124
7125 func __asm_proxy_VCMPSS__(p *Program, v ...interface{}) *Instruction {
7126 switch len(v) {
7127 case 4 : return p.VCMPSS(v[0], v[1], v[2], v[3])
7128 case 5 : return p.VCMPSS(v[0], v[1], v[2], v[3], v[4])
7129 default : panic("instruction VCMPSS takes 4 or 5 operands")
7130 }
7131 }
7132
7133 func __asm_proxy_VCOMISD__(p *Program, v ...interface{}) *Instruction {
7134 switch len(v) {
7135 case 2 : return p.VCOMISD(v[0], v[1])
7136 case 3 : return p.VCOMISD(v[0], v[1], v[2])
7137 default : panic("instruction VCOMISD takes 2 or 3 operands")
7138 }
7139 }
7140
7141 func __asm_proxy_VCOMISS__(p *Program, v ...interface{}) *Instruction {
7142 switch len(v) {
7143 case 2 : return p.VCOMISS(v[0], v[1])
7144 case 3 : return p.VCOMISS(v[0], v[1], v[2])
7145 default : panic("instruction VCOMISS takes 2 or 3 operands")
7146 }
7147 }
7148
7149 func __asm_proxy_VCOMPRESSPD__(p *Program, v ...interface{}) *Instruction {
7150 if len(v) == 2 {
7151 return p.VCOMPRESSPD(v[0], v[1])
7152 } else {
7153 panic("instruction VCOMPRESSPD takes exactly 2 operands")
7154 }
7155 }
7156
7157 func __asm_proxy_VCOMPRESSPS__(p *Program, v ...interface{}) *Instruction {
7158 if len(v) == 2 {
7159 return p.VCOMPRESSPS(v[0], v[1])
7160 } else {
7161 panic("instruction VCOMPRESSPS takes exactly 2 operands")
7162 }
7163 }
7164
7165 func __asm_proxy_VCVTDQ2PD__(p *Program, v ...interface{}) *Instruction {
7166 if len(v) == 2 {
7167 return p.VCVTDQ2PD(v[0], v[1])
7168 } else {
7169 panic("instruction VCVTDQ2PD takes exactly 2 operands")
7170 }
7171 }
7172
7173 func __asm_proxy_VCVTDQ2PS__(p *Program, v ...interface{}) *Instruction {
7174 switch len(v) {
7175 case 2 : return p.VCVTDQ2PS(v[0], v[1])
7176 case 3 : return p.VCVTDQ2PS(v[0], v[1], v[2])
7177 default : panic("instruction VCVTDQ2PS takes 2 or 3 operands")
7178 }
7179 }
7180
7181 func __asm_proxy_VCVTPD2DQ__(p *Program, v ...interface{}) *Instruction {
7182 switch len(v) {
7183 case 2 : return p.VCVTPD2DQ(v[0], v[1])
7184 case 3 : return p.VCVTPD2DQ(v[0], v[1], v[2])
7185 default : panic("instruction VCVTPD2DQ takes 2 or 3 operands")
7186 }
7187 }
7188
7189 func __asm_proxy_VCVTPD2PS__(p *Program, v ...interface{}) *Instruction {
7190 switch len(v) {
7191 case 2 : return p.VCVTPD2PS(v[0], v[1])
7192 case 3 : return p.VCVTPD2PS(v[0], v[1], v[2])
7193 default : panic("instruction VCVTPD2PS takes 2 or 3 operands")
7194 }
7195 }
7196
7197 func __asm_proxy_VCVTPD2QQ__(p *Program, v ...interface{}) *Instruction {
7198 switch len(v) {
7199 case 2 : return p.VCVTPD2QQ(v[0], v[1])
7200 case 3 : return p.VCVTPD2QQ(v[0], v[1], v[2])
7201 default : panic("instruction VCVTPD2QQ takes 2 or 3 operands")
7202 }
7203 }
7204
7205 func __asm_proxy_VCVTPD2UDQ__(p *Program, v ...interface{}) *Instruction {
7206 switch len(v) {
7207 case 2 : return p.VCVTPD2UDQ(v[0], v[1])
7208 case 3 : return p.VCVTPD2UDQ(v[0], v[1], v[2])
7209 default : panic("instruction VCVTPD2UDQ takes 2 or 3 operands")
7210 }
7211 }
7212
7213 func __asm_proxy_VCVTPD2UQQ__(p *Program, v ...interface{}) *Instruction {
7214 switch len(v) {
7215 case 2 : return p.VCVTPD2UQQ(v[0], v[1])
7216 case 3 : return p.VCVTPD2UQQ(v[0], v[1], v[2])
7217 default : panic("instruction VCVTPD2UQQ takes 2 or 3 operands")
7218 }
7219 }
7220
7221 func __asm_proxy_VCVTPH2PS__(p *Program, v ...interface{}) *Instruction {
7222 switch len(v) {
7223 case 2 : return p.VCVTPH2PS(v[0], v[1])
7224 case 3 : return p.VCVTPH2PS(v[0], v[1], v[2])
7225 default : panic("instruction VCVTPH2PS takes 2 or 3 operands")
7226 }
7227 }
7228
7229 func __asm_proxy_VCVTPS2DQ__(p *Program, v ...interface{}) *Instruction {
7230 switch len(v) {
7231 case 2 : return p.VCVTPS2DQ(v[0], v[1])
7232 case 3 : return p.VCVTPS2DQ(v[0], v[1], v[2])
7233 default : panic("instruction VCVTPS2DQ takes 2 or 3 operands")
7234 }
7235 }
7236
7237 func __asm_proxy_VCVTPS2PD__(p *Program, v ...interface{}) *Instruction {
7238 switch len(v) {
7239 case 2 : return p.VCVTPS2PD(v[0], v[1])
7240 case 3 : return p.VCVTPS2PD(v[0], v[1], v[2])
7241 default : panic("instruction VCVTPS2PD takes 2 or 3 operands")
7242 }
7243 }
7244
7245 func __asm_proxy_VCVTPS2PH__(p *Program, v ...interface{}) *Instruction {
7246 switch len(v) {
7247 case 3 : return p.VCVTPS2PH(v[0], v[1], v[2])
7248 case 4 : return p.VCVTPS2PH(v[0], v[1], v[2], v[3])
7249 default : panic("instruction VCVTPS2PH takes 3 or 4 operands")
7250 }
7251 }
7252
7253 func __asm_proxy_VCVTPS2QQ__(p *Program, v ...interface{}) *Instruction {
7254 switch len(v) {
7255 case 2 : return p.VCVTPS2QQ(v[0], v[1])
7256 case 3 : return p.VCVTPS2QQ(v[0], v[1], v[2])
7257 default : panic("instruction VCVTPS2QQ takes 2 or 3 operands")
7258 }
7259 }
7260
7261 func __asm_proxy_VCVTPS2UDQ__(p *Program, v ...interface{}) *Instruction {
7262 switch len(v) {
7263 case 2 : return p.VCVTPS2UDQ(v[0], v[1])
7264 case 3 : return p.VCVTPS2UDQ(v[0], v[1], v[2])
7265 default : panic("instruction VCVTPS2UDQ takes 2 or 3 operands")
7266 }
7267 }
7268
7269 func __asm_proxy_VCVTPS2UQQ__(p *Program, v ...interface{}) *Instruction {
7270 switch len(v) {
7271 case 2 : return p.VCVTPS2UQQ(v[0], v[1])
7272 case 3 : return p.VCVTPS2UQQ(v[0], v[1], v[2])
7273 default : panic("instruction VCVTPS2UQQ takes 2 or 3 operands")
7274 }
7275 }
7276
7277 func __asm_proxy_VCVTQQ2PD__(p *Program, v ...interface{}) *Instruction {
7278 switch len(v) {
7279 case 2 : return p.VCVTQQ2PD(v[0], v[1])
7280 case 3 : return p.VCVTQQ2PD(v[0], v[1], v[2])
7281 default : panic("instruction VCVTQQ2PD takes 2 or 3 operands")
7282 }
7283 }
7284
7285 func __asm_proxy_VCVTQQ2PS__(p *Program, v ...interface{}) *Instruction {
7286 switch len(v) {
7287 case 2 : return p.VCVTQQ2PS(v[0], v[1])
7288 case 3 : return p.VCVTQQ2PS(v[0], v[1], v[2])
7289 default : panic("instruction VCVTQQ2PS takes 2 or 3 operands")
7290 }
7291 }
7292
7293 func __asm_proxy_VCVTSD2SI__(p *Program, v ...interface{}) *Instruction {
7294 switch len(v) {
7295 case 2 : return p.VCVTSD2SI(v[0], v[1])
7296 case 3 : return p.VCVTSD2SI(v[0], v[1], v[2])
7297 default : panic("instruction VCVTSD2SI takes 2 or 3 operands")
7298 }
7299 }
7300
7301 func __asm_proxy_VCVTSD2SS__(p *Program, v ...interface{}) *Instruction {
7302 switch len(v) {
7303 case 3 : return p.VCVTSD2SS(v[0], v[1], v[2])
7304 case 4 : return p.VCVTSD2SS(v[0], v[1], v[2], v[3])
7305 default : panic("instruction VCVTSD2SS takes 3 or 4 operands")
7306 }
7307 }
7308
7309 func __asm_proxy_VCVTSD2USI__(p *Program, v ...interface{}) *Instruction {
7310 switch len(v) {
7311 case 2 : return p.VCVTSD2USI(v[0], v[1])
7312 case 3 : return p.VCVTSD2USI(v[0], v[1], v[2])
7313 default : panic("instruction VCVTSD2USI takes 2 or 3 operands")
7314 }
7315 }
7316
7317 func __asm_proxy_VCVTSI2SD__(p *Program, v ...interface{}) *Instruction {
7318 switch len(v) {
7319 case 3 : return p.VCVTSI2SD(v[0], v[1], v[2])
7320 case 4 : return p.VCVTSI2SD(v[0], v[1], v[2], v[3])
7321 default : panic("instruction VCVTSI2SD takes 3 or 4 operands")
7322 }
7323 }
7324
7325 func __asm_proxy_VCVTSI2SS__(p *Program, v ...interface{}) *Instruction {
7326 switch len(v) {
7327 case 3 : return p.VCVTSI2SS(v[0], v[1], v[2])
7328 case 4 : return p.VCVTSI2SS(v[0], v[1], v[2], v[3])
7329 default : panic("instruction VCVTSI2SS takes 3 or 4 operands")
7330 }
7331 }
7332
7333 func __asm_proxy_VCVTSS2SD__(p *Program, v ...interface{}) *Instruction {
7334 switch len(v) {
7335 case 3 : return p.VCVTSS2SD(v[0], v[1], v[2])
7336 case 4 : return p.VCVTSS2SD(v[0], v[1], v[2], v[3])
7337 default : panic("instruction VCVTSS2SD takes 3 or 4 operands")
7338 }
7339 }
7340
7341 func __asm_proxy_VCVTSS2SI__(p *Program, v ...interface{}) *Instruction {
7342 switch len(v) {
7343 case 2 : return p.VCVTSS2SI(v[0], v[1])
7344 case 3 : return p.VCVTSS2SI(v[0], v[1], v[2])
7345 default : panic("instruction VCVTSS2SI takes 2 or 3 operands")
7346 }
7347 }
7348
7349 func __asm_proxy_VCVTSS2USI__(p *Program, v ...interface{}) *Instruction {
7350 switch len(v) {
7351 case 2 : return p.VCVTSS2USI(v[0], v[1])
7352 case 3 : return p.VCVTSS2USI(v[0], v[1], v[2])
7353 default : panic("instruction VCVTSS2USI takes 2 or 3 operands")
7354 }
7355 }
7356
7357 func __asm_proxy_VCVTTPD2DQ__(p *Program, v ...interface{}) *Instruction {
7358 switch len(v) {
7359 case 2 : return p.VCVTTPD2DQ(v[0], v[1])
7360 case 3 : return p.VCVTTPD2DQ(v[0], v[1], v[2])
7361 default : panic("instruction VCVTTPD2DQ takes 2 or 3 operands")
7362 }
7363 }
7364
7365 func __asm_proxy_VCVTTPD2QQ__(p *Program, v ...interface{}) *Instruction {
7366 switch len(v) {
7367 case 2 : return p.VCVTTPD2QQ(v[0], v[1])
7368 case 3 : return p.VCVTTPD2QQ(v[0], v[1], v[2])
7369 default : panic("instruction VCVTTPD2QQ takes 2 or 3 operands")
7370 }
7371 }
7372
7373 func __asm_proxy_VCVTTPD2UDQ__(p *Program, v ...interface{}) *Instruction {
7374 switch len(v) {
7375 case 2 : return p.VCVTTPD2UDQ(v[0], v[1])
7376 case 3 : return p.VCVTTPD2UDQ(v[0], v[1], v[2])
7377 default : panic("instruction VCVTTPD2UDQ takes 2 or 3 operands")
7378 }
7379 }
7380
7381 func __asm_proxy_VCVTTPD2UQQ__(p *Program, v ...interface{}) *Instruction {
7382 switch len(v) {
7383 case 2 : return p.VCVTTPD2UQQ(v[0], v[1])
7384 case 3 : return p.VCVTTPD2UQQ(v[0], v[1], v[2])
7385 default : panic("instruction VCVTTPD2UQQ takes 2 or 3 operands")
7386 }
7387 }
7388
7389 func __asm_proxy_VCVTTPS2DQ__(p *Program, v ...interface{}) *Instruction {
7390 switch len(v) {
7391 case 2 : return p.VCVTTPS2DQ(v[0], v[1])
7392 case 3 : return p.VCVTTPS2DQ(v[0], v[1], v[2])
7393 default : panic("instruction VCVTTPS2DQ takes 2 or 3 operands")
7394 }
7395 }
7396
7397 func __asm_proxy_VCVTTPS2QQ__(p *Program, v ...interface{}) *Instruction {
7398 switch len(v) {
7399 case 2 : return p.VCVTTPS2QQ(v[0], v[1])
7400 case 3 : return p.VCVTTPS2QQ(v[0], v[1], v[2])
7401 default : panic("instruction VCVTTPS2QQ takes 2 or 3 operands")
7402 }
7403 }
7404
7405 func __asm_proxy_VCVTTPS2UDQ__(p *Program, v ...interface{}) *Instruction {
7406 switch len(v) {
7407 case 2 : return p.VCVTTPS2UDQ(v[0], v[1])
7408 case 3 : return p.VCVTTPS2UDQ(v[0], v[1], v[2])
7409 default : panic("instruction VCVTTPS2UDQ takes 2 or 3 operands")
7410 }
7411 }
7412
7413 func __asm_proxy_VCVTTPS2UQQ__(p *Program, v ...interface{}) *Instruction {
7414 switch len(v) {
7415 case 2 : return p.VCVTTPS2UQQ(v[0], v[1])
7416 case 3 : return p.VCVTTPS2UQQ(v[0], v[1], v[2])
7417 default : panic("instruction VCVTTPS2UQQ takes 2 or 3 operands")
7418 }
7419 }
7420
7421 func __asm_proxy_VCVTTSD2SI__(p *Program, v ...interface{}) *Instruction {
7422 switch len(v) {
7423 case 2 : return p.VCVTTSD2SI(v[0], v[1])
7424 case 3 : return p.VCVTTSD2SI(v[0], v[1], v[2])
7425 default : panic("instruction VCVTTSD2SI takes 2 or 3 operands")
7426 }
7427 }
7428
7429 func __asm_proxy_VCVTTSD2USI__(p *Program, v ...interface{}) *Instruction {
7430 switch len(v) {
7431 case 2 : return p.VCVTTSD2USI(v[0], v[1])
7432 case 3 : return p.VCVTTSD2USI(v[0], v[1], v[2])
7433 default : panic("instruction VCVTTSD2USI takes 2 or 3 operands")
7434 }
7435 }
7436
7437 func __asm_proxy_VCVTTSS2SI__(p *Program, v ...interface{}) *Instruction {
7438 switch len(v) {
7439 case 2 : return p.VCVTTSS2SI(v[0], v[1])
7440 case 3 : return p.VCVTTSS2SI(v[0], v[1], v[2])
7441 default : panic("instruction VCVTTSS2SI takes 2 or 3 operands")
7442 }
7443 }
7444
7445 func __asm_proxy_VCVTTSS2USI__(p *Program, v ...interface{}) *Instruction {
7446 switch len(v) {
7447 case 2 : return p.VCVTTSS2USI(v[0], v[1])
7448 case 3 : return p.VCVTTSS2USI(v[0], v[1], v[2])
7449 default : panic("instruction VCVTTSS2USI takes 2 or 3 operands")
7450 }
7451 }
7452
7453 func __asm_proxy_VCVTUDQ2PD__(p *Program, v ...interface{}) *Instruction {
7454 if len(v) == 2 {
7455 return p.VCVTUDQ2PD(v[0], v[1])
7456 } else {
7457 panic("instruction VCVTUDQ2PD takes exactly 2 operands")
7458 }
7459 }
7460
7461 func __asm_proxy_VCVTUDQ2PS__(p *Program, v ...interface{}) *Instruction {
7462 switch len(v) {
7463 case 2 : return p.VCVTUDQ2PS(v[0], v[1])
7464 case 3 : return p.VCVTUDQ2PS(v[0], v[1], v[2])
7465 default : panic("instruction VCVTUDQ2PS takes 2 or 3 operands")
7466 }
7467 }
7468
7469 func __asm_proxy_VCVTUQQ2PD__(p *Program, v ...interface{}) *Instruction {
7470 switch len(v) {
7471 case 2 : return p.VCVTUQQ2PD(v[0], v[1])
7472 case 3 : return p.VCVTUQQ2PD(v[0], v[1], v[2])
7473 default : panic("instruction VCVTUQQ2PD takes 2 or 3 operands")
7474 }
7475 }
7476
7477 func __asm_proxy_VCVTUQQ2PS__(p *Program, v ...interface{}) *Instruction {
7478 switch len(v) {
7479 case 2 : return p.VCVTUQQ2PS(v[0], v[1])
7480 case 3 : return p.VCVTUQQ2PS(v[0], v[1], v[2])
7481 default : panic("instruction VCVTUQQ2PS takes 2 or 3 operands")
7482 }
7483 }
7484
7485 func __asm_proxy_VCVTUSI2SD__(p *Program, v ...interface{}) *Instruction {
7486 switch len(v) {
7487 case 3 : return p.VCVTUSI2SD(v[0], v[1], v[2])
7488 case 4 : return p.VCVTUSI2SD(v[0], v[1], v[2], v[3])
7489 default : panic("instruction VCVTUSI2SD takes 3 or 4 operands")
7490 }
7491 }
7492
7493 func __asm_proxy_VCVTUSI2SS__(p *Program, v ...interface{}) *Instruction {
7494 switch len(v) {
7495 case 3 : return p.VCVTUSI2SS(v[0], v[1], v[2])
7496 case 4 : return p.VCVTUSI2SS(v[0], v[1], v[2], v[3])
7497 default : panic("instruction VCVTUSI2SS takes 3 or 4 operands")
7498 }
7499 }
7500
7501 func __asm_proxy_VDBPSADBW__(p *Program, v ...interface{}) *Instruction {
7502 if len(v) == 4 {
7503 return p.VDBPSADBW(v[0], v[1], v[2], v[3])
7504 } else {
7505 panic("instruction VDBPSADBW takes exactly 4 operands")
7506 }
7507 }
7508
7509 func __asm_proxy_VDIVPD__(p *Program, v ...interface{}) *Instruction {
7510 switch len(v) {
7511 case 3 : return p.VDIVPD(v[0], v[1], v[2])
7512 case 4 : return p.VDIVPD(v[0], v[1], v[2], v[3])
7513 default : panic("instruction VDIVPD takes 3 or 4 operands")
7514 }
7515 }
7516
7517 func __asm_proxy_VDIVPS__(p *Program, v ...interface{}) *Instruction {
7518 switch len(v) {
7519 case 3 : return p.VDIVPS(v[0], v[1], v[2])
7520 case 4 : return p.VDIVPS(v[0], v[1], v[2], v[3])
7521 default : panic("instruction VDIVPS takes 3 or 4 operands")
7522 }
7523 }
7524
7525 func __asm_proxy_VDIVSD__(p *Program, v ...interface{}) *Instruction {
7526 switch len(v) {
7527 case 3 : return p.VDIVSD(v[0], v[1], v[2])
7528 case 4 : return p.VDIVSD(v[0], v[1], v[2], v[3])
7529 default : panic("instruction VDIVSD takes 3 or 4 operands")
7530 }
7531 }
7532
7533 func __asm_proxy_VDIVSS__(p *Program, v ...interface{}) *Instruction {
7534 switch len(v) {
7535 case 3 : return p.VDIVSS(v[0], v[1], v[2])
7536 case 4 : return p.VDIVSS(v[0], v[1], v[2], v[3])
7537 default : panic("instruction VDIVSS takes 3 or 4 operands")
7538 }
7539 }
7540
7541 func __asm_proxy_VDPPD__(p *Program, v ...interface{}) *Instruction {
7542 if len(v) == 4 {
7543 return p.VDPPD(v[0], v[1], v[2], v[3])
7544 } else {
7545 panic("instruction VDPPD takes exactly 4 operands")
7546 }
7547 }
7548
7549 func __asm_proxy_VDPPS__(p *Program, v ...interface{}) *Instruction {
7550 if len(v) == 4 {
7551 return p.VDPPS(v[0], v[1], v[2], v[3])
7552 } else {
7553 panic("instruction VDPPS takes exactly 4 operands")
7554 }
7555 }
7556
7557 func __asm_proxy_VEXP2PD__(p *Program, v ...interface{}) *Instruction {
7558 switch len(v) {
7559 case 2 : return p.VEXP2PD(v[0], v[1])
7560 case 3 : return p.VEXP2PD(v[0], v[1], v[2])
7561 default : panic("instruction VEXP2PD takes 2 or 3 operands")
7562 }
7563 }
7564
7565 func __asm_proxy_VEXP2PS__(p *Program, v ...interface{}) *Instruction {
7566 switch len(v) {
7567 case 2 : return p.VEXP2PS(v[0], v[1])
7568 case 3 : return p.VEXP2PS(v[0], v[1], v[2])
7569 default : panic("instruction VEXP2PS takes 2 or 3 operands")
7570 }
7571 }
7572
7573 func __asm_proxy_VEXPANDPD__(p *Program, v ...interface{}) *Instruction {
7574 if len(v) == 2 {
7575 return p.VEXPANDPD(v[0], v[1])
7576 } else {
7577 panic("instruction VEXPANDPD takes exactly 2 operands")
7578 }
7579 }
7580
7581 func __asm_proxy_VEXPANDPS__(p *Program, v ...interface{}) *Instruction {
7582 if len(v) == 2 {
7583 return p.VEXPANDPS(v[0], v[1])
7584 } else {
7585 panic("instruction VEXPANDPS takes exactly 2 operands")
7586 }
7587 }
7588
7589 func __asm_proxy_VEXTRACTF128__(p *Program, v ...interface{}) *Instruction {
7590 if len(v) == 3 {
7591 return p.VEXTRACTF128(v[0], v[1], v[2])
7592 } else {
7593 panic("instruction VEXTRACTF128 takes exactly 3 operands")
7594 }
7595 }
7596
7597 func __asm_proxy_VEXTRACTF32X4__(p *Program, v ...interface{}) *Instruction {
7598 if len(v) == 3 {
7599 return p.VEXTRACTF32X4(v[0], v[1], v[2])
7600 } else {
7601 panic("instruction VEXTRACTF32X4 takes exactly 3 operands")
7602 }
7603 }
7604
7605 func __asm_proxy_VEXTRACTF32X8__(p *Program, v ...interface{}) *Instruction {
7606 if len(v) == 3 {
7607 return p.VEXTRACTF32X8(v[0], v[1], v[2])
7608 } else {
7609 panic("instruction VEXTRACTF32X8 takes exactly 3 operands")
7610 }
7611 }
7612
7613 func __asm_proxy_VEXTRACTF64X2__(p *Program, v ...interface{}) *Instruction {
7614 if len(v) == 3 {
7615 return p.VEXTRACTF64X2(v[0], v[1], v[2])
7616 } else {
7617 panic("instruction VEXTRACTF64X2 takes exactly 3 operands")
7618 }
7619 }
7620
7621 func __asm_proxy_VEXTRACTF64X4__(p *Program, v ...interface{}) *Instruction {
7622 if len(v) == 3 {
7623 return p.VEXTRACTF64X4(v[0], v[1], v[2])
7624 } else {
7625 panic("instruction VEXTRACTF64X4 takes exactly 3 operands")
7626 }
7627 }
7628
7629 func __asm_proxy_VEXTRACTI128__(p *Program, v ...interface{}) *Instruction {
7630 if len(v) == 3 {
7631 return p.VEXTRACTI128(v[0], v[1], v[2])
7632 } else {
7633 panic("instruction VEXTRACTI128 takes exactly 3 operands")
7634 }
7635 }
7636
7637 func __asm_proxy_VEXTRACTI32X4__(p *Program, v ...interface{}) *Instruction {
7638 if len(v) == 3 {
7639 return p.VEXTRACTI32X4(v[0], v[1], v[2])
7640 } else {
7641 panic("instruction VEXTRACTI32X4 takes exactly 3 operands")
7642 }
7643 }
7644
7645 func __asm_proxy_VEXTRACTI32X8__(p *Program, v ...interface{}) *Instruction {
7646 if len(v) == 3 {
7647 return p.VEXTRACTI32X8(v[0], v[1], v[2])
7648 } else {
7649 panic("instruction VEXTRACTI32X8 takes exactly 3 operands")
7650 }
7651 }
7652
7653 func __asm_proxy_VEXTRACTI64X2__(p *Program, v ...interface{}) *Instruction {
7654 if len(v) == 3 {
7655 return p.VEXTRACTI64X2(v[0], v[1], v[2])
7656 } else {
7657 panic("instruction VEXTRACTI64X2 takes exactly 3 operands")
7658 }
7659 }
7660
7661 func __asm_proxy_VEXTRACTI64X4__(p *Program, v ...interface{}) *Instruction {
7662 if len(v) == 3 {
7663 return p.VEXTRACTI64X4(v[0], v[1], v[2])
7664 } else {
7665 panic("instruction VEXTRACTI64X4 takes exactly 3 operands")
7666 }
7667 }
7668
7669 func __asm_proxy_VEXTRACTPS__(p *Program, v ...interface{}) *Instruction {
7670 if len(v) == 3 {
7671 return p.VEXTRACTPS(v[0], v[1], v[2])
7672 } else {
7673 panic("instruction VEXTRACTPS takes exactly 3 operands")
7674 }
7675 }
7676
7677 func __asm_proxy_VFIXUPIMMPD__(p *Program, v ...interface{}) *Instruction {
7678 switch len(v) {
7679 case 4 : return p.VFIXUPIMMPD(v[0], v[1], v[2], v[3])
7680 case 5 : return p.VFIXUPIMMPD(v[0], v[1], v[2], v[3], v[4])
7681 default : panic("instruction VFIXUPIMMPD takes 4 or 5 operands")
7682 }
7683 }
7684
7685 func __asm_proxy_VFIXUPIMMPS__(p *Program, v ...interface{}) *Instruction {
7686 switch len(v) {
7687 case 4 : return p.VFIXUPIMMPS(v[0], v[1], v[2], v[3])
7688 case 5 : return p.VFIXUPIMMPS(v[0], v[1], v[2], v[3], v[4])
7689 default : panic("instruction VFIXUPIMMPS takes 4 or 5 operands")
7690 }
7691 }
7692
7693 func __asm_proxy_VFIXUPIMMSD__(p *Program, v ...interface{}) *Instruction {
7694 switch len(v) {
7695 case 4 : return p.VFIXUPIMMSD(v[0], v[1], v[2], v[3])
7696 case 5 : return p.VFIXUPIMMSD(v[0], v[1], v[2], v[3], v[4])
7697 default : panic("instruction VFIXUPIMMSD takes 4 or 5 operands")
7698 }
7699 }
7700
7701 func __asm_proxy_VFIXUPIMMSS__(p *Program, v ...interface{}) *Instruction {
7702 switch len(v) {
7703 case 4 : return p.VFIXUPIMMSS(v[0], v[1], v[2], v[3])
7704 case 5 : return p.VFIXUPIMMSS(v[0], v[1], v[2], v[3], v[4])
7705 default : panic("instruction VFIXUPIMMSS takes 4 or 5 operands")
7706 }
7707 }
7708
7709 func __asm_proxy_VFMADD132PD__(p *Program, v ...interface{}) *Instruction {
7710 switch len(v) {
7711 case 3 : return p.VFMADD132PD(v[0], v[1], v[2])
7712 case 4 : return p.VFMADD132PD(v[0], v[1], v[2], v[3])
7713 default : panic("instruction VFMADD132PD takes 3 or 4 operands")
7714 }
7715 }
7716
7717 func __asm_proxy_VFMADD132PS__(p *Program, v ...interface{}) *Instruction {
7718 switch len(v) {
7719 case 3 : return p.VFMADD132PS(v[0], v[1], v[2])
7720 case 4 : return p.VFMADD132PS(v[0], v[1], v[2], v[3])
7721 default : panic("instruction VFMADD132PS takes 3 or 4 operands")
7722 }
7723 }
7724
7725 func __asm_proxy_VFMADD132SD__(p *Program, v ...interface{}) *Instruction {
7726 switch len(v) {
7727 case 3 : return p.VFMADD132SD(v[0], v[1], v[2])
7728 case 4 : return p.VFMADD132SD(v[0], v[1], v[2], v[3])
7729 default : panic("instruction VFMADD132SD takes 3 or 4 operands")
7730 }
7731 }
7732
7733 func __asm_proxy_VFMADD132SS__(p *Program, v ...interface{}) *Instruction {
7734 switch len(v) {
7735 case 3 : return p.VFMADD132SS(v[0], v[1], v[2])
7736 case 4 : return p.VFMADD132SS(v[0], v[1], v[2], v[3])
7737 default : panic("instruction VFMADD132SS takes 3 or 4 operands")
7738 }
7739 }
7740
7741 func __asm_proxy_VFMADD213PD__(p *Program, v ...interface{}) *Instruction {
7742 switch len(v) {
7743 case 3 : return p.VFMADD213PD(v[0], v[1], v[2])
7744 case 4 : return p.VFMADD213PD(v[0], v[1], v[2], v[3])
7745 default : panic("instruction VFMADD213PD takes 3 or 4 operands")
7746 }
7747 }
7748
7749 func __asm_proxy_VFMADD213PS__(p *Program, v ...interface{}) *Instruction {
7750 switch len(v) {
7751 case 3 : return p.VFMADD213PS(v[0], v[1], v[2])
7752 case 4 : return p.VFMADD213PS(v[0], v[1], v[2], v[3])
7753 default : panic("instruction VFMADD213PS takes 3 or 4 operands")
7754 }
7755 }
7756
7757 func __asm_proxy_VFMADD213SD__(p *Program, v ...interface{}) *Instruction {
7758 switch len(v) {
7759 case 3 : return p.VFMADD213SD(v[0], v[1], v[2])
7760 case 4 : return p.VFMADD213SD(v[0], v[1], v[2], v[3])
7761 default : panic("instruction VFMADD213SD takes 3 or 4 operands")
7762 }
7763 }
7764
7765 func __asm_proxy_VFMADD213SS__(p *Program, v ...interface{}) *Instruction {
7766 switch len(v) {
7767 case 3 : return p.VFMADD213SS(v[0], v[1], v[2])
7768 case 4 : return p.VFMADD213SS(v[0], v[1], v[2], v[3])
7769 default : panic("instruction VFMADD213SS takes 3 or 4 operands")
7770 }
7771 }
7772
7773 func __asm_proxy_VFMADD231PD__(p *Program, v ...interface{}) *Instruction {
7774 switch len(v) {
7775 case 3 : return p.VFMADD231PD(v[0], v[1], v[2])
7776 case 4 : return p.VFMADD231PD(v[0], v[1], v[2], v[3])
7777 default : panic("instruction VFMADD231PD takes 3 or 4 operands")
7778 }
7779 }
7780
7781 func __asm_proxy_VFMADD231PS__(p *Program, v ...interface{}) *Instruction {
7782 switch len(v) {
7783 case 3 : return p.VFMADD231PS(v[0], v[1], v[2])
7784 case 4 : return p.VFMADD231PS(v[0], v[1], v[2], v[3])
7785 default : panic("instruction VFMADD231PS takes 3 or 4 operands")
7786 }
7787 }
7788
7789 func __asm_proxy_VFMADD231SD__(p *Program, v ...interface{}) *Instruction {
7790 switch len(v) {
7791 case 3 : return p.VFMADD231SD(v[0], v[1], v[2])
7792 case 4 : return p.VFMADD231SD(v[0], v[1], v[2], v[3])
7793 default : panic("instruction VFMADD231SD takes 3 or 4 operands")
7794 }
7795 }
7796
7797 func __asm_proxy_VFMADD231SS__(p *Program, v ...interface{}) *Instruction {
7798 switch len(v) {
7799 case 3 : return p.VFMADD231SS(v[0], v[1], v[2])
7800 case 4 : return p.VFMADD231SS(v[0], v[1], v[2], v[3])
7801 default : panic("instruction VFMADD231SS takes 3 or 4 operands")
7802 }
7803 }
7804
7805 func __asm_proxy_VFMADDPD__(p *Program, v ...interface{}) *Instruction {
7806 if len(v) == 4 {
7807 return p.VFMADDPD(v[0], v[1], v[2], v[3])
7808 } else {
7809 panic("instruction VFMADDPD takes exactly 4 operands")
7810 }
7811 }
7812
7813 func __asm_proxy_VFMADDPS__(p *Program, v ...interface{}) *Instruction {
7814 if len(v) == 4 {
7815 return p.VFMADDPS(v[0], v[1], v[2], v[3])
7816 } else {
7817 panic("instruction VFMADDPS takes exactly 4 operands")
7818 }
7819 }
7820
7821 func __asm_proxy_VFMADDSD__(p *Program, v ...interface{}) *Instruction {
7822 if len(v) == 4 {
7823 return p.VFMADDSD(v[0], v[1], v[2], v[3])
7824 } else {
7825 panic("instruction VFMADDSD takes exactly 4 operands")
7826 }
7827 }
7828
7829 func __asm_proxy_VFMADDSS__(p *Program, v ...interface{}) *Instruction {
7830 if len(v) == 4 {
7831 return p.VFMADDSS(v[0], v[1], v[2], v[3])
7832 } else {
7833 panic("instruction VFMADDSS takes exactly 4 operands")
7834 }
7835 }
7836
7837 func __asm_proxy_VFMADDSUB132PD__(p *Program, v ...interface{}) *Instruction {
7838 switch len(v) {
7839 case 3 : return p.VFMADDSUB132PD(v[0], v[1], v[2])
7840 case 4 : return p.VFMADDSUB132PD(v[0], v[1], v[2], v[3])
7841 default : panic("instruction VFMADDSUB132PD takes 3 or 4 operands")
7842 }
7843 }
7844
7845 func __asm_proxy_VFMADDSUB132PS__(p *Program, v ...interface{}) *Instruction {
7846 switch len(v) {
7847 case 3 : return p.VFMADDSUB132PS(v[0], v[1], v[2])
7848 case 4 : return p.VFMADDSUB132PS(v[0], v[1], v[2], v[3])
7849 default : panic("instruction VFMADDSUB132PS takes 3 or 4 operands")
7850 }
7851 }
7852
7853 func __asm_proxy_VFMADDSUB213PD__(p *Program, v ...interface{}) *Instruction {
7854 switch len(v) {
7855 case 3 : return p.VFMADDSUB213PD(v[0], v[1], v[2])
7856 case 4 : return p.VFMADDSUB213PD(v[0], v[1], v[2], v[3])
7857 default : panic("instruction VFMADDSUB213PD takes 3 or 4 operands")
7858 }
7859 }
7860
7861 func __asm_proxy_VFMADDSUB213PS__(p *Program, v ...interface{}) *Instruction {
7862 switch len(v) {
7863 case 3 : return p.VFMADDSUB213PS(v[0], v[1], v[2])
7864 case 4 : return p.VFMADDSUB213PS(v[0], v[1], v[2], v[3])
7865 default : panic("instruction VFMADDSUB213PS takes 3 or 4 operands")
7866 }
7867 }
7868
7869 func __asm_proxy_VFMADDSUB231PD__(p *Program, v ...interface{}) *Instruction {
7870 switch len(v) {
7871 case 3 : return p.VFMADDSUB231PD(v[0], v[1], v[2])
7872 case 4 : return p.VFMADDSUB231PD(v[0], v[1], v[2], v[3])
7873 default : panic("instruction VFMADDSUB231PD takes 3 or 4 operands")
7874 }
7875 }
7876
7877 func __asm_proxy_VFMADDSUB231PS__(p *Program, v ...interface{}) *Instruction {
7878 switch len(v) {
7879 case 3 : return p.VFMADDSUB231PS(v[0], v[1], v[2])
7880 case 4 : return p.VFMADDSUB231PS(v[0], v[1], v[2], v[3])
7881 default : panic("instruction VFMADDSUB231PS takes 3 or 4 operands")
7882 }
7883 }
7884
7885 func __asm_proxy_VFMADDSUBPD__(p *Program, v ...interface{}) *Instruction {
7886 if len(v) == 4 {
7887 return p.VFMADDSUBPD(v[0], v[1], v[2], v[3])
7888 } else {
7889 panic("instruction VFMADDSUBPD takes exactly 4 operands")
7890 }
7891 }
7892
7893 func __asm_proxy_VFMADDSUBPS__(p *Program, v ...interface{}) *Instruction {
7894 if len(v) == 4 {
7895 return p.VFMADDSUBPS(v[0], v[1], v[2], v[3])
7896 } else {
7897 panic("instruction VFMADDSUBPS takes exactly 4 operands")
7898 }
7899 }
7900
7901 func __asm_proxy_VFMSUB132PD__(p *Program, v ...interface{}) *Instruction {
7902 switch len(v) {
7903 case 3 : return p.VFMSUB132PD(v[0], v[1], v[2])
7904 case 4 : return p.VFMSUB132PD(v[0], v[1], v[2], v[3])
7905 default : panic("instruction VFMSUB132PD takes 3 or 4 operands")
7906 }
7907 }
7908
7909 func __asm_proxy_VFMSUB132PS__(p *Program, v ...interface{}) *Instruction {
7910 switch len(v) {
7911 case 3 : return p.VFMSUB132PS(v[0], v[1], v[2])
7912 case 4 : return p.VFMSUB132PS(v[0], v[1], v[2], v[3])
7913 default : panic("instruction VFMSUB132PS takes 3 or 4 operands")
7914 }
7915 }
7916
7917 func __asm_proxy_VFMSUB132SD__(p *Program, v ...interface{}) *Instruction {
7918 switch len(v) {
7919 case 3 : return p.VFMSUB132SD(v[0], v[1], v[2])
7920 case 4 : return p.VFMSUB132SD(v[0], v[1], v[2], v[3])
7921 default : panic("instruction VFMSUB132SD takes 3 or 4 operands")
7922 }
7923 }
7924
7925 func __asm_proxy_VFMSUB132SS__(p *Program, v ...interface{}) *Instruction {
7926 switch len(v) {
7927 case 3 : return p.VFMSUB132SS(v[0], v[1], v[2])
7928 case 4 : return p.VFMSUB132SS(v[0], v[1], v[2], v[3])
7929 default : panic("instruction VFMSUB132SS takes 3 or 4 operands")
7930 }
7931 }
7932
7933 func __asm_proxy_VFMSUB213PD__(p *Program, v ...interface{}) *Instruction {
7934 switch len(v) {
7935 case 3 : return p.VFMSUB213PD(v[0], v[1], v[2])
7936 case 4 : return p.VFMSUB213PD(v[0], v[1], v[2], v[3])
7937 default : panic("instruction VFMSUB213PD takes 3 or 4 operands")
7938 }
7939 }
7940
7941 func __asm_proxy_VFMSUB213PS__(p *Program, v ...interface{}) *Instruction {
7942 switch len(v) {
7943 case 3 : return p.VFMSUB213PS(v[0], v[1], v[2])
7944 case 4 : return p.VFMSUB213PS(v[0], v[1], v[2], v[3])
7945 default : panic("instruction VFMSUB213PS takes 3 or 4 operands")
7946 }
7947 }
7948
7949 func __asm_proxy_VFMSUB213SD__(p *Program, v ...interface{}) *Instruction {
7950 switch len(v) {
7951 case 3 : return p.VFMSUB213SD(v[0], v[1], v[2])
7952 case 4 : return p.VFMSUB213SD(v[0], v[1], v[2], v[3])
7953 default : panic("instruction VFMSUB213SD takes 3 or 4 operands")
7954 }
7955 }
7956
7957 func __asm_proxy_VFMSUB213SS__(p *Program, v ...interface{}) *Instruction {
7958 switch len(v) {
7959 case 3 : return p.VFMSUB213SS(v[0], v[1], v[2])
7960 case 4 : return p.VFMSUB213SS(v[0], v[1], v[2], v[3])
7961 default : panic("instruction VFMSUB213SS takes 3 or 4 operands")
7962 }
7963 }
7964
7965 func __asm_proxy_VFMSUB231PD__(p *Program, v ...interface{}) *Instruction {
7966 switch len(v) {
7967 case 3 : return p.VFMSUB231PD(v[0], v[1], v[2])
7968 case 4 : return p.VFMSUB231PD(v[0], v[1], v[2], v[3])
7969 default : panic("instruction VFMSUB231PD takes 3 or 4 operands")
7970 }
7971 }
7972
7973 func __asm_proxy_VFMSUB231PS__(p *Program, v ...interface{}) *Instruction {
7974 switch len(v) {
7975 case 3 : return p.VFMSUB231PS(v[0], v[1], v[2])
7976 case 4 : return p.VFMSUB231PS(v[0], v[1], v[2], v[3])
7977 default : panic("instruction VFMSUB231PS takes 3 or 4 operands")
7978 }
7979 }
7980
7981 func __asm_proxy_VFMSUB231SD__(p *Program, v ...interface{}) *Instruction {
7982 switch len(v) {
7983 case 3 : return p.VFMSUB231SD(v[0], v[1], v[2])
7984 case 4 : return p.VFMSUB231SD(v[0], v[1], v[2], v[3])
7985 default : panic("instruction VFMSUB231SD takes 3 or 4 operands")
7986 }
7987 }
7988
7989 func __asm_proxy_VFMSUB231SS__(p *Program, v ...interface{}) *Instruction {
7990 switch len(v) {
7991 case 3 : return p.VFMSUB231SS(v[0], v[1], v[2])
7992 case 4 : return p.VFMSUB231SS(v[0], v[1], v[2], v[3])
7993 default : panic("instruction VFMSUB231SS takes 3 or 4 operands")
7994 }
7995 }
7996
7997 func __asm_proxy_VFMSUBADD132PD__(p *Program, v ...interface{}) *Instruction {
7998 switch len(v) {
7999 case 3 : return p.VFMSUBADD132PD(v[0], v[1], v[2])
8000 case 4 : return p.VFMSUBADD132PD(v[0], v[1], v[2], v[3])
8001 default : panic("instruction VFMSUBADD132PD takes 3 or 4 operands")
8002 }
8003 }
8004
8005 func __asm_proxy_VFMSUBADD132PS__(p *Program, v ...interface{}) *Instruction {
8006 switch len(v) {
8007 case 3 : return p.VFMSUBADD132PS(v[0], v[1], v[2])
8008 case 4 : return p.VFMSUBADD132PS(v[0], v[1], v[2], v[3])
8009 default : panic("instruction VFMSUBADD132PS takes 3 or 4 operands")
8010 }
8011 }
8012
8013 func __asm_proxy_VFMSUBADD213PD__(p *Program, v ...interface{}) *Instruction {
8014 switch len(v) {
8015 case 3 : return p.VFMSUBADD213PD(v[0], v[1], v[2])
8016 case 4 : return p.VFMSUBADD213PD(v[0], v[1], v[2], v[3])
8017 default : panic("instruction VFMSUBADD213PD takes 3 or 4 operands")
8018 }
8019 }
8020
8021 func __asm_proxy_VFMSUBADD213PS__(p *Program, v ...interface{}) *Instruction {
8022 switch len(v) {
8023 case 3 : return p.VFMSUBADD213PS(v[0], v[1], v[2])
8024 case 4 : return p.VFMSUBADD213PS(v[0], v[1], v[2], v[3])
8025 default : panic("instruction VFMSUBADD213PS takes 3 or 4 operands")
8026 }
8027 }
8028
8029 func __asm_proxy_VFMSUBADD231PD__(p *Program, v ...interface{}) *Instruction {
8030 switch len(v) {
8031 case 3 : return p.VFMSUBADD231PD(v[0], v[1], v[2])
8032 case 4 : return p.VFMSUBADD231PD(v[0], v[1], v[2], v[3])
8033 default : panic("instruction VFMSUBADD231PD takes 3 or 4 operands")
8034 }
8035 }
8036
8037 func __asm_proxy_VFMSUBADD231PS__(p *Program, v ...interface{}) *Instruction {
8038 switch len(v) {
8039 case 3 : return p.VFMSUBADD231PS(v[0], v[1], v[2])
8040 case 4 : return p.VFMSUBADD231PS(v[0], v[1], v[2], v[3])
8041 default : panic("instruction VFMSUBADD231PS takes 3 or 4 operands")
8042 }
8043 }
8044
8045 func __asm_proxy_VFMSUBADDPD__(p *Program, v ...interface{}) *Instruction {
8046 if len(v) == 4 {
8047 return p.VFMSUBADDPD(v[0], v[1], v[2], v[3])
8048 } else {
8049 panic("instruction VFMSUBADDPD takes exactly 4 operands")
8050 }
8051 }
8052
8053 func __asm_proxy_VFMSUBADDPS__(p *Program, v ...interface{}) *Instruction {
8054 if len(v) == 4 {
8055 return p.VFMSUBADDPS(v[0], v[1], v[2], v[3])
8056 } else {
8057 panic("instruction VFMSUBADDPS takes exactly 4 operands")
8058 }
8059 }
8060
8061 func __asm_proxy_VFMSUBPD__(p *Program, v ...interface{}) *Instruction {
8062 if len(v) == 4 {
8063 return p.VFMSUBPD(v[0], v[1], v[2], v[3])
8064 } else {
8065 panic("instruction VFMSUBPD takes exactly 4 operands")
8066 }
8067 }
8068
8069 func __asm_proxy_VFMSUBPS__(p *Program, v ...interface{}) *Instruction {
8070 if len(v) == 4 {
8071 return p.VFMSUBPS(v[0], v[1], v[2], v[3])
8072 } else {
8073 panic("instruction VFMSUBPS takes exactly 4 operands")
8074 }
8075 }
8076
8077 func __asm_proxy_VFMSUBSD__(p *Program, v ...interface{}) *Instruction {
8078 if len(v) == 4 {
8079 return p.VFMSUBSD(v[0], v[1], v[2], v[3])
8080 } else {
8081 panic("instruction VFMSUBSD takes exactly 4 operands")
8082 }
8083 }
8084
8085 func __asm_proxy_VFMSUBSS__(p *Program, v ...interface{}) *Instruction {
8086 if len(v) == 4 {
8087 return p.VFMSUBSS(v[0], v[1], v[2], v[3])
8088 } else {
8089 panic("instruction VFMSUBSS takes exactly 4 operands")
8090 }
8091 }
8092
8093 func __asm_proxy_VFNMADD132PD__(p *Program, v ...interface{}) *Instruction {
8094 switch len(v) {
8095 case 3 : return p.VFNMADD132PD(v[0], v[1], v[2])
8096 case 4 : return p.VFNMADD132PD(v[0], v[1], v[2], v[3])
8097 default : panic("instruction VFNMADD132PD takes 3 or 4 operands")
8098 }
8099 }
8100
8101 func __asm_proxy_VFNMADD132PS__(p *Program, v ...interface{}) *Instruction {
8102 switch len(v) {
8103 case 3 : return p.VFNMADD132PS(v[0], v[1], v[2])
8104 case 4 : return p.VFNMADD132PS(v[0], v[1], v[2], v[3])
8105 default : panic("instruction VFNMADD132PS takes 3 or 4 operands")
8106 }
8107 }
8108
8109 func __asm_proxy_VFNMADD132SD__(p *Program, v ...interface{}) *Instruction {
8110 switch len(v) {
8111 case 3 : return p.VFNMADD132SD(v[0], v[1], v[2])
8112 case 4 : return p.VFNMADD132SD(v[0], v[1], v[2], v[3])
8113 default : panic("instruction VFNMADD132SD takes 3 or 4 operands")
8114 }
8115 }
8116
8117 func __asm_proxy_VFNMADD132SS__(p *Program, v ...interface{}) *Instruction {
8118 switch len(v) {
8119 case 3 : return p.VFNMADD132SS(v[0], v[1], v[2])
8120 case 4 : return p.VFNMADD132SS(v[0], v[1], v[2], v[3])
8121 default : panic("instruction VFNMADD132SS takes 3 or 4 operands")
8122 }
8123 }
8124
8125 func __asm_proxy_VFNMADD213PD__(p *Program, v ...interface{}) *Instruction {
8126 switch len(v) {
8127 case 3 : return p.VFNMADD213PD(v[0], v[1], v[2])
8128 case 4 : return p.VFNMADD213PD(v[0], v[1], v[2], v[3])
8129 default : panic("instruction VFNMADD213PD takes 3 or 4 operands")
8130 }
8131 }
8132
8133 func __asm_proxy_VFNMADD213PS__(p *Program, v ...interface{}) *Instruction {
8134 switch len(v) {
8135 case 3 : return p.VFNMADD213PS(v[0], v[1], v[2])
8136 case 4 : return p.VFNMADD213PS(v[0], v[1], v[2], v[3])
8137 default : panic("instruction VFNMADD213PS takes 3 or 4 operands")
8138 }
8139 }
8140
8141 func __asm_proxy_VFNMADD213SD__(p *Program, v ...interface{}) *Instruction {
8142 switch len(v) {
8143 case 3 : return p.VFNMADD213SD(v[0], v[1], v[2])
8144 case 4 : return p.VFNMADD213SD(v[0], v[1], v[2], v[3])
8145 default : panic("instruction VFNMADD213SD takes 3 or 4 operands")
8146 }
8147 }
8148
8149 func __asm_proxy_VFNMADD213SS__(p *Program, v ...interface{}) *Instruction {
8150 switch len(v) {
8151 case 3 : return p.VFNMADD213SS(v[0], v[1], v[2])
8152 case 4 : return p.VFNMADD213SS(v[0], v[1], v[2], v[3])
8153 default : panic("instruction VFNMADD213SS takes 3 or 4 operands")
8154 }
8155 }
8156
8157 func __asm_proxy_VFNMADD231PD__(p *Program, v ...interface{}) *Instruction {
8158 switch len(v) {
8159 case 3 : return p.VFNMADD231PD(v[0], v[1], v[2])
8160 case 4 : return p.VFNMADD231PD(v[0], v[1], v[2], v[3])
8161 default : panic("instruction VFNMADD231PD takes 3 or 4 operands")
8162 }
8163 }
8164
8165 func __asm_proxy_VFNMADD231PS__(p *Program, v ...interface{}) *Instruction {
8166 switch len(v) {
8167 case 3 : return p.VFNMADD231PS(v[0], v[1], v[2])
8168 case 4 : return p.VFNMADD231PS(v[0], v[1], v[2], v[3])
8169 default : panic("instruction VFNMADD231PS takes 3 or 4 operands")
8170 }
8171 }
8172
8173 func __asm_proxy_VFNMADD231SD__(p *Program, v ...interface{}) *Instruction {
8174 switch len(v) {
8175 case 3 : return p.VFNMADD231SD(v[0], v[1], v[2])
8176 case 4 : return p.VFNMADD231SD(v[0], v[1], v[2], v[3])
8177 default : panic("instruction VFNMADD231SD takes 3 or 4 operands")
8178 }
8179 }
8180
8181 func __asm_proxy_VFNMADD231SS__(p *Program, v ...interface{}) *Instruction {
8182 switch len(v) {
8183 case 3 : return p.VFNMADD231SS(v[0], v[1], v[2])
8184 case 4 : return p.VFNMADD231SS(v[0], v[1], v[2], v[3])
8185 default : panic("instruction VFNMADD231SS takes 3 or 4 operands")
8186 }
8187 }
8188
8189 func __asm_proxy_VFNMADDPD__(p *Program, v ...interface{}) *Instruction {
8190 if len(v) == 4 {
8191 return p.VFNMADDPD(v[0], v[1], v[2], v[3])
8192 } else {
8193 panic("instruction VFNMADDPD takes exactly 4 operands")
8194 }
8195 }
8196
8197 func __asm_proxy_VFNMADDPS__(p *Program, v ...interface{}) *Instruction {
8198 if len(v) == 4 {
8199 return p.VFNMADDPS(v[0], v[1], v[2], v[3])
8200 } else {
8201 panic("instruction VFNMADDPS takes exactly 4 operands")
8202 }
8203 }
8204
8205 func __asm_proxy_VFNMADDSD__(p *Program, v ...interface{}) *Instruction {
8206 if len(v) == 4 {
8207 return p.VFNMADDSD(v[0], v[1], v[2], v[3])
8208 } else {
8209 panic("instruction VFNMADDSD takes exactly 4 operands")
8210 }
8211 }
8212
8213 func __asm_proxy_VFNMADDSS__(p *Program, v ...interface{}) *Instruction {
8214 if len(v) == 4 {
8215 return p.VFNMADDSS(v[0], v[1], v[2], v[3])
8216 } else {
8217 panic("instruction VFNMADDSS takes exactly 4 operands")
8218 }
8219 }
8220
8221 func __asm_proxy_VFNMSUB132PD__(p *Program, v ...interface{}) *Instruction {
8222 switch len(v) {
8223 case 3 : return p.VFNMSUB132PD(v[0], v[1], v[2])
8224 case 4 : return p.VFNMSUB132PD(v[0], v[1], v[2], v[3])
8225 default : panic("instruction VFNMSUB132PD takes 3 or 4 operands")
8226 }
8227 }
8228
8229 func __asm_proxy_VFNMSUB132PS__(p *Program, v ...interface{}) *Instruction {
8230 switch len(v) {
8231 case 3 : return p.VFNMSUB132PS(v[0], v[1], v[2])
8232 case 4 : return p.VFNMSUB132PS(v[0], v[1], v[2], v[3])
8233 default : panic("instruction VFNMSUB132PS takes 3 or 4 operands")
8234 }
8235 }
8236
8237 func __asm_proxy_VFNMSUB132SD__(p *Program, v ...interface{}) *Instruction {
8238 switch len(v) {
8239 case 3 : return p.VFNMSUB132SD(v[0], v[1], v[2])
8240 case 4 : return p.VFNMSUB132SD(v[0], v[1], v[2], v[3])
8241 default : panic("instruction VFNMSUB132SD takes 3 or 4 operands")
8242 }
8243 }
8244
8245 func __asm_proxy_VFNMSUB132SS__(p *Program, v ...interface{}) *Instruction {
8246 switch len(v) {
8247 case 3 : return p.VFNMSUB132SS(v[0], v[1], v[2])
8248 case 4 : return p.VFNMSUB132SS(v[0], v[1], v[2], v[3])
8249 default : panic("instruction VFNMSUB132SS takes 3 or 4 operands")
8250 }
8251 }
8252
8253 func __asm_proxy_VFNMSUB213PD__(p *Program, v ...interface{}) *Instruction {
8254 switch len(v) {
8255 case 3 : return p.VFNMSUB213PD(v[0], v[1], v[2])
8256 case 4 : return p.VFNMSUB213PD(v[0], v[1], v[2], v[3])
8257 default : panic("instruction VFNMSUB213PD takes 3 or 4 operands")
8258 }
8259 }
8260
8261 func __asm_proxy_VFNMSUB213PS__(p *Program, v ...interface{}) *Instruction {
8262 switch len(v) {
8263 case 3 : return p.VFNMSUB213PS(v[0], v[1], v[2])
8264 case 4 : return p.VFNMSUB213PS(v[0], v[1], v[2], v[3])
8265 default : panic("instruction VFNMSUB213PS takes 3 or 4 operands")
8266 }
8267 }
8268
8269 func __asm_proxy_VFNMSUB213SD__(p *Program, v ...interface{}) *Instruction {
8270 switch len(v) {
8271 case 3 : return p.VFNMSUB213SD(v[0], v[1], v[2])
8272 case 4 : return p.VFNMSUB213SD(v[0], v[1], v[2], v[3])
8273 default : panic("instruction VFNMSUB213SD takes 3 or 4 operands")
8274 }
8275 }
8276
8277 func __asm_proxy_VFNMSUB213SS__(p *Program, v ...interface{}) *Instruction {
8278 switch len(v) {
8279 case 3 : return p.VFNMSUB213SS(v[0], v[1], v[2])
8280 case 4 : return p.VFNMSUB213SS(v[0], v[1], v[2], v[3])
8281 default : panic("instruction VFNMSUB213SS takes 3 or 4 operands")
8282 }
8283 }
8284
8285 func __asm_proxy_VFNMSUB231PD__(p *Program, v ...interface{}) *Instruction {
8286 switch len(v) {
8287 case 3 : return p.VFNMSUB231PD(v[0], v[1], v[2])
8288 case 4 : return p.VFNMSUB231PD(v[0], v[1], v[2], v[3])
8289 default : panic("instruction VFNMSUB231PD takes 3 or 4 operands")
8290 }
8291 }
8292
8293 func __asm_proxy_VFNMSUB231PS__(p *Program, v ...interface{}) *Instruction {
8294 switch len(v) {
8295 case 3 : return p.VFNMSUB231PS(v[0], v[1], v[2])
8296 case 4 : return p.VFNMSUB231PS(v[0], v[1], v[2], v[3])
8297 default : panic("instruction VFNMSUB231PS takes 3 or 4 operands")
8298 }
8299 }
8300
8301 func __asm_proxy_VFNMSUB231SD__(p *Program, v ...interface{}) *Instruction {
8302 switch len(v) {
8303 case 3 : return p.VFNMSUB231SD(v[0], v[1], v[2])
8304 case 4 : return p.VFNMSUB231SD(v[0], v[1], v[2], v[3])
8305 default : panic("instruction VFNMSUB231SD takes 3 or 4 operands")
8306 }
8307 }
8308
8309 func __asm_proxy_VFNMSUB231SS__(p *Program, v ...interface{}) *Instruction {
8310 switch len(v) {
8311 case 3 : return p.VFNMSUB231SS(v[0], v[1], v[2])
8312 case 4 : return p.VFNMSUB231SS(v[0], v[1], v[2], v[3])
8313 default : panic("instruction VFNMSUB231SS takes 3 or 4 operands")
8314 }
8315 }
8316
8317 func __asm_proxy_VFNMSUBPD__(p *Program, v ...interface{}) *Instruction {
8318 if len(v) == 4 {
8319 return p.VFNMSUBPD(v[0], v[1], v[2], v[3])
8320 } else {
8321 panic("instruction VFNMSUBPD takes exactly 4 operands")
8322 }
8323 }
8324
8325 func __asm_proxy_VFNMSUBPS__(p *Program, v ...interface{}) *Instruction {
8326 if len(v) == 4 {
8327 return p.VFNMSUBPS(v[0], v[1], v[2], v[3])
8328 } else {
8329 panic("instruction VFNMSUBPS takes exactly 4 operands")
8330 }
8331 }
8332
8333 func __asm_proxy_VFNMSUBSD__(p *Program, v ...interface{}) *Instruction {
8334 if len(v) == 4 {
8335 return p.VFNMSUBSD(v[0], v[1], v[2], v[3])
8336 } else {
8337 panic("instruction VFNMSUBSD takes exactly 4 operands")
8338 }
8339 }
8340
8341 func __asm_proxy_VFNMSUBSS__(p *Program, v ...interface{}) *Instruction {
8342 if len(v) == 4 {
8343 return p.VFNMSUBSS(v[0], v[1], v[2], v[3])
8344 } else {
8345 panic("instruction VFNMSUBSS takes exactly 4 operands")
8346 }
8347 }
8348
8349 func __asm_proxy_VFPCLASSPD__(p *Program, v ...interface{}) *Instruction {
8350 if len(v) == 3 {
8351 return p.VFPCLASSPD(v[0], v[1], v[2])
8352 } else {
8353 panic("instruction VFPCLASSPD takes exactly 3 operands")
8354 }
8355 }
8356
8357 func __asm_proxy_VFPCLASSPS__(p *Program, v ...interface{}) *Instruction {
8358 if len(v) == 3 {
8359 return p.VFPCLASSPS(v[0], v[1], v[2])
8360 } else {
8361 panic("instruction VFPCLASSPS takes exactly 3 operands")
8362 }
8363 }
8364
8365 func __asm_proxy_VFPCLASSSD__(p *Program, v ...interface{}) *Instruction {
8366 if len(v) == 3 {
8367 return p.VFPCLASSSD(v[0], v[1], v[2])
8368 } else {
8369 panic("instruction VFPCLASSSD takes exactly 3 operands")
8370 }
8371 }
8372
8373 func __asm_proxy_VFPCLASSSS__(p *Program, v ...interface{}) *Instruction {
8374 if len(v) == 3 {
8375 return p.VFPCLASSSS(v[0], v[1], v[2])
8376 } else {
8377 panic("instruction VFPCLASSSS takes exactly 3 operands")
8378 }
8379 }
8380
8381 func __asm_proxy_VFRCZPD__(p *Program, v ...interface{}) *Instruction {
8382 if len(v) == 2 {
8383 return p.VFRCZPD(v[0], v[1])
8384 } else {
8385 panic("instruction VFRCZPD takes exactly 2 operands")
8386 }
8387 }
8388
8389 func __asm_proxy_VFRCZPS__(p *Program, v ...interface{}) *Instruction {
8390 if len(v) == 2 {
8391 return p.VFRCZPS(v[0], v[1])
8392 } else {
8393 panic("instruction VFRCZPS takes exactly 2 operands")
8394 }
8395 }
8396
8397 func __asm_proxy_VFRCZSD__(p *Program, v ...interface{}) *Instruction {
8398 if len(v) == 2 {
8399 return p.VFRCZSD(v[0], v[1])
8400 } else {
8401 panic("instruction VFRCZSD takes exactly 2 operands")
8402 }
8403 }
8404
8405 func __asm_proxy_VFRCZSS__(p *Program, v ...interface{}) *Instruction {
8406 if len(v) == 2 {
8407 return p.VFRCZSS(v[0], v[1])
8408 } else {
8409 panic("instruction VFRCZSS takes exactly 2 operands")
8410 }
8411 }
8412
8413 func __asm_proxy_VGATHERDPD__(p *Program, v ...interface{}) *Instruction {
8414 switch len(v) {
8415 case 2 : return p.VGATHERDPD(v[0], v[1])
8416 case 3 : return p.VGATHERDPD(v[0], v[1], v[2])
8417 default : panic("instruction VGATHERDPD takes 2 or 3 operands")
8418 }
8419 }
8420
8421 func __asm_proxy_VGATHERDPS__(p *Program, v ...interface{}) *Instruction {
8422 switch len(v) {
8423 case 2 : return p.VGATHERDPS(v[0], v[1])
8424 case 3 : return p.VGATHERDPS(v[0], v[1], v[2])
8425 default : panic("instruction VGATHERDPS takes 2 or 3 operands")
8426 }
8427 }
8428
8429 func __asm_proxy_VGATHERPF0DPD__(p *Program, v ...interface{}) *Instruction {
8430 if len(v) == 1 {
8431 return p.VGATHERPF0DPD(v[0])
8432 } else {
8433 panic("instruction VGATHERPF0DPD takes exactly 1 operand")
8434 }
8435 }
8436
8437 func __asm_proxy_VGATHERPF0DPS__(p *Program, v ...interface{}) *Instruction {
8438 if len(v) == 1 {
8439 return p.VGATHERPF0DPS(v[0])
8440 } else {
8441 panic("instruction VGATHERPF0DPS takes exactly 1 operand")
8442 }
8443 }
8444
8445 func __asm_proxy_VGATHERPF0QPD__(p *Program, v ...interface{}) *Instruction {
8446 if len(v) == 1 {
8447 return p.VGATHERPF0QPD(v[0])
8448 } else {
8449 panic("instruction VGATHERPF0QPD takes exactly 1 operand")
8450 }
8451 }
8452
8453 func __asm_proxy_VGATHERPF0QPS__(p *Program, v ...interface{}) *Instruction {
8454 if len(v) == 1 {
8455 return p.VGATHERPF0QPS(v[0])
8456 } else {
8457 panic("instruction VGATHERPF0QPS takes exactly 1 operand")
8458 }
8459 }
8460
8461 func __asm_proxy_VGATHERPF1DPD__(p *Program, v ...interface{}) *Instruction {
8462 if len(v) == 1 {
8463 return p.VGATHERPF1DPD(v[0])
8464 } else {
8465 panic("instruction VGATHERPF1DPD takes exactly 1 operand")
8466 }
8467 }
8468
8469 func __asm_proxy_VGATHERPF1DPS__(p *Program, v ...interface{}) *Instruction {
8470 if len(v) == 1 {
8471 return p.VGATHERPF1DPS(v[0])
8472 } else {
8473 panic("instruction VGATHERPF1DPS takes exactly 1 operand")
8474 }
8475 }
8476
8477 func __asm_proxy_VGATHERPF1QPD__(p *Program, v ...interface{}) *Instruction {
8478 if len(v) == 1 {
8479 return p.VGATHERPF1QPD(v[0])
8480 } else {
8481 panic("instruction VGATHERPF1QPD takes exactly 1 operand")
8482 }
8483 }
8484
8485 func __asm_proxy_VGATHERPF1QPS__(p *Program, v ...interface{}) *Instruction {
8486 if len(v) == 1 {
8487 return p.VGATHERPF1QPS(v[0])
8488 } else {
8489 panic("instruction VGATHERPF1QPS takes exactly 1 operand")
8490 }
8491 }
8492
8493 func __asm_proxy_VGATHERQPD__(p *Program, v ...interface{}) *Instruction {
8494 switch len(v) {
8495 case 2 : return p.VGATHERQPD(v[0], v[1])
8496 case 3 : return p.VGATHERQPD(v[0], v[1], v[2])
8497 default : panic("instruction VGATHERQPD takes 2 or 3 operands")
8498 }
8499 }
8500
8501 func __asm_proxy_VGATHERQPS__(p *Program, v ...interface{}) *Instruction {
8502 switch len(v) {
8503 case 2 : return p.VGATHERQPS(v[0], v[1])
8504 case 3 : return p.VGATHERQPS(v[0], v[1], v[2])
8505 default : panic("instruction VGATHERQPS takes 2 or 3 operands")
8506 }
8507 }
8508
8509 func __asm_proxy_VGETEXPPD__(p *Program, v ...interface{}) *Instruction {
8510 switch len(v) {
8511 case 2 : return p.VGETEXPPD(v[0], v[1])
8512 case 3 : return p.VGETEXPPD(v[0], v[1], v[2])
8513 default : panic("instruction VGETEXPPD takes 2 or 3 operands")
8514 }
8515 }
8516
8517 func __asm_proxy_VGETEXPPS__(p *Program, v ...interface{}) *Instruction {
8518 switch len(v) {
8519 case 2 : return p.VGETEXPPS(v[0], v[1])
8520 case 3 : return p.VGETEXPPS(v[0], v[1], v[2])
8521 default : panic("instruction VGETEXPPS takes 2 or 3 operands")
8522 }
8523 }
8524
8525 func __asm_proxy_VGETEXPSD__(p *Program, v ...interface{}) *Instruction {
8526 switch len(v) {
8527 case 3 : return p.VGETEXPSD(v[0], v[1], v[2])
8528 case 4 : return p.VGETEXPSD(v[0], v[1], v[2], v[3])
8529 default : panic("instruction VGETEXPSD takes 3 or 4 operands")
8530 }
8531 }
8532
8533 func __asm_proxy_VGETEXPSS__(p *Program, v ...interface{}) *Instruction {
8534 switch len(v) {
8535 case 3 : return p.VGETEXPSS(v[0], v[1], v[2])
8536 case 4 : return p.VGETEXPSS(v[0], v[1], v[2], v[3])
8537 default : panic("instruction VGETEXPSS takes 3 or 4 operands")
8538 }
8539 }
8540
8541 func __asm_proxy_VGETMANTPD__(p *Program, v ...interface{}) *Instruction {
8542 switch len(v) {
8543 case 3 : return p.VGETMANTPD(v[0], v[1], v[2])
8544 case 4 : return p.VGETMANTPD(v[0], v[1], v[2], v[3])
8545 default : panic("instruction VGETMANTPD takes 3 or 4 operands")
8546 }
8547 }
8548
8549 func __asm_proxy_VGETMANTPS__(p *Program, v ...interface{}) *Instruction {
8550 switch len(v) {
8551 case 3 : return p.VGETMANTPS(v[0], v[1], v[2])
8552 case 4 : return p.VGETMANTPS(v[0], v[1], v[2], v[3])
8553 default : panic("instruction VGETMANTPS takes 3 or 4 operands")
8554 }
8555 }
8556
8557 func __asm_proxy_VGETMANTSD__(p *Program, v ...interface{}) *Instruction {
8558 switch len(v) {
8559 case 4 : return p.VGETMANTSD(v[0], v[1], v[2], v[3])
8560 case 5 : return p.VGETMANTSD(v[0], v[1], v[2], v[3], v[4])
8561 default : panic("instruction VGETMANTSD takes 4 or 5 operands")
8562 }
8563 }
8564
8565 func __asm_proxy_VGETMANTSS__(p *Program, v ...interface{}) *Instruction {
8566 switch len(v) {
8567 case 4 : return p.VGETMANTSS(v[0], v[1], v[2], v[3])
8568 case 5 : return p.VGETMANTSS(v[0], v[1], v[2], v[3], v[4])
8569 default : panic("instruction VGETMANTSS takes 4 or 5 operands")
8570 }
8571 }
8572
8573 func __asm_proxy_VHADDPD__(p *Program, v ...interface{}) *Instruction {
8574 if len(v) == 3 {
8575 return p.VHADDPD(v[0], v[1], v[2])
8576 } else {
8577 panic("instruction VHADDPD takes exactly 3 operands")
8578 }
8579 }
8580
8581 func __asm_proxy_VHADDPS__(p *Program, v ...interface{}) *Instruction {
8582 if len(v) == 3 {
8583 return p.VHADDPS(v[0], v[1], v[2])
8584 } else {
8585 panic("instruction VHADDPS takes exactly 3 operands")
8586 }
8587 }
8588
8589 func __asm_proxy_VHSUBPD__(p *Program, v ...interface{}) *Instruction {
8590 if len(v) == 3 {
8591 return p.VHSUBPD(v[0], v[1], v[2])
8592 } else {
8593 panic("instruction VHSUBPD takes exactly 3 operands")
8594 }
8595 }
8596
8597 func __asm_proxy_VHSUBPS__(p *Program, v ...interface{}) *Instruction {
8598 if len(v) == 3 {
8599 return p.VHSUBPS(v[0], v[1], v[2])
8600 } else {
8601 panic("instruction VHSUBPS takes exactly 3 operands")
8602 }
8603 }
8604
8605 func __asm_proxy_VINSERTF128__(p *Program, v ...interface{}) *Instruction {
8606 if len(v) == 4 {
8607 return p.VINSERTF128(v[0], v[1], v[2], v[3])
8608 } else {
8609 panic("instruction VINSERTF128 takes exactly 4 operands")
8610 }
8611 }
8612
8613 func __asm_proxy_VINSERTF32X4__(p *Program, v ...interface{}) *Instruction {
8614 if len(v) == 4 {
8615 return p.VINSERTF32X4(v[0], v[1], v[2], v[3])
8616 } else {
8617 panic("instruction VINSERTF32X4 takes exactly 4 operands")
8618 }
8619 }
8620
8621 func __asm_proxy_VINSERTF32X8__(p *Program, v ...interface{}) *Instruction {
8622 if len(v) == 4 {
8623 return p.VINSERTF32X8(v[0], v[1], v[2], v[3])
8624 } else {
8625 panic("instruction VINSERTF32X8 takes exactly 4 operands")
8626 }
8627 }
8628
8629 func __asm_proxy_VINSERTF64X2__(p *Program, v ...interface{}) *Instruction {
8630 if len(v) == 4 {
8631 return p.VINSERTF64X2(v[0], v[1], v[2], v[3])
8632 } else {
8633 panic("instruction VINSERTF64X2 takes exactly 4 operands")
8634 }
8635 }
8636
8637 func __asm_proxy_VINSERTF64X4__(p *Program, v ...interface{}) *Instruction {
8638 if len(v) == 4 {
8639 return p.VINSERTF64X4(v[0], v[1], v[2], v[3])
8640 } else {
8641 panic("instruction VINSERTF64X4 takes exactly 4 operands")
8642 }
8643 }
8644
8645 func __asm_proxy_VINSERTI128__(p *Program, v ...interface{}) *Instruction {
8646 if len(v) == 4 {
8647 return p.VINSERTI128(v[0], v[1], v[2], v[3])
8648 } else {
8649 panic("instruction VINSERTI128 takes exactly 4 operands")
8650 }
8651 }
8652
8653 func __asm_proxy_VINSERTI32X4__(p *Program, v ...interface{}) *Instruction {
8654 if len(v) == 4 {
8655 return p.VINSERTI32X4(v[0], v[1], v[2], v[3])
8656 } else {
8657 panic("instruction VINSERTI32X4 takes exactly 4 operands")
8658 }
8659 }
8660
8661 func __asm_proxy_VINSERTI32X8__(p *Program, v ...interface{}) *Instruction {
8662 if len(v) == 4 {
8663 return p.VINSERTI32X8(v[0], v[1], v[2], v[3])
8664 } else {
8665 panic("instruction VINSERTI32X8 takes exactly 4 operands")
8666 }
8667 }
8668
8669 func __asm_proxy_VINSERTI64X2__(p *Program, v ...interface{}) *Instruction {
8670 if len(v) == 4 {
8671 return p.VINSERTI64X2(v[0], v[1], v[2], v[3])
8672 } else {
8673 panic("instruction VINSERTI64X2 takes exactly 4 operands")
8674 }
8675 }
8676
8677 func __asm_proxy_VINSERTI64X4__(p *Program, v ...interface{}) *Instruction {
8678 if len(v) == 4 {
8679 return p.VINSERTI64X4(v[0], v[1], v[2], v[3])
8680 } else {
8681 panic("instruction VINSERTI64X4 takes exactly 4 operands")
8682 }
8683 }
8684
8685 func __asm_proxy_VINSERTPS__(p *Program, v ...interface{}) *Instruction {
8686 if len(v) == 4 {
8687 return p.VINSERTPS(v[0], v[1], v[2], v[3])
8688 } else {
8689 panic("instruction VINSERTPS takes exactly 4 operands")
8690 }
8691 }
8692
8693 func __asm_proxy_VLDDQU__(p *Program, v ...interface{}) *Instruction {
8694 if len(v) == 2 {
8695 return p.VLDDQU(v[0], v[1])
8696 } else {
8697 panic("instruction VLDDQU takes exactly 2 operands")
8698 }
8699 }
8700
8701 func __asm_proxy_VLDMXCSR__(p *Program, v ...interface{}) *Instruction {
8702 if len(v) == 1 {
8703 return p.VLDMXCSR(v[0])
8704 } else {
8705 panic("instruction VLDMXCSR takes exactly 1 operand")
8706 }
8707 }
8708
8709 func __asm_proxy_VMASKMOVDQU__(p *Program, v ...interface{}) *Instruction {
8710 if len(v) == 2 {
8711 return p.VMASKMOVDQU(v[0], v[1])
8712 } else {
8713 panic("instruction VMASKMOVDQU takes exactly 2 operands")
8714 }
8715 }
8716
8717 func __asm_proxy_VMASKMOVPD__(p *Program, v ...interface{}) *Instruction {
8718 if len(v) == 3 {
8719 return p.VMASKMOVPD(v[0], v[1], v[2])
8720 } else {
8721 panic("instruction VMASKMOVPD takes exactly 3 operands")
8722 }
8723 }
8724
8725 func __asm_proxy_VMASKMOVPS__(p *Program, v ...interface{}) *Instruction {
8726 if len(v) == 3 {
8727 return p.VMASKMOVPS(v[0], v[1], v[2])
8728 } else {
8729 panic("instruction VMASKMOVPS takes exactly 3 operands")
8730 }
8731 }
8732
8733 func __asm_proxy_VMAXPD__(p *Program, v ...interface{}) *Instruction {
8734 switch len(v) {
8735 case 3 : return p.VMAXPD(v[0], v[1], v[2])
8736 case 4 : return p.VMAXPD(v[0], v[1], v[2], v[3])
8737 default : panic("instruction VMAXPD takes 3 or 4 operands")
8738 }
8739 }
8740
8741 func __asm_proxy_VMAXPS__(p *Program, v ...interface{}) *Instruction {
8742 switch len(v) {
8743 case 3 : return p.VMAXPS(v[0], v[1], v[2])
8744 case 4 : return p.VMAXPS(v[0], v[1], v[2], v[3])
8745 default : panic("instruction VMAXPS takes 3 or 4 operands")
8746 }
8747 }
8748
8749 func __asm_proxy_VMAXSD__(p *Program, v ...interface{}) *Instruction {
8750 switch len(v) {
8751 case 3 : return p.VMAXSD(v[0], v[1], v[2])
8752 case 4 : return p.VMAXSD(v[0], v[1], v[2], v[3])
8753 default : panic("instruction VMAXSD takes 3 or 4 operands")
8754 }
8755 }
8756
8757 func __asm_proxy_VMAXSS__(p *Program, v ...interface{}) *Instruction {
8758 switch len(v) {
8759 case 3 : return p.VMAXSS(v[0], v[1], v[2])
8760 case 4 : return p.VMAXSS(v[0], v[1], v[2], v[3])
8761 default : panic("instruction VMAXSS takes 3 or 4 operands")
8762 }
8763 }
8764
8765 func __asm_proxy_VMINPD__(p *Program, v ...interface{}) *Instruction {
8766 switch len(v) {
8767 case 3 : return p.VMINPD(v[0], v[1], v[2])
8768 case 4 : return p.VMINPD(v[0], v[1], v[2], v[3])
8769 default : panic("instruction VMINPD takes 3 or 4 operands")
8770 }
8771 }
8772
8773 func __asm_proxy_VMINPS__(p *Program, v ...interface{}) *Instruction {
8774 switch len(v) {
8775 case 3 : return p.VMINPS(v[0], v[1], v[2])
8776 case 4 : return p.VMINPS(v[0], v[1], v[2], v[3])
8777 default : panic("instruction VMINPS takes 3 or 4 operands")
8778 }
8779 }
8780
8781 func __asm_proxy_VMINSD__(p *Program, v ...interface{}) *Instruction {
8782 switch len(v) {
8783 case 3 : return p.VMINSD(v[0], v[1], v[2])
8784 case 4 : return p.VMINSD(v[0], v[1], v[2], v[3])
8785 default : panic("instruction VMINSD takes 3 or 4 operands")
8786 }
8787 }
8788
8789 func __asm_proxy_VMINSS__(p *Program, v ...interface{}) *Instruction {
8790 switch len(v) {
8791 case 3 : return p.VMINSS(v[0], v[1], v[2])
8792 case 4 : return p.VMINSS(v[0], v[1], v[2], v[3])
8793 default : panic("instruction VMINSS takes 3 or 4 operands")
8794 }
8795 }
8796
8797 func __asm_proxy_VMOVAPD__(p *Program, v ...interface{}) *Instruction {
8798 if len(v) == 2 {
8799 return p.VMOVAPD(v[0], v[1])
8800 } else {
8801 panic("instruction VMOVAPD takes exactly 2 operands")
8802 }
8803 }
8804
8805 func __asm_proxy_VMOVAPS__(p *Program, v ...interface{}) *Instruction {
8806 if len(v) == 2 {
8807 return p.VMOVAPS(v[0], v[1])
8808 } else {
8809 panic("instruction VMOVAPS takes exactly 2 operands")
8810 }
8811 }
8812
8813 func __asm_proxy_VMOVD__(p *Program, v ...interface{}) *Instruction {
8814 if len(v) == 2 {
8815 return p.VMOVD(v[0], v[1])
8816 } else {
8817 panic("instruction VMOVD takes exactly 2 operands")
8818 }
8819 }
8820
8821 func __asm_proxy_VMOVDDUP__(p *Program, v ...interface{}) *Instruction {
8822 if len(v) == 2 {
8823 return p.VMOVDDUP(v[0], v[1])
8824 } else {
8825 panic("instruction VMOVDDUP takes exactly 2 operands")
8826 }
8827 }
8828
8829 func __asm_proxy_VMOVDQA__(p *Program, v ...interface{}) *Instruction {
8830 if len(v) == 2 {
8831 return p.VMOVDQA(v[0], v[1])
8832 } else {
8833 panic("instruction VMOVDQA takes exactly 2 operands")
8834 }
8835 }
8836
8837 func __asm_proxy_VMOVDQA32__(p *Program, v ...interface{}) *Instruction {
8838 if len(v) == 2 {
8839 return p.VMOVDQA32(v[0], v[1])
8840 } else {
8841 panic("instruction VMOVDQA32 takes exactly 2 operands")
8842 }
8843 }
8844
8845 func __asm_proxy_VMOVDQA64__(p *Program, v ...interface{}) *Instruction {
8846 if len(v) == 2 {
8847 return p.VMOVDQA64(v[0], v[1])
8848 } else {
8849 panic("instruction VMOVDQA64 takes exactly 2 operands")
8850 }
8851 }
8852
8853 func __asm_proxy_VMOVDQU__(p *Program, v ...interface{}) *Instruction {
8854 if len(v) == 2 {
8855 return p.VMOVDQU(v[0], v[1])
8856 } else {
8857 panic("instruction VMOVDQU takes exactly 2 operands")
8858 }
8859 }
8860
8861 func __asm_proxy_VMOVDQU16__(p *Program, v ...interface{}) *Instruction {
8862 if len(v) == 2 {
8863 return p.VMOVDQU16(v[0], v[1])
8864 } else {
8865 panic("instruction VMOVDQU16 takes exactly 2 operands")
8866 }
8867 }
8868
8869 func __asm_proxy_VMOVDQU32__(p *Program, v ...interface{}) *Instruction {
8870 if len(v) == 2 {
8871 return p.VMOVDQU32(v[0], v[1])
8872 } else {
8873 panic("instruction VMOVDQU32 takes exactly 2 operands")
8874 }
8875 }
8876
8877 func __asm_proxy_VMOVDQU64__(p *Program, v ...interface{}) *Instruction {
8878 if len(v) == 2 {
8879 return p.VMOVDQU64(v[0], v[1])
8880 } else {
8881 panic("instruction VMOVDQU64 takes exactly 2 operands")
8882 }
8883 }
8884
8885 func __asm_proxy_VMOVDQU8__(p *Program, v ...interface{}) *Instruction {
8886 if len(v) == 2 {
8887 return p.VMOVDQU8(v[0], v[1])
8888 } else {
8889 panic("instruction VMOVDQU8 takes exactly 2 operands")
8890 }
8891 }
8892
8893 func __asm_proxy_VMOVHLPS__(p *Program, v ...interface{}) *Instruction {
8894 if len(v) == 3 {
8895 return p.VMOVHLPS(v[0], v[1], v[2])
8896 } else {
8897 panic("instruction VMOVHLPS takes exactly 3 operands")
8898 }
8899 }
8900
8901 func __asm_proxy_VMOVHPD__(p *Program, v ...interface{}) *Instruction {
8902 switch len(v) {
8903 case 2 : return p.VMOVHPD(v[0], v[1])
8904 case 3 : return p.VMOVHPD(v[0], v[1], v[2])
8905 default : panic("instruction VMOVHPD takes 2 or 3 operands")
8906 }
8907 }
8908
8909 func __asm_proxy_VMOVHPS__(p *Program, v ...interface{}) *Instruction {
8910 switch len(v) {
8911 case 2 : return p.VMOVHPS(v[0], v[1])
8912 case 3 : return p.VMOVHPS(v[0], v[1], v[2])
8913 default : panic("instruction VMOVHPS takes 2 or 3 operands")
8914 }
8915 }
8916
8917 func __asm_proxy_VMOVLHPS__(p *Program, v ...interface{}) *Instruction {
8918 if len(v) == 3 {
8919 return p.VMOVLHPS(v[0], v[1], v[2])
8920 } else {
8921 panic("instruction VMOVLHPS takes exactly 3 operands")
8922 }
8923 }
8924
8925 func __asm_proxy_VMOVLPD__(p *Program, v ...interface{}) *Instruction {
8926 switch len(v) {
8927 case 2 : return p.VMOVLPD(v[0], v[1])
8928 case 3 : return p.VMOVLPD(v[0], v[1], v[2])
8929 default : panic("instruction VMOVLPD takes 2 or 3 operands")
8930 }
8931 }
8932
8933 func __asm_proxy_VMOVLPS__(p *Program, v ...interface{}) *Instruction {
8934 switch len(v) {
8935 case 2 : return p.VMOVLPS(v[0], v[1])
8936 case 3 : return p.VMOVLPS(v[0], v[1], v[2])
8937 default : panic("instruction VMOVLPS takes 2 or 3 operands")
8938 }
8939 }
8940
8941 func __asm_proxy_VMOVMSKPD__(p *Program, v ...interface{}) *Instruction {
8942 if len(v) == 2 {
8943 return p.VMOVMSKPD(v[0], v[1])
8944 } else {
8945 panic("instruction VMOVMSKPD takes exactly 2 operands")
8946 }
8947 }
8948
8949 func __asm_proxy_VMOVMSKPS__(p *Program, v ...interface{}) *Instruction {
8950 if len(v) == 2 {
8951 return p.VMOVMSKPS(v[0], v[1])
8952 } else {
8953 panic("instruction VMOVMSKPS takes exactly 2 operands")
8954 }
8955 }
8956
8957 func __asm_proxy_VMOVNTDQ__(p *Program, v ...interface{}) *Instruction {
8958 if len(v) == 2 {
8959 return p.VMOVNTDQ(v[0], v[1])
8960 } else {
8961 panic("instruction VMOVNTDQ takes exactly 2 operands")
8962 }
8963 }
8964
8965 func __asm_proxy_VMOVNTDQA__(p *Program, v ...interface{}) *Instruction {
8966 if len(v) == 2 {
8967 return p.VMOVNTDQA(v[0], v[1])
8968 } else {
8969 panic("instruction VMOVNTDQA takes exactly 2 operands")
8970 }
8971 }
8972
8973 func __asm_proxy_VMOVNTPD__(p *Program, v ...interface{}) *Instruction {
8974 if len(v) == 2 {
8975 return p.VMOVNTPD(v[0], v[1])
8976 } else {
8977 panic("instruction VMOVNTPD takes exactly 2 operands")
8978 }
8979 }
8980
8981 func __asm_proxy_VMOVNTPS__(p *Program, v ...interface{}) *Instruction {
8982 if len(v) == 2 {
8983 return p.VMOVNTPS(v[0], v[1])
8984 } else {
8985 panic("instruction VMOVNTPS takes exactly 2 operands")
8986 }
8987 }
8988
8989 func __asm_proxy_VMOVQ__(p *Program, v ...interface{}) *Instruction {
8990 if len(v) == 2 {
8991 return p.VMOVQ(v[0], v[1])
8992 } else {
8993 panic("instruction VMOVQ takes exactly 2 operands")
8994 }
8995 }
8996
8997 func __asm_proxy_VMOVSD__(p *Program, v ...interface{}) *Instruction {
8998 switch len(v) {
8999 case 2 : return p.VMOVSD(v[0], v[1])
9000 case 3 : return p.VMOVSD(v[0], v[1], v[2])
9001 default : panic("instruction VMOVSD takes 2 or 3 operands")
9002 }
9003 }
9004
9005 func __asm_proxy_VMOVSHDUP__(p *Program, v ...interface{}) *Instruction {
9006 if len(v) == 2 {
9007 return p.VMOVSHDUP(v[0], v[1])
9008 } else {
9009 panic("instruction VMOVSHDUP takes exactly 2 operands")
9010 }
9011 }
9012
9013 func __asm_proxy_VMOVSLDUP__(p *Program, v ...interface{}) *Instruction {
9014 if len(v) == 2 {
9015 return p.VMOVSLDUP(v[0], v[1])
9016 } else {
9017 panic("instruction VMOVSLDUP takes exactly 2 operands")
9018 }
9019 }
9020
9021 func __asm_proxy_VMOVSS__(p *Program, v ...interface{}) *Instruction {
9022 switch len(v) {
9023 case 2 : return p.VMOVSS(v[0], v[1])
9024 case 3 : return p.VMOVSS(v[0], v[1], v[2])
9025 default : panic("instruction VMOVSS takes 2 or 3 operands")
9026 }
9027 }
9028
9029 func __asm_proxy_VMOVUPD__(p *Program, v ...interface{}) *Instruction {
9030 if len(v) == 2 {
9031 return p.VMOVUPD(v[0], v[1])
9032 } else {
9033 panic("instruction VMOVUPD takes exactly 2 operands")
9034 }
9035 }
9036
9037 func __asm_proxy_VMOVUPS__(p *Program, v ...interface{}) *Instruction {
9038 if len(v) == 2 {
9039 return p.VMOVUPS(v[0], v[1])
9040 } else {
9041 panic("instruction VMOVUPS takes exactly 2 operands")
9042 }
9043 }
9044
9045 func __asm_proxy_VMPSADBW__(p *Program, v ...interface{}) *Instruction {
9046 if len(v) == 4 {
9047 return p.VMPSADBW(v[0], v[1], v[2], v[3])
9048 } else {
9049 panic("instruction VMPSADBW takes exactly 4 operands")
9050 }
9051 }
9052
9053 func __asm_proxy_VMULPD__(p *Program, v ...interface{}) *Instruction {
9054 switch len(v) {
9055 case 3 : return p.VMULPD(v[0], v[1], v[2])
9056 case 4 : return p.VMULPD(v[0], v[1], v[2], v[3])
9057 default : panic("instruction VMULPD takes 3 or 4 operands")
9058 }
9059 }
9060
9061 func __asm_proxy_VMULPS__(p *Program, v ...interface{}) *Instruction {
9062 switch len(v) {
9063 case 3 : return p.VMULPS(v[0], v[1], v[2])
9064 case 4 : return p.VMULPS(v[0], v[1], v[2], v[3])
9065 default : panic("instruction VMULPS takes 3 or 4 operands")
9066 }
9067 }
9068
9069 func __asm_proxy_VMULSD__(p *Program, v ...interface{}) *Instruction {
9070 switch len(v) {
9071 case 3 : return p.VMULSD(v[0], v[1], v[2])
9072 case 4 : return p.VMULSD(v[0], v[1], v[2], v[3])
9073 default : panic("instruction VMULSD takes 3 or 4 operands")
9074 }
9075 }
9076
9077 func __asm_proxy_VMULSS__(p *Program, v ...interface{}) *Instruction {
9078 switch len(v) {
9079 case 3 : return p.VMULSS(v[0], v[1], v[2])
9080 case 4 : return p.VMULSS(v[0], v[1], v[2], v[3])
9081 default : panic("instruction VMULSS takes 3 or 4 operands")
9082 }
9083 }
9084
9085 func __asm_proxy_VORPD__(p *Program, v ...interface{}) *Instruction {
9086 if len(v) == 3 {
9087 return p.VORPD(v[0], v[1], v[2])
9088 } else {
9089 panic("instruction VORPD takes exactly 3 operands")
9090 }
9091 }
9092
9093 func __asm_proxy_VORPS__(p *Program, v ...interface{}) *Instruction {
9094 if len(v) == 3 {
9095 return p.VORPS(v[0], v[1], v[2])
9096 } else {
9097 panic("instruction VORPS takes exactly 3 operands")
9098 }
9099 }
9100
9101 func __asm_proxy_VPABSB__(p *Program, v ...interface{}) *Instruction {
9102 if len(v) == 2 {
9103 return p.VPABSB(v[0], v[1])
9104 } else {
9105 panic("instruction VPABSB takes exactly 2 operands")
9106 }
9107 }
9108
9109 func __asm_proxy_VPABSD__(p *Program, v ...interface{}) *Instruction {
9110 if len(v) == 2 {
9111 return p.VPABSD(v[0], v[1])
9112 } else {
9113 panic("instruction VPABSD takes exactly 2 operands")
9114 }
9115 }
9116
9117 func __asm_proxy_VPABSQ__(p *Program, v ...interface{}) *Instruction {
9118 if len(v) == 2 {
9119 return p.VPABSQ(v[0], v[1])
9120 } else {
9121 panic("instruction VPABSQ takes exactly 2 operands")
9122 }
9123 }
9124
9125 func __asm_proxy_VPABSW__(p *Program, v ...interface{}) *Instruction {
9126 if len(v) == 2 {
9127 return p.VPABSW(v[0], v[1])
9128 } else {
9129 panic("instruction VPABSW takes exactly 2 operands")
9130 }
9131 }
9132
9133 func __asm_proxy_VPACKSSDW__(p *Program, v ...interface{}) *Instruction {
9134 if len(v) == 3 {
9135 return p.VPACKSSDW(v[0], v[1], v[2])
9136 } else {
9137 panic("instruction VPACKSSDW takes exactly 3 operands")
9138 }
9139 }
9140
9141 func __asm_proxy_VPACKSSWB__(p *Program, v ...interface{}) *Instruction {
9142 if len(v) == 3 {
9143 return p.VPACKSSWB(v[0], v[1], v[2])
9144 } else {
9145 panic("instruction VPACKSSWB takes exactly 3 operands")
9146 }
9147 }
9148
9149 func __asm_proxy_VPACKUSDW__(p *Program, v ...interface{}) *Instruction {
9150 if len(v) == 3 {
9151 return p.VPACKUSDW(v[0], v[1], v[2])
9152 } else {
9153 panic("instruction VPACKUSDW takes exactly 3 operands")
9154 }
9155 }
9156
9157 func __asm_proxy_VPACKUSWB__(p *Program, v ...interface{}) *Instruction {
9158 if len(v) == 3 {
9159 return p.VPACKUSWB(v[0], v[1], v[2])
9160 } else {
9161 panic("instruction VPACKUSWB takes exactly 3 operands")
9162 }
9163 }
9164
9165 func __asm_proxy_VPADDB__(p *Program, v ...interface{}) *Instruction {
9166 if len(v) == 3 {
9167 return p.VPADDB(v[0], v[1], v[2])
9168 } else {
9169 panic("instruction VPADDB takes exactly 3 operands")
9170 }
9171 }
9172
9173 func __asm_proxy_VPADDD__(p *Program, v ...interface{}) *Instruction {
9174 if len(v) == 3 {
9175 return p.VPADDD(v[0], v[1], v[2])
9176 } else {
9177 panic("instruction VPADDD takes exactly 3 operands")
9178 }
9179 }
9180
9181 func __asm_proxy_VPADDQ__(p *Program, v ...interface{}) *Instruction {
9182 if len(v) == 3 {
9183 return p.VPADDQ(v[0], v[1], v[2])
9184 } else {
9185 panic("instruction VPADDQ takes exactly 3 operands")
9186 }
9187 }
9188
9189 func __asm_proxy_VPADDSB__(p *Program, v ...interface{}) *Instruction {
9190 if len(v) == 3 {
9191 return p.VPADDSB(v[0], v[1], v[2])
9192 } else {
9193 panic("instruction VPADDSB takes exactly 3 operands")
9194 }
9195 }
9196
9197 func __asm_proxy_VPADDSW__(p *Program, v ...interface{}) *Instruction {
9198 if len(v) == 3 {
9199 return p.VPADDSW(v[0], v[1], v[2])
9200 } else {
9201 panic("instruction VPADDSW takes exactly 3 operands")
9202 }
9203 }
9204
9205 func __asm_proxy_VPADDUSB__(p *Program, v ...interface{}) *Instruction {
9206 if len(v) == 3 {
9207 return p.VPADDUSB(v[0], v[1], v[2])
9208 } else {
9209 panic("instruction VPADDUSB takes exactly 3 operands")
9210 }
9211 }
9212
9213 func __asm_proxy_VPADDUSW__(p *Program, v ...interface{}) *Instruction {
9214 if len(v) == 3 {
9215 return p.VPADDUSW(v[0], v[1], v[2])
9216 } else {
9217 panic("instruction VPADDUSW takes exactly 3 operands")
9218 }
9219 }
9220
9221 func __asm_proxy_VPADDW__(p *Program, v ...interface{}) *Instruction {
9222 if len(v) == 3 {
9223 return p.VPADDW(v[0], v[1], v[2])
9224 } else {
9225 panic("instruction VPADDW takes exactly 3 operands")
9226 }
9227 }
9228
9229 func __asm_proxy_VPALIGNR__(p *Program, v ...interface{}) *Instruction {
9230 if len(v) == 4 {
9231 return p.VPALIGNR(v[0], v[1], v[2], v[3])
9232 } else {
9233 panic("instruction VPALIGNR takes exactly 4 operands")
9234 }
9235 }
9236
9237 func __asm_proxy_VPAND__(p *Program, v ...interface{}) *Instruction {
9238 if len(v) == 3 {
9239 return p.VPAND(v[0], v[1], v[2])
9240 } else {
9241 panic("instruction VPAND takes exactly 3 operands")
9242 }
9243 }
9244
9245 func __asm_proxy_VPANDD__(p *Program, v ...interface{}) *Instruction {
9246 if len(v) == 3 {
9247 return p.VPANDD(v[0], v[1], v[2])
9248 } else {
9249 panic("instruction VPANDD takes exactly 3 operands")
9250 }
9251 }
9252
9253 func __asm_proxy_VPANDN__(p *Program, v ...interface{}) *Instruction {
9254 if len(v) == 3 {
9255 return p.VPANDN(v[0], v[1], v[2])
9256 } else {
9257 panic("instruction VPANDN takes exactly 3 operands")
9258 }
9259 }
9260
9261 func __asm_proxy_VPANDND__(p *Program, v ...interface{}) *Instruction {
9262 if len(v) == 3 {
9263 return p.VPANDND(v[0], v[1], v[2])
9264 } else {
9265 panic("instruction VPANDND takes exactly 3 operands")
9266 }
9267 }
9268
9269 func __asm_proxy_VPANDNQ__(p *Program, v ...interface{}) *Instruction {
9270 if len(v) == 3 {
9271 return p.VPANDNQ(v[0], v[1], v[2])
9272 } else {
9273 panic("instruction VPANDNQ takes exactly 3 operands")
9274 }
9275 }
9276
9277 func __asm_proxy_VPANDQ__(p *Program, v ...interface{}) *Instruction {
9278 if len(v) == 3 {
9279 return p.VPANDQ(v[0], v[1], v[2])
9280 } else {
9281 panic("instruction VPANDQ takes exactly 3 operands")
9282 }
9283 }
9284
9285 func __asm_proxy_VPAVGB__(p *Program, v ...interface{}) *Instruction {
9286 if len(v) == 3 {
9287 return p.VPAVGB(v[0], v[1], v[2])
9288 } else {
9289 panic("instruction VPAVGB takes exactly 3 operands")
9290 }
9291 }
9292
9293 func __asm_proxy_VPAVGW__(p *Program, v ...interface{}) *Instruction {
9294 if len(v) == 3 {
9295 return p.VPAVGW(v[0], v[1], v[2])
9296 } else {
9297 panic("instruction VPAVGW takes exactly 3 operands")
9298 }
9299 }
9300
9301 func __asm_proxy_VPBLENDD__(p *Program, v ...interface{}) *Instruction {
9302 if len(v) == 4 {
9303 return p.VPBLENDD(v[0], v[1], v[2], v[3])
9304 } else {
9305 panic("instruction VPBLENDD takes exactly 4 operands")
9306 }
9307 }
9308
9309 func __asm_proxy_VPBLENDMB__(p *Program, v ...interface{}) *Instruction {
9310 if len(v) == 3 {
9311 return p.VPBLENDMB(v[0], v[1], v[2])
9312 } else {
9313 panic("instruction VPBLENDMB takes exactly 3 operands")
9314 }
9315 }
9316
9317 func __asm_proxy_VPBLENDMD__(p *Program, v ...interface{}) *Instruction {
9318 if len(v) == 3 {
9319 return p.VPBLENDMD(v[0], v[1], v[2])
9320 } else {
9321 panic("instruction VPBLENDMD takes exactly 3 operands")
9322 }
9323 }
9324
9325 func __asm_proxy_VPBLENDMQ__(p *Program, v ...interface{}) *Instruction {
9326 if len(v) == 3 {
9327 return p.VPBLENDMQ(v[0], v[1], v[2])
9328 } else {
9329 panic("instruction VPBLENDMQ takes exactly 3 operands")
9330 }
9331 }
9332
9333 func __asm_proxy_VPBLENDMW__(p *Program, v ...interface{}) *Instruction {
9334 if len(v) == 3 {
9335 return p.VPBLENDMW(v[0], v[1], v[2])
9336 } else {
9337 panic("instruction VPBLENDMW takes exactly 3 operands")
9338 }
9339 }
9340
9341 func __asm_proxy_VPBLENDVB__(p *Program, v ...interface{}) *Instruction {
9342 if len(v) == 4 {
9343 return p.VPBLENDVB(v[0], v[1], v[2], v[3])
9344 } else {
9345 panic("instruction VPBLENDVB takes exactly 4 operands")
9346 }
9347 }
9348
9349 func __asm_proxy_VPBLENDW__(p *Program, v ...interface{}) *Instruction {
9350 if len(v) == 4 {
9351 return p.VPBLENDW(v[0], v[1], v[2], v[3])
9352 } else {
9353 panic("instruction VPBLENDW takes exactly 4 operands")
9354 }
9355 }
9356
9357 func __asm_proxy_VPBROADCASTB__(p *Program, v ...interface{}) *Instruction {
9358 if len(v) == 2 {
9359 return p.VPBROADCASTB(v[0], v[1])
9360 } else {
9361 panic("instruction VPBROADCASTB takes exactly 2 operands")
9362 }
9363 }
9364
9365 func __asm_proxy_VPBROADCASTD__(p *Program, v ...interface{}) *Instruction {
9366 if len(v) == 2 {
9367 return p.VPBROADCASTD(v[0], v[1])
9368 } else {
9369 panic("instruction VPBROADCASTD takes exactly 2 operands")
9370 }
9371 }
9372
9373 func __asm_proxy_VPBROADCASTMB2Q__(p *Program, v ...interface{}) *Instruction {
9374 if len(v) == 2 {
9375 return p.VPBROADCASTMB2Q(v[0], v[1])
9376 } else {
9377 panic("instruction VPBROADCASTMB2Q takes exactly 2 operands")
9378 }
9379 }
9380
9381 func __asm_proxy_VPBROADCASTMW2D__(p *Program, v ...interface{}) *Instruction {
9382 if len(v) == 2 {
9383 return p.VPBROADCASTMW2D(v[0], v[1])
9384 } else {
9385 panic("instruction VPBROADCASTMW2D takes exactly 2 operands")
9386 }
9387 }
9388
9389 func __asm_proxy_VPBROADCASTQ__(p *Program, v ...interface{}) *Instruction {
9390 if len(v) == 2 {
9391 return p.VPBROADCASTQ(v[0], v[1])
9392 } else {
9393 panic("instruction VPBROADCASTQ takes exactly 2 operands")
9394 }
9395 }
9396
9397 func __asm_proxy_VPBROADCASTW__(p *Program, v ...interface{}) *Instruction {
9398 if len(v) == 2 {
9399 return p.VPBROADCASTW(v[0], v[1])
9400 } else {
9401 panic("instruction VPBROADCASTW takes exactly 2 operands")
9402 }
9403 }
9404
9405 func __asm_proxy_VPCLMULQDQ__(p *Program, v ...interface{}) *Instruction {
9406 if len(v) == 4 {
9407 return p.VPCLMULQDQ(v[0], v[1], v[2], v[3])
9408 } else {
9409 panic("instruction VPCLMULQDQ takes exactly 4 operands")
9410 }
9411 }
9412
9413 func __asm_proxy_VPCMOV__(p *Program, v ...interface{}) *Instruction {
9414 if len(v) == 4 {
9415 return p.VPCMOV(v[0], v[1], v[2], v[3])
9416 } else {
9417 panic("instruction VPCMOV takes exactly 4 operands")
9418 }
9419 }
9420
9421 func __asm_proxy_VPCMPB__(p *Program, v ...interface{}) *Instruction {
9422 if len(v) == 4 {
9423 return p.VPCMPB(v[0], v[1], v[2], v[3])
9424 } else {
9425 panic("instruction VPCMPB takes exactly 4 operands")
9426 }
9427 }
9428
9429 func __asm_proxy_VPCMPD__(p *Program, v ...interface{}) *Instruction {
9430 if len(v) == 4 {
9431 return p.VPCMPD(v[0], v[1], v[2], v[3])
9432 } else {
9433 panic("instruction VPCMPD takes exactly 4 operands")
9434 }
9435 }
9436
9437 func __asm_proxy_VPCMPEQB__(p *Program, v ...interface{}) *Instruction {
9438 if len(v) == 3 {
9439 return p.VPCMPEQB(v[0], v[1], v[2])
9440 } else {
9441 panic("instruction VPCMPEQB takes exactly 3 operands")
9442 }
9443 }
9444
9445 func __asm_proxy_VPCMPEQD__(p *Program, v ...interface{}) *Instruction {
9446 if len(v) == 3 {
9447 return p.VPCMPEQD(v[0], v[1], v[2])
9448 } else {
9449 panic("instruction VPCMPEQD takes exactly 3 operands")
9450 }
9451 }
9452
9453 func __asm_proxy_VPCMPEQQ__(p *Program, v ...interface{}) *Instruction {
9454 if len(v) == 3 {
9455 return p.VPCMPEQQ(v[0], v[1], v[2])
9456 } else {
9457 panic("instruction VPCMPEQQ takes exactly 3 operands")
9458 }
9459 }
9460
9461 func __asm_proxy_VPCMPEQW__(p *Program, v ...interface{}) *Instruction {
9462 if len(v) == 3 {
9463 return p.VPCMPEQW(v[0], v[1], v[2])
9464 } else {
9465 panic("instruction VPCMPEQW takes exactly 3 operands")
9466 }
9467 }
9468
9469 func __asm_proxy_VPCMPESTRI__(p *Program, v ...interface{}) *Instruction {
9470 if len(v) == 3 {
9471 return p.VPCMPESTRI(v[0], v[1], v[2])
9472 } else {
9473 panic("instruction VPCMPESTRI takes exactly 3 operands")
9474 }
9475 }
9476
9477 func __asm_proxy_VPCMPESTRM__(p *Program, v ...interface{}) *Instruction {
9478 if len(v) == 3 {
9479 return p.VPCMPESTRM(v[0], v[1], v[2])
9480 } else {
9481 panic("instruction VPCMPESTRM takes exactly 3 operands")
9482 }
9483 }
9484
9485 func __asm_proxy_VPCMPGTB__(p *Program, v ...interface{}) *Instruction {
9486 if len(v) == 3 {
9487 return p.VPCMPGTB(v[0], v[1], v[2])
9488 } else {
9489 panic("instruction VPCMPGTB takes exactly 3 operands")
9490 }
9491 }
9492
9493 func __asm_proxy_VPCMPGTD__(p *Program, v ...interface{}) *Instruction {
9494 if len(v) == 3 {
9495 return p.VPCMPGTD(v[0], v[1], v[2])
9496 } else {
9497 panic("instruction VPCMPGTD takes exactly 3 operands")
9498 }
9499 }
9500
9501 func __asm_proxy_VPCMPGTQ__(p *Program, v ...interface{}) *Instruction {
9502 if len(v) == 3 {
9503 return p.VPCMPGTQ(v[0], v[1], v[2])
9504 } else {
9505 panic("instruction VPCMPGTQ takes exactly 3 operands")
9506 }
9507 }
9508
9509 func __asm_proxy_VPCMPGTW__(p *Program, v ...interface{}) *Instruction {
9510 if len(v) == 3 {
9511 return p.VPCMPGTW(v[0], v[1], v[2])
9512 } else {
9513 panic("instruction VPCMPGTW takes exactly 3 operands")
9514 }
9515 }
9516
9517 func __asm_proxy_VPCMPISTRI__(p *Program, v ...interface{}) *Instruction {
9518 if len(v) == 3 {
9519 return p.VPCMPISTRI(v[0], v[1], v[2])
9520 } else {
9521 panic("instruction VPCMPISTRI takes exactly 3 operands")
9522 }
9523 }
9524
9525 func __asm_proxy_VPCMPISTRM__(p *Program, v ...interface{}) *Instruction {
9526 if len(v) == 3 {
9527 return p.VPCMPISTRM(v[0], v[1], v[2])
9528 } else {
9529 panic("instruction VPCMPISTRM takes exactly 3 operands")
9530 }
9531 }
9532
9533 func __asm_proxy_VPCMPQ__(p *Program, v ...interface{}) *Instruction {
9534 if len(v) == 4 {
9535 return p.VPCMPQ(v[0], v[1], v[2], v[3])
9536 } else {
9537 panic("instruction VPCMPQ takes exactly 4 operands")
9538 }
9539 }
9540
9541 func __asm_proxy_VPCMPUB__(p *Program, v ...interface{}) *Instruction {
9542 if len(v) == 4 {
9543 return p.VPCMPUB(v[0], v[1], v[2], v[3])
9544 } else {
9545 panic("instruction VPCMPUB takes exactly 4 operands")
9546 }
9547 }
9548
9549 func __asm_proxy_VPCMPUD__(p *Program, v ...interface{}) *Instruction {
9550 if len(v) == 4 {
9551 return p.VPCMPUD(v[0], v[1], v[2], v[3])
9552 } else {
9553 panic("instruction VPCMPUD takes exactly 4 operands")
9554 }
9555 }
9556
9557 func __asm_proxy_VPCMPUQ__(p *Program, v ...interface{}) *Instruction {
9558 if len(v) == 4 {
9559 return p.VPCMPUQ(v[0], v[1], v[2], v[3])
9560 } else {
9561 panic("instruction VPCMPUQ takes exactly 4 operands")
9562 }
9563 }
9564
9565 func __asm_proxy_VPCMPUW__(p *Program, v ...interface{}) *Instruction {
9566 if len(v) == 4 {
9567 return p.VPCMPUW(v[0], v[1], v[2], v[3])
9568 } else {
9569 panic("instruction VPCMPUW takes exactly 4 operands")
9570 }
9571 }
9572
9573 func __asm_proxy_VPCMPW__(p *Program, v ...interface{}) *Instruction {
9574 if len(v) == 4 {
9575 return p.VPCMPW(v[0], v[1], v[2], v[3])
9576 } else {
9577 panic("instruction VPCMPW takes exactly 4 operands")
9578 }
9579 }
9580
9581 func __asm_proxy_VPCOMB__(p *Program, v ...interface{}) *Instruction {
9582 if len(v) == 4 {
9583 return p.VPCOMB(v[0], v[1], v[2], v[3])
9584 } else {
9585 panic("instruction VPCOMB takes exactly 4 operands")
9586 }
9587 }
9588
9589 func __asm_proxy_VPCOMD__(p *Program, v ...interface{}) *Instruction {
9590 if len(v) == 4 {
9591 return p.VPCOMD(v[0], v[1], v[2], v[3])
9592 } else {
9593 panic("instruction VPCOMD takes exactly 4 operands")
9594 }
9595 }
9596
9597 func __asm_proxy_VPCOMPRESSD__(p *Program, v ...interface{}) *Instruction {
9598 if len(v) == 2 {
9599 return p.VPCOMPRESSD(v[0], v[1])
9600 } else {
9601 panic("instruction VPCOMPRESSD takes exactly 2 operands")
9602 }
9603 }
9604
9605 func __asm_proxy_VPCOMPRESSQ__(p *Program, v ...interface{}) *Instruction {
9606 if len(v) == 2 {
9607 return p.VPCOMPRESSQ(v[0], v[1])
9608 } else {
9609 panic("instruction VPCOMPRESSQ takes exactly 2 operands")
9610 }
9611 }
9612
9613 func __asm_proxy_VPCOMQ__(p *Program, v ...interface{}) *Instruction {
9614 if len(v) == 4 {
9615 return p.VPCOMQ(v[0], v[1], v[2], v[3])
9616 } else {
9617 panic("instruction VPCOMQ takes exactly 4 operands")
9618 }
9619 }
9620
9621 func __asm_proxy_VPCOMUB__(p *Program, v ...interface{}) *Instruction {
9622 if len(v) == 4 {
9623 return p.VPCOMUB(v[0], v[1], v[2], v[3])
9624 } else {
9625 panic("instruction VPCOMUB takes exactly 4 operands")
9626 }
9627 }
9628
9629 func __asm_proxy_VPCOMUD__(p *Program, v ...interface{}) *Instruction {
9630 if len(v) == 4 {
9631 return p.VPCOMUD(v[0], v[1], v[2], v[3])
9632 } else {
9633 panic("instruction VPCOMUD takes exactly 4 operands")
9634 }
9635 }
9636
9637 func __asm_proxy_VPCOMUQ__(p *Program, v ...interface{}) *Instruction {
9638 if len(v) == 4 {
9639 return p.VPCOMUQ(v[0], v[1], v[2], v[3])
9640 } else {
9641 panic("instruction VPCOMUQ takes exactly 4 operands")
9642 }
9643 }
9644
9645 func __asm_proxy_VPCOMUW__(p *Program, v ...interface{}) *Instruction {
9646 if len(v) == 4 {
9647 return p.VPCOMUW(v[0], v[1], v[2], v[3])
9648 } else {
9649 panic("instruction VPCOMUW takes exactly 4 operands")
9650 }
9651 }
9652
9653 func __asm_proxy_VPCOMW__(p *Program, v ...interface{}) *Instruction {
9654 if len(v) == 4 {
9655 return p.VPCOMW(v[0], v[1], v[2], v[3])
9656 } else {
9657 panic("instruction VPCOMW takes exactly 4 operands")
9658 }
9659 }
9660
9661 func __asm_proxy_VPCONFLICTD__(p *Program, v ...interface{}) *Instruction {
9662 if len(v) == 2 {
9663 return p.VPCONFLICTD(v[0], v[1])
9664 } else {
9665 panic("instruction VPCONFLICTD takes exactly 2 operands")
9666 }
9667 }
9668
9669 func __asm_proxy_VPCONFLICTQ__(p *Program, v ...interface{}) *Instruction {
9670 if len(v) == 2 {
9671 return p.VPCONFLICTQ(v[0], v[1])
9672 } else {
9673 panic("instruction VPCONFLICTQ takes exactly 2 operands")
9674 }
9675 }
9676
9677 func __asm_proxy_VPERM2F128__(p *Program, v ...interface{}) *Instruction {
9678 if len(v) == 4 {
9679 return p.VPERM2F128(v[0], v[1], v[2], v[3])
9680 } else {
9681 panic("instruction VPERM2F128 takes exactly 4 operands")
9682 }
9683 }
9684
9685 func __asm_proxy_VPERM2I128__(p *Program, v ...interface{}) *Instruction {
9686 if len(v) == 4 {
9687 return p.VPERM2I128(v[0], v[1], v[2], v[3])
9688 } else {
9689 panic("instruction VPERM2I128 takes exactly 4 operands")
9690 }
9691 }
9692
9693 func __asm_proxy_VPERMB__(p *Program, v ...interface{}) *Instruction {
9694 if len(v) == 3 {
9695 return p.VPERMB(v[0], v[1], v[2])
9696 } else {
9697 panic("instruction VPERMB takes exactly 3 operands")
9698 }
9699 }
9700
9701 func __asm_proxy_VPERMD__(p *Program, v ...interface{}) *Instruction {
9702 if len(v) == 3 {
9703 return p.VPERMD(v[0], v[1], v[2])
9704 } else {
9705 panic("instruction VPERMD takes exactly 3 operands")
9706 }
9707 }
9708
9709 func __asm_proxy_VPERMI2B__(p *Program, v ...interface{}) *Instruction {
9710 if len(v) == 3 {
9711 return p.VPERMI2B(v[0], v[1], v[2])
9712 } else {
9713 panic("instruction VPERMI2B takes exactly 3 operands")
9714 }
9715 }
9716
9717 func __asm_proxy_VPERMI2D__(p *Program, v ...interface{}) *Instruction {
9718 if len(v) == 3 {
9719 return p.VPERMI2D(v[0], v[1], v[2])
9720 } else {
9721 panic("instruction VPERMI2D takes exactly 3 operands")
9722 }
9723 }
9724
9725 func __asm_proxy_VPERMI2PD__(p *Program, v ...interface{}) *Instruction {
9726 if len(v) == 3 {
9727 return p.VPERMI2PD(v[0], v[1], v[2])
9728 } else {
9729 panic("instruction VPERMI2PD takes exactly 3 operands")
9730 }
9731 }
9732
9733 func __asm_proxy_VPERMI2PS__(p *Program, v ...interface{}) *Instruction {
9734 if len(v) == 3 {
9735 return p.VPERMI2PS(v[0], v[1], v[2])
9736 } else {
9737 panic("instruction VPERMI2PS takes exactly 3 operands")
9738 }
9739 }
9740
9741 func __asm_proxy_VPERMI2Q__(p *Program, v ...interface{}) *Instruction {
9742 if len(v) == 3 {
9743 return p.VPERMI2Q(v[0], v[1], v[2])
9744 } else {
9745 panic("instruction VPERMI2Q takes exactly 3 operands")
9746 }
9747 }
9748
9749 func __asm_proxy_VPERMI2W__(p *Program, v ...interface{}) *Instruction {
9750 if len(v) == 3 {
9751 return p.VPERMI2W(v[0], v[1], v[2])
9752 } else {
9753 panic("instruction VPERMI2W takes exactly 3 operands")
9754 }
9755 }
9756
9757 func __asm_proxy_VPERMIL2PD__(p *Program, v ...interface{}) *Instruction {
9758 if len(v) == 5 {
9759 return p.VPERMIL2PD(v[0], v[1], v[2], v[3], v[4])
9760 } else {
9761 panic("instruction VPERMIL2PD takes exactly 5 operands")
9762 }
9763 }
9764
9765 func __asm_proxy_VPERMIL2PS__(p *Program, v ...interface{}) *Instruction {
9766 if len(v) == 5 {
9767 return p.VPERMIL2PS(v[0], v[1], v[2], v[3], v[4])
9768 } else {
9769 panic("instruction VPERMIL2PS takes exactly 5 operands")
9770 }
9771 }
9772
9773 func __asm_proxy_VPERMILPD__(p *Program, v ...interface{}) *Instruction {
9774 if len(v) == 3 {
9775 return p.VPERMILPD(v[0], v[1], v[2])
9776 } else {
9777 panic("instruction VPERMILPD takes exactly 3 operands")
9778 }
9779 }
9780
9781 func __asm_proxy_VPERMILPS__(p *Program, v ...interface{}) *Instruction {
9782 if len(v) == 3 {
9783 return p.VPERMILPS(v[0], v[1], v[2])
9784 } else {
9785 panic("instruction VPERMILPS takes exactly 3 operands")
9786 }
9787 }
9788
9789 func __asm_proxy_VPERMPD__(p *Program, v ...interface{}) *Instruction {
9790 if len(v) == 3 {
9791 return p.VPERMPD(v[0], v[1], v[2])
9792 } else {
9793 panic("instruction VPERMPD takes exactly 3 operands")
9794 }
9795 }
9796
9797 func __asm_proxy_VPERMPS__(p *Program, v ...interface{}) *Instruction {
9798 if len(v) == 3 {
9799 return p.VPERMPS(v[0], v[1], v[2])
9800 } else {
9801 panic("instruction VPERMPS takes exactly 3 operands")
9802 }
9803 }
9804
9805 func __asm_proxy_VPERMQ__(p *Program, v ...interface{}) *Instruction {
9806 if len(v) == 3 {
9807 return p.VPERMQ(v[0], v[1], v[2])
9808 } else {
9809 panic("instruction VPERMQ takes exactly 3 operands")
9810 }
9811 }
9812
9813 func __asm_proxy_VPERMT2B__(p *Program, v ...interface{}) *Instruction {
9814 if len(v) == 3 {
9815 return p.VPERMT2B(v[0], v[1], v[2])
9816 } else {
9817 panic("instruction VPERMT2B takes exactly 3 operands")
9818 }
9819 }
9820
9821 func __asm_proxy_VPERMT2D__(p *Program, v ...interface{}) *Instruction {
9822 if len(v) == 3 {
9823 return p.VPERMT2D(v[0], v[1], v[2])
9824 } else {
9825 panic("instruction VPERMT2D takes exactly 3 operands")
9826 }
9827 }
9828
9829 func __asm_proxy_VPERMT2PD__(p *Program, v ...interface{}) *Instruction {
9830 if len(v) == 3 {
9831 return p.VPERMT2PD(v[0], v[1], v[2])
9832 } else {
9833 panic("instruction VPERMT2PD takes exactly 3 operands")
9834 }
9835 }
9836
9837 func __asm_proxy_VPERMT2PS__(p *Program, v ...interface{}) *Instruction {
9838 if len(v) == 3 {
9839 return p.VPERMT2PS(v[0], v[1], v[2])
9840 } else {
9841 panic("instruction VPERMT2PS takes exactly 3 operands")
9842 }
9843 }
9844
9845 func __asm_proxy_VPERMT2Q__(p *Program, v ...interface{}) *Instruction {
9846 if len(v) == 3 {
9847 return p.VPERMT2Q(v[0], v[1], v[2])
9848 } else {
9849 panic("instruction VPERMT2Q takes exactly 3 operands")
9850 }
9851 }
9852
9853 func __asm_proxy_VPERMT2W__(p *Program, v ...interface{}) *Instruction {
9854 if len(v) == 3 {
9855 return p.VPERMT2W(v[0], v[1], v[2])
9856 } else {
9857 panic("instruction VPERMT2W takes exactly 3 operands")
9858 }
9859 }
9860
9861 func __asm_proxy_VPERMW__(p *Program, v ...interface{}) *Instruction {
9862 if len(v) == 3 {
9863 return p.VPERMW(v[0], v[1], v[2])
9864 } else {
9865 panic("instruction VPERMW takes exactly 3 operands")
9866 }
9867 }
9868
9869 func __asm_proxy_VPEXPANDD__(p *Program, v ...interface{}) *Instruction {
9870 if len(v) == 2 {
9871 return p.VPEXPANDD(v[0], v[1])
9872 } else {
9873 panic("instruction VPEXPANDD takes exactly 2 operands")
9874 }
9875 }
9876
9877 func __asm_proxy_VPEXPANDQ__(p *Program, v ...interface{}) *Instruction {
9878 if len(v) == 2 {
9879 return p.VPEXPANDQ(v[0], v[1])
9880 } else {
9881 panic("instruction VPEXPANDQ takes exactly 2 operands")
9882 }
9883 }
9884
9885 func __asm_proxy_VPEXTRB__(p *Program, v ...interface{}) *Instruction {
9886 if len(v) == 3 {
9887 return p.VPEXTRB(v[0], v[1], v[2])
9888 } else {
9889 panic("instruction VPEXTRB takes exactly 3 operands")
9890 }
9891 }
9892
9893 func __asm_proxy_VPEXTRD__(p *Program, v ...interface{}) *Instruction {
9894 if len(v) == 3 {
9895 return p.VPEXTRD(v[0], v[1], v[2])
9896 } else {
9897 panic("instruction VPEXTRD takes exactly 3 operands")
9898 }
9899 }
9900
9901 func __asm_proxy_VPEXTRQ__(p *Program, v ...interface{}) *Instruction {
9902 if len(v) == 3 {
9903 return p.VPEXTRQ(v[0], v[1], v[2])
9904 } else {
9905 panic("instruction VPEXTRQ takes exactly 3 operands")
9906 }
9907 }
9908
9909 func __asm_proxy_VPEXTRW__(p *Program, v ...interface{}) *Instruction {
9910 if len(v) == 3 {
9911 return p.VPEXTRW(v[0], v[1], v[2])
9912 } else {
9913 panic("instruction VPEXTRW takes exactly 3 operands")
9914 }
9915 }
9916
9917 func __asm_proxy_VPGATHERDD__(p *Program, v ...interface{}) *Instruction {
9918 switch len(v) {
9919 case 2 : return p.VPGATHERDD(v[0], v[1])
9920 case 3 : return p.VPGATHERDD(v[0], v[1], v[2])
9921 default : panic("instruction VPGATHERDD takes 2 or 3 operands")
9922 }
9923 }
9924
9925 func __asm_proxy_VPGATHERDQ__(p *Program, v ...interface{}) *Instruction {
9926 switch len(v) {
9927 case 2 : return p.VPGATHERDQ(v[0], v[1])
9928 case 3 : return p.VPGATHERDQ(v[0], v[1], v[2])
9929 default : panic("instruction VPGATHERDQ takes 2 or 3 operands")
9930 }
9931 }
9932
9933 func __asm_proxy_VPGATHERQD__(p *Program, v ...interface{}) *Instruction {
9934 switch len(v) {
9935 case 2 : return p.VPGATHERQD(v[0], v[1])
9936 case 3 : return p.VPGATHERQD(v[0], v[1], v[2])
9937 default : panic("instruction VPGATHERQD takes 2 or 3 operands")
9938 }
9939 }
9940
9941 func __asm_proxy_VPGATHERQQ__(p *Program, v ...interface{}) *Instruction {
9942 switch len(v) {
9943 case 2 : return p.VPGATHERQQ(v[0], v[1])
9944 case 3 : return p.VPGATHERQQ(v[0], v[1], v[2])
9945 default : panic("instruction VPGATHERQQ takes 2 or 3 operands")
9946 }
9947 }
9948
9949 func __asm_proxy_VPHADDBD__(p *Program, v ...interface{}) *Instruction {
9950 if len(v) == 2 {
9951 return p.VPHADDBD(v[0], v[1])
9952 } else {
9953 panic("instruction VPHADDBD takes exactly 2 operands")
9954 }
9955 }
9956
9957 func __asm_proxy_VPHADDBQ__(p *Program, v ...interface{}) *Instruction {
9958 if len(v) == 2 {
9959 return p.VPHADDBQ(v[0], v[1])
9960 } else {
9961 panic("instruction VPHADDBQ takes exactly 2 operands")
9962 }
9963 }
9964
9965 func __asm_proxy_VPHADDBW__(p *Program, v ...interface{}) *Instruction {
9966 if len(v) == 2 {
9967 return p.VPHADDBW(v[0], v[1])
9968 } else {
9969 panic("instruction VPHADDBW takes exactly 2 operands")
9970 }
9971 }
9972
9973 func __asm_proxy_VPHADDD__(p *Program, v ...interface{}) *Instruction {
9974 if len(v) == 3 {
9975 return p.VPHADDD(v[0], v[1], v[2])
9976 } else {
9977 panic("instruction VPHADDD takes exactly 3 operands")
9978 }
9979 }
9980
9981 func __asm_proxy_VPHADDDQ__(p *Program, v ...interface{}) *Instruction {
9982 if len(v) == 2 {
9983 return p.VPHADDDQ(v[0], v[1])
9984 } else {
9985 panic("instruction VPHADDDQ takes exactly 2 operands")
9986 }
9987 }
9988
9989 func __asm_proxy_VPHADDSW__(p *Program, v ...interface{}) *Instruction {
9990 if len(v) == 3 {
9991 return p.VPHADDSW(v[0], v[1], v[2])
9992 } else {
9993 panic("instruction VPHADDSW takes exactly 3 operands")
9994 }
9995 }
9996
9997 func __asm_proxy_VPHADDUBD__(p *Program, v ...interface{}) *Instruction {
9998 if len(v) == 2 {
9999 return p.VPHADDUBD(v[0], v[1])
10000 } else {
10001 panic("instruction VPHADDUBD takes exactly 2 operands")
10002 }
10003 }
10004
10005 func __asm_proxy_VPHADDUBQ__(p *Program, v ...interface{}) *Instruction {
10006 if len(v) == 2 {
10007 return p.VPHADDUBQ(v[0], v[1])
10008 } else {
10009 panic("instruction VPHADDUBQ takes exactly 2 operands")
10010 }
10011 }
10012
10013 func __asm_proxy_VPHADDUBW__(p *Program, v ...interface{}) *Instruction {
10014 if len(v) == 2 {
10015 return p.VPHADDUBW(v[0], v[1])
10016 } else {
10017 panic("instruction VPHADDUBW takes exactly 2 operands")
10018 }
10019 }
10020
10021 func __asm_proxy_VPHADDUDQ__(p *Program, v ...interface{}) *Instruction {
10022 if len(v) == 2 {
10023 return p.VPHADDUDQ(v[0], v[1])
10024 } else {
10025 panic("instruction VPHADDUDQ takes exactly 2 operands")
10026 }
10027 }
10028
10029 func __asm_proxy_VPHADDUWD__(p *Program, v ...interface{}) *Instruction {
10030 if len(v) == 2 {
10031 return p.VPHADDUWD(v[0], v[1])
10032 } else {
10033 panic("instruction VPHADDUWD takes exactly 2 operands")
10034 }
10035 }
10036
10037 func __asm_proxy_VPHADDUWQ__(p *Program, v ...interface{}) *Instruction {
10038 if len(v) == 2 {
10039 return p.VPHADDUWQ(v[0], v[1])
10040 } else {
10041 panic("instruction VPHADDUWQ takes exactly 2 operands")
10042 }
10043 }
10044
10045 func __asm_proxy_VPHADDW__(p *Program, v ...interface{}) *Instruction {
10046 if len(v) == 3 {
10047 return p.VPHADDW(v[0], v[1], v[2])
10048 } else {
10049 panic("instruction VPHADDW takes exactly 3 operands")
10050 }
10051 }
10052
10053 func __asm_proxy_VPHADDWD__(p *Program, v ...interface{}) *Instruction {
10054 if len(v) == 2 {
10055 return p.VPHADDWD(v[0], v[1])
10056 } else {
10057 panic("instruction VPHADDWD takes exactly 2 operands")
10058 }
10059 }
10060
10061 func __asm_proxy_VPHADDWQ__(p *Program, v ...interface{}) *Instruction {
10062 if len(v) == 2 {
10063 return p.VPHADDWQ(v[0], v[1])
10064 } else {
10065 panic("instruction VPHADDWQ takes exactly 2 operands")
10066 }
10067 }
10068
10069 func __asm_proxy_VPHMINPOSUW__(p *Program, v ...interface{}) *Instruction {
10070 if len(v) == 2 {
10071 return p.VPHMINPOSUW(v[0], v[1])
10072 } else {
10073 panic("instruction VPHMINPOSUW takes exactly 2 operands")
10074 }
10075 }
10076
10077 func __asm_proxy_VPHSUBBW__(p *Program, v ...interface{}) *Instruction {
10078 if len(v) == 2 {
10079 return p.VPHSUBBW(v[0], v[1])
10080 } else {
10081 panic("instruction VPHSUBBW takes exactly 2 operands")
10082 }
10083 }
10084
10085 func __asm_proxy_VPHSUBD__(p *Program, v ...interface{}) *Instruction {
10086 if len(v) == 3 {
10087 return p.VPHSUBD(v[0], v[1], v[2])
10088 } else {
10089 panic("instruction VPHSUBD takes exactly 3 operands")
10090 }
10091 }
10092
10093 func __asm_proxy_VPHSUBDQ__(p *Program, v ...interface{}) *Instruction {
10094 if len(v) == 2 {
10095 return p.VPHSUBDQ(v[0], v[1])
10096 } else {
10097 panic("instruction VPHSUBDQ takes exactly 2 operands")
10098 }
10099 }
10100
10101 func __asm_proxy_VPHSUBSW__(p *Program, v ...interface{}) *Instruction {
10102 if len(v) == 3 {
10103 return p.VPHSUBSW(v[0], v[1], v[2])
10104 } else {
10105 panic("instruction VPHSUBSW takes exactly 3 operands")
10106 }
10107 }
10108
10109 func __asm_proxy_VPHSUBW__(p *Program, v ...interface{}) *Instruction {
10110 if len(v) == 3 {
10111 return p.VPHSUBW(v[0], v[1], v[2])
10112 } else {
10113 panic("instruction VPHSUBW takes exactly 3 operands")
10114 }
10115 }
10116
10117 func __asm_proxy_VPHSUBWD__(p *Program, v ...interface{}) *Instruction {
10118 if len(v) == 2 {
10119 return p.VPHSUBWD(v[0], v[1])
10120 } else {
10121 panic("instruction VPHSUBWD takes exactly 2 operands")
10122 }
10123 }
10124
10125 func __asm_proxy_VPINSRB__(p *Program, v ...interface{}) *Instruction {
10126 if len(v) == 4 {
10127 return p.VPINSRB(v[0], v[1], v[2], v[3])
10128 } else {
10129 panic("instruction VPINSRB takes exactly 4 operands")
10130 }
10131 }
10132
10133 func __asm_proxy_VPINSRD__(p *Program, v ...interface{}) *Instruction {
10134 if len(v) == 4 {
10135 return p.VPINSRD(v[0], v[1], v[2], v[3])
10136 } else {
10137 panic("instruction VPINSRD takes exactly 4 operands")
10138 }
10139 }
10140
10141 func __asm_proxy_VPINSRQ__(p *Program, v ...interface{}) *Instruction {
10142 if len(v) == 4 {
10143 return p.VPINSRQ(v[0], v[1], v[2], v[3])
10144 } else {
10145 panic("instruction VPINSRQ takes exactly 4 operands")
10146 }
10147 }
10148
10149 func __asm_proxy_VPINSRW__(p *Program, v ...interface{}) *Instruction {
10150 if len(v) == 4 {
10151 return p.VPINSRW(v[0], v[1], v[2], v[3])
10152 } else {
10153 panic("instruction VPINSRW takes exactly 4 operands")
10154 }
10155 }
10156
10157 func __asm_proxy_VPLZCNTD__(p *Program, v ...interface{}) *Instruction {
10158 if len(v) == 2 {
10159 return p.VPLZCNTD(v[0], v[1])
10160 } else {
10161 panic("instruction VPLZCNTD takes exactly 2 operands")
10162 }
10163 }
10164
10165 func __asm_proxy_VPLZCNTQ__(p *Program, v ...interface{}) *Instruction {
10166 if len(v) == 2 {
10167 return p.VPLZCNTQ(v[0], v[1])
10168 } else {
10169 panic("instruction VPLZCNTQ takes exactly 2 operands")
10170 }
10171 }
10172
10173 func __asm_proxy_VPMACSDD__(p *Program, v ...interface{}) *Instruction {
10174 if len(v) == 4 {
10175 return p.VPMACSDD(v[0], v[1], v[2], v[3])
10176 } else {
10177 panic("instruction VPMACSDD takes exactly 4 operands")
10178 }
10179 }
10180
10181 func __asm_proxy_VPMACSDQH__(p *Program, v ...interface{}) *Instruction {
10182 if len(v) == 4 {
10183 return p.VPMACSDQH(v[0], v[1], v[2], v[3])
10184 } else {
10185 panic("instruction VPMACSDQH takes exactly 4 operands")
10186 }
10187 }
10188
10189 func __asm_proxy_VPMACSDQL__(p *Program, v ...interface{}) *Instruction {
10190 if len(v) == 4 {
10191 return p.VPMACSDQL(v[0], v[1], v[2], v[3])
10192 } else {
10193 panic("instruction VPMACSDQL takes exactly 4 operands")
10194 }
10195 }
10196
10197 func __asm_proxy_VPMACSSDD__(p *Program, v ...interface{}) *Instruction {
10198 if len(v) == 4 {
10199 return p.VPMACSSDD(v[0], v[1], v[2], v[3])
10200 } else {
10201 panic("instruction VPMACSSDD takes exactly 4 operands")
10202 }
10203 }
10204
10205 func __asm_proxy_VPMACSSDQH__(p *Program, v ...interface{}) *Instruction {
10206 if len(v) == 4 {
10207 return p.VPMACSSDQH(v[0], v[1], v[2], v[3])
10208 } else {
10209 panic("instruction VPMACSSDQH takes exactly 4 operands")
10210 }
10211 }
10212
10213 func __asm_proxy_VPMACSSDQL__(p *Program, v ...interface{}) *Instruction {
10214 if len(v) == 4 {
10215 return p.VPMACSSDQL(v[0], v[1], v[2], v[3])
10216 } else {
10217 panic("instruction VPMACSSDQL takes exactly 4 operands")
10218 }
10219 }
10220
10221 func __asm_proxy_VPMACSSWD__(p *Program, v ...interface{}) *Instruction {
10222 if len(v) == 4 {
10223 return p.VPMACSSWD(v[0], v[1], v[2], v[3])
10224 } else {
10225 panic("instruction VPMACSSWD takes exactly 4 operands")
10226 }
10227 }
10228
10229 func __asm_proxy_VPMACSSWW__(p *Program, v ...interface{}) *Instruction {
10230 if len(v) == 4 {
10231 return p.VPMACSSWW(v[0], v[1], v[2], v[3])
10232 } else {
10233 panic("instruction VPMACSSWW takes exactly 4 operands")
10234 }
10235 }
10236
10237 func __asm_proxy_VPMACSWD__(p *Program, v ...interface{}) *Instruction {
10238 if len(v) == 4 {
10239 return p.VPMACSWD(v[0], v[1], v[2], v[3])
10240 } else {
10241 panic("instruction VPMACSWD takes exactly 4 operands")
10242 }
10243 }
10244
10245 func __asm_proxy_VPMACSWW__(p *Program, v ...interface{}) *Instruction {
10246 if len(v) == 4 {
10247 return p.VPMACSWW(v[0], v[1], v[2], v[3])
10248 } else {
10249 panic("instruction VPMACSWW takes exactly 4 operands")
10250 }
10251 }
10252
10253 func __asm_proxy_VPMADCSSWD__(p *Program, v ...interface{}) *Instruction {
10254 if len(v) == 4 {
10255 return p.VPMADCSSWD(v[0], v[1], v[2], v[3])
10256 } else {
10257 panic("instruction VPMADCSSWD takes exactly 4 operands")
10258 }
10259 }
10260
10261 func __asm_proxy_VPMADCSWD__(p *Program, v ...interface{}) *Instruction {
10262 if len(v) == 4 {
10263 return p.VPMADCSWD(v[0], v[1], v[2], v[3])
10264 } else {
10265 panic("instruction VPMADCSWD takes exactly 4 operands")
10266 }
10267 }
10268
10269 func __asm_proxy_VPMADD52HUQ__(p *Program, v ...interface{}) *Instruction {
10270 if len(v) == 3 {
10271 return p.VPMADD52HUQ(v[0], v[1], v[2])
10272 } else {
10273 panic("instruction VPMADD52HUQ takes exactly 3 operands")
10274 }
10275 }
10276
10277 func __asm_proxy_VPMADD52LUQ__(p *Program, v ...interface{}) *Instruction {
10278 if len(v) == 3 {
10279 return p.VPMADD52LUQ(v[0], v[1], v[2])
10280 } else {
10281 panic("instruction VPMADD52LUQ takes exactly 3 operands")
10282 }
10283 }
10284
10285 func __asm_proxy_VPMADDUBSW__(p *Program, v ...interface{}) *Instruction {
10286 if len(v) == 3 {
10287 return p.VPMADDUBSW(v[0], v[1], v[2])
10288 } else {
10289 panic("instruction VPMADDUBSW takes exactly 3 operands")
10290 }
10291 }
10292
10293 func __asm_proxy_VPMADDWD__(p *Program, v ...interface{}) *Instruction {
10294 if len(v) == 3 {
10295 return p.VPMADDWD(v[0], v[1], v[2])
10296 } else {
10297 panic("instruction VPMADDWD takes exactly 3 operands")
10298 }
10299 }
10300
10301 func __asm_proxy_VPMASKMOVD__(p *Program, v ...interface{}) *Instruction {
10302 if len(v) == 3 {
10303 return p.VPMASKMOVD(v[0], v[1], v[2])
10304 } else {
10305 panic("instruction VPMASKMOVD takes exactly 3 operands")
10306 }
10307 }
10308
10309 func __asm_proxy_VPMASKMOVQ__(p *Program, v ...interface{}) *Instruction {
10310 if len(v) == 3 {
10311 return p.VPMASKMOVQ(v[0], v[1], v[2])
10312 } else {
10313 panic("instruction VPMASKMOVQ takes exactly 3 operands")
10314 }
10315 }
10316
10317 func __asm_proxy_VPMAXSB__(p *Program, v ...interface{}) *Instruction {
10318 if len(v) == 3 {
10319 return p.VPMAXSB(v[0], v[1], v[2])
10320 } else {
10321 panic("instruction VPMAXSB takes exactly 3 operands")
10322 }
10323 }
10324
10325 func __asm_proxy_VPMAXSD__(p *Program, v ...interface{}) *Instruction {
10326 if len(v) == 3 {
10327 return p.VPMAXSD(v[0], v[1], v[2])
10328 } else {
10329 panic("instruction VPMAXSD takes exactly 3 operands")
10330 }
10331 }
10332
10333 func __asm_proxy_VPMAXSQ__(p *Program, v ...interface{}) *Instruction {
10334 if len(v) == 3 {
10335 return p.VPMAXSQ(v[0], v[1], v[2])
10336 } else {
10337 panic("instruction VPMAXSQ takes exactly 3 operands")
10338 }
10339 }
10340
10341 func __asm_proxy_VPMAXSW__(p *Program, v ...interface{}) *Instruction {
10342 if len(v) == 3 {
10343 return p.VPMAXSW(v[0], v[1], v[2])
10344 } else {
10345 panic("instruction VPMAXSW takes exactly 3 operands")
10346 }
10347 }
10348
10349 func __asm_proxy_VPMAXUB__(p *Program, v ...interface{}) *Instruction {
10350 if len(v) == 3 {
10351 return p.VPMAXUB(v[0], v[1], v[2])
10352 } else {
10353 panic("instruction VPMAXUB takes exactly 3 operands")
10354 }
10355 }
10356
10357 func __asm_proxy_VPMAXUD__(p *Program, v ...interface{}) *Instruction {
10358 if len(v) == 3 {
10359 return p.VPMAXUD(v[0], v[1], v[2])
10360 } else {
10361 panic("instruction VPMAXUD takes exactly 3 operands")
10362 }
10363 }
10364
10365 func __asm_proxy_VPMAXUQ__(p *Program, v ...interface{}) *Instruction {
10366 if len(v) == 3 {
10367 return p.VPMAXUQ(v[0], v[1], v[2])
10368 } else {
10369 panic("instruction VPMAXUQ takes exactly 3 operands")
10370 }
10371 }
10372
10373 func __asm_proxy_VPMAXUW__(p *Program, v ...interface{}) *Instruction {
10374 if len(v) == 3 {
10375 return p.VPMAXUW(v[0], v[1], v[2])
10376 } else {
10377 panic("instruction VPMAXUW takes exactly 3 operands")
10378 }
10379 }
10380
10381 func __asm_proxy_VPMINSB__(p *Program, v ...interface{}) *Instruction {
10382 if len(v) == 3 {
10383 return p.VPMINSB(v[0], v[1], v[2])
10384 } else {
10385 panic("instruction VPMINSB takes exactly 3 operands")
10386 }
10387 }
10388
10389 func __asm_proxy_VPMINSD__(p *Program, v ...interface{}) *Instruction {
10390 if len(v) == 3 {
10391 return p.VPMINSD(v[0], v[1], v[2])
10392 } else {
10393 panic("instruction VPMINSD takes exactly 3 operands")
10394 }
10395 }
10396
10397 func __asm_proxy_VPMINSQ__(p *Program, v ...interface{}) *Instruction {
10398 if len(v) == 3 {
10399 return p.VPMINSQ(v[0], v[1], v[2])
10400 } else {
10401 panic("instruction VPMINSQ takes exactly 3 operands")
10402 }
10403 }
10404
10405 func __asm_proxy_VPMINSW__(p *Program, v ...interface{}) *Instruction {
10406 if len(v) == 3 {
10407 return p.VPMINSW(v[0], v[1], v[2])
10408 } else {
10409 panic("instruction VPMINSW takes exactly 3 operands")
10410 }
10411 }
10412
10413 func __asm_proxy_VPMINUB__(p *Program, v ...interface{}) *Instruction {
10414 if len(v) == 3 {
10415 return p.VPMINUB(v[0], v[1], v[2])
10416 } else {
10417 panic("instruction VPMINUB takes exactly 3 operands")
10418 }
10419 }
10420
10421 func __asm_proxy_VPMINUD__(p *Program, v ...interface{}) *Instruction {
10422 if len(v) == 3 {
10423 return p.VPMINUD(v[0], v[1], v[2])
10424 } else {
10425 panic("instruction VPMINUD takes exactly 3 operands")
10426 }
10427 }
10428
10429 func __asm_proxy_VPMINUQ__(p *Program, v ...interface{}) *Instruction {
10430 if len(v) == 3 {
10431 return p.VPMINUQ(v[0], v[1], v[2])
10432 } else {
10433 panic("instruction VPMINUQ takes exactly 3 operands")
10434 }
10435 }
10436
10437 func __asm_proxy_VPMINUW__(p *Program, v ...interface{}) *Instruction {
10438 if len(v) == 3 {
10439 return p.VPMINUW(v[0], v[1], v[2])
10440 } else {
10441 panic("instruction VPMINUW takes exactly 3 operands")
10442 }
10443 }
10444
10445 func __asm_proxy_VPMOVB2M__(p *Program, v ...interface{}) *Instruction {
10446 if len(v) == 2 {
10447 return p.VPMOVB2M(v[0], v[1])
10448 } else {
10449 panic("instruction VPMOVB2M takes exactly 2 operands")
10450 }
10451 }
10452
10453 func __asm_proxy_VPMOVD2M__(p *Program, v ...interface{}) *Instruction {
10454 if len(v) == 2 {
10455 return p.VPMOVD2M(v[0], v[1])
10456 } else {
10457 panic("instruction VPMOVD2M takes exactly 2 operands")
10458 }
10459 }
10460
10461 func __asm_proxy_VPMOVDB__(p *Program, v ...interface{}) *Instruction {
10462 if len(v) == 2 {
10463 return p.VPMOVDB(v[0], v[1])
10464 } else {
10465 panic("instruction VPMOVDB takes exactly 2 operands")
10466 }
10467 }
10468
10469 func __asm_proxy_VPMOVDW__(p *Program, v ...interface{}) *Instruction {
10470 if len(v) == 2 {
10471 return p.VPMOVDW(v[0], v[1])
10472 } else {
10473 panic("instruction VPMOVDW takes exactly 2 operands")
10474 }
10475 }
10476
10477 func __asm_proxy_VPMOVM2B__(p *Program, v ...interface{}) *Instruction {
10478 if len(v) == 2 {
10479 return p.VPMOVM2B(v[0], v[1])
10480 } else {
10481 panic("instruction VPMOVM2B takes exactly 2 operands")
10482 }
10483 }
10484
10485 func __asm_proxy_VPMOVM2D__(p *Program, v ...interface{}) *Instruction {
10486 if len(v) == 2 {
10487 return p.VPMOVM2D(v[0], v[1])
10488 } else {
10489 panic("instruction VPMOVM2D takes exactly 2 operands")
10490 }
10491 }
10492
10493 func __asm_proxy_VPMOVM2Q__(p *Program, v ...interface{}) *Instruction {
10494 if len(v) == 2 {
10495 return p.VPMOVM2Q(v[0], v[1])
10496 } else {
10497 panic("instruction VPMOVM2Q takes exactly 2 operands")
10498 }
10499 }
10500
10501 func __asm_proxy_VPMOVM2W__(p *Program, v ...interface{}) *Instruction {
10502 if len(v) == 2 {
10503 return p.VPMOVM2W(v[0], v[1])
10504 } else {
10505 panic("instruction VPMOVM2W takes exactly 2 operands")
10506 }
10507 }
10508
10509 func __asm_proxy_VPMOVMSKB__(p *Program, v ...interface{}) *Instruction {
10510 if len(v) == 2 {
10511 return p.VPMOVMSKB(v[0], v[1])
10512 } else {
10513 panic("instruction VPMOVMSKB takes exactly 2 operands")
10514 }
10515 }
10516
10517 func __asm_proxy_VPMOVQ2M__(p *Program, v ...interface{}) *Instruction {
10518 if len(v) == 2 {
10519 return p.VPMOVQ2M(v[0], v[1])
10520 } else {
10521 panic("instruction VPMOVQ2M takes exactly 2 operands")
10522 }
10523 }
10524
10525 func __asm_proxy_VPMOVQB__(p *Program, v ...interface{}) *Instruction {
10526 if len(v) == 2 {
10527 return p.VPMOVQB(v[0], v[1])
10528 } else {
10529 panic("instruction VPMOVQB takes exactly 2 operands")
10530 }
10531 }
10532
10533 func __asm_proxy_VPMOVQD__(p *Program, v ...interface{}) *Instruction {
10534 if len(v) == 2 {
10535 return p.VPMOVQD(v[0], v[1])
10536 } else {
10537 panic("instruction VPMOVQD takes exactly 2 operands")
10538 }
10539 }
10540
10541 func __asm_proxy_VPMOVQW__(p *Program, v ...interface{}) *Instruction {
10542 if len(v) == 2 {
10543 return p.VPMOVQW(v[0], v[1])
10544 } else {
10545 panic("instruction VPMOVQW takes exactly 2 operands")
10546 }
10547 }
10548
10549 func __asm_proxy_VPMOVSDB__(p *Program, v ...interface{}) *Instruction {
10550 if len(v) == 2 {
10551 return p.VPMOVSDB(v[0], v[1])
10552 } else {
10553 panic("instruction VPMOVSDB takes exactly 2 operands")
10554 }
10555 }
10556
10557 func __asm_proxy_VPMOVSDW__(p *Program, v ...interface{}) *Instruction {
10558 if len(v) == 2 {
10559 return p.VPMOVSDW(v[0], v[1])
10560 } else {
10561 panic("instruction VPMOVSDW takes exactly 2 operands")
10562 }
10563 }
10564
10565 func __asm_proxy_VPMOVSQB__(p *Program, v ...interface{}) *Instruction {
10566 if len(v) == 2 {
10567 return p.VPMOVSQB(v[0], v[1])
10568 } else {
10569 panic("instruction VPMOVSQB takes exactly 2 operands")
10570 }
10571 }
10572
10573 func __asm_proxy_VPMOVSQD__(p *Program, v ...interface{}) *Instruction {
10574 if len(v) == 2 {
10575 return p.VPMOVSQD(v[0], v[1])
10576 } else {
10577 panic("instruction VPMOVSQD takes exactly 2 operands")
10578 }
10579 }
10580
10581 func __asm_proxy_VPMOVSQW__(p *Program, v ...interface{}) *Instruction {
10582 if len(v) == 2 {
10583 return p.VPMOVSQW(v[0], v[1])
10584 } else {
10585 panic("instruction VPMOVSQW takes exactly 2 operands")
10586 }
10587 }
10588
10589 func __asm_proxy_VPMOVSWB__(p *Program, v ...interface{}) *Instruction {
10590 if len(v) == 2 {
10591 return p.VPMOVSWB(v[0], v[1])
10592 } else {
10593 panic("instruction VPMOVSWB takes exactly 2 operands")
10594 }
10595 }
10596
10597 func __asm_proxy_VPMOVSXBD__(p *Program, v ...interface{}) *Instruction {
10598 if len(v) == 2 {
10599 return p.VPMOVSXBD(v[0], v[1])
10600 } else {
10601 panic("instruction VPMOVSXBD takes exactly 2 operands")
10602 }
10603 }
10604
10605 func __asm_proxy_VPMOVSXBQ__(p *Program, v ...interface{}) *Instruction {
10606 if len(v) == 2 {
10607 return p.VPMOVSXBQ(v[0], v[1])
10608 } else {
10609 panic("instruction VPMOVSXBQ takes exactly 2 operands")
10610 }
10611 }
10612
10613 func __asm_proxy_VPMOVSXBW__(p *Program, v ...interface{}) *Instruction {
10614 if len(v) == 2 {
10615 return p.VPMOVSXBW(v[0], v[1])
10616 } else {
10617 panic("instruction VPMOVSXBW takes exactly 2 operands")
10618 }
10619 }
10620
10621 func __asm_proxy_VPMOVSXDQ__(p *Program, v ...interface{}) *Instruction {
10622 if len(v) == 2 {
10623 return p.VPMOVSXDQ(v[0], v[1])
10624 } else {
10625 panic("instruction VPMOVSXDQ takes exactly 2 operands")
10626 }
10627 }
10628
10629 func __asm_proxy_VPMOVSXWD__(p *Program, v ...interface{}) *Instruction {
10630 if len(v) == 2 {
10631 return p.VPMOVSXWD(v[0], v[1])
10632 } else {
10633 panic("instruction VPMOVSXWD takes exactly 2 operands")
10634 }
10635 }
10636
10637 func __asm_proxy_VPMOVSXWQ__(p *Program, v ...interface{}) *Instruction {
10638 if len(v) == 2 {
10639 return p.VPMOVSXWQ(v[0], v[1])
10640 } else {
10641 panic("instruction VPMOVSXWQ takes exactly 2 operands")
10642 }
10643 }
10644
10645 func __asm_proxy_VPMOVUSDB__(p *Program, v ...interface{}) *Instruction {
10646 if len(v) == 2 {
10647 return p.VPMOVUSDB(v[0], v[1])
10648 } else {
10649 panic("instruction VPMOVUSDB takes exactly 2 operands")
10650 }
10651 }
10652
10653 func __asm_proxy_VPMOVUSDW__(p *Program, v ...interface{}) *Instruction {
10654 if len(v) == 2 {
10655 return p.VPMOVUSDW(v[0], v[1])
10656 } else {
10657 panic("instruction VPMOVUSDW takes exactly 2 operands")
10658 }
10659 }
10660
10661 func __asm_proxy_VPMOVUSQB__(p *Program, v ...interface{}) *Instruction {
10662 if len(v) == 2 {
10663 return p.VPMOVUSQB(v[0], v[1])
10664 } else {
10665 panic("instruction VPMOVUSQB takes exactly 2 operands")
10666 }
10667 }
10668
10669 func __asm_proxy_VPMOVUSQD__(p *Program, v ...interface{}) *Instruction {
10670 if len(v) == 2 {
10671 return p.VPMOVUSQD(v[0], v[1])
10672 } else {
10673 panic("instruction VPMOVUSQD takes exactly 2 operands")
10674 }
10675 }
10676
10677 func __asm_proxy_VPMOVUSQW__(p *Program, v ...interface{}) *Instruction {
10678 if len(v) == 2 {
10679 return p.VPMOVUSQW(v[0], v[1])
10680 } else {
10681 panic("instruction VPMOVUSQW takes exactly 2 operands")
10682 }
10683 }
10684
10685 func __asm_proxy_VPMOVUSWB__(p *Program, v ...interface{}) *Instruction {
10686 if len(v) == 2 {
10687 return p.VPMOVUSWB(v[0], v[1])
10688 } else {
10689 panic("instruction VPMOVUSWB takes exactly 2 operands")
10690 }
10691 }
10692
10693 func __asm_proxy_VPMOVW2M__(p *Program, v ...interface{}) *Instruction {
10694 if len(v) == 2 {
10695 return p.VPMOVW2M(v[0], v[1])
10696 } else {
10697 panic("instruction VPMOVW2M takes exactly 2 operands")
10698 }
10699 }
10700
10701 func __asm_proxy_VPMOVWB__(p *Program, v ...interface{}) *Instruction {
10702 if len(v) == 2 {
10703 return p.VPMOVWB(v[0], v[1])
10704 } else {
10705 panic("instruction VPMOVWB takes exactly 2 operands")
10706 }
10707 }
10708
10709 func __asm_proxy_VPMOVZXBD__(p *Program, v ...interface{}) *Instruction {
10710 if len(v) == 2 {
10711 return p.VPMOVZXBD(v[0], v[1])
10712 } else {
10713 panic("instruction VPMOVZXBD takes exactly 2 operands")
10714 }
10715 }
10716
10717 func __asm_proxy_VPMOVZXBQ__(p *Program, v ...interface{}) *Instruction {
10718 if len(v) == 2 {
10719 return p.VPMOVZXBQ(v[0], v[1])
10720 } else {
10721 panic("instruction VPMOVZXBQ takes exactly 2 operands")
10722 }
10723 }
10724
10725 func __asm_proxy_VPMOVZXBW__(p *Program, v ...interface{}) *Instruction {
10726 if len(v) == 2 {
10727 return p.VPMOVZXBW(v[0], v[1])
10728 } else {
10729 panic("instruction VPMOVZXBW takes exactly 2 operands")
10730 }
10731 }
10732
10733 func __asm_proxy_VPMOVZXDQ__(p *Program, v ...interface{}) *Instruction {
10734 if len(v) == 2 {
10735 return p.VPMOVZXDQ(v[0], v[1])
10736 } else {
10737 panic("instruction VPMOVZXDQ takes exactly 2 operands")
10738 }
10739 }
10740
10741 func __asm_proxy_VPMOVZXWD__(p *Program, v ...interface{}) *Instruction {
10742 if len(v) == 2 {
10743 return p.VPMOVZXWD(v[0], v[1])
10744 } else {
10745 panic("instruction VPMOVZXWD takes exactly 2 operands")
10746 }
10747 }
10748
10749 func __asm_proxy_VPMOVZXWQ__(p *Program, v ...interface{}) *Instruction {
10750 if len(v) == 2 {
10751 return p.VPMOVZXWQ(v[0], v[1])
10752 } else {
10753 panic("instruction VPMOVZXWQ takes exactly 2 operands")
10754 }
10755 }
10756
10757 func __asm_proxy_VPMULDQ__(p *Program, v ...interface{}) *Instruction {
10758 if len(v) == 3 {
10759 return p.VPMULDQ(v[0], v[1], v[2])
10760 } else {
10761 panic("instruction VPMULDQ takes exactly 3 operands")
10762 }
10763 }
10764
10765 func __asm_proxy_VPMULHRSW__(p *Program, v ...interface{}) *Instruction {
10766 if len(v) == 3 {
10767 return p.VPMULHRSW(v[0], v[1], v[2])
10768 } else {
10769 panic("instruction VPMULHRSW takes exactly 3 operands")
10770 }
10771 }
10772
10773 func __asm_proxy_VPMULHUW__(p *Program, v ...interface{}) *Instruction {
10774 if len(v) == 3 {
10775 return p.VPMULHUW(v[0], v[1], v[2])
10776 } else {
10777 panic("instruction VPMULHUW takes exactly 3 operands")
10778 }
10779 }
10780
10781 func __asm_proxy_VPMULHW__(p *Program, v ...interface{}) *Instruction {
10782 if len(v) == 3 {
10783 return p.VPMULHW(v[0], v[1], v[2])
10784 } else {
10785 panic("instruction VPMULHW takes exactly 3 operands")
10786 }
10787 }
10788
10789 func __asm_proxy_VPMULLD__(p *Program, v ...interface{}) *Instruction {
10790 if len(v) == 3 {
10791 return p.VPMULLD(v[0], v[1], v[2])
10792 } else {
10793 panic("instruction VPMULLD takes exactly 3 operands")
10794 }
10795 }
10796
10797 func __asm_proxy_VPMULLQ__(p *Program, v ...interface{}) *Instruction {
10798 if len(v) == 3 {
10799 return p.VPMULLQ(v[0], v[1], v[2])
10800 } else {
10801 panic("instruction VPMULLQ takes exactly 3 operands")
10802 }
10803 }
10804
10805 func __asm_proxy_VPMULLW__(p *Program, v ...interface{}) *Instruction {
10806 if len(v) == 3 {
10807 return p.VPMULLW(v[0], v[1], v[2])
10808 } else {
10809 panic("instruction VPMULLW takes exactly 3 operands")
10810 }
10811 }
10812
10813 func __asm_proxy_VPMULTISHIFTQB__(p *Program, v ...interface{}) *Instruction {
10814 if len(v) == 3 {
10815 return p.VPMULTISHIFTQB(v[0], v[1], v[2])
10816 } else {
10817 panic("instruction VPMULTISHIFTQB takes exactly 3 operands")
10818 }
10819 }
10820
10821 func __asm_proxy_VPMULUDQ__(p *Program, v ...interface{}) *Instruction {
10822 if len(v) == 3 {
10823 return p.VPMULUDQ(v[0], v[1], v[2])
10824 } else {
10825 panic("instruction VPMULUDQ takes exactly 3 operands")
10826 }
10827 }
10828
10829 func __asm_proxy_VPOPCNTD__(p *Program, v ...interface{}) *Instruction {
10830 if len(v) == 2 {
10831 return p.VPOPCNTD(v[0], v[1])
10832 } else {
10833 panic("instruction VPOPCNTD takes exactly 2 operands")
10834 }
10835 }
10836
10837 func __asm_proxy_VPOPCNTQ__(p *Program, v ...interface{}) *Instruction {
10838 if len(v) == 2 {
10839 return p.VPOPCNTQ(v[0], v[1])
10840 } else {
10841 panic("instruction VPOPCNTQ takes exactly 2 operands")
10842 }
10843 }
10844
10845 func __asm_proxy_VPOR__(p *Program, v ...interface{}) *Instruction {
10846 if len(v) == 3 {
10847 return p.VPOR(v[0], v[1], v[2])
10848 } else {
10849 panic("instruction VPOR takes exactly 3 operands")
10850 }
10851 }
10852
10853 func __asm_proxy_VPORD__(p *Program, v ...interface{}) *Instruction {
10854 if len(v) == 3 {
10855 return p.VPORD(v[0], v[1], v[2])
10856 } else {
10857 panic("instruction VPORD takes exactly 3 operands")
10858 }
10859 }
10860
10861 func __asm_proxy_VPORQ__(p *Program, v ...interface{}) *Instruction {
10862 if len(v) == 3 {
10863 return p.VPORQ(v[0], v[1], v[2])
10864 } else {
10865 panic("instruction VPORQ takes exactly 3 operands")
10866 }
10867 }
10868
10869 func __asm_proxy_VPPERM__(p *Program, v ...interface{}) *Instruction {
10870 if len(v) == 4 {
10871 return p.VPPERM(v[0], v[1], v[2], v[3])
10872 } else {
10873 panic("instruction VPPERM takes exactly 4 operands")
10874 }
10875 }
10876
10877 func __asm_proxy_VPROLD__(p *Program, v ...interface{}) *Instruction {
10878 if len(v) == 3 {
10879 return p.VPROLD(v[0], v[1], v[2])
10880 } else {
10881 panic("instruction VPROLD takes exactly 3 operands")
10882 }
10883 }
10884
10885 func __asm_proxy_VPROLQ__(p *Program, v ...interface{}) *Instruction {
10886 if len(v) == 3 {
10887 return p.VPROLQ(v[0], v[1], v[2])
10888 } else {
10889 panic("instruction VPROLQ takes exactly 3 operands")
10890 }
10891 }
10892
10893 func __asm_proxy_VPROLVD__(p *Program, v ...interface{}) *Instruction {
10894 if len(v) == 3 {
10895 return p.VPROLVD(v[0], v[1], v[2])
10896 } else {
10897 panic("instruction VPROLVD takes exactly 3 operands")
10898 }
10899 }
10900
10901 func __asm_proxy_VPROLVQ__(p *Program, v ...interface{}) *Instruction {
10902 if len(v) == 3 {
10903 return p.VPROLVQ(v[0], v[1], v[2])
10904 } else {
10905 panic("instruction VPROLVQ takes exactly 3 operands")
10906 }
10907 }
10908
10909 func __asm_proxy_VPRORD__(p *Program, v ...interface{}) *Instruction {
10910 if len(v) == 3 {
10911 return p.VPRORD(v[0], v[1], v[2])
10912 } else {
10913 panic("instruction VPRORD takes exactly 3 operands")
10914 }
10915 }
10916
10917 func __asm_proxy_VPRORQ__(p *Program, v ...interface{}) *Instruction {
10918 if len(v) == 3 {
10919 return p.VPRORQ(v[0], v[1], v[2])
10920 } else {
10921 panic("instruction VPRORQ takes exactly 3 operands")
10922 }
10923 }
10924
10925 func __asm_proxy_VPRORVD__(p *Program, v ...interface{}) *Instruction {
10926 if len(v) == 3 {
10927 return p.VPRORVD(v[0], v[1], v[2])
10928 } else {
10929 panic("instruction VPRORVD takes exactly 3 operands")
10930 }
10931 }
10932
10933 func __asm_proxy_VPRORVQ__(p *Program, v ...interface{}) *Instruction {
10934 if len(v) == 3 {
10935 return p.VPRORVQ(v[0], v[1], v[2])
10936 } else {
10937 panic("instruction VPRORVQ takes exactly 3 operands")
10938 }
10939 }
10940
10941 func __asm_proxy_VPROTB__(p *Program, v ...interface{}) *Instruction {
10942 if len(v) == 3 {
10943 return p.VPROTB(v[0], v[1], v[2])
10944 } else {
10945 panic("instruction VPROTB takes exactly 3 operands")
10946 }
10947 }
10948
10949 func __asm_proxy_VPROTD__(p *Program, v ...interface{}) *Instruction {
10950 if len(v) == 3 {
10951 return p.VPROTD(v[0], v[1], v[2])
10952 } else {
10953 panic("instruction VPROTD takes exactly 3 operands")
10954 }
10955 }
10956
10957 func __asm_proxy_VPROTQ__(p *Program, v ...interface{}) *Instruction {
10958 if len(v) == 3 {
10959 return p.VPROTQ(v[0], v[1], v[2])
10960 } else {
10961 panic("instruction VPROTQ takes exactly 3 operands")
10962 }
10963 }
10964
10965 func __asm_proxy_VPROTW__(p *Program, v ...interface{}) *Instruction {
10966 if len(v) == 3 {
10967 return p.VPROTW(v[0], v[1], v[2])
10968 } else {
10969 panic("instruction VPROTW takes exactly 3 operands")
10970 }
10971 }
10972
10973 func __asm_proxy_VPSADBW__(p *Program, v ...interface{}) *Instruction {
10974 if len(v) == 3 {
10975 return p.VPSADBW(v[0], v[1], v[2])
10976 } else {
10977 panic("instruction VPSADBW takes exactly 3 operands")
10978 }
10979 }
10980
10981 func __asm_proxy_VPSCATTERDD__(p *Program, v ...interface{}) *Instruction {
10982 if len(v) == 2 {
10983 return p.VPSCATTERDD(v[0], v[1])
10984 } else {
10985 panic("instruction VPSCATTERDD takes exactly 2 operands")
10986 }
10987 }
10988
10989 func __asm_proxy_VPSCATTERDQ__(p *Program, v ...interface{}) *Instruction {
10990 if len(v) == 2 {
10991 return p.VPSCATTERDQ(v[0], v[1])
10992 } else {
10993 panic("instruction VPSCATTERDQ takes exactly 2 operands")
10994 }
10995 }
10996
10997 func __asm_proxy_VPSCATTERQD__(p *Program, v ...interface{}) *Instruction {
10998 if len(v) == 2 {
10999 return p.VPSCATTERQD(v[0], v[1])
11000 } else {
11001 panic("instruction VPSCATTERQD takes exactly 2 operands")
11002 }
11003 }
11004
11005 func __asm_proxy_VPSCATTERQQ__(p *Program, v ...interface{}) *Instruction {
11006 if len(v) == 2 {
11007 return p.VPSCATTERQQ(v[0], v[1])
11008 } else {
11009 panic("instruction VPSCATTERQQ takes exactly 2 operands")
11010 }
11011 }
11012
11013 func __asm_proxy_VPSHAB__(p *Program, v ...interface{}) *Instruction {
11014 if len(v) == 3 {
11015 return p.VPSHAB(v[0], v[1], v[2])
11016 } else {
11017 panic("instruction VPSHAB takes exactly 3 operands")
11018 }
11019 }
11020
11021 func __asm_proxy_VPSHAD__(p *Program, v ...interface{}) *Instruction {
11022 if len(v) == 3 {
11023 return p.VPSHAD(v[0], v[1], v[2])
11024 } else {
11025 panic("instruction VPSHAD takes exactly 3 operands")
11026 }
11027 }
11028
11029 func __asm_proxy_VPSHAQ__(p *Program, v ...interface{}) *Instruction {
11030 if len(v) == 3 {
11031 return p.VPSHAQ(v[0], v[1], v[2])
11032 } else {
11033 panic("instruction VPSHAQ takes exactly 3 operands")
11034 }
11035 }
11036
11037 func __asm_proxy_VPSHAW__(p *Program, v ...interface{}) *Instruction {
11038 if len(v) == 3 {
11039 return p.VPSHAW(v[0], v[1], v[2])
11040 } else {
11041 panic("instruction VPSHAW takes exactly 3 operands")
11042 }
11043 }
11044
11045 func __asm_proxy_VPSHLB__(p *Program, v ...interface{}) *Instruction {
11046 if len(v) == 3 {
11047 return p.VPSHLB(v[0], v[1], v[2])
11048 } else {
11049 panic("instruction VPSHLB takes exactly 3 operands")
11050 }
11051 }
11052
11053 func __asm_proxy_VPSHLD__(p *Program, v ...interface{}) *Instruction {
11054 if len(v) == 3 {
11055 return p.VPSHLD(v[0], v[1], v[2])
11056 } else {
11057 panic("instruction VPSHLD takes exactly 3 operands")
11058 }
11059 }
11060
11061 func __asm_proxy_VPSHLQ__(p *Program, v ...interface{}) *Instruction {
11062 if len(v) == 3 {
11063 return p.VPSHLQ(v[0], v[1], v[2])
11064 } else {
11065 panic("instruction VPSHLQ takes exactly 3 operands")
11066 }
11067 }
11068
11069 func __asm_proxy_VPSHLW__(p *Program, v ...interface{}) *Instruction {
11070 if len(v) == 3 {
11071 return p.VPSHLW(v[0], v[1], v[2])
11072 } else {
11073 panic("instruction VPSHLW takes exactly 3 operands")
11074 }
11075 }
11076
11077 func __asm_proxy_VPSHUFB__(p *Program, v ...interface{}) *Instruction {
11078 if len(v) == 3 {
11079 return p.VPSHUFB(v[0], v[1], v[2])
11080 } else {
11081 panic("instruction VPSHUFB takes exactly 3 operands")
11082 }
11083 }
11084
11085 func __asm_proxy_VPSHUFD__(p *Program, v ...interface{}) *Instruction {
11086 if len(v) == 3 {
11087 return p.VPSHUFD(v[0], v[1], v[2])
11088 } else {
11089 panic("instruction VPSHUFD takes exactly 3 operands")
11090 }
11091 }
11092
11093 func __asm_proxy_VPSHUFHW__(p *Program, v ...interface{}) *Instruction {
11094 if len(v) == 3 {
11095 return p.VPSHUFHW(v[0], v[1], v[2])
11096 } else {
11097 panic("instruction VPSHUFHW takes exactly 3 operands")
11098 }
11099 }
11100
11101 func __asm_proxy_VPSHUFLW__(p *Program, v ...interface{}) *Instruction {
11102 if len(v) == 3 {
11103 return p.VPSHUFLW(v[0], v[1], v[2])
11104 } else {
11105 panic("instruction VPSHUFLW takes exactly 3 operands")
11106 }
11107 }
11108
11109 func __asm_proxy_VPSIGNB__(p *Program, v ...interface{}) *Instruction {
11110 if len(v) == 3 {
11111 return p.VPSIGNB(v[0], v[1], v[2])
11112 } else {
11113 panic("instruction VPSIGNB takes exactly 3 operands")
11114 }
11115 }
11116
11117 func __asm_proxy_VPSIGND__(p *Program, v ...interface{}) *Instruction {
11118 if len(v) == 3 {
11119 return p.VPSIGND(v[0], v[1], v[2])
11120 } else {
11121 panic("instruction VPSIGND takes exactly 3 operands")
11122 }
11123 }
11124
11125 func __asm_proxy_VPSIGNW__(p *Program, v ...interface{}) *Instruction {
11126 if len(v) == 3 {
11127 return p.VPSIGNW(v[0], v[1], v[2])
11128 } else {
11129 panic("instruction VPSIGNW takes exactly 3 operands")
11130 }
11131 }
11132
11133 func __asm_proxy_VPSLLD__(p *Program, v ...interface{}) *Instruction {
11134 if len(v) == 3 {
11135 return p.VPSLLD(v[0], v[1], v[2])
11136 } else {
11137 panic("instruction VPSLLD takes exactly 3 operands")
11138 }
11139 }
11140
11141 func __asm_proxy_VPSLLDQ__(p *Program, v ...interface{}) *Instruction {
11142 if len(v) == 3 {
11143 return p.VPSLLDQ(v[0], v[1], v[2])
11144 } else {
11145 panic("instruction VPSLLDQ takes exactly 3 operands")
11146 }
11147 }
11148
11149 func __asm_proxy_VPSLLQ__(p *Program, v ...interface{}) *Instruction {
11150 if len(v) == 3 {
11151 return p.VPSLLQ(v[0], v[1], v[2])
11152 } else {
11153 panic("instruction VPSLLQ takes exactly 3 operands")
11154 }
11155 }
11156
11157 func __asm_proxy_VPSLLVD__(p *Program, v ...interface{}) *Instruction {
11158 if len(v) == 3 {
11159 return p.VPSLLVD(v[0], v[1], v[2])
11160 } else {
11161 panic("instruction VPSLLVD takes exactly 3 operands")
11162 }
11163 }
11164
11165 func __asm_proxy_VPSLLVQ__(p *Program, v ...interface{}) *Instruction {
11166 if len(v) == 3 {
11167 return p.VPSLLVQ(v[0], v[1], v[2])
11168 } else {
11169 panic("instruction VPSLLVQ takes exactly 3 operands")
11170 }
11171 }
11172
11173 func __asm_proxy_VPSLLVW__(p *Program, v ...interface{}) *Instruction {
11174 if len(v) == 3 {
11175 return p.VPSLLVW(v[0], v[1], v[2])
11176 } else {
11177 panic("instruction VPSLLVW takes exactly 3 operands")
11178 }
11179 }
11180
11181 func __asm_proxy_VPSLLW__(p *Program, v ...interface{}) *Instruction {
11182 if len(v) == 3 {
11183 return p.VPSLLW(v[0], v[1], v[2])
11184 } else {
11185 panic("instruction VPSLLW takes exactly 3 operands")
11186 }
11187 }
11188
11189 func __asm_proxy_VPSRAD__(p *Program, v ...interface{}) *Instruction {
11190 if len(v) == 3 {
11191 return p.VPSRAD(v[0], v[1], v[2])
11192 } else {
11193 panic("instruction VPSRAD takes exactly 3 operands")
11194 }
11195 }
11196
11197 func __asm_proxy_VPSRAQ__(p *Program, v ...interface{}) *Instruction {
11198 if len(v) == 3 {
11199 return p.VPSRAQ(v[0], v[1], v[2])
11200 } else {
11201 panic("instruction VPSRAQ takes exactly 3 operands")
11202 }
11203 }
11204
11205 func __asm_proxy_VPSRAVD__(p *Program, v ...interface{}) *Instruction {
11206 if len(v) == 3 {
11207 return p.VPSRAVD(v[0], v[1], v[2])
11208 } else {
11209 panic("instruction VPSRAVD takes exactly 3 operands")
11210 }
11211 }
11212
11213 func __asm_proxy_VPSRAVQ__(p *Program, v ...interface{}) *Instruction {
11214 if len(v) == 3 {
11215 return p.VPSRAVQ(v[0], v[1], v[2])
11216 } else {
11217 panic("instruction VPSRAVQ takes exactly 3 operands")
11218 }
11219 }
11220
11221 func __asm_proxy_VPSRAVW__(p *Program, v ...interface{}) *Instruction {
11222 if len(v) == 3 {
11223 return p.VPSRAVW(v[0], v[1], v[2])
11224 } else {
11225 panic("instruction VPSRAVW takes exactly 3 operands")
11226 }
11227 }
11228
11229 func __asm_proxy_VPSRAW__(p *Program, v ...interface{}) *Instruction {
11230 if len(v) == 3 {
11231 return p.VPSRAW(v[0], v[1], v[2])
11232 } else {
11233 panic("instruction VPSRAW takes exactly 3 operands")
11234 }
11235 }
11236
11237 func __asm_proxy_VPSRLD__(p *Program, v ...interface{}) *Instruction {
11238 if len(v) == 3 {
11239 return p.VPSRLD(v[0], v[1], v[2])
11240 } else {
11241 panic("instruction VPSRLD takes exactly 3 operands")
11242 }
11243 }
11244
11245 func __asm_proxy_VPSRLDQ__(p *Program, v ...interface{}) *Instruction {
11246 if len(v) == 3 {
11247 return p.VPSRLDQ(v[0], v[1], v[2])
11248 } else {
11249 panic("instruction VPSRLDQ takes exactly 3 operands")
11250 }
11251 }
11252
11253 func __asm_proxy_VPSRLQ__(p *Program, v ...interface{}) *Instruction {
11254 if len(v) == 3 {
11255 return p.VPSRLQ(v[0], v[1], v[2])
11256 } else {
11257 panic("instruction VPSRLQ takes exactly 3 operands")
11258 }
11259 }
11260
11261 func __asm_proxy_VPSRLVD__(p *Program, v ...interface{}) *Instruction {
11262 if len(v) == 3 {
11263 return p.VPSRLVD(v[0], v[1], v[2])
11264 } else {
11265 panic("instruction VPSRLVD takes exactly 3 operands")
11266 }
11267 }
11268
11269 func __asm_proxy_VPSRLVQ__(p *Program, v ...interface{}) *Instruction {
11270 if len(v) == 3 {
11271 return p.VPSRLVQ(v[0], v[1], v[2])
11272 } else {
11273 panic("instruction VPSRLVQ takes exactly 3 operands")
11274 }
11275 }
11276
11277 func __asm_proxy_VPSRLVW__(p *Program, v ...interface{}) *Instruction {
11278 if len(v) == 3 {
11279 return p.VPSRLVW(v[0], v[1], v[2])
11280 } else {
11281 panic("instruction VPSRLVW takes exactly 3 operands")
11282 }
11283 }
11284
11285 func __asm_proxy_VPSRLW__(p *Program, v ...interface{}) *Instruction {
11286 if len(v) == 3 {
11287 return p.VPSRLW(v[0], v[1], v[2])
11288 } else {
11289 panic("instruction VPSRLW takes exactly 3 operands")
11290 }
11291 }
11292
11293 func __asm_proxy_VPSUBB__(p *Program, v ...interface{}) *Instruction {
11294 if len(v) == 3 {
11295 return p.VPSUBB(v[0], v[1], v[2])
11296 } else {
11297 panic("instruction VPSUBB takes exactly 3 operands")
11298 }
11299 }
11300
11301 func __asm_proxy_VPSUBD__(p *Program, v ...interface{}) *Instruction {
11302 if len(v) == 3 {
11303 return p.VPSUBD(v[0], v[1], v[2])
11304 } else {
11305 panic("instruction VPSUBD takes exactly 3 operands")
11306 }
11307 }
11308
11309 func __asm_proxy_VPSUBQ__(p *Program, v ...interface{}) *Instruction {
11310 if len(v) == 3 {
11311 return p.VPSUBQ(v[0], v[1], v[2])
11312 } else {
11313 panic("instruction VPSUBQ takes exactly 3 operands")
11314 }
11315 }
11316
11317 func __asm_proxy_VPSUBSB__(p *Program, v ...interface{}) *Instruction {
11318 if len(v) == 3 {
11319 return p.VPSUBSB(v[0], v[1], v[2])
11320 } else {
11321 panic("instruction VPSUBSB takes exactly 3 operands")
11322 }
11323 }
11324
11325 func __asm_proxy_VPSUBSW__(p *Program, v ...interface{}) *Instruction {
11326 if len(v) == 3 {
11327 return p.VPSUBSW(v[0], v[1], v[2])
11328 } else {
11329 panic("instruction VPSUBSW takes exactly 3 operands")
11330 }
11331 }
11332
11333 func __asm_proxy_VPSUBUSB__(p *Program, v ...interface{}) *Instruction {
11334 if len(v) == 3 {
11335 return p.VPSUBUSB(v[0], v[1], v[2])
11336 } else {
11337 panic("instruction VPSUBUSB takes exactly 3 operands")
11338 }
11339 }
11340
11341 func __asm_proxy_VPSUBUSW__(p *Program, v ...interface{}) *Instruction {
11342 if len(v) == 3 {
11343 return p.VPSUBUSW(v[0], v[1], v[2])
11344 } else {
11345 panic("instruction VPSUBUSW takes exactly 3 operands")
11346 }
11347 }
11348
11349 func __asm_proxy_VPSUBW__(p *Program, v ...interface{}) *Instruction {
11350 if len(v) == 3 {
11351 return p.VPSUBW(v[0], v[1], v[2])
11352 } else {
11353 panic("instruction VPSUBW takes exactly 3 operands")
11354 }
11355 }
11356
11357 func __asm_proxy_VPTERNLOGD__(p *Program, v ...interface{}) *Instruction {
11358 if len(v) == 4 {
11359 return p.VPTERNLOGD(v[0], v[1], v[2], v[3])
11360 } else {
11361 panic("instruction VPTERNLOGD takes exactly 4 operands")
11362 }
11363 }
11364
11365 func __asm_proxy_VPTERNLOGQ__(p *Program, v ...interface{}) *Instruction {
11366 if len(v) == 4 {
11367 return p.VPTERNLOGQ(v[0], v[1], v[2], v[3])
11368 } else {
11369 panic("instruction VPTERNLOGQ takes exactly 4 operands")
11370 }
11371 }
11372
11373 func __asm_proxy_VPTEST__(p *Program, v ...interface{}) *Instruction {
11374 if len(v) == 2 {
11375 return p.VPTEST(v[0], v[1])
11376 } else {
11377 panic("instruction VPTEST takes exactly 2 operands")
11378 }
11379 }
11380
11381 func __asm_proxy_VPTESTMB__(p *Program, v ...interface{}) *Instruction {
11382 if len(v) == 3 {
11383 return p.VPTESTMB(v[0], v[1], v[2])
11384 } else {
11385 panic("instruction VPTESTMB takes exactly 3 operands")
11386 }
11387 }
11388
11389 func __asm_proxy_VPTESTMD__(p *Program, v ...interface{}) *Instruction {
11390 if len(v) == 3 {
11391 return p.VPTESTMD(v[0], v[1], v[2])
11392 } else {
11393 panic("instruction VPTESTMD takes exactly 3 operands")
11394 }
11395 }
11396
11397 func __asm_proxy_VPTESTMQ__(p *Program, v ...interface{}) *Instruction {
11398 if len(v) == 3 {
11399 return p.VPTESTMQ(v[0], v[1], v[2])
11400 } else {
11401 panic("instruction VPTESTMQ takes exactly 3 operands")
11402 }
11403 }
11404
11405 func __asm_proxy_VPTESTMW__(p *Program, v ...interface{}) *Instruction {
11406 if len(v) == 3 {
11407 return p.VPTESTMW(v[0], v[1], v[2])
11408 } else {
11409 panic("instruction VPTESTMW takes exactly 3 operands")
11410 }
11411 }
11412
11413 func __asm_proxy_VPTESTNMB__(p *Program, v ...interface{}) *Instruction {
11414 if len(v) == 3 {
11415 return p.VPTESTNMB(v[0], v[1], v[2])
11416 } else {
11417 panic("instruction VPTESTNMB takes exactly 3 operands")
11418 }
11419 }
11420
11421 func __asm_proxy_VPTESTNMD__(p *Program, v ...interface{}) *Instruction {
11422 if len(v) == 3 {
11423 return p.VPTESTNMD(v[0], v[1], v[2])
11424 } else {
11425 panic("instruction VPTESTNMD takes exactly 3 operands")
11426 }
11427 }
11428
11429 func __asm_proxy_VPTESTNMQ__(p *Program, v ...interface{}) *Instruction {
11430 if len(v) == 3 {
11431 return p.VPTESTNMQ(v[0], v[1], v[2])
11432 } else {
11433 panic("instruction VPTESTNMQ takes exactly 3 operands")
11434 }
11435 }
11436
11437 func __asm_proxy_VPTESTNMW__(p *Program, v ...interface{}) *Instruction {
11438 if len(v) == 3 {
11439 return p.VPTESTNMW(v[0], v[1], v[2])
11440 } else {
11441 panic("instruction VPTESTNMW takes exactly 3 operands")
11442 }
11443 }
11444
11445 func __asm_proxy_VPUNPCKHBW__(p *Program, v ...interface{}) *Instruction {
11446 if len(v) == 3 {
11447 return p.VPUNPCKHBW(v[0], v[1], v[2])
11448 } else {
11449 panic("instruction VPUNPCKHBW takes exactly 3 operands")
11450 }
11451 }
11452
11453 func __asm_proxy_VPUNPCKHDQ__(p *Program, v ...interface{}) *Instruction {
11454 if len(v) == 3 {
11455 return p.VPUNPCKHDQ(v[0], v[1], v[2])
11456 } else {
11457 panic("instruction VPUNPCKHDQ takes exactly 3 operands")
11458 }
11459 }
11460
11461 func __asm_proxy_VPUNPCKHQDQ__(p *Program, v ...interface{}) *Instruction {
11462 if len(v) == 3 {
11463 return p.VPUNPCKHQDQ(v[0], v[1], v[2])
11464 } else {
11465 panic("instruction VPUNPCKHQDQ takes exactly 3 operands")
11466 }
11467 }
11468
11469 func __asm_proxy_VPUNPCKHWD__(p *Program, v ...interface{}) *Instruction {
11470 if len(v) == 3 {
11471 return p.VPUNPCKHWD(v[0], v[1], v[2])
11472 } else {
11473 panic("instruction VPUNPCKHWD takes exactly 3 operands")
11474 }
11475 }
11476
11477 func __asm_proxy_VPUNPCKLBW__(p *Program, v ...interface{}) *Instruction {
11478 if len(v) == 3 {
11479 return p.VPUNPCKLBW(v[0], v[1], v[2])
11480 } else {
11481 panic("instruction VPUNPCKLBW takes exactly 3 operands")
11482 }
11483 }
11484
11485 func __asm_proxy_VPUNPCKLDQ__(p *Program, v ...interface{}) *Instruction {
11486 if len(v) == 3 {
11487 return p.VPUNPCKLDQ(v[0], v[1], v[2])
11488 } else {
11489 panic("instruction VPUNPCKLDQ takes exactly 3 operands")
11490 }
11491 }
11492
11493 func __asm_proxy_VPUNPCKLQDQ__(p *Program, v ...interface{}) *Instruction {
11494 if len(v) == 3 {
11495 return p.VPUNPCKLQDQ(v[0], v[1], v[2])
11496 } else {
11497 panic("instruction VPUNPCKLQDQ takes exactly 3 operands")
11498 }
11499 }
11500
11501 func __asm_proxy_VPUNPCKLWD__(p *Program, v ...interface{}) *Instruction {
11502 if len(v) == 3 {
11503 return p.VPUNPCKLWD(v[0], v[1], v[2])
11504 } else {
11505 panic("instruction VPUNPCKLWD takes exactly 3 operands")
11506 }
11507 }
11508
11509 func __asm_proxy_VPXOR__(p *Program, v ...interface{}) *Instruction {
11510 if len(v) == 3 {
11511 return p.VPXOR(v[0], v[1], v[2])
11512 } else {
11513 panic("instruction VPXOR takes exactly 3 operands")
11514 }
11515 }
11516
11517 func __asm_proxy_VPXORD__(p *Program, v ...interface{}) *Instruction {
11518 if len(v) == 3 {
11519 return p.VPXORD(v[0], v[1], v[2])
11520 } else {
11521 panic("instruction VPXORD takes exactly 3 operands")
11522 }
11523 }
11524
11525 func __asm_proxy_VPXORQ__(p *Program, v ...interface{}) *Instruction {
11526 if len(v) == 3 {
11527 return p.VPXORQ(v[0], v[1], v[2])
11528 } else {
11529 panic("instruction VPXORQ takes exactly 3 operands")
11530 }
11531 }
11532
11533 func __asm_proxy_VRANGEPD__(p *Program, v ...interface{}) *Instruction {
11534 switch len(v) {
11535 case 4 : return p.VRANGEPD(v[0], v[1], v[2], v[3])
11536 case 5 : return p.VRANGEPD(v[0], v[1], v[2], v[3], v[4])
11537 default : panic("instruction VRANGEPD takes 4 or 5 operands")
11538 }
11539 }
11540
11541 func __asm_proxy_VRANGEPS__(p *Program, v ...interface{}) *Instruction {
11542 switch len(v) {
11543 case 4 : return p.VRANGEPS(v[0], v[1], v[2], v[3])
11544 case 5 : return p.VRANGEPS(v[0], v[1], v[2], v[3], v[4])
11545 default : panic("instruction VRANGEPS takes 4 or 5 operands")
11546 }
11547 }
11548
11549 func __asm_proxy_VRANGESD__(p *Program, v ...interface{}) *Instruction {
11550 switch len(v) {
11551 case 4 : return p.VRANGESD(v[0], v[1], v[2], v[3])
11552 case 5 : return p.VRANGESD(v[0], v[1], v[2], v[3], v[4])
11553 default : panic("instruction VRANGESD takes 4 or 5 operands")
11554 }
11555 }
11556
11557 func __asm_proxy_VRANGESS__(p *Program, v ...interface{}) *Instruction {
11558 switch len(v) {
11559 case 4 : return p.VRANGESS(v[0], v[1], v[2], v[3])
11560 case 5 : return p.VRANGESS(v[0], v[1], v[2], v[3], v[4])
11561 default : panic("instruction VRANGESS takes 4 or 5 operands")
11562 }
11563 }
11564
11565 func __asm_proxy_VRCP14PD__(p *Program, v ...interface{}) *Instruction {
11566 if len(v) == 2 {
11567 return p.VRCP14PD(v[0], v[1])
11568 } else {
11569 panic("instruction VRCP14PD takes exactly 2 operands")
11570 }
11571 }
11572
11573 func __asm_proxy_VRCP14PS__(p *Program, v ...interface{}) *Instruction {
11574 if len(v) == 2 {
11575 return p.VRCP14PS(v[0], v[1])
11576 } else {
11577 panic("instruction VRCP14PS takes exactly 2 operands")
11578 }
11579 }
11580
11581 func __asm_proxy_VRCP14SD__(p *Program, v ...interface{}) *Instruction {
11582 if len(v) == 3 {
11583 return p.VRCP14SD(v[0], v[1], v[2])
11584 } else {
11585 panic("instruction VRCP14SD takes exactly 3 operands")
11586 }
11587 }
11588
11589 func __asm_proxy_VRCP14SS__(p *Program, v ...interface{}) *Instruction {
11590 if len(v) == 3 {
11591 return p.VRCP14SS(v[0], v[1], v[2])
11592 } else {
11593 panic("instruction VRCP14SS takes exactly 3 operands")
11594 }
11595 }
11596
11597 func __asm_proxy_VRCP28PD__(p *Program, v ...interface{}) *Instruction {
11598 switch len(v) {
11599 case 2 : return p.VRCP28PD(v[0], v[1])
11600 case 3 : return p.VRCP28PD(v[0], v[1], v[2])
11601 default : panic("instruction VRCP28PD takes 2 or 3 operands")
11602 }
11603 }
11604
11605 func __asm_proxy_VRCP28PS__(p *Program, v ...interface{}) *Instruction {
11606 switch len(v) {
11607 case 2 : return p.VRCP28PS(v[0], v[1])
11608 case 3 : return p.VRCP28PS(v[0], v[1], v[2])
11609 default : panic("instruction VRCP28PS takes 2 or 3 operands")
11610 }
11611 }
11612
11613 func __asm_proxy_VRCP28SD__(p *Program, v ...interface{}) *Instruction {
11614 switch len(v) {
11615 case 3 : return p.VRCP28SD(v[0], v[1], v[2])
11616 case 4 : return p.VRCP28SD(v[0], v[1], v[2], v[3])
11617 default : panic("instruction VRCP28SD takes 3 or 4 operands")
11618 }
11619 }
11620
11621 func __asm_proxy_VRCP28SS__(p *Program, v ...interface{}) *Instruction {
11622 switch len(v) {
11623 case 3 : return p.VRCP28SS(v[0], v[1], v[2])
11624 case 4 : return p.VRCP28SS(v[0], v[1], v[2], v[3])
11625 default : panic("instruction VRCP28SS takes 3 or 4 operands")
11626 }
11627 }
11628
11629 func __asm_proxy_VRCPPS__(p *Program, v ...interface{}) *Instruction {
11630 if len(v) == 2 {
11631 return p.VRCPPS(v[0], v[1])
11632 } else {
11633 panic("instruction VRCPPS takes exactly 2 operands")
11634 }
11635 }
11636
11637 func __asm_proxy_VRCPSS__(p *Program, v ...interface{}) *Instruction {
11638 if len(v) == 3 {
11639 return p.VRCPSS(v[0], v[1], v[2])
11640 } else {
11641 panic("instruction VRCPSS takes exactly 3 operands")
11642 }
11643 }
11644
11645 func __asm_proxy_VREDUCEPD__(p *Program, v ...interface{}) *Instruction {
11646 if len(v) == 3 {
11647 return p.VREDUCEPD(v[0], v[1], v[2])
11648 } else {
11649 panic("instruction VREDUCEPD takes exactly 3 operands")
11650 }
11651 }
11652
11653 func __asm_proxy_VREDUCEPS__(p *Program, v ...interface{}) *Instruction {
11654 if len(v) == 3 {
11655 return p.VREDUCEPS(v[0], v[1], v[2])
11656 } else {
11657 panic("instruction VREDUCEPS takes exactly 3 operands")
11658 }
11659 }
11660
11661 func __asm_proxy_VREDUCESD__(p *Program, v ...interface{}) *Instruction {
11662 if len(v) == 4 {
11663 return p.VREDUCESD(v[0], v[1], v[2], v[3])
11664 } else {
11665 panic("instruction VREDUCESD takes exactly 4 operands")
11666 }
11667 }
11668
11669 func __asm_proxy_VREDUCESS__(p *Program, v ...interface{}) *Instruction {
11670 if len(v) == 4 {
11671 return p.VREDUCESS(v[0], v[1], v[2], v[3])
11672 } else {
11673 panic("instruction VREDUCESS takes exactly 4 operands")
11674 }
11675 }
11676
11677 func __asm_proxy_VRNDSCALEPD__(p *Program, v ...interface{}) *Instruction {
11678 switch len(v) {
11679 case 3 : return p.VRNDSCALEPD(v[0], v[1], v[2])
11680 case 4 : return p.VRNDSCALEPD(v[0], v[1], v[2], v[3])
11681 default : panic("instruction VRNDSCALEPD takes 3 or 4 operands")
11682 }
11683 }
11684
11685 func __asm_proxy_VRNDSCALEPS__(p *Program, v ...interface{}) *Instruction {
11686 switch len(v) {
11687 case 3 : return p.VRNDSCALEPS(v[0], v[1], v[2])
11688 case 4 : return p.VRNDSCALEPS(v[0], v[1], v[2], v[3])
11689 default : panic("instruction VRNDSCALEPS takes 3 or 4 operands")
11690 }
11691 }
11692
11693 func __asm_proxy_VRNDSCALESD__(p *Program, v ...interface{}) *Instruction {
11694 switch len(v) {
11695 case 4 : return p.VRNDSCALESD(v[0], v[1], v[2], v[3])
11696 case 5 : return p.VRNDSCALESD(v[0], v[1], v[2], v[3], v[4])
11697 default : panic("instruction VRNDSCALESD takes 4 or 5 operands")
11698 }
11699 }
11700
11701 func __asm_proxy_VRNDSCALESS__(p *Program, v ...interface{}) *Instruction {
11702 switch len(v) {
11703 case 4 : return p.VRNDSCALESS(v[0], v[1], v[2], v[3])
11704 case 5 : return p.VRNDSCALESS(v[0], v[1], v[2], v[3], v[4])
11705 default : panic("instruction VRNDSCALESS takes 4 or 5 operands")
11706 }
11707 }
11708
11709 func __asm_proxy_VROUNDPD__(p *Program, v ...interface{}) *Instruction {
11710 if len(v) == 3 {
11711 return p.VROUNDPD(v[0], v[1], v[2])
11712 } else {
11713 panic("instruction VROUNDPD takes exactly 3 operands")
11714 }
11715 }
11716
11717 func __asm_proxy_VROUNDPS__(p *Program, v ...interface{}) *Instruction {
11718 if len(v) == 3 {
11719 return p.VROUNDPS(v[0], v[1], v[2])
11720 } else {
11721 panic("instruction VROUNDPS takes exactly 3 operands")
11722 }
11723 }
11724
11725 func __asm_proxy_VROUNDSD__(p *Program, v ...interface{}) *Instruction {
11726 if len(v) == 4 {
11727 return p.VROUNDSD(v[0], v[1], v[2], v[3])
11728 } else {
11729 panic("instruction VROUNDSD takes exactly 4 operands")
11730 }
11731 }
11732
11733 func __asm_proxy_VROUNDSS__(p *Program, v ...interface{}) *Instruction {
11734 if len(v) == 4 {
11735 return p.VROUNDSS(v[0], v[1], v[2], v[3])
11736 } else {
11737 panic("instruction VROUNDSS takes exactly 4 operands")
11738 }
11739 }
11740
11741 func __asm_proxy_VRSQRT14PD__(p *Program, v ...interface{}) *Instruction {
11742 if len(v) == 2 {
11743 return p.VRSQRT14PD(v[0], v[1])
11744 } else {
11745 panic("instruction VRSQRT14PD takes exactly 2 operands")
11746 }
11747 }
11748
11749 func __asm_proxy_VRSQRT14PS__(p *Program, v ...interface{}) *Instruction {
11750 if len(v) == 2 {
11751 return p.VRSQRT14PS(v[0], v[1])
11752 } else {
11753 panic("instruction VRSQRT14PS takes exactly 2 operands")
11754 }
11755 }
11756
11757 func __asm_proxy_VRSQRT14SD__(p *Program, v ...interface{}) *Instruction {
11758 if len(v) == 3 {
11759 return p.VRSQRT14SD(v[0], v[1], v[2])
11760 } else {
11761 panic("instruction VRSQRT14SD takes exactly 3 operands")
11762 }
11763 }
11764
11765 func __asm_proxy_VRSQRT14SS__(p *Program, v ...interface{}) *Instruction {
11766 if len(v) == 3 {
11767 return p.VRSQRT14SS(v[0], v[1], v[2])
11768 } else {
11769 panic("instruction VRSQRT14SS takes exactly 3 operands")
11770 }
11771 }
11772
11773 func __asm_proxy_VRSQRT28PD__(p *Program, v ...interface{}) *Instruction {
11774 switch len(v) {
11775 case 2 : return p.VRSQRT28PD(v[0], v[1])
11776 case 3 : return p.VRSQRT28PD(v[0], v[1], v[2])
11777 default : panic("instruction VRSQRT28PD takes 2 or 3 operands")
11778 }
11779 }
11780
11781 func __asm_proxy_VRSQRT28PS__(p *Program, v ...interface{}) *Instruction {
11782 switch len(v) {
11783 case 2 : return p.VRSQRT28PS(v[0], v[1])
11784 case 3 : return p.VRSQRT28PS(v[0], v[1], v[2])
11785 default : panic("instruction VRSQRT28PS takes 2 or 3 operands")
11786 }
11787 }
11788
11789 func __asm_proxy_VRSQRT28SD__(p *Program, v ...interface{}) *Instruction {
11790 switch len(v) {
11791 case 3 : return p.VRSQRT28SD(v[0], v[1], v[2])
11792 case 4 : return p.VRSQRT28SD(v[0], v[1], v[2], v[3])
11793 default : panic("instruction VRSQRT28SD takes 3 or 4 operands")
11794 }
11795 }
11796
11797 func __asm_proxy_VRSQRT28SS__(p *Program, v ...interface{}) *Instruction {
11798 switch len(v) {
11799 case 3 : return p.VRSQRT28SS(v[0], v[1], v[2])
11800 case 4 : return p.VRSQRT28SS(v[0], v[1], v[2], v[3])
11801 default : panic("instruction VRSQRT28SS takes 3 or 4 operands")
11802 }
11803 }
11804
11805 func __asm_proxy_VRSQRTPS__(p *Program, v ...interface{}) *Instruction {
11806 if len(v) == 2 {
11807 return p.VRSQRTPS(v[0], v[1])
11808 } else {
11809 panic("instruction VRSQRTPS takes exactly 2 operands")
11810 }
11811 }
11812
11813 func __asm_proxy_VRSQRTSS__(p *Program, v ...interface{}) *Instruction {
11814 if len(v) == 3 {
11815 return p.VRSQRTSS(v[0], v[1], v[2])
11816 } else {
11817 panic("instruction VRSQRTSS takes exactly 3 operands")
11818 }
11819 }
11820
11821 func __asm_proxy_VSCALEFPD__(p *Program, v ...interface{}) *Instruction {
11822 switch len(v) {
11823 case 3 : return p.VSCALEFPD(v[0], v[1], v[2])
11824 case 4 : return p.VSCALEFPD(v[0], v[1], v[2], v[3])
11825 default : panic("instruction VSCALEFPD takes 3 or 4 operands")
11826 }
11827 }
11828
11829 func __asm_proxy_VSCALEFPS__(p *Program, v ...interface{}) *Instruction {
11830 switch len(v) {
11831 case 3 : return p.VSCALEFPS(v[0], v[1], v[2])
11832 case 4 : return p.VSCALEFPS(v[0], v[1], v[2], v[3])
11833 default : panic("instruction VSCALEFPS takes 3 or 4 operands")
11834 }
11835 }
11836
11837 func __asm_proxy_VSCALEFSD__(p *Program, v ...interface{}) *Instruction {
11838 switch len(v) {
11839 case 3 : return p.VSCALEFSD(v[0], v[1], v[2])
11840 case 4 : return p.VSCALEFSD(v[0], v[1], v[2], v[3])
11841 default : panic("instruction VSCALEFSD takes 3 or 4 operands")
11842 }
11843 }
11844
11845 func __asm_proxy_VSCALEFSS__(p *Program, v ...interface{}) *Instruction {
11846 switch len(v) {
11847 case 3 : return p.VSCALEFSS(v[0], v[1], v[2])
11848 case 4 : return p.VSCALEFSS(v[0], v[1], v[2], v[3])
11849 default : panic("instruction VSCALEFSS takes 3 or 4 operands")
11850 }
11851 }
11852
11853 func __asm_proxy_VSCATTERDPD__(p *Program, v ...interface{}) *Instruction {
11854 if len(v) == 2 {
11855 return p.VSCATTERDPD(v[0], v[1])
11856 } else {
11857 panic("instruction VSCATTERDPD takes exactly 2 operands")
11858 }
11859 }
11860
11861 func __asm_proxy_VSCATTERDPS__(p *Program, v ...interface{}) *Instruction {
11862 if len(v) == 2 {
11863 return p.VSCATTERDPS(v[0], v[1])
11864 } else {
11865 panic("instruction VSCATTERDPS takes exactly 2 operands")
11866 }
11867 }
11868
11869 func __asm_proxy_VSCATTERPF0DPD__(p *Program, v ...interface{}) *Instruction {
11870 if len(v) == 1 {
11871 return p.VSCATTERPF0DPD(v[0])
11872 } else {
11873 panic("instruction VSCATTERPF0DPD takes exactly 1 operand")
11874 }
11875 }
11876
11877 func __asm_proxy_VSCATTERPF0DPS__(p *Program, v ...interface{}) *Instruction {
11878 if len(v) == 1 {
11879 return p.VSCATTERPF0DPS(v[0])
11880 } else {
11881 panic("instruction VSCATTERPF0DPS takes exactly 1 operand")
11882 }
11883 }
11884
11885 func __asm_proxy_VSCATTERPF0QPD__(p *Program, v ...interface{}) *Instruction {
11886 if len(v) == 1 {
11887 return p.VSCATTERPF0QPD(v[0])
11888 } else {
11889 panic("instruction VSCATTERPF0QPD takes exactly 1 operand")
11890 }
11891 }
11892
11893 func __asm_proxy_VSCATTERPF0QPS__(p *Program, v ...interface{}) *Instruction {
11894 if len(v) == 1 {
11895 return p.VSCATTERPF0QPS(v[0])
11896 } else {
11897 panic("instruction VSCATTERPF0QPS takes exactly 1 operand")
11898 }
11899 }
11900
11901 func __asm_proxy_VSCATTERPF1DPD__(p *Program, v ...interface{}) *Instruction {
11902 if len(v) == 1 {
11903 return p.VSCATTERPF1DPD(v[0])
11904 } else {
11905 panic("instruction VSCATTERPF1DPD takes exactly 1 operand")
11906 }
11907 }
11908
11909 func __asm_proxy_VSCATTERPF1DPS__(p *Program, v ...interface{}) *Instruction {
11910 if len(v) == 1 {
11911 return p.VSCATTERPF1DPS(v[0])
11912 } else {
11913 panic("instruction VSCATTERPF1DPS takes exactly 1 operand")
11914 }
11915 }
11916
11917 func __asm_proxy_VSCATTERPF1QPD__(p *Program, v ...interface{}) *Instruction {
11918 if len(v) == 1 {
11919 return p.VSCATTERPF1QPD(v[0])
11920 } else {
11921 panic("instruction VSCATTERPF1QPD takes exactly 1 operand")
11922 }
11923 }
11924
11925 func __asm_proxy_VSCATTERPF1QPS__(p *Program, v ...interface{}) *Instruction {
11926 if len(v) == 1 {
11927 return p.VSCATTERPF1QPS(v[0])
11928 } else {
11929 panic("instruction VSCATTERPF1QPS takes exactly 1 operand")
11930 }
11931 }
11932
11933 func __asm_proxy_VSCATTERQPD__(p *Program, v ...interface{}) *Instruction {
11934 if len(v) == 2 {
11935 return p.VSCATTERQPD(v[0], v[1])
11936 } else {
11937 panic("instruction VSCATTERQPD takes exactly 2 operands")
11938 }
11939 }
11940
11941 func __asm_proxy_VSCATTERQPS__(p *Program, v ...interface{}) *Instruction {
11942 if len(v) == 2 {
11943 return p.VSCATTERQPS(v[0], v[1])
11944 } else {
11945 panic("instruction VSCATTERQPS takes exactly 2 operands")
11946 }
11947 }
11948
11949 func __asm_proxy_VSHUFF32X4__(p *Program, v ...interface{}) *Instruction {
11950 if len(v) == 4 {
11951 return p.VSHUFF32X4(v[0], v[1], v[2], v[3])
11952 } else {
11953 panic("instruction VSHUFF32X4 takes exactly 4 operands")
11954 }
11955 }
11956
11957 func __asm_proxy_VSHUFF64X2__(p *Program, v ...interface{}) *Instruction {
11958 if len(v) == 4 {
11959 return p.VSHUFF64X2(v[0], v[1], v[2], v[3])
11960 } else {
11961 panic("instruction VSHUFF64X2 takes exactly 4 operands")
11962 }
11963 }
11964
11965 func __asm_proxy_VSHUFI32X4__(p *Program, v ...interface{}) *Instruction {
11966 if len(v) == 4 {
11967 return p.VSHUFI32X4(v[0], v[1], v[2], v[3])
11968 } else {
11969 panic("instruction VSHUFI32X4 takes exactly 4 operands")
11970 }
11971 }
11972
11973 func __asm_proxy_VSHUFI64X2__(p *Program, v ...interface{}) *Instruction {
11974 if len(v) == 4 {
11975 return p.VSHUFI64X2(v[0], v[1], v[2], v[3])
11976 } else {
11977 panic("instruction VSHUFI64X2 takes exactly 4 operands")
11978 }
11979 }
11980
11981 func __asm_proxy_VSHUFPD__(p *Program, v ...interface{}) *Instruction {
11982 if len(v) == 4 {
11983 return p.VSHUFPD(v[0], v[1], v[2], v[3])
11984 } else {
11985 panic("instruction VSHUFPD takes exactly 4 operands")
11986 }
11987 }
11988
11989 func __asm_proxy_VSHUFPS__(p *Program, v ...interface{}) *Instruction {
11990 if len(v) == 4 {
11991 return p.VSHUFPS(v[0], v[1], v[2], v[3])
11992 } else {
11993 panic("instruction VSHUFPS takes exactly 4 operands")
11994 }
11995 }
11996
11997 func __asm_proxy_VSQRTPD__(p *Program, v ...interface{}) *Instruction {
11998 switch len(v) {
11999 case 2 : return p.VSQRTPD(v[0], v[1])
12000 case 3 : return p.VSQRTPD(v[0], v[1], v[2])
12001 default : panic("instruction VSQRTPD takes 2 or 3 operands")
12002 }
12003 }
12004
12005 func __asm_proxy_VSQRTPS__(p *Program, v ...interface{}) *Instruction {
12006 switch len(v) {
12007 case 2 : return p.VSQRTPS(v[0], v[1])
12008 case 3 : return p.VSQRTPS(v[0], v[1], v[2])
12009 default : panic("instruction VSQRTPS takes 2 or 3 operands")
12010 }
12011 }
12012
12013 func __asm_proxy_VSQRTSD__(p *Program, v ...interface{}) *Instruction {
12014 switch len(v) {
12015 case 3 : return p.VSQRTSD(v[0], v[1], v[2])
12016 case 4 : return p.VSQRTSD(v[0], v[1], v[2], v[3])
12017 default : panic("instruction VSQRTSD takes 3 or 4 operands")
12018 }
12019 }
12020
12021 func __asm_proxy_VSQRTSS__(p *Program, v ...interface{}) *Instruction {
12022 switch len(v) {
12023 case 3 : return p.VSQRTSS(v[0], v[1], v[2])
12024 case 4 : return p.VSQRTSS(v[0], v[1], v[2], v[3])
12025 default : panic("instruction VSQRTSS takes 3 or 4 operands")
12026 }
12027 }
12028
12029 func __asm_proxy_VSTMXCSR__(p *Program, v ...interface{}) *Instruction {
12030 if len(v) == 1 {
12031 return p.VSTMXCSR(v[0])
12032 } else {
12033 panic("instruction VSTMXCSR takes exactly 1 operand")
12034 }
12035 }
12036
12037 func __asm_proxy_VSUBPD__(p *Program, v ...interface{}) *Instruction {
12038 switch len(v) {
12039 case 3 : return p.VSUBPD(v[0], v[1], v[2])
12040 case 4 : return p.VSUBPD(v[0], v[1], v[2], v[3])
12041 default : panic("instruction VSUBPD takes 3 or 4 operands")
12042 }
12043 }
12044
12045 func __asm_proxy_VSUBPS__(p *Program, v ...interface{}) *Instruction {
12046 switch len(v) {
12047 case 3 : return p.VSUBPS(v[0], v[1], v[2])
12048 case 4 : return p.VSUBPS(v[0], v[1], v[2], v[3])
12049 default : panic("instruction VSUBPS takes 3 or 4 operands")
12050 }
12051 }
12052
12053 func __asm_proxy_VSUBSD__(p *Program, v ...interface{}) *Instruction {
12054 switch len(v) {
12055 case 3 : return p.VSUBSD(v[0], v[1], v[2])
12056 case 4 : return p.VSUBSD(v[0], v[1], v[2], v[3])
12057 default : panic("instruction VSUBSD takes 3 or 4 operands")
12058 }
12059 }
12060
12061 func __asm_proxy_VSUBSS__(p *Program, v ...interface{}) *Instruction {
12062 switch len(v) {
12063 case 3 : return p.VSUBSS(v[0], v[1], v[2])
12064 case 4 : return p.VSUBSS(v[0], v[1], v[2], v[3])
12065 default : panic("instruction VSUBSS takes 3 or 4 operands")
12066 }
12067 }
12068
12069 func __asm_proxy_VTESTPD__(p *Program, v ...interface{}) *Instruction {
12070 if len(v) == 2 {
12071 return p.VTESTPD(v[0], v[1])
12072 } else {
12073 panic("instruction VTESTPD takes exactly 2 operands")
12074 }
12075 }
12076
12077 func __asm_proxy_VTESTPS__(p *Program, v ...interface{}) *Instruction {
12078 if len(v) == 2 {
12079 return p.VTESTPS(v[0], v[1])
12080 } else {
12081 panic("instruction VTESTPS takes exactly 2 operands")
12082 }
12083 }
12084
12085 func __asm_proxy_VUCOMISD__(p *Program, v ...interface{}) *Instruction {
12086 switch len(v) {
12087 case 2 : return p.VUCOMISD(v[0], v[1])
12088 case 3 : return p.VUCOMISD(v[0], v[1], v[2])
12089 default : panic("instruction VUCOMISD takes 2 or 3 operands")
12090 }
12091 }
12092
12093 func __asm_proxy_VUCOMISS__(p *Program, v ...interface{}) *Instruction {
12094 switch len(v) {
12095 case 2 : return p.VUCOMISS(v[0], v[1])
12096 case 3 : return p.VUCOMISS(v[0], v[1], v[2])
12097 default : panic("instruction VUCOMISS takes 2 or 3 operands")
12098 }
12099 }
12100
12101 func __asm_proxy_VUNPCKHPD__(p *Program, v ...interface{}) *Instruction {
12102 if len(v) == 3 {
12103 return p.VUNPCKHPD(v[0], v[1], v[2])
12104 } else {
12105 panic("instruction VUNPCKHPD takes exactly 3 operands")
12106 }
12107 }
12108
12109 func __asm_proxy_VUNPCKHPS__(p *Program, v ...interface{}) *Instruction {
12110 if len(v) == 3 {
12111 return p.VUNPCKHPS(v[0], v[1], v[2])
12112 } else {
12113 panic("instruction VUNPCKHPS takes exactly 3 operands")
12114 }
12115 }
12116
12117 func __asm_proxy_VUNPCKLPD__(p *Program, v ...interface{}) *Instruction {
12118 if len(v) == 3 {
12119 return p.VUNPCKLPD(v[0], v[1], v[2])
12120 } else {
12121 panic("instruction VUNPCKLPD takes exactly 3 operands")
12122 }
12123 }
12124
12125 func __asm_proxy_VUNPCKLPS__(p *Program, v ...interface{}) *Instruction {
12126 if len(v) == 3 {
12127 return p.VUNPCKLPS(v[0], v[1], v[2])
12128 } else {
12129 panic("instruction VUNPCKLPS takes exactly 3 operands")
12130 }
12131 }
12132
12133 func __asm_proxy_VXORPD__(p *Program, v ...interface{}) *Instruction {
12134 if len(v) == 3 {
12135 return p.VXORPD(v[0], v[1], v[2])
12136 } else {
12137 panic("instruction VXORPD takes exactly 3 operands")
12138 }
12139 }
12140
12141 func __asm_proxy_VXORPS__(p *Program, v ...interface{}) *Instruction {
12142 if len(v) == 3 {
12143 return p.VXORPS(v[0], v[1], v[2])
12144 } else {
12145 panic("instruction VXORPS takes exactly 3 operands")
12146 }
12147 }
12148
12149 func __asm_proxy_VZEROALL__(p *Program, v ...interface{}) *Instruction {
12150 if len(v) == 0 {
12151 return p.VZEROALL()
12152 } else {
12153 panic("instruction VZEROALL takes no operands")
12154 }
12155 }
12156
12157 func __asm_proxy_VZEROUPPER__(p *Program, v ...interface{}) *Instruction {
12158 if len(v) == 0 {
12159 return p.VZEROUPPER()
12160 } else {
12161 panic("instruction VZEROUPPER takes no operands")
12162 }
12163 }
12164
12165 func __asm_proxy_XADDB__(p *Program, v ...interface{}) *Instruction {
12166 if len(v) == 2 {
12167 return p.XADDB(v[0], v[1])
12168 } else {
12169 panic("instruction XADDB takes exactly 2 operands")
12170 }
12171 }
12172
12173 func __asm_proxy_XADDL__(p *Program, v ...interface{}) *Instruction {
12174 if len(v) == 2 {
12175 return p.XADDL(v[0], v[1])
12176 } else {
12177 panic("instruction XADDL takes exactly 2 operands")
12178 }
12179 }
12180
12181 func __asm_proxy_XADDQ__(p *Program, v ...interface{}) *Instruction {
12182 if len(v) == 2 {
12183 return p.XADDQ(v[0], v[1])
12184 } else {
12185 panic("instruction XADDQ takes exactly 2 operands")
12186 }
12187 }
12188
12189 func __asm_proxy_XADDW__(p *Program, v ...interface{}) *Instruction {
12190 if len(v) == 2 {
12191 return p.XADDW(v[0], v[1])
12192 } else {
12193 panic("instruction XADDW takes exactly 2 operands")
12194 }
12195 }
12196
12197 func __asm_proxy_XCHGB__(p *Program, v ...interface{}) *Instruction {
12198 if len(v) == 2 {
12199 return p.XCHGB(v[0], v[1])
12200 } else {
12201 panic("instruction XCHGB takes exactly 2 operands")
12202 }
12203 }
12204
12205 func __asm_proxy_XCHGL__(p *Program, v ...interface{}) *Instruction {
12206 if len(v) == 2 {
12207 return p.XCHGL(v[0], v[1])
12208 } else {
12209 panic("instruction XCHGL takes exactly 2 operands")
12210 }
12211 }
12212
12213 func __asm_proxy_XCHGQ__(p *Program, v ...interface{}) *Instruction {
12214 if len(v) == 2 {
12215 return p.XCHGQ(v[0], v[1])
12216 } else {
12217 panic("instruction XCHGQ takes exactly 2 operands")
12218 }
12219 }
12220
12221 func __asm_proxy_XCHGW__(p *Program, v ...interface{}) *Instruction {
12222 if len(v) == 2 {
12223 return p.XCHGW(v[0], v[1])
12224 } else {
12225 panic("instruction XCHGW takes exactly 2 operands")
12226 }
12227 }
12228
12229 func __asm_proxy_XGETBV__(p *Program, v ...interface{}) *Instruction {
12230 if len(v) == 0 {
12231 return p.XGETBV()
12232 } else {
12233 panic("instruction XGETBV takes no operands")
12234 }
12235 }
12236
12237 func __asm_proxy_XLATB__(p *Program, v ...interface{}) *Instruction {
12238 if len(v) == 0 {
12239 return p.XLATB()
12240 } else {
12241 panic("instruction XLATB takes no operands")
12242 }
12243 }
12244
12245 func __asm_proxy_XORB__(p *Program, v ...interface{}) *Instruction {
12246 if len(v) == 2 {
12247 return p.XORB(v[0], v[1])
12248 } else {
12249 panic("instruction XORB takes exactly 2 operands")
12250 }
12251 }
12252
12253 func __asm_proxy_XORL__(p *Program, v ...interface{}) *Instruction {
12254 if len(v) == 2 {
12255 return p.XORL(v[0], v[1])
12256 } else {
12257 panic("instruction XORL takes exactly 2 operands")
12258 }
12259 }
12260
12261 func __asm_proxy_XORPD__(p *Program, v ...interface{}) *Instruction {
12262 if len(v) == 2 {
12263 return p.XORPD(v[0], v[1])
12264 } else {
12265 panic("instruction XORPD takes exactly 2 operands")
12266 }
12267 }
12268
12269 func __asm_proxy_XORPS__(p *Program, v ...interface{}) *Instruction {
12270 if len(v) == 2 {
12271 return p.XORPS(v[0], v[1])
12272 } else {
12273 panic("instruction XORPS takes exactly 2 operands")
12274 }
12275 }
12276
12277 func __asm_proxy_XORQ__(p *Program, v ...interface{}) *Instruction {
12278 if len(v) == 2 {
12279 return p.XORQ(v[0], v[1])
12280 } else {
12281 panic("instruction XORQ takes exactly 2 operands")
12282 }
12283 }
12284
12285 func __asm_proxy_XORW__(p *Program, v ...interface{}) *Instruction {
12286 if len(v) == 2 {
12287 return p.XORW(v[0], v[1])
12288 } else {
12289 panic("instruction XORW takes exactly 2 operands")
12290 }
12291 }
12292
View as plain text