xref: /third_party/vixl/test/aarch32/traces/assembler-cond-rd-operand-imm16-movw-t32.h

// Copyright 2015, VIXL authors
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   * Redistributions of source code must retain the above copyright notice,
//     this list of conditions and the following disclaimer.
//   * Redistributions in binary form must reproduce the above copyright notice,
//     this list of conditions and the following disclaimer in the documentation
//     and/or other materials provided with the distribution.
//   * Neither the name of ARM Limited nor the names of its contributors may be
//     used to endorse or promote products derived from this software without
//     specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


// ---------------------------------------------------------------------
// This file is auto generated using tools/generate_simulator_traces.py.
//
// PLEASE DO NOT EDIT.
// ---------------------------------------------------------------------

#ifndef VIXL_ASSEMBLER_COND_RD_OPERAND_IMM16_MOVW_T32_H_
#define VIXL_ASSEMBLER_COND_RD_OPERAND_IMM16_MOVW_T32_H_

const byte kInstruction_movw_al_r0_0x0000[] = {
  0x40, 0xf2, 0x00, 0x00 // movw al r0 0x0000
};
const byte kInstruction_movw_al_r0_0x0001[] = {
  0x40, 0xf2, 0x01, 0x00 // movw al r0 0x0001
};
const byte kInstruction_movw_al_r0_0x0002[] = {
  0x40, 0xf2, 0x02, 0x00 // movw al r0 0x0002
};
const byte kInstruction_movw_al_r0_0x0020[] = {
  0x40, 0xf2, 0x20, 0x00 // movw al r0 0x0020
};
const byte kInstruction_movw_al_r0_0x007d[] = {
  0x40, 0xf2, 0x7d, 0x00 // movw al r0 0x007d
};
const byte kInstruction_movw_al_r0_0x007e[] = {
  0x40, 0xf2, 0x7e, 0x00 // movw al r0 0x007e
};
const byte kInstruction_movw_al_r0_0x007f[] = {
  0x40, 0xf2, 0x7f, 0x00 // movw al r0 0x007f
};
const byte kInstruction_movw_al_r0_0x7ffd[] = {
  0x47, 0xf6, 0xfd, 0x70 // movw al r0 0x7ffd
};
const byte kInstruction_movw_al_r0_0x7ffe[] = {
  0x47, 0xf6, 0xfe, 0x70 // movw al r0 0x7ffe
};
const byte kInstruction_movw_al_r0_0x7fff[] = {
  0x47, 0xf6, 0xff, 0x70 // movw al r0 0x7fff
};
const byte kInstruction_movw_al_r0_0x3333[] = {
  0x43, 0xf2, 0x33, 0x30 // movw al r0 0x3333
};
const byte kInstruction_movw_al_r0_0x5555[] = {
  0x45, 0xf2, 0x55, 0x50 // movw al r0 0x5555
};
const byte kInstruction_movw_al_r0_0xaaaa[] = {
  0x4a, 0xf6, 0xaa, 0x20 // movw al r0 0xaaaa
};
const byte kInstruction_movw_al_r0_0xcccc[] = {
  0x4c, 0xf6, 0xcc, 0x40 // movw al r0 0xcccc
};
const byte kInstruction_movw_al_r0_0x8000[] = {
  0x48, 0xf2, 0x00, 0x00 // movw al r0 0x8000
};
const byte kInstruction_movw_al_r0_0x8001[] = {
  0x48, 0xf2, 0x01, 0x00 // movw al r0 0x8001
};
const byte kInstruction_movw_al_r0_0x8002[] = {
  0x48, 0xf2, 0x02, 0x00 // movw al r0 0x8002
};
const byte kInstruction_movw_al_r0_0x8003[] = {
  0x48, 0xf2, 0x03, 0x00 // movw al r0 0x8003
};
const byte kInstruction_movw_al_r0_0xff80[] = {
  0x4f, 0xf6, 0x80, 0x70 // movw al r0 0xff80
};
const byte kInstruction_movw_al_r0_0xff81[] = {
  0x4f, 0xf6, 0x81, 0x70 // movw al r0 0xff81
};
const byte kInstruction_movw_al_r0_0xff82[] = {
  0x4f, 0xf6, 0x82, 0x70 // movw al r0 0xff82
};
const byte kInstruction_movw_al_r0_0xff83[] = {
  0x4f, 0xf6, 0x83, 0x70 // movw al r0 0xff83
};
const byte kInstruction_movw_al_r0_0xffe0[] = {
  0x4f, 0xf6, 0xe0, 0x70 // movw al r0 0xffe0
};
const byte kInstruction_movw_al_r0_0xfffd[] = {
  0x4f, 0xf6, 0xfd, 0x70 // movw al r0 0xfffd
};
const byte kInstruction_movw_al_r0_0xfffe[] = {
  0x4f, 0xf6, 0xfe, 0x70 // movw al r0 0xfffe
};
const byte kInstruction_movw_al_r0_0xffff[] = {
  0x4f, 0xf6, 0xff, 0x70 // movw al r0 0xffff
};
const byte kInstruction_movw_al_r1_0x0000[] = {
  0x40, 0xf2, 0x00, 0x01 // movw al r1 0x0000
};
const byte kInstruction_movw_al_r1_0x0001[] = {
  0x40, 0xf2, 0x01, 0x01 // movw al r1 0x0001
};
const byte kInstruction_movw_al_r1_0x0002[] = {
  0x40, 0xf2, 0x02, 0x01 // movw al r1 0x0002
};
const byte kInstruction_movw_al_r1_0x0020[] = {
  0x40, 0xf2, 0x20, 0x01 // movw al r1 0x0020
};
const byte kInstruction_movw_al_r1_0x007d[] = {
  0x40, 0xf2, 0x7d, 0x01 // movw al r1 0x007d
};
const byte kInstruction_movw_al_r1_0x007e[] = {
  0x40, 0xf2, 0x7e, 0x01 // movw al r1 0x007e
};
const byte kInstruction_movw_al_r1_0x007f[] = {
  0x40, 0xf2, 0x7f, 0x01 // movw al r1 0x007f
};
const byte kInstruction_movw_al_r1_0x7ffd[] = {
  0x47, 0xf6, 0xfd, 0x71 // movw al r1 0x7ffd
};
const byte kInstruction_movw_al_r1_0x7ffe[] = {
  0x47, 0xf6, 0xfe, 0x71 // movw al r1 0x7ffe
};
const byte kInstruction_movw_al_r1_0x7fff[] = {
  0x47, 0xf6, 0xff, 0x71 // movw al r1 0x7fff
};
const byte kInstruction_movw_al_r1_0x3333[] = {
  0x43, 0xf2, 0x33, 0x31 // movw al r1 0x3333
};
const byte kInstruction_movw_al_r1_0x5555[] = {
  0x45, 0xf2, 0x55, 0x51 // movw al r1 0x5555
};
const byte kInstruction_movw_al_r1_0xaaaa[] = {
  0x4a, 0xf6, 0xaa, 0x21 // movw al r1 0xaaaa
};
const byte kInstruction_movw_al_r1_0xcccc[] = {
  0x4c, 0xf6, 0xcc, 0x41 // movw al r1 0xcccc
};
const byte kInstruction_movw_al_r1_0x8000[] = {
  0x48, 0xf2, 0x00, 0x01 // movw al r1 0x8000
};
const byte kInstruction_movw_al_r1_0x8001[] = {
  0x48, 0xf2, 0x01, 0x01 // movw al r1 0x8001
};
const byte kInstruction_movw_al_r1_0x8002[] = {
  0x48, 0xf2, 0x02, 0x01 // movw al r1 0x8002
};
const byte kInstruction_movw_al_r1_0x8003[] = {
  0x48, 0xf2, 0x03, 0x01 // movw al r1 0x8003
};
const byte kInstruction_movw_al_r1_0xff80[] = {
  0x4f, 0xf6, 0x80, 0x71 // movw al r1 0xff80
};
const byte kInstruction_movw_al_r1_0xff81[] = {
  0x4f, 0xf6, 0x81, 0x71 // movw al r1 0xff81
};
const byte kInstruction_movw_al_r1_0xff82[] = {
  0x4f, 0xf6, 0x82, 0x71 // movw al r1 0xff82
};
const byte kInstruction_movw_al_r1_0xff83[] = {
  0x4f, 0xf6, 0x83, 0x71 // movw al r1 0xff83
};
const byte kInstruction_movw_al_r1_0xffe0[] = {
  0x4f, 0xf6, 0xe0, 0x71 // movw al r1 0xffe0
};
const byte kInstruction_movw_al_r1_0xfffd[] = {
  0x4f, 0xf6, 0xfd, 0x71 // movw al r1 0xfffd
};
const byte kInstruction_movw_al_r1_0xfffe[] = {
  0x4f, 0xf6, 0xfe, 0x71 // movw al r1 0xfffe
};
const byte kInstruction_movw_al_r1_0xffff[] = {
  0x4f, 0xf6, 0xff, 0x71 // movw al r1 0xffff
};
const byte kInstruction_movw_al_r2_0x0000[] = {
  0x40, 0xf2, 0x00, 0x02 // movw al r2 0x0000
};
const byte kInstruction_movw_al_r2_0x0001[] = {
  0x40, 0xf2, 0x01, 0x02 // movw al r2 0x0001
};
const byte kInstruction_movw_al_r2_0x0002[] = {
  0x40, 0xf2, 0x02, 0x02 // movw al r2 0x0002
};
const byte kInstruction_movw_al_r2_0x0020[] = {
  0x40, 0xf2, 0x20, 0x02 // movw al r2 0x0020
};
const byte kInstruction_movw_al_r2_0x007d[] = {
  0x40, 0xf2, 0x7d, 0x02 // movw al r2 0x007d
};
const byte kInstruction_movw_al_r2_0x007e[] = {
  0x40, 0xf2, 0x7e, 0x02 // movw al r2 0x007e
};
const byte kInstruction_movw_al_r2_0x007f[] = {
  0x40, 0xf2, 0x7f, 0x02 // movw al r2 0x007f
};
const byte kInstruction_movw_al_r2_0x7ffd[] = {
  0x47, 0xf6, 0xfd, 0x72 // movw al r2 0x7ffd
};
const byte kInstruction_movw_al_r2_0x7ffe[] = {
  0x47, 0xf6, 0xfe, 0x72 // movw al r2 0x7ffe
};
const byte kInstruction_movw_al_r2_0x7fff[] = {
  0x47, 0xf6, 0xff, 0x72 // movw al r2 0x7fff
};
const byte kInstruction_movw_al_r2_0x3333[] = {
  0x43, 0xf2, 0x33, 0x32 // movw al r2 0x3333
};
const byte kInstruction_movw_al_r2_0x5555[] = {
  0x45, 0xf2, 0x55, 0x52 // movw al r2 0x5555
};
const byte kInstruction_movw_al_r2_0xaaaa[] = {
  0x4a, 0xf6, 0xaa, 0x22 // movw al r2 0xaaaa
};
const byte kInstruction_movw_al_r2_0xcccc[] = {
  0x4c, 0xf6, 0xcc, 0x42 // movw al r2 0xcccc
};
const byte kInstruction_movw_al_r2_0x8000[] = {
  0x48, 0xf2, 0x00, 0x02 // movw al r2 0x8000
};
const byte kInstruction_movw_al_r2_0x8001[] = {
  0x48, 0xf2, 0x01, 0x02 // movw al r2 0x8001
};
const byte kInstruction_movw_al_r2_0x8002[] = {
  0x48, 0xf2, 0x02, 0x02 // movw al r2 0x8002
};
const byte kInstruction_movw_al_r2_0x8003[] = {
  0x48, 0xf2, 0x03, 0x02 // movw al r2 0x8003
};
const byte kInstruction_movw_al_r2_0xff80[] = {
  0x4f, 0xf6, 0x80, 0x72 // movw al r2 0xff80
};
const byte kInstruction_movw_al_r2_0xff81[] = {
  0x4f, 0xf6, 0x81, 0x72 // movw al r2 0xff81
};
const byte kInstruction_movw_al_r2_0xff82[] = {
  0x4f, 0xf6, 0x82, 0x72 // movw al r2 0xff82
};
const byte kInstruction_movw_al_r2_0xff83[] = {
  0x4f, 0xf6, 0x83, 0x72 // movw al r2 0xff83
};
const byte kInstruction_movw_al_r2_0xffe0[] = {
  0x4f, 0xf6, 0xe0, 0x72 // movw al r2 0xffe0
};
const byte kInstruction_movw_al_r2_0xfffd[] = {
  0x4f, 0xf6, 0xfd, 0x72 // movw al r2 0xfffd
};
const byte kInstruction_movw_al_r2_0xfffe[] = {
  0x4f, 0xf6, 0xfe, 0x72 // movw al r2 0xfffe
};
const byte kInstruction_movw_al_r2_0xffff[] = {
  0x4f, 0xf6, 0xff, 0x72 // movw al r2 0xffff
};
const byte kInstruction_movw_al_r3_0x0000[] = {
  0x40, 0xf2, 0x00, 0x03 // movw al r3 0x0000
};
const byte kInstruction_movw_al_r3_0x0001[] = {
  0x40, 0xf2, 0x01, 0x03 // movw al r3 0x0001
};
const byte kInstruction_movw_al_r3_0x0002[] = {
  0x40, 0xf2, 0x02, 0x03 // movw al r3 0x0002
};
const byte kInstruction_movw_al_r3_0x0020[] = {
  0x40, 0xf2, 0x20, 0x03 // movw al r3 0x0020
};
const byte kInstruction_movw_al_r3_0x007d[] = {
  0x40, 0xf2, 0x7d, 0x03 // movw al r3 0x007d
};
const byte kInstruction_movw_al_r3_0x007e[] = {
  0x40, 0xf2, 0x7e, 0x03 // movw al r3 0x007e
};
const byte kInstruction_movw_al_r3_0x007f[] = {
  0x40, 0xf2, 0x7f, 0x03 // movw al r3 0x007f
};
const byte kInstruction_movw_al_r3_0x7ffd[] = {
  0x47, 0xf6, 0xfd, 0x73 // movw al r3 0x7ffd
};
const byte kInstruction_movw_al_r3_0x7ffe[] = {
  0x47, 0xf6, 0xfe, 0x73 // movw al r3 0x7ffe
};
const byte kInstruction_movw_al_r3_0x7fff[] = {
  0x47, 0xf6, 0xff, 0x73 // movw al r3 0x7fff
};
const byte kInstruction_movw_al_r3_0x3333[] = {
  0x43, 0xf2, 0x33, 0x33 // movw al r3 0x3333
};
const byte kInstruction_movw_al_r3_0x5555[] = {
  0x45, 0xf2, 0x55, 0x53 // movw al r3 0x5555
};
const byte kInstruction_movw_al_r3_0xaaaa[] = {
  0x4a, 0xf6, 0xaa, 0x23 // movw al r3 0xaaaa
};
const byte kInstruction_movw_al_r3_0xcccc[] = {
  0x4c, 0xf6, 0xcc, 0x43 // movw al r3 0xcccc
};
const byte kInstruction_movw_al_r3_0x8000[] = {
  0x48, 0xf2, 0x00, 0x03 // movw al r3 0x8000
};
const byte kInstruction_movw_al_r3_0x8001[] = {
  0x48, 0xf2, 0x01, 0x03 // movw al r3 0x8001
};
const byte kInstruction_movw_al_r3_0x8002[] = {
  0x48, 0xf2, 0x02, 0x03 // movw al r3 0x8002
};
const byte kInstruction_movw_al_r3_0x8003[] = {
  0x48, 0xf2, 0x03, 0x03 // movw al r3 0x8003
};
const byte kInstruction_movw_al_r3_0xff80[] = {
  0x4f, 0xf6, 0x80, 0x73 // movw al r3 0xff80
};
const byte kInstruction_movw_al_r3_0xff81[] = {
  0x4f, 0xf6, 0x81, 0x73 // movw al r3 0xff81
};
const byte kInstruction_movw_al_r3_0xff82[] = {
  0x4f, 0xf6, 0x82, 0x73 // movw al r3 0xff82
};
const byte kInstruction_movw_al_r3_0xff83[] = {
  0x4f, 0xf6, 0x83, 0x73 // movw al r3 0xff83
};
const byte kInstruction_movw_al_r3_0xffe0[] = {
  0x4f, 0xf6, 0xe0, 0x73 // movw al r3 0xffe0
};
const byte kInstruction_movw_al_r3_0xfffd[] = {
  0x4f, 0xf6, 0xfd, 0x73 // movw al r3 0xfffd
};
const byte kInstruction_movw_al_r3_0xfffe[] = {
  0x4f, 0xf6, 0xfe, 0x73 // movw al r3 0xfffe
};
const byte kInstruction_movw_al_r3_0xffff[] = {
  0x4f, 0xf6, 0xff, 0x73 // movw al r3 0xffff
};
const byte kInstruction_movw_al_r4_0x0000[] = {
  0x40, 0xf2, 0x00, 0x04 // movw al r4 0x0000
};
const byte kInstruction_movw_al_r4_0x0001[] = {
  0x40, 0xf2, 0x01, 0x04 // movw al r4 0x0001
};
const byte kInstruction_movw_al_r4_0x0002[] = {
  0x40, 0xf2, 0x02, 0x04 // movw al r4 0x0002
};
const byte kInstruction_movw_al_r4_0x0020[] = {
  0x40, 0xf2, 0x20, 0x04 // movw al r4 0x0020
};
const byte kInstruction_movw_al_r4_0x007d[] = {
  0x40, 0xf2, 0x7d, 0x04 // movw al r4 0x007d
};
const byte kInstruction_movw_al_r4_0x007e[] = {
  0x40, 0xf2, 0x7e, 0x04 // movw al r4 0x007e
};
const byte kInstruction_movw_al_r4_0x007f[] = {
  0x40, 0xf2, 0x7f, 0x04 // movw al r4 0x007f
};
const byte kInstruction_movw_al_r4_0x7ffd[] = {
  0x47, 0xf6, 0xfd, 0x74 // movw al r4 0x7ffd
};
const byte kInstruction_movw_al_r4_0x7ffe[] = {
  0x47, 0xf6, 0xfe, 0x74 // movw al r4 0x7ffe
};
const byte kInstruction_movw_al_r4_0x7fff[] = {
  0x47, 0xf6, 0xff, 0x74 // movw al r4 0x7fff
};
const byte kInstruction_movw_al_r4_0x3333[] = {
  0x43, 0xf2, 0x33, 0x34 // movw al r4 0x3333
};
const byte kInstruction_movw_al_r4_0x5555[] = {
  0x45, 0xf2, 0x55, 0x54 // movw al r4 0x5555
};
const byte kInstruction_movw_al_r4_0xaaaa[] = {
  0x4a, 0xf6, 0xaa, 0x24 // movw al r4 0xaaaa
};
const byte kInstruction_movw_al_r4_0xcccc[] = {
  0x4c, 0xf6, 0xcc, 0x44 // movw al r4 0xcccc
};
const byte kInstruction_movw_al_r4_0x8000[] = {
  0x48, 0xf2, 0x00, 0x04 // movw al r4 0x8000
};
const byte kInstruction_movw_al_r4_0x8001[] = {
  0x48, 0xf2, 0x01, 0x04 // movw al r4 0x8001
};
const byte kInstruction_movw_al_r4_0x8002[] = {
  0x48, 0xf2, 0x02, 0x04 // movw al r4 0x8002
};
const byte kInstruction_movw_al_r4_0x8003[] = {
  0x48, 0xf2, 0x03, 0x04 // movw al r4 0x8003
};
const byte kInstruction_movw_al_r4_0xff80[] = {
  0x4f, 0xf6, 0x80, 0x74 // movw al r4 0xff80
};
const byte kInstruction_movw_al_r4_0xff81[] = {
  0x4f, 0xf6, 0x81, 0x74 // movw al r4 0xff81
};
const byte kInstruction_movw_al_r4_0xff82[] = {
  0x4f, 0xf6, 0x82, 0x74 // movw al r4 0xff82
};
const byte kInstruction_movw_al_r4_0xff83[] = {
  0x4f, 0xf6, 0x83, 0x74 // movw al r4 0xff83
};
const byte kInstruction_movw_al_r4_0xffe0[] = {
  0x4f, 0xf6, 0xe0, 0x74 // movw al r4 0xffe0
};
const byte kInstruction_movw_al_r4_0xfffd[] = {
  0x4f, 0xf6, 0xfd, 0x74 // movw al r4 0xfffd
};
const byte kInstruction_movw_al_r4_0xfffe[] = {
  0x4f, 0xf6, 0xfe, 0x74 // movw al r4 0xfffe
};
const byte kInstruction_movw_al_r4_0xffff[] = {
  0x4f, 0xf6, 0xff, 0x74 // movw al r4 0xffff
};
const byte kInstruction_movw_al_r5_0x0000[] = {
  0x40, 0xf2, 0x00, 0x05 // movw al r5 0x0000
};
const byte kInstruction_movw_al_r5_0x0001[] = {
  0x40, 0xf2, 0x01, 0x05 // movw al r5 0x0001
};
const byte kInstruction_movw_al_r5_0x0002[] = {
  0x40, 0xf2, 0x02, 0x05 // movw al r5 0x0002
};
const byte kInstruction_movw_al_r5_0x0020[] = {
  0x40, 0xf2, 0x20, 0x05 // movw al r5 0x0020
};
const byte kInstruction_movw_al_r5_0x007d[] = {
  0x40, 0xf2, 0x7d, 0x05 // movw al r5 0x007d
};
const byte kInstruction_movw_al_r5_0x007e[] = {
  0x40, 0xf2, 0x7e, 0x05 // movw al r5 0x007e
};
const byte kInstruction_movw_al_r5_0x007f[] = {
  0x40, 0xf2, 0x7f, 0x05 // movw al r5 0x007f
};
const byte kInstruction_movw_al_r5_0x7ffd[] = {
  0x47, 0xf6, 0xfd, 0x75 // movw al r5 0x7ffd
};
const byte kInstruction_movw_al_r5_0x7ffe[] = {
  0x47, 0xf6, 0xfe, 0x75 // movw al r5 0x7ffe
};
const byte kInstruction_movw_al_r5_0x7fff[] = {
  0x47, 0xf6, 0xff, 0x75 // movw al r5 0x7fff
};
const byte kInstruction_movw_al_r5_0x3333[] = {
  0x43, 0xf2, 0x33, 0x35 // movw al r5 0x3333
};
const byte kInstruction_movw_al_r5_0x5555[] = {
  0x45, 0xf2, 0x55, 0x55 // movw al r5 0x5555
};
const byte kInstruction_movw_al_r5_0xaaaa[] = {
  0x4a, 0xf6, 0xaa, 0x25 // movw al r5 0xaaaa
};
const byte kInstruction_movw_al_r5_0xcccc[] = {
  0x4c, 0xf6, 0xcc, 0x45 // movw al r5 0xcccc
};
const byte kInstruction_movw_al_r5_0x8000[] = {
  0x48, 0xf2, 0x00, 0x05 // movw al r5 0x8000
};
const byte kInstruction_movw_al_r5_0x8001[] = {
  0x48, 0xf2, 0x01, 0x05 // movw al r5 0x8001
};
const byte kInstruction_movw_al_r5_0x8002[] = {
  0x48, 0xf2, 0x02, 0x05 // movw al r5 0x8002
};
const byte kInstruction_movw_al_r5_0x8003[] = {
  0x48, 0xf2, 0x03, 0x05 // movw al r5 0x8003
};
const byte kInstruction_movw_al_r5_0xff80[] = {
  0x4f, 0xf6, 0x80, 0x75 // movw al r5 0xff80
};
const byte kInstruction_movw_al_r5_0xff81[] = {
  0x4f, 0xf6, 0x81, 0x75 // movw al r5 0xff81
};
const byte kInstruction_movw_al_r5_0xff82[] = {
  0x4f, 0xf6, 0x82, 0x75 // movw al r5 0xff82
};
const byte kInstruction_movw_al_r5_0xff83[] = {
  0x4f, 0xf6, 0x83, 0x75 // movw al r5 0xff83
};
const byte kInstruction_movw_al_r5_0xffe0[] = {
  0x4f, 0xf6, 0xe0, 0x75 // movw al r5 0xffe0
};
const byte kInstruction_movw_al_r5_0xfffd[] = {
  0x4f, 0xf6, 0xfd, 0x75 // movw al r5 0xfffd
};
const byte kInstruction_movw_al_r5_0xfffe[] = {
  0x4f, 0xf6, 0xfe, 0x75 // movw al r5 0xfffe
};
const byte kInstruction_movw_al_r5_0xffff[] = {
  0x4f, 0xf6, 0xff, 0x75 // movw al r5 0xffff
};
const byte kInstruction_movw_al_r6_0x0000[] = {
  0x40, 0xf2, 0x00, 0x06 // movw al r6 0x0000
};
const byte kInstruction_movw_al_r6_0x0001[] = {
  0x40, 0xf2, 0x01, 0x06 // movw al r6 0x0001
};
const byte kInstruction_movw_al_r6_0x0002[] = {
  0x40, 0xf2, 0x02, 0x06 // movw al r6 0x0002
};
const byte kInstruction_movw_al_r6_0x0020[] = {
  0x40, 0xf2, 0x20, 0x06 // movw al r6 0x0020
};
const byte kInstruction_movw_al_r6_0x007d[] = {
  0x40, 0xf2, 0x7d, 0x06 // movw al r6 0x007d
};
const byte kInstruction_movw_al_r6_0x007e[] = {
  0x40, 0xf2, 0x7e, 0x06 // movw al r6 0x007e
};
const byte kInstruction_movw_al_r6_0x007f[] = {
  0x40, 0xf2, 0x7f, 0x06 // movw al r6 0x007f
};
const byte kInstruction_movw_al_r6_0x7ffd[] = {
  0x47, 0xf6, 0xfd, 0x76 // movw al r6 0x7ffd
};
const byte kInstruction_movw_al_r6_0x7ffe[] = {
  0x47, 0xf6, 0xfe, 0x76 // movw al r6 0x7ffe
};
const byte kInstruction_movw_al_r6_0x7fff[] = {
  0x47, 0xf6, 0xff, 0x76 // movw al r6 0x7fff
};
const byte kInstruction_movw_al_r6_0x3333[] = {
  0x43, 0xf2, 0x33, 0x36 // movw al r6 0x3333
};
const byte kInstruction_movw_al_r6_0x5555[] = {
  0x45, 0xf2, 0x55, 0x56 // movw al r6 0x5555
};
const byte kInstruction_movw_al_r6_0xaaaa[] = {
  0x4a, 0xf6, 0xaa, 0x26 // movw al r6 0xaaaa
};
const byte kInstruction_movw_al_r6_0xcccc[] = {
  0x4c, 0xf6, 0xcc, 0x46 // movw al r6 0xcccc
};
const byte kInstruction_movw_al_r6_0x8000[] = {
  0x48, 0xf2, 0x00, 0x06 // movw al r6 0x8000
};
const byte kInstruction_movw_al_r6_0x8001[] = {
  0x48, 0xf2, 0x01, 0x06 // movw al r6 0x8001
};
const byte kInstruction_movw_al_r6_0x8002[] = {
  0x48, 0xf2, 0x02, 0x06 // movw al r6 0x8002
};
const byte kInstruction_movw_al_r6_0x8003[] = {
  0x48, 0xf2, 0x03, 0x06 // movw al r6 0x8003
};
const byte kInstruction_movw_al_r6_0xff80[] = {
  0x4f, 0xf6, 0x80, 0x76 // movw al r6 0xff80
};
const byte kInstruction_movw_al_r6_0xff81[] = {
  0x4f, 0xf6, 0x81, 0x76 // movw al r6 0xff81
};
const byte kInstruction_movw_al_r6_0xff82[] = {
  0x4f, 0xf6, 0x82, 0x76 // movw al r6 0xff82
};
const byte kInstruction_movw_al_r6_0xff83[] = {
  0x4f, 0xf6, 0x83, 0x76 // movw al r6 0xff83
};
const byte kInstruction_movw_al_r6_0xffe0[] = {
  0x4f, 0xf6, 0xe0, 0x76 // movw al r6 0xffe0
};
const byte kInstruction_movw_al_r6_0xfffd[] = {
  0x4f, 0xf6, 0xfd, 0x76 // movw al r6 0xfffd
};
const byte kInstruction_movw_al_r6_0xfffe[] = {
  0x4f, 0xf6, 0xfe, 0x76 // movw al r6 0xfffe
};
const byte kInstruction_movw_al_r6_0xffff[] = {
  0x4f, 0xf6, 0xff, 0x76 // movw al r6 0xffff
};
const byte kInstruction_movw_al_r7_0x0000[] = {
  0x40, 0xf2, 0x00, 0x07 // movw al r7 0x0000
};
const byte kInstruction_movw_al_r7_0x0001[] = {
  0x40, 0xf2, 0x01, 0x07 // movw al r7 0x0001
};
const byte kInstruction_movw_al_r7_0x0002[] = {
  0x40, 0xf2, 0x02, 0x07 // movw al r7 0x0002
};
const byte kInstruction_movw_al_r7_0x0020[] = {
  0x40, 0xf2, 0x20, 0x07 // movw al r7 0x0020
};
const byte kInstruction_movw_al_r7_0x007d[] = {
  0x40, 0xf2, 0x7d, 0x07 // movw al r7 0x007d
};
const byte kInstruction_movw_al_r7_0x007e[] = {
  0x40, 0xf2, 0x7e, 0x07 // movw al r7 0x007e
};
const byte kInstruction_movw_al_r7_0x007f[] = {
  0x40, 0xf2, 0x7f, 0x07 // movw al r7 0x007f
};
const byte kInstruction_movw_al_r7_0x7ffd[] = {
  0x47, 0xf6, 0xfd, 0x77 // movw al r7 0x7ffd
};
const byte kInstruction_movw_al_r7_0x7ffe[] = {
  0x47, 0xf6, 0xfe, 0x77 // movw al r7 0x7ffe
};
const byte kInstruction_movw_al_r7_0x7fff[] = {
  0x47, 0xf6, 0xff, 0x77 // movw al r7 0x7fff
};
const byte kInstruction_movw_al_r7_0x3333[] = {
  0x43, 0xf2, 0x33, 0x37 // movw al r7 0x3333
};
const byte kInstruction_movw_al_r7_0x5555[] = {
  0x45, 0xf2, 0x55, 0x57 // movw al r7 0x5555
};
const byte kInstruction_movw_al_r7_0xaaaa[] = {
  0x4a, 0xf6, 0xaa, 0x27 // movw al r7 0xaaaa
};
const byte kInstruction_movw_al_r7_0xcccc[] = {
  0x4c, 0xf6, 0xcc, 0x47 // movw al r7 0xcccc
};
const byte kInstruction_movw_al_r7_0x8000[] = {
  0x48, 0xf2, 0x00, 0x07 // movw al r7 0x8000
};
const byte kInstruction_movw_al_r7_0x8001[] = {
  0x48, 0xf2, 0x01, 0x07 // movw al r7 0x8001
};
const byte kInstruction_movw_al_r7_0x8002[] = {
  0x48, 0xf2, 0x02, 0x07 // movw al r7 0x8002
};
const byte kInstruction_movw_al_r7_0x8003[] = {
  0x48, 0xf2, 0x03, 0x07 // movw al r7 0x8003
};
const byte kInstruction_movw_al_r7_0xff80[] = {
  0x4f, 0xf6, 0x80, 0x77 // movw al r7 0xff80
};
const byte kInstruction_movw_al_r7_0xff81[] = {
  0x4f, 0xf6, 0x81, 0x77 // movw al r7 0xff81
};
const byte kInstruction_movw_al_r7_0xff82[] = {
  0x4f, 0xf6, 0x82, 0x77 // movw al r7 0xff82
};
const byte kInstruction_movw_al_r7_0xff83[] = {
  0x4f, 0xf6, 0x83, 0x77 // movw al r7 0xff83
};
const byte kInstruction_movw_al_r7_0xffe0[] = {
  0x4f, 0xf6, 0xe0, 0x77 // movw al r7 0xffe0
};
const byte kInstruction_movw_al_r7_0xfffd[] = {
  0x4f, 0xf6, 0xfd, 0x77 // movw al r7 0xfffd
};
const byte kInstruction_movw_al_r7_0xfffe[] = {
  0x4f, 0xf6, 0xfe, 0x77 // movw al r7 0xfffe
};
const byte kInstruction_movw_al_r7_0xffff[] = {
  0x4f, 0xf6, 0xff, 0x77 // movw al r7 0xffff
};
const byte kInstruction_movw_al_r8_0x0000[] = {
  0x40, 0xf2, 0x00, 0x08 // movw al r8 0x0000
};
const byte kInstruction_movw_al_r8_0x0001[] = {
  0x40, 0xf2, 0x01, 0x08 // movw al r8 0x0001
};
const byte kInstruction_movw_al_r8_0x0002[] = {
  0x40, 0xf2, 0x02, 0x08 // movw al r8 0x0002
};
const byte kInstruction_movw_al_r8_0x0020[] = {
  0x40, 0xf2, 0x20, 0x08 // movw al r8 0x0020
};
const byte kInstruction_movw_al_r8_0x007d[] = {
  0x40, 0xf2, 0x7d, 0x08 // movw al r8 0x007d
};
const byte kInstruction_movw_al_r8_0x007e[] = {
  0x40, 0xf2, 0x7e, 0x08 // movw al r8 0x007e
};
const byte kInstruction_movw_al_r8_0x007f[] = {
  0x40, 0xf2, 0x7f, 0x08 // movw al r8 0x007f
};
const byte kInstruction_movw_al_r8_0x7ffd[] = {
  0x47, 0xf6, 0xfd, 0x78 // movw al r8 0x7ffd
};
const byte kInstruction_movw_al_r8_0x7ffe[] = {
  0x47, 0xf6, 0xfe, 0x78 // movw al r8 0x7ffe
};
const byte kInstruction_movw_al_r8_0x7fff[] = {
  0x47, 0xf6, 0xff, 0x78 // movw al r8 0x7fff
};
const byte kInstruction_movw_al_r8_0x3333[] = {
  0x43, 0xf2, 0x33, 0x38 // movw al r8 0x3333
};
const byte kInstruction_movw_al_r8_0x5555[] = {
  0x45, 0xf2, 0x55, 0x58 // movw al r8 0x5555
};
const byte kInstruction_movw_al_r8_0xaaaa[] = {
  0x4a, 0xf6, 0xaa, 0x28 // movw al r8 0xaaaa
};
const byte kInstruction_movw_al_r8_0xcccc[] = {
  0x4c, 0xf6, 0xcc, 0x48 // movw al r8 0xcccc
};
const byte kInstruction_movw_al_r8_0x8000[] = {
  0x48, 0xf2, 0x00, 0x08 // movw al r8 0x8000
};
const byte kInstruction_movw_al_r8_0x8001[] = {
  0x48, 0xf2, 0x01, 0x08 // movw al r8 0x8001
};
const byte kInstruction_movw_al_r8_0x8002[] = {
  0x48, 0xf2, 0x02, 0x08 // movw al r8 0x8002
};
const byte kInstruction_movw_al_r8_0x8003[] = {
  0x48, 0xf2, 0x03, 0x08 // movw al r8 0x8003
};
const byte kInstruction_movw_al_r8_0xff80[] = {
  0x4f, 0xf6, 0x80, 0x78 // movw al r8 0xff80
};
const byte kInstruction_movw_al_r8_0xff81[] = {
  0x4f, 0xf6, 0x81, 0x78 // movw al r8 0xff81
};
const byte kInstruction_movw_al_r8_0xff82[] = {
  0x4f, 0xf6, 0x82, 0x78 // movw al r8 0xff82
};
const byte kInstruction_movw_al_r8_0xff83[] = {
  0x4f, 0xf6, 0x83, 0x78 // movw al r8 0xff83
};
const byte kInstruction_movw_al_r8_0xffe0[] = {
  0x4f, 0xf6, 0xe0, 0x78 // movw al r8 0xffe0
};
const byte kInstruction_movw_al_r8_0xfffd[] = {
  0x4f, 0xf6, 0xfd, 0x78 // movw al r8 0xfffd
};
const byte kInstruction_movw_al_r8_0xfffe[] = {
  0x4f, 0xf6, 0xfe, 0x78 // movw al r8 0xfffe
};
const byte kInstruction_movw_al_r8_0xffff[] = {
  0x4f, 0xf6, 0xff, 0x78 // movw al r8 0xffff
};
const byte kInstruction_movw_al_r9_0x0000[] = {
  0x40, 0xf2, 0x00, 0x09 // movw al r9 0x0000
};
const byte kInstruction_movw_al_r9_0x0001[] = {
  0x40, 0xf2, 0x01, 0x09 // movw al r9 0x0001
};
const byte kInstruction_movw_al_r9_0x0002[] = {
  0x40, 0xf2, 0x02, 0x09 // movw al r9 0x0002
};
const byte kInstruction_movw_al_r9_0x0020[] = {
  0x40, 0xf2, 0x20, 0x09 // movw al r9 0x0020
};
const byte kInstruction_movw_al_r9_0x007d[] = {
  0x40, 0xf2, 0x7d, 0x09 // movw al r9 0x007d
};
const byte kInstruction_movw_al_r9_0x007e[] = {
  0x40, 0xf2, 0x7e, 0x09 // movw al r9 0x007e
};
const byte kInstruction_movw_al_r9_0x007f[] = {
  0x40, 0xf2, 0x7f, 0x09 // movw al r9 0x007f
};
const byte kInstruction_movw_al_r9_0x7ffd[] = {
  0x47, 0xf6, 0xfd, 0x79 // movw al r9 0x7ffd
};
const byte kInstruction_movw_al_r9_0x7ffe[] = {
  0x47, 0xf6, 0xfe, 0x79 // movw al r9 0x7ffe
};
const byte kInstruction_movw_al_r9_0x7fff[] = {
  0x47, 0xf6, 0xff, 0x79 // movw al r9 0x7fff
};
const byte kInstruction_movw_al_r9_0x3333[] = {
  0x43, 0xf2, 0x33, 0x39 // movw al r9 0x3333
};
const byte kInstruction_movw_al_r9_0x5555[] = {
  0x45, 0xf2, 0x55, 0x59 // movw al r9 0x5555
};
const byte kInstruction_movw_al_r9_0xaaaa[] = {
  0x4a, 0xf6, 0xaa, 0x29 // movw al r9 0xaaaa
};
const byte kInstruction_movw_al_r9_0xcccc[] = {
  0x4c, 0xf6, 0xcc, 0x49 // movw al r9 0xcccc
};
const byte kInstruction_movw_al_r9_0x8000[] = {
  0x48, 0xf2, 0x00, 0x09 // movw al r9 0x8000
};
const byte kInstruction_movw_al_r9_0x8001[] = {
  0x48, 0xf2, 0x01, 0x09 // movw al r9 0x8001
};
const byte kInstruction_movw_al_r9_0x8002[] = {
  0x48, 0xf2, 0x02, 0x09 // movw al r9 0x8002
};
const byte kInstruction_movw_al_r9_0x8003[] = {
  0x48, 0xf2, 0x03, 0x09 // movw al r9 0x8003
};
const byte kInstruction_movw_al_r9_0xff80[] = {
  0x4f, 0xf6, 0x80, 0x79 // movw al r9 0xff80
};
const byte kInstruction_movw_al_r9_0xff81[] = {
  0x4f, 0xf6, 0x81, 0x79 // movw al r9 0xff81
};
const byte kInstruction_movw_al_r9_0xff82[] = {
  0x4f, 0xf6, 0x82, 0x79 // movw al r9 0xff82
};
const byte kInstruction_movw_al_r9_0xff83[] = {
  0x4f, 0xf6, 0x83, 0x79 // movw al r9 0xff83
};
const byte kInstruction_movw_al_r9_0xffe0[] = {
  0x4f, 0xf6, 0xe0, 0x79 // movw al r9 0xffe0
};
const byte kInstruction_movw_al_r9_0xfffd[] = {
  0x4f, 0xf6, 0xfd, 0x79 // movw al r9 0xfffd
};
const byte kInstruction_movw_al_r9_0xfffe[] = {
  0x4f, 0xf6, 0xfe, 0x79 // movw al r9 0xfffe
};
const byte kInstruction_movw_al_r9_0xffff[] = {
  0x4f, 0xf6, 0xff, 0x79 // movw al r9 0xffff
};
const byte kInstruction_movw_al_r10_0x0000[] = {
  0x40, 0xf2, 0x00, 0x0a // movw al r10 0x0000
};
const byte kInstruction_movw_al_r10_0x0001[] = {
  0x40, 0xf2, 0x01, 0x0a // movw al r10 0x0001
};
const byte kInstruction_movw_al_r10_0x0002[] = {
  0x40, 0xf2, 0x02, 0x0a // movw al r10 0x0002
};
const byte kInstruction_movw_al_r10_0x0020[] = {
  0x40, 0xf2, 0x20, 0x0a // movw al r10 0x0020
};
const byte kInstruction_movw_al_r10_0x007d[] = {
  0x40, 0xf2, 0x7d, 0x0a // movw al r10 0x007d
};
const byte kInstruction_movw_al_r10_0x007e[] = {
  0x40, 0xf2, 0x7e, 0x0a // movw al r10 0x007e
};
const byte kInstruction_movw_al_r10_0x007f[] = {
  0x40, 0xf2, 0x7f, 0x0a // movw al r10 0x007f
};
const byte kInstruction_movw_al_r10_0x7ffd[] = {
  0x47, 0xf6, 0xfd, 0x7a // movw al r10 0x7ffd
};
const byte kInstruction_movw_al_r10_0x7ffe[] = {
  0x47, 0xf6, 0xfe, 0x7a // movw al r10 0x7ffe
};
const byte kInstruction_movw_al_r10_0x7fff[] = {
  0x47, 0xf6, 0xff, 0x7a // movw al r10 0x7fff
};
const byte kInstruction_movw_al_r10_0x3333[] = {
  0x43, 0xf2, 0x33, 0x3a // movw al r10 0x3333
};
const byte kInstruction_movw_al_r10_0x5555[] = {
  0x45, 0xf2, 0x55, 0x5a // movw al r10 0x5555
};
const byte kInstruction_movw_al_r10_0xaaaa[] = {
  0x4a, 0xf6, 0xaa, 0x2a // movw al r10 0xaaaa
};
const byte kInstruction_movw_al_r10_0xcccc[] = {
  0x4c, 0xf6, 0xcc, 0x4a // movw al r10 0xcccc
};
const byte kInstruction_movw_al_r10_0x8000[] = {
  0x48, 0xf2, 0x00, 0x0a // movw al r10 0x8000
};
const byte kInstruction_movw_al_r10_0x8001[] = {
  0x48, 0xf2, 0x01, 0x0a // movw al r10 0x8001
};
const byte kInstruction_movw_al_r10_0x8002[] = {
  0x48, 0xf2, 0x02, 0x0a // movw al r10 0x8002
};
const byte kInstruction_movw_al_r10_0x8003[] = {
  0x48, 0xf2, 0x03, 0x0a // movw al r10 0x8003
};
const byte kInstruction_movw_al_r10_0xff80[] = {
  0x4f, 0xf6, 0x80, 0x7a // movw al r10 0xff80
};
const byte kInstruction_movw_al_r10_0xff81[] = {
  0x4f, 0xf6, 0x81, 0x7a // movw al r10 0xff81
};
const byte kInstruction_movw_al_r10_0xff82[] = {
  0x4f, 0xf6, 0x82, 0x7a // movw al r10 0xff82
};
const byte kInstruction_movw_al_r10_0xff83[] = {
  0x4f, 0xf6, 0x83, 0x7a // movw al r10 0xff83
};
const byte kInstruction_movw_al_r10_0xffe0[] = {
  0x4f, 0xf6, 0xe0, 0x7a // movw al r10 0xffe0
};
const byte kInstruction_movw_al_r10_0xfffd[] = {
  0x4f, 0xf6, 0xfd, 0x7a // movw al r10 0xfffd
};
const byte kInstruction_movw_al_r10_0xfffe[] = {
  0x4f, 0xf6, 0xfe, 0x7a // movw al r10 0xfffe
};
const byte kInstruction_movw_al_r10_0xffff[] = {
  0x4f, 0xf6, 0xff, 0x7a // movw al r10 0xffff
};
const byte kInstruction_movw_al_r11_0x0000[] = {
  0x40, 0xf2, 0x00, 0x0b // movw al r11 0x0000
};
const byte kInstruction_movw_al_r11_0x0001[] = {
  0x40, 0xf2, 0x01, 0x0b // movw al r11 0x0001
};
const byte kInstruction_movw_al_r11_0x0002[] = {
  0x40, 0xf2, 0x02, 0x0b // movw al r11 0x0002
};
const byte kInstruction_movw_al_r11_0x0020[] = {
  0x40, 0xf2, 0x20, 0x0b // movw al r11 0x0020
};
const byte kInstruction_movw_al_r11_0x007d[] = {
  0x40, 0xf2, 0x7d, 0x0b // movw al r11 0x007d
};
const byte kInstruction_movw_al_r11_0x007e[] = {
  0x40, 0xf2, 0x7e, 0x0b // movw al r11 0x007e
};
const byte kInstruction_movw_al_r11_0x007f[] = {
  0x40, 0xf2, 0x7f, 0x0b // movw al r11 0x007f
};
const byte kInstruction_movw_al_r11_0x7ffd[] = {
  0x47, 0xf6, 0xfd, 0x7b // movw al r11 0x7ffd
};
const byte kInstruction_movw_al_r11_0x7ffe[] = {
  0x47, 0xf6, 0xfe, 0x7b // movw al r11 0x7ffe
};
const byte kInstruction_movw_al_r11_0x7fff[] = {
  0x47, 0xf6, 0xff, 0x7b // movw al r11 0x7fff
};
const byte kInstruction_movw_al_r11_0x3333[] = {
  0x43, 0xf2, 0x33, 0x3b // movw al r11 0x3333
};
const byte kInstruction_movw_al_r11_0x5555[] = {
  0x45, 0xf2, 0x55, 0x5b // movw al r11 0x5555
};
const byte kInstruction_movw_al_r11_0xaaaa[] = {
  0x4a, 0xf6, 0xaa, 0x2b // movw al r11 0xaaaa
};
const byte kInstruction_movw_al_r11_0xcccc[] = {
  0x4c, 0xf6, 0xcc, 0x4b // movw al r11 0xcccc
};
const byte kInstruction_movw_al_r11_0x8000[] = {
  0x48, 0xf2, 0x00, 0x0b // movw al r11 0x8000
};
const byte kInstruction_movw_al_r11_0x8001[] = {
  0x48, 0xf2, 0x01, 0x0b // movw al r11 0x8001
};
const byte kInstruction_movw_al_r11_0x8002[] = {
  0x48, 0xf2, 0x02, 0x0b // movw al r11 0x8002
};
const byte kInstruction_movw_al_r11_0x8003[] = {
  0x48, 0xf2, 0x03, 0x0b // movw al r11 0x8003
};
const byte kInstruction_movw_al_r11_0xff80[] = {
  0x4f, 0xf6, 0x80, 0x7b // movw al r11 0xff80
};
const byte kInstruction_movw_al_r11_0xff81[] = {
  0x4f, 0xf6, 0x81, 0x7b // movw al r11 0xff81
};
const byte kInstruction_movw_al_r11_0xff82[] = {
  0x4f, 0xf6, 0x82, 0x7b // movw al r11 0xff82
};
const byte kInstruction_movw_al_r11_0xff83[] = {
  0x4f, 0xf6, 0x83, 0x7b // movw al r11 0xff83
};
const byte kInstruction_movw_al_r11_0xffe0[] = {
  0x4f, 0xf6, 0xe0, 0x7b // movw al r11 0xffe0
};
const byte kInstruction_movw_al_r11_0xfffd[] = {
  0x4f, 0xf6, 0xfd, 0x7b // movw al r11 0xfffd
};
const byte kInstruction_movw_al_r11_0xfffe[] = {
  0x4f, 0xf6, 0xfe, 0x7b // movw al r11 0xfffe
};
const byte kInstruction_movw_al_r11_0xffff[] = {
  0x4f, 0xf6, 0xff, 0x7b // movw al r11 0xffff
};
const byte kInstruction_movw_al_r12_0x0000[] = {
  0x40, 0xf2, 0x00, 0x0c // movw al r12 0x0000
};
const byte kInstruction_movw_al_r12_0x0001[] = {
  0x40, 0xf2, 0x01, 0x0c // movw al r12 0x0001
};
const byte kInstruction_movw_al_r12_0x0002[] = {
  0x40, 0xf2, 0x02, 0x0c // movw al r12 0x0002
};
const byte kInstruction_movw_al_r12_0x0020[] = {
  0x40, 0xf2, 0x20, 0x0c // movw al r12 0x0020
};
const byte kInstruction_movw_al_r12_0x007d[] = {
  0x40, 0xf2, 0x7d, 0x0c // movw al r12 0x007d
};
const byte kInstruction_movw_al_r12_0x007e[] = {
  0x40, 0xf2, 0x7e, 0x0c // movw al r12 0x007e
};
const byte kInstruction_movw_al_r12_0x007f[] = {
  0x40, 0xf2, 0x7f, 0x0c // movw al r12 0x007f
};
const byte kInstruction_movw_al_r12_0x7ffd[] = {
  0x47, 0xf6, 0xfd, 0x7c // movw al r12 0x7ffd
};
const byte kInstruction_movw_al_r12_0x7ffe[] = {
  0x47, 0xf6, 0xfe, 0x7c // movw al r12 0x7ffe
};
const byte kInstruction_movw_al_r12_0x7fff[] = {
  0x47, 0xf6, 0xff, 0x7c // movw al r12 0x7fff
};
const byte kInstruction_movw_al_r12_0x3333[] = {
  0x43, 0xf2, 0x33, 0x3c // movw al r12 0x3333
};
const byte kInstruction_movw_al_r12_0x5555[] = {
  0x45, 0xf2, 0x55, 0x5c // movw al r12 0x5555
};
const byte kInstruction_movw_al_r12_0xaaaa[] = {
  0x4a, 0xf6, 0xaa, 0x2c // movw al r12 0xaaaa
};
const byte kInstruction_movw_al_r12_0xcccc[] = {
  0x4c, 0xf6, 0xcc, 0x4c // movw al r12 0xcccc
};
const byte kInstruction_movw_al_r12_0x8000[] = {
  0x48, 0xf2, 0x00, 0x0c // movw al r12 0x8000
};
const byte kInstruction_movw_al_r12_0x8001[] = {
  0x48, 0xf2, 0x01, 0x0c // movw al r12 0x8001
};
const byte kInstruction_movw_al_r12_0x8002[] = {
  0x48, 0xf2, 0x02, 0x0c // movw al r12 0x8002
};
const byte kInstruction_movw_al_r12_0x8003[] = {
  0x48, 0xf2, 0x03, 0x0c // movw al r12 0x8003
};
const byte kInstruction_movw_al_r12_0xff80[] = {
  0x4f, 0xf6, 0x80, 0x7c // movw al r12 0xff80
};
const byte kInstruction_movw_al_r12_0xff81[] = {
  0x4f, 0xf6, 0x81, 0x7c // movw al r12 0xff81
};
const byte kInstruction_movw_al_r12_0xff82[] = {
  0x4f, 0xf6, 0x82, 0x7c // movw al r12 0xff82
};
const byte kInstruction_movw_al_r12_0xff83[] = {
  0x4f, 0xf6, 0x83, 0x7c // movw al r12 0xff83
};
const byte kInstruction_movw_al_r12_0xffe0[] = {
  0x4f, 0xf6, 0xe0, 0x7c // movw al r12 0xffe0
};
const byte kInstruction_movw_al_r12_0xfffd[] = {
  0x4f, 0xf6, 0xfd, 0x7c // movw al r12 0xfffd
};
const byte kInstruction_movw_al_r12_0xfffe[] = {
  0x4f, 0xf6, 0xfe, 0x7c // movw al r12 0xfffe
};
const byte kInstruction_movw_al_r12_0xffff[] = {
  0x4f, 0xf6, 0xff, 0x7c // movw al r12 0xffff
};
const byte kInstruction_movw_al_r13_0x0000[] = {
  0x40, 0xf2, 0x00, 0x0d // movw al r13 0x0000
};
const byte kInstruction_movw_al_r13_0x0001[] = {
  0x40, 0xf2, 0x01, 0x0d // movw al r13 0x0001
};
const byte kInstruction_movw_al_r13_0x0002[] = {
  0x40, 0xf2, 0x02, 0x0d // movw al r13 0x0002
};
const byte kInstruction_movw_al_r13_0x0020[] = {
  0x40, 0xf2, 0x20, 0x0d // movw al r13 0x0020
};
const byte kInstruction_movw_al_r13_0x007d[] = {
  0x40, 0xf2, 0x7d, 0x0d // movw al r13 0x007d
};
const byte kInstruction_movw_al_r13_0x007e[] = {
  0x40, 0xf2, 0x7e, 0x0d // movw al r13 0x007e
};
const byte kInstruction_movw_al_r13_0x007f[] = {
  0x40, 0xf2, 0x7f, 0x0d // movw al r13 0x007f
};
const byte kInstruction_movw_al_r13_0x7ffd[] = {
  0x47, 0xf6, 0xfd, 0x7d // movw al r13 0x7ffd
};
const byte kInstruction_movw_al_r13_0x7ffe[] = {
  0x47, 0xf6, 0xfe, 0x7d // movw al r13 0x7ffe
};
const byte kInstruction_movw_al_r13_0x7fff[] = {
  0x47, 0xf6, 0xff, 0x7d // movw al r13 0x7fff
};
const byte kInstruction_movw_al_r13_0x3333[] = {
  0x43, 0xf2, 0x33, 0x3d // movw al r13 0x3333
};
const byte kInstruction_movw_al_r13_0x5555[] = {
  0x45, 0xf2, 0x55, 0x5d // movw al r13 0x5555
};
const byte kInstruction_movw_al_r13_0xaaaa[] = {
  0x4a, 0xf6, 0xaa, 0x2d // movw al r13 0xaaaa
};
const byte kInstruction_movw_al_r13_0xcccc[] = {
  0x4c, 0xf6, 0xcc, 0x4d // movw al r13 0xcccc
};
const byte kInstruction_movw_al_r13_0x8000[] = {
  0x48, 0xf2, 0x00, 0x0d // movw al r13 0x8000
};
const byte kInstruction_movw_al_r13_0x8001[] = {
  0x48, 0xf2, 0x01, 0x0d // movw al r13 0x8001
};
const byte kInstruction_movw_al_r13_0x8002[] = {
  0x48, 0xf2, 0x02, 0x0d // movw al r13 0x8002
};
const byte kInstruction_movw_al_r13_0x8003[] = {
  0x48, 0xf2, 0x03, 0x0d // movw al r13 0x8003
};
const byte kInstruction_movw_al_r13_0xff80[] = {
  0x4f, 0xf6, 0x80, 0x7d // movw al r13 0xff80
};
const byte kInstruction_movw_al_r13_0xff81[] = {
  0x4f, 0xf6, 0x81, 0x7d // movw al r13 0xff81
};
const byte kInstruction_movw_al_r13_0xff82[] = {
  0x4f, 0xf6, 0x82, 0x7d // movw al r13 0xff82
};
const byte kInstruction_movw_al_r13_0xff83[] = {
  0x4f, 0xf6, 0x83, 0x7d // movw al r13 0xff83
};
const byte kInstruction_movw_al_r13_0xffe0[] = {
  0x4f, 0xf6, 0xe0, 0x7d // movw al r13 0xffe0
};
const byte kInstruction_movw_al_r13_0xfffd[] = {
  0x4f, 0xf6, 0xfd, 0x7d // movw al r13 0xfffd
};
const byte kInstruction_movw_al_r13_0xfffe[] = {
  0x4f, 0xf6, 0xfe, 0x7d // movw al r13 0xfffe
};
const byte kInstruction_movw_al_r13_0xffff[] = {
  0x4f, 0xf6, 0xff, 0x7d // movw al r13 0xffff
};
const byte kInstruction_movw_al_r14_0x0000[] = {
  0x40, 0xf2, 0x00, 0x0e // movw al r14 0x0000
};
const byte kInstruction_movw_al_r14_0x0001[] = {
  0x40, 0xf2, 0x01, 0x0e // movw al r14 0x0001
};
const byte kInstruction_movw_al_r14_0x0002[] = {
  0x40, 0xf2, 0x02, 0x0e // movw al r14 0x0002
};
const byte kInstruction_movw_al_r14_0x0020[] = {
  0x40, 0xf2, 0x20, 0x0e // movw al r14 0x0020
};
const byte kInstruction_movw_al_r14_0x007d[] = {
  0x40, 0xf2, 0x7d, 0x0e // movw al r14 0x007d
};
const byte kInstruction_movw_al_r14_0x007e[] = {
  0x40, 0xf2, 0x7e, 0x0e // movw al r14 0x007e
};
const byte kInstruction_movw_al_r14_0x007f[] = {
  0x40, 0xf2, 0x7f, 0x0e // movw al r14 0x007f
};
const byte kInstruction_movw_al_r14_0x7ffd[] = {
  0x47, 0xf6, 0xfd, 0x7e // movw al r14 0x7ffd
};
const byte kInstruction_movw_al_r14_0x7ffe[] = {
  0x47, 0xf6, 0xfe, 0x7e // movw al r14 0x7ffe
};
const byte kInstruction_movw_al_r14_0x7fff[] = {
  0x47, 0xf6, 0xff, 0x7e // movw al r14 0x7fff
};
const byte kInstruction_movw_al_r14_0x3333[] = {
  0x43, 0xf2, 0x33, 0x3e // movw al r14 0x3333
};
const byte kInstruction_movw_al_r14_0x5555[] = {
  0x45, 0xf2, 0x55, 0x5e // movw al r14 0x5555
};
const byte kInstruction_movw_al_r14_0xaaaa[] = {
  0x4a, 0xf6, 0xaa, 0x2e // movw al r14 0xaaaa
};
const byte kInstruction_movw_al_r14_0xcccc[] = {
  0x4c, 0xf6, 0xcc, 0x4e // movw al r14 0xcccc
};
const byte kInstruction_movw_al_r14_0x8000[] = {
  0x48, 0xf2, 0x00, 0x0e // movw al r14 0x8000
};
const byte kInstruction_movw_al_r14_0x8001[] = {
  0x48, 0xf2, 0x01, 0x0e // movw al r14 0x8001
};
const byte kInstruction_movw_al_r14_0x8002[] = {
  0x48, 0xf2, 0x02, 0x0e // movw al r14 0x8002
};
const byte kInstruction_movw_al_r14_0x8003[] = {
  0x48, 0xf2, 0x03, 0x0e // movw al r14 0x8003
};
const byte kInstruction_movw_al_r14_0xff80[] = {
  0x4f, 0xf6, 0x80, 0x7e // movw al r14 0xff80
};
const byte kInstruction_movw_al_r14_0xff81[] = {
  0x4f, 0xf6, 0x81, 0x7e // movw al r14 0xff81
};
const byte kInstruction_movw_al_r14_0xff82[] = {
  0x4f, 0xf6, 0x82, 0x7e // movw al r14 0xff82
};
const byte kInstruction_movw_al_r14_0xff83[] = {
  0x4f, 0xf6, 0x83, 0x7e // movw al r14 0xff83
};
const byte kInstruction_movw_al_r14_0xffe0[] = {
  0x4f, 0xf6, 0xe0, 0x7e // movw al r14 0xffe0
};
const byte kInstruction_movw_al_r14_0xfffd[] = {
  0x4f, 0xf6, 0xfd, 0x7e // movw al r14 0xfffd
};
const byte kInstruction_movw_al_r14_0xfffe[] = {
  0x4f, 0xf6, 0xfe, 0x7e // movw al r14 0xfffe
};
const byte kInstruction_movw_al_r14_0xffff[] = {
  0x4f, 0xf6, 0xff, 0x7e // movw al r14 0xffff
};
const TestResult kReferencemovw[] = {
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0x0000),
    kInstruction_movw_al_r0_0x0000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0x0001),
    kInstruction_movw_al_r0_0x0001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0x0002),
    kInstruction_movw_al_r0_0x0002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0x0020),
    kInstruction_movw_al_r0_0x0020,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0x007d),
    kInstruction_movw_al_r0_0x007d,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0x007e),
    kInstruction_movw_al_r0_0x007e,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0x007f),
    kInstruction_movw_al_r0_0x007f,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0x7ffd),
    kInstruction_movw_al_r0_0x7ffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0x7ffe),
    kInstruction_movw_al_r0_0x7ffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0x7fff),
    kInstruction_movw_al_r0_0x7fff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0x3333),
    kInstruction_movw_al_r0_0x3333,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0x5555),
    kInstruction_movw_al_r0_0x5555,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0xaaaa),
    kInstruction_movw_al_r0_0xaaaa,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0xcccc),
    kInstruction_movw_al_r0_0xcccc,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0x8000),
    kInstruction_movw_al_r0_0x8000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0x8001),
    kInstruction_movw_al_r0_0x8001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0x8002),
    kInstruction_movw_al_r0_0x8002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0x8003),
    kInstruction_movw_al_r0_0x8003,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0xff80),
    kInstruction_movw_al_r0_0xff80,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0xff81),
    kInstruction_movw_al_r0_0xff81,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0xff82),
    kInstruction_movw_al_r0_0xff82,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0xff83),
    kInstruction_movw_al_r0_0xff83,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0xffe0),
    kInstruction_movw_al_r0_0xffe0,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0xfffd),
    kInstruction_movw_al_r0_0xfffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0xfffe),
    kInstruction_movw_al_r0_0xfffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r0_0xffff),
    kInstruction_movw_al_r0_0xffff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0x0000),
    kInstruction_movw_al_r1_0x0000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0x0001),
    kInstruction_movw_al_r1_0x0001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0x0002),
    kInstruction_movw_al_r1_0x0002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0x0020),
    kInstruction_movw_al_r1_0x0020,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0x007d),
    kInstruction_movw_al_r1_0x007d,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0x007e),
    kInstruction_movw_al_r1_0x007e,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0x007f),
    kInstruction_movw_al_r1_0x007f,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0x7ffd),
    kInstruction_movw_al_r1_0x7ffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0x7ffe),
    kInstruction_movw_al_r1_0x7ffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0x7fff),
    kInstruction_movw_al_r1_0x7fff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0x3333),
    kInstruction_movw_al_r1_0x3333,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0x5555),
    kInstruction_movw_al_r1_0x5555,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0xaaaa),
    kInstruction_movw_al_r1_0xaaaa,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0xcccc),
    kInstruction_movw_al_r1_0xcccc,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0x8000),
    kInstruction_movw_al_r1_0x8000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0x8001),
    kInstruction_movw_al_r1_0x8001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0x8002),
    kInstruction_movw_al_r1_0x8002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0x8003),
    kInstruction_movw_al_r1_0x8003,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0xff80),
    kInstruction_movw_al_r1_0xff80,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0xff81),
    kInstruction_movw_al_r1_0xff81,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0xff82),
    kInstruction_movw_al_r1_0xff82,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0xff83),
    kInstruction_movw_al_r1_0xff83,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0xffe0),
    kInstruction_movw_al_r1_0xffe0,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0xfffd),
    kInstruction_movw_al_r1_0xfffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0xfffe),
    kInstruction_movw_al_r1_0xfffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r1_0xffff),
    kInstruction_movw_al_r1_0xffff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0x0000),
    kInstruction_movw_al_r2_0x0000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0x0001),
    kInstruction_movw_al_r2_0x0001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0x0002),
    kInstruction_movw_al_r2_0x0002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0x0020),
    kInstruction_movw_al_r2_0x0020,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0x007d),
    kInstruction_movw_al_r2_0x007d,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0x007e),
    kInstruction_movw_al_r2_0x007e,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0x007f),
    kInstruction_movw_al_r2_0x007f,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0x7ffd),
    kInstruction_movw_al_r2_0x7ffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0x7ffe),
    kInstruction_movw_al_r2_0x7ffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0x7fff),
    kInstruction_movw_al_r2_0x7fff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0x3333),
    kInstruction_movw_al_r2_0x3333,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0x5555),
    kInstruction_movw_al_r2_0x5555,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0xaaaa),
    kInstruction_movw_al_r2_0xaaaa,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0xcccc),
    kInstruction_movw_al_r2_0xcccc,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0x8000),
    kInstruction_movw_al_r2_0x8000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0x8001),
    kInstruction_movw_al_r2_0x8001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0x8002),
    kInstruction_movw_al_r2_0x8002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0x8003),
    kInstruction_movw_al_r2_0x8003,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0xff80),
    kInstruction_movw_al_r2_0xff80,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0xff81),
    kInstruction_movw_al_r2_0xff81,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0xff82),
    kInstruction_movw_al_r2_0xff82,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0xff83),
    kInstruction_movw_al_r2_0xff83,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0xffe0),
    kInstruction_movw_al_r2_0xffe0,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0xfffd),
    kInstruction_movw_al_r2_0xfffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0xfffe),
    kInstruction_movw_al_r2_0xfffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r2_0xffff),
    kInstruction_movw_al_r2_0xffff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0x0000),
    kInstruction_movw_al_r3_0x0000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0x0001),
    kInstruction_movw_al_r3_0x0001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0x0002),
    kInstruction_movw_al_r3_0x0002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0x0020),
    kInstruction_movw_al_r3_0x0020,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0x007d),
    kInstruction_movw_al_r3_0x007d,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0x007e),
    kInstruction_movw_al_r3_0x007e,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0x007f),
    kInstruction_movw_al_r3_0x007f,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0x7ffd),
    kInstruction_movw_al_r3_0x7ffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0x7ffe),
    kInstruction_movw_al_r3_0x7ffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0x7fff),
    kInstruction_movw_al_r3_0x7fff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0x3333),
    kInstruction_movw_al_r3_0x3333,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0x5555),
    kInstruction_movw_al_r3_0x5555,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0xaaaa),
    kInstruction_movw_al_r3_0xaaaa,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0xcccc),
    kInstruction_movw_al_r3_0xcccc,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0x8000),
    kInstruction_movw_al_r3_0x8000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0x8001),
    kInstruction_movw_al_r3_0x8001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0x8002),
    kInstruction_movw_al_r3_0x8002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0x8003),
    kInstruction_movw_al_r3_0x8003,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0xff80),
    kInstruction_movw_al_r3_0xff80,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0xff81),
    kInstruction_movw_al_r3_0xff81,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0xff82),
    kInstruction_movw_al_r3_0xff82,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0xff83),
    kInstruction_movw_al_r3_0xff83,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0xffe0),
    kInstruction_movw_al_r3_0xffe0,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0xfffd),
    kInstruction_movw_al_r3_0xfffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0xfffe),
    kInstruction_movw_al_r3_0xfffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r3_0xffff),
    kInstruction_movw_al_r3_0xffff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0x0000),
    kInstruction_movw_al_r4_0x0000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0x0001),
    kInstruction_movw_al_r4_0x0001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0x0002),
    kInstruction_movw_al_r4_0x0002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0x0020),
    kInstruction_movw_al_r4_0x0020,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0x007d),
    kInstruction_movw_al_r4_0x007d,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0x007e),
    kInstruction_movw_al_r4_0x007e,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0x007f),
    kInstruction_movw_al_r4_0x007f,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0x7ffd),
    kInstruction_movw_al_r4_0x7ffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0x7ffe),
    kInstruction_movw_al_r4_0x7ffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0x7fff),
    kInstruction_movw_al_r4_0x7fff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0x3333),
    kInstruction_movw_al_r4_0x3333,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0x5555),
    kInstruction_movw_al_r4_0x5555,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0xaaaa),
    kInstruction_movw_al_r4_0xaaaa,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0xcccc),
    kInstruction_movw_al_r4_0xcccc,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0x8000),
    kInstruction_movw_al_r4_0x8000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0x8001),
    kInstruction_movw_al_r4_0x8001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0x8002),
    kInstruction_movw_al_r4_0x8002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0x8003),
    kInstruction_movw_al_r4_0x8003,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0xff80),
    kInstruction_movw_al_r4_0xff80,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0xff81),
    kInstruction_movw_al_r4_0xff81,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0xff82),
    kInstruction_movw_al_r4_0xff82,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0xff83),
    kInstruction_movw_al_r4_0xff83,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0xffe0),
    kInstruction_movw_al_r4_0xffe0,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0xfffd),
    kInstruction_movw_al_r4_0xfffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0xfffe),
    kInstruction_movw_al_r4_0xfffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r4_0xffff),
    kInstruction_movw_al_r4_0xffff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0x0000),
    kInstruction_movw_al_r5_0x0000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0x0001),
    kInstruction_movw_al_r5_0x0001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0x0002),
    kInstruction_movw_al_r5_0x0002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0x0020),
    kInstruction_movw_al_r5_0x0020,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0x007d),
    kInstruction_movw_al_r5_0x007d,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0x007e),
    kInstruction_movw_al_r5_0x007e,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0x007f),
    kInstruction_movw_al_r5_0x007f,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0x7ffd),
    kInstruction_movw_al_r5_0x7ffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0x7ffe),
    kInstruction_movw_al_r5_0x7ffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0x7fff),
    kInstruction_movw_al_r5_0x7fff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0x3333),
    kInstruction_movw_al_r5_0x3333,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0x5555),
    kInstruction_movw_al_r5_0x5555,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0xaaaa),
    kInstruction_movw_al_r5_0xaaaa,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0xcccc),
    kInstruction_movw_al_r5_0xcccc,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0x8000),
    kInstruction_movw_al_r5_0x8000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0x8001),
    kInstruction_movw_al_r5_0x8001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0x8002),
    kInstruction_movw_al_r5_0x8002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0x8003),
    kInstruction_movw_al_r5_0x8003,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0xff80),
    kInstruction_movw_al_r5_0xff80,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0xff81),
    kInstruction_movw_al_r5_0xff81,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0xff82),
    kInstruction_movw_al_r5_0xff82,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0xff83),
    kInstruction_movw_al_r5_0xff83,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0xffe0),
    kInstruction_movw_al_r5_0xffe0,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0xfffd),
    kInstruction_movw_al_r5_0xfffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0xfffe),
    kInstruction_movw_al_r5_0xfffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r5_0xffff),
    kInstruction_movw_al_r5_0xffff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0x0000),
    kInstruction_movw_al_r6_0x0000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0x0001),
    kInstruction_movw_al_r6_0x0001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0x0002),
    kInstruction_movw_al_r6_0x0002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0x0020),
    kInstruction_movw_al_r6_0x0020,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0x007d),
    kInstruction_movw_al_r6_0x007d,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0x007e),
    kInstruction_movw_al_r6_0x007e,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0x007f),
    kInstruction_movw_al_r6_0x007f,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0x7ffd),
    kInstruction_movw_al_r6_0x7ffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0x7ffe),
    kInstruction_movw_al_r6_0x7ffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0x7fff),
    kInstruction_movw_al_r6_0x7fff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0x3333),
    kInstruction_movw_al_r6_0x3333,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0x5555),
    kInstruction_movw_al_r6_0x5555,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0xaaaa),
    kInstruction_movw_al_r6_0xaaaa,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0xcccc),
    kInstruction_movw_al_r6_0xcccc,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0x8000),
    kInstruction_movw_al_r6_0x8000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0x8001),
    kInstruction_movw_al_r6_0x8001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0x8002),
    kInstruction_movw_al_r6_0x8002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0x8003),
    kInstruction_movw_al_r6_0x8003,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0xff80),
    kInstruction_movw_al_r6_0xff80,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0xff81),
    kInstruction_movw_al_r6_0xff81,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0xff82),
    kInstruction_movw_al_r6_0xff82,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0xff83),
    kInstruction_movw_al_r6_0xff83,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0xffe0),
    kInstruction_movw_al_r6_0xffe0,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0xfffd),
    kInstruction_movw_al_r6_0xfffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0xfffe),
    kInstruction_movw_al_r6_0xfffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r6_0xffff),
    kInstruction_movw_al_r6_0xffff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0x0000),
    kInstruction_movw_al_r7_0x0000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0x0001),
    kInstruction_movw_al_r7_0x0001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0x0002),
    kInstruction_movw_al_r7_0x0002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0x0020),
    kInstruction_movw_al_r7_0x0020,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0x007d),
    kInstruction_movw_al_r7_0x007d,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0x007e),
    kInstruction_movw_al_r7_0x007e,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0x007f),
    kInstruction_movw_al_r7_0x007f,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0x7ffd),
    kInstruction_movw_al_r7_0x7ffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0x7ffe),
    kInstruction_movw_al_r7_0x7ffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0x7fff),
    kInstruction_movw_al_r7_0x7fff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0x3333),
    kInstruction_movw_al_r7_0x3333,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0x5555),
    kInstruction_movw_al_r7_0x5555,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0xaaaa),
    kInstruction_movw_al_r7_0xaaaa,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0xcccc),
    kInstruction_movw_al_r7_0xcccc,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0x8000),
    kInstruction_movw_al_r7_0x8000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0x8001),
    kInstruction_movw_al_r7_0x8001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0x8002),
    kInstruction_movw_al_r7_0x8002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0x8003),
    kInstruction_movw_al_r7_0x8003,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0xff80),
    kInstruction_movw_al_r7_0xff80,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0xff81),
    kInstruction_movw_al_r7_0xff81,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0xff82),
    kInstruction_movw_al_r7_0xff82,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0xff83),
    kInstruction_movw_al_r7_0xff83,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0xffe0),
    kInstruction_movw_al_r7_0xffe0,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0xfffd),
    kInstruction_movw_al_r7_0xfffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0xfffe),
    kInstruction_movw_al_r7_0xfffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r7_0xffff),
    kInstruction_movw_al_r7_0xffff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0x0000),
    kInstruction_movw_al_r8_0x0000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0x0001),
    kInstruction_movw_al_r8_0x0001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0x0002),
    kInstruction_movw_al_r8_0x0002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0x0020),
    kInstruction_movw_al_r8_0x0020,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0x007d),
    kInstruction_movw_al_r8_0x007d,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0x007e),
    kInstruction_movw_al_r8_0x007e,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0x007f),
    kInstruction_movw_al_r8_0x007f,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0x7ffd),
    kInstruction_movw_al_r8_0x7ffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0x7ffe),
    kInstruction_movw_al_r8_0x7ffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0x7fff),
    kInstruction_movw_al_r8_0x7fff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0x3333),
    kInstruction_movw_al_r8_0x3333,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0x5555),
    kInstruction_movw_al_r8_0x5555,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0xaaaa),
    kInstruction_movw_al_r8_0xaaaa,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0xcccc),
    kInstruction_movw_al_r8_0xcccc,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0x8000),
    kInstruction_movw_al_r8_0x8000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0x8001),
    kInstruction_movw_al_r8_0x8001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0x8002),
    kInstruction_movw_al_r8_0x8002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0x8003),
    kInstruction_movw_al_r8_0x8003,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0xff80),
    kInstruction_movw_al_r8_0xff80,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0xff81),
    kInstruction_movw_al_r8_0xff81,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0xff82),
    kInstruction_movw_al_r8_0xff82,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0xff83),
    kInstruction_movw_al_r8_0xff83,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0xffe0),
    kInstruction_movw_al_r8_0xffe0,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0xfffd),
    kInstruction_movw_al_r8_0xfffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0xfffe),
    kInstruction_movw_al_r8_0xfffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r8_0xffff),
    kInstruction_movw_al_r8_0xffff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0x0000),
    kInstruction_movw_al_r9_0x0000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0x0001),
    kInstruction_movw_al_r9_0x0001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0x0002),
    kInstruction_movw_al_r9_0x0002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0x0020),
    kInstruction_movw_al_r9_0x0020,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0x007d),
    kInstruction_movw_al_r9_0x007d,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0x007e),
    kInstruction_movw_al_r9_0x007e,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0x007f),
    kInstruction_movw_al_r9_0x007f,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0x7ffd),
    kInstruction_movw_al_r9_0x7ffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0x7ffe),
    kInstruction_movw_al_r9_0x7ffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0x7fff),
    kInstruction_movw_al_r9_0x7fff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0x3333),
    kInstruction_movw_al_r9_0x3333,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0x5555),
    kInstruction_movw_al_r9_0x5555,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0xaaaa),
    kInstruction_movw_al_r9_0xaaaa,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0xcccc),
    kInstruction_movw_al_r9_0xcccc,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0x8000),
    kInstruction_movw_al_r9_0x8000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0x8001),
    kInstruction_movw_al_r9_0x8001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0x8002),
    kInstruction_movw_al_r9_0x8002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0x8003),
    kInstruction_movw_al_r9_0x8003,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0xff80),
    kInstruction_movw_al_r9_0xff80,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0xff81),
    kInstruction_movw_al_r9_0xff81,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0xff82),
    kInstruction_movw_al_r9_0xff82,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0xff83),
    kInstruction_movw_al_r9_0xff83,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0xffe0),
    kInstruction_movw_al_r9_0xffe0,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0xfffd),
    kInstruction_movw_al_r9_0xfffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0xfffe),
    kInstruction_movw_al_r9_0xfffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r9_0xffff),
    kInstruction_movw_al_r9_0xffff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0x0000),
    kInstruction_movw_al_r10_0x0000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0x0001),
    kInstruction_movw_al_r10_0x0001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0x0002),
    kInstruction_movw_al_r10_0x0002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0x0020),
    kInstruction_movw_al_r10_0x0020,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0x007d),
    kInstruction_movw_al_r10_0x007d,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0x007e),
    kInstruction_movw_al_r10_0x007e,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0x007f),
    kInstruction_movw_al_r10_0x007f,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0x7ffd),
    kInstruction_movw_al_r10_0x7ffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0x7ffe),
    kInstruction_movw_al_r10_0x7ffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0x7fff),
    kInstruction_movw_al_r10_0x7fff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0x3333),
    kInstruction_movw_al_r10_0x3333,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0x5555),
    kInstruction_movw_al_r10_0x5555,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0xaaaa),
    kInstruction_movw_al_r10_0xaaaa,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0xcccc),
    kInstruction_movw_al_r10_0xcccc,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0x8000),
    kInstruction_movw_al_r10_0x8000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0x8001),
    kInstruction_movw_al_r10_0x8001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0x8002),
    kInstruction_movw_al_r10_0x8002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0x8003),
    kInstruction_movw_al_r10_0x8003,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0xff80),
    kInstruction_movw_al_r10_0xff80,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0xff81),
    kInstruction_movw_al_r10_0xff81,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0xff82),
    kInstruction_movw_al_r10_0xff82,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0xff83),
    kInstruction_movw_al_r10_0xff83,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0xffe0),
    kInstruction_movw_al_r10_0xffe0,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0xfffd),
    kInstruction_movw_al_r10_0xfffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0xfffe),
    kInstruction_movw_al_r10_0xfffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r10_0xffff),
    kInstruction_movw_al_r10_0xffff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0x0000),
    kInstruction_movw_al_r11_0x0000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0x0001),
    kInstruction_movw_al_r11_0x0001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0x0002),
    kInstruction_movw_al_r11_0x0002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0x0020),
    kInstruction_movw_al_r11_0x0020,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0x007d),
    kInstruction_movw_al_r11_0x007d,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0x007e),
    kInstruction_movw_al_r11_0x007e,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0x007f),
    kInstruction_movw_al_r11_0x007f,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0x7ffd),
    kInstruction_movw_al_r11_0x7ffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0x7ffe),
    kInstruction_movw_al_r11_0x7ffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0x7fff),
    kInstruction_movw_al_r11_0x7fff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0x3333),
    kInstruction_movw_al_r11_0x3333,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0x5555),
    kInstruction_movw_al_r11_0x5555,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0xaaaa),
    kInstruction_movw_al_r11_0xaaaa,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0xcccc),
    kInstruction_movw_al_r11_0xcccc,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0x8000),
    kInstruction_movw_al_r11_0x8000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0x8001),
    kInstruction_movw_al_r11_0x8001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0x8002),
    kInstruction_movw_al_r11_0x8002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0x8003),
    kInstruction_movw_al_r11_0x8003,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0xff80),
    kInstruction_movw_al_r11_0xff80,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0xff81),
    kInstruction_movw_al_r11_0xff81,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0xff82),
    kInstruction_movw_al_r11_0xff82,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0xff83),
    kInstruction_movw_al_r11_0xff83,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0xffe0),
    kInstruction_movw_al_r11_0xffe0,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0xfffd),
    kInstruction_movw_al_r11_0xfffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0xfffe),
    kInstruction_movw_al_r11_0xfffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r11_0xffff),
    kInstruction_movw_al_r11_0xffff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0x0000),
    kInstruction_movw_al_r12_0x0000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0x0001),
    kInstruction_movw_al_r12_0x0001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0x0002),
    kInstruction_movw_al_r12_0x0002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0x0020),
    kInstruction_movw_al_r12_0x0020,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0x007d),
    kInstruction_movw_al_r12_0x007d,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0x007e),
    kInstruction_movw_al_r12_0x007e,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0x007f),
    kInstruction_movw_al_r12_0x007f,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0x7ffd),
    kInstruction_movw_al_r12_0x7ffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0x7ffe),
    kInstruction_movw_al_r12_0x7ffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0x7fff),
    kInstruction_movw_al_r12_0x7fff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0x3333),
    kInstruction_movw_al_r12_0x3333,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0x5555),
    kInstruction_movw_al_r12_0x5555,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0xaaaa),
    kInstruction_movw_al_r12_0xaaaa,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0xcccc),
    kInstruction_movw_al_r12_0xcccc,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0x8000),
    kInstruction_movw_al_r12_0x8000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0x8001),
    kInstruction_movw_al_r12_0x8001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0x8002),
    kInstruction_movw_al_r12_0x8002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0x8003),
    kInstruction_movw_al_r12_0x8003,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0xff80),
    kInstruction_movw_al_r12_0xff80,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0xff81),
    kInstruction_movw_al_r12_0xff81,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0xff82),
    kInstruction_movw_al_r12_0xff82,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0xff83),
    kInstruction_movw_al_r12_0xff83,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0xffe0),
    kInstruction_movw_al_r12_0xffe0,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0xfffd),
    kInstruction_movw_al_r12_0xfffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0xfffe),
    kInstruction_movw_al_r12_0xfffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r12_0xffff),
    kInstruction_movw_al_r12_0xffff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0x0000),
    kInstruction_movw_al_r13_0x0000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0x0001),
    kInstruction_movw_al_r13_0x0001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0x0002),
    kInstruction_movw_al_r13_0x0002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0x0020),
    kInstruction_movw_al_r13_0x0020,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0x007d),
    kInstruction_movw_al_r13_0x007d,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0x007e),
    kInstruction_movw_al_r13_0x007e,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0x007f),
    kInstruction_movw_al_r13_0x007f,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0x7ffd),
    kInstruction_movw_al_r13_0x7ffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0x7ffe),
    kInstruction_movw_al_r13_0x7ffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0x7fff),
    kInstruction_movw_al_r13_0x7fff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0x3333),
    kInstruction_movw_al_r13_0x3333,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0x5555),
    kInstruction_movw_al_r13_0x5555,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0xaaaa),
    kInstruction_movw_al_r13_0xaaaa,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0xcccc),
    kInstruction_movw_al_r13_0xcccc,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0x8000),
    kInstruction_movw_al_r13_0x8000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0x8001),
    kInstruction_movw_al_r13_0x8001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0x8002),
    kInstruction_movw_al_r13_0x8002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0x8003),
    kInstruction_movw_al_r13_0x8003,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0xff80),
    kInstruction_movw_al_r13_0xff80,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0xff81),
    kInstruction_movw_al_r13_0xff81,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0xff82),
    kInstruction_movw_al_r13_0xff82,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0xff83),
    kInstruction_movw_al_r13_0xff83,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0xffe0),
    kInstruction_movw_al_r13_0xffe0,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0xfffd),
    kInstruction_movw_al_r13_0xfffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0xfffe),
    kInstruction_movw_al_r13_0xfffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r13_0xffff),
    kInstruction_movw_al_r13_0xffff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0x0000),
    kInstruction_movw_al_r14_0x0000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0x0001),
    kInstruction_movw_al_r14_0x0001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0x0002),
    kInstruction_movw_al_r14_0x0002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0x0020),
    kInstruction_movw_al_r14_0x0020,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0x007d),
    kInstruction_movw_al_r14_0x007d,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0x007e),
    kInstruction_movw_al_r14_0x007e,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0x007f),
    kInstruction_movw_al_r14_0x007f,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0x7ffd),
    kInstruction_movw_al_r14_0x7ffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0x7ffe),
    kInstruction_movw_al_r14_0x7ffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0x7fff),
    kInstruction_movw_al_r14_0x7fff,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0x3333),
    kInstruction_movw_al_r14_0x3333,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0x5555),
    kInstruction_movw_al_r14_0x5555,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0xaaaa),
    kInstruction_movw_al_r14_0xaaaa,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0xcccc),
    kInstruction_movw_al_r14_0xcccc,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0x8000),
    kInstruction_movw_al_r14_0x8000,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0x8001),
    kInstruction_movw_al_r14_0x8001,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0x8002),
    kInstruction_movw_al_r14_0x8002,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0x8003),
    kInstruction_movw_al_r14_0x8003,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0xff80),
    kInstruction_movw_al_r14_0xff80,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0xff81),
    kInstruction_movw_al_r14_0xff81,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0xff82),
    kInstruction_movw_al_r14_0xff82,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0xff83),
    kInstruction_movw_al_r14_0xff83,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0xffe0),
    kInstruction_movw_al_r14_0xffe0,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0xfffd),
    kInstruction_movw_al_r14_0xfffd,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0xfffe),
    kInstruction_movw_al_r14_0xfffe,
  },
  {
    ARRAY_SIZE(kInstruction_movw_al_r14_0xffff),
    kInstruction_movw_al_r14_0xffff,
  },
};

#endif  // VIXL_ASSEMBLER_COND_RD_OPERAND_IMM16_MOVW_T32_H_