1 // Copyright 2015, VIXL authors 2 // All rights reserved. 3 // 4 // Redistribution and use in source and binary forms, with or without 5 // modification, are permitted provided that the following conditions are met: 6 // 7 // * Redistributions of source code must retain the above copyright notice, 8 // this list of conditions and the following disclaimer. 9 // * Redistributions in binary form must reproduce the above copyright notice, 10 // this list of conditions and the following disclaimer in the documentation 11 // and/or other materials provided with the distribution. 12 // * Neither the name of ARM Limited nor the names of its contributors may be 13 // used to endorse or promote products derived from this software without 14 // specific prior written permission. 15 // 16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND 17 // ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 18 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 19 // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE 20 // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 22 // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 23 // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 25 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 27 28 // --------------------------------------------------------------------- 29 // This file is auto generated using tools/generate_simulator_traces.py. 30 // 31 // PLEASE DO NOT EDIT. 32 // --------------------------------------------------------------------- 33 34 #ifndef VIXL_ASSEMBLER_COND_RD_OPERAND_IMM16_MOV_T32_H_ 35 #define VIXL_ASSEMBLER_COND_RD_OPERAND_IMM16_MOV_T32_H_ 36 37 const byte kInstruction_mov_al_r0_0x0000[] = { 38 0x4f, 0xf0, 0x00, 0x00 // mov al r0 0x0000 39 }; 40 const byte kInstruction_mov_al_r0_0x0001[] = { 41 0x4f, 0xf0, 0x01, 0x00 // mov al r0 0x0001 42 }; 43 const byte kInstruction_mov_al_r0_0x0002[] = { 44 0x4f, 0xf0, 0x02, 0x00 // mov al r0 0x0002 45 }; 46 const byte kInstruction_mov_al_r0_0x0020[] = { 47 0x4f, 0xf0, 0x20, 0x00 // mov al r0 0x0020 48 }; 49 const byte kInstruction_mov_al_r0_0x007d[] = { 50 0x4f, 0xf0, 0x7d, 0x00 // mov al r0 0x007d 51 }; 52 const byte kInstruction_mov_al_r0_0x007e[] = { 53 0x4f, 0xf0, 0x7e, 0x00 // mov al r0 0x007e 54 }; 55 const byte kInstruction_mov_al_r0_0x007f[] = { 56 0x4f, 0xf0, 0x7f, 0x00 // mov al r0 0x007f 57 }; 58 const byte kInstruction_mov_al_r0_0x7ffd[] = { 59 0x47, 0xf6, 0xfd, 0x70 // mov al r0 0x7ffd 60 }; 61 const byte kInstruction_mov_al_r0_0x7ffe[] = { 62 0x47, 0xf6, 0xfe, 0x70 // mov al r0 0x7ffe 63 }; 64 const byte kInstruction_mov_al_r0_0x7fff[] = { 65 0x47, 0xf6, 0xff, 0x70 // mov al r0 0x7fff 66 }; 67 const byte kInstruction_mov_al_r0_0x3333[] = { 68 0x43, 0xf2, 0x33, 0x30 // mov al r0 0x3333 69 }; 70 const byte kInstruction_mov_al_r0_0x5555[] = { 71 0x45, 0xf2, 0x55, 0x50 // mov al r0 0x5555 72 }; 73 const byte kInstruction_mov_al_r0_0xaaaa[] = { 74 0x4a, 0xf6, 0xaa, 0x20 // mov al r0 0xaaaa 75 }; 76 const byte kInstruction_mov_al_r0_0xcccc[] = { 77 0x4c, 0xf6, 0xcc, 0x40 // mov al r0 0xcccc 78 }; 79 const byte kInstruction_mov_al_r0_0x8000[] = { 80 0x4f, 0xf4, 0x00, 0x40 // mov al r0 0x8000 81 }; 82 const byte kInstruction_mov_al_r0_0x8001[] = { 83 0x48, 0xf2, 0x01, 0x00 // mov al r0 0x8001 84 }; 85 const byte kInstruction_mov_al_r0_0x8002[] = { 86 0x48, 0xf2, 0x02, 0x00 // mov al r0 0x8002 87 }; 88 const byte kInstruction_mov_al_r0_0x8003[] = { 89 0x48, 0xf2, 0x03, 0x00 // mov al r0 0x8003 90 }; 91 const byte kInstruction_mov_al_r0_0xff80[] = { 92 0x4f, 0xf6, 0x80, 0x70 // mov al r0 0xff80 93 }; 94 const byte kInstruction_mov_al_r0_0xff81[] = { 95 0x4f, 0xf6, 0x81, 0x70 // mov al r0 0xff81 96 }; 97 const byte kInstruction_mov_al_r0_0xff82[] = { 98 0x4f, 0xf6, 0x82, 0x70 // mov al r0 0xff82 99 }; 100 const byte kInstruction_mov_al_r0_0xff83[] = { 101 0x4f, 0xf6, 0x83, 0x70 // mov al r0 0xff83 102 }; 103 const byte kInstruction_mov_al_r0_0xffe0[] = { 104 0x4f, 0xf6, 0xe0, 0x70 // mov al r0 0xffe0 105 }; 106 const byte kInstruction_mov_al_r0_0xfffd[] = { 107 0x4f, 0xf6, 0xfd, 0x70 // mov al r0 0xfffd 108 }; 109 const byte kInstruction_mov_al_r0_0xfffe[] = { 110 0x4f, 0xf6, 0xfe, 0x70 // mov al r0 0xfffe 111 }; 112 const byte kInstruction_mov_al_r0_0xffff[] = { 113 0x4f, 0xf6, 0xff, 0x70 // mov al r0 0xffff 114 }; 115 const byte kInstruction_mov_al_r1_0x0000[] = { 116 0x4f, 0xf0, 0x00, 0x01 // mov al r1 0x0000 117 }; 118 const byte kInstruction_mov_al_r1_0x0001[] = { 119 0x4f, 0xf0, 0x01, 0x01 // mov al r1 0x0001 120 }; 121 const byte kInstruction_mov_al_r1_0x0002[] = { 122 0x4f, 0xf0, 0x02, 0x01 // mov al r1 0x0002 123 }; 124 const byte kInstruction_mov_al_r1_0x0020[] = { 125 0x4f, 0xf0, 0x20, 0x01 // mov al r1 0x0020 126 }; 127 const byte kInstruction_mov_al_r1_0x007d[] = { 128 0x4f, 0xf0, 0x7d, 0x01 // mov al r1 0x007d 129 }; 130 const byte kInstruction_mov_al_r1_0x007e[] = { 131 0x4f, 0xf0, 0x7e, 0x01 // mov al r1 0x007e 132 }; 133 const byte kInstruction_mov_al_r1_0x007f[] = { 134 0x4f, 0xf0, 0x7f, 0x01 // mov al r1 0x007f 135 }; 136 const byte kInstruction_mov_al_r1_0x7ffd[] = { 137 0x47, 0xf6, 0xfd, 0x71 // mov al r1 0x7ffd 138 }; 139 const byte kInstruction_mov_al_r1_0x7ffe[] = { 140 0x47, 0xf6, 0xfe, 0x71 // mov al r1 0x7ffe 141 }; 142 const byte kInstruction_mov_al_r1_0x7fff[] = { 143 0x47, 0xf6, 0xff, 0x71 // mov al r1 0x7fff 144 }; 145 const byte kInstruction_mov_al_r1_0x3333[] = { 146 0x43, 0xf2, 0x33, 0x31 // mov al r1 0x3333 147 }; 148 const byte kInstruction_mov_al_r1_0x5555[] = { 149 0x45, 0xf2, 0x55, 0x51 // mov al r1 0x5555 150 }; 151 const byte kInstruction_mov_al_r1_0xaaaa[] = { 152 0x4a, 0xf6, 0xaa, 0x21 // mov al r1 0xaaaa 153 }; 154 const byte kInstruction_mov_al_r1_0xcccc[] = { 155 0x4c, 0xf6, 0xcc, 0x41 // mov al r1 0xcccc 156 }; 157 const byte kInstruction_mov_al_r1_0x8000[] = { 158 0x4f, 0xf4, 0x00, 0x41 // mov al r1 0x8000 159 }; 160 const byte kInstruction_mov_al_r1_0x8001[] = { 161 0x48, 0xf2, 0x01, 0x01 // mov al r1 0x8001 162 }; 163 const byte kInstruction_mov_al_r1_0x8002[] = { 164 0x48, 0xf2, 0x02, 0x01 // mov al r1 0x8002 165 }; 166 const byte kInstruction_mov_al_r1_0x8003[] = { 167 0x48, 0xf2, 0x03, 0x01 // mov al r1 0x8003 168 }; 169 const byte kInstruction_mov_al_r1_0xff80[] = { 170 0x4f, 0xf6, 0x80, 0x71 // mov al r1 0xff80 171 }; 172 const byte kInstruction_mov_al_r1_0xff81[] = { 173 0x4f, 0xf6, 0x81, 0x71 // mov al r1 0xff81 174 }; 175 const byte kInstruction_mov_al_r1_0xff82[] = { 176 0x4f, 0xf6, 0x82, 0x71 // mov al r1 0xff82 177 }; 178 const byte kInstruction_mov_al_r1_0xff83[] = { 179 0x4f, 0xf6, 0x83, 0x71 // mov al r1 0xff83 180 }; 181 const byte kInstruction_mov_al_r1_0xffe0[] = { 182 0x4f, 0xf6, 0xe0, 0x71 // mov al r1 0xffe0 183 }; 184 const byte kInstruction_mov_al_r1_0xfffd[] = { 185 0x4f, 0xf6, 0xfd, 0x71 // mov al r1 0xfffd 186 }; 187 const byte kInstruction_mov_al_r1_0xfffe[] = { 188 0x4f, 0xf6, 0xfe, 0x71 // mov al r1 0xfffe 189 }; 190 const byte kInstruction_mov_al_r1_0xffff[] = { 191 0x4f, 0xf6, 0xff, 0x71 // mov al r1 0xffff 192 }; 193 const byte kInstruction_mov_al_r2_0x0000[] = { 194 0x4f, 0xf0, 0x00, 0x02 // mov al r2 0x0000 195 }; 196 const byte kInstruction_mov_al_r2_0x0001[] = { 197 0x4f, 0xf0, 0x01, 0x02 // mov al r2 0x0001 198 }; 199 const byte kInstruction_mov_al_r2_0x0002[] = { 200 0x4f, 0xf0, 0x02, 0x02 // mov al r2 0x0002 201 }; 202 const byte kInstruction_mov_al_r2_0x0020[] = { 203 0x4f, 0xf0, 0x20, 0x02 // mov al r2 0x0020 204 }; 205 const byte kInstruction_mov_al_r2_0x007d[] = { 206 0x4f, 0xf0, 0x7d, 0x02 // mov al r2 0x007d 207 }; 208 const byte kInstruction_mov_al_r2_0x007e[] = { 209 0x4f, 0xf0, 0x7e, 0x02 // mov al r2 0x007e 210 }; 211 const byte kInstruction_mov_al_r2_0x007f[] = { 212 0x4f, 0xf0, 0x7f, 0x02 // mov al r2 0x007f 213 }; 214 const byte kInstruction_mov_al_r2_0x7ffd[] = { 215 0x47, 0xf6, 0xfd, 0x72 // mov al r2 0x7ffd 216 }; 217 const byte kInstruction_mov_al_r2_0x7ffe[] = { 218 0x47, 0xf6, 0xfe, 0x72 // mov al r2 0x7ffe 219 }; 220 const byte kInstruction_mov_al_r2_0x7fff[] = { 221 0x47, 0xf6, 0xff, 0x72 // mov al r2 0x7fff 222 }; 223 const byte kInstruction_mov_al_r2_0x3333[] = { 224 0x43, 0xf2, 0x33, 0x32 // mov al r2 0x3333 225 }; 226 const byte kInstruction_mov_al_r2_0x5555[] = { 227 0x45, 0xf2, 0x55, 0x52 // mov al r2 0x5555 228 }; 229 const byte kInstruction_mov_al_r2_0xaaaa[] = { 230 0x4a, 0xf6, 0xaa, 0x22 // mov al r2 0xaaaa 231 }; 232 const byte kInstruction_mov_al_r2_0xcccc[] = { 233 0x4c, 0xf6, 0xcc, 0x42 // mov al r2 0xcccc 234 }; 235 const byte kInstruction_mov_al_r2_0x8000[] = { 236 0x4f, 0xf4, 0x00, 0x42 // mov al r2 0x8000 237 }; 238 const byte kInstruction_mov_al_r2_0x8001[] = { 239 0x48, 0xf2, 0x01, 0x02 // mov al r2 0x8001 240 }; 241 const byte kInstruction_mov_al_r2_0x8002[] = { 242 0x48, 0xf2, 0x02, 0x02 // mov al r2 0x8002 243 }; 244 const byte kInstruction_mov_al_r2_0x8003[] = { 245 0x48, 0xf2, 0x03, 0x02 // mov al r2 0x8003 246 }; 247 const byte kInstruction_mov_al_r2_0xff80[] = { 248 0x4f, 0xf6, 0x80, 0x72 // mov al r2 0xff80 249 }; 250 const byte kInstruction_mov_al_r2_0xff81[] = { 251 0x4f, 0xf6, 0x81, 0x72 // mov al r2 0xff81 252 }; 253 const byte kInstruction_mov_al_r2_0xff82[] = { 254 0x4f, 0xf6, 0x82, 0x72 // mov al r2 0xff82 255 }; 256 const byte kInstruction_mov_al_r2_0xff83[] = { 257 0x4f, 0xf6, 0x83, 0x72 // mov al r2 0xff83 258 }; 259 const byte kInstruction_mov_al_r2_0xffe0[] = { 260 0x4f, 0xf6, 0xe0, 0x72 // mov al r2 0xffe0 261 }; 262 const byte kInstruction_mov_al_r2_0xfffd[] = { 263 0x4f, 0xf6, 0xfd, 0x72 // mov al r2 0xfffd 264 }; 265 const byte kInstruction_mov_al_r2_0xfffe[] = { 266 0x4f, 0xf6, 0xfe, 0x72 // mov al r2 0xfffe 267 }; 268 const byte kInstruction_mov_al_r2_0xffff[] = { 269 0x4f, 0xf6, 0xff, 0x72 // mov al r2 0xffff 270 }; 271 const byte kInstruction_mov_al_r3_0x0000[] = { 272 0x4f, 0xf0, 0x00, 0x03 // mov al r3 0x0000 273 }; 274 const byte kInstruction_mov_al_r3_0x0001[] = { 275 0x4f, 0xf0, 0x01, 0x03 // mov al r3 0x0001 276 }; 277 const byte kInstruction_mov_al_r3_0x0002[] = { 278 0x4f, 0xf0, 0x02, 0x03 // mov al r3 0x0002 279 }; 280 const byte kInstruction_mov_al_r3_0x0020[] = { 281 0x4f, 0xf0, 0x20, 0x03 // mov al r3 0x0020 282 }; 283 const byte kInstruction_mov_al_r3_0x007d[] = { 284 0x4f, 0xf0, 0x7d, 0x03 // mov al r3 0x007d 285 }; 286 const byte kInstruction_mov_al_r3_0x007e[] = { 287 0x4f, 0xf0, 0x7e, 0x03 // mov al r3 0x007e 288 }; 289 const byte kInstruction_mov_al_r3_0x007f[] = { 290 0x4f, 0xf0, 0x7f, 0x03 // mov al r3 0x007f 291 }; 292 const byte kInstruction_mov_al_r3_0x7ffd[] = { 293 0x47, 0xf6, 0xfd, 0x73 // mov al r3 0x7ffd 294 }; 295 const byte kInstruction_mov_al_r3_0x7ffe[] = { 296 0x47, 0xf6, 0xfe, 0x73 // mov al r3 0x7ffe 297 }; 298 const byte kInstruction_mov_al_r3_0x7fff[] = { 299 0x47, 0xf6, 0xff, 0x73 // mov al r3 0x7fff 300 }; 301 const byte kInstruction_mov_al_r3_0x3333[] = { 302 0x43, 0xf2, 0x33, 0x33 // mov al r3 0x3333 303 }; 304 const byte kInstruction_mov_al_r3_0x5555[] = { 305 0x45, 0xf2, 0x55, 0x53 // mov al r3 0x5555 306 }; 307 const byte kInstruction_mov_al_r3_0xaaaa[] = { 308 0x4a, 0xf6, 0xaa, 0x23 // mov al r3 0xaaaa 309 }; 310 const byte kInstruction_mov_al_r3_0xcccc[] = { 311 0x4c, 0xf6, 0xcc, 0x43 // mov al r3 0xcccc 312 }; 313 const byte kInstruction_mov_al_r3_0x8000[] = { 314 0x4f, 0xf4, 0x00, 0x43 // mov al r3 0x8000 315 }; 316 const byte kInstruction_mov_al_r3_0x8001[] = { 317 0x48, 0xf2, 0x01, 0x03 // mov al r3 0x8001 318 }; 319 const byte kInstruction_mov_al_r3_0x8002[] = { 320 0x48, 0xf2, 0x02, 0x03 // mov al r3 0x8002 321 }; 322 const byte kInstruction_mov_al_r3_0x8003[] = { 323 0x48, 0xf2, 0x03, 0x03 // mov al r3 0x8003 324 }; 325 const byte kInstruction_mov_al_r3_0xff80[] = { 326 0x4f, 0xf6, 0x80, 0x73 // mov al r3 0xff80 327 }; 328 const byte kInstruction_mov_al_r3_0xff81[] = { 329 0x4f, 0xf6, 0x81, 0x73 // mov al r3 0xff81 330 }; 331 const byte kInstruction_mov_al_r3_0xff82[] = { 332 0x4f, 0xf6, 0x82, 0x73 // mov al r3 0xff82 333 }; 334 const byte kInstruction_mov_al_r3_0xff83[] = { 335 0x4f, 0xf6, 0x83, 0x73 // mov al r3 0xff83 336 }; 337 const byte kInstruction_mov_al_r3_0xffe0[] = { 338 0x4f, 0xf6, 0xe0, 0x73 // mov al r3 0xffe0 339 }; 340 const byte kInstruction_mov_al_r3_0xfffd[] = { 341 0x4f, 0xf6, 0xfd, 0x73 // mov al r3 0xfffd 342 }; 343 const byte kInstruction_mov_al_r3_0xfffe[] = { 344 0x4f, 0xf6, 0xfe, 0x73 // mov al r3 0xfffe 345 }; 346 const byte kInstruction_mov_al_r3_0xffff[] = { 347 0x4f, 0xf6, 0xff, 0x73 // mov al r3 0xffff 348 }; 349 const byte kInstruction_mov_al_r4_0x0000[] = { 350 0x4f, 0xf0, 0x00, 0x04 // mov al r4 0x0000 351 }; 352 const byte kInstruction_mov_al_r4_0x0001[] = { 353 0x4f, 0xf0, 0x01, 0x04 // mov al r4 0x0001 354 }; 355 const byte kInstruction_mov_al_r4_0x0002[] = { 356 0x4f, 0xf0, 0x02, 0x04 // mov al r4 0x0002 357 }; 358 const byte kInstruction_mov_al_r4_0x0020[] = { 359 0x4f, 0xf0, 0x20, 0x04 // mov al r4 0x0020 360 }; 361 const byte kInstruction_mov_al_r4_0x007d[] = { 362 0x4f, 0xf0, 0x7d, 0x04 // mov al r4 0x007d 363 }; 364 const byte kInstruction_mov_al_r4_0x007e[] = { 365 0x4f, 0xf0, 0x7e, 0x04 // mov al r4 0x007e 366 }; 367 const byte kInstruction_mov_al_r4_0x007f[] = { 368 0x4f, 0xf0, 0x7f, 0x04 // mov al r4 0x007f 369 }; 370 const byte kInstruction_mov_al_r4_0x7ffd[] = { 371 0x47, 0xf6, 0xfd, 0x74 // mov al r4 0x7ffd 372 }; 373 const byte kInstruction_mov_al_r4_0x7ffe[] = { 374 0x47, 0xf6, 0xfe, 0x74 // mov al r4 0x7ffe 375 }; 376 const byte kInstruction_mov_al_r4_0x7fff[] = { 377 0x47, 0xf6, 0xff, 0x74 // mov al r4 0x7fff 378 }; 379 const byte kInstruction_mov_al_r4_0x3333[] = { 380 0x43, 0xf2, 0x33, 0x34 // mov al r4 0x3333 381 }; 382 const byte kInstruction_mov_al_r4_0x5555[] = { 383 0x45, 0xf2, 0x55, 0x54 // mov al r4 0x5555 384 }; 385 const byte kInstruction_mov_al_r4_0xaaaa[] = { 386 0x4a, 0xf6, 0xaa, 0x24 // mov al r4 0xaaaa 387 }; 388 const byte kInstruction_mov_al_r4_0xcccc[] = { 389 0x4c, 0xf6, 0xcc, 0x44 // mov al r4 0xcccc 390 }; 391 const byte kInstruction_mov_al_r4_0x8000[] = { 392 0x4f, 0xf4, 0x00, 0x44 // mov al r4 0x8000 393 }; 394 const byte kInstruction_mov_al_r4_0x8001[] = { 395 0x48, 0xf2, 0x01, 0x04 // mov al r4 0x8001 396 }; 397 const byte kInstruction_mov_al_r4_0x8002[] = { 398 0x48, 0xf2, 0x02, 0x04 // mov al r4 0x8002 399 }; 400 const byte kInstruction_mov_al_r4_0x8003[] = { 401 0x48, 0xf2, 0x03, 0x04 // mov al r4 0x8003 402 }; 403 const byte kInstruction_mov_al_r4_0xff80[] = { 404 0x4f, 0xf6, 0x80, 0x74 // mov al r4 0xff80 405 }; 406 const byte kInstruction_mov_al_r4_0xff81[] = { 407 0x4f, 0xf6, 0x81, 0x74 // mov al r4 0xff81 408 }; 409 const byte kInstruction_mov_al_r4_0xff82[] = { 410 0x4f, 0xf6, 0x82, 0x74 // mov al r4 0xff82 411 }; 412 const byte kInstruction_mov_al_r4_0xff83[] = { 413 0x4f, 0xf6, 0x83, 0x74 // mov al r4 0xff83 414 }; 415 const byte kInstruction_mov_al_r4_0xffe0[] = { 416 0x4f, 0xf6, 0xe0, 0x74 // mov al r4 0xffe0 417 }; 418 const byte kInstruction_mov_al_r4_0xfffd[] = { 419 0x4f, 0xf6, 0xfd, 0x74 // mov al r4 0xfffd 420 }; 421 const byte kInstruction_mov_al_r4_0xfffe[] = { 422 0x4f, 0xf6, 0xfe, 0x74 // mov al r4 0xfffe 423 }; 424 const byte kInstruction_mov_al_r4_0xffff[] = { 425 0x4f, 0xf6, 0xff, 0x74 // mov al r4 0xffff 426 }; 427 const byte kInstruction_mov_al_r5_0x0000[] = { 428 0x4f, 0xf0, 0x00, 0x05 // mov al r5 0x0000 429 }; 430 const byte kInstruction_mov_al_r5_0x0001[] = { 431 0x4f, 0xf0, 0x01, 0x05 // mov al r5 0x0001 432 }; 433 const byte kInstruction_mov_al_r5_0x0002[] = { 434 0x4f, 0xf0, 0x02, 0x05 // mov al r5 0x0002 435 }; 436 const byte kInstruction_mov_al_r5_0x0020[] = { 437 0x4f, 0xf0, 0x20, 0x05 // mov al r5 0x0020 438 }; 439 const byte kInstruction_mov_al_r5_0x007d[] = { 440 0x4f, 0xf0, 0x7d, 0x05 // mov al r5 0x007d 441 }; 442 const byte kInstruction_mov_al_r5_0x007e[] = { 443 0x4f, 0xf0, 0x7e, 0x05 // mov al r5 0x007e 444 }; 445 const byte kInstruction_mov_al_r5_0x007f[] = { 446 0x4f, 0xf0, 0x7f, 0x05 // mov al r5 0x007f 447 }; 448 const byte kInstruction_mov_al_r5_0x7ffd[] = { 449 0x47, 0xf6, 0xfd, 0x75 // mov al r5 0x7ffd 450 }; 451 const byte kInstruction_mov_al_r5_0x7ffe[] = { 452 0x47, 0xf6, 0xfe, 0x75 // mov al r5 0x7ffe 453 }; 454 const byte kInstruction_mov_al_r5_0x7fff[] = { 455 0x47, 0xf6, 0xff, 0x75 // mov al r5 0x7fff 456 }; 457 const byte kInstruction_mov_al_r5_0x3333[] = { 458 0x43, 0xf2, 0x33, 0x35 // mov al r5 0x3333 459 }; 460 const byte kInstruction_mov_al_r5_0x5555[] = { 461 0x45, 0xf2, 0x55, 0x55 // mov al r5 0x5555 462 }; 463 const byte kInstruction_mov_al_r5_0xaaaa[] = { 464 0x4a, 0xf6, 0xaa, 0x25 // mov al r5 0xaaaa 465 }; 466 const byte kInstruction_mov_al_r5_0xcccc[] = { 467 0x4c, 0xf6, 0xcc, 0x45 // mov al r5 0xcccc 468 }; 469 const byte kInstruction_mov_al_r5_0x8000[] = { 470 0x4f, 0xf4, 0x00, 0x45 // mov al r5 0x8000 471 }; 472 const byte kInstruction_mov_al_r5_0x8001[] = { 473 0x48, 0xf2, 0x01, 0x05 // mov al r5 0x8001 474 }; 475 const byte kInstruction_mov_al_r5_0x8002[] = { 476 0x48, 0xf2, 0x02, 0x05 // mov al r5 0x8002 477 }; 478 const byte kInstruction_mov_al_r5_0x8003[] = { 479 0x48, 0xf2, 0x03, 0x05 // mov al r5 0x8003 480 }; 481 const byte kInstruction_mov_al_r5_0xff80[] = { 482 0x4f, 0xf6, 0x80, 0x75 // mov al r5 0xff80 483 }; 484 const byte kInstruction_mov_al_r5_0xff81[] = { 485 0x4f, 0xf6, 0x81, 0x75 // mov al r5 0xff81 486 }; 487 const byte kInstruction_mov_al_r5_0xff82[] = { 488 0x4f, 0xf6, 0x82, 0x75 // mov al r5 0xff82 489 }; 490 const byte kInstruction_mov_al_r5_0xff83[] = { 491 0x4f, 0xf6, 0x83, 0x75 // mov al r5 0xff83 492 }; 493 const byte kInstruction_mov_al_r5_0xffe0[] = { 494 0x4f, 0xf6, 0xe0, 0x75 // mov al r5 0xffe0 495 }; 496 const byte kInstruction_mov_al_r5_0xfffd[] = { 497 0x4f, 0xf6, 0xfd, 0x75 // mov al r5 0xfffd 498 }; 499 const byte kInstruction_mov_al_r5_0xfffe[] = { 500 0x4f, 0xf6, 0xfe, 0x75 // mov al r5 0xfffe 501 }; 502 const byte kInstruction_mov_al_r5_0xffff[] = { 503 0x4f, 0xf6, 0xff, 0x75 // mov al r5 0xffff 504 }; 505 const byte kInstruction_mov_al_r6_0x0000[] = { 506 0x4f, 0xf0, 0x00, 0x06 // mov al r6 0x0000 507 }; 508 const byte kInstruction_mov_al_r6_0x0001[] = { 509 0x4f, 0xf0, 0x01, 0x06 // mov al r6 0x0001 510 }; 511 const byte kInstruction_mov_al_r6_0x0002[] = { 512 0x4f, 0xf0, 0x02, 0x06 // mov al r6 0x0002 513 }; 514 const byte kInstruction_mov_al_r6_0x0020[] = { 515 0x4f, 0xf0, 0x20, 0x06 // mov al r6 0x0020 516 }; 517 const byte kInstruction_mov_al_r6_0x007d[] = { 518 0x4f, 0xf0, 0x7d, 0x06 // mov al r6 0x007d 519 }; 520 const byte kInstruction_mov_al_r6_0x007e[] = { 521 0x4f, 0xf0, 0x7e, 0x06 // mov al r6 0x007e 522 }; 523 const byte kInstruction_mov_al_r6_0x007f[] = { 524 0x4f, 0xf0, 0x7f, 0x06 // mov al r6 0x007f 525 }; 526 const byte kInstruction_mov_al_r6_0x7ffd[] = { 527 0x47, 0xf6, 0xfd, 0x76 // mov al r6 0x7ffd 528 }; 529 const byte kInstruction_mov_al_r6_0x7ffe[] = { 530 0x47, 0xf6, 0xfe, 0x76 // mov al r6 0x7ffe 531 }; 532 const byte kInstruction_mov_al_r6_0x7fff[] = { 533 0x47, 0xf6, 0xff, 0x76 // mov al r6 0x7fff 534 }; 535 const byte kInstruction_mov_al_r6_0x3333[] = { 536 0x43, 0xf2, 0x33, 0x36 // mov al r6 0x3333 537 }; 538 const byte kInstruction_mov_al_r6_0x5555[] = { 539 0x45, 0xf2, 0x55, 0x56 // mov al r6 0x5555 540 }; 541 const byte kInstruction_mov_al_r6_0xaaaa[] = { 542 0x4a, 0xf6, 0xaa, 0x26 // mov al r6 0xaaaa 543 }; 544 const byte kInstruction_mov_al_r6_0xcccc[] = { 545 0x4c, 0xf6, 0xcc, 0x46 // mov al r6 0xcccc 546 }; 547 const byte kInstruction_mov_al_r6_0x8000[] = { 548 0x4f, 0xf4, 0x00, 0x46 // mov al r6 0x8000 549 }; 550 const byte kInstruction_mov_al_r6_0x8001[] = { 551 0x48, 0xf2, 0x01, 0x06 // mov al r6 0x8001 552 }; 553 const byte kInstruction_mov_al_r6_0x8002[] = { 554 0x48, 0xf2, 0x02, 0x06 // mov al r6 0x8002 555 }; 556 const byte kInstruction_mov_al_r6_0x8003[] = { 557 0x48, 0xf2, 0x03, 0x06 // mov al r6 0x8003 558 }; 559 const byte kInstruction_mov_al_r6_0xff80[] = { 560 0x4f, 0xf6, 0x80, 0x76 // mov al r6 0xff80 561 }; 562 const byte kInstruction_mov_al_r6_0xff81[] = { 563 0x4f, 0xf6, 0x81, 0x76 // mov al r6 0xff81 564 }; 565 const byte kInstruction_mov_al_r6_0xff82[] = { 566 0x4f, 0xf6, 0x82, 0x76 // mov al r6 0xff82 567 }; 568 const byte kInstruction_mov_al_r6_0xff83[] = { 569 0x4f, 0xf6, 0x83, 0x76 // mov al r6 0xff83 570 }; 571 const byte kInstruction_mov_al_r6_0xffe0[] = { 572 0x4f, 0xf6, 0xe0, 0x76 // mov al r6 0xffe0 573 }; 574 const byte kInstruction_mov_al_r6_0xfffd[] = { 575 0x4f, 0xf6, 0xfd, 0x76 // mov al r6 0xfffd 576 }; 577 const byte kInstruction_mov_al_r6_0xfffe[] = { 578 0x4f, 0xf6, 0xfe, 0x76 // mov al r6 0xfffe 579 }; 580 const byte kInstruction_mov_al_r6_0xffff[] = { 581 0x4f, 0xf6, 0xff, 0x76 // mov al r6 0xffff 582 }; 583 const byte kInstruction_mov_al_r7_0x0000[] = { 584 0x4f, 0xf0, 0x00, 0x07 // mov al r7 0x0000 585 }; 586 const byte kInstruction_mov_al_r7_0x0001[] = { 587 0x4f, 0xf0, 0x01, 0x07 // mov al r7 0x0001 588 }; 589 const byte kInstruction_mov_al_r7_0x0002[] = { 590 0x4f, 0xf0, 0x02, 0x07 // mov al r7 0x0002 591 }; 592 const byte kInstruction_mov_al_r7_0x0020[] = { 593 0x4f, 0xf0, 0x20, 0x07 // mov al r7 0x0020 594 }; 595 const byte kInstruction_mov_al_r7_0x007d[] = { 596 0x4f, 0xf0, 0x7d, 0x07 // mov al r7 0x007d 597 }; 598 const byte kInstruction_mov_al_r7_0x007e[] = { 599 0x4f, 0xf0, 0x7e, 0x07 // mov al r7 0x007e 600 }; 601 const byte kInstruction_mov_al_r7_0x007f[] = { 602 0x4f, 0xf0, 0x7f, 0x07 // mov al r7 0x007f 603 }; 604 const byte kInstruction_mov_al_r7_0x7ffd[] = { 605 0x47, 0xf6, 0xfd, 0x77 // mov al r7 0x7ffd 606 }; 607 const byte kInstruction_mov_al_r7_0x7ffe[] = { 608 0x47, 0xf6, 0xfe, 0x77 // mov al r7 0x7ffe 609 }; 610 const byte kInstruction_mov_al_r7_0x7fff[] = { 611 0x47, 0xf6, 0xff, 0x77 // mov al r7 0x7fff 612 }; 613 const byte kInstruction_mov_al_r7_0x3333[] = { 614 0x43, 0xf2, 0x33, 0x37 // mov al r7 0x3333 615 }; 616 const byte kInstruction_mov_al_r7_0x5555[] = { 617 0x45, 0xf2, 0x55, 0x57 // mov al r7 0x5555 618 }; 619 const byte kInstruction_mov_al_r7_0xaaaa[] = { 620 0x4a, 0xf6, 0xaa, 0x27 // mov al r7 0xaaaa 621 }; 622 const byte kInstruction_mov_al_r7_0xcccc[] = { 623 0x4c, 0xf6, 0xcc, 0x47 // mov al r7 0xcccc 624 }; 625 const byte kInstruction_mov_al_r7_0x8000[] = { 626 0x4f, 0xf4, 0x00, 0x47 // mov al r7 0x8000 627 }; 628 const byte kInstruction_mov_al_r7_0x8001[] = { 629 0x48, 0xf2, 0x01, 0x07 // mov al r7 0x8001 630 }; 631 const byte kInstruction_mov_al_r7_0x8002[] = { 632 0x48, 0xf2, 0x02, 0x07 // mov al r7 0x8002 633 }; 634 const byte kInstruction_mov_al_r7_0x8003[] = { 635 0x48, 0xf2, 0x03, 0x07 // mov al r7 0x8003 636 }; 637 const byte kInstruction_mov_al_r7_0xff80[] = { 638 0x4f, 0xf6, 0x80, 0x77 // mov al r7 0xff80 639 }; 640 const byte kInstruction_mov_al_r7_0xff81[] = { 641 0x4f, 0xf6, 0x81, 0x77 // mov al r7 0xff81 642 }; 643 const byte kInstruction_mov_al_r7_0xff82[] = { 644 0x4f, 0xf6, 0x82, 0x77 // mov al r7 0xff82 645 }; 646 const byte kInstruction_mov_al_r7_0xff83[] = { 647 0x4f, 0xf6, 0x83, 0x77 // mov al r7 0xff83 648 }; 649 const byte kInstruction_mov_al_r7_0xffe0[] = { 650 0x4f, 0xf6, 0xe0, 0x77 // mov al r7 0xffe0 651 }; 652 const byte kInstruction_mov_al_r7_0xfffd[] = { 653 0x4f, 0xf6, 0xfd, 0x77 // mov al r7 0xfffd 654 }; 655 const byte kInstruction_mov_al_r7_0xfffe[] = { 656 0x4f, 0xf6, 0xfe, 0x77 // mov al r7 0xfffe 657 }; 658 const byte kInstruction_mov_al_r7_0xffff[] = { 659 0x4f, 0xf6, 0xff, 0x77 // mov al r7 0xffff 660 }; 661 const byte kInstruction_mov_al_r8_0x0000[] = { 662 0x4f, 0xf0, 0x00, 0x08 // mov al r8 0x0000 663 }; 664 const byte kInstruction_mov_al_r8_0x0001[] = { 665 0x4f, 0xf0, 0x01, 0x08 // mov al r8 0x0001 666 }; 667 const byte kInstruction_mov_al_r8_0x0002[] = { 668 0x4f, 0xf0, 0x02, 0x08 // mov al r8 0x0002 669 }; 670 const byte kInstruction_mov_al_r8_0x0020[] = { 671 0x4f, 0xf0, 0x20, 0x08 // mov al r8 0x0020 672 }; 673 const byte kInstruction_mov_al_r8_0x007d[] = { 674 0x4f, 0xf0, 0x7d, 0x08 // mov al r8 0x007d 675 }; 676 const byte kInstruction_mov_al_r8_0x007e[] = { 677 0x4f, 0xf0, 0x7e, 0x08 // mov al r8 0x007e 678 }; 679 const byte kInstruction_mov_al_r8_0x007f[] = { 680 0x4f, 0xf0, 0x7f, 0x08 // mov al r8 0x007f 681 }; 682 const byte kInstruction_mov_al_r8_0x7ffd[] = { 683 0x47, 0xf6, 0xfd, 0x78 // mov al r8 0x7ffd 684 }; 685 const byte kInstruction_mov_al_r8_0x7ffe[] = { 686 0x47, 0xf6, 0xfe, 0x78 // mov al r8 0x7ffe 687 }; 688 const byte kInstruction_mov_al_r8_0x7fff[] = { 689 0x47, 0xf6, 0xff, 0x78 // mov al r8 0x7fff 690 }; 691 const byte kInstruction_mov_al_r8_0x3333[] = { 692 0x43, 0xf2, 0x33, 0x38 // mov al r8 0x3333 693 }; 694 const byte kInstruction_mov_al_r8_0x5555[] = { 695 0x45, 0xf2, 0x55, 0x58 // mov al r8 0x5555 696 }; 697 const byte kInstruction_mov_al_r8_0xaaaa[] = { 698 0x4a, 0xf6, 0xaa, 0x28 // mov al r8 0xaaaa 699 }; 700 const byte kInstruction_mov_al_r8_0xcccc[] = { 701 0x4c, 0xf6, 0xcc, 0x48 // mov al r8 0xcccc 702 }; 703 const byte kInstruction_mov_al_r8_0x8000[] = { 704 0x4f, 0xf4, 0x00, 0x48 // mov al r8 0x8000 705 }; 706 const byte kInstruction_mov_al_r8_0x8001[] = { 707 0x48, 0xf2, 0x01, 0x08 // mov al r8 0x8001 708 }; 709 const byte kInstruction_mov_al_r8_0x8002[] = { 710 0x48, 0xf2, 0x02, 0x08 // mov al r8 0x8002 711 }; 712 const byte kInstruction_mov_al_r8_0x8003[] = { 713 0x48, 0xf2, 0x03, 0x08 // mov al r8 0x8003 714 }; 715 const byte kInstruction_mov_al_r8_0xff80[] = { 716 0x4f, 0xf6, 0x80, 0x78 // mov al r8 0xff80 717 }; 718 const byte kInstruction_mov_al_r8_0xff81[] = { 719 0x4f, 0xf6, 0x81, 0x78 // mov al r8 0xff81 720 }; 721 const byte kInstruction_mov_al_r8_0xff82[] = { 722 0x4f, 0xf6, 0x82, 0x78 // mov al r8 0xff82 723 }; 724 const byte kInstruction_mov_al_r8_0xff83[] = { 725 0x4f, 0xf6, 0x83, 0x78 // mov al r8 0xff83 726 }; 727 const byte kInstruction_mov_al_r8_0xffe0[] = { 728 0x4f, 0xf6, 0xe0, 0x78 // mov al r8 0xffe0 729 }; 730 const byte kInstruction_mov_al_r8_0xfffd[] = { 731 0x4f, 0xf6, 0xfd, 0x78 // mov al r8 0xfffd 732 }; 733 const byte kInstruction_mov_al_r8_0xfffe[] = { 734 0x4f, 0xf6, 0xfe, 0x78 // mov al r8 0xfffe 735 }; 736 const byte kInstruction_mov_al_r8_0xffff[] = { 737 0x4f, 0xf6, 0xff, 0x78 // mov al r8 0xffff 738 }; 739 const byte kInstruction_mov_al_r9_0x0000[] = { 740 0x4f, 0xf0, 0x00, 0x09 // mov al r9 0x0000 741 }; 742 const byte kInstruction_mov_al_r9_0x0001[] = { 743 0x4f, 0xf0, 0x01, 0x09 // mov al r9 0x0001 744 }; 745 const byte kInstruction_mov_al_r9_0x0002[] = { 746 0x4f, 0xf0, 0x02, 0x09 // mov al r9 0x0002 747 }; 748 const byte kInstruction_mov_al_r9_0x0020[] = { 749 0x4f, 0xf0, 0x20, 0x09 // mov al r9 0x0020 750 }; 751 const byte kInstruction_mov_al_r9_0x007d[] = { 752 0x4f, 0xf0, 0x7d, 0x09 // mov al r9 0x007d 753 }; 754 const byte kInstruction_mov_al_r9_0x007e[] = { 755 0x4f, 0xf0, 0x7e, 0x09 // mov al r9 0x007e 756 }; 757 const byte kInstruction_mov_al_r9_0x007f[] = { 758 0x4f, 0xf0, 0x7f, 0x09 // mov al r9 0x007f 759 }; 760 const byte kInstruction_mov_al_r9_0x7ffd[] = { 761 0x47, 0xf6, 0xfd, 0x79 // mov al r9 0x7ffd 762 }; 763 const byte kInstruction_mov_al_r9_0x7ffe[] = { 764 0x47, 0xf6, 0xfe, 0x79 // mov al r9 0x7ffe 765 }; 766 const byte kInstruction_mov_al_r9_0x7fff[] = { 767 0x47, 0xf6, 0xff, 0x79 // mov al r9 0x7fff 768 }; 769 const byte kInstruction_mov_al_r9_0x3333[] = { 770 0x43, 0xf2, 0x33, 0x39 // mov al r9 0x3333 771 }; 772 const byte kInstruction_mov_al_r9_0x5555[] = { 773 0x45, 0xf2, 0x55, 0x59 // mov al r9 0x5555 774 }; 775 const byte kInstruction_mov_al_r9_0xaaaa[] = { 776 0x4a, 0xf6, 0xaa, 0x29 // mov al r9 0xaaaa 777 }; 778 const byte kInstruction_mov_al_r9_0xcccc[] = { 779 0x4c, 0xf6, 0xcc, 0x49 // mov al r9 0xcccc 780 }; 781 const byte kInstruction_mov_al_r9_0x8000[] = { 782 0x4f, 0xf4, 0x00, 0x49 // mov al r9 0x8000 783 }; 784 const byte kInstruction_mov_al_r9_0x8001[] = { 785 0x48, 0xf2, 0x01, 0x09 // mov al r9 0x8001 786 }; 787 const byte kInstruction_mov_al_r9_0x8002[] = { 788 0x48, 0xf2, 0x02, 0x09 // mov al r9 0x8002 789 }; 790 const byte kInstruction_mov_al_r9_0x8003[] = { 791 0x48, 0xf2, 0x03, 0x09 // mov al r9 0x8003 792 }; 793 const byte kInstruction_mov_al_r9_0xff80[] = { 794 0x4f, 0xf6, 0x80, 0x79 // mov al r9 0xff80 795 }; 796 const byte kInstruction_mov_al_r9_0xff81[] = { 797 0x4f, 0xf6, 0x81, 0x79 // mov al r9 0xff81 798 }; 799 const byte kInstruction_mov_al_r9_0xff82[] = { 800 0x4f, 0xf6, 0x82, 0x79 // mov al r9 0xff82 801 }; 802 const byte kInstruction_mov_al_r9_0xff83[] = { 803 0x4f, 0xf6, 0x83, 0x79 // mov al r9 0xff83 804 }; 805 const byte kInstruction_mov_al_r9_0xffe0[] = { 806 0x4f, 0xf6, 0xe0, 0x79 // mov al r9 0xffe0 807 }; 808 const byte kInstruction_mov_al_r9_0xfffd[] = { 809 0x4f, 0xf6, 0xfd, 0x79 // mov al r9 0xfffd 810 }; 811 const byte kInstruction_mov_al_r9_0xfffe[] = { 812 0x4f, 0xf6, 0xfe, 0x79 // mov al r9 0xfffe 813 }; 814 const byte kInstruction_mov_al_r9_0xffff[] = { 815 0x4f, 0xf6, 0xff, 0x79 // mov al r9 0xffff 816 }; 817 const byte kInstruction_mov_al_r10_0x0000[] = { 818 0x4f, 0xf0, 0x00, 0x0a // mov al r10 0x0000 819 }; 820 const byte kInstruction_mov_al_r10_0x0001[] = { 821 0x4f, 0xf0, 0x01, 0x0a // mov al r10 0x0001 822 }; 823 const byte kInstruction_mov_al_r10_0x0002[] = { 824 0x4f, 0xf0, 0x02, 0x0a // mov al r10 0x0002 825 }; 826 const byte kInstruction_mov_al_r10_0x0020[] = { 827 0x4f, 0xf0, 0x20, 0x0a // mov al r10 0x0020 828 }; 829 const byte kInstruction_mov_al_r10_0x007d[] = { 830 0x4f, 0xf0, 0x7d, 0x0a // mov al r10 0x007d 831 }; 832 const byte kInstruction_mov_al_r10_0x007e[] = { 833 0x4f, 0xf0, 0x7e, 0x0a // mov al r10 0x007e 834 }; 835 const byte kInstruction_mov_al_r10_0x007f[] = { 836 0x4f, 0xf0, 0x7f, 0x0a // mov al r10 0x007f 837 }; 838 const byte kInstruction_mov_al_r10_0x7ffd[] = { 839 0x47, 0xf6, 0xfd, 0x7a // mov al r10 0x7ffd 840 }; 841 const byte kInstruction_mov_al_r10_0x7ffe[] = { 842 0x47, 0xf6, 0xfe, 0x7a // mov al r10 0x7ffe 843 }; 844 const byte kInstruction_mov_al_r10_0x7fff[] = { 845 0x47, 0xf6, 0xff, 0x7a // mov al r10 0x7fff 846 }; 847 const byte kInstruction_mov_al_r10_0x3333[] = { 848 0x43, 0xf2, 0x33, 0x3a // mov al r10 0x3333 849 }; 850 const byte kInstruction_mov_al_r10_0x5555[] = { 851 0x45, 0xf2, 0x55, 0x5a // mov al r10 0x5555 852 }; 853 const byte kInstruction_mov_al_r10_0xaaaa[] = { 854 0x4a, 0xf6, 0xaa, 0x2a // mov al r10 0xaaaa 855 }; 856 const byte kInstruction_mov_al_r10_0xcccc[] = { 857 0x4c, 0xf6, 0xcc, 0x4a // mov al r10 0xcccc 858 }; 859 const byte kInstruction_mov_al_r10_0x8000[] = { 860 0x4f, 0xf4, 0x00, 0x4a // mov al r10 0x8000 861 }; 862 const byte kInstruction_mov_al_r10_0x8001[] = { 863 0x48, 0xf2, 0x01, 0x0a // mov al r10 0x8001 864 }; 865 const byte kInstruction_mov_al_r10_0x8002[] = { 866 0x48, 0xf2, 0x02, 0x0a // mov al r10 0x8002 867 }; 868 const byte kInstruction_mov_al_r10_0x8003[] = { 869 0x48, 0xf2, 0x03, 0x0a // mov al r10 0x8003 870 }; 871 const byte kInstruction_mov_al_r10_0xff80[] = { 872 0x4f, 0xf6, 0x80, 0x7a // mov al r10 0xff80 873 }; 874 const byte kInstruction_mov_al_r10_0xff81[] = { 875 0x4f, 0xf6, 0x81, 0x7a // mov al r10 0xff81 876 }; 877 const byte kInstruction_mov_al_r10_0xff82[] = { 878 0x4f, 0xf6, 0x82, 0x7a // mov al r10 0xff82 879 }; 880 const byte kInstruction_mov_al_r10_0xff83[] = { 881 0x4f, 0xf6, 0x83, 0x7a // mov al r10 0xff83 882 }; 883 const byte kInstruction_mov_al_r10_0xffe0[] = { 884 0x4f, 0xf6, 0xe0, 0x7a // mov al r10 0xffe0 885 }; 886 const byte kInstruction_mov_al_r10_0xfffd[] = { 887 0x4f, 0xf6, 0xfd, 0x7a // mov al r10 0xfffd 888 }; 889 const byte kInstruction_mov_al_r10_0xfffe[] = { 890 0x4f, 0xf6, 0xfe, 0x7a // mov al r10 0xfffe 891 }; 892 const byte kInstruction_mov_al_r10_0xffff[] = { 893 0x4f, 0xf6, 0xff, 0x7a // mov al r10 0xffff 894 }; 895 const byte kInstruction_mov_al_r11_0x0000[] = { 896 0x4f, 0xf0, 0x00, 0x0b // mov al r11 0x0000 897 }; 898 const byte kInstruction_mov_al_r11_0x0001[] = { 899 0x4f, 0xf0, 0x01, 0x0b // mov al r11 0x0001 900 }; 901 const byte kInstruction_mov_al_r11_0x0002[] = { 902 0x4f, 0xf0, 0x02, 0x0b // mov al r11 0x0002 903 }; 904 const byte kInstruction_mov_al_r11_0x0020[] = { 905 0x4f, 0xf0, 0x20, 0x0b // mov al r11 0x0020 906 }; 907 const byte kInstruction_mov_al_r11_0x007d[] = { 908 0x4f, 0xf0, 0x7d, 0x0b // mov al r11 0x007d 909 }; 910 const byte kInstruction_mov_al_r11_0x007e[] = { 911 0x4f, 0xf0, 0x7e, 0x0b // mov al r11 0x007e 912 }; 913 const byte kInstruction_mov_al_r11_0x007f[] = { 914 0x4f, 0xf0, 0x7f, 0x0b // mov al r11 0x007f 915 }; 916 const byte kInstruction_mov_al_r11_0x7ffd[] = { 917 0x47, 0xf6, 0xfd, 0x7b // mov al r11 0x7ffd 918 }; 919 const byte kInstruction_mov_al_r11_0x7ffe[] = { 920 0x47, 0xf6, 0xfe, 0x7b // mov al r11 0x7ffe 921 }; 922 const byte kInstruction_mov_al_r11_0x7fff[] = { 923 0x47, 0xf6, 0xff, 0x7b // mov al r11 0x7fff 924 }; 925 const byte kInstruction_mov_al_r11_0x3333[] = { 926 0x43, 0xf2, 0x33, 0x3b // mov al r11 0x3333 927 }; 928 const byte kInstruction_mov_al_r11_0x5555[] = { 929 0x45, 0xf2, 0x55, 0x5b // mov al r11 0x5555 930 }; 931 const byte kInstruction_mov_al_r11_0xaaaa[] = { 932 0x4a, 0xf6, 0xaa, 0x2b // mov al r11 0xaaaa 933 }; 934 const byte kInstruction_mov_al_r11_0xcccc[] = { 935 0x4c, 0xf6, 0xcc, 0x4b // mov al r11 0xcccc 936 }; 937 const byte kInstruction_mov_al_r11_0x8000[] = { 938 0x4f, 0xf4, 0x00, 0x4b // mov al r11 0x8000 939 }; 940 const byte kInstruction_mov_al_r11_0x8001[] = { 941 0x48, 0xf2, 0x01, 0x0b // mov al r11 0x8001 942 }; 943 const byte kInstruction_mov_al_r11_0x8002[] = { 944 0x48, 0xf2, 0x02, 0x0b // mov al r11 0x8002 945 }; 946 const byte kInstruction_mov_al_r11_0x8003[] = { 947 0x48, 0xf2, 0x03, 0x0b // mov al r11 0x8003 948 }; 949 const byte kInstruction_mov_al_r11_0xff80[] = { 950 0x4f, 0xf6, 0x80, 0x7b // mov al r11 0xff80 951 }; 952 const byte kInstruction_mov_al_r11_0xff81[] = { 953 0x4f, 0xf6, 0x81, 0x7b // mov al r11 0xff81 954 }; 955 const byte kInstruction_mov_al_r11_0xff82[] = { 956 0x4f, 0xf6, 0x82, 0x7b // mov al r11 0xff82 957 }; 958 const byte kInstruction_mov_al_r11_0xff83[] = { 959 0x4f, 0xf6, 0x83, 0x7b // mov al r11 0xff83 960 }; 961 const byte kInstruction_mov_al_r11_0xffe0[] = { 962 0x4f, 0xf6, 0xe0, 0x7b // mov al r11 0xffe0 963 }; 964 const byte kInstruction_mov_al_r11_0xfffd[] = { 965 0x4f, 0xf6, 0xfd, 0x7b // mov al r11 0xfffd 966 }; 967 const byte kInstruction_mov_al_r11_0xfffe[] = { 968 0x4f, 0xf6, 0xfe, 0x7b // mov al r11 0xfffe 969 }; 970 const byte kInstruction_mov_al_r11_0xffff[] = { 971 0x4f, 0xf6, 0xff, 0x7b // mov al r11 0xffff 972 }; 973 const byte kInstruction_mov_al_r12_0x0000[] = { 974 0x4f, 0xf0, 0x00, 0x0c // mov al r12 0x0000 975 }; 976 const byte kInstruction_mov_al_r12_0x0001[] = { 977 0x4f, 0xf0, 0x01, 0x0c // mov al r12 0x0001 978 }; 979 const byte kInstruction_mov_al_r12_0x0002[] = { 980 0x4f, 0xf0, 0x02, 0x0c // mov al r12 0x0002 981 }; 982 const byte kInstruction_mov_al_r12_0x0020[] = { 983 0x4f, 0xf0, 0x20, 0x0c // mov al r12 0x0020 984 }; 985 const byte kInstruction_mov_al_r12_0x007d[] = { 986 0x4f, 0xf0, 0x7d, 0x0c // mov al r12 0x007d 987 }; 988 const byte kInstruction_mov_al_r12_0x007e[] = { 989 0x4f, 0xf0, 0x7e, 0x0c // mov al r12 0x007e 990 }; 991 const byte kInstruction_mov_al_r12_0x007f[] = { 992 0x4f, 0xf0, 0x7f, 0x0c // mov al r12 0x007f 993 }; 994 const byte kInstruction_mov_al_r12_0x7ffd[] = { 995 0x47, 0xf6, 0xfd, 0x7c // mov al r12 0x7ffd 996 }; 997 const byte kInstruction_mov_al_r12_0x7ffe[] = { 998 0x47, 0xf6, 0xfe, 0x7c // mov al r12 0x7ffe 999 }; 1000 const byte kInstruction_mov_al_r12_0x7fff[] = { 1001 0x47, 0xf6, 0xff, 0x7c // mov al r12 0x7fff 1002 }; 1003 const byte kInstruction_mov_al_r12_0x3333[] = { 1004 0x43, 0xf2, 0x33, 0x3c // mov al r12 0x3333 1005 }; 1006 const byte kInstruction_mov_al_r12_0x5555[] = { 1007 0x45, 0xf2, 0x55, 0x5c // mov al r12 0x5555 1008 }; 1009 const byte kInstruction_mov_al_r12_0xaaaa[] = { 1010 0x4a, 0xf6, 0xaa, 0x2c // mov al r12 0xaaaa 1011 }; 1012 const byte kInstruction_mov_al_r12_0xcccc[] = { 1013 0x4c, 0xf6, 0xcc, 0x4c // mov al r12 0xcccc 1014 }; 1015 const byte kInstruction_mov_al_r12_0x8000[] = { 1016 0x4f, 0xf4, 0x00, 0x4c // mov al r12 0x8000 1017 }; 1018 const byte kInstruction_mov_al_r12_0x8001[] = { 1019 0x48, 0xf2, 0x01, 0x0c // mov al r12 0x8001 1020 }; 1021 const byte kInstruction_mov_al_r12_0x8002[] = { 1022 0x48, 0xf2, 0x02, 0x0c // mov al r12 0x8002 1023 }; 1024 const byte kInstruction_mov_al_r12_0x8003[] = { 1025 0x48, 0xf2, 0x03, 0x0c // mov al r12 0x8003 1026 }; 1027 const byte kInstruction_mov_al_r12_0xff80[] = { 1028 0x4f, 0xf6, 0x80, 0x7c // mov al r12 0xff80 1029 }; 1030 const byte kInstruction_mov_al_r12_0xff81[] = { 1031 0x4f, 0xf6, 0x81, 0x7c // mov al r12 0xff81 1032 }; 1033 const byte kInstruction_mov_al_r12_0xff82[] = { 1034 0x4f, 0xf6, 0x82, 0x7c // mov al r12 0xff82 1035 }; 1036 const byte kInstruction_mov_al_r12_0xff83[] = { 1037 0x4f, 0xf6, 0x83, 0x7c // mov al r12 0xff83 1038 }; 1039 const byte kInstruction_mov_al_r12_0xffe0[] = { 1040 0x4f, 0xf6, 0xe0, 0x7c // mov al r12 0xffe0 1041 }; 1042 const byte kInstruction_mov_al_r12_0xfffd[] = { 1043 0x4f, 0xf6, 0xfd, 0x7c // mov al r12 0xfffd 1044 }; 1045 const byte kInstruction_mov_al_r12_0xfffe[] = { 1046 0x4f, 0xf6, 0xfe, 0x7c // mov al r12 0xfffe 1047 }; 1048 const byte kInstruction_mov_al_r12_0xffff[] = { 1049 0x4f, 0xf6, 0xff, 0x7c // mov al r12 0xffff 1050 }; 1051 const byte kInstruction_mov_al_r13_0x0000[] = { 1052 0x4f, 0xf0, 0x00, 0x0d // mov al r13 0x0000 1053 }; 1054 const byte kInstruction_mov_al_r13_0x0001[] = { 1055 0x4f, 0xf0, 0x01, 0x0d // mov al r13 0x0001 1056 }; 1057 const byte kInstruction_mov_al_r13_0x0002[] = { 1058 0x4f, 0xf0, 0x02, 0x0d // mov al r13 0x0002 1059 }; 1060 const byte kInstruction_mov_al_r13_0x0020[] = { 1061 0x4f, 0xf0, 0x20, 0x0d // mov al r13 0x0020 1062 }; 1063 const byte kInstruction_mov_al_r13_0x007d[] = { 1064 0x4f, 0xf0, 0x7d, 0x0d // mov al r13 0x007d 1065 }; 1066 const byte kInstruction_mov_al_r13_0x007e[] = { 1067 0x4f, 0xf0, 0x7e, 0x0d // mov al r13 0x007e 1068 }; 1069 const byte kInstruction_mov_al_r13_0x007f[] = { 1070 0x4f, 0xf0, 0x7f, 0x0d // mov al r13 0x007f 1071 }; 1072 const byte kInstruction_mov_al_r13_0x7ffd[] = { 1073 0x47, 0xf6, 0xfd, 0x7d // mov al r13 0x7ffd 1074 }; 1075 const byte kInstruction_mov_al_r13_0x7ffe[] = { 1076 0x47, 0xf6, 0xfe, 0x7d // mov al r13 0x7ffe 1077 }; 1078 const byte kInstruction_mov_al_r13_0x7fff[] = { 1079 0x47, 0xf6, 0xff, 0x7d // mov al r13 0x7fff 1080 }; 1081 const byte kInstruction_mov_al_r13_0x3333[] = { 1082 0x43, 0xf2, 0x33, 0x3d // mov al r13 0x3333 1083 }; 1084 const byte kInstruction_mov_al_r13_0x5555[] = { 1085 0x45, 0xf2, 0x55, 0x5d // mov al r13 0x5555 1086 }; 1087 const byte kInstruction_mov_al_r13_0xaaaa[] = { 1088 0x4a, 0xf6, 0xaa, 0x2d // mov al r13 0xaaaa 1089 }; 1090 const byte kInstruction_mov_al_r13_0xcccc[] = { 1091 0x4c, 0xf6, 0xcc, 0x4d // mov al r13 0xcccc 1092 }; 1093 const byte kInstruction_mov_al_r13_0x8000[] = { 1094 0x4f, 0xf4, 0x00, 0x4d // mov al r13 0x8000 1095 }; 1096 const byte kInstruction_mov_al_r13_0x8001[] = { 1097 0x48, 0xf2, 0x01, 0x0d // mov al r13 0x8001 1098 }; 1099 const byte kInstruction_mov_al_r13_0x8002[] = { 1100 0x48, 0xf2, 0x02, 0x0d // mov al r13 0x8002 1101 }; 1102 const byte kInstruction_mov_al_r13_0x8003[] = { 1103 0x48, 0xf2, 0x03, 0x0d // mov al r13 0x8003 1104 }; 1105 const byte kInstruction_mov_al_r13_0xff80[] = { 1106 0x4f, 0xf6, 0x80, 0x7d // mov al r13 0xff80 1107 }; 1108 const byte kInstruction_mov_al_r13_0xff81[] = { 1109 0x4f, 0xf6, 0x81, 0x7d // mov al r13 0xff81 1110 }; 1111 const byte kInstruction_mov_al_r13_0xff82[] = { 1112 0x4f, 0xf6, 0x82, 0x7d // mov al r13 0xff82 1113 }; 1114 const byte kInstruction_mov_al_r13_0xff83[] = { 1115 0x4f, 0xf6, 0x83, 0x7d // mov al r13 0xff83 1116 }; 1117 const byte kInstruction_mov_al_r13_0xffe0[] = { 1118 0x4f, 0xf6, 0xe0, 0x7d // mov al r13 0xffe0 1119 }; 1120 const byte kInstruction_mov_al_r13_0xfffd[] = { 1121 0x4f, 0xf6, 0xfd, 0x7d // mov al r13 0xfffd 1122 }; 1123 const byte kInstruction_mov_al_r13_0xfffe[] = { 1124 0x4f, 0xf6, 0xfe, 0x7d // mov al r13 0xfffe 1125 }; 1126 const byte kInstruction_mov_al_r13_0xffff[] = { 1127 0x4f, 0xf6, 0xff, 0x7d // mov al r13 0xffff 1128 }; 1129 const byte kInstruction_mov_al_r14_0x0000[] = { 1130 0x4f, 0xf0, 0x00, 0x0e // mov al r14 0x0000 1131 }; 1132 const byte kInstruction_mov_al_r14_0x0001[] = { 1133 0x4f, 0xf0, 0x01, 0x0e // mov al r14 0x0001 1134 }; 1135 const byte kInstruction_mov_al_r14_0x0002[] = { 1136 0x4f, 0xf0, 0x02, 0x0e // mov al r14 0x0002 1137 }; 1138 const byte kInstruction_mov_al_r14_0x0020[] = { 1139 0x4f, 0xf0, 0x20, 0x0e // mov al r14 0x0020 1140 }; 1141 const byte kInstruction_mov_al_r14_0x007d[] = { 1142 0x4f, 0xf0, 0x7d, 0x0e // mov al r14 0x007d 1143 }; 1144 const byte kInstruction_mov_al_r14_0x007e[] = { 1145 0x4f, 0xf0, 0x7e, 0x0e // mov al r14 0x007e 1146 }; 1147 const byte kInstruction_mov_al_r14_0x007f[] = { 1148 0x4f, 0xf0, 0x7f, 0x0e // mov al r14 0x007f 1149 }; 1150 const byte kInstruction_mov_al_r14_0x7ffd[] = { 1151 0x47, 0xf6, 0xfd, 0x7e // mov al r14 0x7ffd 1152 }; 1153 const byte kInstruction_mov_al_r14_0x7ffe[] = { 1154 0x47, 0xf6, 0xfe, 0x7e // mov al r14 0x7ffe 1155 }; 1156 const byte kInstruction_mov_al_r14_0x7fff[] = { 1157 0x47, 0xf6, 0xff, 0x7e // mov al r14 0x7fff 1158 }; 1159 const byte kInstruction_mov_al_r14_0x3333[] = { 1160 0x43, 0xf2, 0x33, 0x3e // mov al r14 0x3333 1161 }; 1162 const byte kInstruction_mov_al_r14_0x5555[] = { 1163 0x45, 0xf2, 0x55, 0x5e // mov al r14 0x5555 1164 }; 1165 const byte kInstruction_mov_al_r14_0xaaaa[] = { 1166 0x4a, 0xf6, 0xaa, 0x2e // mov al r14 0xaaaa 1167 }; 1168 const byte kInstruction_mov_al_r14_0xcccc[] = { 1169 0x4c, 0xf6, 0xcc, 0x4e // mov al r14 0xcccc 1170 }; 1171 const byte kInstruction_mov_al_r14_0x8000[] = { 1172 0x4f, 0xf4, 0x00, 0x4e // mov al r14 0x8000 1173 }; 1174 const byte kInstruction_mov_al_r14_0x8001[] = { 1175 0x48, 0xf2, 0x01, 0x0e // mov al r14 0x8001 1176 }; 1177 const byte kInstruction_mov_al_r14_0x8002[] = { 1178 0x48, 0xf2, 0x02, 0x0e // mov al r14 0x8002 1179 }; 1180 const byte kInstruction_mov_al_r14_0x8003[] = { 1181 0x48, 0xf2, 0x03, 0x0e // mov al r14 0x8003 1182 }; 1183 const byte kInstruction_mov_al_r14_0xff80[] = { 1184 0x4f, 0xf6, 0x80, 0x7e // mov al r14 0xff80 1185 }; 1186 const byte kInstruction_mov_al_r14_0xff81[] = { 1187 0x4f, 0xf6, 0x81, 0x7e // mov al r14 0xff81 1188 }; 1189 const byte kInstruction_mov_al_r14_0xff82[] = { 1190 0x4f, 0xf6, 0x82, 0x7e // mov al r14 0xff82 1191 }; 1192 const byte kInstruction_mov_al_r14_0xff83[] = { 1193 0x4f, 0xf6, 0x83, 0x7e // mov al r14 0xff83 1194 }; 1195 const byte kInstruction_mov_al_r14_0xffe0[] = { 1196 0x4f, 0xf6, 0xe0, 0x7e // mov al r14 0xffe0 1197 }; 1198 const byte kInstruction_mov_al_r14_0xfffd[] = { 1199 0x4f, 0xf6, 0xfd, 0x7e // mov al r14 0xfffd 1200 }; 1201 const byte kInstruction_mov_al_r14_0xfffe[] = { 1202 0x4f, 0xf6, 0xfe, 0x7e // mov al r14 0xfffe 1203 }; 1204 const byte kInstruction_mov_al_r14_0xffff[] = { 1205 0x4f, 0xf6, 0xff, 0x7e // mov al r14 0xffff 1206 }; 1207 const TestResult kReferencemov[] = { 1208 { 1209 ARRAY_SIZE(kInstruction_mov_al_r0_0x0000), 1210 kInstruction_mov_al_r0_0x0000, 1211 }, 1212 { 1213 ARRAY_SIZE(kInstruction_mov_al_r0_0x0001), 1214 kInstruction_mov_al_r0_0x0001, 1215 }, 1216 { 1217 ARRAY_SIZE(kInstruction_mov_al_r0_0x0002), 1218 kInstruction_mov_al_r0_0x0002, 1219 }, 1220 { 1221 ARRAY_SIZE(kInstruction_mov_al_r0_0x0020), 1222 kInstruction_mov_al_r0_0x0020, 1223 }, 1224 { 1225 ARRAY_SIZE(kInstruction_mov_al_r0_0x007d), 1226 kInstruction_mov_al_r0_0x007d, 1227 }, 1228 { 1229 ARRAY_SIZE(kInstruction_mov_al_r0_0x007e), 1230 kInstruction_mov_al_r0_0x007e, 1231 }, 1232 { 1233 ARRAY_SIZE(kInstruction_mov_al_r0_0x007f), 1234 kInstruction_mov_al_r0_0x007f, 1235 }, 1236 { 1237 ARRAY_SIZE(kInstruction_mov_al_r0_0x7ffd), 1238 kInstruction_mov_al_r0_0x7ffd, 1239 }, 1240 { 1241 ARRAY_SIZE(kInstruction_mov_al_r0_0x7ffe), 1242 kInstruction_mov_al_r0_0x7ffe, 1243 }, 1244 { 1245 ARRAY_SIZE(kInstruction_mov_al_r0_0x7fff), 1246 kInstruction_mov_al_r0_0x7fff, 1247 }, 1248 { 1249 ARRAY_SIZE(kInstruction_mov_al_r0_0x3333), 1250 kInstruction_mov_al_r0_0x3333, 1251 }, 1252 { 1253 ARRAY_SIZE(kInstruction_mov_al_r0_0x5555), 1254 kInstruction_mov_al_r0_0x5555, 1255 }, 1256 { 1257 ARRAY_SIZE(kInstruction_mov_al_r0_0xaaaa), 1258 kInstruction_mov_al_r0_0xaaaa, 1259 }, 1260 { 1261 ARRAY_SIZE(kInstruction_mov_al_r0_0xcccc), 1262 kInstruction_mov_al_r0_0xcccc, 1263 }, 1264 { 1265 ARRAY_SIZE(kInstruction_mov_al_r0_0x8000), 1266 kInstruction_mov_al_r0_0x8000, 1267 }, 1268 { 1269 ARRAY_SIZE(kInstruction_mov_al_r0_0x8001), 1270 kInstruction_mov_al_r0_0x8001, 1271 }, 1272 { 1273 ARRAY_SIZE(kInstruction_mov_al_r0_0x8002), 1274 kInstruction_mov_al_r0_0x8002, 1275 }, 1276 { 1277 ARRAY_SIZE(kInstruction_mov_al_r0_0x8003), 1278 kInstruction_mov_al_r0_0x8003, 1279 }, 1280 { 1281 ARRAY_SIZE(kInstruction_mov_al_r0_0xff80), 1282 kInstruction_mov_al_r0_0xff80, 1283 }, 1284 { 1285 ARRAY_SIZE(kInstruction_mov_al_r0_0xff81), 1286 kInstruction_mov_al_r0_0xff81, 1287 }, 1288 { 1289 ARRAY_SIZE(kInstruction_mov_al_r0_0xff82), 1290 kInstruction_mov_al_r0_0xff82, 1291 }, 1292 { 1293 ARRAY_SIZE(kInstruction_mov_al_r0_0xff83), 1294 kInstruction_mov_al_r0_0xff83, 1295 }, 1296 { 1297 ARRAY_SIZE(kInstruction_mov_al_r0_0xffe0), 1298 kInstruction_mov_al_r0_0xffe0, 1299 }, 1300 { 1301 ARRAY_SIZE(kInstruction_mov_al_r0_0xfffd), 1302 kInstruction_mov_al_r0_0xfffd, 1303 }, 1304 { 1305 ARRAY_SIZE(kInstruction_mov_al_r0_0xfffe), 1306 kInstruction_mov_al_r0_0xfffe, 1307 }, 1308 { 1309 ARRAY_SIZE(kInstruction_mov_al_r0_0xffff), 1310 kInstruction_mov_al_r0_0xffff, 1311 }, 1312 { 1313 ARRAY_SIZE(kInstruction_mov_al_r1_0x0000), 1314 kInstruction_mov_al_r1_0x0000, 1315 }, 1316 { 1317 ARRAY_SIZE(kInstruction_mov_al_r1_0x0001), 1318 kInstruction_mov_al_r1_0x0001, 1319 }, 1320 { 1321 ARRAY_SIZE(kInstruction_mov_al_r1_0x0002), 1322 kInstruction_mov_al_r1_0x0002, 1323 }, 1324 { 1325 ARRAY_SIZE(kInstruction_mov_al_r1_0x0020), 1326 kInstruction_mov_al_r1_0x0020, 1327 }, 1328 { 1329 ARRAY_SIZE(kInstruction_mov_al_r1_0x007d), 1330 kInstruction_mov_al_r1_0x007d, 1331 }, 1332 { 1333 ARRAY_SIZE(kInstruction_mov_al_r1_0x007e), 1334 kInstruction_mov_al_r1_0x007e, 1335 }, 1336 { 1337 ARRAY_SIZE(kInstruction_mov_al_r1_0x007f), 1338 kInstruction_mov_al_r1_0x007f, 1339 }, 1340 { 1341 ARRAY_SIZE(kInstruction_mov_al_r1_0x7ffd), 1342 kInstruction_mov_al_r1_0x7ffd, 1343 }, 1344 { 1345 ARRAY_SIZE(kInstruction_mov_al_r1_0x7ffe), 1346 kInstruction_mov_al_r1_0x7ffe, 1347 }, 1348 { 1349 ARRAY_SIZE(kInstruction_mov_al_r1_0x7fff), 1350 kInstruction_mov_al_r1_0x7fff, 1351 }, 1352 { 1353 ARRAY_SIZE(kInstruction_mov_al_r1_0x3333), 1354 kInstruction_mov_al_r1_0x3333, 1355 }, 1356 { 1357 ARRAY_SIZE(kInstruction_mov_al_r1_0x5555), 1358 kInstruction_mov_al_r1_0x5555, 1359 }, 1360 { 1361 ARRAY_SIZE(kInstruction_mov_al_r1_0xaaaa), 1362 kInstruction_mov_al_r1_0xaaaa, 1363 }, 1364 { 1365 ARRAY_SIZE(kInstruction_mov_al_r1_0xcccc), 1366 kInstruction_mov_al_r1_0xcccc, 1367 }, 1368 { 1369 ARRAY_SIZE(kInstruction_mov_al_r1_0x8000), 1370 kInstruction_mov_al_r1_0x8000, 1371 }, 1372 { 1373 ARRAY_SIZE(kInstruction_mov_al_r1_0x8001), 1374 kInstruction_mov_al_r1_0x8001, 1375 }, 1376 { 1377 ARRAY_SIZE(kInstruction_mov_al_r1_0x8002), 1378 kInstruction_mov_al_r1_0x8002, 1379 }, 1380 { 1381 ARRAY_SIZE(kInstruction_mov_al_r1_0x8003), 1382 kInstruction_mov_al_r1_0x8003, 1383 }, 1384 { 1385 ARRAY_SIZE(kInstruction_mov_al_r1_0xff80), 1386 kInstruction_mov_al_r1_0xff80, 1387 }, 1388 { 1389 ARRAY_SIZE(kInstruction_mov_al_r1_0xff81), 1390 kInstruction_mov_al_r1_0xff81, 1391 }, 1392 { 1393 ARRAY_SIZE(kInstruction_mov_al_r1_0xff82), 1394 kInstruction_mov_al_r1_0xff82, 1395 }, 1396 { 1397 ARRAY_SIZE(kInstruction_mov_al_r1_0xff83), 1398 kInstruction_mov_al_r1_0xff83, 1399 }, 1400 { 1401 ARRAY_SIZE(kInstruction_mov_al_r1_0xffe0), 1402 kInstruction_mov_al_r1_0xffe0, 1403 }, 1404 { 1405 ARRAY_SIZE(kInstruction_mov_al_r1_0xfffd), 1406 kInstruction_mov_al_r1_0xfffd, 1407 }, 1408 { 1409 ARRAY_SIZE(kInstruction_mov_al_r1_0xfffe), 1410 kInstruction_mov_al_r1_0xfffe, 1411 }, 1412 { 1413 ARRAY_SIZE(kInstruction_mov_al_r1_0xffff), 1414 kInstruction_mov_al_r1_0xffff, 1415 }, 1416 { 1417 ARRAY_SIZE(kInstruction_mov_al_r2_0x0000), 1418 kInstruction_mov_al_r2_0x0000, 1419 }, 1420 { 1421 ARRAY_SIZE(kInstruction_mov_al_r2_0x0001), 1422 kInstruction_mov_al_r2_0x0001, 1423 }, 1424 { 1425 ARRAY_SIZE(kInstruction_mov_al_r2_0x0002), 1426 kInstruction_mov_al_r2_0x0002, 1427 }, 1428 { 1429 ARRAY_SIZE(kInstruction_mov_al_r2_0x0020), 1430 kInstruction_mov_al_r2_0x0020, 1431 }, 1432 { 1433 ARRAY_SIZE(kInstruction_mov_al_r2_0x007d), 1434 kInstruction_mov_al_r2_0x007d, 1435 }, 1436 { 1437 ARRAY_SIZE(kInstruction_mov_al_r2_0x007e), 1438 kInstruction_mov_al_r2_0x007e, 1439 }, 1440 { 1441 ARRAY_SIZE(kInstruction_mov_al_r2_0x007f), 1442 kInstruction_mov_al_r2_0x007f, 1443 }, 1444 { 1445 ARRAY_SIZE(kInstruction_mov_al_r2_0x7ffd), 1446 kInstruction_mov_al_r2_0x7ffd, 1447 }, 1448 { 1449 ARRAY_SIZE(kInstruction_mov_al_r2_0x7ffe), 1450 kInstruction_mov_al_r2_0x7ffe, 1451 }, 1452 { 1453 ARRAY_SIZE(kInstruction_mov_al_r2_0x7fff), 1454 kInstruction_mov_al_r2_0x7fff, 1455 }, 1456 { 1457 ARRAY_SIZE(kInstruction_mov_al_r2_0x3333), 1458 kInstruction_mov_al_r2_0x3333, 1459 }, 1460 { 1461 ARRAY_SIZE(kInstruction_mov_al_r2_0x5555), 1462 kInstruction_mov_al_r2_0x5555, 1463 }, 1464 { 1465 ARRAY_SIZE(kInstruction_mov_al_r2_0xaaaa), 1466 kInstruction_mov_al_r2_0xaaaa, 1467 }, 1468 { 1469 ARRAY_SIZE(kInstruction_mov_al_r2_0xcccc), 1470 kInstruction_mov_al_r2_0xcccc, 1471 }, 1472 { 1473 ARRAY_SIZE(kInstruction_mov_al_r2_0x8000), 1474 kInstruction_mov_al_r2_0x8000, 1475 }, 1476 { 1477 ARRAY_SIZE(kInstruction_mov_al_r2_0x8001), 1478 kInstruction_mov_al_r2_0x8001, 1479 }, 1480 { 1481 ARRAY_SIZE(kInstruction_mov_al_r2_0x8002), 1482 kInstruction_mov_al_r2_0x8002, 1483 }, 1484 { 1485 ARRAY_SIZE(kInstruction_mov_al_r2_0x8003), 1486 kInstruction_mov_al_r2_0x8003, 1487 }, 1488 { 1489 ARRAY_SIZE(kInstruction_mov_al_r2_0xff80), 1490 kInstruction_mov_al_r2_0xff80, 1491 }, 1492 { 1493 ARRAY_SIZE(kInstruction_mov_al_r2_0xff81), 1494 kInstruction_mov_al_r2_0xff81, 1495 }, 1496 { 1497 ARRAY_SIZE(kInstruction_mov_al_r2_0xff82), 1498 kInstruction_mov_al_r2_0xff82, 1499 }, 1500 { 1501 ARRAY_SIZE(kInstruction_mov_al_r2_0xff83), 1502 kInstruction_mov_al_r2_0xff83, 1503 }, 1504 { 1505 ARRAY_SIZE(kInstruction_mov_al_r2_0xffe0), 1506 kInstruction_mov_al_r2_0xffe0, 1507 }, 1508 { 1509 ARRAY_SIZE(kInstruction_mov_al_r2_0xfffd), 1510 kInstruction_mov_al_r2_0xfffd, 1511 }, 1512 { 1513 ARRAY_SIZE(kInstruction_mov_al_r2_0xfffe), 1514 kInstruction_mov_al_r2_0xfffe, 1515 }, 1516 { 1517 ARRAY_SIZE(kInstruction_mov_al_r2_0xffff), 1518 kInstruction_mov_al_r2_0xffff, 1519 }, 1520 { 1521 ARRAY_SIZE(kInstruction_mov_al_r3_0x0000), 1522 kInstruction_mov_al_r3_0x0000, 1523 }, 1524 { 1525 ARRAY_SIZE(kInstruction_mov_al_r3_0x0001), 1526 kInstruction_mov_al_r3_0x0001, 1527 }, 1528 { 1529 ARRAY_SIZE(kInstruction_mov_al_r3_0x0002), 1530 kInstruction_mov_al_r3_0x0002, 1531 }, 1532 { 1533 ARRAY_SIZE(kInstruction_mov_al_r3_0x0020), 1534 kInstruction_mov_al_r3_0x0020, 1535 }, 1536 { 1537 ARRAY_SIZE(kInstruction_mov_al_r3_0x007d), 1538 kInstruction_mov_al_r3_0x007d, 1539 }, 1540 { 1541 ARRAY_SIZE(kInstruction_mov_al_r3_0x007e), 1542 kInstruction_mov_al_r3_0x007e, 1543 }, 1544 { 1545 ARRAY_SIZE(kInstruction_mov_al_r3_0x007f), 1546 kInstruction_mov_al_r3_0x007f, 1547 }, 1548 { 1549 ARRAY_SIZE(kInstruction_mov_al_r3_0x7ffd), 1550 kInstruction_mov_al_r3_0x7ffd, 1551 }, 1552 { 1553 ARRAY_SIZE(kInstruction_mov_al_r3_0x7ffe), 1554 kInstruction_mov_al_r3_0x7ffe, 1555 }, 1556 { 1557 ARRAY_SIZE(kInstruction_mov_al_r3_0x7fff), 1558 kInstruction_mov_al_r3_0x7fff, 1559 }, 1560 { 1561 ARRAY_SIZE(kInstruction_mov_al_r3_0x3333), 1562 kInstruction_mov_al_r3_0x3333, 1563 }, 1564 { 1565 ARRAY_SIZE(kInstruction_mov_al_r3_0x5555), 1566 kInstruction_mov_al_r3_0x5555, 1567 }, 1568 { 1569 ARRAY_SIZE(kInstruction_mov_al_r3_0xaaaa), 1570 kInstruction_mov_al_r3_0xaaaa, 1571 }, 1572 { 1573 ARRAY_SIZE(kInstruction_mov_al_r3_0xcccc), 1574 kInstruction_mov_al_r3_0xcccc, 1575 }, 1576 { 1577 ARRAY_SIZE(kInstruction_mov_al_r3_0x8000), 1578 kInstruction_mov_al_r3_0x8000, 1579 }, 1580 { 1581 ARRAY_SIZE(kInstruction_mov_al_r3_0x8001), 1582 kInstruction_mov_al_r3_0x8001, 1583 }, 1584 { 1585 ARRAY_SIZE(kInstruction_mov_al_r3_0x8002), 1586 kInstruction_mov_al_r3_0x8002, 1587 }, 1588 { 1589 ARRAY_SIZE(kInstruction_mov_al_r3_0x8003), 1590 kInstruction_mov_al_r3_0x8003, 1591 }, 1592 { 1593 ARRAY_SIZE(kInstruction_mov_al_r3_0xff80), 1594 kInstruction_mov_al_r3_0xff80, 1595 }, 1596 { 1597 ARRAY_SIZE(kInstruction_mov_al_r3_0xff81), 1598 kInstruction_mov_al_r3_0xff81, 1599 }, 1600 { 1601 ARRAY_SIZE(kInstruction_mov_al_r3_0xff82), 1602 kInstruction_mov_al_r3_0xff82, 1603 }, 1604 { 1605 ARRAY_SIZE(kInstruction_mov_al_r3_0xff83), 1606 kInstruction_mov_al_r3_0xff83, 1607 }, 1608 { 1609 ARRAY_SIZE(kInstruction_mov_al_r3_0xffe0), 1610 kInstruction_mov_al_r3_0xffe0, 1611 }, 1612 { 1613 ARRAY_SIZE(kInstruction_mov_al_r3_0xfffd), 1614 kInstruction_mov_al_r3_0xfffd, 1615 }, 1616 { 1617 ARRAY_SIZE(kInstruction_mov_al_r3_0xfffe), 1618 kInstruction_mov_al_r3_0xfffe, 1619 }, 1620 { 1621 ARRAY_SIZE(kInstruction_mov_al_r3_0xffff), 1622 kInstruction_mov_al_r3_0xffff, 1623 }, 1624 { 1625 ARRAY_SIZE(kInstruction_mov_al_r4_0x0000), 1626 kInstruction_mov_al_r4_0x0000, 1627 }, 1628 { 1629 ARRAY_SIZE(kInstruction_mov_al_r4_0x0001), 1630 kInstruction_mov_al_r4_0x0001, 1631 }, 1632 { 1633 ARRAY_SIZE(kInstruction_mov_al_r4_0x0002), 1634 kInstruction_mov_al_r4_0x0002, 1635 }, 1636 { 1637 ARRAY_SIZE(kInstruction_mov_al_r4_0x0020), 1638 kInstruction_mov_al_r4_0x0020, 1639 }, 1640 { 1641 ARRAY_SIZE(kInstruction_mov_al_r4_0x007d), 1642 kInstruction_mov_al_r4_0x007d, 1643 }, 1644 { 1645 ARRAY_SIZE(kInstruction_mov_al_r4_0x007e), 1646 kInstruction_mov_al_r4_0x007e, 1647 }, 1648 { 1649 ARRAY_SIZE(kInstruction_mov_al_r4_0x007f), 1650 kInstruction_mov_al_r4_0x007f, 1651 }, 1652 { 1653 ARRAY_SIZE(kInstruction_mov_al_r4_0x7ffd), 1654 kInstruction_mov_al_r4_0x7ffd, 1655 }, 1656 { 1657 ARRAY_SIZE(kInstruction_mov_al_r4_0x7ffe), 1658 kInstruction_mov_al_r4_0x7ffe, 1659 }, 1660 { 1661 ARRAY_SIZE(kInstruction_mov_al_r4_0x7fff), 1662 kInstruction_mov_al_r4_0x7fff, 1663 }, 1664 { 1665 ARRAY_SIZE(kInstruction_mov_al_r4_0x3333), 1666 kInstruction_mov_al_r4_0x3333, 1667 }, 1668 { 1669 ARRAY_SIZE(kInstruction_mov_al_r4_0x5555), 1670 kInstruction_mov_al_r4_0x5555, 1671 }, 1672 { 1673 ARRAY_SIZE(kInstruction_mov_al_r4_0xaaaa), 1674 kInstruction_mov_al_r4_0xaaaa, 1675 }, 1676 { 1677 ARRAY_SIZE(kInstruction_mov_al_r4_0xcccc), 1678 kInstruction_mov_al_r4_0xcccc, 1679 }, 1680 { 1681 ARRAY_SIZE(kInstruction_mov_al_r4_0x8000), 1682 kInstruction_mov_al_r4_0x8000, 1683 }, 1684 { 1685 ARRAY_SIZE(kInstruction_mov_al_r4_0x8001), 1686 kInstruction_mov_al_r4_0x8001, 1687 }, 1688 { 1689 ARRAY_SIZE(kInstruction_mov_al_r4_0x8002), 1690 kInstruction_mov_al_r4_0x8002, 1691 }, 1692 { 1693 ARRAY_SIZE(kInstruction_mov_al_r4_0x8003), 1694 kInstruction_mov_al_r4_0x8003, 1695 }, 1696 { 1697 ARRAY_SIZE(kInstruction_mov_al_r4_0xff80), 1698 kInstruction_mov_al_r4_0xff80, 1699 }, 1700 { 1701 ARRAY_SIZE(kInstruction_mov_al_r4_0xff81), 1702 kInstruction_mov_al_r4_0xff81, 1703 }, 1704 { 1705 ARRAY_SIZE(kInstruction_mov_al_r4_0xff82), 1706 kInstruction_mov_al_r4_0xff82, 1707 }, 1708 { 1709 ARRAY_SIZE(kInstruction_mov_al_r4_0xff83), 1710 kInstruction_mov_al_r4_0xff83, 1711 }, 1712 { 1713 ARRAY_SIZE(kInstruction_mov_al_r4_0xffe0), 1714 kInstruction_mov_al_r4_0xffe0, 1715 }, 1716 { 1717 ARRAY_SIZE(kInstruction_mov_al_r4_0xfffd), 1718 kInstruction_mov_al_r4_0xfffd, 1719 }, 1720 { 1721 ARRAY_SIZE(kInstruction_mov_al_r4_0xfffe), 1722 kInstruction_mov_al_r4_0xfffe, 1723 }, 1724 { 1725 ARRAY_SIZE(kInstruction_mov_al_r4_0xffff), 1726 kInstruction_mov_al_r4_0xffff, 1727 }, 1728 { 1729 ARRAY_SIZE(kInstruction_mov_al_r5_0x0000), 1730 kInstruction_mov_al_r5_0x0000, 1731 }, 1732 { 1733 ARRAY_SIZE(kInstruction_mov_al_r5_0x0001), 1734 kInstruction_mov_al_r5_0x0001, 1735 }, 1736 { 1737 ARRAY_SIZE(kInstruction_mov_al_r5_0x0002), 1738 kInstruction_mov_al_r5_0x0002, 1739 }, 1740 { 1741 ARRAY_SIZE(kInstruction_mov_al_r5_0x0020), 1742 kInstruction_mov_al_r5_0x0020, 1743 }, 1744 { 1745 ARRAY_SIZE(kInstruction_mov_al_r5_0x007d), 1746 kInstruction_mov_al_r5_0x007d, 1747 }, 1748 { 1749 ARRAY_SIZE(kInstruction_mov_al_r5_0x007e), 1750 kInstruction_mov_al_r5_0x007e, 1751 }, 1752 { 1753 ARRAY_SIZE(kInstruction_mov_al_r5_0x007f), 1754 kInstruction_mov_al_r5_0x007f, 1755 }, 1756 { 1757 ARRAY_SIZE(kInstruction_mov_al_r5_0x7ffd), 1758 kInstruction_mov_al_r5_0x7ffd, 1759 }, 1760 { 1761 ARRAY_SIZE(kInstruction_mov_al_r5_0x7ffe), 1762 kInstruction_mov_al_r5_0x7ffe, 1763 }, 1764 { 1765 ARRAY_SIZE(kInstruction_mov_al_r5_0x7fff), 1766 kInstruction_mov_al_r5_0x7fff, 1767 }, 1768 { 1769 ARRAY_SIZE(kInstruction_mov_al_r5_0x3333), 1770 kInstruction_mov_al_r5_0x3333, 1771 }, 1772 { 1773 ARRAY_SIZE(kInstruction_mov_al_r5_0x5555), 1774 kInstruction_mov_al_r5_0x5555, 1775 }, 1776 { 1777 ARRAY_SIZE(kInstruction_mov_al_r5_0xaaaa), 1778 kInstruction_mov_al_r5_0xaaaa, 1779 }, 1780 { 1781 ARRAY_SIZE(kInstruction_mov_al_r5_0xcccc), 1782 kInstruction_mov_al_r5_0xcccc, 1783 }, 1784 { 1785 ARRAY_SIZE(kInstruction_mov_al_r5_0x8000), 1786 kInstruction_mov_al_r5_0x8000, 1787 }, 1788 { 1789 ARRAY_SIZE(kInstruction_mov_al_r5_0x8001), 1790 kInstruction_mov_al_r5_0x8001, 1791 }, 1792 { 1793 ARRAY_SIZE(kInstruction_mov_al_r5_0x8002), 1794 kInstruction_mov_al_r5_0x8002, 1795 }, 1796 { 1797 ARRAY_SIZE(kInstruction_mov_al_r5_0x8003), 1798 kInstruction_mov_al_r5_0x8003, 1799 }, 1800 { 1801 ARRAY_SIZE(kInstruction_mov_al_r5_0xff80), 1802 kInstruction_mov_al_r5_0xff80, 1803 }, 1804 { 1805 ARRAY_SIZE(kInstruction_mov_al_r5_0xff81), 1806 kInstruction_mov_al_r5_0xff81, 1807 }, 1808 { 1809 ARRAY_SIZE(kInstruction_mov_al_r5_0xff82), 1810 kInstruction_mov_al_r5_0xff82, 1811 }, 1812 { 1813 ARRAY_SIZE(kInstruction_mov_al_r5_0xff83), 1814 kInstruction_mov_al_r5_0xff83, 1815 }, 1816 { 1817 ARRAY_SIZE(kInstruction_mov_al_r5_0xffe0), 1818 kInstruction_mov_al_r5_0xffe0, 1819 }, 1820 { 1821 ARRAY_SIZE(kInstruction_mov_al_r5_0xfffd), 1822 kInstruction_mov_al_r5_0xfffd, 1823 }, 1824 { 1825 ARRAY_SIZE(kInstruction_mov_al_r5_0xfffe), 1826 kInstruction_mov_al_r5_0xfffe, 1827 }, 1828 { 1829 ARRAY_SIZE(kInstruction_mov_al_r5_0xffff), 1830 kInstruction_mov_al_r5_0xffff, 1831 }, 1832 { 1833 ARRAY_SIZE(kInstruction_mov_al_r6_0x0000), 1834 kInstruction_mov_al_r6_0x0000, 1835 }, 1836 { 1837 ARRAY_SIZE(kInstruction_mov_al_r6_0x0001), 1838 kInstruction_mov_al_r6_0x0001, 1839 }, 1840 { 1841 ARRAY_SIZE(kInstruction_mov_al_r6_0x0002), 1842 kInstruction_mov_al_r6_0x0002, 1843 }, 1844 { 1845 ARRAY_SIZE(kInstruction_mov_al_r6_0x0020), 1846 kInstruction_mov_al_r6_0x0020, 1847 }, 1848 { 1849 ARRAY_SIZE(kInstruction_mov_al_r6_0x007d), 1850 kInstruction_mov_al_r6_0x007d, 1851 }, 1852 { 1853 ARRAY_SIZE(kInstruction_mov_al_r6_0x007e), 1854 kInstruction_mov_al_r6_0x007e, 1855 }, 1856 { 1857 ARRAY_SIZE(kInstruction_mov_al_r6_0x007f), 1858 kInstruction_mov_al_r6_0x007f, 1859 }, 1860 { 1861 ARRAY_SIZE(kInstruction_mov_al_r6_0x7ffd), 1862 kInstruction_mov_al_r6_0x7ffd, 1863 }, 1864 { 1865 ARRAY_SIZE(kInstruction_mov_al_r6_0x7ffe), 1866 kInstruction_mov_al_r6_0x7ffe, 1867 }, 1868 { 1869 ARRAY_SIZE(kInstruction_mov_al_r6_0x7fff), 1870 kInstruction_mov_al_r6_0x7fff, 1871 }, 1872 { 1873 ARRAY_SIZE(kInstruction_mov_al_r6_0x3333), 1874 kInstruction_mov_al_r6_0x3333, 1875 }, 1876 { 1877 ARRAY_SIZE(kInstruction_mov_al_r6_0x5555), 1878 kInstruction_mov_al_r6_0x5555, 1879 }, 1880 { 1881 ARRAY_SIZE(kInstruction_mov_al_r6_0xaaaa), 1882 kInstruction_mov_al_r6_0xaaaa, 1883 }, 1884 { 1885 ARRAY_SIZE(kInstruction_mov_al_r6_0xcccc), 1886 kInstruction_mov_al_r6_0xcccc, 1887 }, 1888 { 1889 ARRAY_SIZE(kInstruction_mov_al_r6_0x8000), 1890 kInstruction_mov_al_r6_0x8000, 1891 }, 1892 { 1893 ARRAY_SIZE(kInstruction_mov_al_r6_0x8001), 1894 kInstruction_mov_al_r6_0x8001, 1895 }, 1896 { 1897 ARRAY_SIZE(kInstruction_mov_al_r6_0x8002), 1898 kInstruction_mov_al_r6_0x8002, 1899 }, 1900 { 1901 ARRAY_SIZE(kInstruction_mov_al_r6_0x8003), 1902 kInstruction_mov_al_r6_0x8003, 1903 }, 1904 { 1905 ARRAY_SIZE(kInstruction_mov_al_r6_0xff80), 1906 kInstruction_mov_al_r6_0xff80, 1907 }, 1908 { 1909 ARRAY_SIZE(kInstruction_mov_al_r6_0xff81), 1910 kInstruction_mov_al_r6_0xff81, 1911 }, 1912 { 1913 ARRAY_SIZE(kInstruction_mov_al_r6_0xff82), 1914 kInstruction_mov_al_r6_0xff82, 1915 }, 1916 { 1917 ARRAY_SIZE(kInstruction_mov_al_r6_0xff83), 1918 kInstruction_mov_al_r6_0xff83, 1919 }, 1920 { 1921 ARRAY_SIZE(kInstruction_mov_al_r6_0xffe0), 1922 kInstruction_mov_al_r6_0xffe0, 1923 }, 1924 { 1925 ARRAY_SIZE(kInstruction_mov_al_r6_0xfffd), 1926 kInstruction_mov_al_r6_0xfffd, 1927 }, 1928 { 1929 ARRAY_SIZE(kInstruction_mov_al_r6_0xfffe), 1930 kInstruction_mov_al_r6_0xfffe, 1931 }, 1932 { 1933 ARRAY_SIZE(kInstruction_mov_al_r6_0xffff), 1934 kInstruction_mov_al_r6_0xffff, 1935 }, 1936 { 1937 ARRAY_SIZE(kInstruction_mov_al_r7_0x0000), 1938 kInstruction_mov_al_r7_0x0000, 1939 }, 1940 { 1941 ARRAY_SIZE(kInstruction_mov_al_r7_0x0001), 1942 kInstruction_mov_al_r7_0x0001, 1943 }, 1944 { 1945 ARRAY_SIZE(kInstruction_mov_al_r7_0x0002), 1946 kInstruction_mov_al_r7_0x0002, 1947 }, 1948 { 1949 ARRAY_SIZE(kInstruction_mov_al_r7_0x0020), 1950 kInstruction_mov_al_r7_0x0020, 1951 }, 1952 { 1953 ARRAY_SIZE(kInstruction_mov_al_r7_0x007d), 1954 kInstruction_mov_al_r7_0x007d, 1955 }, 1956 { 1957 ARRAY_SIZE(kInstruction_mov_al_r7_0x007e), 1958 kInstruction_mov_al_r7_0x007e, 1959 }, 1960 { 1961 ARRAY_SIZE(kInstruction_mov_al_r7_0x007f), 1962 kInstruction_mov_al_r7_0x007f, 1963 }, 1964 { 1965 ARRAY_SIZE(kInstruction_mov_al_r7_0x7ffd), 1966 kInstruction_mov_al_r7_0x7ffd, 1967 }, 1968 { 1969 ARRAY_SIZE(kInstruction_mov_al_r7_0x7ffe), 1970 kInstruction_mov_al_r7_0x7ffe, 1971 }, 1972 { 1973 ARRAY_SIZE(kInstruction_mov_al_r7_0x7fff), 1974 kInstruction_mov_al_r7_0x7fff, 1975 }, 1976 { 1977 ARRAY_SIZE(kInstruction_mov_al_r7_0x3333), 1978 kInstruction_mov_al_r7_0x3333, 1979 }, 1980 { 1981 ARRAY_SIZE(kInstruction_mov_al_r7_0x5555), 1982 kInstruction_mov_al_r7_0x5555, 1983 }, 1984 { 1985 ARRAY_SIZE(kInstruction_mov_al_r7_0xaaaa), 1986 kInstruction_mov_al_r7_0xaaaa, 1987 }, 1988 { 1989 ARRAY_SIZE(kInstruction_mov_al_r7_0xcccc), 1990 kInstruction_mov_al_r7_0xcccc, 1991 }, 1992 { 1993 ARRAY_SIZE(kInstruction_mov_al_r7_0x8000), 1994 kInstruction_mov_al_r7_0x8000, 1995 }, 1996 { 1997 ARRAY_SIZE(kInstruction_mov_al_r7_0x8001), 1998 kInstruction_mov_al_r7_0x8001, 1999 }, 2000 { 2001 ARRAY_SIZE(kInstruction_mov_al_r7_0x8002), 2002 kInstruction_mov_al_r7_0x8002, 2003 }, 2004 { 2005 ARRAY_SIZE(kInstruction_mov_al_r7_0x8003), 2006 kInstruction_mov_al_r7_0x8003, 2007 }, 2008 { 2009 ARRAY_SIZE(kInstruction_mov_al_r7_0xff80), 2010 kInstruction_mov_al_r7_0xff80, 2011 }, 2012 { 2013 ARRAY_SIZE(kInstruction_mov_al_r7_0xff81), 2014 kInstruction_mov_al_r7_0xff81, 2015 }, 2016 { 2017 ARRAY_SIZE(kInstruction_mov_al_r7_0xff82), 2018 kInstruction_mov_al_r7_0xff82, 2019 }, 2020 { 2021 ARRAY_SIZE(kInstruction_mov_al_r7_0xff83), 2022 kInstruction_mov_al_r7_0xff83, 2023 }, 2024 { 2025 ARRAY_SIZE(kInstruction_mov_al_r7_0xffe0), 2026 kInstruction_mov_al_r7_0xffe0, 2027 }, 2028 { 2029 ARRAY_SIZE(kInstruction_mov_al_r7_0xfffd), 2030 kInstruction_mov_al_r7_0xfffd, 2031 }, 2032 { 2033 ARRAY_SIZE(kInstruction_mov_al_r7_0xfffe), 2034 kInstruction_mov_al_r7_0xfffe, 2035 }, 2036 { 2037 ARRAY_SIZE(kInstruction_mov_al_r7_0xffff), 2038 kInstruction_mov_al_r7_0xffff, 2039 }, 2040 { 2041 ARRAY_SIZE(kInstruction_mov_al_r8_0x0000), 2042 kInstruction_mov_al_r8_0x0000, 2043 }, 2044 { 2045 ARRAY_SIZE(kInstruction_mov_al_r8_0x0001), 2046 kInstruction_mov_al_r8_0x0001, 2047 }, 2048 { 2049 ARRAY_SIZE(kInstruction_mov_al_r8_0x0002), 2050 kInstruction_mov_al_r8_0x0002, 2051 }, 2052 { 2053 ARRAY_SIZE(kInstruction_mov_al_r8_0x0020), 2054 kInstruction_mov_al_r8_0x0020, 2055 }, 2056 { 2057 ARRAY_SIZE(kInstruction_mov_al_r8_0x007d), 2058 kInstruction_mov_al_r8_0x007d, 2059 }, 2060 { 2061 ARRAY_SIZE(kInstruction_mov_al_r8_0x007e), 2062 kInstruction_mov_al_r8_0x007e, 2063 }, 2064 { 2065 ARRAY_SIZE(kInstruction_mov_al_r8_0x007f), 2066 kInstruction_mov_al_r8_0x007f, 2067 }, 2068 { 2069 ARRAY_SIZE(kInstruction_mov_al_r8_0x7ffd), 2070 kInstruction_mov_al_r8_0x7ffd, 2071 }, 2072 { 2073 ARRAY_SIZE(kInstruction_mov_al_r8_0x7ffe), 2074 kInstruction_mov_al_r8_0x7ffe, 2075 }, 2076 { 2077 ARRAY_SIZE(kInstruction_mov_al_r8_0x7fff), 2078 kInstruction_mov_al_r8_0x7fff, 2079 }, 2080 { 2081 ARRAY_SIZE(kInstruction_mov_al_r8_0x3333), 2082 kInstruction_mov_al_r8_0x3333, 2083 }, 2084 { 2085 ARRAY_SIZE(kInstruction_mov_al_r8_0x5555), 2086 kInstruction_mov_al_r8_0x5555, 2087 }, 2088 { 2089 ARRAY_SIZE(kInstruction_mov_al_r8_0xaaaa), 2090 kInstruction_mov_al_r8_0xaaaa, 2091 }, 2092 { 2093 ARRAY_SIZE(kInstruction_mov_al_r8_0xcccc), 2094 kInstruction_mov_al_r8_0xcccc, 2095 }, 2096 { 2097 ARRAY_SIZE(kInstruction_mov_al_r8_0x8000), 2098 kInstruction_mov_al_r8_0x8000, 2099 }, 2100 { 2101 ARRAY_SIZE(kInstruction_mov_al_r8_0x8001), 2102 kInstruction_mov_al_r8_0x8001, 2103 }, 2104 { 2105 ARRAY_SIZE(kInstruction_mov_al_r8_0x8002), 2106 kInstruction_mov_al_r8_0x8002, 2107 }, 2108 { 2109 ARRAY_SIZE(kInstruction_mov_al_r8_0x8003), 2110 kInstruction_mov_al_r8_0x8003, 2111 }, 2112 { 2113 ARRAY_SIZE(kInstruction_mov_al_r8_0xff80), 2114 kInstruction_mov_al_r8_0xff80, 2115 }, 2116 { 2117 ARRAY_SIZE(kInstruction_mov_al_r8_0xff81), 2118 kInstruction_mov_al_r8_0xff81, 2119 }, 2120 { 2121 ARRAY_SIZE(kInstruction_mov_al_r8_0xff82), 2122 kInstruction_mov_al_r8_0xff82, 2123 }, 2124 { 2125 ARRAY_SIZE(kInstruction_mov_al_r8_0xff83), 2126 kInstruction_mov_al_r8_0xff83, 2127 }, 2128 { 2129 ARRAY_SIZE(kInstruction_mov_al_r8_0xffe0), 2130 kInstruction_mov_al_r8_0xffe0, 2131 }, 2132 { 2133 ARRAY_SIZE(kInstruction_mov_al_r8_0xfffd), 2134 kInstruction_mov_al_r8_0xfffd, 2135 }, 2136 { 2137 ARRAY_SIZE(kInstruction_mov_al_r8_0xfffe), 2138 kInstruction_mov_al_r8_0xfffe, 2139 }, 2140 { 2141 ARRAY_SIZE(kInstruction_mov_al_r8_0xffff), 2142 kInstruction_mov_al_r8_0xffff, 2143 }, 2144 { 2145 ARRAY_SIZE(kInstruction_mov_al_r9_0x0000), 2146 kInstruction_mov_al_r9_0x0000, 2147 }, 2148 { 2149 ARRAY_SIZE(kInstruction_mov_al_r9_0x0001), 2150 kInstruction_mov_al_r9_0x0001, 2151 }, 2152 { 2153 ARRAY_SIZE(kInstruction_mov_al_r9_0x0002), 2154 kInstruction_mov_al_r9_0x0002, 2155 }, 2156 { 2157 ARRAY_SIZE(kInstruction_mov_al_r9_0x0020), 2158 kInstruction_mov_al_r9_0x0020, 2159 }, 2160 { 2161 ARRAY_SIZE(kInstruction_mov_al_r9_0x007d), 2162 kInstruction_mov_al_r9_0x007d, 2163 }, 2164 { 2165 ARRAY_SIZE(kInstruction_mov_al_r9_0x007e), 2166 kInstruction_mov_al_r9_0x007e, 2167 }, 2168 { 2169 ARRAY_SIZE(kInstruction_mov_al_r9_0x007f), 2170 kInstruction_mov_al_r9_0x007f, 2171 }, 2172 { 2173 ARRAY_SIZE(kInstruction_mov_al_r9_0x7ffd), 2174 kInstruction_mov_al_r9_0x7ffd, 2175 }, 2176 { 2177 ARRAY_SIZE(kInstruction_mov_al_r9_0x7ffe), 2178 kInstruction_mov_al_r9_0x7ffe, 2179 }, 2180 { 2181 ARRAY_SIZE(kInstruction_mov_al_r9_0x7fff), 2182 kInstruction_mov_al_r9_0x7fff, 2183 }, 2184 { 2185 ARRAY_SIZE(kInstruction_mov_al_r9_0x3333), 2186 kInstruction_mov_al_r9_0x3333, 2187 }, 2188 { 2189 ARRAY_SIZE(kInstruction_mov_al_r9_0x5555), 2190 kInstruction_mov_al_r9_0x5555, 2191 }, 2192 { 2193 ARRAY_SIZE(kInstruction_mov_al_r9_0xaaaa), 2194 kInstruction_mov_al_r9_0xaaaa, 2195 }, 2196 { 2197 ARRAY_SIZE(kInstruction_mov_al_r9_0xcccc), 2198 kInstruction_mov_al_r9_0xcccc, 2199 }, 2200 { 2201 ARRAY_SIZE(kInstruction_mov_al_r9_0x8000), 2202 kInstruction_mov_al_r9_0x8000, 2203 }, 2204 { 2205 ARRAY_SIZE(kInstruction_mov_al_r9_0x8001), 2206 kInstruction_mov_al_r9_0x8001, 2207 }, 2208 { 2209 ARRAY_SIZE(kInstruction_mov_al_r9_0x8002), 2210 kInstruction_mov_al_r9_0x8002, 2211 }, 2212 { 2213 ARRAY_SIZE(kInstruction_mov_al_r9_0x8003), 2214 kInstruction_mov_al_r9_0x8003, 2215 }, 2216 { 2217 ARRAY_SIZE(kInstruction_mov_al_r9_0xff80), 2218 kInstruction_mov_al_r9_0xff80, 2219 }, 2220 { 2221 ARRAY_SIZE(kInstruction_mov_al_r9_0xff81), 2222 kInstruction_mov_al_r9_0xff81, 2223 }, 2224 { 2225 ARRAY_SIZE(kInstruction_mov_al_r9_0xff82), 2226 kInstruction_mov_al_r9_0xff82, 2227 }, 2228 { 2229 ARRAY_SIZE(kInstruction_mov_al_r9_0xff83), 2230 kInstruction_mov_al_r9_0xff83, 2231 }, 2232 { 2233 ARRAY_SIZE(kInstruction_mov_al_r9_0xffe0), 2234 kInstruction_mov_al_r9_0xffe0, 2235 }, 2236 { 2237 ARRAY_SIZE(kInstruction_mov_al_r9_0xfffd), 2238 kInstruction_mov_al_r9_0xfffd, 2239 }, 2240 { 2241 ARRAY_SIZE(kInstruction_mov_al_r9_0xfffe), 2242 kInstruction_mov_al_r9_0xfffe, 2243 }, 2244 { 2245 ARRAY_SIZE(kInstruction_mov_al_r9_0xffff), 2246 kInstruction_mov_al_r9_0xffff, 2247 }, 2248 { 2249 ARRAY_SIZE(kInstruction_mov_al_r10_0x0000), 2250 kInstruction_mov_al_r10_0x0000, 2251 }, 2252 { 2253 ARRAY_SIZE(kInstruction_mov_al_r10_0x0001), 2254 kInstruction_mov_al_r10_0x0001, 2255 }, 2256 { 2257 ARRAY_SIZE(kInstruction_mov_al_r10_0x0002), 2258 kInstruction_mov_al_r10_0x0002, 2259 }, 2260 { 2261 ARRAY_SIZE(kInstruction_mov_al_r10_0x0020), 2262 kInstruction_mov_al_r10_0x0020, 2263 }, 2264 { 2265 ARRAY_SIZE(kInstruction_mov_al_r10_0x007d), 2266 kInstruction_mov_al_r10_0x007d, 2267 }, 2268 { 2269 ARRAY_SIZE(kInstruction_mov_al_r10_0x007e), 2270 kInstruction_mov_al_r10_0x007e, 2271 }, 2272 { 2273 ARRAY_SIZE(kInstruction_mov_al_r10_0x007f), 2274 kInstruction_mov_al_r10_0x007f, 2275 }, 2276 { 2277 ARRAY_SIZE(kInstruction_mov_al_r10_0x7ffd), 2278 kInstruction_mov_al_r10_0x7ffd, 2279 }, 2280 { 2281 ARRAY_SIZE(kInstruction_mov_al_r10_0x7ffe), 2282 kInstruction_mov_al_r10_0x7ffe, 2283 }, 2284 { 2285 ARRAY_SIZE(kInstruction_mov_al_r10_0x7fff), 2286 kInstruction_mov_al_r10_0x7fff, 2287 }, 2288 { 2289 ARRAY_SIZE(kInstruction_mov_al_r10_0x3333), 2290 kInstruction_mov_al_r10_0x3333, 2291 }, 2292 { 2293 ARRAY_SIZE(kInstruction_mov_al_r10_0x5555), 2294 kInstruction_mov_al_r10_0x5555, 2295 }, 2296 { 2297 ARRAY_SIZE(kInstruction_mov_al_r10_0xaaaa), 2298 kInstruction_mov_al_r10_0xaaaa, 2299 }, 2300 { 2301 ARRAY_SIZE(kInstruction_mov_al_r10_0xcccc), 2302 kInstruction_mov_al_r10_0xcccc, 2303 }, 2304 { 2305 ARRAY_SIZE(kInstruction_mov_al_r10_0x8000), 2306 kInstruction_mov_al_r10_0x8000, 2307 }, 2308 { 2309 ARRAY_SIZE(kInstruction_mov_al_r10_0x8001), 2310 kInstruction_mov_al_r10_0x8001, 2311 }, 2312 { 2313 ARRAY_SIZE(kInstruction_mov_al_r10_0x8002), 2314 kInstruction_mov_al_r10_0x8002, 2315 }, 2316 { 2317 ARRAY_SIZE(kInstruction_mov_al_r10_0x8003), 2318 kInstruction_mov_al_r10_0x8003, 2319 }, 2320 { 2321 ARRAY_SIZE(kInstruction_mov_al_r10_0xff80), 2322 kInstruction_mov_al_r10_0xff80, 2323 }, 2324 { 2325 ARRAY_SIZE(kInstruction_mov_al_r10_0xff81), 2326 kInstruction_mov_al_r10_0xff81, 2327 }, 2328 { 2329 ARRAY_SIZE(kInstruction_mov_al_r10_0xff82), 2330 kInstruction_mov_al_r10_0xff82, 2331 }, 2332 { 2333 ARRAY_SIZE(kInstruction_mov_al_r10_0xff83), 2334 kInstruction_mov_al_r10_0xff83, 2335 }, 2336 { 2337 ARRAY_SIZE(kInstruction_mov_al_r10_0xffe0), 2338 kInstruction_mov_al_r10_0xffe0, 2339 }, 2340 { 2341 ARRAY_SIZE(kInstruction_mov_al_r10_0xfffd), 2342 kInstruction_mov_al_r10_0xfffd, 2343 }, 2344 { 2345 ARRAY_SIZE(kInstruction_mov_al_r10_0xfffe), 2346 kInstruction_mov_al_r10_0xfffe, 2347 }, 2348 { 2349 ARRAY_SIZE(kInstruction_mov_al_r10_0xffff), 2350 kInstruction_mov_al_r10_0xffff, 2351 }, 2352 { 2353 ARRAY_SIZE(kInstruction_mov_al_r11_0x0000), 2354 kInstruction_mov_al_r11_0x0000, 2355 }, 2356 { 2357 ARRAY_SIZE(kInstruction_mov_al_r11_0x0001), 2358 kInstruction_mov_al_r11_0x0001, 2359 }, 2360 { 2361 ARRAY_SIZE(kInstruction_mov_al_r11_0x0002), 2362 kInstruction_mov_al_r11_0x0002, 2363 }, 2364 { 2365 ARRAY_SIZE(kInstruction_mov_al_r11_0x0020), 2366 kInstruction_mov_al_r11_0x0020, 2367 }, 2368 { 2369 ARRAY_SIZE(kInstruction_mov_al_r11_0x007d), 2370 kInstruction_mov_al_r11_0x007d, 2371 }, 2372 { 2373 ARRAY_SIZE(kInstruction_mov_al_r11_0x007e), 2374 kInstruction_mov_al_r11_0x007e, 2375 }, 2376 { 2377 ARRAY_SIZE(kInstruction_mov_al_r11_0x007f), 2378 kInstruction_mov_al_r11_0x007f, 2379 }, 2380 { 2381 ARRAY_SIZE(kInstruction_mov_al_r11_0x7ffd), 2382 kInstruction_mov_al_r11_0x7ffd, 2383 }, 2384 { 2385 ARRAY_SIZE(kInstruction_mov_al_r11_0x7ffe), 2386 kInstruction_mov_al_r11_0x7ffe, 2387 }, 2388 { 2389 ARRAY_SIZE(kInstruction_mov_al_r11_0x7fff), 2390 kInstruction_mov_al_r11_0x7fff, 2391 }, 2392 { 2393 ARRAY_SIZE(kInstruction_mov_al_r11_0x3333), 2394 kInstruction_mov_al_r11_0x3333, 2395 }, 2396 { 2397 ARRAY_SIZE(kInstruction_mov_al_r11_0x5555), 2398 kInstruction_mov_al_r11_0x5555, 2399 }, 2400 { 2401 ARRAY_SIZE(kInstruction_mov_al_r11_0xaaaa), 2402 kInstruction_mov_al_r11_0xaaaa, 2403 }, 2404 { 2405 ARRAY_SIZE(kInstruction_mov_al_r11_0xcccc), 2406 kInstruction_mov_al_r11_0xcccc, 2407 }, 2408 { 2409 ARRAY_SIZE(kInstruction_mov_al_r11_0x8000), 2410 kInstruction_mov_al_r11_0x8000, 2411 }, 2412 { 2413 ARRAY_SIZE(kInstruction_mov_al_r11_0x8001), 2414 kInstruction_mov_al_r11_0x8001, 2415 }, 2416 { 2417 ARRAY_SIZE(kInstruction_mov_al_r11_0x8002), 2418 kInstruction_mov_al_r11_0x8002, 2419 }, 2420 { 2421 ARRAY_SIZE(kInstruction_mov_al_r11_0x8003), 2422 kInstruction_mov_al_r11_0x8003, 2423 }, 2424 { 2425 ARRAY_SIZE(kInstruction_mov_al_r11_0xff80), 2426 kInstruction_mov_al_r11_0xff80, 2427 }, 2428 { 2429 ARRAY_SIZE(kInstruction_mov_al_r11_0xff81), 2430 kInstruction_mov_al_r11_0xff81, 2431 }, 2432 { 2433 ARRAY_SIZE(kInstruction_mov_al_r11_0xff82), 2434 kInstruction_mov_al_r11_0xff82, 2435 }, 2436 { 2437 ARRAY_SIZE(kInstruction_mov_al_r11_0xff83), 2438 kInstruction_mov_al_r11_0xff83, 2439 }, 2440 { 2441 ARRAY_SIZE(kInstruction_mov_al_r11_0xffe0), 2442 kInstruction_mov_al_r11_0xffe0, 2443 }, 2444 { 2445 ARRAY_SIZE(kInstruction_mov_al_r11_0xfffd), 2446 kInstruction_mov_al_r11_0xfffd, 2447 }, 2448 { 2449 ARRAY_SIZE(kInstruction_mov_al_r11_0xfffe), 2450 kInstruction_mov_al_r11_0xfffe, 2451 }, 2452 { 2453 ARRAY_SIZE(kInstruction_mov_al_r11_0xffff), 2454 kInstruction_mov_al_r11_0xffff, 2455 }, 2456 { 2457 ARRAY_SIZE(kInstruction_mov_al_r12_0x0000), 2458 kInstruction_mov_al_r12_0x0000, 2459 }, 2460 { 2461 ARRAY_SIZE(kInstruction_mov_al_r12_0x0001), 2462 kInstruction_mov_al_r12_0x0001, 2463 }, 2464 { 2465 ARRAY_SIZE(kInstruction_mov_al_r12_0x0002), 2466 kInstruction_mov_al_r12_0x0002, 2467 }, 2468 { 2469 ARRAY_SIZE(kInstruction_mov_al_r12_0x0020), 2470 kInstruction_mov_al_r12_0x0020, 2471 }, 2472 { 2473 ARRAY_SIZE(kInstruction_mov_al_r12_0x007d), 2474 kInstruction_mov_al_r12_0x007d, 2475 }, 2476 { 2477 ARRAY_SIZE(kInstruction_mov_al_r12_0x007e), 2478 kInstruction_mov_al_r12_0x007e, 2479 }, 2480 { 2481 ARRAY_SIZE(kInstruction_mov_al_r12_0x007f), 2482 kInstruction_mov_al_r12_0x007f, 2483 }, 2484 { 2485 ARRAY_SIZE(kInstruction_mov_al_r12_0x7ffd), 2486 kInstruction_mov_al_r12_0x7ffd, 2487 }, 2488 { 2489 ARRAY_SIZE(kInstruction_mov_al_r12_0x7ffe), 2490 kInstruction_mov_al_r12_0x7ffe, 2491 }, 2492 { 2493 ARRAY_SIZE(kInstruction_mov_al_r12_0x7fff), 2494 kInstruction_mov_al_r12_0x7fff, 2495 }, 2496 { 2497 ARRAY_SIZE(kInstruction_mov_al_r12_0x3333), 2498 kInstruction_mov_al_r12_0x3333, 2499 }, 2500 { 2501 ARRAY_SIZE(kInstruction_mov_al_r12_0x5555), 2502 kInstruction_mov_al_r12_0x5555, 2503 }, 2504 { 2505 ARRAY_SIZE(kInstruction_mov_al_r12_0xaaaa), 2506 kInstruction_mov_al_r12_0xaaaa, 2507 }, 2508 { 2509 ARRAY_SIZE(kInstruction_mov_al_r12_0xcccc), 2510 kInstruction_mov_al_r12_0xcccc, 2511 }, 2512 { 2513 ARRAY_SIZE(kInstruction_mov_al_r12_0x8000), 2514 kInstruction_mov_al_r12_0x8000, 2515 }, 2516 { 2517 ARRAY_SIZE(kInstruction_mov_al_r12_0x8001), 2518 kInstruction_mov_al_r12_0x8001, 2519 }, 2520 { 2521 ARRAY_SIZE(kInstruction_mov_al_r12_0x8002), 2522 kInstruction_mov_al_r12_0x8002, 2523 }, 2524 { 2525 ARRAY_SIZE(kInstruction_mov_al_r12_0x8003), 2526 kInstruction_mov_al_r12_0x8003, 2527 }, 2528 { 2529 ARRAY_SIZE(kInstruction_mov_al_r12_0xff80), 2530 kInstruction_mov_al_r12_0xff80, 2531 }, 2532 { 2533 ARRAY_SIZE(kInstruction_mov_al_r12_0xff81), 2534 kInstruction_mov_al_r12_0xff81, 2535 }, 2536 { 2537 ARRAY_SIZE(kInstruction_mov_al_r12_0xff82), 2538 kInstruction_mov_al_r12_0xff82, 2539 }, 2540 { 2541 ARRAY_SIZE(kInstruction_mov_al_r12_0xff83), 2542 kInstruction_mov_al_r12_0xff83, 2543 }, 2544 { 2545 ARRAY_SIZE(kInstruction_mov_al_r12_0xffe0), 2546 kInstruction_mov_al_r12_0xffe0, 2547 }, 2548 { 2549 ARRAY_SIZE(kInstruction_mov_al_r12_0xfffd), 2550 kInstruction_mov_al_r12_0xfffd, 2551 }, 2552 { 2553 ARRAY_SIZE(kInstruction_mov_al_r12_0xfffe), 2554 kInstruction_mov_al_r12_0xfffe, 2555 }, 2556 { 2557 ARRAY_SIZE(kInstruction_mov_al_r12_0xffff), 2558 kInstruction_mov_al_r12_0xffff, 2559 }, 2560 { 2561 ARRAY_SIZE(kInstruction_mov_al_r13_0x0000), 2562 kInstruction_mov_al_r13_0x0000, 2563 }, 2564 { 2565 ARRAY_SIZE(kInstruction_mov_al_r13_0x0001), 2566 kInstruction_mov_al_r13_0x0001, 2567 }, 2568 { 2569 ARRAY_SIZE(kInstruction_mov_al_r13_0x0002), 2570 kInstruction_mov_al_r13_0x0002, 2571 }, 2572 { 2573 ARRAY_SIZE(kInstruction_mov_al_r13_0x0020), 2574 kInstruction_mov_al_r13_0x0020, 2575 }, 2576 { 2577 ARRAY_SIZE(kInstruction_mov_al_r13_0x007d), 2578 kInstruction_mov_al_r13_0x007d, 2579 }, 2580 { 2581 ARRAY_SIZE(kInstruction_mov_al_r13_0x007e), 2582 kInstruction_mov_al_r13_0x007e, 2583 }, 2584 { 2585 ARRAY_SIZE(kInstruction_mov_al_r13_0x007f), 2586 kInstruction_mov_al_r13_0x007f, 2587 }, 2588 { 2589 ARRAY_SIZE(kInstruction_mov_al_r13_0x7ffd), 2590 kInstruction_mov_al_r13_0x7ffd, 2591 }, 2592 { 2593 ARRAY_SIZE(kInstruction_mov_al_r13_0x7ffe), 2594 kInstruction_mov_al_r13_0x7ffe, 2595 }, 2596 { 2597 ARRAY_SIZE(kInstruction_mov_al_r13_0x7fff), 2598 kInstruction_mov_al_r13_0x7fff, 2599 }, 2600 { 2601 ARRAY_SIZE(kInstruction_mov_al_r13_0x3333), 2602 kInstruction_mov_al_r13_0x3333, 2603 }, 2604 { 2605 ARRAY_SIZE(kInstruction_mov_al_r13_0x5555), 2606 kInstruction_mov_al_r13_0x5555, 2607 }, 2608 { 2609 ARRAY_SIZE(kInstruction_mov_al_r13_0xaaaa), 2610 kInstruction_mov_al_r13_0xaaaa, 2611 }, 2612 { 2613 ARRAY_SIZE(kInstruction_mov_al_r13_0xcccc), 2614 kInstruction_mov_al_r13_0xcccc, 2615 }, 2616 { 2617 ARRAY_SIZE(kInstruction_mov_al_r13_0x8000), 2618 kInstruction_mov_al_r13_0x8000, 2619 }, 2620 { 2621 ARRAY_SIZE(kInstruction_mov_al_r13_0x8001), 2622 kInstruction_mov_al_r13_0x8001, 2623 }, 2624 { 2625 ARRAY_SIZE(kInstruction_mov_al_r13_0x8002), 2626 kInstruction_mov_al_r13_0x8002, 2627 }, 2628 { 2629 ARRAY_SIZE(kInstruction_mov_al_r13_0x8003), 2630 kInstruction_mov_al_r13_0x8003, 2631 }, 2632 { 2633 ARRAY_SIZE(kInstruction_mov_al_r13_0xff80), 2634 kInstruction_mov_al_r13_0xff80, 2635 }, 2636 { 2637 ARRAY_SIZE(kInstruction_mov_al_r13_0xff81), 2638 kInstruction_mov_al_r13_0xff81, 2639 }, 2640 { 2641 ARRAY_SIZE(kInstruction_mov_al_r13_0xff82), 2642 kInstruction_mov_al_r13_0xff82, 2643 }, 2644 { 2645 ARRAY_SIZE(kInstruction_mov_al_r13_0xff83), 2646 kInstruction_mov_al_r13_0xff83, 2647 }, 2648 { 2649 ARRAY_SIZE(kInstruction_mov_al_r13_0xffe0), 2650 kInstruction_mov_al_r13_0xffe0, 2651 }, 2652 { 2653 ARRAY_SIZE(kInstruction_mov_al_r13_0xfffd), 2654 kInstruction_mov_al_r13_0xfffd, 2655 }, 2656 { 2657 ARRAY_SIZE(kInstruction_mov_al_r13_0xfffe), 2658 kInstruction_mov_al_r13_0xfffe, 2659 }, 2660 { 2661 ARRAY_SIZE(kInstruction_mov_al_r13_0xffff), 2662 kInstruction_mov_al_r13_0xffff, 2663 }, 2664 { 2665 ARRAY_SIZE(kInstruction_mov_al_r14_0x0000), 2666 kInstruction_mov_al_r14_0x0000, 2667 }, 2668 { 2669 ARRAY_SIZE(kInstruction_mov_al_r14_0x0001), 2670 kInstruction_mov_al_r14_0x0001, 2671 }, 2672 { 2673 ARRAY_SIZE(kInstruction_mov_al_r14_0x0002), 2674 kInstruction_mov_al_r14_0x0002, 2675 }, 2676 { 2677 ARRAY_SIZE(kInstruction_mov_al_r14_0x0020), 2678 kInstruction_mov_al_r14_0x0020, 2679 }, 2680 { 2681 ARRAY_SIZE(kInstruction_mov_al_r14_0x007d), 2682 kInstruction_mov_al_r14_0x007d, 2683 }, 2684 { 2685 ARRAY_SIZE(kInstruction_mov_al_r14_0x007e), 2686 kInstruction_mov_al_r14_0x007e, 2687 }, 2688 { 2689 ARRAY_SIZE(kInstruction_mov_al_r14_0x007f), 2690 kInstruction_mov_al_r14_0x007f, 2691 }, 2692 { 2693 ARRAY_SIZE(kInstruction_mov_al_r14_0x7ffd), 2694 kInstruction_mov_al_r14_0x7ffd, 2695 }, 2696 { 2697 ARRAY_SIZE(kInstruction_mov_al_r14_0x7ffe), 2698 kInstruction_mov_al_r14_0x7ffe, 2699 }, 2700 { 2701 ARRAY_SIZE(kInstruction_mov_al_r14_0x7fff), 2702 kInstruction_mov_al_r14_0x7fff, 2703 }, 2704 { 2705 ARRAY_SIZE(kInstruction_mov_al_r14_0x3333), 2706 kInstruction_mov_al_r14_0x3333, 2707 }, 2708 { 2709 ARRAY_SIZE(kInstruction_mov_al_r14_0x5555), 2710 kInstruction_mov_al_r14_0x5555, 2711 }, 2712 { 2713 ARRAY_SIZE(kInstruction_mov_al_r14_0xaaaa), 2714 kInstruction_mov_al_r14_0xaaaa, 2715 }, 2716 { 2717 ARRAY_SIZE(kInstruction_mov_al_r14_0xcccc), 2718 kInstruction_mov_al_r14_0xcccc, 2719 }, 2720 { 2721 ARRAY_SIZE(kInstruction_mov_al_r14_0x8000), 2722 kInstruction_mov_al_r14_0x8000, 2723 }, 2724 { 2725 ARRAY_SIZE(kInstruction_mov_al_r14_0x8001), 2726 kInstruction_mov_al_r14_0x8001, 2727 }, 2728 { 2729 ARRAY_SIZE(kInstruction_mov_al_r14_0x8002), 2730 kInstruction_mov_al_r14_0x8002, 2731 }, 2732 { 2733 ARRAY_SIZE(kInstruction_mov_al_r14_0x8003), 2734 kInstruction_mov_al_r14_0x8003, 2735 }, 2736 { 2737 ARRAY_SIZE(kInstruction_mov_al_r14_0xff80), 2738 kInstruction_mov_al_r14_0xff80, 2739 }, 2740 { 2741 ARRAY_SIZE(kInstruction_mov_al_r14_0xff81), 2742 kInstruction_mov_al_r14_0xff81, 2743 }, 2744 { 2745 ARRAY_SIZE(kInstruction_mov_al_r14_0xff82), 2746 kInstruction_mov_al_r14_0xff82, 2747 }, 2748 { 2749 ARRAY_SIZE(kInstruction_mov_al_r14_0xff83), 2750 kInstruction_mov_al_r14_0xff83, 2751 }, 2752 { 2753 ARRAY_SIZE(kInstruction_mov_al_r14_0xffe0), 2754 kInstruction_mov_al_r14_0xffe0, 2755 }, 2756 { 2757 ARRAY_SIZE(kInstruction_mov_al_r14_0xfffd), 2758 kInstruction_mov_al_r14_0xfffd, 2759 }, 2760 { 2761 ARRAY_SIZE(kInstruction_mov_al_r14_0xfffe), 2762 kInstruction_mov_al_r14_0xfffe, 2763 }, 2764 { 2765 ARRAY_SIZE(kInstruction_mov_al_r14_0xffff), 2766 kInstruction_mov_al_r14_0xffff, 2767 }, 2768 }; 2769 2770 #endif // VIXL_ASSEMBLER_COND_RD_OPERAND_IMM16_MOV_T32_H_ 2771