source: Daodan/src/beaengine/Includes/instr_set/opcodes_SSE.c @ 984

Last change on this file since 984 was 984, checked in by alloc, 8 years ago

Daodan: TV code

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