1# This file is auto-generated by /codegen/x86_64_test_encoding.py
2# Reference opcodes are generated by:
3#     GNU assembler (GNU Binutils) 2.28.51.20170402
4
5from peachpy.x86_64 import *
6import unittest
7
8
9class TestADD(unittest.TestCase):
10    def runTest(self):
11        self.assertEqual(bytearray([0x04, 0x02]), ADD(al, 2).encode())
12        self.assertEqual(bytearray([0x80, 0xC3, 0x02]), ADD(bl, 2).encode())
13        self.assertEqual(bytearray([0x44, 0x00, 0xCB]), ADD(bl, r9b).encode())
14        self.assertEqual(bytearray([0x41, 0x02, 0x5C, 0xBE, 0x85]), ADD(bl, byte[r14 + rdi*4 - 123]).encode())
15        self.assertEqual(bytearray([0x66, 0x05, 0x00, 0x7D]), ADD(ax, 32000).encode())
16        self.assertEqual(bytearray([0x66, 0x83, 0xC6, 0x02]), ADD(si, 2).encode())
17        self.assertEqual(bytearray([0x66, 0x81, 0xC6, 0x00, 0x7D]), ADD(si, 32000).encode())
18        self.assertEqual(bytearray([0x66, 0x44, 0x01, 0xE6]), ADD(si, r12w).encode())
19        self.assertEqual(bytearray([0x66, 0x41, 0x03, 0x74, 0xED, 0x95]), ADD(si, word[r13 + rbp*8 - 107]).encode())
20        self.assertEqual(bytearray([0x05, 0x00, 0x00, 0x00, 0x10]), ADD(eax, 0x10000000).encode())
21        self.assertEqual(bytearray([0x83, 0xC5, 0x02]), ADD(ebp, 2).encode())
22        self.assertEqual(bytearray([0x81, 0xC5, 0x00, 0x00, 0x00, 0x10]), ADD(ebp, 0x10000000).encode())
23        self.assertEqual(bytearray([0x44, 0x01, 0xC5]), ADD(ebp, r8d).encode())
24        self.assertEqual(bytearray([0x41, 0x03, 0x6C, 0xCC, 0x9D]), ADD(ebp, dword[r12 + rcx*8 - 99]).encode())
25        self.assertEqual(bytearray([0x48, 0x05, 0x00, 0x00, 0x00, 0x10]), ADD(rax, 0x10000000).encode())
26        self.assertEqual(bytearray([0x48, 0x83, 0xC1, 0x02]), ADD(rcx, 2).encode())
27        self.assertEqual(bytearray([0x48, 0x81, 0xC1, 0x00, 0x00, 0x00, 0x10]), ADD(rcx, 0x10000000).encode())
28        self.assertEqual(bytearray([0x4C, 0x01, 0xF9]), ADD(rcx, r15).encode())
29        self.assertEqual(bytearray([0x49, 0x03, 0x4C, 0xD3, 0xA8]), ADD(rcx, qword[r11 + rdx*8 - 88]).encode())
30        self.assertEqual(bytearray([0x41, 0x80, 0x44, 0xBE, 0x85, 0x02]), ADD(byte[r14 + rdi*4 - 123], 2).encode())
31        self.assertEqual(bytearray([0x45, 0x00, 0x4C, 0xBE, 0x85]), ADD(byte[r14 + rdi*4 - 123], r9b).encode())
32        self.assertEqual(bytearray([0x66, 0x41, 0x83, 0x44, 0xED, 0x95, 0x02]), ADD(word[r13 + rbp*8 - 107], 2).encode())
33        self.assertEqual(bytearray([0x66, 0x41, 0x81, 0x44, 0xED, 0x95, 0x00, 0x7D]), ADD(word[r13 + rbp*8 - 107], 32000).encode())
34        self.assertEqual(bytearray([0x66, 0x45, 0x01, 0x64, 0xED, 0x95]), ADD(word[r13 + rbp*8 - 107], r12w).encode())
35        self.assertEqual(bytearray([0x41, 0x83, 0x44, 0xCC, 0x9D, 0x02]), ADD(dword[r12 + rcx*8 - 99], 2).encode())
36        self.assertEqual(bytearray([0x41, 0x81, 0x44, 0xCC, 0x9D, 0x00, 0x00, 0x00, 0x10]), ADD(dword[r12 + rcx*8 - 99], 0x10000000).encode())
37        self.assertEqual(bytearray([0x45, 0x01, 0x44, 0xCC, 0x9D]), ADD(dword[r12 + rcx*8 - 99], r8d).encode())
38        self.assertEqual(bytearray([0x49, 0x83, 0x44, 0xD3, 0xA8, 0x02]), ADD(qword[r11 + rdx*8 - 88], 2).encode())
39        self.assertEqual(bytearray([0x49, 0x81, 0x44, 0xD3, 0xA8, 0x00, 0x00, 0x00, 0x10]), ADD(qword[r11 + rdx*8 - 88], 0x10000000).encode())
40        self.assertEqual(bytearray([0x4D, 0x01, 0x7C, 0xD3, 0xA8]), ADD(qword[r11 + rdx*8 - 88], r15).encode())
41
42
43class TestSUB(unittest.TestCase):
44    def runTest(self):
45        self.assertEqual(bytearray([0x2C, 0x02]), SUB(al, 2).encode())
46        self.assertEqual(bytearray([0x80, 0xEB, 0x02]), SUB(bl, 2).encode())
47        self.assertEqual(bytearray([0x44, 0x28, 0xCB]), SUB(bl, r9b).encode())
48        self.assertEqual(bytearray([0x41, 0x2A, 0x5C, 0xBE, 0x85]), SUB(bl, byte[r14 + rdi*4 - 123]).encode())
49        self.assertEqual(bytearray([0x66, 0x2D, 0x00, 0x7D]), SUB(ax, 32000).encode())
50        self.assertEqual(bytearray([0x66, 0x83, 0xEE, 0x02]), SUB(si, 2).encode())
51        self.assertEqual(bytearray([0x66, 0x81, 0xEE, 0x00, 0x7D]), SUB(si, 32000).encode())
52        self.assertEqual(bytearray([0x66, 0x44, 0x29, 0xE6]), SUB(si, r12w).encode())
53        self.assertEqual(bytearray([0x66, 0x41, 0x2B, 0x74, 0xED, 0x95]), SUB(si, word[r13 + rbp*8 - 107]).encode())
54        self.assertEqual(bytearray([0x2D, 0x00, 0x00, 0x00, 0x10]), SUB(eax, 0x10000000).encode())
55        self.assertEqual(bytearray([0x83, 0xED, 0x02]), SUB(ebp, 2).encode())
56        self.assertEqual(bytearray([0x81, 0xED, 0x00, 0x00, 0x00, 0x10]), SUB(ebp, 0x10000000).encode())
57        self.assertEqual(bytearray([0x44, 0x29, 0xC5]), SUB(ebp, r8d).encode())
58        self.assertEqual(bytearray([0x41, 0x2B, 0x6C, 0xCC, 0x9D]), SUB(ebp, dword[r12 + rcx*8 - 99]).encode())
59        self.assertEqual(bytearray([0x48, 0x2D, 0x00, 0x00, 0x00, 0x10]), SUB(rax, 0x10000000).encode())
60        self.assertEqual(bytearray([0x48, 0x83, 0xE9, 0x02]), SUB(rcx, 2).encode())
61        self.assertEqual(bytearray([0x48, 0x81, 0xE9, 0x00, 0x00, 0x00, 0x10]), SUB(rcx, 0x10000000).encode())
62        self.assertEqual(bytearray([0x4C, 0x29, 0xF9]), SUB(rcx, r15).encode())
63        self.assertEqual(bytearray([0x49, 0x2B, 0x4C, 0xD3, 0xA8]), SUB(rcx, qword[r11 + rdx*8 - 88]).encode())
64        self.assertEqual(bytearray([0x41, 0x80, 0x6C, 0xBE, 0x85, 0x02]), SUB(byte[r14 + rdi*4 - 123], 2).encode())
65        self.assertEqual(bytearray([0x45, 0x28, 0x4C, 0xBE, 0x85]), SUB(byte[r14 + rdi*4 - 123], r9b).encode())
66        self.assertEqual(bytearray([0x66, 0x41, 0x83, 0x6C, 0xED, 0x95, 0x02]), SUB(word[r13 + rbp*8 - 107], 2).encode())
67        self.assertEqual(bytearray([0x66, 0x41, 0x81, 0x6C, 0xED, 0x95, 0x00, 0x7D]), SUB(word[r13 + rbp*8 - 107], 32000).encode())
68        self.assertEqual(bytearray([0x66, 0x45, 0x29, 0x64, 0xED, 0x95]), SUB(word[r13 + rbp*8 - 107], r12w).encode())
69        self.assertEqual(bytearray([0x41, 0x83, 0x6C, 0xCC, 0x9D, 0x02]), SUB(dword[r12 + rcx*8 - 99], 2).encode())
70        self.assertEqual(bytearray([0x41, 0x81, 0x6C, 0xCC, 0x9D, 0x00, 0x00, 0x00, 0x10]), SUB(dword[r12 + rcx*8 - 99], 0x10000000).encode())
71        self.assertEqual(bytearray([0x45, 0x29, 0x44, 0xCC, 0x9D]), SUB(dword[r12 + rcx*8 - 99], r8d).encode())
72        self.assertEqual(bytearray([0x49, 0x83, 0x6C, 0xD3, 0xA8, 0x02]), SUB(qword[r11 + rdx*8 - 88], 2).encode())
73        self.assertEqual(bytearray([0x49, 0x81, 0x6C, 0xD3, 0xA8, 0x00, 0x00, 0x00, 0x10]), SUB(qword[r11 + rdx*8 - 88], 0x10000000).encode())
74        self.assertEqual(bytearray([0x4D, 0x29, 0x7C, 0xD3, 0xA8]), SUB(qword[r11 + rdx*8 - 88], r15).encode())
75
76
77class TestADC(unittest.TestCase):
78    def runTest(self):
79        self.assertEqual(bytearray([0x14, 0x02]), ADC(al, 2).encode())
80        self.assertEqual(bytearray([0x80, 0xD3, 0x02]), ADC(bl, 2).encode())
81        self.assertEqual(bytearray([0x44, 0x10, 0xCB]), ADC(bl, r9b).encode())
82        self.assertEqual(bytearray([0x41, 0x12, 0x5C, 0xBE, 0x85]), ADC(bl, byte[r14 + rdi*4 - 123]).encode())
83        self.assertEqual(bytearray([0x66, 0x15, 0x00, 0x7D]), ADC(ax, 32000).encode())
84        self.assertEqual(bytearray([0x66, 0x83, 0xD6, 0x02]), ADC(si, 2).encode())
85        self.assertEqual(bytearray([0x66, 0x81, 0xD6, 0x00, 0x7D]), ADC(si, 32000).encode())
86        self.assertEqual(bytearray([0x66, 0x44, 0x11, 0xE6]), ADC(si, r12w).encode())
87        self.assertEqual(bytearray([0x66, 0x41, 0x13, 0x74, 0xED, 0x95]), ADC(si, word[r13 + rbp*8 - 107]).encode())
88        self.assertEqual(bytearray([0x15, 0x00, 0x00, 0x00, 0x10]), ADC(eax, 0x10000000).encode())
89        self.assertEqual(bytearray([0x83, 0xD5, 0x02]), ADC(ebp, 2).encode())
90        self.assertEqual(bytearray([0x81, 0xD5, 0x00, 0x00, 0x00, 0x10]), ADC(ebp, 0x10000000).encode())
91        self.assertEqual(bytearray([0x44, 0x11, 0xC5]), ADC(ebp, r8d).encode())
92        self.assertEqual(bytearray([0x41, 0x13, 0x6C, 0xCC, 0x9D]), ADC(ebp, dword[r12 + rcx*8 - 99]).encode())
93        self.assertEqual(bytearray([0x48, 0x15, 0x00, 0x00, 0x00, 0x10]), ADC(rax, 0x10000000).encode())
94        self.assertEqual(bytearray([0x48, 0x83, 0xD1, 0x02]), ADC(rcx, 2).encode())
95        self.assertEqual(bytearray([0x48, 0x81, 0xD1, 0x00, 0x00, 0x00, 0x10]), ADC(rcx, 0x10000000).encode())
96        self.assertEqual(bytearray([0x4C, 0x11, 0xF9]), ADC(rcx, r15).encode())
97        self.assertEqual(bytearray([0x49, 0x13, 0x4C, 0xD3, 0xA8]), ADC(rcx, qword[r11 + rdx*8 - 88]).encode())
98        self.assertEqual(bytearray([0x41, 0x80, 0x54, 0xBE, 0x85, 0x02]), ADC(byte[r14 + rdi*4 - 123], 2).encode())
99        self.assertEqual(bytearray([0x45, 0x10, 0x4C, 0xBE, 0x85]), ADC(byte[r14 + rdi*4 - 123], r9b).encode())
100        self.assertEqual(bytearray([0x66, 0x41, 0x83, 0x54, 0xED, 0x95, 0x02]), ADC(word[r13 + rbp*8 - 107], 2).encode())
101        self.assertEqual(bytearray([0x66, 0x41, 0x81, 0x54, 0xED, 0x95, 0x00, 0x7D]), ADC(word[r13 + rbp*8 - 107], 32000).encode())
102        self.assertEqual(bytearray([0x66, 0x45, 0x11, 0x64, 0xED, 0x95]), ADC(word[r13 + rbp*8 - 107], r12w).encode())
103        self.assertEqual(bytearray([0x41, 0x83, 0x54, 0xCC, 0x9D, 0x02]), ADC(dword[r12 + rcx*8 - 99], 2).encode())
104        self.assertEqual(bytearray([0x41, 0x81, 0x54, 0xCC, 0x9D, 0x00, 0x00, 0x00, 0x10]), ADC(dword[r12 + rcx*8 - 99], 0x10000000).encode())
105        self.assertEqual(bytearray([0x45, 0x11, 0x44, 0xCC, 0x9D]), ADC(dword[r12 + rcx*8 - 99], r8d).encode())
106        self.assertEqual(bytearray([0x49, 0x83, 0x54, 0xD3, 0xA8, 0x02]), ADC(qword[r11 + rdx*8 - 88], 2).encode())
107        self.assertEqual(bytearray([0x49, 0x81, 0x54, 0xD3, 0xA8, 0x00, 0x00, 0x00, 0x10]), ADC(qword[r11 + rdx*8 - 88], 0x10000000).encode())
108        self.assertEqual(bytearray([0x4D, 0x11, 0x7C, 0xD3, 0xA8]), ADC(qword[r11 + rdx*8 - 88], r15).encode())
109
110
111class TestSBB(unittest.TestCase):
112    def runTest(self):
113        self.assertEqual(bytearray([0x1C, 0x02]), SBB(al, 2).encode())
114        self.assertEqual(bytearray([0x80, 0xDB, 0x02]), SBB(bl, 2).encode())
115        self.assertEqual(bytearray([0x44, 0x18, 0xCB]), SBB(bl, r9b).encode())
116        self.assertEqual(bytearray([0x41, 0x1A, 0x5C, 0xBE, 0x85]), SBB(bl, byte[r14 + rdi*4 - 123]).encode())
117        self.assertEqual(bytearray([0x66, 0x1D, 0x00, 0x7D]), SBB(ax, 32000).encode())
118        self.assertEqual(bytearray([0x66, 0x83, 0xDE, 0x02]), SBB(si, 2).encode())
119        self.assertEqual(bytearray([0x66, 0x81, 0xDE, 0x00, 0x7D]), SBB(si, 32000).encode())
120        self.assertEqual(bytearray([0x66, 0x44, 0x19, 0xE6]), SBB(si, r12w).encode())
121        self.assertEqual(bytearray([0x66, 0x41, 0x1B, 0x74, 0xED, 0x95]), SBB(si, word[r13 + rbp*8 - 107]).encode())
122        self.assertEqual(bytearray([0x1D, 0x00, 0x00, 0x00, 0x10]), SBB(eax, 0x10000000).encode())
123        self.assertEqual(bytearray([0x83, 0xDD, 0x02]), SBB(ebp, 2).encode())
124        self.assertEqual(bytearray([0x81, 0xDD, 0x00, 0x00, 0x00, 0x10]), SBB(ebp, 0x10000000).encode())
125        self.assertEqual(bytearray([0x44, 0x19, 0xC5]), SBB(ebp, r8d).encode())
126        self.assertEqual(bytearray([0x41, 0x1B, 0x6C, 0xCC, 0x9D]), SBB(ebp, dword[r12 + rcx*8 - 99]).encode())
127        self.assertEqual(bytearray([0x48, 0x1D, 0x00, 0x00, 0x00, 0x10]), SBB(rax, 0x10000000).encode())
128        self.assertEqual(bytearray([0x48, 0x83, 0xD9, 0x02]), SBB(rcx, 2).encode())
129        self.assertEqual(bytearray([0x48, 0x81, 0xD9, 0x00, 0x00, 0x00, 0x10]), SBB(rcx, 0x10000000).encode())
130        self.assertEqual(bytearray([0x4C, 0x19, 0xF9]), SBB(rcx, r15).encode())
131        self.assertEqual(bytearray([0x49, 0x1B, 0x4C, 0xD3, 0xA8]), SBB(rcx, qword[r11 + rdx*8 - 88]).encode())
132        self.assertEqual(bytearray([0x41, 0x80, 0x5C, 0xBE, 0x85, 0x02]), SBB(byte[r14 + rdi*4 - 123], 2).encode())
133        self.assertEqual(bytearray([0x45, 0x18, 0x4C, 0xBE, 0x85]), SBB(byte[r14 + rdi*4 - 123], r9b).encode())
134        self.assertEqual(bytearray([0x66, 0x41, 0x83, 0x5C, 0xED, 0x95, 0x02]), SBB(word[r13 + rbp*8 - 107], 2).encode())
135        self.assertEqual(bytearray([0x66, 0x41, 0x81, 0x5C, 0xED, 0x95, 0x00, 0x7D]), SBB(word[r13 + rbp*8 - 107], 32000).encode())
136        self.assertEqual(bytearray([0x66, 0x45, 0x19, 0x64, 0xED, 0x95]), SBB(word[r13 + rbp*8 - 107], r12w).encode())
137        self.assertEqual(bytearray([0x41, 0x83, 0x5C, 0xCC, 0x9D, 0x02]), SBB(dword[r12 + rcx*8 - 99], 2).encode())
138        self.assertEqual(bytearray([0x41, 0x81, 0x5C, 0xCC, 0x9D, 0x00, 0x00, 0x00, 0x10]), SBB(dword[r12 + rcx*8 - 99], 0x10000000).encode())
139        self.assertEqual(bytearray([0x45, 0x19, 0x44, 0xCC, 0x9D]), SBB(dword[r12 + rcx*8 - 99], r8d).encode())
140        self.assertEqual(bytearray([0x49, 0x83, 0x5C, 0xD3, 0xA8, 0x02]), SBB(qword[r11 + rdx*8 - 88], 2).encode())
141        self.assertEqual(bytearray([0x49, 0x81, 0x5C, 0xD3, 0xA8, 0x00, 0x00, 0x00, 0x10]), SBB(qword[r11 + rdx*8 - 88], 0x10000000).encode())
142        self.assertEqual(bytearray([0x4D, 0x19, 0x7C, 0xD3, 0xA8]), SBB(qword[r11 + rdx*8 - 88], r15).encode())
143
144
145class TestADCX(unittest.TestCase):
146    def runTest(self):
147        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x38, 0xF6, 0xE8]), ADCX(ebp, r8d).encode())
148        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x38, 0xF6, 0x6C, 0xCC, 0x9D]), ADCX(ebp, dword[r12 + rcx*8 - 99]).encode())
149        self.assertEqual(bytearray([0x66, 0x49, 0x0F, 0x38, 0xF6, 0xCF]), ADCX(rcx, r15).encode())
150        self.assertEqual(bytearray([0x66, 0x49, 0x0F, 0x38, 0xF6, 0x4C, 0xD3, 0xA8]), ADCX(rcx, qword[r11 + rdx*8 - 88]).encode())
151
152
153class TestADOX(unittest.TestCase):
154    def runTest(self):
155        self.assertEqual(bytearray([0xF3, 0x41, 0x0F, 0x38, 0xF6, 0xE8]), ADOX(ebp, r8d).encode())
156        self.assertEqual(bytearray([0xF3, 0x41, 0x0F, 0x38, 0xF6, 0x6C, 0xCC, 0x9D]), ADOX(ebp, dword[r12 + rcx*8 - 99]).encode())
157        self.assertEqual(bytearray([0xF3, 0x49, 0x0F, 0x38, 0xF6, 0xCF]), ADOX(rcx, r15).encode())
158        self.assertEqual(bytearray([0xF3, 0x49, 0x0F, 0x38, 0xF6, 0x4C, 0xD3, 0xA8]), ADOX(rcx, qword[r11 + rdx*8 - 88]).encode())
159
160
161class TestAND(unittest.TestCase):
162    def runTest(self):
163        self.assertEqual(bytearray([0x24, 0x02]), AND(al, 2).encode())
164        self.assertEqual(bytearray([0x80, 0xE3, 0x02]), AND(bl, 2).encode())
165        self.assertEqual(bytearray([0x44, 0x20, 0xCB]), AND(bl, r9b).encode())
166        self.assertEqual(bytearray([0x41, 0x22, 0x5C, 0xBE, 0x85]), AND(bl, byte[r14 + rdi*4 - 123]).encode())
167        self.assertEqual(bytearray([0x66, 0x25, 0x00, 0x7D]), AND(ax, 32000).encode())
168        self.assertEqual(bytearray([0x66, 0x83, 0xE6, 0x02]), AND(si, 2).encode())
169        self.assertEqual(bytearray([0x66, 0x81, 0xE6, 0x00, 0x7D]), AND(si, 32000).encode())
170        self.assertEqual(bytearray([0x66, 0x44, 0x21, 0xE6]), AND(si, r12w).encode())
171        self.assertEqual(bytearray([0x66, 0x41, 0x23, 0x74, 0xED, 0x95]), AND(si, word[r13 + rbp*8 - 107]).encode())
172        self.assertEqual(bytearray([0x25, 0x00, 0x00, 0x00, 0x10]), AND(eax, 0x10000000).encode())
173        self.assertEqual(bytearray([0x83, 0xE5, 0x02]), AND(ebp, 2).encode())
174        self.assertEqual(bytearray([0x81, 0xE5, 0x00, 0x00, 0x00, 0x10]), AND(ebp, 0x10000000).encode())
175        self.assertEqual(bytearray([0x44, 0x21, 0xC5]), AND(ebp, r8d).encode())
176        self.assertEqual(bytearray([0x41, 0x23, 0x6C, 0xCC, 0x9D]), AND(ebp, dword[r12 + rcx*8 - 99]).encode())
177        self.assertEqual(bytearray([0x48, 0x25, 0x00, 0x00, 0x00, 0x10]), AND(rax, 0x10000000).encode())
178        self.assertEqual(bytearray([0x48, 0x83, 0xE1, 0x02]), AND(rcx, 2).encode())
179        self.assertEqual(bytearray([0x48, 0x81, 0xE1, 0x00, 0x00, 0x00, 0x10]), AND(rcx, 0x10000000).encode())
180        self.assertEqual(bytearray([0x4C, 0x21, 0xF9]), AND(rcx, r15).encode())
181        self.assertEqual(bytearray([0x49, 0x23, 0x4C, 0xD3, 0xA8]), AND(rcx, qword[r11 + rdx*8 - 88]).encode())
182        self.assertEqual(bytearray([0x41, 0x80, 0x64, 0xBE, 0x85, 0x02]), AND(byte[r14 + rdi*4 - 123], 2).encode())
183        self.assertEqual(bytearray([0x45, 0x20, 0x4C, 0xBE, 0x85]), AND(byte[r14 + rdi*4 - 123], r9b).encode())
184        self.assertEqual(bytearray([0x66, 0x41, 0x83, 0x64, 0xED, 0x95, 0x02]), AND(word[r13 + rbp*8 - 107], 2).encode())
185        self.assertEqual(bytearray([0x66, 0x41, 0x81, 0x64, 0xED, 0x95, 0x00, 0x7D]), AND(word[r13 + rbp*8 - 107], 32000).encode())
186        self.assertEqual(bytearray([0x66, 0x45, 0x21, 0x64, 0xED, 0x95]), AND(word[r13 + rbp*8 - 107], r12w).encode())
187        self.assertEqual(bytearray([0x41, 0x83, 0x64, 0xCC, 0x9D, 0x02]), AND(dword[r12 + rcx*8 - 99], 2).encode())
188        self.assertEqual(bytearray([0x41, 0x81, 0x64, 0xCC, 0x9D, 0x00, 0x00, 0x00, 0x10]), AND(dword[r12 + rcx*8 - 99], 0x10000000).encode())
189        self.assertEqual(bytearray([0x45, 0x21, 0x44, 0xCC, 0x9D]), AND(dword[r12 + rcx*8 - 99], r8d).encode())
190        self.assertEqual(bytearray([0x49, 0x83, 0x64, 0xD3, 0xA8, 0x02]), AND(qword[r11 + rdx*8 - 88], 2).encode())
191        self.assertEqual(bytearray([0x49, 0x81, 0x64, 0xD3, 0xA8, 0x00, 0x00, 0x00, 0x10]), AND(qword[r11 + rdx*8 - 88], 0x10000000).encode())
192        self.assertEqual(bytearray([0x4D, 0x21, 0x7C, 0xD3, 0xA8]), AND(qword[r11 + rdx*8 - 88], r15).encode())
193
194
195class TestOR(unittest.TestCase):
196    def runTest(self):
197        self.assertEqual(bytearray([0x0C, 0x02]), OR(al, 2).encode())
198        self.assertEqual(bytearray([0x80, 0xCB, 0x02]), OR(bl, 2).encode())
199        self.assertEqual(bytearray([0x44, 0x08, 0xCB]), OR(bl, r9b).encode())
200        self.assertEqual(bytearray([0x41, 0x0A, 0x5C, 0xBE, 0x85]), OR(bl, byte[r14 + rdi*4 - 123]).encode())
201        self.assertEqual(bytearray([0x66, 0x0D, 0x00, 0x7D]), OR(ax, 32000).encode())
202        self.assertEqual(bytearray([0x66, 0x83, 0xCE, 0x02]), OR(si, 2).encode())
203        self.assertEqual(bytearray([0x66, 0x81, 0xCE, 0x00, 0x7D]), OR(si, 32000).encode())
204        self.assertEqual(bytearray([0x66, 0x44, 0x09, 0xE6]), OR(si, r12w).encode())
205        self.assertEqual(bytearray([0x66, 0x41, 0x0B, 0x74, 0xED, 0x95]), OR(si, word[r13 + rbp*8 - 107]).encode())
206        self.assertEqual(bytearray([0x0D, 0x00, 0x00, 0x00, 0x10]), OR(eax, 0x10000000).encode())
207        self.assertEqual(bytearray([0x83, 0xCD, 0x02]), OR(ebp, 2).encode())
208        self.assertEqual(bytearray([0x81, 0xCD, 0x00, 0x00, 0x00, 0x10]), OR(ebp, 0x10000000).encode())
209        self.assertEqual(bytearray([0x44, 0x09, 0xC5]), OR(ebp, r8d).encode())
210        self.assertEqual(bytearray([0x41, 0x0B, 0x6C, 0xCC, 0x9D]), OR(ebp, dword[r12 + rcx*8 - 99]).encode())
211        self.assertEqual(bytearray([0x48, 0x0D, 0x00, 0x00, 0x00, 0x10]), OR(rax, 0x10000000).encode())
212        self.assertEqual(bytearray([0x48, 0x83, 0xC9, 0x02]), OR(rcx, 2).encode())
213        self.assertEqual(bytearray([0x48, 0x81, 0xC9, 0x00, 0x00, 0x00, 0x10]), OR(rcx, 0x10000000).encode())
214        self.assertEqual(bytearray([0x4C, 0x09, 0xF9]), OR(rcx, r15).encode())
215        self.assertEqual(bytearray([0x49, 0x0B, 0x4C, 0xD3, 0xA8]), OR(rcx, qword[r11 + rdx*8 - 88]).encode())
216        self.assertEqual(bytearray([0x41, 0x80, 0x4C, 0xBE, 0x85, 0x02]), OR(byte[r14 + rdi*4 - 123], 2).encode())
217        self.assertEqual(bytearray([0x45, 0x08, 0x4C, 0xBE, 0x85]), OR(byte[r14 + rdi*4 - 123], r9b).encode())
218        self.assertEqual(bytearray([0x66, 0x41, 0x83, 0x4C, 0xED, 0x95, 0x02]), OR(word[r13 + rbp*8 - 107], 2).encode())
219        self.assertEqual(bytearray([0x66, 0x41, 0x81, 0x4C, 0xED, 0x95, 0x00, 0x7D]), OR(word[r13 + rbp*8 - 107], 32000).encode())
220        self.assertEqual(bytearray([0x66, 0x45, 0x09, 0x64, 0xED, 0x95]), OR(word[r13 + rbp*8 - 107], r12w).encode())
221        self.assertEqual(bytearray([0x41, 0x83, 0x4C, 0xCC, 0x9D, 0x02]), OR(dword[r12 + rcx*8 - 99], 2).encode())
222        self.assertEqual(bytearray([0x41, 0x81, 0x4C, 0xCC, 0x9D, 0x00, 0x00, 0x00, 0x10]), OR(dword[r12 + rcx*8 - 99], 0x10000000).encode())
223        self.assertEqual(bytearray([0x45, 0x09, 0x44, 0xCC, 0x9D]), OR(dword[r12 + rcx*8 - 99], r8d).encode())
224        self.assertEqual(bytearray([0x49, 0x83, 0x4C, 0xD3, 0xA8, 0x02]), OR(qword[r11 + rdx*8 - 88], 2).encode())
225        self.assertEqual(bytearray([0x49, 0x81, 0x4C, 0xD3, 0xA8, 0x00, 0x00, 0x00, 0x10]), OR(qword[r11 + rdx*8 - 88], 0x10000000).encode())
226        self.assertEqual(bytearray([0x4D, 0x09, 0x7C, 0xD3, 0xA8]), OR(qword[r11 + rdx*8 - 88], r15).encode())
227
228
229class TestXOR(unittest.TestCase):
230    def runTest(self):
231        self.assertEqual(bytearray([0x34, 0x02]), XOR(al, 2).encode())
232        self.assertEqual(bytearray([0x80, 0xF3, 0x02]), XOR(bl, 2).encode())
233        self.assertEqual(bytearray([0x44, 0x30, 0xCB]), XOR(bl, r9b).encode())
234        self.assertEqual(bytearray([0x41, 0x32, 0x5C, 0xBE, 0x85]), XOR(bl, byte[r14 + rdi*4 - 123]).encode())
235        self.assertEqual(bytearray([0x66, 0x35, 0x00, 0x7D]), XOR(ax, 32000).encode())
236        self.assertEqual(bytearray([0x66, 0x83, 0xF6, 0x02]), XOR(si, 2).encode())
237        self.assertEqual(bytearray([0x66, 0x81, 0xF6, 0x00, 0x7D]), XOR(si, 32000).encode())
238        self.assertEqual(bytearray([0x66, 0x44, 0x31, 0xE6]), XOR(si, r12w).encode())
239        self.assertEqual(bytearray([0x66, 0x41, 0x33, 0x74, 0xED, 0x95]), XOR(si, word[r13 + rbp*8 - 107]).encode())
240        self.assertEqual(bytearray([0x35, 0x00, 0x00, 0x00, 0x10]), XOR(eax, 0x10000000).encode())
241        self.assertEqual(bytearray([0x83, 0xF5, 0x02]), XOR(ebp, 2).encode())
242        self.assertEqual(bytearray([0x81, 0xF5, 0x00, 0x00, 0x00, 0x10]), XOR(ebp, 0x10000000).encode())
243        self.assertEqual(bytearray([0x44, 0x31, 0xC5]), XOR(ebp, r8d).encode())
244        self.assertEqual(bytearray([0x41, 0x33, 0x6C, 0xCC, 0x9D]), XOR(ebp, dword[r12 + rcx*8 - 99]).encode())
245        self.assertEqual(bytearray([0x48, 0x35, 0x00, 0x00, 0x00, 0x10]), XOR(rax, 0x10000000).encode())
246        self.assertEqual(bytearray([0x48, 0x83, 0xF1, 0x02]), XOR(rcx, 2).encode())
247        self.assertEqual(bytearray([0x48, 0x81, 0xF1, 0x00, 0x00, 0x00, 0x10]), XOR(rcx, 0x10000000).encode())
248        self.assertEqual(bytearray([0x4C, 0x31, 0xF9]), XOR(rcx, r15).encode())
249        self.assertEqual(bytearray([0x49, 0x33, 0x4C, 0xD3, 0xA8]), XOR(rcx, qword[r11 + rdx*8 - 88]).encode())
250        self.assertEqual(bytearray([0x41, 0x80, 0x74, 0xBE, 0x85, 0x02]), XOR(byte[r14 + rdi*4 - 123], 2).encode())
251        self.assertEqual(bytearray([0x45, 0x30, 0x4C, 0xBE, 0x85]), XOR(byte[r14 + rdi*4 - 123], r9b).encode())
252        self.assertEqual(bytearray([0x66, 0x41, 0x83, 0x74, 0xED, 0x95, 0x02]), XOR(word[r13 + rbp*8 - 107], 2).encode())
253        self.assertEqual(bytearray([0x66, 0x41, 0x81, 0x74, 0xED, 0x95, 0x00, 0x7D]), XOR(word[r13 + rbp*8 - 107], 32000).encode())
254        self.assertEqual(bytearray([0x66, 0x45, 0x31, 0x64, 0xED, 0x95]), XOR(word[r13 + rbp*8 - 107], r12w).encode())
255        self.assertEqual(bytearray([0x41, 0x83, 0x74, 0xCC, 0x9D, 0x02]), XOR(dword[r12 + rcx*8 - 99], 2).encode())
256        self.assertEqual(bytearray([0x41, 0x81, 0x74, 0xCC, 0x9D, 0x00, 0x00, 0x00, 0x10]), XOR(dword[r12 + rcx*8 - 99], 0x10000000).encode())
257        self.assertEqual(bytearray([0x45, 0x31, 0x44, 0xCC, 0x9D]), XOR(dword[r12 + rcx*8 - 99], r8d).encode())
258        self.assertEqual(bytearray([0x49, 0x83, 0x74, 0xD3, 0xA8, 0x02]), XOR(qword[r11 + rdx*8 - 88], 2).encode())
259        self.assertEqual(bytearray([0x49, 0x81, 0x74, 0xD3, 0xA8, 0x00, 0x00, 0x00, 0x10]), XOR(qword[r11 + rdx*8 - 88], 0x10000000).encode())
260        self.assertEqual(bytearray([0x4D, 0x31, 0x7C, 0xD3, 0xA8]), XOR(qword[r11 + rdx*8 - 88], r15).encode())
261
262
263class TestANDN(unittest.TestCase):
264    def runTest(self):
265        self.assertEqual(bytearray([0xC4, 0xE2, 0x38, 0xF2, 0xE8]), ANDN(ebp, r8d, eax).encode())
266        self.assertEqual(bytearray([0xC4, 0xC2, 0x38, 0xF2, 0x6C, 0xCC, 0x9D]), ANDN(ebp, r8d, dword[r12 + rcx*8 - 99]).encode())
267        self.assertEqual(bytearray([0xC4, 0xE2, 0x80, 0xF2, 0xC8]), ANDN(rcx, r15, rax).encode())
268        self.assertEqual(bytearray([0xC4, 0xC2, 0x80, 0xF2, 0x4C, 0xD3, 0xA8]), ANDN(rcx, r15, qword[r11 + rdx*8 - 88]).encode())
269
270
271class TestNOT(unittest.TestCase):
272    def runTest(self):
273        self.assertEqual(bytearray([0xF6, 0xD3]), NOT(bl).encode())
274        self.assertEqual(bytearray([0x66, 0xF7, 0xD6]), NOT(si).encode())
275        self.assertEqual(bytearray([0xF7, 0xD5]), NOT(ebp).encode())
276        self.assertEqual(bytearray([0x48, 0xF7, 0xD1]), NOT(rcx).encode())
277        self.assertEqual(bytearray([0x41, 0xF6, 0x54, 0xBE, 0x85]), NOT(byte[r14 + rdi*4 - 123]).encode())
278        self.assertEqual(bytearray([0x66, 0x41, 0xF7, 0x54, 0xED, 0x95]), NOT(word[r13 + rbp*8 - 107]).encode())
279        self.assertEqual(bytearray([0x41, 0xF7, 0x54, 0xCC, 0x9D]), NOT(dword[r12 + rcx*8 - 99]).encode())
280        self.assertEqual(bytearray([0x49, 0xF7, 0x54, 0xD3, 0xA8]), NOT(qword[r11 + rdx*8 - 88]).encode())
281
282
283class TestNEG(unittest.TestCase):
284    def runTest(self):
285        self.assertEqual(bytearray([0xF6, 0xDB]), NEG(bl).encode())
286        self.assertEqual(bytearray([0x66, 0xF7, 0xDE]), NEG(si).encode())
287        self.assertEqual(bytearray([0xF7, 0xDD]), NEG(ebp).encode())
288        self.assertEqual(bytearray([0x48, 0xF7, 0xD9]), NEG(rcx).encode())
289        self.assertEqual(bytearray([0x41, 0xF6, 0x5C, 0xBE, 0x85]), NEG(byte[r14 + rdi*4 - 123]).encode())
290        self.assertEqual(bytearray([0x66, 0x41, 0xF7, 0x5C, 0xED, 0x95]), NEG(word[r13 + rbp*8 - 107]).encode())
291        self.assertEqual(bytearray([0x41, 0xF7, 0x5C, 0xCC, 0x9D]), NEG(dword[r12 + rcx*8 - 99]).encode())
292        self.assertEqual(bytearray([0x49, 0xF7, 0x5C, 0xD3, 0xA8]), NEG(qword[r11 + rdx*8 - 88]).encode())
293
294
295class TestINC(unittest.TestCase):
296    def runTest(self):
297        self.assertEqual(bytearray([0xFE, 0xC3]), INC(bl).encode())
298        self.assertEqual(bytearray([0x66, 0xFF, 0xC6]), INC(si).encode())
299        self.assertEqual(bytearray([0xFF, 0xC5]), INC(ebp).encode())
300        self.assertEqual(bytearray([0x48, 0xFF, 0xC1]), INC(rcx).encode())
301        self.assertEqual(bytearray([0x41, 0xFE, 0x44, 0xBE, 0x85]), INC(byte[r14 + rdi*4 - 123]).encode())
302        self.assertEqual(bytearray([0x66, 0x41, 0xFF, 0x44, 0xED, 0x95]), INC(word[r13 + rbp*8 - 107]).encode())
303        self.assertEqual(bytearray([0x41, 0xFF, 0x44, 0xCC, 0x9D]), INC(dword[r12 + rcx*8 - 99]).encode())
304        self.assertEqual(bytearray([0x49, 0xFF, 0x44, 0xD3, 0xA8]), INC(qword[r11 + rdx*8 - 88]).encode())
305
306
307class TestDEC(unittest.TestCase):
308    def runTest(self):
309        self.assertEqual(bytearray([0xFE, 0xCB]), DEC(bl).encode())
310        self.assertEqual(bytearray([0x66, 0xFF, 0xCE]), DEC(si).encode())
311        self.assertEqual(bytearray([0xFF, 0xCD]), DEC(ebp).encode())
312        self.assertEqual(bytearray([0x48, 0xFF, 0xC9]), DEC(rcx).encode())
313        self.assertEqual(bytearray([0x41, 0xFE, 0x4C, 0xBE, 0x85]), DEC(byte[r14 + rdi*4 - 123]).encode())
314        self.assertEqual(bytearray([0x66, 0x41, 0xFF, 0x4C, 0xED, 0x95]), DEC(word[r13 + rbp*8 - 107]).encode())
315        self.assertEqual(bytearray([0x41, 0xFF, 0x4C, 0xCC, 0x9D]), DEC(dword[r12 + rcx*8 - 99]).encode())
316        self.assertEqual(bytearray([0x49, 0xFF, 0x4C, 0xD3, 0xA8]), DEC(qword[r11 + rdx*8 - 88]).encode())
317
318
319class TestTEST(unittest.TestCase):
320    def runTest(self):
321        self.assertEqual(bytearray([0xA8, 0x02]), TEST(al, 2).encode())
322        self.assertEqual(bytearray([0xF6, 0xC3, 0x02]), TEST(bl, 2).encode())
323        self.assertEqual(bytearray([0x44, 0x84, 0xCB]), TEST(bl, r9b).encode())
324        self.assertEqual(bytearray([0x66, 0xA9, 0x00, 0x7D]), TEST(ax, 32000).encode())
325        self.assertEqual(bytearray([0x66, 0xF7, 0xC6, 0x00, 0x7D]), TEST(si, 32000).encode())
326        self.assertEqual(bytearray([0x66, 0x44, 0x85, 0xE6]), TEST(si, r12w).encode())
327        self.assertEqual(bytearray([0xA9, 0x00, 0x00, 0x00, 0x10]), TEST(eax, 0x10000000).encode())
328        self.assertEqual(bytearray([0xF7, 0xC5, 0x00, 0x00, 0x00, 0x10]), TEST(ebp, 0x10000000).encode())
329        self.assertEqual(bytearray([0x44, 0x85, 0xC5]), TEST(ebp, r8d).encode())
330        self.assertEqual(bytearray([0x48, 0xA9, 0x00, 0x00, 0x00, 0x10]), TEST(rax, 0x10000000).encode())
331        self.assertEqual(bytearray([0x48, 0xF7, 0xC1, 0x00, 0x00, 0x00, 0x10]), TEST(rcx, 0x10000000).encode())
332        self.assertEqual(bytearray([0x4C, 0x85, 0xF9]), TEST(rcx, r15).encode())
333        self.assertEqual(bytearray([0x41, 0xF6, 0x44, 0xBE, 0x85, 0x02]), TEST(byte[r14 + rdi*4 - 123], 2).encode())
334        self.assertEqual(bytearray([0x45, 0x84, 0x4C, 0xBE, 0x85]), TEST(byte[r14 + rdi*4 - 123], r9b).encode())
335        self.assertEqual(bytearray([0x66, 0x41, 0xF7, 0x44, 0xED, 0x95, 0x00, 0x7D]), TEST(word[r13 + rbp*8 - 107], 32000).encode())
336        self.assertEqual(bytearray([0x66, 0x45, 0x85, 0x64, 0xED, 0x95]), TEST(word[r13 + rbp*8 - 107], r12w).encode())
337        self.assertEqual(bytearray([0x41, 0xF7, 0x44, 0xCC, 0x9D, 0x00, 0x00, 0x00, 0x10]), TEST(dword[r12 + rcx*8 - 99], 0x10000000).encode())
338        self.assertEqual(bytearray([0x45, 0x85, 0x44, 0xCC, 0x9D]), TEST(dword[r12 + rcx*8 - 99], r8d).encode())
339        self.assertEqual(bytearray([0x49, 0xF7, 0x44, 0xD3, 0xA8, 0x00, 0x00, 0x00, 0x10]), TEST(qword[r11 + rdx*8 - 88], 0x10000000).encode())
340        self.assertEqual(bytearray([0x4D, 0x85, 0x7C, 0xD3, 0xA8]), TEST(qword[r11 + rdx*8 - 88], r15).encode())
341
342
343class TestCMP(unittest.TestCase):
344    def runTest(self):
345        self.assertEqual(bytearray([0x3C, 0x02]), CMP(al, 2).encode())
346        self.assertEqual(bytearray([0x80, 0xFB, 0x02]), CMP(bl, 2).encode())
347        self.assertEqual(bytearray([0x44, 0x38, 0xCB]), CMP(bl, r9b).encode())
348        self.assertEqual(bytearray([0x41, 0x3A, 0x5C, 0xBE, 0x85]), CMP(bl, byte[r14 + rdi*4 - 123]).encode())
349        self.assertEqual(bytearray([0x66, 0x3D, 0x00, 0x7D]), CMP(ax, 32000).encode())
350        self.assertEqual(bytearray([0x66, 0x83, 0xFE, 0x02]), CMP(si, 2).encode())
351        self.assertEqual(bytearray([0x66, 0x81, 0xFE, 0x00, 0x7D]), CMP(si, 32000).encode())
352        self.assertEqual(bytearray([0x66, 0x44, 0x39, 0xE6]), CMP(si, r12w).encode())
353        self.assertEqual(bytearray([0x66, 0x41, 0x3B, 0x74, 0xED, 0x95]), CMP(si, word[r13 + rbp*8 - 107]).encode())
354        self.assertEqual(bytearray([0x3D, 0x00, 0x00, 0x00, 0x10]), CMP(eax, 0x10000000).encode())
355        self.assertEqual(bytearray([0x83, 0xFD, 0x02]), CMP(ebp, 2).encode())
356        self.assertEqual(bytearray([0x81, 0xFD, 0x00, 0x00, 0x00, 0x10]), CMP(ebp, 0x10000000).encode())
357        self.assertEqual(bytearray([0x44, 0x39, 0xC5]), CMP(ebp, r8d).encode())
358        self.assertEqual(bytearray([0x41, 0x3B, 0x6C, 0xCC, 0x9D]), CMP(ebp, dword[r12 + rcx*8 - 99]).encode())
359        self.assertEqual(bytearray([0x48, 0x3D, 0x00, 0x00, 0x00, 0x10]), CMP(rax, 0x10000000).encode())
360        self.assertEqual(bytearray([0x48, 0x83, 0xF9, 0x02]), CMP(rcx, 2).encode())
361        self.assertEqual(bytearray([0x48, 0x81, 0xF9, 0x00, 0x00, 0x00, 0x10]), CMP(rcx, 0x10000000).encode())
362        self.assertEqual(bytearray([0x4C, 0x39, 0xF9]), CMP(rcx, r15).encode())
363        self.assertEqual(bytearray([0x49, 0x3B, 0x4C, 0xD3, 0xA8]), CMP(rcx, qword[r11 + rdx*8 - 88]).encode())
364        self.assertEqual(bytearray([0x41, 0x80, 0x7C, 0xBE, 0x85, 0x02]), CMP(byte[r14 + rdi*4 - 123], 2).encode())
365        self.assertEqual(bytearray([0x45, 0x38, 0x4C, 0xBE, 0x85]), CMP(byte[r14 + rdi*4 - 123], r9b).encode())
366        self.assertEqual(bytearray([0x66, 0x41, 0x83, 0x7C, 0xED, 0x95, 0x02]), CMP(word[r13 + rbp*8 - 107], 2).encode())
367        self.assertEqual(bytearray([0x66, 0x41, 0x81, 0x7C, 0xED, 0x95, 0x00, 0x7D]), CMP(word[r13 + rbp*8 - 107], 32000).encode())
368        self.assertEqual(bytearray([0x66, 0x45, 0x39, 0x64, 0xED, 0x95]), CMP(word[r13 + rbp*8 - 107], r12w).encode())
369        self.assertEqual(bytearray([0x41, 0x83, 0x7C, 0xCC, 0x9D, 0x02]), CMP(dword[r12 + rcx*8 - 99], 2).encode())
370        self.assertEqual(bytearray([0x41, 0x81, 0x7C, 0xCC, 0x9D, 0x00, 0x00, 0x00, 0x10]), CMP(dword[r12 + rcx*8 - 99], 0x10000000).encode())
371        self.assertEqual(bytearray([0x45, 0x39, 0x44, 0xCC, 0x9D]), CMP(dword[r12 + rcx*8 - 99], r8d).encode())
372        self.assertEqual(bytearray([0x49, 0x83, 0x7C, 0xD3, 0xA8, 0x02]), CMP(qword[r11 + rdx*8 - 88], 2).encode())
373        self.assertEqual(bytearray([0x49, 0x81, 0x7C, 0xD3, 0xA8, 0x00, 0x00, 0x00, 0x10]), CMP(qword[r11 + rdx*8 - 88], 0x10000000).encode())
374        self.assertEqual(bytearray([0x4D, 0x39, 0x7C, 0xD3, 0xA8]), CMP(qword[r11 + rdx*8 - 88], r15).encode())
375
376
377class TestMOV(unittest.TestCase):
378    def runTest(self):
379        self.assertEqual(bytearray([0xB3, 0x02]), MOV(bl, 2).encode())
380        self.assertEqual(bytearray([0x44, 0x88, 0xCB]), MOV(bl, r9b).encode())
381        self.assertEqual(bytearray([0x41, 0x8A, 0x5C, 0xBE, 0x85]), MOV(bl, byte[r14 + rdi*4 - 123]).encode())
382        self.assertEqual(bytearray([0x66, 0xBE, 0x00, 0x7D]), MOV(si, 32000).encode())
383        self.assertEqual(bytearray([0x66, 0x44, 0x89, 0xE6]), MOV(si, r12w).encode())
384        self.assertEqual(bytearray([0x66, 0x41, 0x8B, 0x74, 0xED, 0x95]), MOV(si, word[r13 + rbp*8 - 107]).encode())
385        self.assertEqual(bytearray([0xBD, 0x00, 0x00, 0x00, 0x10]), MOV(ebp, 0x10000000).encode())
386        self.assertEqual(bytearray([0x44, 0x89, 0xC5]), MOV(ebp, r8d).encode())
387        self.assertEqual(bytearray([0x41, 0x8B, 0x6C, 0xCC, 0x9D]), MOV(ebp, dword[r12 + rcx*8 - 99]).encode())
388        self.assertEqual(bytearray([0x48, 0xC7, 0xC1, 0x00, 0x00, 0x00, 0x10]), MOV(rcx, 0x10000000).encode())
389        self.assertEqual(bytearray([0x48, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00]), MOV(rcx, 0x100000000).encode())
390        self.assertEqual(bytearray([0x4C, 0x89, 0xF9]), MOV(rcx, r15).encode())
391        self.assertEqual(bytearray([0x49, 0x8B, 0x4C, 0xD3, 0xA8]), MOV(rcx, qword[r11 + rdx*8 - 88]).encode())
392        self.assertEqual(bytearray([0x41, 0xC6, 0x44, 0xBE, 0x85, 0x02]), MOV(byte[r14 + rdi*4 - 123], 2).encode())
393        self.assertEqual(bytearray([0x45, 0x88, 0x4C, 0xBE, 0x85]), MOV(byte[r14 + rdi*4 - 123], r9b).encode())
394        self.assertEqual(bytearray([0x66, 0x41, 0xC7, 0x44, 0xED, 0x95, 0x00, 0x7D]), MOV(word[r13 + rbp*8 - 107], 32000).encode())
395        self.assertEqual(bytearray([0x66, 0x45, 0x89, 0x64, 0xED, 0x95]), MOV(word[r13 + rbp*8 - 107], r12w).encode())
396        self.assertEqual(bytearray([0x41, 0xC7, 0x44, 0xCC, 0x9D, 0x00, 0x00, 0x00, 0x10]), MOV(dword[r12 + rcx*8 - 99], 0x10000000).encode())
397        self.assertEqual(bytearray([0x45, 0x89, 0x44, 0xCC, 0x9D]), MOV(dword[r12 + rcx*8 - 99], r8d).encode())
398        self.assertEqual(bytearray([0x49, 0xC7, 0x44, 0xD3, 0xA8, 0x00, 0x00, 0x00, 0x10]), MOV(qword[r11 + rdx*8 - 88], 0x10000000).encode())
399        self.assertEqual(bytearray([0x4D, 0x89, 0x7C, 0xD3, 0xA8]), MOV(qword[r11 + rdx*8 - 88], r15).encode())
400
401
402class TestMOVZX(unittest.TestCase):
403    def runTest(self):
404        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0xB6, 0xF1]), MOVZX(si, r9b).encode())
405        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0xB6, 0x74, 0xBE, 0x85]), MOVZX(si, byte[r14 + rdi*4 - 123]).encode())
406        self.assertEqual(bytearray([0x41, 0x0F, 0xB6, 0xE9]), MOVZX(ebp, r9b).encode())
407        self.assertEqual(bytearray([0x41, 0x0F, 0xB7, 0xEC]), MOVZX(ebp, r12w).encode())
408        self.assertEqual(bytearray([0x41, 0x0F, 0xB6, 0x6C, 0xBE, 0x85]), MOVZX(ebp, byte[r14 + rdi*4 - 123]).encode())
409        self.assertEqual(bytearray([0x41, 0x0F, 0xB7, 0x6C, 0xED, 0x95]), MOVZX(ebp, word[r13 + rbp*8 - 107]).encode())
410        self.assertEqual(bytearray([0x49, 0x0F, 0xB6, 0xC9]), MOVZX(rcx, r9b).encode())
411        self.assertEqual(bytearray([0x49, 0x0F, 0xB7, 0xCC]), MOVZX(rcx, r12w).encode())
412        self.assertEqual(bytearray([0x49, 0x0F, 0xB6, 0x4C, 0xBE, 0x85]), MOVZX(rcx, byte[r14 + rdi*4 - 123]).encode())
413        self.assertEqual(bytearray([0x49, 0x0F, 0xB7, 0x4C, 0xED, 0x95]), MOVZX(rcx, word[r13 + rbp*8 - 107]).encode())
414
415
416class TestMOVSX(unittest.TestCase):
417    def runTest(self):
418        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0xBE, 0xF1]), MOVSX(si, r9b).encode())
419        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0xBE, 0x74, 0xBE, 0x85]), MOVSX(si, byte[r14 + rdi*4 - 123]).encode())
420        self.assertEqual(bytearray([0x41, 0x0F, 0xBE, 0xE9]), MOVSX(ebp, r9b).encode())
421        self.assertEqual(bytearray([0x41, 0x0F, 0xBF, 0xEC]), MOVSX(ebp, r12w).encode())
422        self.assertEqual(bytearray([0x41, 0x0F, 0xBE, 0x6C, 0xBE, 0x85]), MOVSX(ebp, byte[r14 + rdi*4 - 123]).encode())
423        self.assertEqual(bytearray([0x41, 0x0F, 0xBF, 0x6C, 0xED, 0x95]), MOVSX(ebp, word[r13 + rbp*8 - 107]).encode())
424        self.assertEqual(bytearray([0x49, 0x0F, 0xBE, 0xC9]), MOVSX(rcx, r9b).encode())
425        self.assertEqual(bytearray([0x49, 0x0F, 0xBF, 0xCC]), MOVSX(rcx, r12w).encode())
426        self.assertEqual(bytearray([0x49, 0x0F, 0xBE, 0x4C, 0xBE, 0x85]), MOVSX(rcx, byte[r14 + rdi*4 - 123]).encode())
427        self.assertEqual(bytearray([0x49, 0x0F, 0xBF, 0x4C, 0xED, 0x95]), MOVSX(rcx, word[r13 + rbp*8 - 107]).encode())
428
429
430class TestMOVSXD(unittest.TestCase):
431    def runTest(self):
432        self.assertEqual(bytearray([0x49, 0x63, 0xC8]), MOVSXD(rcx, r8d).encode())
433        self.assertEqual(bytearray([0x49, 0x63, 0x4C, 0xCC, 0x9D]), MOVSXD(rcx, dword[r12 + rcx*8 - 99]).encode())
434
435
436class TestMOVBE(unittest.TestCase):
437    def runTest(self):
438        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x38, 0xF0, 0x74, 0xED, 0x95]), MOVBE(si, word[r13 + rbp*8 - 107]).encode())
439        self.assertEqual(bytearray([0x41, 0x0F, 0x38, 0xF0, 0x6C, 0xCC, 0x9D]), MOVBE(ebp, dword[r12 + rcx*8 - 99]).encode())
440        self.assertEqual(bytearray([0x49, 0x0F, 0x38, 0xF0, 0x4C, 0xD3, 0xA8]), MOVBE(rcx, qword[r11 + rdx*8 - 88]).encode())
441        self.assertEqual(bytearray([0x66, 0x45, 0x0F, 0x38, 0xF1, 0x64, 0xED, 0x95]), MOVBE(word[r13 + rbp*8 - 107], r12w).encode())
442        self.assertEqual(bytearray([0x45, 0x0F, 0x38, 0xF1, 0x44, 0xCC, 0x9D]), MOVBE(dword[r12 + rcx*8 - 99], r8d).encode())
443        self.assertEqual(bytearray([0x4D, 0x0F, 0x38, 0xF1, 0x7C, 0xD3, 0xA8]), MOVBE(qword[r11 + rdx*8 - 88], r15).encode())
444
445
446class TestMOVNTI(unittest.TestCase):
447    def runTest(self):
448        self.assertEqual(bytearray([0x45, 0x0F, 0xC3, 0x44, 0xCC, 0x9D]), MOVNTI(dword[r12 + rcx*8 - 99], r8d).encode())
449        self.assertEqual(bytearray([0x4D, 0x0F, 0xC3, 0x7C, 0xD3, 0xA8]), MOVNTI(qword[r11 + rdx*8 - 88], r15).encode())
450
451
452class TestBT(unittest.TestCase):
453    def runTest(self):
454        self.assertEqual(bytearray([0x66, 0x0F, 0xBA, 0xE6, 0x02]), BT(si, 2).encode())
455        self.assertEqual(bytearray([0x66, 0x44, 0x0F, 0xA3, 0xE6]), BT(si, r12w).encode())
456        self.assertEqual(bytearray([0x0F, 0xBA, 0xE5, 0x02]), BT(ebp, 2).encode())
457        self.assertEqual(bytearray([0x44, 0x0F, 0xA3, 0xC5]), BT(ebp, r8d).encode())
458        self.assertEqual(bytearray([0x48, 0x0F, 0xBA, 0xE1, 0x02]), BT(rcx, 2).encode())
459        self.assertEqual(bytearray([0x4C, 0x0F, 0xA3, 0xF9]), BT(rcx, r15).encode())
460        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0xBA, 0x64, 0xED, 0x95, 0x02]), BT(word[r13 + rbp*8 - 107], 2).encode())
461        self.assertEqual(bytearray([0x66, 0x45, 0x0F, 0xA3, 0x64, 0xED, 0x95]), BT(word[r13 + rbp*8 - 107], r12w).encode())
462        self.assertEqual(bytearray([0x41, 0x0F, 0xBA, 0x64, 0xCC, 0x9D, 0x02]), BT(dword[r12 + rcx*8 - 99], 2).encode())
463        self.assertEqual(bytearray([0x45, 0x0F, 0xA3, 0x44, 0xCC, 0x9D]), BT(dword[r12 + rcx*8 - 99], r8d).encode())
464        self.assertEqual(bytearray([0x49, 0x0F, 0xBA, 0x64, 0xD3, 0xA8, 0x02]), BT(qword[r11 + rdx*8 - 88], 2).encode())
465        self.assertEqual(bytearray([0x4D, 0x0F, 0xA3, 0x7C, 0xD3, 0xA8]), BT(qword[r11 + rdx*8 - 88], r15).encode())
466
467
468class TestBTS(unittest.TestCase):
469    def runTest(self):
470        self.assertEqual(bytearray([0x66, 0x0F, 0xBA, 0xEE, 0x02]), BTS(si, 2).encode())
471        self.assertEqual(bytearray([0x66, 0x44, 0x0F, 0xAB, 0xE6]), BTS(si, r12w).encode())
472        self.assertEqual(bytearray([0x0F, 0xBA, 0xED, 0x02]), BTS(ebp, 2).encode())
473        self.assertEqual(bytearray([0x44, 0x0F, 0xAB, 0xC5]), BTS(ebp, r8d).encode())
474        self.assertEqual(bytearray([0x48, 0x0F, 0xBA, 0xE9, 0x02]), BTS(rcx, 2).encode())
475        self.assertEqual(bytearray([0x4C, 0x0F, 0xAB, 0xF9]), BTS(rcx, r15).encode())
476        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0xBA, 0x6C, 0xED, 0x95, 0x02]), BTS(word[r13 + rbp*8 - 107], 2).encode())
477        self.assertEqual(bytearray([0x66, 0x45, 0x0F, 0xAB, 0x64, 0xED, 0x95]), BTS(word[r13 + rbp*8 - 107], r12w).encode())
478        self.assertEqual(bytearray([0x41, 0x0F, 0xBA, 0x6C, 0xCC, 0x9D, 0x02]), BTS(dword[r12 + rcx*8 - 99], 2).encode())
479        self.assertEqual(bytearray([0x45, 0x0F, 0xAB, 0x44, 0xCC, 0x9D]), BTS(dword[r12 + rcx*8 - 99], r8d).encode())
480        self.assertEqual(bytearray([0x49, 0x0F, 0xBA, 0x6C, 0xD3, 0xA8, 0x02]), BTS(qword[r11 + rdx*8 - 88], 2).encode())
481        self.assertEqual(bytearray([0x4D, 0x0F, 0xAB, 0x7C, 0xD3, 0xA8]), BTS(qword[r11 + rdx*8 - 88], r15).encode())
482
483
484class TestBTR(unittest.TestCase):
485    def runTest(self):
486        self.assertEqual(bytearray([0x66, 0x0F, 0xBA, 0xF6, 0x02]), BTR(si, 2).encode())
487        self.assertEqual(bytearray([0x66, 0x44, 0x0F, 0xB3, 0xE6]), BTR(si, r12w).encode())
488        self.assertEqual(bytearray([0x0F, 0xBA, 0xF5, 0x02]), BTR(ebp, 2).encode())
489        self.assertEqual(bytearray([0x44, 0x0F, 0xB3, 0xC5]), BTR(ebp, r8d).encode())
490        self.assertEqual(bytearray([0x48, 0x0F, 0xBA, 0xF1, 0x02]), BTR(rcx, 2).encode())
491        self.assertEqual(bytearray([0x4C, 0x0F, 0xB3, 0xF9]), BTR(rcx, r15).encode())
492        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0xBA, 0x74, 0xED, 0x95, 0x02]), BTR(word[r13 + rbp*8 - 107], 2).encode())
493        self.assertEqual(bytearray([0x66, 0x45, 0x0F, 0xB3, 0x64, 0xED, 0x95]), BTR(word[r13 + rbp*8 - 107], r12w).encode())
494        self.assertEqual(bytearray([0x41, 0x0F, 0xBA, 0x74, 0xCC, 0x9D, 0x02]), BTR(dword[r12 + rcx*8 - 99], 2).encode())
495        self.assertEqual(bytearray([0x45, 0x0F, 0xB3, 0x44, 0xCC, 0x9D]), BTR(dword[r12 + rcx*8 - 99], r8d).encode())
496        self.assertEqual(bytearray([0x49, 0x0F, 0xBA, 0x74, 0xD3, 0xA8, 0x02]), BTR(qword[r11 + rdx*8 - 88], 2).encode())
497        self.assertEqual(bytearray([0x4D, 0x0F, 0xB3, 0x7C, 0xD3, 0xA8]), BTR(qword[r11 + rdx*8 - 88], r15).encode())
498
499
500class TestBTC(unittest.TestCase):
501    def runTest(self):
502        self.assertEqual(bytearray([0x66, 0x0F, 0xBA, 0xFE, 0x02]), BTC(si, 2).encode())
503        self.assertEqual(bytearray([0x66, 0x44, 0x0F, 0xBB, 0xE6]), BTC(si, r12w).encode())
504        self.assertEqual(bytearray([0x0F, 0xBA, 0xFD, 0x02]), BTC(ebp, 2).encode())
505        self.assertEqual(bytearray([0x44, 0x0F, 0xBB, 0xC5]), BTC(ebp, r8d).encode())
506        self.assertEqual(bytearray([0x48, 0x0F, 0xBA, 0xF9, 0x02]), BTC(rcx, 2).encode())
507        self.assertEqual(bytearray([0x4C, 0x0F, 0xBB, 0xF9]), BTC(rcx, r15).encode())
508        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0xBA, 0x7C, 0xED, 0x95, 0x02]), BTC(word[r13 + rbp*8 - 107], 2).encode())
509        self.assertEqual(bytearray([0x66, 0x45, 0x0F, 0xBB, 0x64, 0xED, 0x95]), BTC(word[r13 + rbp*8 - 107], r12w).encode())
510        self.assertEqual(bytearray([0x41, 0x0F, 0xBA, 0x7C, 0xCC, 0x9D, 0x02]), BTC(dword[r12 + rcx*8 - 99], 2).encode())
511        self.assertEqual(bytearray([0x45, 0x0F, 0xBB, 0x44, 0xCC, 0x9D]), BTC(dword[r12 + rcx*8 - 99], r8d).encode())
512        self.assertEqual(bytearray([0x49, 0x0F, 0xBA, 0x7C, 0xD3, 0xA8, 0x02]), BTC(qword[r11 + rdx*8 - 88], 2).encode())
513        self.assertEqual(bytearray([0x4D, 0x0F, 0xBB, 0x7C, 0xD3, 0xA8]), BTC(qword[r11 + rdx*8 - 88], r15).encode())
514
515
516class TestPOPCNT(unittest.TestCase):
517    def runTest(self):
518        self.assertEqual(bytearray([0x66, 0xF3, 0x41, 0x0F, 0xB8, 0xF4]), POPCNT(si, r12w).encode())
519        self.assertEqual(bytearray([0x66, 0xF3, 0x41, 0x0F, 0xB8, 0x74, 0xED, 0x95]), POPCNT(si, word[r13 + rbp*8 - 107]).encode())
520        self.assertEqual(bytearray([0xF3, 0x41, 0x0F, 0xB8, 0xE8]), POPCNT(ebp, r8d).encode())
521        self.assertEqual(bytearray([0xF3, 0x41, 0x0F, 0xB8, 0x6C, 0xCC, 0x9D]), POPCNT(ebp, dword[r12 + rcx*8 - 99]).encode())
522        self.assertEqual(bytearray([0xF3, 0x49, 0x0F, 0xB8, 0xCF]), POPCNT(rcx, r15).encode())
523        self.assertEqual(bytearray([0xF3, 0x49, 0x0F, 0xB8, 0x4C, 0xD3, 0xA8]), POPCNT(rcx, qword[r11 + rdx*8 - 88]).encode())
524
525
526class TestBSWAP(unittest.TestCase):
527    def runTest(self):
528        self.assertEqual(bytearray([0x0F, 0xCD]), BSWAP(ebp).encode())
529        self.assertEqual(bytearray([0x48, 0x0F, 0xC9]), BSWAP(rcx).encode())
530
531
532class TestBSF(unittest.TestCase):
533    def runTest(self):
534        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0xBC, 0xF4]), BSF(si, r12w).encode())
535        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0xBC, 0x74, 0xED, 0x95]), BSF(si, word[r13 + rbp*8 - 107]).encode())
536        self.assertEqual(bytearray([0x41, 0x0F, 0xBC, 0xE8]), BSF(ebp, r8d).encode())
537        self.assertEqual(bytearray([0x41, 0x0F, 0xBC, 0x6C, 0xCC, 0x9D]), BSF(ebp, dword[r12 + rcx*8 - 99]).encode())
538        self.assertEqual(bytearray([0x49, 0x0F, 0xBC, 0xCF]), BSF(rcx, r15).encode())
539        self.assertEqual(bytearray([0x49, 0x0F, 0xBC, 0x4C, 0xD3, 0xA8]), BSF(rcx, qword[r11 + rdx*8 - 88]).encode())
540
541
542class TestBSR(unittest.TestCase):
543    def runTest(self):
544        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0xBD, 0xF4]), BSR(si, r12w).encode())
545        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0xBD, 0x74, 0xED, 0x95]), BSR(si, word[r13 + rbp*8 - 107]).encode())
546        self.assertEqual(bytearray([0x41, 0x0F, 0xBD, 0xE8]), BSR(ebp, r8d).encode())
547        self.assertEqual(bytearray([0x41, 0x0F, 0xBD, 0x6C, 0xCC, 0x9D]), BSR(ebp, dword[r12 + rcx*8 - 99]).encode())
548        self.assertEqual(bytearray([0x49, 0x0F, 0xBD, 0xCF]), BSR(rcx, r15).encode())
549        self.assertEqual(bytearray([0x49, 0x0F, 0xBD, 0x4C, 0xD3, 0xA8]), BSR(rcx, qword[r11 + rdx*8 - 88]).encode())
550
551
552class TestLZCNT(unittest.TestCase):
553    def runTest(self):
554        self.assertEqual(bytearray([0x66, 0xF3, 0x41, 0x0F, 0xBD, 0xF4]), LZCNT(si, r12w).encode())
555        self.assertEqual(bytearray([0x66, 0xF3, 0x41, 0x0F, 0xBD, 0x74, 0xED, 0x95]), LZCNT(si, word[r13 + rbp*8 - 107]).encode())
556        self.assertEqual(bytearray([0xF3, 0x41, 0x0F, 0xBD, 0xE8]), LZCNT(ebp, r8d).encode())
557        self.assertEqual(bytearray([0xF3, 0x41, 0x0F, 0xBD, 0x6C, 0xCC, 0x9D]), LZCNT(ebp, dword[r12 + rcx*8 - 99]).encode())
558        self.assertEqual(bytearray([0xF3, 0x49, 0x0F, 0xBD, 0xCF]), LZCNT(rcx, r15).encode())
559        self.assertEqual(bytearray([0xF3, 0x49, 0x0F, 0xBD, 0x4C, 0xD3, 0xA8]), LZCNT(rcx, qword[r11 + rdx*8 - 88]).encode())
560
561
562class TestTZCNT(unittest.TestCase):
563    def runTest(self):
564        self.assertEqual(bytearray([0x66, 0xF3, 0x41, 0x0F, 0xBC, 0xF4]), TZCNT(si, r12w).encode())
565        self.assertEqual(bytearray([0x66, 0xF3, 0x41, 0x0F, 0xBC, 0x74, 0xED, 0x95]), TZCNT(si, word[r13 + rbp*8 - 107]).encode())
566        self.assertEqual(bytearray([0xF3, 0x41, 0x0F, 0xBC, 0xE8]), TZCNT(ebp, r8d).encode())
567        self.assertEqual(bytearray([0xF3, 0x41, 0x0F, 0xBC, 0x6C, 0xCC, 0x9D]), TZCNT(ebp, dword[r12 + rcx*8 - 99]).encode())
568        self.assertEqual(bytearray([0xF3, 0x49, 0x0F, 0xBC, 0xCF]), TZCNT(rcx, r15).encode())
569        self.assertEqual(bytearray([0xF3, 0x49, 0x0F, 0xBC, 0x4C, 0xD3, 0xA8]), TZCNT(rcx, qword[r11 + rdx*8 - 88]).encode())
570
571
572class TestSHR(unittest.TestCase):
573    def runTest(self):
574        self.assertEqual(bytearray([0xD0, 0xEB]), SHR(bl, 1).encode())
575        self.assertEqual(bytearray([0xC0, 0xEB, 0x02]), SHR(bl, 2).encode())
576        self.assertEqual(bytearray([0xD2, 0xEB]), SHR(bl, cl).encode())
577        self.assertEqual(bytearray([0x66, 0xD1, 0xEE]), SHR(si, 1).encode())
578        self.assertEqual(bytearray([0x66, 0xC1, 0xEE, 0x02]), SHR(si, 2).encode())
579        self.assertEqual(bytearray([0x66, 0xD3, 0xEE]), SHR(si, cl).encode())
580        self.assertEqual(bytearray([0xD1, 0xED]), SHR(ebp, 1).encode())
581        self.assertEqual(bytearray([0xC1, 0xED, 0x02]), SHR(ebp, 2).encode())
582        self.assertEqual(bytearray([0xD3, 0xED]), SHR(ebp, cl).encode())
583        self.assertEqual(bytearray([0x48, 0xD1, 0xE9]), SHR(rcx, 1).encode())
584        self.assertEqual(bytearray([0x48, 0xC1, 0xE9, 0x02]), SHR(rcx, 2).encode())
585        self.assertEqual(bytearray([0x48, 0xD3, 0xE9]), SHR(rcx, cl).encode())
586        self.assertEqual(bytearray([0x41, 0xD0, 0x6C, 0xBE, 0x85]), SHR(byte[r14 + rdi*4 - 123], 1).encode())
587        self.assertEqual(bytearray([0x41, 0xC0, 0x6C, 0xBE, 0x85, 0x02]), SHR(byte[r14 + rdi*4 - 123], 2).encode())
588        self.assertEqual(bytearray([0x41, 0xD2, 0x6C, 0xBE, 0x85]), SHR(byte[r14 + rdi*4 - 123], cl).encode())
589        self.assertEqual(bytearray([0x66, 0x41, 0xD1, 0x6C, 0xED, 0x95]), SHR(word[r13 + rbp*8 - 107], 1).encode())
590        self.assertEqual(bytearray([0x66, 0x41, 0xC1, 0x6C, 0xED, 0x95, 0x02]), SHR(word[r13 + rbp*8 - 107], 2).encode())
591        self.assertEqual(bytearray([0x66, 0x41, 0xD3, 0x6C, 0xED, 0x95]), SHR(word[r13 + rbp*8 - 107], cl).encode())
592        self.assertEqual(bytearray([0x41, 0xD1, 0x6C, 0xCC, 0x9D]), SHR(dword[r12 + rcx*8 - 99], 1).encode())
593        self.assertEqual(bytearray([0x41, 0xC1, 0x6C, 0xCC, 0x9D, 0x02]), SHR(dword[r12 + rcx*8 - 99], 2).encode())
594        self.assertEqual(bytearray([0x41, 0xD3, 0x6C, 0xCC, 0x9D]), SHR(dword[r12 + rcx*8 - 99], cl).encode())
595        self.assertEqual(bytearray([0x49, 0xD1, 0x6C, 0xD3, 0xA8]), SHR(qword[r11 + rdx*8 - 88], 1).encode())
596        self.assertEqual(bytearray([0x49, 0xC1, 0x6C, 0xD3, 0xA8, 0x02]), SHR(qword[r11 + rdx*8 - 88], 2).encode())
597        self.assertEqual(bytearray([0x49, 0xD3, 0x6C, 0xD3, 0xA8]), SHR(qword[r11 + rdx*8 - 88], cl).encode())
598
599
600class TestSAR(unittest.TestCase):
601    def runTest(self):
602        self.assertEqual(bytearray([0xD0, 0xFB]), SAR(bl, 1).encode())
603        self.assertEqual(bytearray([0xC0, 0xFB, 0x02]), SAR(bl, 2).encode())
604        self.assertEqual(bytearray([0xD2, 0xFB]), SAR(bl, cl).encode())
605        self.assertEqual(bytearray([0x66, 0xD1, 0xFE]), SAR(si, 1).encode())
606        self.assertEqual(bytearray([0x66, 0xC1, 0xFE, 0x02]), SAR(si, 2).encode())
607        self.assertEqual(bytearray([0x66, 0xD3, 0xFE]), SAR(si, cl).encode())
608        self.assertEqual(bytearray([0xD1, 0xFD]), SAR(ebp, 1).encode())
609        self.assertEqual(bytearray([0xC1, 0xFD, 0x02]), SAR(ebp, 2).encode())
610        self.assertEqual(bytearray([0xD3, 0xFD]), SAR(ebp, cl).encode())
611        self.assertEqual(bytearray([0x48, 0xD1, 0xF9]), SAR(rcx, 1).encode())
612        self.assertEqual(bytearray([0x48, 0xC1, 0xF9, 0x02]), SAR(rcx, 2).encode())
613        self.assertEqual(bytearray([0x48, 0xD3, 0xF9]), SAR(rcx, cl).encode())
614        self.assertEqual(bytearray([0x41, 0xD0, 0x7C, 0xBE, 0x85]), SAR(byte[r14 + rdi*4 - 123], 1).encode())
615        self.assertEqual(bytearray([0x41, 0xC0, 0x7C, 0xBE, 0x85, 0x02]), SAR(byte[r14 + rdi*4 - 123], 2).encode())
616        self.assertEqual(bytearray([0x41, 0xD2, 0x7C, 0xBE, 0x85]), SAR(byte[r14 + rdi*4 - 123], cl).encode())
617        self.assertEqual(bytearray([0x66, 0x41, 0xD1, 0x7C, 0xED, 0x95]), SAR(word[r13 + rbp*8 - 107], 1).encode())
618        self.assertEqual(bytearray([0x66, 0x41, 0xC1, 0x7C, 0xED, 0x95, 0x02]), SAR(word[r13 + rbp*8 - 107], 2).encode())
619        self.assertEqual(bytearray([0x66, 0x41, 0xD3, 0x7C, 0xED, 0x95]), SAR(word[r13 + rbp*8 - 107], cl).encode())
620        self.assertEqual(bytearray([0x41, 0xD1, 0x7C, 0xCC, 0x9D]), SAR(dword[r12 + rcx*8 - 99], 1).encode())
621        self.assertEqual(bytearray([0x41, 0xC1, 0x7C, 0xCC, 0x9D, 0x02]), SAR(dword[r12 + rcx*8 - 99], 2).encode())
622        self.assertEqual(bytearray([0x41, 0xD3, 0x7C, 0xCC, 0x9D]), SAR(dword[r12 + rcx*8 - 99], cl).encode())
623        self.assertEqual(bytearray([0x49, 0xD1, 0x7C, 0xD3, 0xA8]), SAR(qword[r11 + rdx*8 - 88], 1).encode())
624        self.assertEqual(bytearray([0x49, 0xC1, 0x7C, 0xD3, 0xA8, 0x02]), SAR(qword[r11 + rdx*8 - 88], 2).encode())
625        self.assertEqual(bytearray([0x49, 0xD3, 0x7C, 0xD3, 0xA8]), SAR(qword[r11 + rdx*8 - 88], cl).encode())
626
627
628class TestSHL(unittest.TestCase):
629    def runTest(self):
630        self.assertEqual(bytearray([0xD0, 0xE3]), SHL(bl, 1).encode())
631        self.assertEqual(bytearray([0xC0, 0xE3, 0x02]), SHL(bl, 2).encode())
632        self.assertEqual(bytearray([0xD2, 0xE3]), SHL(bl, cl).encode())
633        self.assertEqual(bytearray([0x66, 0xD1, 0xE6]), SHL(si, 1).encode())
634        self.assertEqual(bytearray([0x66, 0xC1, 0xE6, 0x02]), SHL(si, 2).encode())
635        self.assertEqual(bytearray([0x66, 0xD3, 0xE6]), SHL(si, cl).encode())
636        self.assertEqual(bytearray([0xD1, 0xE5]), SHL(ebp, 1).encode())
637        self.assertEqual(bytearray([0xC1, 0xE5, 0x02]), SHL(ebp, 2).encode())
638        self.assertEqual(bytearray([0xD3, 0xE5]), SHL(ebp, cl).encode())
639        self.assertEqual(bytearray([0x48, 0xD1, 0xE1]), SHL(rcx, 1).encode())
640        self.assertEqual(bytearray([0x48, 0xC1, 0xE1, 0x02]), SHL(rcx, 2).encode())
641        self.assertEqual(bytearray([0x48, 0xD3, 0xE1]), SHL(rcx, cl).encode())
642        self.assertEqual(bytearray([0x41, 0xD0, 0x64, 0xBE, 0x85]), SHL(byte[r14 + rdi*4 - 123], 1).encode())
643        self.assertEqual(bytearray([0x41, 0xC0, 0x64, 0xBE, 0x85, 0x02]), SHL(byte[r14 + rdi*4 - 123], 2).encode())
644        self.assertEqual(bytearray([0x41, 0xD2, 0x64, 0xBE, 0x85]), SHL(byte[r14 + rdi*4 - 123], cl).encode())
645        self.assertEqual(bytearray([0x66, 0x41, 0xD1, 0x64, 0xED, 0x95]), SHL(word[r13 + rbp*8 - 107], 1).encode())
646        self.assertEqual(bytearray([0x66, 0x41, 0xC1, 0x64, 0xED, 0x95, 0x02]), SHL(word[r13 + rbp*8 - 107], 2).encode())
647        self.assertEqual(bytearray([0x66, 0x41, 0xD3, 0x64, 0xED, 0x95]), SHL(word[r13 + rbp*8 - 107], cl).encode())
648        self.assertEqual(bytearray([0x41, 0xD1, 0x64, 0xCC, 0x9D]), SHL(dword[r12 + rcx*8 - 99], 1).encode())
649        self.assertEqual(bytearray([0x41, 0xC1, 0x64, 0xCC, 0x9D, 0x02]), SHL(dword[r12 + rcx*8 - 99], 2).encode())
650        self.assertEqual(bytearray([0x41, 0xD3, 0x64, 0xCC, 0x9D]), SHL(dword[r12 + rcx*8 - 99], cl).encode())
651        self.assertEqual(bytearray([0x49, 0xD1, 0x64, 0xD3, 0xA8]), SHL(qword[r11 + rdx*8 - 88], 1).encode())
652        self.assertEqual(bytearray([0x49, 0xC1, 0x64, 0xD3, 0xA8, 0x02]), SHL(qword[r11 + rdx*8 - 88], 2).encode())
653        self.assertEqual(bytearray([0x49, 0xD3, 0x64, 0xD3, 0xA8]), SHL(qword[r11 + rdx*8 - 88], cl).encode())
654
655
656class TestSAL(unittest.TestCase):
657    def runTest(self):
658        self.assertEqual(bytearray([0xD0, 0xE3]), SAL(bl, 1).encode())
659        self.assertEqual(bytearray([0xC0, 0xE3, 0x02]), SAL(bl, 2).encode())
660        self.assertEqual(bytearray([0xD2, 0xE3]), SAL(bl, cl).encode())
661        self.assertEqual(bytearray([0x66, 0xD1, 0xE6]), SAL(si, 1).encode())
662        self.assertEqual(bytearray([0x66, 0xC1, 0xE6, 0x02]), SAL(si, 2).encode())
663        self.assertEqual(bytearray([0x66, 0xD3, 0xE6]), SAL(si, cl).encode())
664        self.assertEqual(bytearray([0xD1, 0xE5]), SAL(ebp, 1).encode())
665        self.assertEqual(bytearray([0xC1, 0xE5, 0x02]), SAL(ebp, 2).encode())
666        self.assertEqual(bytearray([0xD3, 0xE5]), SAL(ebp, cl).encode())
667        self.assertEqual(bytearray([0x48, 0xD1, 0xE1]), SAL(rcx, 1).encode())
668        self.assertEqual(bytearray([0x48, 0xC1, 0xE1, 0x02]), SAL(rcx, 2).encode())
669        self.assertEqual(bytearray([0x48, 0xD3, 0xE1]), SAL(rcx, cl).encode())
670        self.assertEqual(bytearray([0x41, 0xD0, 0x64, 0xBE, 0x85]), SAL(byte[r14 + rdi*4 - 123], 1).encode())
671        self.assertEqual(bytearray([0x41, 0xC0, 0x64, 0xBE, 0x85, 0x02]), SAL(byte[r14 + rdi*4 - 123], 2).encode())
672        self.assertEqual(bytearray([0x41, 0xD2, 0x64, 0xBE, 0x85]), SAL(byte[r14 + rdi*4 - 123], cl).encode())
673        self.assertEqual(bytearray([0x66, 0x41, 0xD1, 0x64, 0xED, 0x95]), SAL(word[r13 + rbp*8 - 107], 1).encode())
674        self.assertEqual(bytearray([0x66, 0x41, 0xC1, 0x64, 0xED, 0x95, 0x02]), SAL(word[r13 + rbp*8 - 107], 2).encode())
675        self.assertEqual(bytearray([0x66, 0x41, 0xD3, 0x64, 0xED, 0x95]), SAL(word[r13 + rbp*8 - 107], cl).encode())
676        self.assertEqual(bytearray([0x41, 0xD1, 0x64, 0xCC, 0x9D]), SAL(dword[r12 + rcx*8 - 99], 1).encode())
677        self.assertEqual(bytearray([0x41, 0xC1, 0x64, 0xCC, 0x9D, 0x02]), SAL(dword[r12 + rcx*8 - 99], 2).encode())
678        self.assertEqual(bytearray([0x41, 0xD3, 0x64, 0xCC, 0x9D]), SAL(dword[r12 + rcx*8 - 99], cl).encode())
679        self.assertEqual(bytearray([0x49, 0xD1, 0x64, 0xD3, 0xA8]), SAL(qword[r11 + rdx*8 - 88], 1).encode())
680        self.assertEqual(bytearray([0x49, 0xC1, 0x64, 0xD3, 0xA8, 0x02]), SAL(qword[r11 + rdx*8 - 88], 2).encode())
681        self.assertEqual(bytearray([0x49, 0xD3, 0x64, 0xD3, 0xA8]), SAL(qword[r11 + rdx*8 - 88], cl).encode())
682
683
684class TestSHRX(unittest.TestCase):
685    def runTest(self):
686        self.assertEqual(bytearray([0xC4, 0xC2, 0x7B, 0xF7, 0xE8]), SHRX(ebp, r8d, eax).encode())
687        self.assertEqual(bytearray([0xC4, 0xC2, 0x7B, 0xF7, 0x6C, 0xCC, 0x9D]), SHRX(ebp, dword[r12 + rcx*8 - 99], eax).encode())
688        self.assertEqual(bytearray([0xC4, 0xC2, 0xFB, 0xF7, 0xCF]), SHRX(rcx, r15, rax).encode())
689        self.assertEqual(bytearray([0xC4, 0xC2, 0xFB, 0xF7, 0x4C, 0xD3, 0xA8]), SHRX(rcx, qword[r11 + rdx*8 - 88], rax).encode())
690
691
692class TestSARX(unittest.TestCase):
693    def runTest(self):
694        self.assertEqual(bytearray([0xC4, 0xC2, 0x7A, 0xF7, 0xE8]), SARX(ebp, r8d, eax).encode())
695        self.assertEqual(bytearray([0xC4, 0xC2, 0x7A, 0xF7, 0x6C, 0xCC, 0x9D]), SARX(ebp, dword[r12 + rcx*8 - 99], eax).encode())
696        self.assertEqual(bytearray([0xC4, 0xC2, 0xFA, 0xF7, 0xCF]), SARX(rcx, r15, rax).encode())
697        self.assertEqual(bytearray([0xC4, 0xC2, 0xFA, 0xF7, 0x4C, 0xD3, 0xA8]), SARX(rcx, qword[r11 + rdx*8 - 88], rax).encode())
698
699
700class TestSHLX(unittest.TestCase):
701    def runTest(self):
702        self.assertEqual(bytearray([0xC4, 0xC2, 0x79, 0xF7, 0xE8]), SHLX(ebp, r8d, eax).encode())
703        self.assertEqual(bytearray([0xC4, 0xC2, 0x79, 0xF7, 0x6C, 0xCC, 0x9D]), SHLX(ebp, dword[r12 + rcx*8 - 99], eax).encode())
704        self.assertEqual(bytearray([0xC4, 0xC2, 0xF9, 0xF7, 0xCF]), SHLX(rcx, r15, rax).encode())
705        self.assertEqual(bytearray([0xC4, 0xC2, 0xF9, 0xF7, 0x4C, 0xD3, 0xA8]), SHLX(rcx, qword[r11 + rdx*8 - 88], rax).encode())
706
707
708class TestSHRD(unittest.TestCase):
709    def runTest(self):
710        self.assertEqual(bytearray([0x66, 0x44, 0x0F, 0xAC, 0xE6, 0x02]), SHRD(si, r12w, 2).encode())
711        self.assertEqual(bytearray([0x66, 0x44, 0x0F, 0xAD, 0xE6]), SHRD(si, r12w, cl).encode())
712        self.assertEqual(bytearray([0x44, 0x0F, 0xAC, 0xC5, 0x02]), SHRD(ebp, r8d, 2).encode())
713        self.assertEqual(bytearray([0x44, 0x0F, 0xAD, 0xC5]), SHRD(ebp, r8d, cl).encode())
714        self.assertEqual(bytearray([0x4C, 0x0F, 0xAC, 0xF9, 0x02]), SHRD(rcx, r15, 2).encode())
715        self.assertEqual(bytearray([0x4C, 0x0F, 0xAD, 0xF9]), SHRD(rcx, r15, cl).encode())
716        self.assertEqual(bytearray([0x66, 0x45, 0x0F, 0xAC, 0x64, 0xED, 0x95, 0x02]), SHRD(word[r13 + rbp*8 - 107], r12w, 2).encode())
717        self.assertEqual(bytearray([0x66, 0x45, 0x0F, 0xAD, 0x64, 0xED, 0x95]), SHRD(word[r13 + rbp*8 - 107], r12w, cl).encode())
718        self.assertEqual(bytearray([0x45, 0x0F, 0xAC, 0x44, 0xCC, 0x9D, 0x02]), SHRD(dword[r12 + rcx*8 - 99], r8d, 2).encode())
719        self.assertEqual(bytearray([0x45, 0x0F, 0xAD, 0x44, 0xCC, 0x9D]), SHRD(dword[r12 + rcx*8 - 99], r8d, cl).encode())
720        self.assertEqual(bytearray([0x4D, 0x0F, 0xAC, 0x7C, 0xD3, 0xA8, 0x02]), SHRD(qword[r11 + rdx*8 - 88], r15, 2).encode())
721        self.assertEqual(bytearray([0x4D, 0x0F, 0xAD, 0x7C, 0xD3, 0xA8]), SHRD(qword[r11 + rdx*8 - 88], r15, cl).encode())
722
723
724class TestSHLD(unittest.TestCase):
725    def runTest(self):
726        self.assertEqual(bytearray([0x66, 0x44, 0x0F, 0xA4, 0xE6, 0x02]), SHLD(si, r12w, 2).encode())
727        self.assertEqual(bytearray([0x66, 0x44, 0x0F, 0xA5, 0xE6]), SHLD(si, r12w, cl).encode())
728        self.assertEqual(bytearray([0x44, 0x0F, 0xA4, 0xC5, 0x02]), SHLD(ebp, r8d, 2).encode())
729        self.assertEqual(bytearray([0x44, 0x0F, 0xA5, 0xC5]), SHLD(ebp, r8d, cl).encode())
730        self.assertEqual(bytearray([0x4C, 0x0F, 0xA4, 0xF9, 0x02]), SHLD(rcx, r15, 2).encode())
731        self.assertEqual(bytearray([0x4C, 0x0F, 0xA5, 0xF9]), SHLD(rcx, r15, cl).encode())
732        self.assertEqual(bytearray([0x66, 0x45, 0x0F, 0xA4, 0x64, 0xED, 0x95, 0x02]), SHLD(word[r13 + rbp*8 - 107], r12w, 2).encode())
733        self.assertEqual(bytearray([0x66, 0x45, 0x0F, 0xA5, 0x64, 0xED, 0x95]), SHLD(word[r13 + rbp*8 - 107], r12w, cl).encode())
734        self.assertEqual(bytearray([0x45, 0x0F, 0xA4, 0x44, 0xCC, 0x9D, 0x02]), SHLD(dword[r12 + rcx*8 - 99], r8d, 2).encode())
735        self.assertEqual(bytearray([0x45, 0x0F, 0xA5, 0x44, 0xCC, 0x9D]), SHLD(dword[r12 + rcx*8 - 99], r8d, cl).encode())
736        self.assertEqual(bytearray([0x4D, 0x0F, 0xA4, 0x7C, 0xD3, 0xA8, 0x02]), SHLD(qword[r11 + rdx*8 - 88], r15, 2).encode())
737        self.assertEqual(bytearray([0x4D, 0x0F, 0xA5, 0x7C, 0xD3, 0xA8]), SHLD(qword[r11 + rdx*8 - 88], r15, cl).encode())
738
739
740class TestROR(unittest.TestCase):
741    def runTest(self):
742        self.assertEqual(bytearray([0xD0, 0xCB]), ROR(bl, 1).encode())
743        self.assertEqual(bytearray([0xC0, 0xCB, 0x02]), ROR(bl, 2).encode())
744        self.assertEqual(bytearray([0xD2, 0xCB]), ROR(bl, cl).encode())
745        self.assertEqual(bytearray([0x66, 0xD1, 0xCE]), ROR(si, 1).encode())
746        self.assertEqual(bytearray([0x66, 0xC1, 0xCE, 0x02]), ROR(si, 2).encode())
747        self.assertEqual(bytearray([0x66, 0xD3, 0xCE]), ROR(si, cl).encode())
748        self.assertEqual(bytearray([0xD1, 0xCD]), ROR(ebp, 1).encode())
749        self.assertEqual(bytearray([0xC1, 0xCD, 0x02]), ROR(ebp, 2).encode())
750        self.assertEqual(bytearray([0xD3, 0xCD]), ROR(ebp, cl).encode())
751        self.assertEqual(bytearray([0x48, 0xD1, 0xC9]), ROR(rcx, 1).encode())
752        self.assertEqual(bytearray([0x48, 0xC1, 0xC9, 0x02]), ROR(rcx, 2).encode())
753        self.assertEqual(bytearray([0x48, 0xD3, 0xC9]), ROR(rcx, cl).encode())
754        self.assertEqual(bytearray([0x41, 0xD0, 0x4C, 0xBE, 0x85]), ROR(byte[r14 + rdi*4 - 123], 1).encode())
755        self.assertEqual(bytearray([0x41, 0xC0, 0x4C, 0xBE, 0x85, 0x02]), ROR(byte[r14 + rdi*4 - 123], 2).encode())
756        self.assertEqual(bytearray([0x41, 0xD2, 0x4C, 0xBE, 0x85]), ROR(byte[r14 + rdi*4 - 123], cl).encode())
757        self.assertEqual(bytearray([0x66, 0x41, 0xD1, 0x4C, 0xED, 0x95]), ROR(word[r13 + rbp*8 - 107], 1).encode())
758        self.assertEqual(bytearray([0x66, 0x41, 0xC1, 0x4C, 0xED, 0x95, 0x02]), ROR(word[r13 + rbp*8 - 107], 2).encode())
759        self.assertEqual(bytearray([0x66, 0x41, 0xD3, 0x4C, 0xED, 0x95]), ROR(word[r13 + rbp*8 - 107], cl).encode())
760        self.assertEqual(bytearray([0x41, 0xD1, 0x4C, 0xCC, 0x9D]), ROR(dword[r12 + rcx*8 - 99], 1).encode())
761        self.assertEqual(bytearray([0x41, 0xC1, 0x4C, 0xCC, 0x9D, 0x02]), ROR(dword[r12 + rcx*8 - 99], 2).encode())
762        self.assertEqual(bytearray([0x41, 0xD3, 0x4C, 0xCC, 0x9D]), ROR(dword[r12 + rcx*8 - 99], cl).encode())
763        self.assertEqual(bytearray([0x49, 0xD1, 0x4C, 0xD3, 0xA8]), ROR(qword[r11 + rdx*8 - 88], 1).encode())
764        self.assertEqual(bytearray([0x49, 0xC1, 0x4C, 0xD3, 0xA8, 0x02]), ROR(qword[r11 + rdx*8 - 88], 2).encode())
765        self.assertEqual(bytearray([0x49, 0xD3, 0x4C, 0xD3, 0xA8]), ROR(qword[r11 + rdx*8 - 88], cl).encode())
766
767
768class TestROL(unittest.TestCase):
769    def runTest(self):
770        self.assertEqual(bytearray([0xD0, 0xC3]), ROL(bl, 1).encode())
771        self.assertEqual(bytearray([0xC0, 0xC3, 0x02]), ROL(bl, 2).encode())
772        self.assertEqual(bytearray([0xD2, 0xC3]), ROL(bl, cl).encode())
773        self.assertEqual(bytearray([0x66, 0xD1, 0xC6]), ROL(si, 1).encode())
774        self.assertEqual(bytearray([0x66, 0xC1, 0xC6, 0x02]), ROL(si, 2).encode())
775        self.assertEqual(bytearray([0x66, 0xD3, 0xC6]), ROL(si, cl).encode())
776        self.assertEqual(bytearray([0xD1, 0xC5]), ROL(ebp, 1).encode())
777        self.assertEqual(bytearray([0xC1, 0xC5, 0x02]), ROL(ebp, 2).encode())
778        self.assertEqual(bytearray([0xD3, 0xC5]), ROL(ebp, cl).encode())
779        self.assertEqual(bytearray([0x48, 0xD1, 0xC1]), ROL(rcx, 1).encode())
780        self.assertEqual(bytearray([0x48, 0xC1, 0xC1, 0x02]), ROL(rcx, 2).encode())
781        self.assertEqual(bytearray([0x48, 0xD3, 0xC1]), ROL(rcx, cl).encode())
782        self.assertEqual(bytearray([0x41, 0xD0, 0x44, 0xBE, 0x85]), ROL(byte[r14 + rdi*4 - 123], 1).encode())
783        self.assertEqual(bytearray([0x41, 0xC0, 0x44, 0xBE, 0x85, 0x02]), ROL(byte[r14 + rdi*4 - 123], 2).encode())
784        self.assertEqual(bytearray([0x41, 0xD2, 0x44, 0xBE, 0x85]), ROL(byte[r14 + rdi*4 - 123], cl).encode())
785        self.assertEqual(bytearray([0x66, 0x41, 0xD1, 0x44, 0xED, 0x95]), ROL(word[r13 + rbp*8 - 107], 1).encode())
786        self.assertEqual(bytearray([0x66, 0x41, 0xC1, 0x44, 0xED, 0x95, 0x02]), ROL(word[r13 + rbp*8 - 107], 2).encode())
787        self.assertEqual(bytearray([0x66, 0x41, 0xD3, 0x44, 0xED, 0x95]), ROL(word[r13 + rbp*8 - 107], cl).encode())
788        self.assertEqual(bytearray([0x41, 0xD1, 0x44, 0xCC, 0x9D]), ROL(dword[r12 + rcx*8 - 99], 1).encode())
789        self.assertEqual(bytearray([0x41, 0xC1, 0x44, 0xCC, 0x9D, 0x02]), ROL(dword[r12 + rcx*8 - 99], 2).encode())
790        self.assertEqual(bytearray([0x41, 0xD3, 0x44, 0xCC, 0x9D]), ROL(dword[r12 + rcx*8 - 99], cl).encode())
791        self.assertEqual(bytearray([0x49, 0xD1, 0x44, 0xD3, 0xA8]), ROL(qword[r11 + rdx*8 - 88], 1).encode())
792        self.assertEqual(bytearray([0x49, 0xC1, 0x44, 0xD3, 0xA8, 0x02]), ROL(qword[r11 + rdx*8 - 88], 2).encode())
793        self.assertEqual(bytearray([0x49, 0xD3, 0x44, 0xD3, 0xA8]), ROL(qword[r11 + rdx*8 - 88], cl).encode())
794
795
796class TestRORX(unittest.TestCase):
797    def runTest(self):
798        self.assertEqual(bytearray([0xC4, 0xC3, 0x7B, 0xF0, 0xE8, 0x02]), RORX(ebp, r8d, 2).encode())
799        self.assertEqual(bytearray([0xC4, 0xC3, 0x7B, 0xF0, 0x6C, 0xCC, 0x9D, 0x02]), RORX(ebp, dword[r12 + rcx*8 - 99], 2).encode())
800        self.assertEqual(bytearray([0xC4, 0xC3, 0xFB, 0xF0, 0xCF, 0x02]), RORX(rcx, r15, 2).encode())
801        self.assertEqual(bytearray([0xC4, 0xC3, 0xFB, 0xF0, 0x4C, 0xD3, 0xA8, 0x02]), RORX(rcx, qword[r11 + rdx*8 - 88], 2).encode())
802
803
804class TestRCR(unittest.TestCase):
805    def runTest(self):
806        self.assertEqual(bytearray([0xD0, 0xDB]), RCR(bl, 1).encode())
807        self.assertEqual(bytearray([0xC0, 0xDB, 0x02]), RCR(bl, 2).encode())
808        self.assertEqual(bytearray([0xD2, 0xDB]), RCR(bl, cl).encode())
809        self.assertEqual(bytearray([0x66, 0xD1, 0xDE]), RCR(si, 1).encode())
810        self.assertEqual(bytearray([0x66, 0xC1, 0xDE, 0x02]), RCR(si, 2).encode())
811        self.assertEqual(bytearray([0x66, 0xD3, 0xDE]), RCR(si, cl).encode())
812        self.assertEqual(bytearray([0xD1, 0xDD]), RCR(ebp, 1).encode())
813        self.assertEqual(bytearray([0xC1, 0xDD, 0x02]), RCR(ebp, 2).encode())
814        self.assertEqual(bytearray([0xD3, 0xDD]), RCR(ebp, cl).encode())
815        self.assertEqual(bytearray([0x48, 0xD1, 0xD9]), RCR(rcx, 1).encode())
816        self.assertEqual(bytearray([0x48, 0xC1, 0xD9, 0x02]), RCR(rcx, 2).encode())
817        self.assertEqual(bytearray([0x48, 0xD3, 0xD9]), RCR(rcx, cl).encode())
818        self.assertEqual(bytearray([0x41, 0xD0, 0x5C, 0xBE, 0x85]), RCR(byte[r14 + rdi*4 - 123], 1).encode())
819        self.assertEqual(bytearray([0x41, 0xC0, 0x5C, 0xBE, 0x85, 0x02]), RCR(byte[r14 + rdi*4 - 123], 2).encode())
820        self.assertEqual(bytearray([0x41, 0xD2, 0x5C, 0xBE, 0x85]), RCR(byte[r14 + rdi*4 - 123], cl).encode())
821        self.assertEqual(bytearray([0x66, 0x41, 0xD1, 0x5C, 0xED, 0x95]), RCR(word[r13 + rbp*8 - 107], 1).encode())
822        self.assertEqual(bytearray([0x66, 0x41, 0xC1, 0x5C, 0xED, 0x95, 0x02]), RCR(word[r13 + rbp*8 - 107], 2).encode())
823        self.assertEqual(bytearray([0x66, 0x41, 0xD3, 0x5C, 0xED, 0x95]), RCR(word[r13 + rbp*8 - 107], cl).encode())
824        self.assertEqual(bytearray([0x41, 0xD1, 0x5C, 0xCC, 0x9D]), RCR(dword[r12 + rcx*8 - 99], 1).encode())
825        self.assertEqual(bytearray([0x41, 0xC1, 0x5C, 0xCC, 0x9D, 0x02]), RCR(dword[r12 + rcx*8 - 99], 2).encode())
826        self.assertEqual(bytearray([0x41, 0xD3, 0x5C, 0xCC, 0x9D]), RCR(dword[r12 + rcx*8 - 99], cl).encode())
827        self.assertEqual(bytearray([0x49, 0xD1, 0x5C, 0xD3, 0xA8]), RCR(qword[r11 + rdx*8 - 88], 1).encode())
828        self.assertEqual(bytearray([0x49, 0xC1, 0x5C, 0xD3, 0xA8, 0x02]), RCR(qword[r11 + rdx*8 - 88], 2).encode())
829        self.assertEqual(bytearray([0x49, 0xD3, 0x5C, 0xD3, 0xA8]), RCR(qword[r11 + rdx*8 - 88], cl).encode())
830
831
832class TestRCL(unittest.TestCase):
833    def runTest(self):
834        self.assertEqual(bytearray([0xD0, 0xD3]), RCL(bl, 1).encode())
835        self.assertEqual(bytearray([0xC0, 0xD3, 0x02]), RCL(bl, 2).encode())
836        self.assertEqual(bytearray([0xD2, 0xD3]), RCL(bl, cl).encode())
837        self.assertEqual(bytearray([0x66, 0xD1, 0xD6]), RCL(si, 1).encode())
838        self.assertEqual(bytearray([0x66, 0xC1, 0xD6, 0x02]), RCL(si, 2).encode())
839        self.assertEqual(bytearray([0x66, 0xD3, 0xD6]), RCL(si, cl).encode())
840        self.assertEqual(bytearray([0xD1, 0xD5]), RCL(ebp, 1).encode())
841        self.assertEqual(bytearray([0xC1, 0xD5, 0x02]), RCL(ebp, 2).encode())
842        self.assertEqual(bytearray([0xD3, 0xD5]), RCL(ebp, cl).encode())
843        self.assertEqual(bytearray([0x48, 0xD1, 0xD1]), RCL(rcx, 1).encode())
844        self.assertEqual(bytearray([0x48, 0xC1, 0xD1, 0x02]), RCL(rcx, 2).encode())
845        self.assertEqual(bytearray([0x48, 0xD3, 0xD1]), RCL(rcx, cl).encode())
846        self.assertEqual(bytearray([0x41, 0xD0, 0x54, 0xBE, 0x85]), RCL(byte[r14 + rdi*4 - 123], 1).encode())
847        self.assertEqual(bytearray([0x41, 0xC0, 0x54, 0xBE, 0x85, 0x02]), RCL(byte[r14 + rdi*4 - 123], 2).encode())
848        self.assertEqual(bytearray([0x41, 0xD2, 0x54, 0xBE, 0x85]), RCL(byte[r14 + rdi*4 - 123], cl).encode())
849        self.assertEqual(bytearray([0x66, 0x41, 0xD1, 0x54, 0xED, 0x95]), RCL(word[r13 + rbp*8 - 107], 1).encode())
850        self.assertEqual(bytearray([0x66, 0x41, 0xC1, 0x54, 0xED, 0x95, 0x02]), RCL(word[r13 + rbp*8 - 107], 2).encode())
851        self.assertEqual(bytearray([0x66, 0x41, 0xD3, 0x54, 0xED, 0x95]), RCL(word[r13 + rbp*8 - 107], cl).encode())
852        self.assertEqual(bytearray([0x41, 0xD1, 0x54, 0xCC, 0x9D]), RCL(dword[r12 + rcx*8 - 99], 1).encode())
853        self.assertEqual(bytearray([0x41, 0xC1, 0x54, 0xCC, 0x9D, 0x02]), RCL(dword[r12 + rcx*8 - 99], 2).encode())
854        self.assertEqual(bytearray([0x41, 0xD3, 0x54, 0xCC, 0x9D]), RCL(dword[r12 + rcx*8 - 99], cl).encode())
855        self.assertEqual(bytearray([0x49, 0xD1, 0x54, 0xD3, 0xA8]), RCL(qword[r11 + rdx*8 - 88], 1).encode())
856        self.assertEqual(bytearray([0x49, 0xC1, 0x54, 0xD3, 0xA8, 0x02]), RCL(qword[r11 + rdx*8 - 88], 2).encode())
857        self.assertEqual(bytearray([0x49, 0xD3, 0x54, 0xD3, 0xA8]), RCL(qword[r11 + rdx*8 - 88], cl).encode())
858
859
860class TestIMUL(unittest.TestCase):
861    def runTest(self):
862        self.assertEqual(bytearray([0xF6, 0xEB]), IMUL(bl).encode())
863        self.assertEqual(bytearray([0x66, 0xF7, 0xEE]), IMUL(si).encode())
864        self.assertEqual(bytearray([0xF7, 0xED]), IMUL(ebp).encode())
865        self.assertEqual(bytearray([0x48, 0xF7, 0xE9]), IMUL(rcx).encode())
866        self.assertEqual(bytearray([0x41, 0xF6, 0x6C, 0xBE, 0x85]), IMUL(byte[r14 + rdi*4 - 123]).encode())
867        self.assertEqual(bytearray([0x66, 0x41, 0xF7, 0x6C, 0xED, 0x95]), IMUL(word[r13 + rbp*8 - 107]).encode())
868        self.assertEqual(bytearray([0x41, 0xF7, 0x6C, 0xCC, 0x9D]), IMUL(dword[r12 + rcx*8 - 99]).encode())
869        self.assertEqual(bytearray([0x49, 0xF7, 0x6C, 0xD3, 0xA8]), IMUL(qword[r11 + rdx*8 - 88]).encode())
870        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0xAF, 0xF4]), IMUL(si, r12w).encode())
871        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0xAF, 0x74, 0xED, 0x95]), IMUL(si, word[r13 + rbp*8 - 107]).encode())
872        self.assertEqual(bytearray([0x41, 0x0F, 0xAF, 0xE8]), IMUL(ebp, r8d).encode())
873        self.assertEqual(bytearray([0x41, 0x0F, 0xAF, 0x6C, 0xCC, 0x9D]), IMUL(ebp, dword[r12 + rcx*8 - 99]).encode())
874        self.assertEqual(bytearray([0x49, 0x0F, 0xAF, 0xCF]), IMUL(rcx, r15).encode())
875        self.assertEqual(bytearray([0x49, 0x0F, 0xAF, 0x4C, 0xD3, 0xA8]), IMUL(rcx, qword[r11 + rdx*8 - 88]).encode())
876        self.assertEqual(bytearray([0x66, 0x41, 0x6B, 0xF4, 0x02]), IMUL(si, r12w, 2).encode())
877        self.assertEqual(bytearray([0x66, 0x41, 0x69, 0xF4, 0x00, 0x7D]), IMUL(si, r12w, 32000).encode())
878        self.assertEqual(bytearray([0x66, 0x41, 0x6B, 0x74, 0xED, 0x95, 0x02]), IMUL(si, word[r13 + rbp*8 - 107], 2).encode())
879        self.assertEqual(bytearray([0x66, 0x41, 0x69, 0x74, 0xED, 0x95, 0x00, 0x7D]), IMUL(si, word[r13 + rbp*8 - 107], 32000).encode())
880        self.assertEqual(bytearray([0x41, 0x6B, 0xE8, 0x02]), IMUL(ebp, r8d, 2).encode())
881        self.assertEqual(bytearray([0x41, 0x69, 0xE8, 0x00, 0x00, 0x00, 0x10]), IMUL(ebp, r8d, 0x10000000).encode())
882        self.assertEqual(bytearray([0x41, 0x6B, 0x6C, 0xCC, 0x9D, 0x02]), IMUL(ebp, dword[r12 + rcx*8 - 99], 2).encode())
883        self.assertEqual(bytearray([0x41, 0x69, 0x6C, 0xCC, 0x9D, 0x00, 0x00, 0x00, 0x10]), IMUL(ebp, dword[r12 + rcx*8 - 99], 0x10000000).encode())
884        self.assertEqual(bytearray([0x49, 0x6B, 0xCF, 0x02]), IMUL(rcx, r15, 2).encode())
885        self.assertEqual(bytearray([0x49, 0x69, 0xCF, 0x00, 0x00, 0x00, 0x10]), IMUL(rcx, r15, 0x10000000).encode())
886        self.assertEqual(bytearray([0x49, 0x6B, 0x4C, 0xD3, 0xA8, 0x02]), IMUL(rcx, qword[r11 + rdx*8 - 88], 2).encode())
887        self.assertEqual(bytearray([0x49, 0x69, 0x4C, 0xD3, 0xA8, 0x00, 0x00, 0x00, 0x10]), IMUL(rcx, qword[r11 + rdx*8 - 88], 0x10000000).encode())
888
889
890class TestMUL(unittest.TestCase):
891    def runTest(self):
892        self.assertEqual(bytearray([0xF6, 0xE3]), MUL(bl).encode())
893        self.assertEqual(bytearray([0x66, 0xF7, 0xE6]), MUL(si).encode())
894        self.assertEqual(bytearray([0xF7, 0xE5]), MUL(ebp).encode())
895        self.assertEqual(bytearray([0x48, 0xF7, 0xE1]), MUL(rcx).encode())
896        self.assertEqual(bytearray([0x41, 0xF6, 0x64, 0xBE, 0x85]), MUL(byte[r14 + rdi*4 - 123]).encode())
897        self.assertEqual(bytearray([0x66, 0x41, 0xF7, 0x64, 0xED, 0x95]), MUL(word[r13 + rbp*8 - 107]).encode())
898        self.assertEqual(bytearray([0x41, 0xF7, 0x64, 0xCC, 0x9D]), MUL(dword[r12 + rcx*8 - 99]).encode())
899        self.assertEqual(bytearray([0x49, 0xF7, 0x64, 0xD3, 0xA8]), MUL(qword[r11 + rdx*8 - 88]).encode())
900
901
902class TestMULX(unittest.TestCase):
903    def runTest(self):
904        self.assertEqual(bytearray([0xC4, 0xE2, 0x3B, 0xF6, 0xE8]), MULX(ebp, r8d, eax).encode())
905        self.assertEqual(bytearray([0xC4, 0xC2, 0x3B, 0xF6, 0x6C, 0xCC, 0x9D]), MULX(ebp, r8d, dword[r12 + rcx*8 - 99]).encode())
906        self.assertEqual(bytearray([0xC4, 0xE2, 0x83, 0xF6, 0xC8]), MULX(rcx, r15, rax).encode())
907        self.assertEqual(bytearray([0xC4, 0xC2, 0x83, 0xF6, 0x4C, 0xD3, 0xA8]), MULX(rcx, r15, qword[r11 + rdx*8 - 88]).encode())
908
909
910class TestIDIV(unittest.TestCase):
911    def runTest(self):
912        self.assertEqual(bytearray([0xF6, 0xFB]), IDIV(bl).encode())
913        self.assertEqual(bytearray([0x66, 0xF7, 0xFE]), IDIV(si).encode())
914        self.assertEqual(bytearray([0xF7, 0xFD]), IDIV(ebp).encode())
915        self.assertEqual(bytearray([0x48, 0xF7, 0xF9]), IDIV(rcx).encode())
916        self.assertEqual(bytearray([0x41, 0xF6, 0x7C, 0xBE, 0x85]), IDIV(byte[r14 + rdi*4 - 123]).encode())
917        self.assertEqual(bytearray([0x66, 0x41, 0xF7, 0x7C, 0xED, 0x95]), IDIV(word[r13 + rbp*8 - 107]).encode())
918        self.assertEqual(bytearray([0x41, 0xF7, 0x7C, 0xCC, 0x9D]), IDIV(dword[r12 + rcx*8 - 99]).encode())
919        self.assertEqual(bytearray([0x49, 0xF7, 0x7C, 0xD3, 0xA8]), IDIV(qword[r11 + rdx*8 - 88]).encode())
920
921
922class TestDIV(unittest.TestCase):
923    def runTest(self):
924        self.assertEqual(bytearray([0xF6, 0xF3]), DIV(bl).encode())
925        self.assertEqual(bytearray([0x66, 0xF7, 0xF6]), DIV(si).encode())
926        self.assertEqual(bytearray([0xF7, 0xF5]), DIV(ebp).encode())
927        self.assertEqual(bytearray([0x48, 0xF7, 0xF1]), DIV(rcx).encode())
928        self.assertEqual(bytearray([0x41, 0xF6, 0x74, 0xBE, 0x85]), DIV(byte[r14 + rdi*4 - 123]).encode())
929        self.assertEqual(bytearray([0x66, 0x41, 0xF7, 0x74, 0xED, 0x95]), DIV(word[r13 + rbp*8 - 107]).encode())
930        self.assertEqual(bytearray([0x41, 0xF7, 0x74, 0xCC, 0x9D]), DIV(dword[r12 + rcx*8 - 99]).encode())
931        self.assertEqual(bytearray([0x49, 0xF7, 0x74, 0xD3, 0xA8]), DIV(qword[r11 + rdx*8 - 88]).encode())
932
933
934class TestLEA(unittest.TestCase):
935    def runTest(self):
936        self.assertEqual(bytearray([0x66, 0x41, 0x8D, 0x74, 0xF7, 0x80]), LEA(si, [r15 + rsi*8 - 128]).encode())
937        self.assertEqual(bytearray([0x41, 0x8D, 0x6C, 0xF7, 0x80]), LEA(ebp, [r15 + rsi*8 - 128]).encode())
938        self.assertEqual(bytearray([0x49, 0x8D, 0x4C, 0xF7, 0x80]), LEA(rcx, [r15 + rsi*8 - 128]).encode())
939
940
941class TestPUSH(unittest.TestCase):
942    def runTest(self):
943        self.assertEqual(bytearray([0x6A, 0x02]), PUSH(2).encode())
944        self.assertEqual(bytearray([0x68, 0x00, 0x00, 0x00, 0x10]), PUSH(0x10000000).encode())
945        self.assertEqual(bytearray([0x66, 0x56]), PUSH(si).encode())
946        self.assertEqual(bytearray([0x51]), PUSH(rcx).encode())
947        self.assertEqual(bytearray([0x66, 0x41, 0xFF, 0x74, 0xED, 0x95]), PUSH(word[r13 + rbp*8 - 107]).encode())
948        self.assertEqual(bytearray([0x41, 0xFF, 0x74, 0xD3, 0xA8]), PUSH(qword[r11 + rdx*8 - 88]).encode())
949
950
951class TestPOP(unittest.TestCase):
952    def runTest(self):
953        self.assertEqual(bytearray([0x66, 0x5E]), POP(si).encode())
954        self.assertEqual(bytearray([0x59]), POP(rcx).encode())
955        self.assertEqual(bytearray([0x66, 0x41, 0x8F, 0x44, 0xED, 0x95]), POP(word[r13 + rbp*8 - 107]).encode())
956        self.assertEqual(bytearray([0x41, 0x8F, 0x44, 0xD3, 0xA8]), POP(qword[r11 + rdx*8 - 88]).encode())
957
958
959class TestPOPCNT(unittest.TestCase):
960    def runTest(self):
961        self.assertEqual(bytearray([0x66, 0xF3, 0x41, 0x0F, 0xB8, 0xF4]), POPCNT(si, r12w).encode())
962        self.assertEqual(bytearray([0x66, 0xF3, 0x41, 0x0F, 0xB8, 0x74, 0xED, 0x95]), POPCNT(si, word[r13 + rbp*8 - 107]).encode())
963        self.assertEqual(bytearray([0xF3, 0x41, 0x0F, 0xB8, 0xE8]), POPCNT(ebp, r8d).encode())
964        self.assertEqual(bytearray([0xF3, 0x41, 0x0F, 0xB8, 0x6C, 0xCC, 0x9D]), POPCNT(ebp, dword[r12 + rcx*8 - 99]).encode())
965        self.assertEqual(bytearray([0xF3, 0x49, 0x0F, 0xB8, 0xCF]), POPCNT(rcx, r15).encode())
966        self.assertEqual(bytearray([0xF3, 0x49, 0x0F, 0xB8, 0x4C, 0xD3, 0xA8]), POPCNT(rcx, qword[r11 + rdx*8 - 88]).encode())
967
968
969class TestLZCNT(unittest.TestCase):
970    def runTest(self):
971        self.assertEqual(bytearray([0x66, 0xF3, 0x41, 0x0F, 0xBD, 0xF4]), LZCNT(si, r12w).encode())
972        self.assertEqual(bytearray([0x66, 0xF3, 0x41, 0x0F, 0xBD, 0x74, 0xED, 0x95]), LZCNT(si, word[r13 + rbp*8 - 107]).encode())
973        self.assertEqual(bytearray([0xF3, 0x41, 0x0F, 0xBD, 0xE8]), LZCNT(ebp, r8d).encode())
974        self.assertEqual(bytearray([0xF3, 0x41, 0x0F, 0xBD, 0x6C, 0xCC, 0x9D]), LZCNT(ebp, dword[r12 + rcx*8 - 99]).encode())
975        self.assertEqual(bytearray([0xF3, 0x49, 0x0F, 0xBD, 0xCF]), LZCNT(rcx, r15).encode())
976        self.assertEqual(bytearray([0xF3, 0x49, 0x0F, 0xBD, 0x4C, 0xD3, 0xA8]), LZCNT(rcx, qword[r11 + rdx*8 - 88]).encode())
977
978
979class TestTZCNT(unittest.TestCase):
980    def runTest(self):
981        self.assertEqual(bytearray([0x66, 0xF3, 0x41, 0x0F, 0xBC, 0xF4]), TZCNT(si, r12w).encode())
982        self.assertEqual(bytearray([0x66, 0xF3, 0x41, 0x0F, 0xBC, 0x74, 0xED, 0x95]), TZCNT(si, word[r13 + rbp*8 - 107]).encode())
983        self.assertEqual(bytearray([0xF3, 0x41, 0x0F, 0xBC, 0xE8]), TZCNT(ebp, r8d).encode())
984        self.assertEqual(bytearray([0xF3, 0x41, 0x0F, 0xBC, 0x6C, 0xCC, 0x9D]), TZCNT(ebp, dword[r12 + rcx*8 - 99]).encode())
985        self.assertEqual(bytearray([0xF3, 0x49, 0x0F, 0xBC, 0xCF]), TZCNT(rcx, r15).encode())
986        self.assertEqual(bytearray([0xF3, 0x49, 0x0F, 0xBC, 0x4C, 0xD3, 0xA8]), TZCNT(rcx, qword[r11 + rdx*8 - 88]).encode())
987
988
989class TestBEXTR(unittest.TestCase):
990    def runTest(self):
991        self.assertEqual(bytearray([0x8F, 0xCA, 0x78, 0x10, 0xE8, 0x00, 0x00, 0x00, 0x10]), BEXTR(ebp, r8d, 0x10000000).encode())
992        self.assertEqual(bytearray([0xC4, 0xC2, 0x78, 0xF7, 0xE8]), BEXTR(ebp, r8d, eax).encode())
993        self.assertEqual(bytearray([0x8F, 0xCA, 0x78, 0x10, 0x6C, 0xCC, 0x9D, 0x00, 0x00, 0x00, 0x10]), BEXTR(ebp, dword[r12 + rcx*8 - 99], 0x10000000).encode())
994        self.assertEqual(bytearray([0xC4, 0xC2, 0x78, 0xF7, 0x6C, 0xCC, 0x9D]), BEXTR(ebp, dword[r12 + rcx*8 - 99], eax).encode())
995        self.assertEqual(bytearray([0x8F, 0xCA, 0xF8, 0x10, 0xCF, 0x00, 0x00, 0x00, 0x10]), BEXTR(rcx, r15, 0x10000000).encode())
996        self.assertEqual(bytearray([0xC4, 0xC2, 0xF8, 0xF7, 0xCF]), BEXTR(rcx, r15, rax).encode())
997        self.assertEqual(bytearray([0x8F, 0xCA, 0xF8, 0x10, 0x4C, 0xD3, 0xA8, 0x00, 0x00, 0x00, 0x10]), BEXTR(rcx, qword[r11 + rdx*8 - 88], 0x10000000).encode())
998        self.assertEqual(bytearray([0xC4, 0xC2, 0xF8, 0xF7, 0x4C, 0xD3, 0xA8]), BEXTR(rcx, qword[r11 + rdx*8 - 88], rax).encode())
999
1000
1001class TestPDEP(unittest.TestCase):
1002    def runTest(self):
1003        self.assertEqual(bytearray([0xC4, 0xE2, 0x3B, 0xF5, 0xE8]), PDEP(ebp, r8d, eax).encode())
1004        self.assertEqual(bytearray([0xC4, 0xC2, 0x3B, 0xF5, 0x6C, 0xCC, 0x9D]), PDEP(ebp, r8d, dword[r12 + rcx*8 - 99]).encode())
1005        self.assertEqual(bytearray([0xC4, 0xE2, 0x83, 0xF5, 0xC8]), PDEP(rcx, r15, rax).encode())
1006        self.assertEqual(bytearray([0xC4, 0xC2, 0x83, 0xF5, 0x4C, 0xD3, 0xA8]), PDEP(rcx, r15, qword[r11 + rdx*8 - 88]).encode())
1007
1008
1009class TestPEXT(unittest.TestCase):
1010    def runTest(self):
1011        self.assertEqual(bytearray([0xC4, 0xE2, 0x3A, 0xF5, 0xE8]), PEXT(ebp, r8d, eax).encode())
1012        self.assertEqual(bytearray([0xC4, 0xC2, 0x3A, 0xF5, 0x6C, 0xCC, 0x9D]), PEXT(ebp, r8d, dword[r12 + rcx*8 - 99]).encode())
1013        self.assertEqual(bytearray([0xC4, 0xE2, 0x82, 0xF5, 0xC8]), PEXT(rcx, r15, rax).encode())
1014        self.assertEqual(bytearray([0xC4, 0xC2, 0x82, 0xF5, 0x4C, 0xD3, 0xA8]), PEXT(rcx, r15, qword[r11 + rdx*8 - 88]).encode())
1015
1016
1017class TestBZHI(unittest.TestCase):
1018    def runTest(self):
1019        self.assertEqual(bytearray([0xC4, 0xC2, 0x78, 0xF5, 0xE8]), BZHI(ebp, r8d, eax).encode())
1020        self.assertEqual(bytearray([0xC4, 0xC2, 0x78, 0xF5, 0x6C, 0xCC, 0x9D]), BZHI(ebp, dword[r12 + rcx*8 - 99], eax).encode())
1021        self.assertEqual(bytearray([0xC4, 0xC2, 0xF8, 0xF5, 0xCF]), BZHI(rcx, r15, rax).encode())
1022        self.assertEqual(bytearray([0xC4, 0xC2, 0xF8, 0xF5, 0x4C, 0xD3, 0xA8]), BZHI(rcx, qword[r11 + rdx*8 - 88], rax).encode())
1023
1024
1025class TestBLCFILL(unittest.TestCase):
1026    def runTest(self):
1027        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x01, 0xC8]), BLCFILL(ebp, r8d).encode())
1028        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x01, 0x4C, 0xCC, 0x9D]), BLCFILL(ebp, dword[r12 + rcx*8 - 99]).encode())
1029        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x01, 0xCF]), BLCFILL(rcx, r15).encode())
1030        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x01, 0x4C, 0xD3, 0xA8]), BLCFILL(rcx, qword[r11 + rdx*8 - 88]).encode())
1031
1032
1033class TestBLCI(unittest.TestCase):
1034    def runTest(self):
1035        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x02, 0xF0]), BLCI(ebp, r8d).encode())
1036        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x02, 0x74, 0xCC, 0x9D]), BLCI(ebp, dword[r12 + rcx*8 - 99]).encode())
1037        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x02, 0xF7]), BLCI(rcx, r15).encode())
1038        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x02, 0x74, 0xD3, 0xA8]), BLCI(rcx, qword[r11 + rdx*8 - 88]).encode())
1039
1040
1041class TestBLCIC(unittest.TestCase):
1042    def runTest(self):
1043        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x01, 0xE8]), BLCIC(ebp, r8d).encode())
1044        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x01, 0x6C, 0xCC, 0x9D]), BLCIC(ebp, dword[r12 + rcx*8 - 99]).encode())
1045        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x01, 0xEF]), BLCIC(rcx, r15).encode())
1046        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x01, 0x6C, 0xD3, 0xA8]), BLCIC(rcx, qword[r11 + rdx*8 - 88]).encode())
1047
1048
1049class TestBLCMSK(unittest.TestCase):
1050    def runTest(self):
1051        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x02, 0xC8]), BLCMSK(ebp, r8d).encode())
1052        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x02, 0x4C, 0xCC, 0x9D]), BLCMSK(ebp, dword[r12 + rcx*8 - 99]).encode())
1053        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x02, 0xCF]), BLCMSK(rcx, r15).encode())
1054        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x02, 0x4C, 0xD3, 0xA8]), BLCMSK(rcx, qword[r11 + rdx*8 - 88]).encode())
1055
1056
1057class TestBLCS(unittest.TestCase):
1058    def runTest(self):
1059        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x01, 0xD8]), BLCS(ebp, r8d).encode())
1060        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x01, 0x5C, 0xCC, 0x9D]), BLCS(ebp, dword[r12 + rcx*8 - 99]).encode())
1061        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x01, 0xDF]), BLCS(rcx, r15).encode())
1062        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x01, 0x5C, 0xD3, 0xA8]), BLCS(rcx, qword[r11 + rdx*8 - 88]).encode())
1063
1064
1065class TestBLSFILL(unittest.TestCase):
1066    def runTest(self):
1067        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x01, 0xD0]), BLSFILL(ebp, r8d).encode())
1068        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x01, 0x54, 0xCC, 0x9D]), BLSFILL(ebp, dword[r12 + rcx*8 - 99]).encode())
1069        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x01, 0xD7]), BLSFILL(rcx, r15).encode())
1070        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x01, 0x54, 0xD3, 0xA8]), BLSFILL(rcx, qword[r11 + rdx*8 - 88]).encode())
1071
1072
1073class TestBLSI(unittest.TestCase):
1074    def runTest(self):
1075        self.assertEqual(bytearray([0xC4, 0xC2, 0x50, 0xF3, 0xD8]), BLSI(ebp, r8d).encode())
1076        self.assertEqual(bytearray([0xC4, 0xC2, 0x50, 0xF3, 0x5C, 0xCC, 0x9D]), BLSI(ebp, dword[r12 + rcx*8 - 99]).encode())
1077        self.assertEqual(bytearray([0xC4, 0xC2, 0xF0, 0xF3, 0xDF]), BLSI(rcx, r15).encode())
1078        self.assertEqual(bytearray([0xC4, 0xC2, 0xF0, 0xF3, 0x5C, 0xD3, 0xA8]), BLSI(rcx, qword[r11 + rdx*8 - 88]).encode())
1079
1080
1081class TestBLSIC(unittest.TestCase):
1082    def runTest(self):
1083        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x01, 0xF0]), BLSIC(ebp, r8d).encode())
1084        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x01, 0x74, 0xCC, 0x9D]), BLSIC(ebp, dword[r12 + rcx*8 - 99]).encode())
1085        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x01, 0xF7]), BLSIC(rcx, r15).encode())
1086        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x01, 0x74, 0xD3, 0xA8]), BLSIC(rcx, qword[r11 + rdx*8 - 88]).encode())
1087
1088
1089class TestBLSMSK(unittest.TestCase):
1090    def runTest(self):
1091        self.assertEqual(bytearray([0xC4, 0xC2, 0x50, 0xF3, 0xD0]), BLSMSK(ebp, r8d).encode())
1092        self.assertEqual(bytearray([0xC4, 0xC2, 0x50, 0xF3, 0x54, 0xCC, 0x9D]), BLSMSK(ebp, dword[r12 + rcx*8 - 99]).encode())
1093        self.assertEqual(bytearray([0xC4, 0xC2, 0xF0, 0xF3, 0xD7]), BLSMSK(rcx, r15).encode())
1094        self.assertEqual(bytearray([0xC4, 0xC2, 0xF0, 0xF3, 0x54, 0xD3, 0xA8]), BLSMSK(rcx, qword[r11 + rdx*8 - 88]).encode())
1095
1096
1097class TestBLSR(unittest.TestCase):
1098    def runTest(self):
1099        self.assertEqual(bytearray([0xC4, 0xC2, 0x50, 0xF3, 0xC8]), BLSR(ebp, r8d).encode())
1100        self.assertEqual(bytearray([0xC4, 0xC2, 0x50, 0xF3, 0x4C, 0xCC, 0x9D]), BLSR(ebp, dword[r12 + rcx*8 - 99]).encode())
1101        self.assertEqual(bytearray([0xC4, 0xC2, 0xF0, 0xF3, 0xCF]), BLSR(rcx, r15).encode())
1102        self.assertEqual(bytearray([0xC4, 0xC2, 0xF0, 0xF3, 0x4C, 0xD3, 0xA8]), BLSR(rcx, qword[r11 + rdx*8 - 88]).encode())
1103
1104
1105class TestT1MSKC(unittest.TestCase):
1106    def runTest(self):
1107        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x01, 0xF8]), T1MSKC(ebp, r8d).encode())
1108        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x01, 0x7C, 0xCC, 0x9D]), T1MSKC(ebp, dword[r12 + rcx*8 - 99]).encode())
1109        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x01, 0xFF]), T1MSKC(rcx, r15).encode())
1110        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x01, 0x7C, 0xD3, 0xA8]), T1MSKC(rcx, qword[r11 + rdx*8 - 88]).encode())
1111
1112
1113class TestTZMSK(unittest.TestCase):
1114    def runTest(self):
1115        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x01, 0xE0]), TZMSK(ebp, r8d).encode())
1116        self.assertEqual(bytearray([0x8F, 0xC9, 0x50, 0x01, 0x64, 0xCC, 0x9D]), TZMSK(ebp, dword[r12 + rcx*8 - 99]).encode())
1117        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x01, 0xE7]), TZMSK(rcx, r15).encode())
1118        self.assertEqual(bytearray([0x8F, 0xC9, 0xF0, 0x01, 0x64, 0xD3, 0xA8]), TZMSK(rcx, qword[r11 + rdx*8 - 88]).encode())
1119
1120
1121class TestCRC32(unittest.TestCase):
1122    def runTest(self):
1123        self.assertEqual(bytearray([0xF2, 0x41, 0x0F, 0x38, 0xF0, 0xE9]), CRC32(ebp, r9b).encode())
1124        self.assertEqual(bytearray([0x66, 0xF2, 0x41, 0x0F, 0x38, 0xF1, 0xEC]), CRC32(ebp, r12w).encode())
1125        self.assertEqual(bytearray([0xF2, 0x41, 0x0F, 0x38, 0xF1, 0xE8]), CRC32(ebp, r8d).encode())
1126        self.assertEqual(bytearray([0xF2, 0x41, 0x0F, 0x38, 0xF0, 0x6C, 0xBE, 0x85]), CRC32(ebp, byte[r14 + rdi*4 - 123]).encode())
1127        self.assertEqual(bytearray([0x66, 0xF2, 0x41, 0x0F, 0x38, 0xF1, 0x6C, 0xED, 0x95]), CRC32(ebp, word[r13 + rbp*8 - 107]).encode())
1128        self.assertEqual(bytearray([0xF2, 0x41, 0x0F, 0x38, 0xF1, 0x6C, 0xCC, 0x9D]), CRC32(ebp, dword[r12 + rcx*8 - 99]).encode())
1129        self.assertEqual(bytearray([0xF2, 0x49, 0x0F, 0x38, 0xF0, 0xC9]), CRC32(rcx, r9b).encode())
1130        self.assertEqual(bytearray([0xF2, 0x49, 0x0F, 0x38, 0xF1, 0xCF]), CRC32(rcx, r15).encode())
1131        self.assertEqual(bytearray([0xF2, 0x49, 0x0F, 0x38, 0xF0, 0x4C, 0xBE, 0x85]), CRC32(rcx, byte[r14 + rdi*4 - 123]).encode())
1132        self.assertEqual(bytearray([0xF2, 0x49, 0x0F, 0x38, 0xF1, 0x4C, 0xD3, 0xA8]), CRC32(rcx, qword[r11 + rdx*8 - 88]).encode())
1133
1134
1135class TestCBW(unittest.TestCase):
1136    def runTest(self):
1137        self.assertEqual(bytearray([0x66, 0x98]), CBW().encode())
1138
1139
1140class TestCDQ(unittest.TestCase):
1141    def runTest(self):
1142        self.assertEqual(bytearray([0x99]), CDQ().encode())
1143
1144
1145class TestCQO(unittest.TestCase):
1146    def runTest(self):
1147        self.assertEqual(bytearray([0x48, 0x99]), CQO().encode())
1148
1149
1150class TestCWD(unittest.TestCase):
1151    def runTest(self):
1152        self.assertEqual(bytearray([0x66, 0x99]), CWD().encode())
1153
1154
1155class TestCWDE(unittest.TestCase):
1156    def runTest(self):
1157        self.assertEqual(bytearray([0x98]), CWDE().encode())
1158
1159
1160class TestCDQE(unittest.TestCase):
1161    def runTest(self):
1162        self.assertEqual(bytearray([0x48, 0x98]), CDQE().encode())
1163
1164
1165class TestCMOVA(unittest.TestCase):
1166    def runTest(self):
1167        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x47, 0xF4]), CMOVA(si, r12w).encode())
1168        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x47, 0x74, 0xED, 0x95]), CMOVA(si, word[r13 + rbp*8 - 107]).encode())
1169        self.assertEqual(bytearray([0x41, 0x0F, 0x47, 0xE8]), CMOVA(ebp, r8d).encode())
1170        self.assertEqual(bytearray([0x41, 0x0F, 0x47, 0x6C, 0xCC, 0x9D]), CMOVA(ebp, dword[r12 + rcx*8 - 99]).encode())
1171        self.assertEqual(bytearray([0x49, 0x0F, 0x47, 0xCF]), CMOVA(rcx, r15).encode())
1172        self.assertEqual(bytearray([0x49, 0x0F, 0x47, 0x4C, 0xD3, 0xA8]), CMOVA(rcx, qword[r11 + rdx*8 - 88]).encode())
1173
1174
1175class TestCMOVNA(unittest.TestCase):
1176    def runTest(self):
1177        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x46, 0xF4]), CMOVNA(si, r12w).encode())
1178        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x46, 0x74, 0xED, 0x95]), CMOVNA(si, word[r13 + rbp*8 - 107]).encode())
1179        self.assertEqual(bytearray([0x41, 0x0F, 0x46, 0xE8]), CMOVNA(ebp, r8d).encode())
1180        self.assertEqual(bytearray([0x41, 0x0F, 0x46, 0x6C, 0xCC, 0x9D]), CMOVNA(ebp, dword[r12 + rcx*8 - 99]).encode())
1181        self.assertEqual(bytearray([0x49, 0x0F, 0x46, 0xCF]), CMOVNA(rcx, r15).encode())
1182        self.assertEqual(bytearray([0x49, 0x0F, 0x46, 0x4C, 0xD3, 0xA8]), CMOVNA(rcx, qword[r11 + rdx*8 - 88]).encode())
1183
1184
1185class TestCMOVAE(unittest.TestCase):
1186    def runTest(self):
1187        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x43, 0xF4]), CMOVAE(si, r12w).encode())
1188        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x43, 0x74, 0xED, 0x95]), CMOVAE(si, word[r13 + rbp*8 - 107]).encode())
1189        self.assertEqual(bytearray([0x41, 0x0F, 0x43, 0xE8]), CMOVAE(ebp, r8d).encode())
1190        self.assertEqual(bytearray([0x41, 0x0F, 0x43, 0x6C, 0xCC, 0x9D]), CMOVAE(ebp, dword[r12 + rcx*8 - 99]).encode())
1191        self.assertEqual(bytearray([0x49, 0x0F, 0x43, 0xCF]), CMOVAE(rcx, r15).encode())
1192        self.assertEqual(bytearray([0x49, 0x0F, 0x43, 0x4C, 0xD3, 0xA8]), CMOVAE(rcx, qword[r11 + rdx*8 - 88]).encode())
1193
1194
1195class TestCMOVNAE(unittest.TestCase):
1196    def runTest(self):
1197        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x42, 0xF4]), CMOVNAE(si, r12w).encode())
1198        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x42, 0x74, 0xED, 0x95]), CMOVNAE(si, word[r13 + rbp*8 - 107]).encode())
1199        self.assertEqual(bytearray([0x41, 0x0F, 0x42, 0xE8]), CMOVNAE(ebp, r8d).encode())
1200        self.assertEqual(bytearray([0x41, 0x0F, 0x42, 0x6C, 0xCC, 0x9D]), CMOVNAE(ebp, dword[r12 + rcx*8 - 99]).encode())
1201        self.assertEqual(bytearray([0x49, 0x0F, 0x42, 0xCF]), CMOVNAE(rcx, r15).encode())
1202        self.assertEqual(bytearray([0x49, 0x0F, 0x42, 0x4C, 0xD3, 0xA8]), CMOVNAE(rcx, qword[r11 + rdx*8 - 88]).encode())
1203
1204
1205class TestCMOVB(unittest.TestCase):
1206    def runTest(self):
1207        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x42, 0xF4]), CMOVB(si, r12w).encode())
1208        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x42, 0x74, 0xED, 0x95]), CMOVB(si, word[r13 + rbp*8 - 107]).encode())
1209        self.assertEqual(bytearray([0x41, 0x0F, 0x42, 0xE8]), CMOVB(ebp, r8d).encode())
1210        self.assertEqual(bytearray([0x41, 0x0F, 0x42, 0x6C, 0xCC, 0x9D]), CMOVB(ebp, dword[r12 + rcx*8 - 99]).encode())
1211        self.assertEqual(bytearray([0x49, 0x0F, 0x42, 0xCF]), CMOVB(rcx, r15).encode())
1212        self.assertEqual(bytearray([0x49, 0x0F, 0x42, 0x4C, 0xD3, 0xA8]), CMOVB(rcx, qword[r11 + rdx*8 - 88]).encode())
1213
1214
1215class TestCMOVNB(unittest.TestCase):
1216    def runTest(self):
1217        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x43, 0xF4]), CMOVNB(si, r12w).encode())
1218        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x43, 0x74, 0xED, 0x95]), CMOVNB(si, word[r13 + rbp*8 - 107]).encode())
1219        self.assertEqual(bytearray([0x41, 0x0F, 0x43, 0xE8]), CMOVNB(ebp, r8d).encode())
1220        self.assertEqual(bytearray([0x41, 0x0F, 0x43, 0x6C, 0xCC, 0x9D]), CMOVNB(ebp, dword[r12 + rcx*8 - 99]).encode())
1221        self.assertEqual(bytearray([0x49, 0x0F, 0x43, 0xCF]), CMOVNB(rcx, r15).encode())
1222        self.assertEqual(bytearray([0x49, 0x0F, 0x43, 0x4C, 0xD3, 0xA8]), CMOVNB(rcx, qword[r11 + rdx*8 - 88]).encode())
1223
1224
1225class TestCMOVBE(unittest.TestCase):
1226    def runTest(self):
1227        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x46, 0xF4]), CMOVBE(si, r12w).encode())
1228        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x46, 0x74, 0xED, 0x95]), CMOVBE(si, word[r13 + rbp*8 - 107]).encode())
1229        self.assertEqual(bytearray([0x41, 0x0F, 0x46, 0xE8]), CMOVBE(ebp, r8d).encode())
1230        self.assertEqual(bytearray([0x41, 0x0F, 0x46, 0x6C, 0xCC, 0x9D]), CMOVBE(ebp, dword[r12 + rcx*8 - 99]).encode())
1231        self.assertEqual(bytearray([0x49, 0x0F, 0x46, 0xCF]), CMOVBE(rcx, r15).encode())
1232        self.assertEqual(bytearray([0x49, 0x0F, 0x46, 0x4C, 0xD3, 0xA8]), CMOVBE(rcx, qword[r11 + rdx*8 - 88]).encode())
1233
1234
1235class TestCMOVNBE(unittest.TestCase):
1236    def runTest(self):
1237        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x47, 0xF4]), CMOVNBE(si, r12w).encode())
1238        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x47, 0x74, 0xED, 0x95]), CMOVNBE(si, word[r13 + rbp*8 - 107]).encode())
1239        self.assertEqual(bytearray([0x41, 0x0F, 0x47, 0xE8]), CMOVNBE(ebp, r8d).encode())
1240        self.assertEqual(bytearray([0x41, 0x0F, 0x47, 0x6C, 0xCC, 0x9D]), CMOVNBE(ebp, dword[r12 + rcx*8 - 99]).encode())
1241        self.assertEqual(bytearray([0x49, 0x0F, 0x47, 0xCF]), CMOVNBE(rcx, r15).encode())
1242        self.assertEqual(bytearray([0x49, 0x0F, 0x47, 0x4C, 0xD3, 0xA8]), CMOVNBE(rcx, qword[r11 + rdx*8 - 88]).encode())
1243
1244
1245class TestCMOVC(unittest.TestCase):
1246    def runTest(self):
1247        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x42, 0xF4]), CMOVC(si, r12w).encode())
1248        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x42, 0x74, 0xED, 0x95]), CMOVC(si, word[r13 + rbp*8 - 107]).encode())
1249        self.assertEqual(bytearray([0x41, 0x0F, 0x42, 0xE8]), CMOVC(ebp, r8d).encode())
1250        self.assertEqual(bytearray([0x41, 0x0F, 0x42, 0x6C, 0xCC, 0x9D]), CMOVC(ebp, dword[r12 + rcx*8 - 99]).encode())
1251        self.assertEqual(bytearray([0x49, 0x0F, 0x42, 0xCF]), CMOVC(rcx, r15).encode())
1252        self.assertEqual(bytearray([0x49, 0x0F, 0x42, 0x4C, 0xD3, 0xA8]), CMOVC(rcx, qword[r11 + rdx*8 - 88]).encode())
1253
1254
1255class TestCMOVNC(unittest.TestCase):
1256    def runTest(self):
1257        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x43, 0xF4]), CMOVNC(si, r12w).encode())
1258        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x43, 0x74, 0xED, 0x95]), CMOVNC(si, word[r13 + rbp*8 - 107]).encode())
1259        self.assertEqual(bytearray([0x41, 0x0F, 0x43, 0xE8]), CMOVNC(ebp, r8d).encode())
1260        self.assertEqual(bytearray([0x41, 0x0F, 0x43, 0x6C, 0xCC, 0x9D]), CMOVNC(ebp, dword[r12 + rcx*8 - 99]).encode())
1261        self.assertEqual(bytearray([0x49, 0x0F, 0x43, 0xCF]), CMOVNC(rcx, r15).encode())
1262        self.assertEqual(bytearray([0x49, 0x0F, 0x43, 0x4C, 0xD3, 0xA8]), CMOVNC(rcx, qword[r11 + rdx*8 - 88]).encode())
1263
1264
1265class TestCMOVE(unittest.TestCase):
1266    def runTest(self):
1267        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x44, 0xF4]), CMOVE(si, r12w).encode())
1268        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x44, 0x74, 0xED, 0x95]), CMOVE(si, word[r13 + rbp*8 - 107]).encode())
1269        self.assertEqual(bytearray([0x41, 0x0F, 0x44, 0xE8]), CMOVE(ebp, r8d).encode())
1270        self.assertEqual(bytearray([0x41, 0x0F, 0x44, 0x6C, 0xCC, 0x9D]), CMOVE(ebp, dword[r12 + rcx*8 - 99]).encode())
1271        self.assertEqual(bytearray([0x49, 0x0F, 0x44, 0xCF]), CMOVE(rcx, r15).encode())
1272        self.assertEqual(bytearray([0x49, 0x0F, 0x44, 0x4C, 0xD3, 0xA8]), CMOVE(rcx, qword[r11 + rdx*8 - 88]).encode())
1273
1274
1275class TestCMOVNE(unittest.TestCase):
1276    def runTest(self):
1277        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x45, 0xF4]), CMOVNE(si, r12w).encode())
1278        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x45, 0x74, 0xED, 0x95]), CMOVNE(si, word[r13 + rbp*8 - 107]).encode())
1279        self.assertEqual(bytearray([0x41, 0x0F, 0x45, 0xE8]), CMOVNE(ebp, r8d).encode())
1280        self.assertEqual(bytearray([0x41, 0x0F, 0x45, 0x6C, 0xCC, 0x9D]), CMOVNE(ebp, dword[r12 + rcx*8 - 99]).encode())
1281        self.assertEqual(bytearray([0x49, 0x0F, 0x45, 0xCF]), CMOVNE(rcx, r15).encode())
1282        self.assertEqual(bytearray([0x49, 0x0F, 0x45, 0x4C, 0xD3, 0xA8]), CMOVNE(rcx, qword[r11 + rdx*8 - 88]).encode())
1283
1284
1285class TestCMOVG(unittest.TestCase):
1286    def runTest(self):
1287        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4F, 0xF4]), CMOVG(si, r12w).encode())
1288        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4F, 0x74, 0xED, 0x95]), CMOVG(si, word[r13 + rbp*8 - 107]).encode())
1289        self.assertEqual(bytearray([0x41, 0x0F, 0x4F, 0xE8]), CMOVG(ebp, r8d).encode())
1290        self.assertEqual(bytearray([0x41, 0x0F, 0x4F, 0x6C, 0xCC, 0x9D]), CMOVG(ebp, dword[r12 + rcx*8 - 99]).encode())
1291        self.assertEqual(bytearray([0x49, 0x0F, 0x4F, 0xCF]), CMOVG(rcx, r15).encode())
1292        self.assertEqual(bytearray([0x49, 0x0F, 0x4F, 0x4C, 0xD3, 0xA8]), CMOVG(rcx, qword[r11 + rdx*8 - 88]).encode())
1293
1294
1295class TestCMOVNG(unittest.TestCase):
1296    def runTest(self):
1297        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4E, 0xF4]), CMOVNG(si, r12w).encode())
1298        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4E, 0x74, 0xED, 0x95]), CMOVNG(si, word[r13 + rbp*8 - 107]).encode())
1299        self.assertEqual(bytearray([0x41, 0x0F, 0x4E, 0xE8]), CMOVNG(ebp, r8d).encode())
1300        self.assertEqual(bytearray([0x41, 0x0F, 0x4E, 0x6C, 0xCC, 0x9D]), CMOVNG(ebp, dword[r12 + rcx*8 - 99]).encode())
1301        self.assertEqual(bytearray([0x49, 0x0F, 0x4E, 0xCF]), CMOVNG(rcx, r15).encode())
1302        self.assertEqual(bytearray([0x49, 0x0F, 0x4E, 0x4C, 0xD3, 0xA8]), CMOVNG(rcx, qword[r11 + rdx*8 - 88]).encode())
1303
1304
1305class TestCMOVGE(unittest.TestCase):
1306    def runTest(self):
1307        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4D, 0xF4]), CMOVGE(si, r12w).encode())
1308        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4D, 0x74, 0xED, 0x95]), CMOVGE(si, word[r13 + rbp*8 - 107]).encode())
1309        self.assertEqual(bytearray([0x41, 0x0F, 0x4D, 0xE8]), CMOVGE(ebp, r8d).encode())
1310        self.assertEqual(bytearray([0x41, 0x0F, 0x4D, 0x6C, 0xCC, 0x9D]), CMOVGE(ebp, dword[r12 + rcx*8 - 99]).encode())
1311        self.assertEqual(bytearray([0x49, 0x0F, 0x4D, 0xCF]), CMOVGE(rcx, r15).encode())
1312        self.assertEqual(bytearray([0x49, 0x0F, 0x4D, 0x4C, 0xD3, 0xA8]), CMOVGE(rcx, qword[r11 + rdx*8 - 88]).encode())
1313
1314
1315class TestCMOVNGE(unittest.TestCase):
1316    def runTest(self):
1317        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4C, 0xF4]), CMOVNGE(si, r12w).encode())
1318        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4C, 0x74, 0xED, 0x95]), CMOVNGE(si, word[r13 + rbp*8 - 107]).encode())
1319        self.assertEqual(bytearray([0x41, 0x0F, 0x4C, 0xE8]), CMOVNGE(ebp, r8d).encode())
1320        self.assertEqual(bytearray([0x41, 0x0F, 0x4C, 0x6C, 0xCC, 0x9D]), CMOVNGE(ebp, dword[r12 + rcx*8 - 99]).encode())
1321        self.assertEqual(bytearray([0x49, 0x0F, 0x4C, 0xCF]), CMOVNGE(rcx, r15).encode())
1322        self.assertEqual(bytearray([0x49, 0x0F, 0x4C, 0x4C, 0xD3, 0xA8]), CMOVNGE(rcx, qword[r11 + rdx*8 - 88]).encode())
1323
1324
1325class TestCMOVL(unittest.TestCase):
1326    def runTest(self):
1327        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4C, 0xF4]), CMOVL(si, r12w).encode())
1328        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4C, 0x74, 0xED, 0x95]), CMOVL(si, word[r13 + rbp*8 - 107]).encode())
1329        self.assertEqual(bytearray([0x41, 0x0F, 0x4C, 0xE8]), CMOVL(ebp, r8d).encode())
1330        self.assertEqual(bytearray([0x41, 0x0F, 0x4C, 0x6C, 0xCC, 0x9D]), CMOVL(ebp, dword[r12 + rcx*8 - 99]).encode())
1331        self.assertEqual(bytearray([0x49, 0x0F, 0x4C, 0xCF]), CMOVL(rcx, r15).encode())
1332        self.assertEqual(bytearray([0x49, 0x0F, 0x4C, 0x4C, 0xD3, 0xA8]), CMOVL(rcx, qword[r11 + rdx*8 - 88]).encode())
1333
1334
1335class TestCMOVNL(unittest.TestCase):
1336    def runTest(self):
1337        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4D, 0xF4]), CMOVNL(si, r12w).encode())
1338        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4D, 0x74, 0xED, 0x95]), CMOVNL(si, word[r13 + rbp*8 - 107]).encode())
1339        self.assertEqual(bytearray([0x41, 0x0F, 0x4D, 0xE8]), CMOVNL(ebp, r8d).encode())
1340        self.assertEqual(bytearray([0x41, 0x0F, 0x4D, 0x6C, 0xCC, 0x9D]), CMOVNL(ebp, dword[r12 + rcx*8 - 99]).encode())
1341        self.assertEqual(bytearray([0x49, 0x0F, 0x4D, 0xCF]), CMOVNL(rcx, r15).encode())
1342        self.assertEqual(bytearray([0x49, 0x0F, 0x4D, 0x4C, 0xD3, 0xA8]), CMOVNL(rcx, qword[r11 + rdx*8 - 88]).encode())
1343
1344
1345class TestCMOVLE(unittest.TestCase):
1346    def runTest(self):
1347        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4E, 0xF4]), CMOVLE(si, r12w).encode())
1348        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4E, 0x74, 0xED, 0x95]), CMOVLE(si, word[r13 + rbp*8 - 107]).encode())
1349        self.assertEqual(bytearray([0x41, 0x0F, 0x4E, 0xE8]), CMOVLE(ebp, r8d).encode())
1350        self.assertEqual(bytearray([0x41, 0x0F, 0x4E, 0x6C, 0xCC, 0x9D]), CMOVLE(ebp, dword[r12 + rcx*8 - 99]).encode())
1351        self.assertEqual(bytearray([0x49, 0x0F, 0x4E, 0xCF]), CMOVLE(rcx, r15).encode())
1352        self.assertEqual(bytearray([0x49, 0x0F, 0x4E, 0x4C, 0xD3, 0xA8]), CMOVLE(rcx, qword[r11 + rdx*8 - 88]).encode())
1353
1354
1355class TestCMOVNLE(unittest.TestCase):
1356    def runTest(self):
1357        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4F, 0xF4]), CMOVNLE(si, r12w).encode())
1358        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4F, 0x74, 0xED, 0x95]), CMOVNLE(si, word[r13 + rbp*8 - 107]).encode())
1359        self.assertEqual(bytearray([0x41, 0x0F, 0x4F, 0xE8]), CMOVNLE(ebp, r8d).encode())
1360        self.assertEqual(bytearray([0x41, 0x0F, 0x4F, 0x6C, 0xCC, 0x9D]), CMOVNLE(ebp, dword[r12 + rcx*8 - 99]).encode())
1361        self.assertEqual(bytearray([0x49, 0x0F, 0x4F, 0xCF]), CMOVNLE(rcx, r15).encode())
1362        self.assertEqual(bytearray([0x49, 0x0F, 0x4F, 0x4C, 0xD3, 0xA8]), CMOVNLE(rcx, qword[r11 + rdx*8 - 88]).encode())
1363
1364
1365class TestCMOVO(unittest.TestCase):
1366    def runTest(self):
1367        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x40, 0xF4]), CMOVO(si, r12w).encode())
1368        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x40, 0x74, 0xED, 0x95]), CMOVO(si, word[r13 + rbp*8 - 107]).encode())
1369        self.assertEqual(bytearray([0x41, 0x0F, 0x40, 0xE8]), CMOVO(ebp, r8d).encode())
1370        self.assertEqual(bytearray([0x41, 0x0F, 0x40, 0x6C, 0xCC, 0x9D]), CMOVO(ebp, dword[r12 + rcx*8 - 99]).encode())
1371        self.assertEqual(bytearray([0x49, 0x0F, 0x40, 0xCF]), CMOVO(rcx, r15).encode())
1372        self.assertEqual(bytearray([0x49, 0x0F, 0x40, 0x4C, 0xD3, 0xA8]), CMOVO(rcx, qword[r11 + rdx*8 - 88]).encode())
1373
1374
1375class TestCMOVNO(unittest.TestCase):
1376    def runTest(self):
1377        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x41, 0xF4]), CMOVNO(si, r12w).encode())
1378        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x41, 0x74, 0xED, 0x95]), CMOVNO(si, word[r13 + rbp*8 - 107]).encode())
1379        self.assertEqual(bytearray([0x41, 0x0F, 0x41, 0xE8]), CMOVNO(ebp, r8d).encode())
1380        self.assertEqual(bytearray([0x41, 0x0F, 0x41, 0x6C, 0xCC, 0x9D]), CMOVNO(ebp, dword[r12 + rcx*8 - 99]).encode())
1381        self.assertEqual(bytearray([0x49, 0x0F, 0x41, 0xCF]), CMOVNO(rcx, r15).encode())
1382        self.assertEqual(bytearray([0x49, 0x0F, 0x41, 0x4C, 0xD3, 0xA8]), CMOVNO(rcx, qword[r11 + rdx*8 - 88]).encode())
1383
1384
1385class TestCMOVP(unittest.TestCase):
1386    def runTest(self):
1387        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4A, 0xF4]), CMOVP(si, r12w).encode())
1388        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4A, 0x74, 0xED, 0x95]), CMOVP(si, word[r13 + rbp*8 - 107]).encode())
1389        self.assertEqual(bytearray([0x41, 0x0F, 0x4A, 0xE8]), CMOVP(ebp, r8d).encode())
1390        self.assertEqual(bytearray([0x41, 0x0F, 0x4A, 0x6C, 0xCC, 0x9D]), CMOVP(ebp, dword[r12 + rcx*8 - 99]).encode())
1391        self.assertEqual(bytearray([0x49, 0x0F, 0x4A, 0xCF]), CMOVP(rcx, r15).encode())
1392        self.assertEqual(bytearray([0x49, 0x0F, 0x4A, 0x4C, 0xD3, 0xA8]), CMOVP(rcx, qword[r11 + rdx*8 - 88]).encode())
1393
1394
1395class TestCMOVNP(unittest.TestCase):
1396    def runTest(self):
1397        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4B, 0xF4]), CMOVNP(si, r12w).encode())
1398        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4B, 0x74, 0xED, 0x95]), CMOVNP(si, word[r13 + rbp*8 - 107]).encode())
1399        self.assertEqual(bytearray([0x41, 0x0F, 0x4B, 0xE8]), CMOVNP(ebp, r8d).encode())
1400        self.assertEqual(bytearray([0x41, 0x0F, 0x4B, 0x6C, 0xCC, 0x9D]), CMOVNP(ebp, dword[r12 + rcx*8 - 99]).encode())
1401        self.assertEqual(bytearray([0x49, 0x0F, 0x4B, 0xCF]), CMOVNP(rcx, r15).encode())
1402        self.assertEqual(bytearray([0x49, 0x0F, 0x4B, 0x4C, 0xD3, 0xA8]), CMOVNP(rcx, qword[r11 + rdx*8 - 88]).encode())
1403
1404
1405class TestCMOVS(unittest.TestCase):
1406    def runTest(self):
1407        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x48, 0xF4]), CMOVS(si, r12w).encode())
1408        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x48, 0x74, 0xED, 0x95]), CMOVS(si, word[r13 + rbp*8 - 107]).encode())
1409        self.assertEqual(bytearray([0x41, 0x0F, 0x48, 0xE8]), CMOVS(ebp, r8d).encode())
1410        self.assertEqual(bytearray([0x41, 0x0F, 0x48, 0x6C, 0xCC, 0x9D]), CMOVS(ebp, dword[r12 + rcx*8 - 99]).encode())
1411        self.assertEqual(bytearray([0x49, 0x0F, 0x48, 0xCF]), CMOVS(rcx, r15).encode())
1412        self.assertEqual(bytearray([0x49, 0x0F, 0x48, 0x4C, 0xD3, 0xA8]), CMOVS(rcx, qword[r11 + rdx*8 - 88]).encode())
1413
1414
1415class TestCMOVNS(unittest.TestCase):
1416    def runTest(self):
1417        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x49, 0xF4]), CMOVNS(si, r12w).encode())
1418        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x49, 0x74, 0xED, 0x95]), CMOVNS(si, word[r13 + rbp*8 - 107]).encode())
1419        self.assertEqual(bytearray([0x41, 0x0F, 0x49, 0xE8]), CMOVNS(ebp, r8d).encode())
1420        self.assertEqual(bytearray([0x41, 0x0F, 0x49, 0x6C, 0xCC, 0x9D]), CMOVNS(ebp, dword[r12 + rcx*8 - 99]).encode())
1421        self.assertEqual(bytearray([0x49, 0x0F, 0x49, 0xCF]), CMOVNS(rcx, r15).encode())
1422        self.assertEqual(bytearray([0x49, 0x0F, 0x49, 0x4C, 0xD3, 0xA8]), CMOVNS(rcx, qword[r11 + rdx*8 - 88]).encode())
1423
1424
1425class TestCMOVZ(unittest.TestCase):
1426    def runTest(self):
1427        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x44, 0xF4]), CMOVZ(si, r12w).encode())
1428        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x44, 0x74, 0xED, 0x95]), CMOVZ(si, word[r13 + rbp*8 - 107]).encode())
1429        self.assertEqual(bytearray([0x41, 0x0F, 0x44, 0xE8]), CMOVZ(ebp, r8d).encode())
1430        self.assertEqual(bytearray([0x41, 0x0F, 0x44, 0x6C, 0xCC, 0x9D]), CMOVZ(ebp, dword[r12 + rcx*8 - 99]).encode())
1431        self.assertEqual(bytearray([0x49, 0x0F, 0x44, 0xCF]), CMOVZ(rcx, r15).encode())
1432        self.assertEqual(bytearray([0x49, 0x0F, 0x44, 0x4C, 0xD3, 0xA8]), CMOVZ(rcx, qword[r11 + rdx*8 - 88]).encode())
1433
1434
1435class TestCMOVNZ(unittest.TestCase):
1436    def runTest(self):
1437        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x45, 0xF4]), CMOVNZ(si, r12w).encode())
1438        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x45, 0x74, 0xED, 0x95]), CMOVNZ(si, word[r13 + rbp*8 - 107]).encode())
1439        self.assertEqual(bytearray([0x41, 0x0F, 0x45, 0xE8]), CMOVNZ(ebp, r8d).encode())
1440        self.assertEqual(bytearray([0x41, 0x0F, 0x45, 0x6C, 0xCC, 0x9D]), CMOVNZ(ebp, dword[r12 + rcx*8 - 99]).encode())
1441        self.assertEqual(bytearray([0x49, 0x0F, 0x45, 0xCF]), CMOVNZ(rcx, r15).encode())
1442        self.assertEqual(bytearray([0x49, 0x0F, 0x45, 0x4C, 0xD3, 0xA8]), CMOVNZ(rcx, qword[r11 + rdx*8 - 88]).encode())
1443
1444
1445class TestCMOVPE(unittest.TestCase):
1446    def runTest(self):
1447        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4A, 0xF4]), CMOVPE(si, r12w).encode())
1448        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4A, 0x74, 0xED, 0x95]), CMOVPE(si, word[r13 + rbp*8 - 107]).encode())
1449        self.assertEqual(bytearray([0x41, 0x0F, 0x4A, 0xE8]), CMOVPE(ebp, r8d).encode())
1450        self.assertEqual(bytearray([0x41, 0x0F, 0x4A, 0x6C, 0xCC, 0x9D]), CMOVPE(ebp, dword[r12 + rcx*8 - 99]).encode())
1451        self.assertEqual(bytearray([0x49, 0x0F, 0x4A, 0xCF]), CMOVPE(rcx, r15).encode())
1452        self.assertEqual(bytearray([0x49, 0x0F, 0x4A, 0x4C, 0xD3, 0xA8]), CMOVPE(rcx, qword[r11 + rdx*8 - 88]).encode())
1453
1454
1455class TestCMOVPO(unittest.TestCase):
1456    def runTest(self):
1457        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4B, 0xF4]), CMOVPO(si, r12w).encode())
1458        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0x4B, 0x74, 0xED, 0x95]), CMOVPO(si, word[r13 + rbp*8 - 107]).encode())
1459        self.assertEqual(bytearray([0x41, 0x0F, 0x4B, 0xE8]), CMOVPO(ebp, r8d).encode())
1460        self.assertEqual(bytearray([0x41, 0x0F, 0x4B, 0x6C, 0xCC, 0x9D]), CMOVPO(ebp, dword[r12 + rcx*8 - 99]).encode())
1461        self.assertEqual(bytearray([0x49, 0x0F, 0x4B, 0xCF]), CMOVPO(rcx, r15).encode())
1462        self.assertEqual(bytearray([0x49, 0x0F, 0x4B, 0x4C, 0xD3, 0xA8]), CMOVPO(rcx, qword[r11 + rdx*8 - 88]).encode())
1463
1464
1465class TestSETA(unittest.TestCase):
1466    def runTest(self):
1467        self.assertEqual(bytearray([0x0F, 0x97, 0xC3]), SETA(bl).encode())
1468        self.assertEqual(bytearray([0x41, 0x0F, 0x97, 0x44, 0xBE, 0x85]), SETA(byte[r14 + rdi*4 - 123]).encode())
1469
1470
1471class TestSETNA(unittest.TestCase):
1472    def runTest(self):
1473        self.assertEqual(bytearray([0x0F, 0x96, 0xC3]), SETNA(bl).encode())
1474        self.assertEqual(bytearray([0x41, 0x0F, 0x96, 0x44, 0xBE, 0x85]), SETNA(byte[r14 + rdi*4 - 123]).encode())
1475
1476
1477class TestSETAE(unittest.TestCase):
1478    def runTest(self):
1479        self.assertEqual(bytearray([0x0F, 0x93, 0xC3]), SETAE(bl).encode())
1480        self.assertEqual(bytearray([0x41, 0x0F, 0x93, 0x44, 0xBE, 0x85]), SETAE(byte[r14 + rdi*4 - 123]).encode())
1481
1482
1483class TestSETNAE(unittest.TestCase):
1484    def runTest(self):
1485        self.assertEqual(bytearray([0x0F, 0x92, 0xC3]), SETNAE(bl).encode())
1486        self.assertEqual(bytearray([0x41, 0x0F, 0x92, 0x44, 0xBE, 0x85]), SETNAE(byte[r14 + rdi*4 - 123]).encode())
1487
1488
1489class TestSETB(unittest.TestCase):
1490    def runTest(self):
1491        self.assertEqual(bytearray([0x0F, 0x92, 0xC3]), SETB(bl).encode())
1492        self.assertEqual(bytearray([0x41, 0x0F, 0x92, 0x44, 0xBE, 0x85]), SETB(byte[r14 + rdi*4 - 123]).encode())
1493
1494
1495class TestSETNB(unittest.TestCase):
1496    def runTest(self):
1497        self.assertEqual(bytearray([0x0F, 0x93, 0xC3]), SETNB(bl).encode())
1498        self.assertEqual(bytearray([0x41, 0x0F, 0x93, 0x44, 0xBE, 0x85]), SETNB(byte[r14 + rdi*4 - 123]).encode())
1499
1500
1501class TestSETBE(unittest.TestCase):
1502    def runTest(self):
1503        self.assertEqual(bytearray([0x0F, 0x96, 0xC3]), SETBE(bl).encode())
1504        self.assertEqual(bytearray([0x41, 0x0F, 0x96, 0x44, 0xBE, 0x85]), SETBE(byte[r14 + rdi*4 - 123]).encode())
1505
1506
1507class TestSETNBE(unittest.TestCase):
1508    def runTest(self):
1509        self.assertEqual(bytearray([0x0F, 0x97, 0xC3]), SETNBE(bl).encode())
1510        self.assertEqual(bytearray([0x41, 0x0F, 0x97, 0x44, 0xBE, 0x85]), SETNBE(byte[r14 + rdi*4 - 123]).encode())
1511
1512
1513class TestSETC(unittest.TestCase):
1514    def runTest(self):
1515        self.assertEqual(bytearray([0x0F, 0x92, 0xC3]), SETC(bl).encode())
1516        self.assertEqual(bytearray([0x41, 0x0F, 0x92, 0x44, 0xBE, 0x85]), SETC(byte[r14 + rdi*4 - 123]).encode())
1517
1518
1519class TestSETNC(unittest.TestCase):
1520    def runTest(self):
1521        self.assertEqual(bytearray([0x0F, 0x93, 0xC3]), SETNC(bl).encode())
1522        self.assertEqual(bytearray([0x41, 0x0F, 0x93, 0x44, 0xBE, 0x85]), SETNC(byte[r14 + rdi*4 - 123]).encode())
1523
1524
1525class TestSETE(unittest.TestCase):
1526    def runTest(self):
1527        self.assertEqual(bytearray([0x0F, 0x94, 0xC3]), SETE(bl).encode())
1528        self.assertEqual(bytearray([0x41, 0x0F, 0x94, 0x44, 0xBE, 0x85]), SETE(byte[r14 + rdi*4 - 123]).encode())
1529
1530
1531class TestSETNE(unittest.TestCase):
1532    def runTest(self):
1533        self.assertEqual(bytearray([0x0F, 0x95, 0xC3]), SETNE(bl).encode())
1534        self.assertEqual(bytearray([0x41, 0x0F, 0x95, 0x44, 0xBE, 0x85]), SETNE(byte[r14 + rdi*4 - 123]).encode())
1535
1536
1537class TestSETG(unittest.TestCase):
1538    def runTest(self):
1539        self.assertEqual(bytearray([0x0F, 0x9F, 0xC3]), SETG(bl).encode())
1540        self.assertEqual(bytearray([0x41, 0x0F, 0x9F, 0x44, 0xBE, 0x85]), SETG(byte[r14 + rdi*4 - 123]).encode())
1541
1542
1543class TestSETNG(unittest.TestCase):
1544    def runTest(self):
1545        self.assertEqual(bytearray([0x0F, 0x9E, 0xC3]), SETNG(bl).encode())
1546        self.assertEqual(bytearray([0x41, 0x0F, 0x9E, 0x44, 0xBE, 0x85]), SETNG(byte[r14 + rdi*4 - 123]).encode())
1547
1548
1549class TestSETGE(unittest.TestCase):
1550    def runTest(self):
1551        self.assertEqual(bytearray([0x0F, 0x9D, 0xC3]), SETGE(bl).encode())
1552        self.assertEqual(bytearray([0x41, 0x0F, 0x9D, 0x44, 0xBE, 0x85]), SETGE(byte[r14 + rdi*4 - 123]).encode())
1553
1554
1555class TestSETNGE(unittest.TestCase):
1556    def runTest(self):
1557        self.assertEqual(bytearray([0x0F, 0x9C, 0xC3]), SETNGE(bl).encode())
1558        self.assertEqual(bytearray([0x41, 0x0F, 0x9C, 0x44, 0xBE, 0x85]), SETNGE(byte[r14 + rdi*4 - 123]).encode())
1559
1560
1561class TestSETL(unittest.TestCase):
1562    def runTest(self):
1563        self.assertEqual(bytearray([0x0F, 0x9C, 0xC3]), SETL(bl).encode())
1564        self.assertEqual(bytearray([0x41, 0x0F, 0x9C, 0x44, 0xBE, 0x85]), SETL(byte[r14 + rdi*4 - 123]).encode())
1565
1566
1567class TestSETNL(unittest.TestCase):
1568    def runTest(self):
1569        self.assertEqual(bytearray([0x0F, 0x9D, 0xC3]), SETNL(bl).encode())
1570        self.assertEqual(bytearray([0x41, 0x0F, 0x9D, 0x44, 0xBE, 0x85]), SETNL(byte[r14 + rdi*4 - 123]).encode())
1571
1572
1573class TestSETLE(unittest.TestCase):
1574    def runTest(self):
1575        self.assertEqual(bytearray([0x0F, 0x9E, 0xC3]), SETLE(bl).encode())
1576        self.assertEqual(bytearray([0x41, 0x0F, 0x9E, 0x44, 0xBE, 0x85]), SETLE(byte[r14 + rdi*4 - 123]).encode())
1577
1578
1579class TestSETNLE(unittest.TestCase):
1580    def runTest(self):
1581        self.assertEqual(bytearray([0x0F, 0x9F, 0xC3]), SETNLE(bl).encode())
1582        self.assertEqual(bytearray([0x41, 0x0F, 0x9F, 0x44, 0xBE, 0x85]), SETNLE(byte[r14 + rdi*4 - 123]).encode())
1583
1584
1585class TestSETO(unittest.TestCase):
1586    def runTest(self):
1587        self.assertEqual(bytearray([0x0F, 0x90, 0xC3]), SETO(bl).encode())
1588        self.assertEqual(bytearray([0x41, 0x0F, 0x90, 0x44, 0xBE, 0x85]), SETO(byte[r14 + rdi*4 - 123]).encode())
1589
1590
1591class TestSETNO(unittest.TestCase):
1592    def runTest(self):
1593        self.assertEqual(bytearray([0x0F, 0x91, 0xC3]), SETNO(bl).encode())
1594        self.assertEqual(bytearray([0x41, 0x0F, 0x91, 0x44, 0xBE, 0x85]), SETNO(byte[r14 + rdi*4 - 123]).encode())
1595
1596
1597class TestSETP(unittest.TestCase):
1598    def runTest(self):
1599        self.assertEqual(bytearray([0x0F, 0x9A, 0xC3]), SETP(bl).encode())
1600        self.assertEqual(bytearray([0x41, 0x0F, 0x9A, 0x44, 0xBE, 0x85]), SETP(byte[r14 + rdi*4 - 123]).encode())
1601
1602
1603class TestSETNP(unittest.TestCase):
1604    def runTest(self):
1605        self.assertEqual(bytearray([0x0F, 0x9B, 0xC3]), SETNP(bl).encode())
1606        self.assertEqual(bytearray([0x41, 0x0F, 0x9B, 0x44, 0xBE, 0x85]), SETNP(byte[r14 + rdi*4 - 123]).encode())
1607
1608
1609class TestSETS(unittest.TestCase):
1610    def runTest(self):
1611        self.assertEqual(bytearray([0x0F, 0x98, 0xC3]), SETS(bl).encode())
1612        self.assertEqual(bytearray([0x41, 0x0F, 0x98, 0x44, 0xBE, 0x85]), SETS(byte[r14 + rdi*4 - 123]).encode())
1613
1614
1615class TestSETNS(unittest.TestCase):
1616    def runTest(self):
1617        self.assertEqual(bytearray([0x0F, 0x99, 0xC3]), SETNS(bl).encode())
1618        self.assertEqual(bytearray([0x41, 0x0F, 0x99, 0x44, 0xBE, 0x85]), SETNS(byte[r14 + rdi*4 - 123]).encode())
1619
1620
1621class TestSETZ(unittest.TestCase):
1622    def runTest(self):
1623        self.assertEqual(bytearray([0x0F, 0x94, 0xC3]), SETZ(bl).encode())
1624        self.assertEqual(bytearray([0x41, 0x0F, 0x94, 0x44, 0xBE, 0x85]), SETZ(byte[r14 + rdi*4 - 123]).encode())
1625
1626
1627class TestSETNZ(unittest.TestCase):
1628    def runTest(self):
1629        self.assertEqual(bytearray([0x0F, 0x95, 0xC3]), SETNZ(bl).encode())
1630        self.assertEqual(bytearray([0x41, 0x0F, 0x95, 0x44, 0xBE, 0x85]), SETNZ(byte[r14 + rdi*4 - 123]).encode())
1631
1632
1633class TestSETPE(unittest.TestCase):
1634    def runTest(self):
1635        self.assertEqual(bytearray([0x0F, 0x9A, 0xC3]), SETPE(bl).encode())
1636        self.assertEqual(bytearray([0x41, 0x0F, 0x9A, 0x44, 0xBE, 0x85]), SETPE(byte[r14 + rdi*4 - 123]).encode())
1637
1638
1639class TestSETPO(unittest.TestCase):
1640    def runTest(self):
1641        self.assertEqual(bytearray([0x0F, 0x9B, 0xC3]), SETPO(bl).encode())
1642        self.assertEqual(bytearray([0x41, 0x0F, 0x9B, 0x44, 0xBE, 0x85]), SETPO(byte[r14 + rdi*4 - 123]).encode())
1643
1644
1645class TestJA(unittest.TestCase):
1646    def runTest(self):
1647        pass
1648
1649
1650class TestJNA(unittest.TestCase):
1651    def runTest(self):
1652        pass
1653
1654
1655class TestJAE(unittest.TestCase):
1656    def runTest(self):
1657        pass
1658
1659
1660class TestJNAE(unittest.TestCase):
1661    def runTest(self):
1662        pass
1663
1664
1665class TestJB(unittest.TestCase):
1666    def runTest(self):
1667        pass
1668
1669
1670class TestJNB(unittest.TestCase):
1671    def runTest(self):
1672        pass
1673
1674
1675class TestJBE(unittest.TestCase):
1676    def runTest(self):
1677        pass
1678
1679
1680class TestJNBE(unittest.TestCase):
1681    def runTest(self):
1682        pass
1683
1684
1685class TestJC(unittest.TestCase):
1686    def runTest(self):
1687        pass
1688
1689
1690class TestJNC(unittest.TestCase):
1691    def runTest(self):
1692        pass
1693
1694
1695class TestJE(unittest.TestCase):
1696    def runTest(self):
1697        pass
1698
1699
1700class TestJNE(unittest.TestCase):
1701    def runTest(self):
1702        pass
1703
1704
1705class TestJG(unittest.TestCase):
1706    def runTest(self):
1707        pass
1708
1709
1710class TestJNG(unittest.TestCase):
1711    def runTest(self):
1712        pass
1713
1714
1715class TestJGE(unittest.TestCase):
1716    def runTest(self):
1717        pass
1718
1719
1720class TestJNGE(unittest.TestCase):
1721    def runTest(self):
1722        pass
1723
1724
1725class TestJL(unittest.TestCase):
1726    def runTest(self):
1727        pass
1728
1729
1730class TestJNL(unittest.TestCase):
1731    def runTest(self):
1732        pass
1733
1734
1735class TestJLE(unittest.TestCase):
1736    def runTest(self):
1737        pass
1738
1739
1740class TestJNLE(unittest.TestCase):
1741    def runTest(self):
1742        pass
1743
1744
1745class TestJO(unittest.TestCase):
1746    def runTest(self):
1747        pass
1748
1749
1750class TestJNO(unittest.TestCase):
1751    def runTest(self):
1752        pass
1753
1754
1755class TestJP(unittest.TestCase):
1756    def runTest(self):
1757        pass
1758
1759
1760class TestJNP(unittest.TestCase):
1761    def runTest(self):
1762        pass
1763
1764
1765class TestJS(unittest.TestCase):
1766    def runTest(self):
1767        pass
1768
1769
1770class TestJNS(unittest.TestCase):
1771    def runTest(self):
1772        pass
1773
1774
1775class TestJZ(unittest.TestCase):
1776    def runTest(self):
1777        pass
1778
1779
1780class TestJNZ(unittest.TestCase):
1781    def runTest(self):
1782        pass
1783
1784
1785class TestJPE(unittest.TestCase):
1786    def runTest(self):
1787        pass
1788
1789
1790class TestJPO(unittest.TestCase):
1791    def runTest(self):
1792        pass
1793
1794
1795class TestJMP(unittest.TestCase):
1796    def runTest(self):
1797        self.assertEqual(bytearray([0xFF, 0xE1]), JMP(rcx).encode())
1798        self.assertEqual(bytearray([0x41, 0xFF, 0x64, 0xD3, 0xA8]), JMP(qword[r11 + rdx*8 - 88]).encode())
1799
1800
1801class TestJRCXZ(unittest.TestCase):
1802    def runTest(self):
1803        pass
1804
1805
1806class TestJECXZ(unittest.TestCase):
1807    def runTest(self):
1808        pass
1809
1810
1811class TestRET(unittest.TestCase):
1812    def runTest(self):
1813        self.assertEqual(bytearray([0xC3]), RET().encode())
1814        self.assertEqual(bytearray([0xC2, 0x00, 0x7D]), RET(32000).encode())
1815
1816
1817class TestCALL(unittest.TestCase):
1818    def runTest(self):
1819        self.assertEqual(bytearray([0xFF, 0xD1]), CALL(rcx).encode())
1820        self.assertEqual(bytearray([0x41, 0xFF, 0x54, 0xD3, 0xA8]), CALL(qword[r11 + rdx*8 - 88]).encode())
1821
1822
1823class TestPAUSE(unittest.TestCase):
1824    def runTest(self):
1825        self.assertEqual(bytearray([0xF3, 0x90]), PAUSE().encode())
1826
1827
1828class TestNOP(unittest.TestCase):
1829    def runTest(self):
1830        self.assertEqual(bytearray([0x90]), NOP().encode())
1831
1832
1833class TestINT(unittest.TestCase):
1834    def runTest(self):
1835        self.assertEqual(bytearray([0xCC]), INT(3).encode())
1836        self.assertEqual(bytearray([0xCD, 0x02]), INT(2).encode())
1837
1838
1839class TestUD2(unittest.TestCase):
1840    def runTest(self):
1841        self.assertEqual(bytearray([0x0F, 0x0B]), UD2().encode())
1842
1843
1844class TestCPUID(unittest.TestCase):
1845    def runTest(self):
1846        self.assertEqual(bytearray([0x0F, 0xA2]), CPUID().encode())
1847
1848
1849class TestRDTSC(unittest.TestCase):
1850    def runTest(self):
1851        self.assertEqual(bytearray([0x0F, 0x31]), RDTSC().encode())
1852
1853
1854class TestRDTSCP(unittest.TestCase):
1855    def runTest(self):
1856        self.assertEqual(bytearray([0x0F, 0x01, 0xF9]), RDTSCP().encode())
1857
1858
1859class TestXGETBV(unittest.TestCase):
1860    def runTest(self):
1861        self.assertEqual(bytearray([0x0F, 0x01, 0xD0]), XGETBV().encode())
1862
1863
1864class TestSYSCALL(unittest.TestCase):
1865    def runTest(self):
1866        self.assertEqual(bytearray([0x0F, 0x05]), SYSCALL().encode())
1867
1868
1869class TestSTC(unittest.TestCase):
1870    def runTest(self):
1871        self.assertEqual(bytearray([0xF9]), STC().encode())
1872
1873
1874class TestCLC(unittest.TestCase):
1875    def runTest(self):
1876        self.assertEqual(bytearray([0xF8]), CLC().encode())
1877
1878
1879class TestCMC(unittest.TestCase):
1880    def runTest(self):
1881        self.assertEqual(bytearray([0xF5]), CMC().encode())
1882
1883
1884class TestSTD(unittest.TestCase):
1885    def runTest(self):
1886        self.assertEqual(bytearray([0xFD]), STD().encode())
1887
1888
1889class TestCLD(unittest.TestCase):
1890    def runTest(self):
1891        self.assertEqual(bytearray([0xFC]), CLD().encode())
1892
1893
1894class TestXADD(unittest.TestCase):
1895    def runTest(self):
1896        self.assertEqual(bytearray([0x44, 0x0F, 0xC0, 0xCB]), XADD(bl, r9b).encode())
1897        self.assertEqual(bytearray([0x66, 0x44, 0x0F, 0xC1, 0xE6]), XADD(si, r12w).encode())
1898        self.assertEqual(bytearray([0x44, 0x0F, 0xC1, 0xC5]), XADD(ebp, r8d).encode())
1899        self.assertEqual(bytearray([0x4C, 0x0F, 0xC1, 0xF9]), XADD(rcx, r15).encode())
1900        self.assertEqual(bytearray([0x45, 0x0F, 0xC0, 0x4C, 0xBE, 0x85]), XADD(byte[r14 + rdi*4 - 123], r9b).encode())
1901        self.assertEqual(bytearray([0x66, 0x45, 0x0F, 0xC1, 0x64, 0xED, 0x95]), XADD(word[r13 + rbp*8 - 107], r12w).encode())
1902        self.assertEqual(bytearray([0x45, 0x0F, 0xC1, 0x44, 0xCC, 0x9D]), XADD(dword[r12 + rcx*8 - 99], r8d).encode())
1903        self.assertEqual(bytearray([0x4D, 0x0F, 0xC1, 0x7C, 0xD3, 0xA8]), XADD(qword[r11 + rdx*8 - 88], r15).encode())
1904
1905
1906class TestXCHG(unittest.TestCase):
1907    def runTest(self):
1908        self.assertEqual(bytearray([0x44, 0x86, 0xCB]), XCHG(bl, r9b).encode())
1909        self.assertEqual(bytearray([0x41, 0x86, 0x5C, 0xBE, 0x85]), XCHG(bl, byte[r14 + rdi*4 - 123]).encode())
1910        self.assertEqual(bytearray([0x66, 0x41, 0x94]), XCHG(ax, r12w).encode())
1911        self.assertEqual(bytearray([0x66, 0x96]), XCHG(si, ax).encode())
1912        self.assertEqual(bytearray([0x66, 0x44, 0x87, 0xE6]), XCHG(si, r12w).encode())
1913        self.assertEqual(bytearray([0x66, 0x41, 0x87, 0x74, 0xED, 0x95]), XCHG(si, word[r13 + rbp*8 - 107]).encode())
1914        self.assertEqual(bytearray([0x41, 0x90]), XCHG(eax, r8d).encode())
1915        self.assertEqual(bytearray([0x95]), XCHG(ebp, eax).encode())
1916        self.assertEqual(bytearray([0x44, 0x87, 0xC5]), XCHG(ebp, r8d).encode())
1917        self.assertEqual(bytearray([0x41, 0x87, 0x6C, 0xCC, 0x9D]), XCHG(ebp, dword[r12 + rcx*8 - 99]).encode())
1918        self.assertEqual(bytearray([0x49, 0x97]), XCHG(rax, r15).encode())
1919        self.assertEqual(bytearray([0x48, 0x91]), XCHG(rcx, rax).encode())
1920        self.assertEqual(bytearray([0x4C, 0x87, 0xF9]), XCHG(rcx, r15).encode())
1921        self.assertEqual(bytearray([0x49, 0x87, 0x4C, 0xD3, 0xA8]), XCHG(rcx, qword[r11 + rdx*8 - 88]).encode())
1922        self.assertEqual(bytearray([0x45, 0x86, 0x4C, 0xBE, 0x85]), XCHG(byte[r14 + rdi*4 - 123], r9b).encode())
1923        self.assertEqual(bytearray([0x66, 0x45, 0x87, 0x64, 0xED, 0x95]), XCHG(word[r13 + rbp*8 - 107], r12w).encode())
1924        self.assertEqual(bytearray([0x45, 0x87, 0x44, 0xCC, 0x9D]), XCHG(dword[r12 + rcx*8 - 99], r8d).encode())
1925        self.assertEqual(bytearray([0x4D, 0x87, 0x7C, 0xD3, 0xA8]), XCHG(qword[r11 + rdx*8 - 88], r15).encode())
1926
1927
1928class TestCMPXCHG(unittest.TestCase):
1929    def runTest(self):
1930        self.assertEqual(bytearray([0x44, 0x0F, 0xB0, 0xCB]), CMPXCHG(bl, r9b).encode())
1931        self.assertEqual(bytearray([0x66, 0x44, 0x0F, 0xB1, 0xE6]), CMPXCHG(si, r12w).encode())
1932        self.assertEqual(bytearray([0x44, 0x0F, 0xB1, 0xC5]), CMPXCHG(ebp, r8d).encode())
1933        self.assertEqual(bytearray([0x4C, 0x0F, 0xB1, 0xF9]), CMPXCHG(rcx, r15).encode())
1934        self.assertEqual(bytearray([0x45, 0x0F, 0xB0, 0x4C, 0xBE, 0x85]), CMPXCHG(byte[r14 + rdi*4 - 123], r9b).encode())
1935        self.assertEqual(bytearray([0x66, 0x45, 0x0F, 0xB1, 0x64, 0xED, 0x95]), CMPXCHG(word[r13 + rbp*8 - 107], r12w).encode())
1936        self.assertEqual(bytearray([0x45, 0x0F, 0xB1, 0x44, 0xCC, 0x9D]), CMPXCHG(dword[r12 + rcx*8 - 99], r8d).encode())
1937        self.assertEqual(bytearray([0x4D, 0x0F, 0xB1, 0x7C, 0xD3, 0xA8]), CMPXCHG(qword[r11 + rdx*8 - 88], r15).encode())
1938
1939
1940class TestCMPXCHG8B(unittest.TestCase):
1941    def runTest(self):
1942        self.assertEqual(bytearray([0x41, 0x0F, 0xC7, 0x4C, 0xD3, 0xA8]), CMPXCHG8B(qword[r11 + rdx*8 - 88]).encode())
1943
1944
1945class TestCMPXCHG16B(unittest.TestCase):
1946    def runTest(self):
1947        self.assertEqual(bytearray([0x49, 0x0F, 0xC7, 0x4C, 0xC2, 0xB3]), CMPXCHG16B(oword[r10 + rax*8 - 77]).encode())
1948
1949
1950class TestSFENCE(unittest.TestCase):
1951    def runTest(self):
1952        self.assertEqual(bytearray([0x0F, 0xAE, 0xF8]), SFENCE().encode())
1953
1954
1955class TestMFENCE(unittest.TestCase):
1956    def runTest(self):
1957        self.assertEqual(bytearray([0x0F, 0xAE, 0xF0]), MFENCE().encode())
1958
1959
1960class TestLFENCE(unittest.TestCase):
1961    def runTest(self):
1962        self.assertEqual(bytearray([0x0F, 0xAE, 0xE8]), LFENCE().encode())
1963
1964
1965class TestPREFETCHNTA(unittest.TestCase):
1966    def runTest(self):
1967        self.assertEqual(bytearray([0x41, 0x0F, 0x18, 0x44, 0xBE, 0x85]), PREFETCHNTA(byte[r14 + rdi*4 - 123]).encode())
1968
1969
1970class TestPREFETCHT0(unittest.TestCase):
1971    def runTest(self):
1972        self.assertEqual(bytearray([0x41, 0x0F, 0x18, 0x4C, 0xBE, 0x85]), PREFETCHT0(byte[r14 + rdi*4 - 123]).encode())
1973
1974
1975class TestPREFETCHT1(unittest.TestCase):
1976    def runTest(self):
1977        self.assertEqual(bytearray([0x41, 0x0F, 0x18, 0x54, 0xBE, 0x85]), PREFETCHT1(byte[r14 + rdi*4 - 123]).encode())
1978
1979
1980class TestPREFETCHT2(unittest.TestCase):
1981    def runTest(self):
1982        self.assertEqual(bytearray([0x41, 0x0F, 0x18, 0x5C, 0xBE, 0x85]), PREFETCHT2(byte[r14 + rdi*4 - 123]).encode())
1983
1984
1985class TestPREFETCH(unittest.TestCase):
1986    def runTest(self):
1987        self.assertEqual(bytearray([0x41, 0x0F, 0x0D, 0x44, 0xBE, 0x85]), PREFETCH(byte[r14 + rdi*4 - 123]).encode())
1988
1989
1990class TestPREFETCHW(unittest.TestCase):
1991    def runTest(self):
1992        self.assertEqual(bytearray([0x41, 0x0F, 0x0D, 0x4C, 0xBE, 0x85]), PREFETCHW(byte[r14 + rdi*4 - 123]).encode())
1993
1994
1995class TestPREFETCHWT1(unittest.TestCase):
1996    def runTest(self):
1997        self.assertEqual(bytearray([0x41, 0x0F, 0x0D, 0x54, 0xBE, 0x85]), PREFETCHWT1(byte[r14 + rdi*4 - 123]).encode())
1998
1999
2000class TestCLFLUSH(unittest.TestCase):
2001    def runTest(self):
2002        self.assertEqual(bytearray([0x41, 0x0F, 0xAE, 0x7C, 0xBE, 0x85]), CLFLUSH(byte[r14 + rdi*4 - 123]).encode())
2003
2004
2005class TestCLFLUSHOPT(unittest.TestCase):
2006    def runTest(self):
2007        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0xAE, 0x7C, 0xBE, 0x85]), CLFLUSHOPT(byte[r14 + rdi*4 - 123]).encode())
2008
2009
2010class TestCLWB(unittest.TestCase):
2011    def runTest(self):
2012        self.assertEqual(bytearray([0x66, 0x41, 0x0F, 0xAE, 0x74, 0xBE, 0x85]), CLWB(byte[r14 + rdi*4 - 123]).encode())
2013
2014
2015class TestCLZERO(unittest.TestCase):
2016    def runTest(self):
2017        self.assertEqual(bytearray([0x0F, 0x01, 0xFC]), CLZERO().encode())
2018
2019
2020