source: vbox/trunk/src/VBox/ValidationKit/bootsectors/bs3-cpu-instr-2-data16.c16@ 104000

/* $Id: bs3-cpu-instr-2-data16.c16 104000 2024-03-22 15:37:38Z vboxsync $ */
/** @file
 * BS3Kit - bs3-cpu-instr-2, bs3-cpu-instr-2-data16.c16 - auto generated (do not edit).
 */

/*
 * Copyright (C) 2024 Oracle and/or its affiliates.
 *
 * This file is part of VirtualBox base platform packages, as
 * available from https://www.virtualbox.org.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation, in version 3 of the
 * License.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, see <https://www.gnu.org/licenses>.
 *
 * The contents of this file may alternatively be used under the terms
 * of the Common Development and Distribution License Version 1.0
 * (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
 * in the VirtualBox distribution, in which case the provisions of the
 * CDDL are applicable instead of those of the GPL.
 *
 * You may elect to license modified versions of this file under the
 * terms and conditions of either the GPL or the CDDL or both.
 *
 * SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
 */

#include <bs3kit.h>
#include "bs3-cpu-instr-2.h"

const uint16_t g_cBs3CpuInstr2_and_TestDataU8 = 32;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_and_TestDataU8[32] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0xff, 0xff, 0xff, 0x084 },
    { 0x00, 0xff, 0x00, 0x044 },
    { 0x84, 0x32, 0x00, 0x044 },
    { 0xd5, 0x82, 0x80, 0x080 },
    { 0xca, 0x9c, 0x88, 0x084 },
    { 0x9d, 0x23, 0x01, 0x000 },
    { 0xbf, 0xd1, 0x91, 0x080 },
    { 0x4d, 0xed, 0x4d, 0x004 },
    { 0x7b, 0x4b, 0x4b, 0x004 },
    { 0xeb, 0xda, 0xca, 0x084 },
    { 0x8d, 0xe7, 0x85, 0x080 },
    { 0x4a, 0x26, 0x02, 0x000 },
    { 0xb6, 0xf0, 0xb0, 0x080 },
    { 0x5c, 0x05, 0x04, 0x000 },
    { 0x88, 0xce, 0x88, 0x084 },
    { 0x6e, 0xa0, 0x20, 0x000 },
    { 0x60, 0x3f, 0x20, 0x000 },
    { 0x3a, 0xde, 0x1a, 0x000 },
    { 0x8c, 0x33, 0x00, 0x044 },
    { 0x24, 0xfd, 0x24, 0x004 },
    { 0x39, 0xc8, 0x08, 0x000 },
    { 0x40, 0x52, 0x40, 0x000 },
    { 0x4e, 0xa1, 0x00, 0x044 },
    { 0xf7, 0x87, 0x87, 0x084 },
    { 0xae, 0xac, 0xac, 0x084 },
    { 0xc7, 0x46, 0x46, 0x000 },
    { 0xe2, 0x03, 0x02, 0x000 },
    { 0x4b, 0x38, 0x08, 0x000 },
    { 0xeb, 0x48, 0x48, 0x004 },
    { 0xfb, 0x0e, 0x0a, 0x004 },
    { 0x0e, 0x3e, 0x0e, 0x000 },
};

const uint16_t g_cBs3CpuInstr2_and_TestDataU16 = 64;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_and_TestDataU16[64] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x084 },
    { 0x0000, 0xffff, 0x0000, 0x044 },
    { 0x0177, 0x113f, 0x0137, 0x000 },
    { 0x602d, 0x569a, 0x4008, 0x000 },
    { 0xcc19, 0x95f6, 0x8410, 0x080 },
    { 0x1f2f, 0x0036, 0x0026, 0x000 },
    { 0xfd1e, 0xf2f4, 0xf014, 0x084 },
    { 0xacbc, 0x9c4e, 0x8c0c, 0x084 },
    { 0x0129, 0x1bdc, 0x0108, 0x000 },
    { 0xf830, 0x3f22, 0x3820, 0x000 },
    { 0xd46d, 0x42a9, 0x4029, 0x000 },
    { 0x13ea, 0x0003, 0x0002, 0x000 },
    { 0x5a00, 0xc35e, 0x4200, 0x004 },
    { 0x6496, 0xf412, 0x6412, 0x004 },
    { 0x0370, 0x0031, 0x0030, 0x004 },
    { 0xebc2, 0x0f22, 0x0b02, 0x000 },
    { 0xab7f, 0x4c55, 0x0855, 0x004 },
    { 0x0030, 0x24fe, 0x0030, 0x004 },
    { 0x4e8d, 0x3b07, 0x0a05, 0x004 },
    { 0x5770, 0xb8b5, 0x1030, 0x004 },
    { 0x02fa, 0x0036, 0x0032, 0x000 },
    { 0xf50b, 0xdc48, 0xd408, 0x080 },
    { 0xfca3, 0x3d40, 0x3c00, 0x004 },
    { 0x0027, 0x0109, 0x0001, 0x000 },
    { 0xfb3d, 0x7dbb, 0x7939, 0x004 },
    { 0xa12e, 0xd9a9, 0x8128, 0x084 },
    { 0x05db, 0x0042, 0x0042, 0x004 },
    { 0x2d05, 0xba8e, 0x2804, 0x000 },
    { 0xcbc2, 0x5221, 0x4200, 0x004 },
    { 0x7b36, 0x1528, 0x1120, 0x000 },
    { 0x71b5, 0x51e4, 0x51a4, 0x000 },
    /* r/m16, imm8: */
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x084 },
    { 0x0000, 0xffff, 0x0000, 0x044 },
    { 0x0097, 0x0023, 0x0003, 0x004 },
    { 0xebbd, 0x006b, 0x0029, 0x000 },
    { 0x2c6a, 0xff9c, 0x2c08, 0x000 },
    { 0x0033, 0x005c, 0x0010, 0x000 },
    { 0x5142, 0xffd9, 0x5140, 0x000 },
    { 0x5ea7, 0xffa9, 0x5ea1, 0x000 },
    { 0x0319, 0x0071, 0x0011, 0x004 },
    { 0x8949, 0xffda, 0x8948, 0x084 },
    { 0xb8f7, 0x006a, 0x0062, 0x000 },
    { 0x03a7, 0xff84, 0x0384, 0x004 },
    { 0x61ad, 0x002d, 0x002d, 0x004 },
    { 0x6e21, 0xff8f, 0x6e01, 0x000 },
    { 0x3143, 0x0054, 0x0040, 0x000 },
    { 0xaaf1, 0x005b, 0x0051, 0x000 },
    { 0x31f8, 0xffa5, 0x31a0, 0x004 },
    { 0x06f6, 0x004a, 0x0042, 0x004 },
    { 0x5c31, 0xfffd, 0x5c31, 0x000 },
    { 0xc1bf, 0x004d, 0x000d, 0x000 },
    { 0x00de, 0x001a, 0x001a, 0x000 },
    { 0x5e1d, 0xffb6, 0x5e14, 0x004 },
    { 0xc43a, 0xffd6, 0xc412, 0x084 },
    { 0x00ae, 0xffbd, 0x00ac, 0x004 },
    { 0x35f3, 0xffc5, 0x35c1, 0x000 },
    { 0x2579, 0x0079, 0x0079, 0x000 },
    { 0x18e0, 0xffd8, 0x18c0, 0x004 },
    { 0x0588, 0xffdb, 0x0588, 0x004 },
    { 0x6abb, 0x0023, 0x0023, 0x000 },
    { 0x0009, 0xffd2, 0x0000, 0x044 },
    { 0xc663, 0x006b, 0x0063, 0x004 },
};

const uint16_t g_cBs3CpuInstr2_and_TestDataU32 = 72;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_and_TestDataU32[72] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x084 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x044 },
    { 0x00004bd1, 0x00000298, 0x00000290, 0x004 },
    { 0xafde080e, 0xffd89f6f, 0xafd8080e, 0x080 },
    { 0x66cb71fb, 0x76a84a76, 0x66884072, 0x004 },
    { 0x002158ec, 0x00005044, 0x00005044, 0x004 },
    { 0xc464cc43, 0xf59e65c9, 0xc4044441, 0x084 },
    { 0x322c8a9f, 0xca40e675, 0x02008215, 0x000 },
    { 0x0276bc2d, 0x0000345e, 0x0000340c, 0x004 },
    { 0xcf8e2063, 0xfbf06c62, 0xcb802062, 0x080 },
    { 0x255bd57f, 0xf01db8d5, 0x20199055, 0x004 },
    { 0x00a89ef1, 0x00001b61, 0x00001a61, 0x000 },
    { 0x9eb87578, 0xb5095ca9, 0x94085428, 0x084 },
    { 0xf9a27672, 0x990e74c1, 0x99027440, 0x080 },
    { 0x000061fe, 0x03cb3164, 0x00002164, 0x000 },
    { 0xf917aa7d, 0x00ba11d3, 0x00120051, 0x000 },
    { 0x77e854d7, 0xb61a2cc1, 0x360804c1, 0x000 },
    { 0x0003adf5, 0x00000219, 0x00000011, 0x004 },
    { 0x210c9c5e, 0x02edf045, 0x000c9044, 0x004 },
    { 0x53396457, 0x5cea959d, 0x50280415, 0x000 },
    { 0x00082303, 0x00001a04, 0x00000200, 0x004 },
    { 0x06880f77, 0x0eaf71ce, 0x06880146, 0x000 },
    { 0x205892ea, 0xd715513d, 0x00101028, 0x004 },
    { 0x01b2f548, 0x02df2663, 0x00922440, 0x000 },
    { 0xc8514fe1, 0xd25361de, 0xc05141c0, 0x084 },
    { 0x203e600b, 0x1f13a38a, 0x0012200a, 0x004 },
    { 0x003cb080, 0x00362777, 0x00342000, 0x004 },
    { 0x57d93307, 0x34a53d9f, 0x14813107, 0x000 },
    { 0x4c70cd8d, 0x01c6ea5c, 0x0040c80c, 0x004 },
    { 0x00006cc1, 0x0001eed1, 0x00006cc1, 0x000 },
    { 0x4731ffac, 0x238878e4, 0x030078a4, 0x000 },
    { 0xd4b8f3c9, 0x7a8d1bbf, 0x50881389, 0x000 },
    { 0x026388f2, 0x00003072, 0x00000072, 0x004 },
    { 0x8d2dc15f, 0xb6f24abb, 0x8420401b, 0x084 },
    { 0xdd08572b, 0x8e92f7c4, 0x8c005700, 0x084 },
    /* r/m32, imm8: */
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x084 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x044 },
    { 0x00038861, 0x00000030, 0x00000020, 0x000 },
    { 0xc15791b7, 0x00000011, 0x00000011, 0x004 },
    { 0x999ad483, 0x0000006a, 0x00000002, 0x000 },
    { 0x000002c9, 0x0000003e, 0x00000008, 0x000 },
    { 0x97599e27, 0x0000003e, 0x00000026, 0x000 },
    { 0x794a1e89, 0xffffffc1, 0x794a1e81, 0x004 },
    { 0x0190ba5c, 0xffffff91, 0x0190ba10, 0x000 },
    { 0x2e36114c, 0x0000001b, 0x00000008, 0x000 },
    { 0xc4d8b7da, 0xffffff85, 0xc4d8b780, 0x080 },
    { 0x0015a47c, 0x00000011, 0x00000010, 0x000 },
    { 0x1ee2120a, 0x0000005d, 0x00000008, 0x000 },
    { 0x035531da, 0xffffffeb, 0x035531ca, 0x004 },
    { 0x0010677a, 0x00000024, 0x00000020, 0x000 },
    { 0xcc66b494, 0xffffffe8, 0xcc66b480, 0x080 },
    { 0x26f31f52, 0x00000078, 0x00000050, 0x004 },
    { 0x0000e02f, 0x00000023, 0x00000023, 0x000 },
    { 0x2e4bcf30, 0xffffff9e, 0x2e4bcf10, 0x000 },
    { 0x5c1e0067, 0x00000070, 0x00000060, 0x004 },
    { 0x00000ae5, 0x00000042, 0x00000040, 0x000 },
    { 0x1a508d11, 0x00000069, 0x00000001, 0x000 },
    { 0xcde1e0e5, 0x00000055, 0x00000045, 0x000 },
    { 0x000da8e4, 0x00000048, 0x00000040, 0x000 },
    { 0x4dcb26e4, 0xffffffcf, 0x4dcb26c4, 0x000 },
    { 0x0777bf7f, 0xffffff81, 0x0777bf01, 0x000 },
    { 0x02f403fc, 0xffffffbb, 0x02f403b8, 0x004 },
    { 0xae156786, 0xffffffe0, 0xae156780, 0x080 },
    { 0x3419bc90, 0x0000007c, 0x00000010, 0x000 },
    { 0x000b7d0f, 0x0000007e, 0x0000000e, 0x000 },
    { 0xf0477599, 0x00000065, 0x00000001, 0x000 },
    { 0xd09538e8, 0xffffffac, 0xd09538a8, 0x080 },
    { 0x1b74a97e, 0xffffff84, 0x1b74a904, 0x000 },
    { 0x46cb50b2, 0x0000006d, 0x00000020, 0x000 },
    { 0x93cb322c, 0xffffffae, 0x93cb322c, 0x080 },
};

const uint16_t g_cBs3CpuInstr2_or_TestDataU8 = 32;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_or_TestDataU8[32] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0xff, 0xff, 0xff, 0x084 },
    { 0x00, 0xff, 0xff, 0x084 },
    { 0xff, 0x96, 0xff, 0x084 },
    { 0x3f, 0xea, 0xff, 0x084 },
    { 0x19, 0xec, 0xfd, 0x080 },
    { 0x70, 0xeb, 0xfb, 0x080 },
    { 0x0a, 0x26, 0x2e, 0x004 },
    { 0xd2, 0x63, 0xf3, 0x084 },
    { 0xcd, 0xaa, 0xef, 0x080 },
    { 0x15, 0xf0, 0xf5, 0x084 },
    { 0x8f, 0x89, 0x8f, 0x080 },
    { 0xff, 0xe2, 0xff, 0x084 },
    { 0x82, 0x9a, 0x9a, 0x084 },
    { 0x9c, 0xd3, 0xdf, 0x080 },
    { 0xbe, 0x27, 0xbf, 0x080 },
    { 0xcc, 0x69, 0xed, 0x084 },
    { 0xae, 0xc1, 0xef, 0x080 },
    { 0x55, 0x9c, 0xdd, 0x084 },
    { 0x6f, 0x0e, 0x6f, 0x004 },
    { 0x73, 0x5d, 0x7f, 0x000 },
    { 0x16, 0xef, 0xff, 0x084 },
    { 0xec, 0xe4, 0xec, 0x080 },
    { 0x35, 0xf9, 0xfd, 0x080 },
    { 0x97, 0x02, 0x97, 0x080 },
    { 0xa5, 0x03, 0xa7, 0x080 },
    { 0x8c, 0xcf, 0xcf, 0x084 },
    { 0x09, 0x99, 0x99, 0x084 },
    { 0x1b, 0x75, 0x7f, 0x000 },
    { 0x3c, 0x49, 0x7d, 0x004 },
    { 0x29, 0x06, 0x2f, 0x000 },
    { 0xf9, 0x5e, 0xff, 0x084 },
};

const uint16_t g_cBs3CpuInstr2_or_TestDataU16 = 64;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_or_TestDataU16[64] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x084 },
    { 0x0000, 0xffff, 0xffff, 0x084 },
    { 0x0742, 0x01dd, 0x07df, 0x000 },
    { 0xd7bd, 0xdd4b, 0xdfff, 0x084 },
    { 0x7fdf, 0x35a0, 0x7fff, 0x004 },
    { 0x00ea, 0x00d1, 0x00fb, 0x000 },
    { 0x1c56, 0x550e, 0x5d5e, 0x000 },
    { 0x315b, 0x66e0, 0x77fb, 0x000 },
    { 0x000d, 0x0011, 0x001d, 0x004 },
    { 0x89e1, 0x3e14, 0xbff5, 0x084 },
    { 0xa463, 0x9850, 0xbc73, 0x080 },
    { 0x0717, 0x04c2, 0x07d7, 0x004 },
    { 0xb3a7, 0xb6c0, 0xb7e7, 0x084 },
    { 0x12c3, 0xe9ad, 0xfbef, 0x080 },
    { 0x7e52, 0x0d63, 0x7f73, 0x000 },
    { 0xbedd, 0xba28, 0xbefd, 0x080 },
    { 0xa98a, 0xd67e, 0xfffe, 0x080 },
    { 0x2cd5, 0x0056, 0x2cd7, 0x004 },
    { 0xf49f, 0x27df, 0xf7df, 0x080 },
    { 0xdf14, 0x9a4c, 0xdf5c, 0x084 },
    { 0x03e1, 0x238e, 0x23ef, 0x000 },
    { 0xdf29, 0x3ccc, 0xffed, 0x084 },
    { 0x7cf4, 0x8f41, 0xfff5, 0x084 },
    { 0x007e, 0x0f32, 0x0f7e, 0x004 },
    { 0x65ad, 0x45ae, 0x65af, 0x004 },
    { 0xd71e, 0xf94b, 0xff5f, 0x084 },
    { 0x00b5, 0x015a, 0x01ff, 0x004 },
    { 0x9e42, 0x1127, 0x9f67, 0x080 },
    { 0x54eb, 0x18fa, 0x5cfb, 0x000 },
    { 0x04c0, 0x0367, 0x07e7, 0x004 },
    { 0xa010, 0xb84a, 0xb85a, 0x084 },
    /* r/m16, imm8: */
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x084 },
    { 0x0000, 0xffff, 0xffff, 0x084 },
    { 0x002b, 0x006f, 0x006f, 0x004 },
    { 0xa47a, 0xffcb, 0xfffb, 0x080 },
    { 0x518b, 0xffe3, 0xffeb, 0x084 },
    { 0x003a, 0xffc6, 0xfffe, 0x080 },
    { 0xa48b, 0xffab, 0xffab, 0x080 },
    { 0x5311, 0x0073, 0x5373, 0x000 },
    { 0x0027, 0xffd8, 0xffff, 0x084 },
    { 0x45b5, 0xffa8, 0xffbd, 0x084 },
    { 0x2646, 0x0010, 0x2656, 0x004 },
    { 0x0038, 0x002f, 0x003f, 0x004 },
    { 0x3c07, 0x0046, 0x3c47, 0x004 },
    { 0xcf4f, 0xff83, 0xffcf, 0x084 },
    { 0x07fd, 0x000f, 0x07ff, 0x004 },
    { 0x9168, 0xffd9, 0xfff9, 0x084 },
    { 0xedd9, 0xffd7, 0xffdf, 0x080 },
    { 0x0171, 0x0031, 0x0171, 0x004 },
    { 0xc510, 0x001a, 0xc51a, 0x080 },
    { 0x3b22, 0xff89, 0xffab, 0x080 },
    { 0x018b, 0x0017, 0x019f, 0x004 },
    { 0x3991, 0xfffc, 0xfffd, 0x080 },
    { 0x15e9, 0xffc0, 0xffe9, 0x080 },
    { 0x7d80, 0xffd2, 0xffd2, 0x084 },
    { 0x740a, 0x003c, 0x743e, 0x000 },
    { 0x7dcf, 0x005f, 0x7ddf, 0x000 },
    { 0x09b7, 0x0010, 0x09b7, 0x004 },
    { 0x06b1, 0xffdd, 0xfffd, 0x080 },
    { 0x181e, 0xffea, 0xfffe, 0x080 },
    { 0x0019, 0x0072, 0x007b, 0x004 },
    { 0x54a4, 0xffb3, 0xffb7, 0x084 },
};

const uint16_t g_cBs3CpuInstr2_or_TestDataU32 = 72;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_or_TestDataU32[72] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x084 },
    { 0x00000000, 0xffffffff, 0xffffffff, 0x084 },
    { 0x001b1d1a, 0x0009c7c9, 0x001bdfdb, 0x004 },
    { 0x7e9b9654, 0x22fbc8d2, 0x7efbded6, 0x000 },
    { 0x403d64ef, 0xfeada7db, 0xfebde7ff, 0x084 },
    { 0x00005cd0, 0x00000196, 0x00005dd6, 0x000 },
    { 0x47953f7a, 0x977a6679, 0xd7ff7f7b, 0x084 },
    { 0x24ddbecd, 0x1a1997a3, 0x3eddbfef, 0x000 },
    { 0x00000dae, 0x00008e34, 0x00008fbe, 0x004 },
    { 0x4e981d4d, 0x64abb1b7, 0x6ebbbdff, 0x004 },
    { 0x44207830, 0x6fb2996d, 0x6fb2f97d, 0x004 },
    { 0x000006d2, 0x00000292, 0x000006d2, 0x004 },
    { 0x71be185d, 0x3731bc01, 0x77bfbc5d, 0x000 },
    { 0xe22e22c9, 0x02edec7a, 0xe2efeefb, 0x080 },
    { 0x0003e74f, 0x0000009d, 0x0003e7df, 0x000 },
    { 0x56c44497, 0x6f734201, 0x7ff74697, 0x000 },
    { 0xf7f288d0, 0xd3f44d35, 0xf7f6cdf5, 0x084 },
    { 0x47d3bda5, 0x002d991d, 0x47ffbdbd, 0x004 },
    { 0x0d1f7cd0, 0x0e3b633e, 0x0f3f7ffe, 0x000 },
    { 0x1cf0a392, 0xba82d515, 0xbef2f797, 0x080 },
    { 0x001cc08d, 0x000002a5, 0x001cc2ad, 0x000 },
    { 0x1b0c4e96, 0x44fb888d, 0x5fffce9f, 0x004 },
    { 0x9dc1e389, 0x244146a2, 0xbdc1e7ab, 0x080 },
    { 0x01fcb293, 0x00766ec1, 0x01fefed3, 0x000 },
    { 0xd0e15b0a, 0x3b201701, 0xfbe15f0b, 0x080 },
    { 0xb7c681cd, 0x0973f72a, 0xbff7f7ef, 0x080 },
    { 0x000183aa, 0x00006fc4, 0x0001efee, 0x004 },
    { 0x2ea5d094, 0x4820bc79, 0x6ea5fcfd, 0x000 },
    { 0x9d35b01a, 0x2fbc89f1, 0xbfbdb9fb, 0x080 },
    { 0x00000451, 0x0000012f, 0x0000057f, 0x000 },
    { 0x88e90747, 0x3adccae2, 0xbafdcfe7, 0x084 },
    { 0x358bfa72, 0xf8e76dd4, 0xfdeffff6, 0x084 },
    { 0x000034e6, 0x0000154b, 0x000035ef, 0x000 },
    { 0x2b0639ee, 0xe5c56f26, 0xefc77fee, 0x084 },
    { 0xc5045bfd, 0xac18dc45, 0xed1cdffd, 0x080 },
    /* r/m32, imm8: */
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x084 },
    { 0x00000000, 0xffffffff, 0xffffffff, 0x084 },
    { 0x013505d4, 0x00000034, 0x013505f4, 0x000 },
    { 0xf6c4888e, 0xffffff8c, 0xffffff8e, 0x084 },
    { 0x2c481204, 0x00000025, 0x2c481225, 0x000 },
    { 0x00000029, 0x00000005, 0x0000002d, 0x004 },
    { 0xfdee5a6e, 0xffffff85, 0xffffffef, 0x080 },
    { 0x0df97fdf, 0x00000077, 0x0df97fff, 0x004 },
    { 0x00013bee, 0xffffffbf, 0xffffffff, 0x084 },
    { 0x12552d79, 0x00000029, 0x12552d79, 0x000 },
    { 0xac77aae9, 0xffffffa1, 0xffffffe9, 0x080 },
    { 0x0048d13f, 0x00000032, 0x0048d13f, 0x004 },
    { 0xb4540d6e, 0x0000006c, 0xb4540d6e, 0x080 },
    { 0x776cc453, 0xffffff92, 0xffffffd3, 0x080 },
    { 0x005049f2, 0xffffffa5, 0xfffffff7, 0x080 },
    { 0xa2fd568b, 0xffffff9f, 0xffffff9f, 0x084 },
    { 0x62e63155, 0x0000002c, 0x62e6317d, 0x004 },
    { 0x00007cb4, 0x00000034, 0x00007cb4, 0x004 },
    { 0x801e8448, 0x00000007, 0x801e844f, 0x080 },
    { 0x1ae6db64, 0x00000008, 0x1ae6db6c, 0x004 },
    { 0x11e6e6b0, 0x00000046, 0x11e6e6f6, 0x004 },
    { 0xb56a7eeb, 0xffffffb2, 0xfffffffb, 0x080 },
    { 0x797b6fbd, 0xffffffc6, 0xffffffff, 0x084 },
    { 0x043ec31c, 0xffffffa6, 0xffffffbe, 0x084 },
    { 0xa35bc000, 0x00000022, 0xa35bc022, 0x084 },
    { 0x578665ad, 0xffffffeb, 0xffffffef, 0x080 },
    { 0x01adf9d0, 0xffffffbc, 0xfffffffc, 0x084 },
    { 0xbb93d60a, 0xffffffe8, 0xffffffea, 0x080 },
    { 0x7148123c, 0x0000003e, 0x7148123e, 0x000 },
    { 0x0014608c, 0xffffffc9, 0xffffffcd, 0x080 },
    { 0x35787027, 0xffffffdd, 0xffffffff, 0x084 },
    { 0xd76cf6b6, 0xffffff91, 0xffffffb7, 0x084 },
    { 0x00000526, 0x0000000a, 0x0000052e, 0x004 },
    { 0x491b3a8a, 0xffffffb1, 0xffffffbb, 0x084 },
    { 0x8e7404f2, 0xffffff88, 0xfffffffa, 0x084 },
};

const uint16_t g_cBs3CpuInstr2_xor_TestDataU8 = 32;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_xor_TestDataU8[32] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0xff, 0xff, 0x00, 0x044 },
    { 0x00, 0xff, 0xff, 0x084 },
    { 0xa7, 0x75, 0xd2, 0x084 },
    { 0x68, 0xad, 0xc5, 0x084 },
    { 0x80, 0x1f, 0x9f, 0x084 },
    { 0xe2, 0xac, 0x4e, 0x004 },
    { 0x0c, 0x46, 0x4a, 0x000 },
    { 0x1a, 0x74, 0x6e, 0x000 },
    { 0xaf, 0x66, 0xc9, 0x084 },
    { 0x4d, 0x5d, 0x10, 0x000 },
    { 0xaf, 0x5e, 0xf1, 0x080 },
    { 0x4d, 0x1d, 0x50, 0x004 },
    { 0x37, 0x49, 0x7e, 0x004 },
    { 0xd3, 0xa0, 0x73, 0x000 },
    { 0x74, 0x7d, 0x09, 0x004 },
    { 0xfa, 0x54, 0xae, 0x080 },
    { 0x53, 0x0e, 0x5d, 0x000 },
    { 0x7a, 0x6e, 0x14, 0x004 },
    { 0x3c, 0xa7, 0x9b, 0x080 },
    { 0x91, 0x91, 0x00, 0x044 },
    { 0xab, 0x85, 0x2e, 0x004 },
    { 0x71, 0x75, 0x04, 0x000 },
    { 0x7c, 0xd3, 0xaf, 0x084 },
    { 0x9e, 0xd0, 0x4e, 0x004 },
    { 0xe5, 0x83, 0x66, 0x004 },
    { 0x9f, 0x3f, 0xa0, 0x084 },
    { 0xa3, 0x16, 0xb5, 0x080 },
    { 0x28, 0xea, 0xc2, 0x080 },
    { 0x02, 0x66, 0x64, 0x000 },
    { 0xf2, 0xfb, 0x09, 0x004 },
    { 0xaa, 0x66, 0xcc, 0x084 },
};

const uint16_t g_cBs3CpuInstr2_xor_TestDataU16 = 64;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_xor_TestDataU16[64] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0x0000, 0x044 },
    { 0x0000, 0xffff, 0xffff, 0x084 },
    { 0x002d, 0x1ec8, 0x1ee5, 0x000 },
    { 0x3f80, 0x17c5, 0x2845, 0x000 },
    { 0xa22f, 0xd25d, 0x7072, 0x004 },
    { 0x0001, 0x04c4, 0x04c5, 0x004 },
    { 0x1d14, 0x0d57, 0x1043, 0x000 },
    { 0xe4d8, 0x4ae9, 0xae31, 0x080 },
    { 0x0a90, 0x064b, 0x0cdb, 0x004 },
    { 0x2d83, 0x2f4f, 0x02cc, 0x004 },
    { 0xf9f7, 0xed10, 0x14e7, 0x004 },
    { 0x34d3, 0x01cf, 0x351c, 0x000 },
    { 0x9ba6, 0xb450, 0x2ff6, 0x004 },
    { 0xfba5, 0x3ac5, 0xc160, 0x084 },
    { 0x0078, 0x003e, 0x0046, 0x000 },
    { 0x984f, 0x9f2c, 0x0763, 0x004 },
    { 0x40d6, 0xa6d1, 0xe607, 0x080 },
    { 0x0007, 0x0024, 0x0023, 0x000 },
    { 0x1cd5, 0xecae, 0xf07b, 0x084 },
    { 0xc9db, 0x5156, 0x988d, 0x084 },
    { 0x009d, 0x0c59, 0x0cc4, 0x000 },
    { 0x57c3, 0xc7e8, 0x902b, 0x084 },
    { 0x6e8e, 0x5107, 0x3f89, 0x000 },
    { 0x003f, 0x0007, 0x0038, 0x000 },
    { 0xc7e9, 0xa1c5, 0x662c, 0x000 },
    { 0x8dcd, 0xb794, 0x3a59, 0x004 },
    { 0x0769, 0x09d0, 0x0eb9, 0x000 },
    { 0x17ca, 0x0ca2, 0x1b68, 0x000 },
    { 0x66f8, 0x44ab, 0x2253, 0x004 },
    { 0x077f, 0x2034, 0x274b, 0x004 },
    { 0xb74b, 0xa6d1, 0x119a, 0x004 },
    /* r/m16, imm8: */
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0x0000, 0x044 },
    { 0x0000, 0xffff, 0xffff, 0x084 },
    { 0x017b, 0x006e, 0x0115, 0x000 },
    { 0x5855, 0x001c, 0x5849, 0x000 },
    { 0x8c47, 0xfff3, 0x73b4, 0x004 },
    { 0x010f, 0x005c, 0x0153, 0x004 },
    { 0x2aea, 0x0028, 0x2ac2, 0x000 },
    { 0xae45, 0xffe7, 0x51a2, 0x000 },
    { 0x000b, 0xffe9, 0xffe2, 0x084 },
    { 0x281d, 0xffe4, 0xd7f9, 0x084 },
    { 0x8e20, 0xffa9, 0x7189, 0x000 },
    { 0x0004, 0xff84, 0xff80, 0x080 },
    { 0x1fe3, 0x000d, 0x1fee, 0x004 },
    { 0x156b, 0x0008, 0x1563, 0x004 },
    { 0x1fb0, 0x003d, 0x1f8d, 0x004 },
    { 0xdd30, 0xffb6, 0x2286, 0x000 },
    { 0x74e9, 0x0040, 0x74a9, 0x004 },
    { 0x007c, 0x004e, 0x0032, 0x000 },
    { 0xf45e, 0xffa4, 0x0bfa, 0x004 },
    { 0x72f3, 0xffef, 0x8d1c, 0x080 },
    { 0x00ef, 0x0064, 0x008b, 0x004 },
    { 0xe4b9, 0xffb3, 0x1b0a, 0x004 },
    { 0x0210, 0xffac, 0xfdbc, 0x080 },
    { 0x0428, 0xffb4, 0xfb9c, 0x084 },
    { 0xfe5a, 0xffa8, 0x01f2, 0x000 },
    { 0x10c4, 0xff93, 0xef57, 0x080 },
    { 0x000e, 0xffd5, 0xffdb, 0x084 },
    { 0x61d5, 0x0003, 0x61d6, 0x000 },
    { 0x21ad, 0x005f, 0x21f2, 0x000 },
    { 0x028e, 0xfffa, 0xfd74, 0x084 },
    { 0xfcf5, 0xffd6, 0x0323, 0x000 },
};

const uint16_t g_cBs3CpuInstr2_xor_TestDataU32 = 72;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_xor_TestDataU32[72] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0x00000000, 0x044 },
    { 0x00000000, 0xffffffff, 0xffffffff, 0x084 },
    { 0x000bc0e2, 0x0dbc2f20, 0x0db7efc2, 0x000 },
    { 0x1db9f555, 0x9b99aeb2, 0x86205be7, 0x084 },
    { 0x869c3646, 0xb9af310d, 0x3f33074b, 0x004 },
    { 0x00002e4d, 0x000b27a8, 0x000b09e5, 0x000 },
    { 0x5f58892e, 0x2d963b15, 0x72ceb23b, 0x000 },
    { 0xa20117e8, 0xf5c891c8, 0x57c98620, 0x000 },
    { 0x0000c111, 0x000001ae, 0x0000c0bf, 0x000 },
    { 0x76184ca6, 0x755062dc, 0x03482e7a, 0x000 },
    { 0x308a74dc, 0x91fe3069, 0xa17444b5, 0x080 },
    { 0x0000e172, 0x000002e5, 0x0000e397, 0x000 },
    { 0xb4393aae, 0x593b904b, 0xed02aae5, 0x080 },
    { 0x157e38de, 0xd1c781d8, 0xc4b9b906, 0x084 },
    { 0x0122de4f, 0x0000fa14, 0x0122245b, 0x000 },
    { 0xe8f23c87, 0x3763f8e4, 0xdf91c463, 0x084 },
    { 0xc4697df8, 0x29cd47de, 0xeda43a26, 0x080 },
    { 0x0000b0e6, 0x0008dd52, 0x00086db4, 0x004 },
    { 0xaa7a572e, 0xc5f1c39f, 0x6f8b94b1, 0x004 },
    { 0x0361fec5, 0x969d5a12, 0x95fca4d7, 0x084 },
    { 0x02fa8129, 0x007d6e81, 0x0287efa8, 0x000 },
    { 0xd104c12f, 0x8f271e37, 0x5e23df18, 0x004 },
    { 0xd130b4a6, 0x94a427ee, 0x45949348, 0x004 },
    { 0x00003178, 0x00e5cf4f, 0x00e5fe37, 0x000 },
    { 0x9d8d7e42, 0xf45c4f09, 0x69d1314b, 0x004 },
    { 0x1849138d, 0x25a2bb43, 0x3deba8ce, 0x000 },
    { 0x000000e1, 0x031bd588, 0x031bd569, 0x004 },
    { 0x68600ec2, 0x7a68f743, 0x1208f981, 0x004 },
    { 0x6e86d55e, 0x5622262f, 0x38a4f371, 0x004 },
    { 0x000fe84d, 0x00463f67, 0x0049d72a, 0x000 },
    { 0x7d6cb9f4, 0xed248280, 0x90483b74, 0x084 },
    { 0xb7f3d97a, 0x6a4b161c, 0xddb8cf66, 0x084 },
    { 0x002a5422, 0x0000c8cf, 0x002a9ced, 0x004 },
    { 0xe8d38f57, 0x9967ce85, 0x71b441d2, 0x004 },
    { 0x2e278aca, 0x26090c45, 0x082e868f, 0x000 },
    /* r/m32, imm8: */
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0x00000000, 0x044 },
    { 0x00000000, 0xffffffff, 0xffffffff, 0x084 },
    { 0x0006169a, 0x0000006a, 0x000616f0, 0x004 },
    { 0xa7a4ab5f, 0x0000004e, 0xa7a4ab11, 0x084 },
    { 0x9779c96a, 0x00000003, 0x9779c969, 0x084 },
    { 0x066dd027, 0xffffffdc, 0xf9922ffb, 0x080 },
    { 0x704cf218, 0x00000041, 0x704cf259, 0x004 },
    { 0x961eeb36, 0xffffff92, 0x69e114a4, 0x000 },
    { 0x1a8e9741, 0x00000043, 0x1a8e9702, 0x000 },
    { 0x7ef60fed, 0xffffffe6, 0x8109f00b, 0x080 },
    { 0xada6d27b, 0xffffffa7, 0x52592ddc, 0x000 },
    { 0x003eae46, 0xffffffca, 0xffc1518c, 0x080 },
    { 0xfd0a2a96, 0xfffffffc, 0x02f5d56a, 0x004 },
    { 0xce0e9f1c, 0x00000079, 0xce0e9f65, 0x084 },
    { 0x00eed1f4, 0xffffffb3, 0xff112e47, 0x084 },
    { 0x83030a7f, 0x00000064, 0x83030a1b, 0x084 },
    { 0x7ccd1357, 0xfffffff0, 0x8332eca7, 0x080 },
    { 0x0000e68c, 0xffffffce, 0xffff1942, 0x084 },
    { 0x29029320, 0xffffffbc, 0xd6fd6c9c, 0x084 },
    { 0x3b51d42c, 0xffffff89, 0xc4ae2ba5, 0x084 },
    { 0x000000ca, 0x0000002f, 0x000000e5, 0x000 },
    { 0xaaa3bb67, 0xffffffe3, 0x555c4484, 0x004 },
    { 0xa2b9b43c, 0xfffffff3, 0x5d464bcf, 0x004 },
    { 0x0000026d, 0x00000068, 0x00000205, 0x004 },
    { 0xe4208f17, 0x0000005c, 0xe4208f4b, 0x084 },
    { 0xfd779114, 0xffffff92, 0x02886e86, 0x000 },
    { 0x00014ab5, 0xffffffef, 0xfffeb55a, 0x084 },
    { 0x65005d1f, 0x00000006, 0x65005d19, 0x000 },
    { 0xbfa3c6f0, 0x00000007, 0xbfa3c6f7, 0x080 },
    { 0x00000f27, 0x0000003d, 0x00000f1a, 0x000 },
    { 0xbc512b3f, 0xffffffdc, 0x43aed4e3, 0x000 },
    { 0x533a32aa, 0xffffffc2, 0xacc5cd68, 0x080 },
    { 0x006c6744, 0xfffffff8, 0xff9398bc, 0x080 },
    { 0x028da316, 0x0000007c, 0x028da36a, 0x004 },
    { 0x3b6e9b8a, 0x00000055, 0x3b6e9bdf, 0x000 },
};

const uint16_t g_cBs3CpuInstr2_test_TestDataU8 = 32;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_test_TestDataU8[32] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0xff, 0xff, 0xff, 0x084 },
    { 0x00, 0xff, 0x00, 0x044 },
    { 0x1d, 0x72, 0x1d, 0x000 },
    { 0x41, 0x02, 0x41, 0x044 },
    { 0xfe, 0xcb, 0xfe, 0x084 },
    { 0xf2, 0x2d, 0xf2, 0x000 },
    { 0xfa, 0xa3, 0xfa, 0x080 },
    { 0x5a, 0x86, 0x5a, 0x000 },
    { 0x0c, 0xad, 0x0c, 0x004 },
    { 0x23, 0x37, 0x23, 0x000 },
    { 0xaa, 0x83, 0xaa, 0x084 },
    { 0x6b, 0x0e, 0x6b, 0x004 },
    { 0xe3, 0xc2, 0xe3, 0x080 },
    { 0x19, 0x7d, 0x19, 0x000 },
    { 0x47, 0x13, 0x47, 0x004 },
    { 0x19, 0x6c, 0x19, 0x000 },
    { 0x42, 0x5f, 0x42, 0x004 },
    { 0x45, 0xfe, 0x45, 0x004 },
    { 0x80, 0x75, 0x80, 0x044 },
    { 0xa1, 0x70, 0xa1, 0x000 },
    { 0xa4, 0xa2, 0xa4, 0x084 },
    { 0xed, 0xeb, 0xed, 0x080 },
    { 0x6d, 0xa4, 0x6d, 0x004 },
    { 0xa2, 0x2d, 0xa2, 0x000 },
    { 0x19, 0x87, 0x19, 0x000 },
    { 0xda, 0x6a, 0xda, 0x000 },
    { 0xb6, 0xa7, 0xb6, 0x084 },
    { 0x21, 0x75, 0x21, 0x004 },
    { 0x91, 0xb1, 0x91, 0x080 },
    { 0x9f, 0xb0, 0x9f, 0x084 },
    { 0x58, 0x47, 0x58, 0x000 },
};

const uint16_t g_cBs3CpuInstr2_test_TestDataU16 = 64;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_test_TestDataU16[64] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x084 },
    { 0x0000, 0xffff, 0x0000, 0x044 },
    { 0x01d2, 0x0000, 0x01d2, 0x044 },
    { 0x71f8, 0x6eee, 0x71f8, 0x004 },
    { 0xeae7, 0xeaa6, 0xeae7, 0x084 },
    { 0x007d, 0x2c05, 0x007d, 0x004 },
    { 0xa7d5, 0xb6b7, 0xa7d5, 0x084 },
    { 0xd458, 0x0768, 0xd458, 0x004 },
    { 0x0029, 0x141d, 0x0029, 0x004 },
    { 0x0dd9, 0x367d, 0x0dd9, 0x004 },
    { 0x61f9, 0x6275, 0x61f9, 0x004 },
    { 0x0052, 0x005f, 0x0052, 0x000 },
    { 0x813a, 0x1c3e, 0x813a, 0x004 },
    { 0x57cd, 0x8861, 0x57cd, 0x004 },
    { 0x007d, 0x001a, 0x007d, 0x004 },
    { 0x44aa, 0x182d, 0x44aa, 0x004 },
    { 0x70ca, 0x143d, 0x70ca, 0x000 },
    { 0x0878, 0x0048, 0x0878, 0x004 },
    { 0x6a42, 0x181e, 0x6a42, 0x000 },
    { 0x9128, 0xe5d1, 0x9128, 0x084 },
    { 0x0008, 0x0674, 0x0008, 0x044 },
    { 0x3323, 0x7859, 0x3323, 0x000 },
    { 0x4880, 0xee35, 0x4880, 0x004 },
    { 0x0012, 0x007d, 0x0012, 0x000 },
    { 0xf39a, 0x2fa6, 0xf39a, 0x004 },
    { 0x4738, 0xcc44, 0x4738, 0x004 },
    { 0x000a, 0x0105, 0x000a, 0x044 },
    { 0x70e1, 0xe0bb, 0x70e1, 0x000 },
    { 0x4898, 0x3217, 0x4898, 0x000 },
    { 0x00bc, 0x74af, 0x00bc, 0x004 },
    { 0x28cf, 0x57a1, 0x28cf, 0x004 },
    /* r/m16, imm8: */
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x084 },
    { 0x0000, 0xffff, 0x0000, 0x044 },
    { 0x081f, 0x0052, 0x081f, 0x004 },
    { 0x074e, 0x0063, 0x074e, 0x004 },
    { 0xe802, 0x005b, 0xe802, 0x000 },
    { 0x01e1, 0x005b, 0x01e1, 0x004 },
    { 0x3b66, 0x004d, 0x3b66, 0x004 },
    { 0xd4b5, 0xfffc, 0xd4b5, 0x084 },
    { 0x0028, 0xff88, 0x0028, 0x000 },
    { 0xad08, 0xffbb, 0xad08, 0x080 },
    { 0xc34d, 0xff8e, 0xc34d, 0x084 },
    { 0x0017, 0x0065, 0x0017, 0x004 },
    { 0xa836, 0x0033, 0xa836, 0x000 },
    { 0x8648, 0x007c, 0x8648, 0x004 },
    { 0x0789, 0x005f, 0x0789, 0x004 },
    { 0x2c1c, 0x002e, 0x2c1c, 0x004 },
    { 0x3e9f, 0x0071, 0x3e9f, 0x004 },
    { 0x004a, 0x0064, 0x004a, 0x000 },
    { 0xb45c, 0xffe0, 0xb45c, 0x080 },
    { 0x685b, 0xff8b, 0x685b, 0x000 },
    { 0x03c7, 0xffe2, 0x03c7, 0x000 },
    { 0xd816, 0xffdd, 0xd816, 0x084 },
    { 0xf93a, 0x0043, 0xf93a, 0x000 },
    { 0x000e, 0xffee, 0x000e, 0x000 },
    { 0x5be5, 0x001f, 0x5be5, 0x004 },
    { 0x5f4b, 0xffd1, 0x5f4b, 0x004 },
    { 0x00e2, 0xff82, 0x00e2, 0x004 },
    { 0x8404, 0x001e, 0x8404, 0x000 },
    { 0x14da, 0xfff2, 0x14da, 0x004 },
    { 0x002e, 0xffaf, 0x002e, 0x004 },
    { 0x2d6d, 0x0022, 0x2d6d, 0x000 },
};

const uint16_t g_cBs3CpuInstr2_test_TestDataU32 = 72;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_test_TestDataU32[72] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x084 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x044 },
    { 0x000006ea, 0x0007ae7d, 0x000006ea, 0x000 },
    { 0x81a0cd2d, 0xa3fe6704, 0x81a0cd2d, 0x080 },
    { 0x131d4a12, 0xe7e9ed8b, 0x131d4a12, 0x000 },
    { 0x0000467f, 0x2473771b, 0x0000467f, 0x004 },
    { 0xbf0caf22, 0x19be0184, 0xbf0caf22, 0x004 },
    { 0x0955af23, 0x185d4872, 0x0955af23, 0x004 },
    { 0x04bb778d, 0x0279f5c0, 0x04bb778d, 0x000 },
    { 0x80f54d04, 0x289362ed, 0x80f54d04, 0x000 },
    { 0x6443ca6a, 0x1e9e2893, 0x6443ca6a, 0x000 },
    { 0x06fe83fa, 0x000019a4, 0x06fe83fa, 0x004 },
    { 0xe8431d77, 0x0e438447, 0xe8431d77, 0x004 },
    { 0xf2a17975, 0x872d0a4b, 0xf2a17975, 0x084 },
    { 0x0000027f, 0x00000357, 0x0000027f, 0x000 },
    { 0x7f688e15, 0x69482538, 0x7f688e15, 0x000 },
    { 0x7f83b587, 0x6002f378, 0x7f83b587, 0x004 },
    { 0x00001613, 0x00002f39, 0x00001613, 0x004 },
    { 0x28906b4d, 0xe174c1dc, 0x28906b4d, 0x000 },
    { 0xf8638480, 0x4d900c6c, 0xf8638480, 0x004 },
    { 0x00005e4d, 0x00000e54, 0x00005e4d, 0x004 },
    { 0x73ed4e07, 0xdf2dba78, 0x73ed4e07, 0x004 },
    { 0x332d2c45, 0x1ab5a116, 0x332d2c45, 0x000 },
    { 0x000009ce, 0x000089f9, 0x000009ce, 0x000 },
    { 0xa1d36492, 0x3d6fbe97, 0xa1d36492, 0x000 },
    { 0x7349cb03, 0xf1af6d16, 0x7349cb03, 0x000 },
    { 0x0434e0fc, 0x009737e8, 0x0434e0fc, 0x004 },
    { 0x17d77944, 0xc35a6b96, 0x17d77944, 0x000 },
    { 0xbcbf4bd8, 0x330c7110, 0xbcbf4bd8, 0x000 },
    { 0x00000280, 0x0111244d, 0x00000280, 0x044 },
    { 0xd0664a23, 0xab8d6911, 0xd0664a23, 0x080 },
    { 0xd0ed1241, 0x3c497215, 0xd0ed1241, 0x000 },
    { 0x00013c95, 0x00e540b9, 0x00013c95, 0x000 },
    { 0xe7fc60d1, 0xaa384dd9, 0xe7fc60d1, 0x084 },
    { 0x967ef736, 0x69982697, 0x967ef736, 0x000 },
    /* r/m32, imm8: */
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x084 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x044 },
    { 0x00000081, 0xffffffa2, 0x00000081, 0x000 },
    { 0x869c2f5d, 0x0000000e, 0x869c2f5d, 0x004 },
    { 0x84603ea3, 0xffffff93, 0x84603ea3, 0x080 },
    { 0x000e12a7, 0xffffffa2, 0x000e12a7, 0x000 },
    { 0x912e282a, 0x00000009, 0x912e282a, 0x000 },
    { 0x1f56f71c, 0x00000057, 0x1f56f71c, 0x004 },
    { 0x000008b8, 0xffffff84, 0x000008b8, 0x000 },
    { 0x61dcdfb7, 0xffffff94, 0x61dcdfb7, 0x000 },
    { 0x704babd7, 0x00000006, 0x704babd7, 0x004 },
    { 0x02c82b87, 0xffffffbb, 0x02c82b87, 0x000 },
    { 0x3825e9ad, 0xffffffa7, 0x3825e9ad, 0x004 },
    { 0xe0a2e450, 0xffffffed, 0xe0a2e450, 0x080 },
    { 0x09524800, 0x00000005, 0x09524800, 0x044 },
    { 0x08a05710, 0xffffffdc, 0x08a05710, 0x000 },
    { 0xfb2e10fc, 0xffffffbe, 0xfb2e10fc, 0x080 },
    { 0x00012e1f, 0xffffffce, 0x00012e1f, 0x000 },
    { 0xcb4c3978, 0xffffffe6, 0xcb4c3978, 0x084 },
    { 0x7bfed743, 0x0000007a, 0x7bfed743, 0x004 },
    { 0x01dfb499, 0xffffff98, 0x01dfb499, 0x000 },
    { 0x4313e4f3, 0xffffffec, 0x4313e4f3, 0x000 },
    { 0x838e5787, 0x0000001d, 0x838e5787, 0x004 },
    { 0x00001d82, 0x00000065, 0x00001d82, 0x044 },
    { 0xddb218c1, 0xfffffff5, 0xddb218c1, 0x080 },
    { 0x9bee1baf, 0x0000004f, 0x9bee1baf, 0x004 },
    { 0x16fe8aaa, 0xffffffb1, 0x16fe8aaa, 0x004 },
    { 0x1e2d5b85, 0x00000010, 0x1e2d5b85, 0x044 },
    { 0x0d0094d8, 0x00000066, 0x0d0094d8, 0x000 },
    { 0x0016398a, 0x00000005, 0x0016398a, 0x044 },
    { 0x4b103561, 0xfffffff3, 0x4b103561, 0x000 },
    { 0x86e4c52e, 0x0000005e, 0x86e4c52e, 0x000 },
    { 0x15d95aae, 0x00000020, 0x15d95aae, 0x000 },
    { 0xe4b31553, 0xfffffff7, 0xe4b31553, 0x084 },
    { 0xa7a1b01b, 0xfffffff0, 0xa7a1b01b, 0x080 },
};

const uint16_t g_cBs3CpuInstr2_add_TestDataU8 = 32;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_add_TestDataU8[32] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0xff, 0xff, 0xfe, 0x091 },
    { 0x00, 0xff, 0xff, 0x084 },
    { 0x00, 0xa5, 0xa5, 0x084 },
    { 0xa1, 0xfb, 0x9c, 0x085 },
    { 0xef, 0x94, 0x83, 0x091 },
    { 0x79, 0xf9, 0x72, 0x015 },
    { 0x56, 0x7b, 0xd1, 0x894 },
    { 0x15, 0xd2, 0xe7, 0x084 },
    { 0xd8, 0x93, 0x6b, 0x801 },
    { 0xbc, 0x1b, 0xd7, 0x094 },
    { 0x43, 0x01, 0x44, 0x004 },
    { 0xf1, 0xa7, 0x98, 0x081 },
    { 0xe2, 0x7c, 0x5e, 0x001 },
    { 0x9c, 0x40, 0xdc, 0x080 },
    { 0xe6, 0x56, 0x3c, 0x005 },
    { 0xbe, 0xda, 0x98, 0x091 },
    { 0x56, 0xe2, 0x38, 0x001 },
    { 0x66, 0xbb, 0x21, 0x015 },
    { 0xc6, 0xf2, 0xb8, 0x085 },
    { 0x55, 0x51, 0xa6, 0x884 },
    { 0x61, 0x3b, 0x9c, 0x884 },
    { 0xdb, 0x27, 0x02, 0x011 },
    { 0x18, 0x16, 0x2e, 0x004 },
    { 0x45, 0xa7, 0xec, 0x080 },
    { 0xfd, 0xa8, 0xa5, 0x095 },
    { 0x4a, 0xbe, 0x08, 0x011 },
    { 0x3b, 0xe9, 0x24, 0x015 },
    { 0x75, 0x88, 0xfd, 0x080 },
    { 0xdf, 0xa4, 0x83, 0x091 },
    { 0x96, 0x28, 0xbe, 0x084 },
    { 0x29, 0x27, 0x50, 0x014 },
};

const uint16_t g_cBs3CpuInstr2_add_TestDataU16 = 64;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_add_TestDataU16[64] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xfffe, 0x091 },
    { 0x0000, 0xffff, 0xffff, 0x084 },
    { 0x0c62, 0x0042, 0x0ca4, 0x000 },
    { 0x3c9b, 0x254a, 0x61e5, 0x010 },
    { 0x207f, 0x8882, 0xa901, 0x090 },
    { 0x0011, 0x3c24, 0x3c35, 0x004 },
    { 0x360e, 0xfdd4, 0x33e2, 0x015 },
    { 0x6e9a, 0x6dda, 0xdc74, 0x894 },
    { 0x0a9e, 0x1b02, 0x25a0, 0x014 },
    { 0x61cc, 0x9ae7, 0xfcb3, 0x090 },
    { 0xcdca, 0xa71d, 0x74e7, 0x815 },
    { 0x005b, 0x0073, 0x00ce, 0x000 },
    { 0xa9ce, 0x1da7, 0xc775, 0x090 },
    { 0xe084, 0x138a, 0xf40e, 0x080 },
    { 0x0e14, 0x0061, 0x0e75, 0x000 },
    { 0x07f6, 0xc90b, 0xd101, 0x090 },
    { 0x2609, 0x3855, 0x5e5e, 0x000 },
    { 0x0004, 0x6777, 0x677b, 0x004 },
    { 0xf255, 0xe147, 0xd39c, 0x085 },
    { 0x0bfa, 0x60e8, 0x6ce2, 0x014 },
    { 0x002f, 0x001a, 0x0049, 0x010 },
    { 0x33e3, 0x9e13, 0xd1f6, 0x084 },
    { 0xf912, 0x4032, 0x3944, 0x005 },
    { 0x07ba, 0x04aa, 0x0c64, 0x010 },
    { 0x37dc, 0x5604, 0x8de0, 0x890 },
    { 0x57b1, 0x29b8, 0x8169, 0x884 },
    { 0x01b8, 0x0033, 0x01eb, 0x004 },
    { 0x292c, 0x0fa7, 0x38d3, 0x010 },
    { 0xb0f9, 0xd356, 0x844f, 0x081 },
    { 0x0780, 0x001c, 0x079c, 0x004 },
    { 0x3dd1, 0x6934, 0xa705, 0x884 },
    /* r/m16, imm8: */
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xfffe, 0x091 },
    { 0x0000, 0xffff, 0xffff, 0x084 },
    { 0x0664, 0x004d, 0x06b1, 0x014 },
    { 0x0385, 0xffe4, 0x0369, 0x005 },
    { 0x5eb9, 0xffb4, 0x5e6d, 0x001 },
    { 0x041e, 0xff98, 0x03b6, 0x011 },
    { 0x4c11, 0xffdc, 0x4bed, 0x005 },
    { 0x5969, 0x002b, 0x5994, 0x010 },
    { 0x190f, 0x0045, 0x1954, 0x010 },
    { 0x4fd9, 0xffd1, 0x4faa, 0x005 },
    { 0x13fa, 0x0016, 0x1410, 0x010 },
    { 0x0157, 0x0008, 0x015f, 0x004 },
    { 0x788d, 0x0004, 0x7891, 0x010 },
    { 0x60a3, 0x0021, 0x60c4, 0x000 },
    { 0x0985, 0x0058, 0x09dd, 0x004 },
    { 0x3193, 0x0025, 0x31b8, 0x004 },
    { 0x16e4, 0x0046, 0x172a, 0x000 },
    { 0x0390, 0xffaa, 0x033a, 0x005 },
    { 0x54e5, 0xff89, 0x546e, 0x001 },
    { 0xb646, 0xffe1, 0xb627, 0x085 },
    { 0x7ff3, 0x0042, 0x8035, 0x884 },
    { 0x678b, 0x0021, 0x67ac, 0x004 },
    { 0xcae3, 0xffef, 0xcad2, 0x095 },
    { 0x065f, 0xff96, 0x05f5, 0x015 },
    { 0x9702, 0x0013, 0x9715, 0x080 },
    { 0x001b, 0xffb0, 0xffcb, 0x080 },
    { 0x003b, 0xffa0, 0xffdb, 0x084 },
    { 0xef7b, 0xffb2, 0xef2d, 0x085 },
    { 0xff66, 0xffbc, 0xff22, 0x095 },
    { 0x006d, 0xfff3, 0x0060, 0x015 },
    { 0xe6ad, 0x005b, 0xe708, 0x090 },
};

const uint16_t g_cBs3CpuInstr2_add_TestDataU32 = 72;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_add_TestDataU32[72] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xfffffffe, 0x091 },
    { 0x00000000, 0xffffffff, 0xffffffff, 0x084 },
    { 0x0000019e, 0x04031d71, 0x04031f0f, 0x004 },
    { 0xa8976c1d, 0xed3af8bc, 0x95d264d9, 0x091 },
    { 0xfaa036aa, 0x2c64f0f7, 0x270527a1, 0x011 },
    { 0x025ad752, 0x00352ac0, 0x02900212, 0x004 },
    { 0xe889a87c, 0xe59479ae, 0xce1e222a, 0x091 },
    { 0x36c0c29b, 0x29288b05, 0x5fe94da0, 0x014 },
    { 0x0000134a, 0x00012723, 0x00013a6d, 0x000 },
    { 0x09f28dad, 0x53335df5, 0x5d25eba2, 0x010 },
    { 0x115d89ac, 0x53f9841c, 0x65570dc8, 0x010 },
    { 0x0000053b, 0x0000012f, 0x0000066a, 0x014 },
    { 0x46256a8e, 0xbf4b8fda, 0x0570fa68, 0x011 },
    { 0xf9d17280, 0x25b44f27, 0x1f85c1a7, 0x001 },
    { 0x000001e5, 0x00035ee6, 0x000360cb, 0x000 },
    { 0x42cb5db0, 0xb573f012, 0xf83f4dc2, 0x080 },
    { 0x8e964928, 0x6c9d0966, 0xfb33528e, 0x084 },
    { 0x00000ec2, 0x01231b60, 0x01232a22, 0x004 },
    { 0xc7da4c9f, 0x0cdc5ec0, 0xd4b6ab5f, 0x084 },
    { 0x57d095d8, 0x3f1dc4f2, 0x96ee5aca, 0x884 },
    { 0x043e9745, 0x00d95566, 0x0517ecab, 0x000 },
    { 0x4c75d56b, 0xcc0e8b04, 0x1884606f, 0x005 },
    { 0x8ec8da9e, 0xa488e37a, 0x3351be18, 0x815 },
    { 0x059d2970, 0x107d4437, 0x161a6da7, 0x000 },
    { 0x9f86ef53, 0x93ca6324, 0x33515277, 0x805 },
    { 0xcc32daa2, 0xdeafe8c3, 0xaae2c365, 0x085 },
    { 0x0001a6e6, 0x00077120, 0x00091806, 0x004 },
    { 0xfe63f703, 0x94ee05f5, 0x9351fcf8, 0x081 },
    { 0x16c9228f, 0x6efbe5f8, 0x85c50887, 0x894 },
    { 0x1926eb76, 0x001a79a3, 0x19416519, 0x000 },
    { 0x8ce7fda7, 0x92bde58f, 0x1fa5e336, 0x815 },
    { 0x0b33b9e6, 0xf0f1d19c, 0xfc258b82, 0x094 },
    { 0x000010e3, 0x073e812b, 0x073e920e, 0x000 },
    { 0xe0926f50, 0x6dca1eb8, 0x4e5c8e08, 0x001 },
    { 0x30a6d984, 0x5a128210, 0x8ab95b94, 0x880 },
    /* r/m32, imm8: */
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xfffffffe, 0x091 },
    { 0x00000000, 0xffffffff, 0xffffffff, 0x084 },
    { 0x00020444, 0xffffffc7, 0x0002040b, 0x001 },
    { 0x46675a35, 0xffffffaf, 0x466759e4, 0x015 },
    { 0x734cae61, 0x0000006a, 0x734caecb, 0x000 },
    { 0x00000256, 0x00000051, 0x000002a7, 0x000 },
    { 0xbf96698d, 0xffffff98, 0xbf966925, 0x091 },
    { 0x04be89af, 0xffffff97, 0x04be8946, 0x011 },
    { 0x19b2ff6b, 0xffffffc0, 0x19b2ff2b, 0x005 },
    { 0xd53e85e0, 0xffffffd8, 0xd53e85b8, 0x085 },
    { 0x5ea74464, 0xffffffc8, 0x5ea7442c, 0x001 },
    { 0x00006f04, 0xffffffeb, 0x00006eef, 0x001 },
    { 0xfc65d6d8, 0xffffffb6, 0xfc65d68e, 0x085 },
    { 0x97791fbe, 0xffffffcf, 0x97791f8d, 0x095 },
    { 0x0009ed27, 0x00000025, 0x0009ed4c, 0x000 },
    { 0xbb2b431f, 0xffffff92, 0xbb2b42b1, 0x095 },
    { 0x54a1a626, 0x0000005f, 0x54a1a685, 0x010 },
    { 0x000835ca, 0x00000010, 0x000835da, 0x000 },
    { 0xf81f6d05, 0xffffffdf, 0xf81f6ce4, 0x095 },
    { 0xf643bd30, 0x00000025, 0xf643bd55, 0x084 },
    { 0x28d849b3, 0xffffff8b, 0x28d8493e, 0x001 },
    { 0x8dbc729c, 0xffffffcf, 0x8dbc726b, 0x091 },
    { 0xb095c892, 0x0000004e, 0xb095c8e0, 0x090 },
    { 0x00000741, 0xffffffb0, 0x000006f1, 0x001 },
    { 0x6c3ce5fa, 0xffffff9a, 0x6c3ce594, 0x011 },
    { 0x1ea7e8c1, 0xffffffa0, 0x1ea7e861, 0x001 },
    { 0x0000039e, 0x0000007a, 0x00000418, 0x014 },
    { 0x39ec44e2, 0xfffffff7, 0x39ec44d9, 0x001 },
    { 0xd3fda486, 0xffffffaa, 0xd3fda430, 0x095 },
    { 0x036f689a, 0x00000019, 0x036f68b3, 0x010 },
    { 0x57b5d935, 0xffffffbc, 0x57b5d8f1, 0x011 },
    { 0xaad3e6fd, 0xffffffd5, 0xaad3e6d2, 0x095 },
    { 0x000400e9, 0xfffffff8, 0x000400e1, 0x015 },
    { 0x1d113876, 0xffffffca, 0x1d113840, 0x011 },
    { 0xd8349aaa, 0x00000023, 0xd8349acd, 0x080 },
};

const uint16_t g_cBs3CpuInstr2_adc_TestDataU8 = 64;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_adc_TestDataU8[64] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0x00, 0x00, 0x01, 0x008 },
    { 0xff, 0xff, 0xfe, 0x091 },
    { 0xff, 0xff, 0xff, 0x09d },
    { 0x00, 0xff, 0xff, 0x084 },
    { 0x00, 0xff, 0x00, 0x05d },
    { 0xef, 0x6b, 0x5a, 0x015 },
    { 0xef, 0x6b, 0x5b, 0x019 },
    { 0xbd, 0x16, 0xd3, 0x090 },
    { 0xbd, 0x16, 0xd4, 0x09c },
    { 0xe0, 0x2d, 0x0d, 0x001 },
    { 0xe0, 0x2d, 0x0e, 0x009 },
    { 0x96, 0xd7, 0x6d, 0x801 },
    { 0x96, 0xd7, 0x6e, 0x809 },
    { 0x49, 0x57, 0xa0, 0x894 },
    { 0x49, 0x57, 0xa1, 0x898 },
    { 0xbb, 0x0d, 0xc8, 0x090 },
    { 0xbb, 0x0d, 0xc9, 0x09c },
    { 0xd1, 0x0c, 0xdd, 0x084 },
    { 0xd1, 0x0c, 0xde, 0x08c },
    { 0x72, 0xaa, 0x1c, 0x001 },
    { 0x72, 0xaa, 0x1d, 0x00d },
    { 0xb0, 0xbd, 0x6d, 0x801 },
    { 0xb0, 0xbd, 0x6e, 0x809 },
    { 0x56, 0x1b, 0x71, 0x014 },
    { 0x56, 0x1b, 0x72, 0x01c },
    { 0x6f, 0xae, 0x1d, 0x015 },
    { 0x6f, 0xae, 0x1e, 0x01d },
    { 0xc6, 0x18, 0xde, 0x084 },
    { 0xc6, 0x18, 0xdf, 0x088 },
    { 0x73, 0x7d, 0xf0, 0x894 },
    { 0x73, 0x7d, 0xf1, 0x898 },
    { 0xba, 0x9d, 0x57, 0x811 },
    { 0xba, 0x9d, 0x58, 0x819 },
    { 0x4e, 0xbf, 0x0d, 0x011 },
    { 0x4e, 0xbf, 0x0e, 0x019 },
    { 0x5c, 0xaf, 0x0b, 0x011 },
    { 0x5c, 0xaf, 0x0c, 0x01d },
    { 0xe1, 0x89, 0x6a, 0x805 },
    { 0xe1, 0x89, 0x6b, 0x809 },
    { 0x4f, 0xcd, 0x1c, 0x011 },
    { 0x4f, 0xcd, 0x1d, 0x01d },
    { 0x4e, 0x4e, 0x9c, 0x894 },
    { 0x4e, 0x4e, 0x9d, 0x898 },
    { 0x74, 0xa1, 0x15, 0x001 },
    { 0x74, 0xa1, 0x16, 0x009 },
    { 0x1e, 0x8d, 0xab, 0x090 },
    { 0x1e, 0x8d, 0xac, 0x09c },
    { 0xaa, 0x3d, 0xe7, 0x094 },
    { 0xaa, 0x3d, 0xe8, 0x09c },
    { 0xf2, 0x83, 0x75, 0x801 },
    { 0xf2, 0x83, 0x76, 0x809 },
    { 0x7f, 0x03, 0x82, 0x894 },
    { 0x7f, 0x03, 0x83, 0x898 },
    { 0x18, 0x22, 0x3a, 0x004 },
    { 0x18, 0x22, 0x3b, 0x008 },
    { 0x77, 0xca, 0x41, 0x015 },
    { 0x77, 0xca, 0x42, 0x01d },
    { 0x32, 0xdf, 0x11, 0x015 },
    { 0x32, 0xdf, 0x12, 0x01d },
    { 0xdf, 0xd7, 0xb6, 0x091 },
    { 0xdf, 0xd7, 0xb7, 0x09d },
    { 0x93, 0xa2, 0x35, 0x805 },
    { 0x93, 0xa2, 0x36, 0x80d },
};

const uint16_t g_cBs3CpuInstr2_adc_TestDataU16 = 128;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_adc_TestDataU16[128] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0x0000, 0x0000, 0x0001, 0x008 },
    { 0xffff, 0xffff, 0xfffe, 0x091 },
    { 0xffff, 0xffff, 0xffff, 0x09d },
    { 0x0000, 0xffff, 0xffff, 0x084 },
    { 0x0000, 0xffff, 0x0000, 0x05d },
    { 0x04ea, 0x000a, 0x04f4, 0x010 },
    { 0x04ea, 0x000a, 0x04f5, 0x01c },
    { 0x68b0, 0x3852, 0xa102, 0x880 },
    { 0x68b0, 0x3852, 0xa103, 0x88c },
    { 0x8f91, 0xa034, 0x2fc5, 0x805 },
    { 0x8f91, 0xa034, 0x2fc6, 0x80d },
    { 0x0008, 0x026d, 0x0275, 0x010 },
    { 0x0008, 0x026d, 0x0276, 0x018 },
    { 0xcd7c, 0xb596, 0x8312, 0x095 },
    { 0xcd7c, 0xb596, 0x8313, 0x099 },
    { 0xc1ea, 0xf1ff, 0xb3e9, 0x091 },
    { 0xc1ea, 0xf1ff, 0xb3ea, 0x099 },
    { 0x015c, 0x0007, 0x0163, 0x014 },
    { 0x015c, 0x0007, 0x0164, 0x018 },
    { 0x546b, 0x7b7f, 0xcfea, 0x890 },
    { 0x546b, 0x7b7f, 0xcfeb, 0x89c },
    { 0xf81b, 0xdac4, 0xd2df, 0x081 },
    { 0xf81b, 0xdac4, 0xd2e0, 0x099 },
    { 0x00e9, 0x030c, 0x03f5, 0x014 },
    { 0x00e9, 0x030c, 0x03f6, 0x01c },
    { 0x7526, 0x2f4a, 0xa470, 0x890 },
    { 0x7526, 0x2f4a, 0xa471, 0x89c },
    { 0xb75a, 0xb61d, 0x6d77, 0x815 },
    { 0xb75a, 0xb61d, 0x6d78, 0x81d },
    { 0x0033, 0x002a, 0x005d, 0x000 },
    { 0x0033, 0x002a, 0x005e, 0x008 },
    { 0x7be0, 0xe85a, 0x643a, 0x005 },
    { 0x7be0, 0xe85a, 0x643b, 0x009 },
    { 0xacfc, 0xfabe, 0xa7ba, 0x091 },
    { 0xacfc, 0xfabe, 0xa7bb, 0x09d },
    { 0x005e, 0x0020, 0x007e, 0x004 },
    { 0x005e, 0x0020, 0x007f, 0x008 },
    { 0x33d6, 0x4bf1, 0x7fc7, 0x000 },
    { 0x33d6, 0x4bf1, 0x7fc8, 0x008 },
    { 0xc789, 0x16f6, 0xde7f, 0x080 },
    { 0xc789, 0x16f6, 0xde80, 0x098 },
    { 0x0003, 0x0840, 0x0843, 0x000 },
    { 0x0003, 0x0840, 0x0844, 0x00c },
    { 0x17f5, 0x0a48, 0x223d, 0x000 },
    { 0x17f5, 0x0a48, 0x223e, 0x008 },
    { 0xfeec, 0x3ef7, 0x3de3, 0x011 },
    { 0xfeec, 0x3ef7, 0x3de4, 0x01d },
    { 0x0399, 0x02b6, 0x064f, 0x000 },
    { 0x0399, 0x02b6, 0x0650, 0x01c },
    { 0x7b91, 0xa70c, 0x229d, 0x001 },
    { 0x7b91, 0xa70c, 0x229e, 0x009 },
    { 0x4035, 0x949c, 0xd4d1, 0x094 },
    { 0x4035, 0x949c, 0xd4d2, 0x09c },
    { 0x0192, 0x011d, 0x02af, 0x004 },
    { 0x0192, 0x011d, 0x02b0, 0x018 },
    { 0xf0ea, 0xcc95, 0xbd7f, 0x081 },
    { 0xf0ea, 0xcc95, 0xbd80, 0x099 },
    { 0x5a41, 0x7853, 0xd294, 0x880 },
    { 0x5a41, 0x7853, 0xd295, 0x88c },
    { 0x0022, 0x084f, 0x0871, 0x014 },
    { 0x0022, 0x084f, 0x0872, 0x01c },
    { 0x4548, 0x81eb, 0xc733, 0x094 },
    { 0x4548, 0x81eb, 0xc734, 0x098 },
    /* r/m16, imm8: */
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0x0000, 0x0000, 0x0001, 0x008 },
    { 0xffff, 0xffff, 0xfffe, 0x091 },
    { 0xffff, 0xffff, 0xffff, 0x09d },
    { 0x0000, 0xffff, 0xffff, 0x084 },
    { 0x0000, 0xffff, 0x0000, 0x05d },
    { 0x003f, 0x0079, 0x00b8, 0x014 },
    { 0x003f, 0x0079, 0x00b9, 0x018 },
    { 0x5915, 0xfff7, 0x590c, 0x005 },
    { 0x5915, 0xfff7, 0x590d, 0x009 },
    { 0x2059, 0x0078, 0x20d1, 0x014 },
    { 0x2059, 0x0078, 0x20d2, 0x01c },
    { 0x0337, 0xfff9, 0x0330, 0x015 },
    { 0x0337, 0xfff9, 0x0331, 0x019 },
    { 0x952b, 0xffeb, 0x9516, 0x091 },
    { 0x952b, 0xffeb, 0x9517, 0x09d },
    { 0xfb6f, 0x007d, 0xfbec, 0x090 },
    { 0xfb6f, 0x007d, 0xfbed, 0x09c },
    { 0x0031, 0x002a, 0x005b, 0x000 },
    { 0x0031, 0x002a, 0x005c, 0x00c },
    { 0xdc27, 0x003f, 0xdc66, 0x094 },
    { 0xdc27, 0x003f, 0xdc67, 0x098 },
    { 0xc59c, 0x0064, 0xc600, 0x094 },
    { 0xc59c, 0x0064, 0xc601, 0x098 },
    { 0x01e5, 0x0016, 0x01fb, 0x000 },
    { 0x01e5, 0x0016, 0x01fc, 0x00c },
    { 0x83c6, 0xffae, 0x8374, 0x095 },
    { 0x83c6, 0xffae, 0x8375, 0x099 },
    { 0xa702, 0x000a, 0xa70c, 0x084 },
    { 0xa702, 0x000a, 0xa70d, 0x088 },
    { 0x0052, 0xffdb, 0x002d, 0x005 },
    { 0x0052, 0xffdb, 0x002e, 0x00d },
    { 0x7378, 0xff9d, 0x7315, 0x011 },
    { 0x7378, 0xff9d, 0x7316, 0x019 },
    { 0x2adc, 0x0000, 0x2adc, 0x000 },
    { 0x2adc, 0x0000, 0x2add, 0x00c },
    { 0x2286, 0xffea, 0x2270, 0x011 },
    { 0x2286, 0xffea, 0x2271, 0x01d },
    { 0xea30, 0x0026, 0xea56, 0x084 },
    { 0xea30, 0x0026, 0xea57, 0x088 },
    { 0xe78b, 0x0010, 0xe79b, 0x080 },
    { 0xe78b, 0x0010, 0xe79c, 0x08c },
    { 0x7ff9, 0x0038, 0x8031, 0x890 },
    { 0x7ff9, 0x0038, 0x8032, 0x898 },
    { 0xa2ab, 0xff84, 0xa22f, 0x081 },
    { 0xa2ab, 0xff84, 0xa230, 0x09d },
    { 0xd33b, 0xffd6, 0xd311, 0x095 },
    { 0xd33b, 0xffd6, 0xd312, 0x09d },
    { 0x0e70, 0x0014, 0x0e84, 0x004 },
    { 0x0e70, 0x0014, 0x0e85, 0x008 },
    { 0x2289, 0xffd4, 0x225d, 0x001 },
    { 0x2289, 0xffd4, 0x225e, 0x009 },
    { 0x9a46, 0xfff8, 0x9a3e, 0x081 },
    { 0x9a46, 0xfff8, 0x9a3f, 0x08d },
    { 0x015e, 0x0005, 0x0163, 0x014 },
    { 0x015e, 0x0005, 0x0164, 0x018 },
    { 0x562a, 0xffd2, 0x55fc, 0x005 },
    { 0x562a, 0xffd2, 0x55fd, 0x009 },
    { 0xbf81, 0x0026, 0xbfa7, 0x080 },
    { 0xbf81, 0x0026, 0xbfa8, 0x088 },
    { 0x000a, 0xffa4, 0xffae, 0x080 },
    { 0x000a, 0xffa4, 0xffaf, 0x08c },
    { 0x5d08, 0xfffb, 0x5d03, 0x015 },
    { 0x5d08, 0xfffb, 0x5d04, 0x019 },
};

const uint16_t g_cBs3CpuInstr2_adc_TestDataU32 = 144;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_adc_TestDataU32[144] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0x00000000, 0x00000000, 0x00000001, 0x008 },
    { 0xffffffff, 0xffffffff, 0xfffffffe, 0x091 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x09d },
    { 0x00000000, 0xffffffff, 0xffffffff, 0x084 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x05d },
    { 0x000009de, 0x00000017, 0x000009f5, 0x014 },
    { 0x000009de, 0x00000017, 0x000009f6, 0x01c },
    { 0x9eadc6e7, 0x62dd9840, 0x018b5f27, 0x005 },
    { 0x9eadc6e7, 0x62dd9840, 0x018b5f28, 0x00d },
    { 0x4236c475, 0x599bff49, 0x9bd2c3be, 0x884 },
    { 0x4236c475, 0x599bff49, 0x9bd2c3bf, 0x888 },
    { 0x00163a3b, 0x000b36ad, 0x002170e8, 0x014 },
    { 0x00163a3b, 0x000b36ad, 0x002170e9, 0x018 },
    { 0xd352a41f, 0xd69519f5, 0xa9e7be14, 0x095 },
    { 0xd352a41f, 0xd69519f5, 0xa9e7be15, 0x099 },
    { 0xd6db503b, 0x18707e09, 0xef4bce44, 0x094 },
    { 0xd6db503b, 0x18707e09, 0xef4bce45, 0x098 },
    { 0x00000506, 0x004a2a10, 0x004a2f16, 0x000 },
    { 0x00000506, 0x004a2a10, 0x004a2f17, 0x00c },
    { 0x860f8c62, 0x26c97909, 0xacd9056b, 0x080 },
    { 0x860f8c62, 0x26c97909, 0xacd9056c, 0x08c },
    { 0xf5297297, 0xb42232c5, 0xa94ba55c, 0x085 },
    { 0xf5297297, 0xb42232c5, 0xa94ba55d, 0x089 },
    { 0x003bf4fc, 0x002fcca3, 0x006bc19f, 0x004 },
    { 0x003bf4fc, 0x002fcca3, 0x006bc1a0, 0x01c },
    { 0x932405d8, 0xa1fbb1b9, 0x351fb791, 0x811 },
    { 0x932405d8, 0xa1fbb1b9, 0x351fb792, 0x819 },
    { 0xa9548fd3, 0xeeae7ad7, 0x98030aaa, 0x085 },
    { 0xa9548fd3, 0xeeae7ad7, 0x98030aab, 0x089 },
    { 0x0000086e, 0x1928d82e, 0x1928e09c, 0x014 },
    { 0x0000086e, 0x1928d82e, 0x1928e09d, 0x018 },
    { 0xc888c0e9, 0xca312633, 0x92b9e71c, 0x081 },
    { 0xc888c0e9, 0xca312633, 0x92b9e71d, 0x08d },
    { 0x60c2e37f, 0x1ae5b7a6, 0x7ba89b25, 0x010 },
    { 0x60c2e37f, 0x1ae5b7a6, 0x7ba89b26, 0x018 },
    { 0x00165825, 0x001a91ec, 0x0030ea11, 0x014 },
    { 0x00165825, 0x001a91ec, 0x0030ea12, 0x01c },
    { 0x8e22441d, 0xaba5f3fe, 0x39c8381b, 0x815 },
    { 0x8e22441d, 0xaba5f3fe, 0x39c8381c, 0x819 },
    { 0x9c35bf15, 0x4c940a2b, 0xe8c9c940, 0x090 },
    { 0x9c35bf15, 0x4c940a2b, 0xe8c9c941, 0x09c },
    { 0x0000030c, 0x00000631, 0x0000093d, 0x000 },
    { 0x0000030c, 0x00000631, 0x0000093e, 0x008 },
    { 0x9b606ef1, 0xd8139e41, 0x73740d32, 0x801 },
    { 0x9b606ef1, 0xd8139e41, 0x73740d33, 0x80d },
    { 0x423e9254, 0x99f8eac6, 0xdc377d1a, 0x080 },
    { 0x423e9254, 0x99f8eac6, 0xdc377d1b, 0x08c },
    { 0x000075dc, 0x01bf5351, 0x01bfc92d, 0x004 },
    { 0x000075dc, 0x01bf5351, 0x01bfc92e, 0x00c },
    { 0x35f715cb, 0x70b7de1a, 0xa6aef3e5, 0x890 },
    { 0x35f715cb, 0x70b7de1a, 0xa6aef3e6, 0x898 },
    { 0x7756b6c6, 0x5df99d8c, 0xd5505452, 0x890 },
    { 0x7756b6c6, 0x5df99d8c, 0xd5505453, 0x89c },
    { 0x04a8679e, 0x00006a2d, 0x04a8d1cb, 0x010 },
    { 0x04a8679e, 0x00006a2d, 0x04a8d1cc, 0x01c },
    { 0xd0255552, 0xc30482c6, 0x9329d818, 0x085 },
    { 0xd0255552, 0xc30482c6, 0x9329d819, 0x089 },
    { 0xdd2596b6, 0xcec995ad, 0xabef2c63, 0x095 },
    { 0xdd2596b6, 0xcec995ad, 0xabef2c64, 0x099 },
    { 0x00000c68, 0x000004a9, 0x00001111, 0x014 },
    { 0x00000c68, 0x000004a9, 0x00001112, 0x01c },
    { 0x7e5a82bc, 0x683d249f, 0xe697a75b, 0x890 },
    { 0x7e5a82bc, 0x683d249f, 0xe697a75c, 0x89c },
    { 0x8e107d03, 0xdc7f77ff, 0x6a8ff502, 0x811 },
    { 0x8e107d03, 0xdc7f77ff, 0x6a8ff503, 0x81d },
    { 0x00015e4a, 0x10e6b52a, 0x10e81374, 0x014 },
    { 0x00015e4a, 0x10e6b52a, 0x10e81375, 0x018 },
    { 0x9a8001e4, 0x89fc4e27, 0x247c500b, 0x801 },
    { 0x9a8001e4, 0x89fc4e27, 0x247c500c, 0x80d },
    { 0x936ee790, 0xd624a8e7, 0x69939077, 0x805 },
    { 0x936ee790, 0xd624a8e7, 0x69939078, 0x80d },
    /* r/m32, imm8: */
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0x00000000, 0x00000000, 0x00000001, 0x008 },
    { 0xffffffff, 0xffffffff, 0xfffffffe, 0x091 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x09d },
    { 0x00000000, 0xffffffff, 0xffffffff, 0x084 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x05d },
    { 0x13361989, 0x00000039, 0x133619c2, 0x010 },
    { 0x13361989, 0x00000039, 0x133619c3, 0x01c },
    { 0xc2c3fe75, 0xffffff91, 0xc2c3fe06, 0x085 },
    { 0xc2c3fe75, 0xffffff91, 0xc2c3fe07, 0x089 },
    { 0x10bf4c5f, 0x00000063, 0x10bf4cc2, 0x010 },
    { 0x10bf4c5f, 0x00000063, 0x10bf4cc3, 0x01c },
    { 0x0063e857, 0x0000005f, 0x0063e8b6, 0x010 },
    { 0x0063e857, 0x0000005f, 0x0063e8b7, 0x01c },
    { 0x05f0aecf, 0x00000051, 0x05f0af20, 0x010 },
    { 0x05f0aecf, 0x00000051, 0x05f0af21, 0x01c },
    { 0x0949211e, 0x00000028, 0x09492146, 0x010 },
    { 0x0949211e, 0x00000028, 0x09492147, 0x01c },
    { 0x010f3cc8, 0x0000004d, 0x010f3d15, 0x010 },
    { 0x010f3cc8, 0x0000004d, 0x010f3d16, 0x018 },
    { 0x739893e3, 0x0000005f, 0x73989442, 0x014 },
    { 0x739893e3, 0x0000005f, 0x73989443, 0x018 },
    { 0xc31b3181, 0xffffff92, 0xc31b3113, 0x081 },
    { 0xc31b3181, 0xffffff92, 0xc31b3114, 0x08d },
    { 0x000352f9, 0x0000006d, 0x00035366, 0x014 },
    { 0x000352f9, 0x0000006d, 0x00035367, 0x018 },
    { 0xe5a3dd6c, 0xffffff95, 0xe5a3dd01, 0x091 },
    { 0xe5a3dd6c, 0xffffff95, 0xe5a3dd02, 0x099 },
    { 0x7514831d, 0x00000024, 0x75148341, 0x014 },
    { 0x7514831d, 0x00000024, 0x75148342, 0x01c },
    { 0x00002cec, 0x00000038, 0x00002d24, 0x014 },
    { 0x00002cec, 0x00000038, 0x00002d25, 0x018 },
    { 0xc6f8d355, 0x00000006, 0xc6f8d35b, 0x080 },
    { 0xc6f8d355, 0x00000006, 0xc6f8d35c, 0x08c },
    { 0x6a18faa6, 0xffffffb5, 0x6a18fa5b, 0x001 },
    { 0x6a18faa6, 0xffffffb5, 0x6a18fa5c, 0x00d },
    { 0x0000f9ae, 0x00000037, 0x0000f9e5, 0x010 },
    { 0x0000f9ae, 0x00000037, 0x0000f9e6, 0x018 },
    { 0x46286d20, 0x00000008, 0x46286d28, 0x004 },
    { 0x46286d20, 0x00000008, 0x46286d29, 0x008 },
    { 0xae575730, 0x00000014, 0xae575744, 0x084 },
    { 0xae575730, 0x00000014, 0xae575745, 0x088 },
    { 0x2cf12886, 0x0000004a, 0x2cf128d0, 0x010 },
    { 0x2cf12886, 0x0000004a, 0x2cf128d1, 0x01c },
    { 0x808dfc91, 0xffffffdf, 0x808dfc70, 0x091 },
    { 0x808dfc91, 0xffffffdf, 0x808dfc71, 0x09d },
    { 0xe22c4bb6, 0x00000014, 0xe22c4bca, 0x084 },
    { 0xe22c4bb6, 0x00000014, 0xe22c4bcb, 0x088 },
    { 0x00000df5, 0x00000022, 0x00000e17, 0x004 },
    { 0x00000df5, 0x00000022, 0x00000e18, 0x00c },
    { 0x5fe33066, 0xffffffb8, 0x5fe3301e, 0x005 },
    { 0x5fe33066, 0xffffffb8, 0x5fe3301f, 0x009 },
    { 0xdfb88e0f, 0x0000000e, 0xdfb88e1d, 0x094 },
    { 0xdfb88e0f, 0x0000000e, 0xdfb88e1e, 0x09c },
    { 0x00006df3, 0xffffffd1, 0x00006dc4, 0x001 },
    { 0x00006df3, 0xffffffd1, 0x00006dc5, 0x00d },
    { 0x470a3a36, 0xffffffa9, 0x470a39df, 0x001 },
    { 0x470a3a36, 0xffffffa9, 0x470a39e0, 0x019 },
    { 0xc44d35ec, 0xfffffffc, 0xc44d35e8, 0x095 },
    { 0xc44d35ec, 0xfffffffc, 0xc44d35e9, 0x099 },
    { 0x04fd301c, 0xffffffd3, 0x04fd2fef, 0x001 },
    { 0x04fd301c, 0xffffffd3, 0x04fd2ff0, 0x01d },
    { 0xc750a1f8, 0xffffff88, 0xc750a180, 0x091 },
    { 0xc750a1f8, 0xffffff88, 0xc750a181, 0x09d },
    { 0x0de0fce4, 0xffffffda, 0x0de0fcbe, 0x005 },
    { 0x0de0fce4, 0xffffffda, 0x0de0fcbf, 0x009 },
    { 0x07183556, 0x00000027, 0x0718357d, 0x004 },
    { 0x07183556, 0x00000027, 0x0718357e, 0x00c },
    { 0xcf81afb6, 0xffffff81, 0xcf81af37, 0x081 },
    { 0xcf81afb6, 0xffffff81, 0xcf81af38, 0x089 },
    { 0x877eedbb, 0xffffffd5, 0x877eed90, 0x095 },
    { 0x877eedbb, 0xffffffd5, 0x877eed91, 0x099 },
};

const uint16_t g_cBs3CpuInstr2_sub_TestDataU8 = 32;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_sub_TestDataU8[32] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0xff, 0xff, 0x00, 0x044 },
    { 0x00, 0xff, 0x01, 0x011 },
    { 0x6b, 0x66, 0x05, 0x004 },
    { 0x99, 0x97, 0x02, 0x000 },
    { 0xdb, 0x3f, 0x9c, 0x094 },
    { 0xee, 0x66, 0x88, 0x084 },
    { 0x23, 0xca, 0x59, 0x015 },
    { 0x2a, 0x71, 0xb9, 0x081 },
    { 0x7c, 0x8d, 0xef, 0x891 },
    { 0xd2, 0x11, 0xc1, 0x080 },
    { 0x1e, 0x55, 0xc9, 0x085 },
    { 0x52, 0x88, 0xca, 0x895 },
    { 0x94, 0x21, 0x73, 0x800 },
    { 0x9b, 0x27, 0x74, 0x804 },
    { 0x7a, 0x85, 0xf5, 0x885 },
    { 0x37, 0x40, 0xf7, 0x081 },
    { 0xff, 0xfb, 0x04, 0x000 },
    { 0x2e, 0x81, 0xad, 0x881 },
    { 0xfe, 0xab, 0x53, 0x004 },
    { 0x24, 0x7f, 0xa5, 0x095 },
    { 0xea, 0x73, 0x77, 0x804 },
    { 0x56, 0x31, 0x25, 0x000 },
    { 0xb2, 0x81, 0x31, 0x000 },
    { 0xee, 0xd6, 0x18, 0x004 },
    { 0x7c, 0x9f, 0xdd, 0x895 },
    { 0x62, 0x11, 0x51, 0x000 },
    { 0xf4, 0xec, 0x08, 0x010 },
    { 0xeb, 0x18, 0xd3, 0x080 },
    { 0x37, 0xff, 0x38, 0x011 },
    { 0x49, 0x8a, 0xbf, 0x891 },
    { 0x4d, 0x57, 0xf6, 0x085 },
};

const uint16_t g_cBs3CpuInstr2_sub_TestDataU16 = 64;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_sub_TestDataU16[64] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0x0000, 0x044 },
    { 0x0000, 0xffff, 0x0001, 0x011 },
    { 0x1ba6, 0x0000, 0x1ba6, 0x004 },
    { 0x3629, 0xfdec, 0x383d, 0x011 },
    { 0xb8d6, 0x2a65, 0x8e71, 0x084 },
    { 0x0010, 0x2206, 0xde0a, 0x095 },
    { 0xb777, 0x1179, 0xa5fe, 0x090 },
    { 0x3629, 0xebc8, 0x4a61, 0x001 },
    { 0x00cf, 0x013c, 0xff93, 0x085 },
    { 0x4c58, 0x64d7, 0xe781, 0x085 },
    { 0x98be, 0x0a0f, 0x8eaf, 0x094 },
    { 0x0749, 0x0029, 0x0720, 0x000 },
    { 0x4218, 0x38e3, 0x0935, 0x004 },
    { 0xdcec, 0x22e1, 0xba0b, 0x080 },
    { 0x15e8, 0x0066, 0x1582, 0x004 },
    { 0x9aee, 0x95af, 0x053f, 0x014 },
    { 0x27dd, 0x2e57, 0xf986, 0x081 },
    { 0x00e7, 0x001e, 0x00c9, 0x014 },
    { 0x07b5, 0x04e3, 0x02d2, 0x004 },
    { 0xe6e6, 0x12a6, 0xd440, 0x080 },
    { 0x97d9, 0x4fcb, 0x480e, 0x810 },
    { 0x9a4d, 0x4528, 0x5525, 0x800 },
    { 0x827d, 0x0bcf, 0x76ae, 0x810 },
    { 0x1830, 0x2f6e, 0xe8c2, 0x091 },
    { 0x2f9e, 0x5603, 0xd99b, 0x081 },
    { 0xfc5d, 0x6852, 0x940b, 0x080 },
    { 0x7900, 0x0135, 0x77cb, 0x010 },
    { 0xc5ec, 0x0cb4, 0xb938, 0x080 },
    { 0x00a6, 0xa769, 0x593d, 0x011 },
    { 0x0002, 0x05ad, 0xfa55, 0x095 },
    { 0x5a6c, 0x9de3, 0xbc89, 0x881 },
    /* r/m16, imm8: */
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0x0000, 0x044 },
    { 0x0000, 0xffff, 0x0001, 0x011 },
    { 0x1851, 0x0023, 0x182e, 0x014 },
    { 0x35fc, 0x0065, 0x3597, 0x000 },
    { 0xe56f, 0xfff8, 0xe577, 0x085 },
    { 0x1971, 0xffe7, 0x198a, 0x011 },
    { 0x5a7e, 0xffb8, 0x5ac6, 0x005 },
    { 0x443e, 0xffbb, 0x4483, 0x001 },
    { 0x063b, 0x0063, 0x05d8, 0x004 },
    { 0xc8d1, 0x0031, 0xc8a0, 0x084 },
    { 0x816b, 0xffb3, 0x81b8, 0x085 },
    { 0x0004, 0x0001, 0x0003, 0x004 },
    { 0xf1c5, 0xff96, 0xf22f, 0x091 },
    { 0x1234, 0xffeb, 0x1249, 0x011 },
    { 0x0e89, 0xffdf, 0x0eaa, 0x015 },
    { 0x792b, 0xffb9, 0x7972, 0x005 },
    { 0x95b0, 0xffd8, 0x95d8, 0x095 },
    { 0x0019, 0xfff2, 0x0027, 0x005 },
    { 0x50b9, 0x0059, 0x5060, 0x004 },
    { 0x46d2, 0xffdb, 0x46f7, 0x011 },
    { 0x8037, 0x0072, 0x7fc5, 0x804 },
    { 0x6035, 0xffd0, 0x6065, 0x005 },
    { 0x3373, 0xffe3, 0x3390, 0x005 },
    { 0x0c42, 0xffc7, 0x0c7b, 0x015 },
    { 0xf509, 0x003d, 0xf4cc, 0x094 },
    { 0xcd5a, 0xffd1, 0xcd89, 0x081 },
    { 0x3a38, 0x0024, 0x3a14, 0x004 },
    { 0xeafd, 0xff80, 0xeb7d, 0x085 },
    { 0x9df2, 0xffb1, 0x9e41, 0x085 },
    { 0x05a9, 0x0042, 0x0567, 0x000 },
    { 0xdfe8, 0x0025, 0xdfc3, 0x084 },
};

const uint16_t g_cBs3CpuInstr2_sub_TestDataU32 = 72;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_sub_TestDataU32[72] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0x00000000, 0x044 },
    { 0x00000000, 0xffffffff, 0x00000001, 0x011 },
    { 0x000f1c61, 0x0b31b0b7, 0xf4dd6baa, 0x095 },
    { 0xcb48f55c, 0xa2e470cd, 0x2864848f, 0x010 },
    { 0x83a9d574, 0x82fcb48d, 0x00ad20e7, 0x014 },
    { 0x0010812c, 0x00007691, 0x00100a9b, 0x000 },
    { 0x2df8e38a, 0xef22909a, 0x3ed652f0, 0x005 },
    { 0x464386a3, 0x7b3c3a8b, 0xcb074c18, 0x095 },
    { 0x00002fd4, 0x001918aa, 0xffe7172a, 0x091 },
    { 0xf1227378, 0x4ccae47b, 0xa4578efd, 0x090 },
    { 0x1c5e6ea0, 0x3bb0d8ec, 0xe0ad95b4, 0x095 },
    { 0x002ecde9, 0x04c5bcd7, 0xfb691112, 0x085 },
    { 0x71f0da1d, 0xbb7fbf88, 0xb6711a95, 0x885 },
    { 0xfff7983c, 0x582babf3, 0xa7cbec49, 0x080 },
    { 0x00000766, 0x000093d5, 0xffff7391, 0x081 },
    { 0x807b9d1e, 0x2d1bf7c5, 0x535fa559, 0x804 },
    { 0x8727bda6, 0x8213e0f5, 0x0513dcb1, 0x004 },
    { 0x032d5c6d, 0x1355dc84, 0xefd77fe9, 0x081 },
    { 0x0a009944, 0x2d4e447d, 0xdcb254c7, 0x091 },
    { 0x2d7281c7, 0x78a667f3, 0xb4cc19d4, 0x085 },
    { 0x0135a485, 0x00017fbe, 0x013424c7, 0x010 },
    { 0x2a99c24b, 0xd4a3009a, 0x55f6c1b1, 0x005 },
    { 0x597c890b, 0xbf095f12, 0x9a7329f9, 0x885 },
    { 0x011e5dfe, 0x03d8775c, 0xfd45e6a2, 0x081 },
    { 0x0884746f, 0x6ff827c7, 0x988c4ca8, 0x081 },
    { 0x0cfb926b, 0x1849d649, 0xf4b1bc22, 0x085 },
    { 0x00000623, 0x000003cb, 0x00000258, 0x010 },
    { 0x1296a8ff, 0xa13106e1, 0x7165a21e, 0x005 },
    { 0x99bacfa0, 0x77953f65, 0x2225903b, 0x810 },
    { 0x00000098, 0x000007b5, 0xfffff8e3, 0x081 },
    { 0x6026208b, 0x6722962a, 0xf9038a61, 0x081 },
    { 0x0fb0b378, 0x99d6b427, 0x75d9ff51, 0x001 },
    { 0x005ba18f, 0x0472be2c, 0xfbe8e363, 0x085 },
    { 0x15bbbb7f, 0xd81299fe, 0x3da92181, 0x005 },
    { 0x2d3c1fde, 0x86503f05, 0xa6ebe0d9, 0x881 },
    /* r/m32, imm8: */
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0x00000000, 0x044 },
    { 0x00000000, 0xffffffff, 0x00000001, 0x011 },
    { 0x00002c1f, 0x0000002e, 0x00002bf1, 0x000 },
    { 0x9ce76388, 0xffffff8b, 0x9ce763fd, 0x091 },
    { 0x99decfa2, 0xffffffc6, 0x99decfdc, 0x091 },
    { 0x0000e9f4, 0x00000045, 0x0000e9af, 0x014 },
    { 0x5f7584b5, 0x00000009, 0x5f7584ac, 0x014 },
    { 0x098f656a, 0xffffffe0, 0x098f658a, 0x001 },
    { 0x00000942, 0x0000001b, 0x00000927, 0x014 },
    { 0x54cb060f, 0x00000073, 0x54cb059c, 0x004 },
    { 0x95c647e2, 0xffffff99, 0x95c64849, 0x091 },
    { 0x0020bb5d, 0x00000019, 0x0020bb44, 0x004 },
    { 0x21eeda13, 0xffffffcc, 0x21eeda47, 0x015 },
    { 0x0f9c401a, 0xfffffff7, 0x0f9c4023, 0x001 },
    { 0x00000095, 0xffffffbe, 0x000000d7, 0x015 },
    { 0x94763573, 0x00000077, 0x947634fc, 0x094 },
    { 0xd9236da0, 0x00000044, 0xd9236d5c, 0x094 },
    { 0x00001171, 0x00000069, 0x00001108, 0x010 },
    { 0xa05fa117, 0xffffff9b, 0xa05fa17c, 0x091 },
    { 0x8201ff93, 0xffffffc0, 0x8201ffd3, 0x081 },
    { 0x00001f47, 0x00000006, 0x00001f41, 0x004 },
    { 0x0d0390d2, 0xffffffaa, 0x0d039128, 0x015 },
    { 0x806d23c0, 0x0000004b, 0x806d2375, 0x090 },
    { 0x00069b99, 0x00000027, 0x00069b72, 0x004 },
    { 0x5cf6045d, 0xffffff85, 0x5cf604d8, 0x005 },
    { 0x7a2466bd, 0xfffffff0, 0x7a2466cd, 0x001 },
    { 0x0001a43e, 0xffffffa4, 0x0001a49a, 0x005 },
    { 0x2b2d0e9a, 0xffffff9b, 0x2b2d0eff, 0x015 },
    { 0x35238803, 0x00000036, 0x352387cd, 0x010 },
    { 0x0000351b, 0x0000006a, 0x000034b1, 0x004 },
    { 0x9327ba90, 0xffffff96, 0x9327bafa, 0x095 },
    { 0x47fb6598, 0x00000013, 0x47fb6585, 0x000 },
    { 0x000114a9, 0x0000004d, 0x0001145c, 0x014 },
    { 0x7bbac298, 0xffffffca, 0x7bbac2ce, 0x011 },
    { 0xfdd2f129, 0x00000074, 0xfdd2f0b5, 0x080 },
};

const uint16_t g_cBs3CpuInstr2_sbb_TestDataU8 = 64;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_sbb_TestDataU8[64] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0x00, 0x00, 0xff, 0x09d },
    { 0xff, 0xff, 0x00, 0x044 },
    { 0xff, 0xff, 0xff, 0x09d },
    { 0x00, 0xff, 0x01, 0x011 },
    { 0x00, 0xff, 0x00, 0x05d },
    { 0xe1, 0xb1, 0x30, 0x004 },
    { 0xe1, 0xb1, 0x2f, 0x018 },
    { 0x29, 0x52, 0xd7, 0x085 },
    { 0x29, 0x52, 0xd6, 0x089 },
    { 0x58, 0x21, 0x37, 0x000 },
    { 0x58, 0x21, 0x36, 0x00c },
    { 0xec, 0x0c, 0xe0, 0x080 },
    { 0xec, 0x0c, 0xdf, 0x098 },
    { 0xe2, 0x9f, 0x43, 0x010 },
    { 0xe2, 0x9f, 0x42, 0x01c },
    { 0x73, 0x5a, 0x19, 0x010 },
    { 0x73, 0x5a, 0x18, 0x01c },
    { 0xea, 0x05, 0xe5, 0x080 },
    { 0xea, 0x05, 0xe4, 0x08c },
    { 0x23, 0xbc, 0x67, 0x011 },
    { 0x23, 0xbc, 0x66, 0x01d },
    { 0x71, 0x72, 0xff, 0x095 },
    { 0x71, 0x72, 0xfe, 0x099 },
    { 0xf5, 0x43, 0xb2, 0x084 },
    { 0xf5, 0x43, 0xb1, 0x08c },
    { 0xc5, 0x32, 0x93, 0x084 },
    { 0xc5, 0x32, 0x92, 0x088 },
    { 0xb4, 0x14, 0xa0, 0x084 },
    { 0xb4, 0x14, 0x9f, 0x09c },
    { 0x11, 0x05, 0x0c, 0x014 },
    { 0x11, 0x05, 0x0b, 0x018 },
    { 0xe0, 0x31, 0xaf, 0x094 },
    { 0xe0, 0x31, 0xae, 0x098 },
    { 0x0f, 0xd3, 0x3c, 0x005 },
    { 0x0f, 0xd3, 0x3b, 0x009 },
    { 0x04, 0x94, 0x70, 0x001 },
    { 0x04, 0x94, 0x6f, 0x01d },
    { 0x00, 0x93, 0x6d, 0x011 },
    { 0x00, 0x93, 0x6c, 0x01d },
    { 0x17, 0xce, 0x49, 0x011 },
    { 0x17, 0xce, 0x48, 0x01d },
    { 0x5f, 0x84, 0xdb, 0x885 },
    { 0x5f, 0x84, 0xda, 0x889 },
    { 0x57, 0xd7, 0x80, 0x881 },
    { 0x57, 0xd7, 0x7f, 0x019 },
    { 0x18, 0x23, 0xf5, 0x085 },
    { 0x18, 0x23, 0xf4, 0x089 },
    { 0xbb, 0x19, 0xa2, 0x080 },
    { 0xbb, 0x19, 0xa1, 0x088 },
    { 0xb2, 0x15, 0x9d, 0x090 },
    { 0xb2, 0x15, 0x9c, 0x09c },
    { 0x41, 0x4c, 0xf5, 0x095 },
    { 0x41, 0x4c, 0xf4, 0x099 },
    { 0xcf, 0x17, 0xb8, 0x084 },
    { 0xcf, 0x17, 0xb7, 0x08c },
    { 0x54, 0x5b, 0xf9, 0x095 },
    { 0x54, 0x5b, 0xf8, 0x099 },
    { 0x64, 0x5c, 0x08, 0x010 },
    { 0x64, 0x5c, 0x07, 0x018 },
    { 0x7b, 0x8a, 0xf1, 0x881 },
    { 0x7b, 0x8a, 0xf0, 0x88d },
    { 0x66, 0x1c, 0x4a, 0x010 },
    { 0x66, 0x1c, 0x49, 0x018 },
};

const uint16_t g_cBs3CpuInstr2_sbb_TestDataU16 = 128;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_sbb_TestDataU16[128] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0x0000, 0x0000, 0xffff, 0x09d },
    { 0xffff, 0xffff, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x09d },
    { 0x0000, 0xffff, 0x0001, 0x011 },
    { 0x0000, 0xffff, 0x0000, 0x05d },
    { 0x009d, 0x001e, 0x007f, 0x010 },
    { 0x009d, 0x001e, 0x007e, 0x01c },
    { 0x30dd, 0x3523, 0xfbba, 0x081 },
    { 0x30dd, 0x3523, 0xfbb9, 0x089 },
    { 0xbc3a, 0xa35d, 0x18dd, 0x014 },
    { 0xbc3a, 0xa35d, 0x18dc, 0x018 },
    { 0x0075, 0x07cc, 0xf8a9, 0x095 },
    { 0x0075, 0x07cc, 0xf8a8, 0x099 },
    { 0x2537, 0x5113, 0xd424, 0x085 },
    { 0x2537, 0x5113, 0xd423, 0x089 },
    { 0xe8d0, 0xd18d, 0x1743, 0x010 },
    { 0xe8d0, 0xd18d, 0x1742, 0x01c },
    { 0x0007, 0x0039, 0xffce, 0x091 },
    { 0x0007, 0x0039, 0xffcd, 0x099 },
    { 0xd68d, 0xf452, 0xe23b, 0x081 },
    { 0xd68d, 0xf452, 0xe23a, 0x08d },
    { 0x6a86, 0x8674, 0xe412, 0x885 },
    { 0x6a86, 0x8674, 0xe411, 0x88d },
    { 0x0259, 0x0068, 0x01f1, 0x000 },
    { 0x0259, 0x0068, 0x01f0, 0x00c },
    { 0xcd4d, 0xa3fc, 0x2951, 0x000 },
    { 0xcd4d, 0xa3fc, 0x2950, 0x00c },
    { 0x3387, 0xef72, 0x4415, 0x001 },
    { 0x3387, 0xef72, 0x4414, 0x00d },
    { 0x0063, 0x0014, 0x004f, 0x010 },
    { 0x0063, 0x0014, 0x004e, 0x01c },
    { 0x2afa, 0xa102, 0x89f8, 0x881 },
    { 0x2afa, 0xa102, 0x89f7, 0x889 },
    { 0xa352, 0x7d8d, 0x25c5, 0x814 },
    { 0xa352, 0x7d8d, 0x25c4, 0x818 },
    { 0x00cb, 0x0076, 0x0055, 0x004 },
    { 0x00cb, 0x0076, 0x0054, 0x008 },
    { 0x636d, 0x8d54, 0xd619, 0x881 },
    { 0x636d, 0x8d54, 0xd618, 0x88d },
    { 0xa0cb, 0x9f6c, 0x015f, 0x014 },
    { 0xa0cb, 0x9f6c, 0x015e, 0x018 },
    { 0x0018, 0x0a2d, 0xf5eb, 0x095 },
    { 0x0018, 0x0a2d, 0xf5ea, 0x099 },
    { 0xcaa1, 0x4103, 0x899e, 0x090 },
    { 0xcaa1, 0x4103, 0x899d, 0x098 },
    { 0x4dde, 0x52fa, 0xfae4, 0x085 },
    { 0x4dde, 0x52fa, 0xfae3, 0x089 },
    { 0x0004, 0x00fe, 0xff06, 0x095 },
    { 0x0004, 0x00fe, 0xff05, 0x09d },
    { 0xce8b, 0x3ef2, 0x8f99, 0x084 },
    { 0xce8b, 0x3ef2, 0x8f98, 0x088 },
    { 0x8250, 0x7354, 0x0efc, 0x814 },
    { 0x8250, 0x7354, 0x0efb, 0x818 },
    { 0x003d, 0x02c9, 0xfd74, 0x085 },
    { 0x003d, 0x02c9, 0xfd73, 0x089 },
    { 0xd8d4, 0x83de, 0x54f6, 0x014 },
    { 0xd8d4, 0x83de, 0x54f5, 0x01c },
    { 0x8dc4, 0x615f, 0x2c65, 0x814 },
    { 0x8dc4, 0x615f, 0x2c64, 0x818 },
    { 0x137c, 0x0f78, 0x0404, 0x000 },
    { 0x137c, 0x0f78, 0x0403, 0x00c },
    { 0x5a98, 0xb3fb, 0xa69d, 0x891 },
    { 0x5a98, 0xb3fb, 0xa69c, 0x89d },
    /* r/m16, imm8: */
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0x0000, 0x0000, 0xffff, 0x09d },
    { 0xffff, 0xffff, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x09d },
    { 0x0000, 0xffff, 0x0001, 0x011 },
    { 0x0000, 0xffff, 0x0000, 0x05d },
    { 0x0007, 0x0041, 0xffc6, 0x085 },
    { 0x0007, 0x0041, 0xffc5, 0x08d },
    { 0x9580, 0x0025, 0x955b, 0x090 },
    { 0x9580, 0x0025, 0x955a, 0x09c },
    { 0x25c7, 0x001c, 0x25ab, 0x010 },
    { 0x25c7, 0x001c, 0x25aa, 0x01c },
    { 0x006c, 0x0014, 0x0058, 0x000 },
    { 0x006c, 0x0014, 0x0057, 0x008 },
    { 0xc907, 0x0062, 0xc8a5, 0x084 },
    { 0xc907, 0x0062, 0xc8a4, 0x088 },
    { 0xcd51, 0x0052, 0xccff, 0x094 },
    { 0xcd51, 0x0052, 0xccfe, 0x098 },
    { 0x365a, 0x007f, 0x35db, 0x014 },
    { 0x365a, 0x007f, 0x35da, 0x018 },
    { 0xb4da, 0x006a, 0xb470, 0x080 },
    { 0xb4da, 0x006a, 0xb46f, 0x09c },
    { 0x2a57, 0xff9a, 0x2abd, 0x015 },
    { 0x2a57, 0xff9a, 0x2abc, 0x019 },
    { 0x000f, 0xffed, 0x0022, 0x005 },
    { 0x000f, 0xffed, 0x0021, 0x00d },
    { 0xf24f, 0x000d, 0xf242, 0x084 },
    { 0xf24f, 0x000d, 0xf241, 0x08c },
    { 0xdc4b, 0x000f, 0xdc3c, 0x094 },
    { 0xdc4b, 0x000f, 0xdc3b, 0x098 },
    { 0x0003, 0xffdd, 0x0026, 0x011 },
    { 0x0003, 0xffdd, 0x0025, 0x019 },
    { 0xccbf, 0xff85, 0xcd3a, 0x085 },
    { 0xccbf, 0xff85, 0xcd39, 0x08d },
    { 0xdd6d, 0xffc8, 0xdda5, 0x085 },
    { 0xdd6d, 0xffc8, 0xdda4, 0x089 },
    { 0x01d0, 0x001f, 0x01b1, 0x014 },
    { 0x01d0, 0x001f, 0x01b0, 0x018 },
    { 0x993d, 0x002f, 0x990e, 0x090 },
    { 0x993d, 0x002f, 0x990d, 0x098 },
    { 0x2e65, 0x000f, 0x2e56, 0x014 },
    { 0x2e65, 0x000f, 0x2e55, 0x01c },
    { 0x8004, 0x0043, 0x7fc1, 0x800 },
    { 0x8004, 0x0043, 0x7fc0, 0x80c },
    { 0x4a23, 0x0023, 0x4a00, 0x004 },
    { 0x4a23, 0x0023, 0x49ff, 0x01c },
    { 0x7fcf, 0xff95, 0x803a, 0x885 },
    { 0x7fcf, 0xff95, 0x8039, 0x88d },
    { 0x0015, 0xfffc, 0x0019, 0x011 },
    { 0x0015, 0xfffc, 0x0018, 0x01d },
    { 0xc03f, 0xffcf, 0xc070, 0x081 },
    { 0xc03f, 0xffcf, 0xc06f, 0x09d },
    { 0xe495, 0xff84, 0xe511, 0x085 },
    { 0xe495, 0xff84, 0xe510, 0x089 },
    { 0x00c2, 0xfffa, 0x00c8, 0x011 },
    { 0x00c2, 0xfffa, 0x00c7, 0x019 },
    { 0xaead, 0xffcc, 0xaee1, 0x085 },
    { 0xaead, 0xffcc, 0xaee0, 0x089 },
    { 0xfc4d, 0xfffa, 0xfc53, 0x085 },
    { 0xfc4d, 0xfffa, 0xfc52, 0x089 },
    { 0x0026, 0xffba, 0x006c, 0x015 },
    { 0x0026, 0xffba, 0x006b, 0x019 },
    { 0x4847, 0x0035, 0x4812, 0x004 },
    { 0x4847, 0x0035, 0x4811, 0x00c },
};

const uint16_t g_cBs3CpuInstr2_sbb_TestDataU32 = 144;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_sbb_TestDataU32[144] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0x00000000, 0x00000000, 0xffffffff, 0x09d },
    { 0xffffffff, 0xffffffff, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x09d },
    { 0x00000000, 0xffffffff, 0x00000001, 0x011 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x05d },
    { 0x000241e6, 0x00175d4b, 0xffeae49b, 0x091 },
    { 0x000241e6, 0x00175d4b, 0xffeae49a, 0x09d },
    { 0xc38e0881, 0x32f0ef9a, 0x909d18e7, 0x094 },
    { 0xc38e0881, 0x32f0ef9a, 0x909d18e6, 0x098 },
    { 0xe8028196, 0xfc89d432, 0xeb78ad64, 0x081 },
    { 0xe8028196, 0xfc89d432, 0xeb78ad63, 0x08d },
    { 0x0201c160, 0x0003c316, 0x01fdfe4a, 0x010 },
    { 0x0201c160, 0x0003c316, 0x01fdfe49, 0x018 },
    { 0x6c99176d, 0xf6d12cce, 0x75c7ea9f, 0x015 },
    { 0x6c99176d, 0xf6d12cce, 0x75c7ea9e, 0x019 },
    { 0x5ed4a47f, 0x9a7bbe7c, 0xc458e603, 0x885 },
    { 0x5ed4a47f, 0x9a7bbe7c, 0xc458e602, 0x889 },
    { 0x00055318, 0x00671e3d, 0xff9e34db, 0x095 },
    { 0x00055318, 0x00671e3d, 0xff9e34da, 0x099 },
    { 0x3df24141, 0x2b9a5300, 0x1257ee41, 0x004 },
    { 0x3df24141, 0x2b9a5300, 0x1257ee40, 0x008 },
    { 0xa0bf3b5d, 0xaad26776, 0xf5ecd3e7, 0x085 },
    { 0xa0bf3b5d, 0xaad26776, 0xf5ecd3e6, 0x089 },
    { 0x000007fa, 0x16caefea, 0xe9351810, 0x081 },
    { 0x000007fa, 0x16caefea, 0xe935180f, 0x09d },
    { 0x054d2894, 0xa53f3fd7, 0x600de8bd, 0x015 },
    { 0x054d2894, 0xa53f3fd7, 0x600de8bc, 0x019 },
    { 0x1b784f5b, 0xb7a20e47, 0x63d64114, 0x005 },
    { 0x1b784f5b, 0xb7a20e47, 0x63d64113, 0x009 },
    { 0x0000052d, 0x00f8ca90, 0xff073a9d, 0x081 },
    { 0x0000052d, 0x00f8ca90, 0xff073a9c, 0x08d },
    { 0x8dbab46f, 0xdc9c0b47, 0xb11ea928, 0x085 },
    { 0x8dbab46f, 0xdc9c0b47, 0xb11ea927, 0x08d },
    { 0x48a870fd, 0x2a92174f, 0x1e1659ae, 0x010 },
    { 0x48a870fd, 0x2a92174f, 0x1e1659ad, 0x018 },
    { 0x00005a22, 0x0170f026, 0xfe8f69fc, 0x095 },
    { 0x00005a22, 0x0170f026, 0xfe8f69fb, 0x099 },
    { 0x95a67475, 0x6327b86d, 0x327ebc08, 0x810 },
    { 0x95a67475, 0x6327b86d, 0x327ebc07, 0x818 },
    { 0x04bd2ef6, 0x60563bbb, 0xa466f33b, 0x091 },
    { 0x04bd2ef6, 0x60563bbb, 0xa466f33a, 0x09d },
    { 0x05b49d0a, 0x0008e6d7, 0x05abb633, 0x004 },
    { 0x05b49d0a, 0x0008e6d7, 0x05abb632, 0x008 },
    { 0x9e9b3cd1, 0xaf135975, 0xef87e35c, 0x095 },
    { 0x9e9b3cd1, 0xaf135975, 0xef87e35b, 0x099 },
    { 0xdf562878, 0x917aee5a, 0x4ddb3a1e, 0x014 },
    { 0xdf562878, 0x917aee5a, 0x4ddb3a1d, 0x01c },
    { 0x00068390, 0x00184658, 0xffee3d38, 0x091 },
    { 0x00068390, 0x00184658, 0xffee3d37, 0x099 },
    { 0xf3725433, 0x96f61b7b, 0x5c7c38b8, 0x014 },
    { 0xf3725433, 0x96f61b7b, 0x5c7c38b7, 0x01c },
    { 0x778654d7, 0xd42c0bbb, 0xa35a491c, 0x891 },
    { 0x778654d7, 0xd42c0bbb, 0xa35a491b, 0x89d },
    { 0x0183cae8, 0x6f98b447, 0x91eb16a1, 0x081 },
    { 0x0183cae8, 0x6f98b447, 0x91eb16a0, 0x08d },
    { 0x1263b9ba, 0x11368c98, 0x012d2d22, 0x004 },
    { 0x1263b9ba, 0x11368c98, 0x012d2d21, 0x00c },
    { 0x99886bcb, 0xcb5ce985, 0xce2b8246, 0x081 },
    { 0x99886bcb, 0xcb5ce985, 0xce2b8245, 0x089 },
    { 0x0007b770, 0x00003e2e, 0x00077942, 0x014 },
    { 0x0007b770, 0x00003e2e, 0x00077941, 0x01c },
    { 0xdeb84a35, 0xd5100e28, 0x09a83c0d, 0x010 },
    { 0xdeb84a35, 0xd5100e28, 0x09a83c0c, 0x01c },
    { 0xd1116ee5, 0x8f87a5f7, 0x4189c8ee, 0x014 },
    { 0xd1116ee5, 0x8f87a5f7, 0x4189c8ed, 0x01c },
    { 0x000003ae, 0x0005c319, 0xfffa4095, 0x085 },
    { 0x000003ae, 0x0005c319, 0xfffa4094, 0x089 },
    { 0xa52bcc8b, 0x1e81ed91, 0x86a9defa, 0x084 },
    { 0xa52bcc8b, 0x1e81ed91, 0x86a9def9, 0x08c },
    { 0x2413da3c, 0x535ccc78, 0xd0b70dc4, 0x081 },
    { 0x2413da3c, 0x535ccc78, 0xd0b70dc3, 0x08d },
    /* r/m32, imm8: */
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0x00000000, 0x00000000, 0xffffffff, 0x09d },
    { 0xffffffff, 0xffffffff, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x09d },
    { 0x00000000, 0xffffffff, 0x00000001, 0x011 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x05d },
    { 0x0000000f, 0x00000050, 0xffffffbf, 0x081 },
    { 0x0000000f, 0x00000050, 0xffffffbe, 0x08d },
    { 0xade3217b, 0xffffff99, 0xade321e2, 0x085 },
    { 0xade3217b, 0xffffff99, 0xade321e1, 0x08d },
    { 0x23aeb150, 0x0000007d, 0x23aeb0d3, 0x010 },
    { 0x23aeb150, 0x0000007d, 0x23aeb0d2, 0x01c },
    { 0x000045bc, 0xffffffe3, 0x000045d9, 0x001 },
    { 0x000045bc, 0xffffffe3, 0x000045d8, 0x00d },
    { 0x82c8e4da, 0x00000077, 0x82c8e463, 0x084 },
    { 0x82c8e4da, 0x00000077, 0x82c8e462, 0x088 },
    { 0x99fdb874, 0xffffffd4, 0x99fdb8a0, 0x085 },
    { 0x99fdb874, 0xffffffd4, 0x99fdb89f, 0x09d },
    { 0x000036ee, 0xfffffff1, 0x000036fd, 0x001 },
    { 0x000036ee, 0xfffffff1, 0x000036fc, 0x00d },
    { 0x5fd8550a, 0xffffffdc, 0x5fd8552e, 0x015 },
    { 0x5fd8550a, 0xffffffdc, 0x5fd8552d, 0x01d },
    { 0xea1495f8, 0x00000030, 0xea1495c8, 0x080 },
    { 0xea1495f8, 0x00000030, 0xea1495c7, 0x088 },
    { 0x00256860, 0xffffffd5, 0x0025688b, 0x015 },
    { 0x00256860, 0xffffffd5, 0x0025688a, 0x019 },
    { 0x62a49392, 0xffffffd6, 0x62a493bc, 0x011 },
    { 0x62a49392, 0xffffffd6, 0x62a493bb, 0x01d },
    { 0x6f63ab77, 0xffffffef, 0x6f63ab88, 0x015 },
    { 0x6f63ab77, 0xffffffef, 0x6f63ab87, 0x01d },
    { 0x00000cf5, 0xffffffa9, 0x00000d4c, 0x011 },
    { 0x00000cf5, 0xffffffa9, 0x00000d4b, 0x01d },
    { 0x57357e9d, 0x00000025, 0x57357e78, 0x004 },
    { 0x57357e9d, 0x00000025, 0x57357e77, 0x00c },
    { 0xaac26938, 0x0000004a, 0xaac268ee, 0x094 },
    { 0xaac26938, 0x0000004a, 0xaac268ed, 0x09c },
    { 0x0000d17f, 0xffffffeb, 0x0000d194, 0x001 },
    { 0x0000d17f, 0xffffffeb, 0x0000d193, 0x00d },
    { 0xac8935d0, 0x0000005b, 0xac893575, 0x090 },
    { 0xac8935d0, 0x0000005b, 0xac893574, 0x09c },
    { 0x4d8396ea, 0x00000067, 0x4d839683, 0x000 },
    { 0x4d8396ea, 0x00000067, 0x4d839682, 0x00c },
    { 0x00081057, 0x00000037, 0x00081020, 0x000 },
    { 0x00081057, 0x00000037, 0x0008101f, 0x018 },
    { 0xa1c9ec81, 0x0000007b, 0xa1c9ec06, 0x094 },
    { 0xa1c9ec81, 0x0000007b, 0xa1c9ec05, 0x09c },
    { 0xd6f4aa27, 0x0000000a, 0xd6f4aa1d, 0x094 },
    { 0xd6f4aa27, 0x0000000a, 0xd6f4aa1c, 0x098 },
    { 0x000035e4, 0xffffffbc, 0x00003628, 0x015 },
    { 0x000035e4, 0xffffffbc, 0x00003627, 0x01d },
    { 0x70f9ac93, 0x00000003, 0x70f9ac90, 0x004 },
    { 0x70f9ac93, 0x00000003, 0x70f9ac8f, 0x018 },
    { 0x6577f1ef, 0x00000020, 0x6577f1cf, 0x004 },
    { 0x6577f1ef, 0x00000020, 0x6577f1ce, 0x008 },
    { 0x0000611f, 0x00000002, 0x0000611d, 0x004 },
    { 0x0000611f, 0x00000002, 0x0000611c, 0x008 },
    { 0xa38ffa87, 0x0000004e, 0xa38ffa39, 0x094 },
    { 0xa38ffa87, 0x0000004e, 0xa38ffa38, 0x098 },
    { 0x3ad4f37e, 0xffffffa4, 0x3ad4f3da, 0x001 },
    { 0x3ad4f37e, 0xffffffa4, 0x3ad4f3d9, 0x009 },
    { 0x0ec615ce, 0xfffffff5, 0x0ec615d9, 0x001 },
    { 0x0ec615ce, 0xfffffff5, 0x0ec615d8, 0x00d },
    { 0x2590afa1, 0x0000001e, 0x2590af83, 0x010 },
    { 0x2590afa1, 0x0000001e, 0x2590af82, 0x01c },
    { 0x92f1e32f, 0x00000034, 0x92f1e2fb, 0x080 },
    { 0x92f1e32f, 0x00000034, 0x92f1e2fa, 0x08c },
    { 0x0002970f, 0xffffff94, 0x0002977b, 0x005 },
    { 0x0002970f, 0xffffff94, 0x0002977a, 0x009 },
    { 0xac6baf12, 0xffffff86, 0xac6baf8c, 0x091 },
    { 0xac6baf12, 0xffffff86, 0xac6baf8b, 0x09d },
    { 0x35edb251, 0xffffff80, 0x35edb2d1, 0x005 },
    { 0x35edb251, 0xffffff80, 0x35edb2d0, 0x009 },
};

const uint16_t g_cBs3CpuInstr2_cmp_TestDataU8 = 32;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_cmp_TestDataU8[32] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0xff, 0xff, 0xff, 0x044 },
    { 0x00, 0xff, 0x00, 0x011 },
    { 0xc6, 0x0d, 0xc6, 0x090 },
    { 0x55, 0x2c, 0x55, 0x010 },
    { 0x9b, 0x2b, 0x9b, 0x800 },
    { 0xa3, 0x2b, 0xa3, 0x814 },
    { 0x81, 0x80, 0x81, 0x000 },
    { 0x86, 0x7b, 0x86, 0x810 },
    { 0x46, 0xdd, 0x46, 0x015 },
    { 0xc7, 0x91, 0xc7, 0x004 },
    { 0xc1, 0x0b, 0xc1, 0x090 },
    { 0x4f, 0x25, 0x4f, 0x000 },
    { 0x8c, 0xd6, 0x8c, 0x081 },
    { 0x80, 0x36, 0x80, 0x810 },
    { 0xef, 0x89, 0xef, 0x004 },
    { 0x3d, 0x37, 0x3d, 0x004 },
    { 0xe7, 0x60, 0xe7, 0x084 },
    { 0xf4, 0x74, 0xf4, 0x080 },
    { 0xfd, 0x87, 0xfd, 0x000 },
    { 0x1c, 0x01, 0x1c, 0x004 },
    { 0x29, 0x32, 0x29, 0x081 },
    { 0xb1, 0x4b, 0xb1, 0x814 },
    { 0xb5, 0xa9, 0xb5, 0x014 },
    { 0x68, 0xed, 0x68, 0x015 },
    { 0x60, 0x0d, 0x60, 0x014 },
    { 0x41, 0x19, 0x41, 0x014 },
    { 0x68, 0x94, 0x68, 0x885 },
    { 0x47, 0x09, 0x47, 0x010 },
    { 0x01, 0x91, 0x01, 0x001 },
    { 0xb7, 0x77, 0xb7, 0x800 },
    { 0x26, 0xc5, 0x26, 0x001 },
};

const uint16_t g_cBs3CpuInstr2_cmp_TestDataU16 = 64;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_cmp_TestDataU16[64] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x044 },
    { 0x0000, 0xffff, 0x0000, 0x011 },
    { 0x0001, 0x001f, 0x0001, 0x095 },
    { 0x519b, 0xaccf, 0x519b, 0x895 },
    { 0x8989, 0xc2b1, 0x8989, 0x085 },
    { 0x00b2, 0x02e0, 0x00b2, 0x085 },
    { 0xbd09, 0xcfb3, 0xbd09, 0x085 },
    { 0xfd41, 0xef2a, 0xfd41, 0x014 },
    { 0x0061, 0x000e, 0x0061, 0x014 },
    { 0xc168, 0x9af0, 0xc168, 0x004 },
    { 0x25fd, 0x088b, 0x25fd, 0x004 },
    { 0x070a, 0x0845, 0x070a, 0x085 },
    { 0xad87, 0x951d, 0xad87, 0x014 },
    { 0xa9d6, 0x391c, 0xa9d6, 0x810 },
    { 0x0130, 0x0038, 0x0130, 0x010 },
    { 0x5f6b, 0x7baf, 0x5f6b, 0x091 },
    { 0x5b2a, 0x57b5, 0x5b2a, 0x000 },
    { 0x0788, 0x1865, 0x0788, 0x081 },
    { 0xe99f, 0xf30c, 0xe99f, 0x085 },
    { 0xb942, 0xda06, 0xb942, 0x095 },
    { 0x0ae1, 0x000f, 0x0ae1, 0x014 },
    { 0x486d, 0xff64, 0x486d, 0x005 },
    { 0x3a98, 0x0d80, 0x3a98, 0x004 },
    { 0x002f, 0x0025, 0x002f, 0x004 },
    { 0x508e, 0xbede, 0x508e, 0x881 },
    { 0x0a56, 0xcdf7, 0x0a56, 0x015 },
    { 0x35dc, 0x00ed, 0x35dc, 0x010 },
    { 0x1413, 0x1f1c, 0x1413, 0x091 },
    { 0x9911, 0x47f5, 0x9911, 0x810 },
    { 0x0371, 0x0012, 0x0371, 0x014 },
    { 0x2c6c, 0x7935, 0x2c6c, 0x081 },
    /* r/m16, imm8: */
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x044 },
    { 0x0000, 0xffff, 0x0000, 0x011 },
    { 0x11cb, 0xff9b, 0x11cb, 0x005 },
    { 0x1671, 0x0066, 0x1671, 0x010 },
    { 0xc7af, 0xff95, 0xc7af, 0x081 },
    { 0x0004, 0xffac, 0x0004, 0x011 },
    { 0x68a3, 0xffa0, 0x68a3, 0x005 },
    { 0x3e09, 0x0035, 0x3e09, 0x004 },
    { 0x00a3, 0xff92, 0x00a3, 0x005 },
    { 0xdc8e, 0x0036, 0xdc8e, 0x080 },
    { 0xb871, 0xffcb, 0xb871, 0x095 },
    { 0x0058, 0xff96, 0x0058, 0x001 },
    { 0x3751, 0x005c, 0x3751, 0x014 },
    { 0xd131, 0x005e, 0xd131, 0x090 },
    { 0x2863, 0x0007, 0x2863, 0x014 },
    { 0xb096, 0x0058, 0xb096, 0x090 },
    { 0x0072, 0xffc0, 0x0072, 0x005 },
    { 0x0006, 0xffa2, 0x0006, 0x001 },
    { 0x7446, 0xfffd, 0x7446, 0x011 },
    { 0x831f, 0x0038, 0x831f, 0x084 },
    { 0x8007, 0x0051, 0x8007, 0x800 },
    { 0xebab, 0x001b, 0xebab, 0x084 },
    { 0xfe2d, 0xff94, 0xfe2d, 0x085 },
    { 0x2b06, 0xffea, 0x2b06, 0x011 },
    { 0x38d6, 0x0023, 0x38d6, 0x000 },
    { 0x69f3, 0xffdb, 0x69f3, 0x015 },
    { 0x006e, 0xfffb, 0x006e, 0x001 },
    { 0x8d42, 0x0017, 0x8d42, 0x094 },
    { 0xb41f, 0xffaf, 0xb41f, 0x081 },
    { 0x713d, 0x0011, 0x713d, 0x000 },
    { 0x51d6, 0xffb0, 0x51d6, 0x001 },
};

const uint16_t g_cBs3CpuInstr2_cmp_TestDataU32 = 72;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_cmp_TestDataU32[72] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x044 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x011 },
    { 0x3f0761c7, 0x000001ed, 0x3f0761c7, 0x010 },
    { 0x57d490af, 0x4466dd62, 0x57d490af, 0x004 },
    { 0x7d504f2f, 0xa37ed6ef, 0x7d504f2f, 0x881 },
    { 0x0000c044, 0x00012555, 0x0000c044, 0x091 },
    { 0xe4b629fe, 0x1c94684c, 0xe4b629fe, 0x084 },
    { 0xd34b643c, 0xbaa1c9dc, 0xd34b643c, 0x004 },
    { 0x0000584d, 0x00cc31fe, 0x0000584d, 0x091 },
    { 0x01e65ab4, 0xfa4d0138, 0x01e65ab4, 0x011 },
    { 0x958b4242, 0x29ab26ee, 0x958b4242, 0x810 },
    { 0x0000b440, 0x000008aa, 0x0000b440, 0x014 },
    { 0x837f02cc, 0xc790c1b2, 0x837f02cc, 0x081 },
    { 0xf09cb1d2, 0xff5e8bc0, 0xf09cb1d2, 0x085 },
    { 0x00000077, 0x0000668a, 0x00000077, 0x095 },
    { 0xa56c0ec9, 0x593ec150, 0xa56c0ec9, 0x800 },
    { 0xa70598f6, 0x607d527d, 0xa70598f6, 0x810 },
    { 0x1dea5b4b, 0x00004c9b, 0x1dea5b4b, 0x000 },
    { 0x0a35787f, 0xfc79ffe8, 0x0a35787f, 0x001 },
    { 0xed901830, 0x4f240eae, 0xed901830, 0x094 },
    { 0x0000345d, 0x00ecd7b5, 0x0000345d, 0x081 },
    { 0x6845bb6c, 0x7a13c41b, 0x6845bb6c, 0x081 },
    { 0xa7b0073a, 0x55aa8531, 0xa7b0073a, 0x804 },
    { 0x000010d7, 0x004d0f93, 0x000010d7, 0x085 },
    { 0xf3b9aafa, 0x62883e71, 0xf3b9aafa, 0x080 },
    { 0x1ebb7e6d, 0x676935de, 0x1ebb7e6d, 0x091 },
    { 0x00004737, 0x000c4021, 0x00004737, 0x081 },
    { 0x35e64183, 0x5fd73bed, 0x35e64183, 0x095 },
    { 0x2b9f75c3, 0x31ec6b94, 0x2b9f75c3, 0x091 },
    { 0x00000780, 0x0038da2b, 0x00000780, 0x095 },
    { 0xfefb4623, 0xa2b9e4f6, 0xfefb4623, 0x014 },
    { 0x1a66e449, 0xd915a2fd, 0x1a66e449, 0x011 },
    { 0x00000246, 0x00000257, 0x00000246, 0x091 },
    { 0xe849dc4f, 0x491edb33, 0xe849dc4f, 0x080 },
    { 0x88c8f5f2, 0x018b0833, 0x88c8f5f2, 0x090 },
    /* r/m32, imm8: */
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x044 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x011 },
    { 0x3e943c30, 0xffffffd4, 0x3e943c30, 0x015 },
    { 0x4a0c14b0, 0xffffffca, 0x4a0c14b0, 0x011 },
    { 0x06ecca91, 0xfffffff7, 0x06ecca91, 0x015 },
    { 0x00007f26, 0x00000027, 0x00007f26, 0x014 },
    { 0xb896dc93, 0xffffffeb, 0xb896dc93, 0x091 },
    { 0x8e52863d, 0x00000023, 0x8e52863d, 0x080 },
    { 0x000037b5, 0xffffffe3, 0x000037b5, 0x005 },
    { 0x712c2d6a, 0x0000005e, 0x712c2d6a, 0x014 },
    { 0xe9f496f7, 0x00000079, 0xe9f496f7, 0x094 },
    { 0x0000075d, 0xffffffdd, 0x0000075d, 0x001 },
    { 0x5fd9522a, 0xffffff8f, 0x5fd9522a, 0x011 },
    { 0xd3eb7347, 0x0000005c, 0xd3eb7347, 0x094 },
    { 0x00000196, 0xffffffcd, 0x00000196, 0x015 },
    { 0xc644f8be, 0x00000029, 0xc644f8be, 0x084 },
    { 0xd6f05428, 0xffffffaf, 0xd6f05428, 0x091 },
    { 0x00003605, 0xffffffcc, 0x00003605, 0x015 },
    { 0x9c2cc5a9, 0xffffff85, 0x9c2cc5a9, 0x085 },
    { 0x82543c1a, 0xfffffffb, 0x82543c1a, 0x091 },
    { 0x0000051d, 0xffffffea, 0x0000051d, 0x005 },
    { 0xf20d9e78, 0x00000010, 0xf20d9e78, 0x080 },
    { 0xf1f9d40e, 0xffffff97, 0xf1f9d40e, 0x085 },
    { 0x000113ff, 0x0000007d, 0x000113ff, 0x004 },
    { 0xf77fc3d5, 0x0000003d, 0xf77fc3d5, 0x090 },
    { 0x056b96a2, 0x00000075, 0x056b96a2, 0x014 },
    { 0x0001ff6e, 0x0000007c, 0x0001ff6e, 0x000 },
    { 0x09358f3f, 0xffffffd2, 0x09358f3f, 0x001 },
    { 0xbdc03bff, 0xffffffd8, 0xbdc03bff, 0x085 },
    { 0x228fcecc, 0x0000003d, 0x228fcecc, 0x010 },
    { 0x98c8ce4a, 0xffffffcf, 0x98c8ce4a, 0x095 },
    { 0x7150aa0e, 0x0000006d, 0x7150aa0e, 0x000 },
    { 0x34e6d153, 0x0000001a, 0x34e6d153, 0x014 },
    { 0xd37a5f08, 0x00000035, 0xd37a5f08, 0x080 },
    { 0x02fb2bf8, 0x0000004f, 0x02fb2bf8, 0x014 },
};

const uint16_t g_cBs3CpuInstr2_bt_TestDataU16 = 32;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_bt_TestDataU16[32] =
{
    { 0x0000, 0x0000, 0x0000, 0x000 },
    { 0xffff, 0xffff, 0xffff, 0x001 },
    { 0x0000, 0xffff, 0x0000, 0x000 },
    { 0x0151, 0x13b8, 0x0151, 0x001 },
    { 0xa43c, 0x9073, 0xa43c, 0x001 },
    { 0x6f32, 0x7561, 0x6f32, 0x001 },
    { 0x00ce, 0x0015, 0x00ce, 0x000 },
    { 0x5b5b, 0xeb4f, 0x5b5b, 0x000 },
    { 0xba59, 0x5f0e, 0xba59, 0x000 },
    { 0x0feb, 0x0796, 0x0feb, 0x001 },
    { 0xb39b, 0x881e, 0xb39b, 0x000 },
    { 0x990d, 0x528a, 0x990d, 0x000 },
    { 0x0004, 0x001d, 0x0004, 0x000 },
    { 0x6cc4, 0xe264, 0x6cc4, 0x000 },
    { 0x2391, 0x31b5, 0x2391, 0x000 },
    { 0x00b4, 0x001f, 0x00b4, 0x000 },
    { 0x08ff, 0xd7d4, 0x08ff, 0x001 },
    { 0xd5c7, 0x1981, 0xd5c7, 0x001 },
    { 0x010d, 0x050f, 0x010d, 0x000 },
    { 0xf9c0, 0xdb57, 0xf9c0, 0x001 },
    { 0x68a1, 0x2fd2, 0x68a1, 0x000 },
    { 0x01d0, 0x0255, 0x01d0, 0x000 },
    { 0x3f57, 0x75ae, 0x3f57, 0x000 },
    { 0x0dc6, 0x7efb, 0x0dc6, 0x001 },
    { 0x0016, 0x008b, 0x0016, 0x000 },
    { 0x1b51, 0x89d2, 0x1b51, 0x000 },
    { 0x47d8, 0xb6ee, 0x47d8, 0x001 },
    { 0x01a5, 0x0071, 0x01a5, 0x000 },
    { 0x03d8, 0x7bd1, 0x03d8, 0x000 },
    { 0xf773, 0xc52c, 0xf773, 0x001 },
    { 0x0402, 0x0163, 0x0402, 0x000 },
    { 0xe1c1, 0x7182, 0xe1c1, 0x000 },
};

const uint16_t g_cBs3CpuInstr2_bt_TestDataU32 = 36;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_bt_TestDataU32[36] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x004 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x005 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x004 },
    { 0x0005b1b3, 0x000038b2, 0x0005b1b3, 0x005 },
    { 0x8d3257b6, 0xa41c747e, 0x8d3257b6, 0x004 },
    { 0x88242f8b, 0xffad52d9, 0x88242f8b, 0x004 },
    { 0x19218335, 0x00005c9a, 0x19218335, 0x004 },
    { 0xa1004402, 0x1870f03b, 0xa1004402, 0x004 },
    { 0x5eabbe06, 0xdd488ba5, 0x5eabbe06, 0x004 },
    { 0x50b6ec8f, 0x000003b6, 0x50b6ec8f, 0x004 },
    { 0x58d8c6ba, 0x7fdf0ae7, 0x58d8c6ba, 0x005 },
    { 0x8c450547, 0xc75d7e9c, 0x8c450547, 0x004 },
    { 0x00000c63, 0x00005dde, 0x00000c63, 0x004 },
    { 0x02c456d4, 0x28209a8a, 0x02c456d4, 0x005 },
    { 0xc6c319b0, 0x72cb961b, 0xc6c319b0, 0x004 },
    { 0x000003f1, 0x00000128, 0x000003f1, 0x005 },
    { 0xd5ea6936, 0x90a1844b, 0xd5ea6936, 0x005 },
    { 0xdbf46074, 0x48e88ed6, 0xdbf46074, 0x005 },
    { 0x00002e39, 0x1a3d7187, 0x00002e39, 0x004 },
    { 0x37e88459, 0x02492c8f, 0x37e88459, 0x005 },
    { 0x520c8248, 0xb33d6f0d, 0x520c8248, 0x004 },
    { 0x00006d6c, 0x02fa2431, 0x00006d6c, 0x004 },
    { 0x805e3993, 0xea1602e8, 0x805e3993, 0x005 },
    { 0x17459a6b, 0x1a9d1390, 0x17459a6b, 0x005 },
    { 0x002e37e0, 0x01b4c722, 0x002e37e0, 0x004 },
    { 0x997da7cd, 0xc893b1a1, 0x997da7cd, 0x004 },
    { 0x5872e640, 0x1f6aa11d, 0x5872e640, 0x004 },
    { 0x000004a6, 0x0000119c, 0x000004a6, 0x004 },
    { 0x2ab440ee, 0xa012fffc, 0x2ab440ee, 0x004 },
    { 0x3f642aaa, 0xc92d403d, 0x3f642aaa, 0x005 },
    { 0x085a4f55, 0x0005e1f9, 0x085a4f55, 0x004 },
    { 0x4676d495, 0xa37e8583, 0x4676d495, 0x004 },
    { 0xacf3b45b, 0xf3c5d96b, 0xacf3b45b, 0x004 },
    { 0x00004d87, 0x000c90c3, 0x00004d87, 0x004 },
    { 0xddf41ccd, 0x058f06eb, 0xddf41ccd, 0x005 },
    { 0xf10f51fa, 0x64cf0d3f, 0xf10f51fa, 0x005 },
};

const uint16_t g_cBs3CpuInstr2_btc_TestDataU16 = 32;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_btc_TestDataU16[32] =
{
    { 0x0000, 0x0000, 0x0001, 0x004 },
    { 0xffff, 0xffff, 0x7fff, 0x005 },
    { 0x0000, 0xffff, 0x8000, 0x004 },
    { 0x008c, 0x08b4, 0x009c, 0x004 },
    { 0xe9d1, 0xb020, 0xe9d0, 0x005 },
    { 0x345d, 0xdab5, 0x347d, 0x004 },
    { 0x22f0, 0x0058, 0x23f0, 0x004 },
    { 0x7077, 0xcae7, 0x70f7, 0x004 },
    { 0x1ef8, 0x358c, 0x0ef8, 0x005 },
    { 0x0b0f, 0x07f2, 0x0b0b, 0x005 },
    { 0xd598, 0x0a63, 0xd590, 0x005 },
    { 0xfe40, 0x49db, 0xf640, 0x005 },
    { 0x01b8, 0x001c, 0x11b8, 0x004 },
    { 0x0a00, 0xa92e, 0x4a00, 0x004 },
    { 0x3906, 0xef7f, 0xb906, 0x004 },
    { 0x05db, 0x0af4, 0x05cb, 0x005 },
    { 0xd015, 0x16af, 0x5015, 0x005 },
    { 0x4067, 0x3fbb, 0x4867, 0x004 },
    { 0x00b0, 0x07d4, 0x00a0, 0x005 },
    { 0x545b, 0x4ece, 0x145b, 0x005 },
    { 0xd832, 0xbb36, 0xd872, 0x004 },
    { 0x07ec, 0x01ee, 0x47ec, 0x004 },
    { 0xb24e, 0x2941, 0xb24c, 0x005 },
    { 0x75d1, 0x1636, 0x7591, 0x005 },
    { 0x4707, 0x00f3, 0x470f, 0x004 },
    { 0xee33, 0x7f50, 0xee32, 0x005 },
    { 0x788d, 0x746b, 0x708d, 0x005 },
    { 0x0030, 0x05bb, 0x0830, 0x004 },
    { 0x4e80, 0xb931, 0x4e82, 0x004 },
    { 0x7f14, 0x1be2, 0x7f10, 0x005 },
    { 0x130e, 0x0003, 0x1306, 0x005 },
    { 0x6be2, 0xe034, 0x6bf2, 0x004 },
};

const uint16_t g_cBs3CpuInstr2_btc_TestDataU32 = 36;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_btc_TestDataU32[36] =
{
    { 0x00000000, 0x00000000, 0x00000001, 0x004 },
    { 0xffffffff, 0xffffffff, 0x7fffffff, 0x005 },
    { 0x00000000, 0xffffffff, 0x80000000, 0x004 },
    { 0x036de7a1, 0x00007c0e, 0x036da7a1, 0x005 },
    { 0x39948ff6, 0xc8777d02, 0x39948ff2, 0x005 },
    { 0xdcb03379, 0x74035ba5, 0xdcb03359, 0x005 },
    { 0x051d3ed2, 0x0003625f, 0x851d3ed2, 0x004 },
    { 0x2c9b5515, 0x49ef0d67, 0x2c9b5595, 0x004 },
    { 0xb0e89359, 0xf521f1f8, 0xb1e89359, 0x004 },
    { 0x001425ef, 0x001fdb61, 0x001425ed, 0x005 },
    { 0x0bfbd3a7, 0x82047f16, 0x0bbbd3a7, 0x005 },
    { 0x75339f36, 0x5019ad83, 0x75339f3e, 0x004 },
    { 0x00000bd3, 0x00008a09, 0x000009d3, 0x005 },
    { 0x34d2825e, 0xa86d0469, 0x34d2805e, 0x005 },
    { 0x0d3cbf0e, 0xcf2357bf, 0x8d3cbf0e, 0x004 },
    { 0x0001bf4e, 0x00004c98, 0x0101bf4e, 0x004 },
    { 0xa5649b98, 0xb0232b55, 0xa5449b98, 0x005 },
    { 0x94f212f7, 0x60bb20df, 0x14f212f7, 0x005 },
    { 0x0454a3f8, 0x00003a43, 0x0454a3f0, 0x005 },
    { 0xdc944420, 0x8a049f88, 0xdc944520, 0x004 },
    { 0x3585bfae, 0x1feb74c9, 0x3585bdae, 0x005 },
    { 0x0001562c, 0x00016be0, 0x0001562d, 0x004 },
    { 0x15877902, 0xb1199e2c, 0x15876902, 0x005 },
    { 0x08df73e3, 0xc63140a2, 0x08df73e7, 0x004 },
    { 0x000111c8, 0x00000619, 0x020111c8, 0x004 },
    { 0x84853255, 0x44ab8d98, 0x85853255, 0x004 },
    { 0x1adcf88d, 0xa141fec2, 0x1adcf889, 0x005 },
    { 0x0064b220, 0x000015bf, 0x8064b220, 0x004 },
    { 0x6d7a06cc, 0x72591952, 0x6d7e06cc, 0x004 },
    { 0xf78d7050, 0x66c8d181, 0xf78d7052, 0x004 },
    { 0x000005b4, 0x001dcbd5, 0x002005b4, 0x004 },
    { 0x9431360a, 0x6ad2f5b4, 0x9421360a, 0x005 },
    { 0x80013336, 0xcec93f0e, 0x80017336, 0x004 },
    { 0x00036f54, 0x000002d9, 0x02036f54, 0x004 },
    { 0x2fd3aed8, 0xb27bff6f, 0x2fd32ed8, 0x005 },
    { 0xaabf0b21, 0xa473b973, 0xaab70b21, 0x005 },
};

const uint16_t g_cBs3CpuInstr2_btr_TestDataU16 = 32;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_btr_TestDataU16[32] =
{
    { 0x0000, 0x0000, 0x0000, 0x000 },
    { 0xffff, 0xffff, 0x7fff, 0x001 },
    { 0x0000, 0xffff, 0x0000, 0x000 },
    { 0x022d, 0x0016, 0x022d, 0x000 },
    { 0xe03b, 0x8188, 0xe03b, 0x000 },
    { 0x0c58, 0x8a95, 0x0c58, 0x000 },
    { 0x01a6, 0x0003, 0x01a6, 0x000 },
    { 0x611a, 0x2485, 0x611a, 0x000 },
    { 0xb568, 0xc3b0, 0xb568, 0x000 },
    { 0x0008, 0x0040, 0x0008, 0x000 },
    { 0xaa67, 0x7d3c, 0xaa67, 0x000 },
    { 0xf13d, 0xe975, 0xf11d, 0x001 },
    { 0x07ff, 0x0516, 0x07bf, 0x001 },
    { 0xb3a5, 0x38e9, 0xb1a5, 0x001 },
    { 0x50fd, 0x191e, 0x10fd, 0x001 },
    { 0x2a81, 0x001c, 0x2a81, 0x000 },
    { 0xee7a, 0xcc99, 0xec7a, 0x001 },
    { 0x8942, 0x74b4, 0x8942, 0x000 },
    { 0x001c, 0x0026, 0x001c, 0x000 },
    { 0x0420, 0xef20, 0x0420, 0x000 },
    { 0x5b24, 0xa62c, 0x4b24, 0x001 },
    { 0x037b, 0x02dc, 0x037b, 0x000 },
    { 0x15ff, 0x575d, 0x15ff, 0x000 },
    { 0x9e56, 0x5636, 0x9e16, 0x001 },
    { 0x1891, 0x0064, 0x1881, 0x001 },
    { 0x8020, 0xdcb3, 0x8020, 0x000 },
    { 0xa443, 0x681f, 0x2443, 0x001 },
    { 0x0001, 0x000a, 0x0001, 0x000 },
    { 0x0fc6, 0xcd38, 0x0ec6, 0x001 },
    { 0x54ae, 0x853c, 0x44ae, 0x001 },
    { 0x00d4, 0x5315, 0x00d4, 0x000 },
    { 0x0e22, 0x145f, 0x0e22, 0x000 },
};

const uint16_t g_cBs3CpuInstr2_btr_TestDataU32 = 36;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_btr_TestDataU32[36] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x000 },
    { 0xffffffff, 0xffffffff, 0x7fffffff, 0x001 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x000 },
    { 0x001a2d6b, 0x1b0244a1, 0x001a2d69, 0x001 },
    { 0x51e7e51e, 0x97118f4c, 0x51e7e51e, 0x000 },
    { 0x81d6d269, 0x3e8fec70, 0x81d6d269, 0x000 },
    { 0x0000006c, 0x0093bef9, 0x0000006c, 0x000 },
    { 0x49dee345, 0xc81aece6, 0x49dee305, 0x001 },
    { 0xdfb71505, 0x6cc52c5a, 0xdbb71505, 0x001 },
    { 0x1335d601, 0x07f2b004, 0x1335d601, 0x000 },
    { 0x4e01daaf, 0x1bbc3f2b, 0x4e01d2af, 0x001 },
    { 0x4c8a4658, 0xca1041d6, 0x4c8a4658, 0x000 },
    { 0x000a73f9, 0x1406f4f8, 0x000a73f9, 0x000 },
    { 0x54bcd00d, 0xb7ff30f1, 0x54bcd00d, 0x000 },
    { 0x92e63aef, 0xc9274b6e, 0x92e63aef, 0x000 },
    { 0x001d29e4, 0x00f448a9, 0x001d29e4, 0x000 },
    { 0xa9ce5e18, 0xab83afec, 0xa9ce4e18, 0x001 },
    { 0xd292e619, 0x6a407cd5, 0xd292e619, 0x000 },
    { 0x00002add, 0x0002f8cc, 0x00002add, 0x000 },
    { 0x3f5c2e7f, 0xfcf0b458, 0x3e5c2e7f, 0x001 },
    { 0x3109cbe0, 0x7a27f846, 0x3109cba0, 0x001 },
    { 0x00000002, 0x0036e81d, 0x00000002, 0x000 },
    { 0x7940cbdf, 0x4d08dbaa, 0x7940cbdf, 0x000 },
    { 0x808d7c95, 0xc8ee3b4f, 0x808d7c95, 0x000 },
    { 0x06ec7530, 0x0001038e, 0x06ec3530, 0x001 },
    { 0xb0409ea0, 0xa26e331f, 0x30409ea0, 0x001 },
    { 0x70de6ab5, 0xda2faa23, 0x70de6ab5, 0x000 },
    { 0x0089ff6f, 0x69e7b6ce, 0x0089bf6f, 0x001 },
    { 0x70affaf1, 0x71841e03, 0x70affaf1, 0x000 },
    { 0x98ce705a, 0x19325242, 0x98ce705a, 0x000 },
    { 0x0069f79e, 0x03af8dbc, 0x0069f79e, 0x000 },
    { 0xba82545b, 0x0270405f, 0x3a82545b, 0x001 },
    { 0xd7923f0c, 0x426959be, 0x97923f0c, 0x001 },
    { 0x000019cc, 0x33494d1e, 0x000019cc, 0x000 },
    { 0x49b88285, 0xf080eebf, 0x49b88285, 0x000 },
    { 0xe0ba5679, 0x2983538b, 0xe0ba5679, 0x000 },
};

const uint16_t g_cBs3CpuInstr2_bts_TestDataU16 = 32;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_bts_TestDataU16[32] =
{
    { 0x0000, 0x0000, 0x0001, 0x004 },
    { 0xffff, 0xffff, 0xffff, 0x005 },
    { 0x0000, 0xffff, 0x8000, 0x004 },
    { 0x0672, 0x3864, 0x0672, 0x005 },
    { 0x8983, 0x035f, 0x8983, 0x005 },
    { 0x5413, 0xd03c, 0x5413, 0x005 },
    { 0x0049, 0x002f, 0x8049, 0x004 },
    { 0xefe8, 0x8061, 0xefea, 0x004 },
    { 0x9806, 0xf02c, 0x9806, 0x005 },
    { 0x006a, 0x0037, 0x00ea, 0x004 },
    { 0x2a17, 0x898b, 0x2a17, 0x005 },
    { 0x2bc0, 0x6d9b, 0x2bc0, 0x005 },
    { 0x2197, 0x0020, 0x2197, 0x005 },
    { 0xb09b, 0x9e52, 0xb09f, 0x004 },
    { 0x332b, 0x5c26, 0x336b, 0x004 },
    { 0x0009, 0x1cfe, 0x4009, 0x004 },
    { 0xf915, 0x0995, 0xf935, 0x004 },
    { 0x17f7, 0x918c, 0x17f7, 0x005 },
    { 0x0596, 0x0003, 0x059e, 0x004 },
    { 0xc02d, 0xf63f, 0xc02d, 0x005 },
    { 0xad23, 0xfda4, 0xad33, 0x004 },
    { 0x74ce, 0x0034, 0x74de, 0x004 },
    { 0xf9fe, 0xbc17, 0xf9fe, 0x005 },
    { 0x9719, 0x1b86, 0x9759, 0x004 },
    { 0x0007, 0x4f2a, 0x0407, 0x004 },
    { 0xfa0f, 0xfcd0, 0xfa0f, 0x005 },
    { 0xd467, 0xc5d5, 0xd467, 0x005 },
    { 0x011e, 0x366a, 0x051e, 0x004 },
    { 0x0700, 0x9dd9, 0x0700, 0x005 },
    { 0x2530, 0xa6b4, 0x2530, 0x005 },
    { 0x049e, 0x00cb, 0x0c9e, 0x004 },
    { 0x85f7, 0x2daf, 0x85f7, 0x005 },
};

const uint16_t g_cBs3CpuInstr2_bts_TestDataU32 = 36;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_bts_TestDataU32[36] =
{
    { 0x00000000, 0x00000000, 0x00000001, 0x000 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x001 },
    { 0x00000000, 0xffffffff, 0x80000000, 0x000 },
    { 0x7f7f90c8, 0x000054e4, 0x7f7f90d8, 0x000 },
    { 0x375ae43e, 0xf03ebed6, 0x375ae43e, 0x001 },
    { 0xa762ec58, 0x0f8aba6f, 0xa762ec58, 0x001 },
    { 0x02ac02e4, 0x0b1ba256, 0x02ec02e4, 0x000 },
    { 0x8d255a91, 0xcf5d0d28, 0x8d255b91, 0x000 },
    { 0x260ae5cc, 0x1574e86a, 0x260ae5cc, 0x001 },
    { 0x000073a5, 0x0000f223, 0x000073ad, 0x000 },
    { 0x89531891, 0x6e71fd32, 0x89571891, 0x000 },
    { 0xfda61643, 0xe2ffc927, 0xfda616c3, 0x000 },
    { 0x0093c09e, 0x00053c91, 0x0093c09e, 0x001 },
    { 0x4dcb81c3, 0xabb43048, 0x4dcb81c3, 0x001 },
    { 0x42cddd62, 0x19816f31, 0x42cfdd62, 0x000 },
    { 0x000042a4, 0x0124c9f5, 0x002042a4, 0x000 },
    { 0x364704d2, 0x270df37f, 0xb64704d2, 0x000 },
    { 0x44ed2ae1, 0x6e9a1c4d, 0x44ed2ae1, 0x001 },
    { 0x0000769c, 0x000005e4, 0x0000769c, 0x001 },
    { 0xee273eb2, 0x5285509d, 0xee273eb2, 0x001 },
    { 0xae6f9dbe, 0x61dd3cc3, 0xae6f9dbe, 0x001 },
    { 0x0080b6a5, 0x00004196, 0x00c0b6a5, 0x000 },
    { 0xd825ef8b, 0xa291bbe3, 0xd825ef8b, 0x001 },
    { 0x4dc645d0, 0x141161c0, 0x4dc645d1, 0x000 },
    { 0x000025bd, 0x00bdd25c, 0x100025bd, 0x000 },
    { 0x403dc69c, 0x17ba2be3, 0x403dc69c, 0x001 },
    { 0xbf977113, 0xaf80d7d6, 0xbfd77113, 0x000 },
    { 0x031988a1, 0x00fc7ac2, 0x031988a5, 0x000 },
    { 0x55df95a2, 0x49d8eab9, 0x57df95a2, 0x000 },
    { 0xc01a3d8f, 0x7abf9829, 0xc01a3f8f, 0x000 },
    { 0x00000076, 0x05da5244, 0x00000076, 0x001 },
    { 0x904f09fb, 0xf518461a, 0x944f09fb, 0x000 },
    { 0x4ca27031, 0xbc73c845, 0x4ca27031, 0x001 },
    { 0x0000d166, 0x00000789, 0x0000d366, 0x000 },
    { 0x005f036c, 0x04f84d97, 0x00df036c, 0x000 },
    { 0xc9ae17e1, 0xc4a1b9be, 0xc9ae17e1, 0x001 },
};