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

/* $Id: bs3-cpu-instr-2-data16.c16 104006 2024-03-22 23:09:25Z 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 },
    { 0x14, 0x83, 0x00, 0x044 },
    { 0x1c, 0xed, 0x0c, 0x004 },
    { 0x07, 0x14, 0x04, 0x000 },
    { 0x92, 0xaa, 0x82, 0x084 },
    { 0x22, 0xbd, 0x20, 0x000 },
    { 0xa6, 0xd9, 0x80, 0x080 },
    { 0xf7, 0xd3, 0xd3, 0x080 },
    { 0x8c, 0x37, 0x04, 0x000 },
    { 0x3c, 0x65, 0x24, 0x004 },
    { 0xb1, 0x62, 0x20, 0x000 },
    { 0x56, 0x07, 0x06, 0x004 },
    { 0x17, 0x01, 0x01, 0x000 },
    { 0xcb, 0xa4, 0x80, 0x080 },
    { 0xf1, 0x2e, 0x20, 0x000 },
    { 0x09, 0x49, 0x09, 0x004 },
    { 0x82, 0x0b, 0x02, 0x000 },
    { 0x8b, 0x81, 0x81, 0x084 },
    { 0xef, 0xc0, 0xc0, 0x084 },
    { 0xf7, 0x60, 0x60, 0x004 },
    { 0x4c, 0x03, 0x00, 0x044 },
    { 0xbc, 0x25, 0x24, 0x004 },
    { 0x72, 0x60, 0x60, 0x004 },
    { 0xec, 0x02, 0x00, 0x044 },
    { 0x8f, 0x51, 0x01, 0x000 },
    { 0x96, 0x8f, 0x86, 0x080 },
    { 0xb8, 0x88, 0x88, 0x084 },
    { 0x17, 0xb0, 0x10, 0x000 },
    { 0x4d, 0x42, 0x40, 0x000 },
    { 0xbd, 0x3d, 0x3d, 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 },
    { 0x0f65, 0x0057, 0x0045, 0x000 },
    { 0x0b22, 0x15c6, 0x0102, 0x000 },
    { 0x81c1, 0xc3cf, 0x81c1, 0x080 },
    { 0x0002, 0x005c, 0x0000, 0x044 },
    { 0x749c, 0xd725, 0x5404, 0x000 },
    { 0xf641, 0x460f, 0x4601, 0x000 },
    { 0x0f9f, 0x01f1, 0x0191, 0x000 },
    { 0xc38a, 0xa828, 0x8008, 0x080 },
    { 0x1591, 0xe36e, 0x0100, 0x004 },
    { 0x0013, 0x0024, 0x0000, 0x044 },
    { 0x868c, 0x6fa3, 0x0680, 0x000 },
    { 0x5ad4, 0x4e72, 0x4a50, 0x004 },
    { 0x002f, 0x0016, 0x0006, 0x004 },
    { 0xa3cc, 0xab6b, 0xa348, 0x084 },
    { 0x2e9b, 0xd54c, 0x0408, 0x000 },
    { 0x345e, 0x0397, 0x0016, 0x000 },
    { 0xfa0e, 0xc2bc, 0xc20c, 0x084 },
    { 0xf19f, 0x0a93, 0x0093, 0x004 },
    { 0x0e32, 0x07bf, 0x0632, 0x000 },
    { 0xc69a, 0xda07, 0xc202, 0x080 },
    { 0x33ca, 0x1393, 0x1382, 0x004 },
    { 0x0057, 0x0008, 0x0000, 0x044 },
    { 0x1a92, 0x923e, 0x1212, 0x004 },
    { 0x2b53, 0x7eff, 0x2a53, 0x004 },
    { 0x0269, 0x001a, 0x0008, 0x000 },
    { 0x5c4d, 0xe37b, 0x4049, 0x000 },
    { 0xbfc1, 0x399a, 0x3980, 0x000 },
    { 0x000e, 0x2245, 0x0004, 0x000 },
    { 0x3781, 0x2c37, 0x2401, 0x000 },
    /* r/m16, imm8: */
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x084 },
    { 0x0000, 0xffff, 0x0000, 0x044 },
    { 0x00bf, 0x001d, 0x001d, 0x004 },
    { 0x3d65, 0x0006, 0x0004, 0x000 },
    { 0xe530, 0xffc1, 0xe500, 0x084 },
    { 0x0001, 0xff97, 0x0001, 0x000 },
    { 0x3a11, 0x003b, 0x0011, 0x004 },
    { 0x4a79, 0xffb1, 0x4a31, 0x000 },
    { 0x122b, 0x004b, 0x000b, 0x000 },
    { 0xc589, 0xffe8, 0xc588, 0x084 },
    { 0x51c3, 0x0077, 0x0043, 0x000 },
    { 0x0056, 0xff93, 0x0012, 0x004 },
    { 0xce01, 0x0033, 0x0001, 0x000 },
    { 0xa7f3, 0xffbc, 0xa7b0, 0x080 },
    { 0x0012, 0xffe2, 0x0002, 0x000 },
    { 0x851f, 0xffc9, 0x8509, 0x084 },
    { 0x81ab, 0xff86, 0x8182, 0x084 },
    { 0x0032, 0x0077, 0x0032, 0x000 },
    { 0xcea9, 0xffbb, 0xcea9, 0x084 },
    { 0x724e, 0x0019, 0x0008, 0x000 },
    { 0x3625, 0xff9f, 0x3605, 0x004 },
    { 0xcecc, 0x004b, 0x0048, 0x004 },
    { 0x3b3a, 0xffbe, 0x3b3a, 0x004 },
    { 0x01fd, 0xff8b, 0x0189, 0x000 },
    { 0xf56a, 0xfffa, 0xf56a, 0x084 },
    { 0xf641, 0xff89, 0xf601, 0x080 },
    { 0x001b, 0x0054, 0x0010, 0x000 },
    { 0x09ae, 0xffac, 0x09ac, 0x004 },
    { 0xc08a, 0xff97, 0xc082, 0x084 },
    { 0x07a9, 0x000d, 0x0009, 0x004 },
    { 0xbd14, 0x0073, 0x0010, 0x000 },
};

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 },
    { 0xdcaa4c16, 0x8fb7e023, 0x8ca24002, 0x080 },
    { 0x70dc21e4, 0x0435399f, 0x00142184, 0x004 },
    { 0x00a0f6cf, 0x04c7f9db, 0x0080f0cb, 0x000 },
    { 0x74e4d4c2, 0xdb4c4882, 0x50444082, 0x004 },
    { 0x2d2c7da1, 0x03ec0d06, 0x012c0d00, 0x004 },
    { 0xbe4b06ec, 0x6fb3b0ba, 0x2e0300a8, 0x000 },
    { 0x0860ed0c, 0x136ad3f3, 0x0060c100, 0x004 },
    { 0x00000145, 0x00000ee5, 0x00000045, 0x000 },
    { 0x43b67d7c, 0x41e859cb, 0x41a05948, 0x004 },
    { 0xbd5f403a, 0xf871e023, 0xb8514022, 0x084 },
    { 0x7c32579b, 0xcd15c0d0, 0x4c104090, 0x004 },
    { 0xcf25bf39, 0xb72d5fc7, 0x87251f01, 0x080 },
    { 0x00004594, 0x0030a574, 0x00000514, 0x004 },
    { 0x02fe6d69, 0x0dc12adb, 0x00c02849, 0x000 },
    { 0xc4e4b7be, 0xc3db3e48, 0xc0c03608, 0x080 },
    { 0xeed5eaf2, 0x5b122266, 0x4a102262, 0x000 },
    { 0x0390646c, 0xfcb1111b, 0x00900008, 0x000 },
    { 0x051eee89, 0x00012655, 0x00002601, 0x000 },
    { 0xb7a5a097, 0xdad256df, 0x92800097, 0x080 },
    { 0x6745583a, 0xb9a37ccd, 0x21015808, 0x000 },
    { 0x5c56b51e, 0x008cf3ee, 0x0004b10e, 0x000 },
    { 0xe5e2af5d, 0xc56736ed, 0xc562264d, 0x084 },
    { 0x00001907, 0x038d883c, 0x00000804, 0x000 },
    { 0x9425993e, 0xf06fe09a, 0x9025801a, 0x080 },
    { 0x8102d821, 0xe1bb7fdf, 0x81025801, 0x080 },
    { 0x5cc81ac6, 0x9555cbed, 0x14400ac4, 0x000 },
    { 0x73bf3f8c, 0x50e51ade, 0x50a51a8c, 0x000 },
    { 0x00009ea2, 0x12e90c40, 0x00000c00, 0x004 },
    { 0x222378b0, 0x06c87c52, 0x02007810, 0x000 },
    { 0xa4c32484, 0x479268f7, 0x04822084, 0x004 },
    { 0x9d293403, 0xfc15bfe9, 0x9c013401, 0x080 },
    { 0xf7ea99a3, 0x4b0cd9d6, 0x43089982, 0x004 },
    { 0x000005bc, 0x00001f1f, 0x0000051c, 0x000 },
    /* r/m32, imm8: */
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x084 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x044 },
    { 0x3e3092e9, 0xffffffb8, 0x3e3092a8, 0x000 },
    { 0x3c625d07, 0xffffff89, 0x3c625d01, 0x000 },
    { 0x0000fae0, 0x00000021, 0x00000020, 0x000 },
    { 0x44f5f433, 0xffffffa3, 0x44f5f423, 0x000 },
    { 0xc0929b7f, 0x00000024, 0x00000024, 0x004 },
    { 0xad7c715e, 0xffffffa6, 0xad7c7106, 0x084 },
    { 0x2e65b4a9, 0x0000000b, 0x00000009, 0x004 },
    { 0x000002cf, 0xffffffd0, 0x000002c0, 0x004 },
    { 0x94db9a3f, 0xffffff9f, 0x94db9a1f, 0x080 },
    { 0x8f81f4d0, 0xffffffa4, 0x8f81f480, 0x080 },
    { 0xb2b8cad3, 0x0000004b, 0x00000043, 0x000 },
    { 0x2a1211a9, 0xffffffa6, 0x2a1211a0, 0x004 },
    { 0x01234691, 0x0000005c, 0x00000010, 0x000 },
    { 0x45a89330, 0x0000000a, 0x00000000, 0x044 },
    { 0x5855187f, 0x00000027, 0x00000027, 0x004 },
    { 0x65714f90, 0xfffffff7, 0x65714f90, 0x004 },
    { 0xbb6a78a9, 0xffffffb8, 0xbb6a78a8, 0x080 },
    { 0x0005f034, 0xffffff9a, 0x0005f010, 0x000 },
    { 0xe452b8dc, 0xfffffff8, 0xe452b8d8, 0x084 },
    { 0xc4dc1eb7, 0xffffffdf, 0xc4dc1e97, 0x080 },
    { 0xcfcc065e, 0x0000006c, 0x0000004c, 0x000 },
    { 0x4d2b3baa, 0x0000007a, 0x0000002a, 0x000 },
    { 0x0000f3de, 0x00000065, 0x00000044, 0x004 },
    { 0x5441c335, 0xffffffca, 0x5441c300, 0x004 },
    { 0x0186040a, 0x00000021, 0x00000000, 0x044 },
    { 0x150e7c26, 0xffffff96, 0x150e7c06, 0x004 },
    { 0x454c8934, 0x00000077, 0x00000034, 0x000 },
    { 0x000014fb, 0xffffff83, 0x00001483, 0x000 },
    { 0x1ed16bf2, 0xffffffac, 0x1ed16ba0, 0x004 },
    { 0xd5f534a1, 0xffffffae, 0xd5f534a0, 0x084 },
    { 0x9c400896, 0x0000002a, 0x00000002, 0x000 },
    { 0xf3c077d1, 0xffffffb5, 0xf3c07791, 0x080 },
    { 0x00000380, 0xffffffbe, 0x00000380, 0x000 },
};

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 },
    { 0x6a, 0x5c, 0x7e, 0x004 },
    { 0xa7, 0x3e, 0xbf, 0x080 },
    { 0x54, 0xbf, 0xff, 0x084 },
    { 0x08, 0x30, 0x38, 0x000 },
    { 0x22, 0x7d, 0x7f, 0x000 },
    { 0x62, 0xeb, 0xeb, 0x084 },
    { 0xd2, 0xa4, 0xf6, 0x084 },
    { 0x68, 0xe5, 0xed, 0x084 },
    { 0x28, 0x1c, 0x3c, 0x004 },
    { 0x9c, 0x48, 0xdc, 0x080 },
    { 0x41, 0x42, 0x43, 0x000 },
    { 0xe8, 0x4b, 0xeb, 0x084 },
    { 0x77, 0xbb, 0xff, 0x084 },
    { 0x74, 0x4f, 0x7f, 0x000 },
    { 0x0c, 0x40, 0x4c, 0x000 },
    { 0x46, 0xf6, 0xf6, 0x084 },
    { 0xc6, 0xdb, 0xdf, 0x080 },
    { 0xc9, 0xe5, 0xed, 0x084 },
    { 0xc2, 0x03, 0xc3, 0x084 },
    { 0xb3, 0x36, 0xb7, 0x084 },
    { 0xf1, 0xe3, 0xf3, 0x084 },
    { 0x11, 0x7d, 0x7d, 0x004 },
    { 0x64, 0xb5, 0xf5, 0x084 },
    { 0x53, 0x5b, 0x5b, 0x000 },
    { 0xa6, 0x44, 0xe6, 0x080 },
    { 0xc7, 0x32, 0xf7, 0x080 },
    { 0x52, 0x62, 0x72, 0x004 },
    { 0xf5, 0xbc, 0xfd, 0x080 },
    { 0xdf, 0x1a, 0xdf, 0x080 },
};

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 },
    { 0x008a, 0x0027, 0x00af, 0x004 },
    { 0x6584, 0xc56d, 0xe5ed, 0x084 },
    { 0x8a09, 0x8e20, 0x8e29, 0x080 },
    { 0x036a, 0x0064, 0x036e, 0x000 },
    { 0x998c, 0xd4e8, 0xddec, 0x080 },
    { 0xe09a, 0xb817, 0xf89f, 0x084 },
    { 0x005a, 0x000d, 0x005f, 0x004 },
    { 0x8278, 0xb7e9, 0xb7f9, 0x084 },
    { 0x3712, 0x883d, 0xbf3f, 0x084 },
    { 0x0197, 0x008e, 0x019f, 0x004 },
    { 0x43f4, 0x7398, 0x73fc, 0x004 },
    { 0x3cd8, 0xba8c, 0xbedc, 0x080 },
    { 0x0091, 0x0031, 0x00b1, 0x004 },
    { 0xe4f9, 0xd504, 0xf5fd, 0x080 },
    { 0x0890, 0x5916, 0x5996, 0x004 },
    { 0x61b0, 0x001a, 0x61ba, 0x000 },
    { 0x217f, 0x1a6a, 0x3b7f, 0x000 },
    { 0x5173, 0x7589, 0x75fb, 0x000 },
    { 0x0077, 0x00bb, 0x00ff, 0x004 },
    { 0x56d2, 0x0f99, 0x5fdb, 0x004 },
    { 0x0bd4, 0xa079, 0xabfd, 0x080 },
    { 0x00a1, 0x75de, 0x75ff, 0x004 },
    { 0x664f, 0xe271, 0xe67f, 0x080 },
    { 0x7fc7, 0xe426, 0xffe7, 0x084 },
    { 0x0287, 0x003e, 0x02bf, 0x000 },
    { 0x43c7, 0xfa75, 0xfbf7, 0x080 },
    { 0x5003, 0x0457, 0x5457, 0x000 },
    { 0x0024, 0x0762, 0x0766, 0x004 },
    { 0x4d08, 0x65b0, 0x6db8, 0x004 },
    /* r/m16, imm8: */
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x084 },
    { 0x0000, 0xffff, 0xffff, 0x084 },
    { 0x076a, 0x0022, 0x076a, 0x004 },
    { 0xefe0, 0xffc1, 0xffe1, 0x084 },
    { 0x6105, 0x003f, 0x613f, 0x004 },
    { 0x09f6, 0xffb8, 0xfffe, 0x080 },
    { 0x2f1f, 0xfffe, 0xffff, 0x084 },
    { 0x584b, 0x0006, 0x584f, 0x000 },
    { 0x000b, 0xffb4, 0xffbf, 0x080 },
    { 0x394c, 0x0060, 0x396c, 0x004 },
    { 0x16db, 0x0004, 0x16df, 0x000 },
    { 0x7cfa, 0x001f, 0x7cff, 0x004 },
    { 0x22c5, 0x000c, 0x22cd, 0x000 },
    { 0x561f, 0x000a, 0x561f, 0x000 },
    { 0x0f97, 0xffeb, 0xffff, 0x084 },
    { 0x5f13, 0xffea, 0xfffb, 0x080 },
    { 0x709b, 0xff94, 0xff9f, 0x084 },
    { 0x04be, 0xfff7, 0xffff, 0x084 },
    { 0xbaff, 0xffab, 0xffff, 0x084 },
    { 0xbeaf, 0xffd3, 0xffff, 0x084 },
    { 0x001a, 0x0001, 0x001b, 0x004 },
    { 0x2263, 0x003d, 0x227f, 0x000 },
    { 0xfbba, 0x0072, 0xfbfa, 0x084 },
    { 0x1067, 0x0026, 0x1067, 0x000 },
    { 0xef5b, 0x000b, 0xef5b, 0x080 },
    { 0xa0ca, 0xfff4, 0xfffe, 0x080 },
    { 0x6cd6, 0xff98, 0xffde, 0x084 },
    { 0xec3e, 0xffff, 0xffff, 0x084 },
    { 0x7f35, 0xfff8, 0xfffd, 0x080 },
    { 0x05ee, 0x001b, 0x05ff, 0x004 },
    { 0x8c57, 0xff94, 0xffd7, 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 },
    { 0x1537eae5, 0x0a1e6b45, 0x1f3febe5, 0x000 },
    { 0x53148433, 0x27f35ae1, 0x77f7def3, 0x004 },
    { 0x00006de7, 0x0001c217, 0x0001eff7, 0x000 },
    { 0xdffda5ba, 0x058b66be, 0xdfffe7be, 0x084 },
    { 0x4306679d, 0x997c96cb, 0xdb7ef7df, 0x080 },
    { 0x82901753, 0x81eb4b75, 0x83fb5f77, 0x084 },
    { 0xbea71022, 0x8a144850, 0xbeb75872, 0x084 },
    { 0x0218b85f, 0x00c57502, 0x02ddfd5f, 0x004 },
    { 0x278505e3, 0x8e458e5a, 0xafc58ffb, 0x080 },
    { 0xf884be07, 0x52d7fb61, 0xfad7ff67, 0x080 },
    { 0x21b8c7c4, 0x6a4346fb, 0x6bfbc7ff, 0x004 },
    { 0x26e91e6a, 0x92cbd51b, 0xb6ebdf7b, 0x084 },
    { 0x0036ac7e, 0x00242d02, 0x0036ad7e, 0x004 },
    { 0xc1071ae6, 0x79771364, 0xf9771be6, 0x080 },
    { 0xb89a27b5, 0x90a4f91b, 0xb8beffbf, 0x080 },
    { 0x7ede6426, 0x3215e90d, 0x7edfed2f, 0x000 },
    { 0x7c776e2b, 0x04e1e810, 0x7cf7ee3b, 0x000 },
    { 0x00000d7a, 0x00009dc5, 0x00009dff, 0x004 },
    { 0x875e0ca4, 0x6f900796, 0xefde0fb6, 0x080 },
    { 0xd8e24212, 0x2e5fd954, 0xfeffdb56, 0x084 },
    { 0x96b55268, 0x1a355651, 0x9eb55679, 0x080 },
    { 0x23b5ed48, 0x3ced2448, 0x3ffded48, 0x004 },
    { 0x00163250, 0x00001b75, 0x00163b75, 0x000 },
    { 0x49b265b8, 0x5f3438d4, 0x5fb67dfc, 0x004 },
    { 0xdd7f1720, 0x02c765d4, 0xdfff77f4, 0x080 },
    { 0xb2c9956c, 0x50712054, 0xf2f9b57c, 0x080 },
    { 0x3301733a, 0xe4341fd2, 0xf7357ffa, 0x084 },
    { 0x0001c1f5, 0x00026a1a, 0x0003ebff, 0x004 },
    { 0x79cbe328, 0x38ae74bc, 0x79eff7bc, 0x000 },
    { 0xc572208a, 0x07b646d1, 0xc7f666db, 0x084 },
    { 0xcfe3474b, 0x525db5e6, 0xdffff7ef, 0x080 },
    { 0xc6513949, 0x7e87eadc, 0xfed7fbdd, 0x084 },
    { 0x0000027f, 0x0008e0a7, 0x0008e2ff, 0x004 },
    /* r/m32, imm8: */
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x084 },
    { 0x00000000, 0xffffffff, 0xffffffff, 0x084 },
    { 0x2f55062a, 0xffffff80, 0xffffffaa, 0x084 },
    { 0xa83147b9, 0x0000001f, 0xa83147bf, 0x080 },
    { 0x000190c3, 0x00000070, 0x000190f3, 0x004 },
    { 0x7937514a, 0xffffffa8, 0xffffffea, 0x080 },
    { 0xf1a3370b, 0xffffffa2, 0xffffffab, 0x080 },
    { 0xeed8c9f7, 0xfffffffb, 0xffffffff, 0x084 },
    { 0x0ae6b642, 0x00000078, 0x0ae6b67a, 0x000 },
    { 0x000001a1, 0xffffffc6, 0xffffffe7, 0x084 },
    { 0x47fb640b, 0x00000045, 0x47fb644f, 0x000 },
    { 0xca9274d4, 0xffffff8b, 0xffffffdf, 0x080 },
    { 0x555f2160, 0x00000069, 0x555f2169, 0x004 },
    { 0xdd98f1e7, 0xffffffb2, 0xfffffff7, 0x080 },
    { 0x0000014a, 0xffffffae, 0xffffffee, 0x084 },
    { 0xf7ab938d, 0xffffff88, 0xffffff8d, 0x084 },
    { 0x372478ab, 0xffffffa8, 0xffffffab, 0x080 },
    { 0xcb4a4de7, 0x0000007b, 0xcb4a4dff, 0x084 },
    { 0x472fdba1, 0xffffffb6, 0xffffffb7, 0x084 },
    { 0x00a68c52, 0x0000004a, 0x00a68c5a, 0x004 },
    { 0x6df2d60f, 0x0000005a, 0x6df2d65f, 0x004 },
    { 0xecb02c07, 0x0000007c, 0xecb02c7f, 0x080 },
    { 0xff8dd935, 0x0000002b, 0xff8dd93f, 0x084 },
    { 0x22699676, 0xffffffbd, 0xffffffff, 0x084 },
    { 0x00f14232, 0x0000005d, 0x00f1427f, 0x000 },
    { 0x90ee6642, 0xffffff90, 0xffffffd2, 0x084 },
    { 0x996a78c1, 0xffffffc3, 0xffffffc3, 0x084 },
    { 0xd9b05df7, 0x00000021, 0xd9b05df7, 0x080 },
    { 0xac98936f, 0x0000001c, 0xac98937f, 0x080 },
    { 0x0000d072, 0x00000017, 0x0000d077, 0x004 },
    { 0xe4f973ca, 0xffffffbc, 0xfffffffe, 0x080 },
    { 0x42cad5b7, 0xffffffa3, 0xffffffb7, 0x084 },
    { 0xb521cbdc, 0xffffff97, 0xffffffdf, 0x080 },
    { 0xa6510608, 0xffffffdf, 0xffffffdf, 0x080 },
    { 0x00013ce2, 0x00000042, 0x00013ce2, 0x004 },
};

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 },
    { 0x37, 0xdb, 0xec, 0x080 },
    { 0xf5, 0xf0, 0x05, 0x004 },
    { 0x1c, 0x1d, 0x01, 0x000 },
    { 0xa9, 0x51, 0xf8, 0x080 },
    { 0xca, 0x6f, 0xa5, 0x084 },
    { 0xa4, 0xb0, 0x14, 0x004 },
    { 0xab, 0x86, 0x2d, 0x004 },
    { 0xa3, 0xd6, 0x75, 0x000 },
    { 0xaf, 0x60, 0xcf, 0x084 },
    { 0x8f, 0x92, 0x1d, 0x004 },
    { 0xea, 0xcb, 0x21, 0x004 },
    { 0x4d, 0x27, 0x6a, 0x004 },
    { 0x68, 0xf4, 0x9c, 0x084 },
    { 0x8c, 0xb4, 0x38, 0x000 },
    { 0x98, 0x35, 0xad, 0x080 },
    { 0xaa, 0x4a, 0xe0, 0x080 },
    { 0xa5, 0x5d, 0xf8, 0x080 },
    { 0x03, 0xc1, 0xc2, 0x080 },
    { 0xca, 0x61, 0xab, 0x080 },
    { 0x50, 0xa4, 0xf4, 0x080 },
    { 0x3c, 0x47, 0x7b, 0x004 },
    { 0xa6, 0x49, 0xef, 0x080 },
    { 0xcb, 0xb6, 0x7d, 0x004 },
    { 0x81, 0x0f, 0x8e, 0x084 },
    { 0xe3, 0x13, 0xf0, 0x084 },
    { 0x84, 0xf6, 0x72, 0x004 },
    { 0x8e, 0x54, 0xda, 0x080 },
    { 0x65, 0xe8, 0x8d, 0x084 },
    { 0xc4, 0xd0, 0x14, 0x004 },
};

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 },
    { 0x0111, 0x11f7, 0x10e6, 0x000 },
    { 0x73ac, 0x35c8, 0x4664, 0x000 },
    { 0xf270, 0xc6b2, 0x34c2, 0x000 },
    { 0x005b, 0x008d, 0x00d6, 0x000 },
    { 0xbdc6, 0x3641, 0x8b87, 0x084 },
    { 0x21eb, 0xeda4, 0xcc4f, 0x080 },
    { 0x0085, 0x3230, 0x32b5, 0x000 },
    { 0xd2f3, 0x5e2b, 0x8cd8, 0x084 },
    { 0x6cbd, 0xee62, 0x82df, 0x080 },
    { 0x0018, 0x0069, 0x0071, 0x004 },
    { 0x955f, 0xb7ea, 0x22b5, 0x000 },
    { 0x8e71, 0xa1ce, 0x2fbf, 0x000 },
    { 0x0238, 0x02d6, 0x00ee, 0x004 },
    { 0xc97d, 0x6256, 0xab2b, 0x084 },
    { 0xfecf, 0xd107, 0x2fc8, 0x000 },
    { 0x1a1c, 0x0011, 0x1a0d, 0x000 },
    { 0x3fd9, 0xff85, 0xc05c, 0x084 },
    { 0x840b, 0x0ced, 0x88e6, 0x080 },
    { 0x0026, 0x1a4b, 0x1a6d, 0x000 },
    { 0x396a, 0x93ee, 0xaa84, 0x084 },
    { 0xf6c4, 0xc4ee, 0x322a, 0x000 },
    { 0x0694, 0x01b5, 0x0721, 0x004 },
    { 0x9c23, 0xfe38, 0x621b, 0x004 },
    { 0x18aa, 0x7599, 0x6d33, 0x004 },
    { 0x001d, 0x0047, 0x005a, 0x004 },
    { 0x8ed6, 0x92c3, 0x1c15, 0x000 },
    { 0x5ef0, 0xf1af, 0xaf5f, 0x084 },
    { 0x0063, 0x001a, 0x0079, 0x000 },
    { 0x9770, 0x496d, 0xde1d, 0x084 },
    /* r/m16, imm8: */
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0x0000, 0x044 },
    { 0x0000, 0xffff, 0xffff, 0x084 },
    { 0x0ba8, 0xffb5, 0xf41d, 0x084 },
    { 0x89e7, 0x004b, 0x89ac, 0x084 },
    { 0xaa95, 0xffcc, 0x5559, 0x004 },
    { 0x13de, 0x0039, 0x13e7, 0x004 },
    { 0xb957, 0xffb6, 0x46e1, 0x004 },
    { 0x9f70, 0x0006, 0x9f76, 0x080 },
    { 0x004f, 0x0034, 0x007b, 0x004 },
    { 0x7c8d, 0xffb8, 0x8335, 0x084 },
    { 0x7517, 0xffc4, 0x8ad3, 0x080 },
    { 0x005f, 0x0004, 0x005b, 0x000 },
    { 0x5b63, 0xff8e, 0xa4ed, 0x084 },
    { 0xeace, 0xff90, 0x155e, 0x000 },
    { 0x22dd, 0x0026, 0x22fb, 0x000 },
    { 0xcc92, 0xffb8, 0x332a, 0x000 },
    { 0xcef9, 0xff8e, 0x3177, 0x004 },
    { 0x0012, 0xffb5, 0xffa7, 0x080 },
    { 0x793f, 0x0048, 0x7977, 0x004 },
    { 0x5bde, 0x0005, 0x5bdb, 0x004 },
    { 0x0006, 0x006a, 0x006c, 0x004 },
    { 0x58e8, 0xfff6, 0xa71e, 0x084 },
    { 0x6c05, 0x005b, 0x6c5e, 0x000 },
    { 0x000f, 0xffdf, 0xffd0, 0x080 },
    { 0x2e75, 0x002f, 0x2e5a, 0x004 },
    { 0x850e, 0x0071, 0x857f, 0x080 },
    { 0x05d7, 0x007e, 0x05a9, 0x004 },
    { 0x82a1, 0x0041, 0x82e0, 0x080 },
    { 0x12a0, 0x0007, 0x12a7, 0x000 },
    { 0x002d, 0xff89, 0xffa4, 0x080 },
    { 0xc823, 0x0014, 0xc837, 0x080 },
};

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 },
    { 0xb48e3961, 0xa5592a3b, 0x11d7135a, 0x004 },
    { 0x00e3bb78, 0x2728e490, 0x27cb5fe8, 0x004 },
    { 0x00007288, 0x000000bd, 0x00007235, 0x004 },
    { 0x7293f058, 0x0e883b59, 0x7c1bcb01, 0x000 },
    { 0x11f05783, 0x30f42158, 0x210476db, 0x004 },
    { 0x6bb93183, 0x4b61c6b5, 0x20d8f736, 0x004 },
    { 0x403cbbbd, 0x5349756a, 0x1375ced7, 0x004 },
    { 0x05e70329, 0x0000cc4d, 0x05e7cf64, 0x000 },
    { 0x39cce9f9, 0x3c1518e7, 0x05d9f11e, 0x004 },
    { 0x0d162555, 0x28ed16fc, 0x25fb33a9, 0x004 },
    { 0x65803035, 0xc2dcfacf, 0xa75ccafa, 0x084 },
    { 0xf9d62d80, 0x91f6855e, 0x6820a8de, 0x004 },
    { 0x0000180e, 0x00006c3d, 0x00007433, 0x004 },
    { 0xc32eb877, 0xf0508e42, 0x337e3635, 0x004 },
    { 0x78abc8a9, 0x9602ec50, 0xeea924f9, 0x084 },
    { 0x59e8837a, 0xf00fcbdf, 0xa9e748a5, 0x084 },
    { 0x9d11d6f3, 0xbe36fa6d, 0x23272c9e, 0x000 },
    { 0x000003f3, 0x00000118, 0x000002eb, 0x004 },
    { 0x0b0a5163, 0x9265403e, 0x996f115d, 0x080 },
    { 0x355cd0b4, 0xa08a159e, 0x95d6c52a, 0x080 },
    { 0xc99148c2, 0x213fde49, 0xe8ae968b, 0x084 },
    { 0x334d8c11, 0x2826eb3a, 0x1b6b672b, 0x004 },
    { 0x001dc408, 0x0d304309, 0x0d2d8701, 0x000 },
    { 0xdb810aa2, 0x74e1409c, 0xaf604a3e, 0x080 },
    { 0x7058fdb6, 0x6278f159, 0x12200cef, 0x000 },
    { 0xf22d3c90, 0x37e34c7f, 0xc5ce70ef, 0x080 },
    { 0x2bb36356, 0x0e3eda57, 0x258db901, 0x000 },
    { 0x01a8124e, 0x01f20d86, 0x005a1fc8, 0x000 },
    { 0xda349a6a, 0xb385d36a, 0x69b14900, 0x004 },
    { 0x16faee93, 0xf44500ae, 0xe2bfee3d, 0x080 },
    { 0x9e2fba51, 0xcf712b52, 0x515e9103, 0x004 },
    { 0x8ed33d3d, 0x8e597765, 0x008a4a58, 0x000 },
    { 0x000018a9, 0x00000ea0, 0x00001609, 0x004 },
    /* r/m32, imm8: */
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0x00000000, 0x044 },
    { 0x00000000, 0xffffffff, 0xffffffff, 0x084 },
    { 0x95daca4b, 0x00000022, 0x95daca69, 0x084 },
    { 0x325f5bbe, 0xffffff9b, 0xcda0a425, 0x080 },
    { 0x07b60fa4, 0xffffffb3, 0xf849f017, 0x084 },
    { 0xd61e7477, 0xfffffff9, 0x29e18b8e, 0x004 },
    { 0x07716db0, 0xffffffa1, 0xf88e9211, 0x084 },
    { 0x26bcc576, 0xffffffab, 0xd9433add, 0x084 },
    { 0xba9a2bad, 0xffffffbd, 0x4565d410, 0x000 },
    { 0x0001d060, 0xffffffd5, 0xfffe2fb5, 0x080 },
    { 0xc8f15ed8, 0x0000007e, 0xc8f15ea6, 0x084 },
    { 0x64745cdb, 0x00000063, 0x64745cb8, 0x004 },
    { 0x8addb493, 0x0000004b, 0x8addb4d8, 0x084 },
    { 0xe25b5018, 0x0000001a, 0xe25b5002, 0x080 },
    { 0x00b0a3c8, 0xffffffb3, 0xff4f5c7b, 0x084 },
    { 0x619e8ab4, 0xffffffaa, 0x9e61751e, 0x084 },
    { 0xc8917155, 0xffffffab, 0x376e8efe, 0x000 },
    { 0x1b3295c3, 0xfffffffb, 0xe4cd6a38, 0x080 },
    { 0xfd8e1fdc, 0x00000016, 0xfd8e1fca, 0x084 },
    { 0x00001db2, 0x0000005a, 0x00001de8, 0x004 },
    { 0xc4d9db4d, 0x0000005d, 0xc4d9db10, 0x080 },
    { 0xe3b7fac3, 0xffffff87, 0x1c480544, 0x004 },
    { 0xa2b806f5, 0xffffffa1, 0x5d47f954, 0x000 },
    { 0x46312b2c, 0xffffffe1, 0xb9ced4cd, 0x080 },
    { 0x00002b55, 0xffffffe5, 0xffffd4b0, 0x080 },
    { 0x418ce6fa, 0xffffffb5, 0xbe73194f, 0x080 },
    { 0xdf9567fa, 0x0000001c, 0xdf9567e6, 0x080 },
    { 0xecc42d26, 0xffffff93, 0x133bd2b5, 0x000 },
    { 0x02fbac7c, 0x0000006b, 0x02fbac17, 0x004 },
    { 0x001d8e50, 0xffffffaa, 0xffe271fa, 0x084 },
    { 0x616d1738, 0xffffff80, 0x9e92e8b8, 0x084 },
    { 0xa4963dde, 0x00000069, 0xa4963db7, 0x084 },
    { 0x6043ab3a, 0x00000035, 0x6043ab0f, 0x004 },
    { 0x83a4e877, 0x00000052, 0x83a4e825, 0x080 },
    { 0x6326c055, 0x0000007a, 0x6326c02f, 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 },
    { 0x08, 0x2b, 0x08, 0x000 },
    { 0x3b, 0x92, 0x3b, 0x004 },
    { 0x60, 0x79, 0x60, 0x004 },
    { 0xa1, 0x04, 0xa1, 0x044 },
    { 0x35, 0xa9, 0x35, 0x004 },
    { 0x80, 0x02, 0x80, 0x044 },
    { 0x21, 0xf3, 0x21, 0x004 },
    { 0x7d, 0x45, 0x7d, 0x000 },
    { 0xce, 0x8f, 0xce, 0x084 },
    { 0x09, 0xd5, 0x09, 0x000 },
    { 0x6f, 0xd9, 0x6f, 0x000 },
    { 0xe9, 0x3d, 0xe9, 0x000 },
    { 0xcf, 0x3c, 0xcf, 0x004 },
    { 0x4e, 0xb1, 0x4e, 0x044 },
    { 0x4e, 0xfe, 0x4e, 0x004 },
    { 0x1c, 0xb4, 0x1c, 0x004 },
    { 0x00, 0xe6, 0x00, 0x044 },
    { 0x50, 0xb5, 0x50, 0x000 },
    { 0x46, 0xf4, 0x46, 0x004 },
    { 0x8b, 0x2a, 0x8b, 0x004 },
    { 0xb5, 0xf2, 0xb5, 0x080 },
    { 0x6d, 0x37, 0x6d, 0x000 },
    { 0x3e, 0x76, 0x3e, 0x004 },
    { 0x50, 0x40, 0x50, 0x000 },
    { 0xf8, 0xde, 0xf8, 0x084 },
    { 0x1a, 0x1d, 0x1a, 0x004 },
    { 0x93, 0x4e, 0x93, 0x000 },
    { 0x26, 0x52, 0x26, 0x000 },
    { 0xe5, 0xb4, 0xe5, 0x080 },
};

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 },
    { 0x007b, 0x29ad, 0x007b, 0x000 },
    { 0xf7d1, 0xd664, 0xf7d1, 0x080 },
    { 0x4dc8, 0xb0e2, 0x4dc8, 0x004 },
    { 0x0010, 0x00e8, 0x0010, 0x044 },
    { 0xfdbf, 0x095b, 0xfdbf, 0x004 },
    { 0x68d5, 0xa293, 0x68d5, 0x000 },
    { 0x0006, 0x0ee2, 0x0006, 0x000 },
    { 0xf2b9, 0x8a7d, 0xf2b9, 0x084 },
    { 0x4e16, 0x87cd, 0x4e16, 0x000 },
    { 0x0090, 0x03fb, 0x0090, 0x004 },
    { 0x550e, 0x29ac, 0x550e, 0x004 },
    { 0xf457, 0x7e50, 0xf457, 0x004 },
    { 0x12d1, 0x1f5b, 0x12d1, 0x000 },
    { 0xcbda, 0x8a59, 0xcbda, 0x080 },
    { 0x0c37, 0x07e5, 0x0c37, 0x000 },
    { 0x04ca, 0x0028, 0x04ca, 0x000 },
    { 0x504a, 0x3725, 0x504a, 0x004 },
    { 0x63e7, 0x0597, 0x63e7, 0x004 },
    { 0x0004, 0x0527, 0x0004, 0x000 },
    { 0x80d3, 0x9cbc, 0x80d3, 0x084 },
    { 0x10e5, 0x58c4, 0x10e5, 0x000 },
    { 0x0242, 0x000b, 0x0242, 0x000 },
    { 0x2053, 0x5d3a, 0x2053, 0x004 },
    { 0x9389, 0x38a1, 0x9389, 0x004 },
    { 0x0028, 0x3e4c, 0x0028, 0x000 },
    { 0x29e7, 0x180e, 0x29e7, 0x004 },
    { 0x7aaf, 0xa89f, 0x7aaf, 0x000 },
    { 0x0075, 0x03f9, 0x0075, 0x004 },
    { 0x6b9c, 0xff61, 0x6b9c, 0x004 },
    /* r/m16, imm8: */
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x084 },
    { 0x0000, 0xffff, 0x0000, 0x044 },
    { 0x0039, 0xffc5, 0x0039, 0x000 },
    { 0x72ff, 0xffd0, 0x72ff, 0x000 },
    { 0xd645, 0x000c, 0xd645, 0x000 },
    { 0x15f0, 0x0043, 0x15f0, 0x000 },
    { 0xa11d, 0xffc7, 0xa11d, 0x084 },
    { 0x5301, 0x0044, 0x5301, 0x044 },
    { 0x0003, 0x001e, 0x0003, 0x000 },
    { 0x1467, 0xff8d, 0x1467, 0x004 },
    { 0xd7c3, 0xffa7, 0xd7c3, 0x080 },
    { 0x009d, 0x0066, 0x009d, 0x000 },
    { 0xc35d, 0xffbe, 0xc35d, 0x080 },
    { 0x9756, 0xff96, 0x9756, 0x080 },
    { 0x003f, 0x0022, 0x003f, 0x004 },
    { 0xacef, 0xffff, 0xacef, 0x080 },
    { 0xd362, 0x0065, 0xd362, 0x004 },
    { 0x0197, 0xfff0, 0x0197, 0x004 },
    { 0x95b3, 0x0043, 0x95b3, 0x004 },
    { 0x7c9e, 0xffe8, 0x7c9e, 0x004 },
    { 0x00e2, 0x0066, 0x00e2, 0x000 },
    { 0xab64, 0xff8c, 0xab64, 0x080 },
    { 0xf96e, 0x005d, 0xf96e, 0x000 },
    { 0x1c01, 0xffe4, 0x1c01, 0x004 },
    { 0x58a3, 0x0071, 0x58a3, 0x004 },
    { 0xc019, 0x0002, 0xc019, 0x044 },
    { 0x012e, 0xffb0, 0x012e, 0x000 },
    { 0x599d, 0xffb9, 0x599d, 0x004 },
    { 0xa101, 0x001e, 0xa101, 0x044 },
    { 0x5de0, 0x0076, 0x5de0, 0x004 },
    { 0x4803, 0xffad, 0x4803, 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 },
    { 0xbf415e4e, 0xe1d89b1a, 0xbf415e4e, 0x084 },
    { 0x13aefa25, 0x44a8be0f, 0x13aefa25, 0x004 },
    { 0x00000623, 0x0005efa2, 0x00000623, 0x004 },
    { 0x1ce7b0dc, 0xaf0c6b2a, 0x1ce7b0dc, 0x000 },
    { 0x984fcb5b, 0x1eafcfd5, 0x984fcb5b, 0x000 },
    { 0x6875b8b0, 0xc8b03f90, 0x6875b8b0, 0x004 },
    { 0xab1d2c38, 0x084226a5, 0xab1d2c38, 0x000 },
    { 0x000bda8f, 0x001cbae8, 0x000bda8f, 0x004 },
    { 0x7932ec7b, 0xbe439c93, 0x7932ec7b, 0x000 },
    { 0xc8dc96d4, 0xca325dab, 0xc8dc96d4, 0x080 },
    { 0xc0ec4897, 0x1891b1fa, 0xc0ec4897, 0x000 },
    { 0x853ba0b0, 0x4db2857f, 0x853ba0b0, 0x004 },
    { 0x0045b004, 0x000f1f11, 0x0045b004, 0x004 },
    { 0x62b0bc63, 0x41203a33, 0x62b0bc63, 0x000 },
    { 0x2acd0bac, 0xfbb95f27, 0x2acd0bac, 0x004 },
    { 0x471638e6, 0x03f1a880, 0x471638e6, 0x000 },
    { 0x6e6d6d85, 0x52316f66, 0x6e6d6d85, 0x000 },
    { 0x00000972, 0x0225b6ed, 0x00000972, 0x004 },
    { 0x2a0cabbd, 0xa5df1adc, 0x2a0cabbd, 0x004 },
    { 0x5a5c74f0, 0x100b40bd, 0x5a5c74f0, 0x000 },
    { 0x52c76159, 0xdfc823b0, 0x52c76159, 0x000 },
    { 0x4c9f28f0, 0xe538cbdc, 0x4c9f28f0, 0x000 },
    { 0x00004528, 0x00000266, 0x00004528, 0x000 },
    { 0x2b9b46e1, 0xdf4a7424, 0x2b9b46e1, 0x000 },
    { 0x910f185c, 0x360848c3, 0x910f185c, 0x000 },
    { 0x19e136bf, 0x10d142df, 0x19e136bf, 0x004 },
    { 0x1a7d4719, 0x96c6c7e5, 0x1a7d4719, 0x000 },
    { 0x00010864, 0x0f56d166, 0x00010864, 0x000 },
    { 0x51dfe0e1, 0x0124fdc5, 0x51dfe0e1, 0x000 },
    { 0x2390b1ec, 0x70913005, 0x2390b1ec, 0x000 },
    { 0x4be7b12c, 0xd820c5cf, 0x4be7b12c, 0x004 },
    { 0x8f9aa569, 0x71e1987f, 0x8f9aa569, 0x004 },
    { 0x0b12223a, 0x000001c4, 0x0b12223a, 0x044 },
    /* r/m32, imm8: */
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x084 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x044 },
    { 0x418d4e22, 0xffffffcd, 0x418d4e22, 0x004 },
    { 0x72c5a234, 0x00000006, 0x72c5a234, 0x000 },
    { 0x00000252, 0x00000006, 0x00000252, 0x000 },
    { 0xfedcf426, 0xffffffdb, 0xfedcf426, 0x080 },
    { 0x85c6661e, 0xffffff88, 0x85c6661e, 0x080 },
    { 0xe0bf655d, 0x00000076, 0xe0bf655d, 0x000 },
    { 0xc1323a4a, 0xffffffb6, 0xc1323a4a, 0x080 },
    { 0x00265a4b, 0xffffffc6, 0x00265a4b, 0x004 },
    { 0xb612813d, 0x0000005a, 0xb612813d, 0x004 },
    { 0xc13969e3, 0xffffff89, 0xc13969e3, 0x084 },
    { 0x256073f5, 0xfffffffe, 0x256073f5, 0x000 },
    { 0x0dcb489b, 0x00000003, 0x0dcb489b, 0x004 },
    { 0x07adc786, 0x0000002d, 0x07adc786, 0x000 },
    { 0x8d3ee1a2, 0x00000079, 0x8d3ee1a2, 0x000 },
    { 0xb67b24f0, 0x00000055, 0xb67b24f0, 0x004 },
    { 0x6081d6fe, 0x00000031, 0x6081d6fe, 0x004 },
    { 0x69f6b181, 0xffffffdd, 0x69f6b181, 0x004 },
    { 0x0019d481, 0x00000029, 0x0019d481, 0x000 },
    { 0x381c2a4a, 0x0000000d, 0x381c2a4a, 0x000 },
    { 0x355601e0, 0x0000007b, 0x355601e0, 0x004 },
    { 0x0aa88876, 0x00000044, 0x0aa88876, 0x004 },
    { 0x74093849, 0x00000023, 0x74093849, 0x000 },
    { 0x00002df8, 0xffffff8c, 0x00002df8, 0x004 },
    { 0x6bb5bbdb, 0x0000001b, 0x6bb5bbdb, 0x004 },
    { 0x19e27415, 0xffffffcd, 0x19e27415, 0x004 },
    { 0x91dcc845, 0xffffffff, 0x91dcc845, 0x080 },
    { 0xdaaac6ce, 0xffffffe3, 0xdaaac6ce, 0x080 },
    { 0x7a191c50, 0xfffffffc, 0x7a191c50, 0x004 },
    { 0x54922796, 0x00000067, 0x54922796, 0x004 },
    { 0x74a7f2fb, 0xffffff92, 0x74a7f2fb, 0x000 },
    { 0x3c52d92c, 0xffffffa4, 0x3c52d92c, 0x004 },
    { 0xa1e9bbdb, 0xffffff82, 0xa1e9bbdb, 0x084 },
    { 0x01e67cdf, 0xffffffdc, 0x01e67cdf, 0x000 },
};

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 },
    { 0x7f, 0xfc, 0x7b, 0x015 },
    { 0x50, 0x6a, 0xba, 0x880 },
    { 0x48, 0xd8, 0x20, 0x011 },
    { 0x28, 0x58, 0x80, 0x890 },
    { 0x9e, 0x3c, 0xda, 0x090 },
    { 0xb1, 0xbd, 0x6e, 0x801 },
    { 0x7a, 0x42, 0xbc, 0x880 },
    { 0xfd, 0xd6, 0xd3, 0x091 },
    { 0xd0, 0x39, 0x09, 0x005 },
    { 0x18, 0x8d, 0xa5, 0x094 },
    { 0xd9, 0x68, 0x41, 0x015 },
    { 0x7b, 0x9a, 0x15, 0x011 },
    { 0x53, 0xf2, 0x45, 0x001 },
    { 0x82, 0x46, 0xc8, 0x080 },
    { 0x3e, 0x93, 0xd1, 0x094 },
    { 0x21, 0xa9, 0xca, 0x084 },
    { 0xff, 0x3e, 0x3d, 0x011 },
    { 0x42, 0x45, 0x87, 0x884 },
    { 0x1b, 0x2e, 0x49, 0x010 },
    { 0xcc, 0x48, 0x14, 0x015 },
    { 0xc7, 0x84, 0x4b, 0x805 },
    { 0x81, 0x9f, 0x20, 0x811 },
    { 0x34, 0xcd, 0x01, 0x011 },
    { 0xda, 0x87, 0x61, 0x811 },
    { 0x46, 0xa2, 0xe8, 0x084 },
    { 0xa0, 0xbf, 0x5f, 0x805 },
    { 0xd9, 0xdd, 0xb6, 0x091 },
    { 0xfa, 0x17, 0x11, 0x015 },
    { 0x5e, 0x8e, 0xec, 0x090 },
};

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 },
    { 0x0069, 0x03a7, 0x0410, 0x010 },
    { 0x85ee, 0xcdb6, 0x53a4, 0x811 },
    { 0x7015, 0xa449, 0x145e, 0x001 },
    { 0x0dcf, 0x0098, 0x0e67, 0x010 },
    { 0xc85a, 0x97ae, 0x6008, 0x811 },
    { 0x24c5, 0x12a9, 0x376e, 0x000 },
    { 0x1c9d, 0x070d, 0x23aa, 0x014 },
    { 0x964e, 0xf598, 0x8be6, 0x091 },
    { 0xe89e, 0xfc9b, 0xe539, 0x095 },
    { 0x0001, 0x03c8, 0x03c9, 0x004 },
    { 0xe546, 0x6fb6, 0x54fc, 0x005 },
    { 0x4d53, 0xa17a, 0xeecd, 0x080 },
    { 0x0021, 0x38b5, 0x38d6, 0x000 },
    { 0xb7c5, 0x075d, 0xbf22, 0x094 },
    { 0x6c2f, 0x947d, 0x00ac, 0x015 },
    { 0x001c, 0x000e, 0x002a, 0x010 },
    { 0x69af, 0x7ed2, 0xe881, 0x894 },
    { 0x3f8c, 0x41dc, 0x8168, 0x890 },
    { 0x3470, 0x0327, 0x3797, 0x000 },
    { 0xa2db, 0x055a, 0xa835, 0x094 },
    { 0x72ad, 0xee14, 0x60c1, 0x011 },
    { 0x097f, 0x004a, 0x09c9, 0x014 },
    { 0xa8a5, 0x01d1, 0xaa76, 0x080 },
    { 0x4492, 0x0077, 0x4509, 0x004 },
    { 0x39d2, 0x0015, 0x39e7, 0x004 },
    { 0xde2d, 0x9888, 0x76b5, 0x811 },
    { 0x3461, 0xd31e, 0x077f, 0x001 },
    { 0x0032, 0x1297, 0x12c9, 0x004 },
    { 0x5021, 0xaa97, 0xfab8, 0x084 },
    /* r/m16, imm8: */
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xfffe, 0x091 },
    { 0x0000, 0xffff, 0xffff, 0x084 },
    { 0x000e, 0x000d, 0x001b, 0x014 },
    { 0x6e89, 0xfffb, 0x6e84, 0x015 },
    { 0x61b7, 0xffc3, 0x617a, 0x001 },
    { 0x003e, 0xff81, 0xffbf, 0x080 },
    { 0x65e8, 0xfff9, 0x65e1, 0x015 },
    { 0x207c, 0xff9d, 0x2019, 0x011 },
    { 0x0017, 0x006e, 0x0085, 0x010 },
    { 0xc89b, 0xffa5, 0xc840, 0x091 },
    { 0xd9be, 0x0073, 0xda31, 0x090 },
    { 0x003e, 0xff89, 0xffc7, 0x090 },
    { 0x2341, 0xffee, 0x232f, 0x001 },
    { 0x3a2f, 0xffea, 0x3a19, 0x011 },
    { 0x0027, 0xffd9, 0x0000, 0x055 },
    { 0x11b1, 0xff95, 0x1146, 0x001 },
    { 0x1836, 0x006a, 0x18a0, 0x014 },
    { 0x1f0b, 0xff86, 0x1e91, 0x011 },
    { 0xba77, 0xfff7, 0xba6e, 0x081 },
    { 0xc21e, 0x0000, 0xc21e, 0x084 },
    { 0x7fc5, 0x0059, 0x801e, 0x884 },
    { 0xda39, 0xffc9, 0xda02, 0x091 },
    { 0xe38c, 0x007d, 0xe409, 0x094 },
    { 0x000d, 0xffed, 0xfffa, 0x094 },
    { 0xc3f6, 0xffc2, 0xc3b8, 0x085 },
    { 0x4105, 0x0043, 0x4148, 0x004 },
    { 0x09ae, 0xff95, 0x0943, 0x011 },
    { 0xc98b, 0xffea, 0xc975, 0x091 },
    { 0xfe25, 0xffaa, 0xfdcf, 0x085 },
    { 0x0c51, 0xffa6, 0x0bf7, 0x001 },
    { 0x635d, 0x0022, 0x637f, 0x000 },
};

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 },
    { 0x4f935ff9, 0x5481dc6c, 0xa4153c65, 0x894 },
    { 0x59ae40f8, 0x7f2b87c7, 0xd8d9c8bf, 0x880 },
    { 0x0003132d, 0x000005bb, 0x000318e8, 0x014 },
    { 0x2ce8dd6a, 0x2c20712e, 0x59094e98, 0x010 },
    { 0xc5e6ba77, 0xeedbfe7b, 0xb4c2b8f2, 0x091 },
    { 0xa5be5cfb, 0x34ca96ec, 0xda88f3e7, 0x094 },
    { 0xa07a7b07, 0x89233a0d, 0x299db514, 0x815 },
    { 0x00000298, 0x00e2051e, 0x00e207b6, 0x010 },
    { 0xa7be0906, 0xad429e1f, 0x5500a725, 0x811 },
    { 0xb09b3d43, 0x1fd312a3, 0xd06e4fe6, 0x080 },
    { 0x1a6c9ba7, 0x105f1f52, 0x2acbbaf9, 0x004 },
    { 0x550148e3, 0x87585aae, 0xdc59a391, 0x090 },
    { 0x258f3db5, 0x000000a4, 0x258f3e59, 0x004 },
    { 0x71f229dc, 0x119a4422, 0x838c6dfe, 0x880 },
    { 0x66ef1d35, 0x5c66968b, 0xc355b3c0, 0x894 },
    { 0xd3258e3e, 0x069d9244, 0xd9c32082, 0x094 },
    { 0x92edb1c0, 0xf330dec8, 0x861e9088, 0x085 },
    { 0x0051f0e0, 0x0032ffd0, 0x0084f0b0, 0x000 },
    { 0x2fb8cdc4, 0x8dcd3829, 0xbd8605ed, 0x084 },
    { 0xdc2233a6, 0xc96d068b, 0xa58f3a31, 0x091 },
    { 0x94c8b556, 0x42a811c2, 0xd770c718, 0x084 },
    { 0x2825d8ea, 0x8cc42011, 0xb4e9f8fb, 0x080 },
    { 0x0009ebc9, 0x000dfbdd, 0x0017e7a6, 0x014 },
    { 0xdc92960c, 0x5bb91d4f, 0x384bb35b, 0x011 },
    { 0x56333bc1, 0x7d980749, 0xd3cb430a, 0x884 },
    { 0x88068a0a, 0x25509aa3, 0xad5724ad, 0x080 },
    { 0xced8774c, 0xe5802631, 0xb4589d7d, 0x085 },
    { 0x0000026b, 0x00a8ac1e, 0x00a8ae89, 0x010 },
    { 0x4dbc10fe, 0xb5ff9abd, 0x03bbabbb, 0x015 },
    { 0x200809fd, 0xafc7d178, 0xcfcfdb75, 0x090 },
    { 0xa99571b2, 0xd25b7272, 0x7bf0e424, 0x805 },
    { 0x31b6a3c8, 0x4dbab8f7, 0x7f715cbf, 0x000 },
    { 0x0000059e, 0x219779c2, 0x21977f60, 0x014 },
    /* r/m32, imm8: */
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xfffffffe, 0x091 },
    { 0x00000000, 0xffffffff, 0xffffffff, 0x084 },
    { 0x7ffffffc, 0x0000006a, 0x80000066, 0x894 },
    { 0x92a0331d, 0x00000078, 0x92a03395, 0x094 },
    { 0x0000b01a, 0x00000038, 0x0000b052, 0x010 },
    { 0x005d06e9, 0x0000002e, 0x005d0717, 0x014 },
    { 0x41f687e8, 0x0000002d, 0x41f68815, 0x010 },
    { 0x187db8f0, 0x0000001f, 0x187db90f, 0x004 },
    { 0xe61a2e86, 0xfffffff5, 0xe61a2e7b, 0x085 },
    { 0x0207c75d, 0x00000069, 0x0207c7c6, 0x014 },
    { 0x578e3937, 0xffffffc9, 0x578e3900, 0x015 },
    { 0xf558a406, 0x0000001a, 0xf558a420, 0x090 },
    { 0x5a0f4062, 0x0000004b, 0x5a0f40ad, 0x000 },
    { 0x724b55cd, 0x0000005a, 0x724b5627, 0x014 },
    { 0x0008f92b, 0xffffffe7, 0x0008f912, 0x015 },
    { 0x41b88762, 0xffffffcf, 0x41b88731, 0x011 },
    { 0xf989997b, 0xffffffbf, 0xf989993a, 0x095 },
    { 0x1bb2da85, 0xffffffcb, 0x1bb2da50, 0x015 },
    { 0xa01fadc4, 0x00000029, 0xa01faded, 0x084 },
    { 0x0017ac8f, 0xffffffd3, 0x0017ac62, 0x011 },
    { 0x7b0783c7, 0xffffffeb, 0x7b0783b2, 0x015 },
    { 0x6e76fe07, 0x00000066, 0x6e76fe6d, 0x000 },
    { 0x83895eae, 0x00000052, 0x83895f00, 0x094 },
    { 0x79b0a4ee, 0xffffffac, 0x79b0a49a, 0x015 },
    { 0x0000d050, 0x00000021, 0x0000d071, 0x004 },
    { 0x5bfcfe90, 0x0000003e, 0x5bfcfece, 0x000 },
    { 0x4292707b, 0x00000062, 0x429270dd, 0x004 },
    { 0x58eb7b56, 0xffffffe2, 0x58eb7b38, 0x001 },
    { 0x8ccbbc8c, 0xffffffb7, 0x8ccbbc43, 0x091 },
    { 0x00006310, 0xffffffcc, 0x000062dc, 0x001 },
    { 0x12f3e35a, 0x0000006e, 0x12f3e3c8, 0x010 },
    { 0xc8d5a09f, 0x00000014, 0xc8d5a0b3, 0x090 },
    { 0x75fed675, 0x00000004, 0x75fed679, 0x000 },
    { 0x6e669fdf, 0x00000045, 0x6e66a024, 0x014 },
    { 0x13dfe54f, 0xffffff8e, 0x13dfe4dd, 0x015 },
};

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 },
    { 0xfb, 0x4f, 0x4a, 0x011 },
    { 0xfb, 0x4f, 0x4b, 0x01d },
    { 0x70, 0xe5, 0x55, 0x005 },
    { 0x70, 0xe5, 0x56, 0x00d },
    { 0xbc, 0xc0, 0x7c, 0x801 },
    { 0xbc, 0xc0, 0x7d, 0x80d },
    { 0x8f, 0xc3, 0x52, 0x811 },
    { 0x8f, 0xc3, 0x53, 0x81d },
    { 0xa2, 0x29, 0xcb, 0x080 },
    { 0xa2, 0x29, 0xcc, 0x08c },
    { 0xe6, 0xed, 0xd3, 0x091 },
    { 0xe6, 0xed, 0xd4, 0x09d },
    { 0xe7, 0x70, 0x57, 0x001 },
    { 0xe7, 0x70, 0x58, 0x009 },
    { 0xbe, 0x98, 0x56, 0x815 },
    { 0xbe, 0x98, 0x57, 0x819 },
    { 0xad, 0x17, 0xc4, 0x090 },
    { 0xad, 0x17, 0xc5, 0x09c },
    { 0xb0, 0x9f, 0x4f, 0x801 },
    { 0xb0, 0x9f, 0x50, 0x81d },
    { 0x23, 0xd2, 0xf5, 0x084 },
    { 0x23, 0xd2, 0xf6, 0x08c },
    { 0xce, 0xcf, 0x9d, 0x091 },
    { 0xce, 0xcf, 0x9e, 0x099 },
    { 0x81, 0x1e, 0x9f, 0x084 },
    { 0x81, 0x1e, 0xa0, 0x09c },
    { 0x43, 0x71, 0xb4, 0x884 },
    { 0x43, 0x71, 0xb5, 0x888 },
    { 0x57, 0x96, 0xed, 0x084 },
    { 0x57, 0x96, 0xee, 0x08c },
    { 0x49, 0x3a, 0x83, 0x890 },
    { 0x49, 0x3a, 0x84, 0x89c },
    { 0xed, 0x0d, 0xfa, 0x094 },
    { 0xed, 0x0d, 0xfb, 0x098 },
    { 0xb1, 0x06, 0xb7, 0x084 },
    { 0xb1, 0x06, 0xb8, 0x08c },
    { 0x2f, 0x5c, 0x8b, 0x894 },
    { 0x2f, 0x5c, 0x8c, 0x898 },
    { 0x36, 0xf9, 0x2f, 0x001 },
    { 0x36, 0xf9, 0x30, 0x01d },
    { 0x71, 0x05, 0x76, 0x000 },
    { 0x71, 0x05, 0x77, 0x00c },
    { 0x12, 0xe5, 0xf7, 0x080 },
    { 0x12, 0xe5, 0xf8, 0x088 },
    { 0x14, 0xc6, 0xda, 0x080 },
    { 0x14, 0xc6, 0xdb, 0x08c },
    { 0xfc, 0x35, 0x31, 0x011 },
    { 0xfc, 0x35, 0x32, 0x019 },
    { 0xe3, 0x27, 0x0a, 0x005 },
    { 0xe3, 0x27, 0x0b, 0x009 },
    { 0x4f, 0x80, 0xcf, 0x084 },
    { 0x4f, 0x80, 0xd0, 0x098 },
    { 0x29, 0xd1, 0xfa, 0x084 },
    { 0x29, 0xd1, 0xfb, 0x088 },
    { 0xa7, 0x79, 0x20, 0x011 },
    { 0xa7, 0x79, 0x21, 0x01d },
    { 0x63, 0xb1, 0x14, 0x005 },
    { 0x63, 0xb1, 0x15, 0x009 },
};

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 },
    { 0x10e1, 0x0013, 0x10f4, 0x000 },
    { 0x10e1, 0x0013, 0x10f5, 0x00c },
    { 0x4a2e, 0x4f80, 0x99ae, 0x880 },
    { 0x4a2e, 0x4f80, 0x99af, 0x88c },
    { 0x7375, 0x0ae9, 0x7e5e, 0x000 },
    { 0x7375, 0x0ae9, 0x7e5f, 0x00c },
    { 0x000b, 0x0300, 0x030b, 0x000 },
    { 0x000b, 0x0300, 0x030c, 0x00c },
    { 0x2144, 0x058a, 0x26ce, 0x000 },
    { 0x2144, 0x058a, 0x26cf, 0x00c },
    { 0xe553, 0xe9e0, 0xcf33, 0x085 },
    { 0xe553, 0xe9e0, 0xcf34, 0x089 },
    { 0x07d4, 0x0052, 0x0826, 0x000 },
    { 0x07d4, 0x0052, 0x0827, 0x00c },
    { 0x2afb, 0x04a4, 0x2f9f, 0x004 },
    { 0x2afb, 0x04a4, 0x2fa0, 0x01c },
    { 0xe171, 0xfccd, 0xde3e, 0x081 },
    { 0xe171, 0xfccd, 0xde3f, 0x08d },
    { 0x002c, 0x08c8, 0x08f4, 0x010 },
    { 0x002c, 0x08c8, 0x08f5, 0x01c },
    { 0xa6e2, 0x4874, 0xef56, 0x084 },
    { 0xa6e2, 0x4874, 0xef57, 0x088 },
    { 0xf89c, 0xcc2c, 0xc4c8, 0x091 },
    { 0xf89c, 0xcc2c, 0xc4c9, 0x09d },
    { 0x0039, 0x0027, 0x0060, 0x014 },
    { 0x0039, 0x0027, 0x0061, 0x018 },
    { 0x40a0, 0xd778, 0x1818, 0x005 },
    { 0x40a0, 0xd778, 0x1819, 0x009 },
    { 0x2095, 0x3376, 0x540b, 0x000 },
    { 0x2095, 0x3376, 0x540c, 0x00c },
    { 0x007b, 0x000e, 0x0089, 0x010 },
    { 0x007b, 0x000e, 0x008a, 0x018 },
    { 0x7bb7, 0x4778, 0xc32f, 0x880 },
    { 0x7bb7, 0x4778, 0xc330, 0x89c },
    { 0x2674, 0xc5c6, 0xec3a, 0x084 },
    { 0x2674, 0xc5c6, 0xec3b, 0x088 },
    { 0x0063, 0x1aff, 0x1b62, 0x010 },
    { 0x0063, 0x1aff, 0x1b63, 0x01c },
    { 0x317d, 0x0a3f, 0x3bbc, 0x010 },
    { 0x317d, 0x0a3f, 0x3bbd, 0x01c },
    { 0xeaa5, 0xff13, 0xe9b8, 0x085 },
    { 0xeaa5, 0xff13, 0xe9b9, 0x089 },
    { 0x0f39, 0x01cb, 0x1104, 0x010 },
    { 0x0f39, 0x01cb, 0x1105, 0x01c },
    { 0x47d7, 0xb326, 0xfafd, 0x080 },
    { 0x47d7, 0xb326, 0xfafe, 0x088 },
    { 0x9cd1, 0x85de, 0x22af, 0x805 },
    { 0x9cd1, 0x85de, 0x22b0, 0x819 },
    { 0x0081, 0x00e1, 0x0162, 0x000 },
    { 0x0081, 0x00e1, 0x0163, 0x00c },
    { 0xf2ea, 0xf019, 0xe303, 0x095 },
    { 0xf2ea, 0xf019, 0xe304, 0x099 },
    { 0x1bf0, 0x50e4, 0x6cd4, 0x004 },
    { 0x1bf0, 0x50e4, 0x6cd5, 0x008 },
    { 0x0d4b, 0x0030, 0x0d7b, 0x004 },
    { 0x0d4b, 0x0030, 0x0d7c, 0x008 },
    { 0x9ce3, 0x3c3a, 0xd91d, 0x084 },
    { 0x9ce3, 0x3c3a, 0xd91e, 0x08c },
    /* 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 },
    { 0x0355, 0x0019, 0x036e, 0x000 },
    { 0x0355, 0x0019, 0x036f, 0x00c },
    { 0xa8b5, 0xffe0, 0xa895, 0x085 },
    { 0xa8b5, 0xffe0, 0xa896, 0x08d },
    { 0xecba, 0x003a, 0xecf4, 0x090 },
    { 0xecba, 0x003a, 0xecf5, 0x09c },
    { 0x01c0, 0xffb4, 0x0174, 0x005 },
    { 0x01c0, 0xffb4, 0x0175, 0x009 },
    { 0xeaaa, 0x005e, 0xeb08, 0x090 },
    { 0xeaaa, 0x005e, 0xeb09, 0x09c },
    { 0xcab0, 0xff85, 0xca35, 0x085 },
    { 0xcab0, 0xff85, 0xca36, 0x08d },
    { 0x0016, 0xffc8, 0xffde, 0x084 },
    { 0x0016, 0xffc8, 0xffdf, 0x088 },
    { 0xac4f, 0xfff3, 0xac42, 0x095 },
    { 0xac4f, 0xfff3, 0xac43, 0x099 },
    { 0xfcc0, 0x002e, 0xfcee, 0x084 },
    { 0xfcc0, 0x002e, 0xfcef, 0x088 },
    { 0x001a, 0xfff9, 0x0013, 0x011 },
    { 0x001a, 0xfff9, 0x0014, 0x01d },
    { 0x79db, 0xffcc, 0x79a7, 0x011 },
    { 0x79db, 0xffcc, 0x79a8, 0x019 },
    { 0x48c2, 0x0073, 0x4935, 0x004 },
    { 0x48c2, 0x0073, 0x4936, 0x00c },
    { 0x0062, 0x0072, 0x00d4, 0x004 },
    { 0x0062, 0x0072, 0x00d5, 0x008 },
    { 0xfb8e, 0xff89, 0xfb17, 0x095 },
    { 0xfb8e, 0xff89, 0xfb18, 0x09d },
    { 0x83c6, 0x0049, 0x840f, 0x084 },
    { 0x83c6, 0x0049, 0x8410, 0x098 },
    { 0x006a, 0x0070, 0x00da, 0x000 },
    { 0x006a, 0x0070, 0x00db, 0x00c },
    { 0x2d7d, 0xffe9, 0x2d66, 0x015 },
    { 0x2d7d, 0xffe9, 0x2d67, 0x019 },
    { 0xa78d, 0x003f, 0xa7cc, 0x094 },
    { 0xa78d, 0x003f, 0xa7cd, 0x098 },
    { 0x8000, 0xfffc, 0x7ffc, 0x805 },
    { 0x8000, 0xfffc, 0x7ffd, 0x809 },
    { 0x7d23, 0xffd3, 0x7cf6, 0x005 },
    { 0x7d23, 0xffd3, 0x7cf7, 0x009 },
    { 0x6c6d, 0xffcb, 0x6c38, 0x011 },
    { 0x6c6d, 0xffcb, 0x6c39, 0x01d },
    { 0x1db0, 0x004b, 0x1dfb, 0x000 },
    { 0x1db0, 0x004b, 0x1dfc, 0x00c },
    { 0x7340, 0xffde, 0x731e, 0x005 },
    { 0x7340, 0xffde, 0x731f, 0x009 },
    { 0x05d3, 0x0064, 0x0637, 0x000 },
    { 0x05d3, 0x0064, 0x0638, 0x008 },
    { 0x0075, 0x0053, 0x00c8, 0x000 },
    { 0x0075, 0x0053, 0x00c9, 0x00c },
    { 0xdb61, 0xfff9, 0xdb5a, 0x085 },
    { 0xdb61, 0xfff9, 0xdb5b, 0x089 },
    { 0xc5da, 0xff9c, 0xc576, 0x091 },
    { 0xc5da, 0xff9c, 0xc577, 0x09d },
    { 0x119e, 0x003a, 0x11d8, 0x014 },
    { 0x119e, 0x003a, 0x11d9, 0x018 },
    { 0xab62, 0x0047, 0xaba9, 0x084 },
    { 0xab62, 0x0047, 0xabaa, 0x08c },
};

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 },
    { 0x75c2a091, 0x7cbbcbfd, 0xf27e6c8e, 0x884 },
    { 0x75c2a091, 0x7cbbcbfd, 0xf27e6c8f, 0x888 },
    { 0x567d7a9d, 0x07fce4f4, 0x5e7a5f91, 0x010 },
    { 0x567d7a9d, 0x07fce4f4, 0x5e7a5f92, 0x018 },
    { 0x75f7ccce, 0x0066e424, 0x765eb0f2, 0x010 },
    { 0x75f7ccce, 0x0066e424, 0x765eb0f3, 0x01c },
    { 0xbd0c23cc, 0xa8026637, 0x650e8a03, 0x815 },
    { 0xbd0c23cc, 0xa8026637, 0x650e8a04, 0x819 },
    { 0x7584b966, 0x9ca7f2fd, 0x122cac63, 0x015 },
    { 0x7584b966, 0x9ca7f2fd, 0x122cac64, 0x019 },
    { 0x9641cebd, 0xba6c0688, 0x50add545, 0x811 },
    { 0x9641cebd, 0xba6c0688, 0x50add546, 0x819 },
    { 0x4a210982, 0x7ef75bd3, 0xc9186555, 0x884 },
    { 0x4a210982, 0x7ef75bd3, 0xc9186556, 0x88c },
    { 0x04c77966, 0x000003e5, 0x04c77d4b, 0x004 },
    { 0x04c77966, 0x000003e5, 0x04c77d4c, 0x008 },
    { 0xde2ce626, 0x15b9d844, 0xf3e6be6a, 0x084 },
    { 0xde2ce626, 0x15b9d844, 0xf3e6be6b, 0x088 },
    { 0xdc256380, 0x1aa797c3, 0xf6ccfb43, 0x080 },
    { 0xdc256380, 0x1aa797c3, 0xf6ccfb44, 0x08c },
    { 0xf0dc90e0, 0xa0ab9c03, 0x91882ce3, 0x081 },
    { 0xf0dc90e0, 0xa0ab9c03, 0x91882ce4, 0x08d },
    { 0x628f99b6, 0x41b4ae47, 0xa44447fd, 0x880 },
    { 0x628f99b6, 0x41b4ae47, 0xa44447fe, 0x888 },
    { 0x0012b4f4, 0x0025ba5b, 0x00386f4f, 0x000 },
    { 0x0012b4f4, 0x0025ba5b, 0x00386f50, 0x01c },
    { 0xe0edc301, 0x199da85e, 0xfa8b6b5f, 0x084 },
    { 0xe0edc301, 0x199da85e, 0xfa8b6b60, 0x09c },
    { 0x3d98c075, 0x778360ea, 0xb51c215f, 0x884 },
    { 0x3d98c075, 0x778360ea, 0xb51c2160, 0x89c },
    { 0x79f7b315, 0xb50e6641, 0x2f061956, 0x005 },
    { 0x79f7b315, 0xb50e6641, 0x2f061957, 0x009 },
    { 0xc45b7171, 0xcf74b3f3, 0x93d02564, 0x081 },
    { 0xc45b7171, 0xcf74b3f3, 0x93d02565, 0x08d },
    { 0x000cea7c, 0x017aa7e6, 0x01879262, 0x010 },
    { 0x000cea7c, 0x017aa7e6, 0x01879263, 0x01c },
    { 0xcba516d4, 0xc37ddf18, 0x8f22f5ec, 0x081 },
    { 0xcba516d4, 0xc37ddf18, 0x8f22f5ed, 0x08d },
    { 0xbcc1c345, 0xd4fb2700, 0x91bcea45, 0x081 },
    { 0xbcc1c345, 0xd4fb2700, 0x91bcea46, 0x089 },
    { 0xf4bd7bc2, 0x4408396e, 0x38c5b530, 0x015 },
    { 0xf4bd7bc2, 0x4408396e, 0x38c5b531, 0x019 },
    { 0xb7f287a6, 0x13a7e0cf, 0xcb9a6875, 0x090 },
    { 0xb7f287a6, 0x13a7e0cf, 0xcb9a6876, 0x098 },
    { 0x0204882a, 0x0000cfbf, 0x020557e9, 0x010 },
    { 0x0204882a, 0x0000cfbf, 0x020557ea, 0x018 },
    { 0x0bc31bc0, 0xb653011b, 0xc2161cdb, 0x084 },
    { 0x0bc31bc0, 0xb653011b, 0xc2161cdc, 0x088 },
    { 0xc36dd04d, 0x9e8691d0, 0x61f4621d, 0x805 },
    { 0xc36dd04d, 0x9e8691d0, 0x61f4621e, 0x80d },
    { 0x14cf1f2b, 0xea076b8c, 0xfed68ab7, 0x094 },
    { 0x14cf1f2b, 0xea076b8c, 0xfed68ab8, 0x09c },
    { 0xcd25eab6, 0x34545978, 0x017a442e, 0x005 },
    { 0xcd25eab6, 0x34545978, 0x017a442f, 0x009 },
    { 0x00000245, 0x00608a7a, 0x00608cbf, 0x000 },
    { 0x00000245, 0x00608a7a, 0x00608cc0, 0x01c },
    { 0x3aa359c7, 0xfa5b56b7, 0x34feb07e, 0x005 },
    { 0x3aa359c7, 0xfa5b56b7, 0x34feb07f, 0x009 },
    { 0xc29a4723, 0x1eb44c2a, 0xe14e934d, 0x084 },
    { 0xc29a4723, 0x1eb44c2a, 0xe14e934e, 0x08c },
    { 0x4ef489f9, 0x6395e661, 0xb28a705a, 0x884 },
    { 0x4ef489f9, 0x6395e661, 0xb28a705b, 0x888 },
    { 0xc6481d5b, 0x287f4495, 0xeec761f0, 0x094 },
    { 0xc6481d5b, 0x287f4495, 0xeec761f1, 0x098 },
    { 0x00061fbc, 0x0000056b, 0x00062527, 0x014 },
    { 0x00061fbc, 0x0000056b, 0x00062528, 0x01c },
    /* 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 },
    { 0x7ffffff1, 0x0000001c, 0x8000000d, 0x880 },
    { 0x7ffffff1, 0x0000001c, 0x8000000e, 0x888 },
    { 0x1d400485, 0xffffffc3, 0x1d400448, 0x005 },
    { 0x1d400485, 0xffffffc3, 0x1d400449, 0x009 },
    { 0x00002d26, 0x0000002c, 0x00002d52, 0x010 },
    { 0x00002d26, 0x0000002c, 0x00002d53, 0x01c },
    { 0x5ec7bd61, 0xffffffe4, 0x5ec7bd45, 0x001 },
    { 0x5ec7bd61, 0xffffffe4, 0x5ec7bd46, 0x009 },
    { 0x267edb92, 0xffffffd0, 0x267edb62, 0x001 },
    { 0x267edb92, 0xffffffd0, 0x267edb63, 0x00d },
    { 0xb4b32f2d, 0x00000036, 0xb4b32f63, 0x094 },
    { 0xb4b32f2d, 0x00000036, 0xb4b32f64, 0x098 },
    { 0x04575292, 0x0000004b, 0x045752dd, 0x004 },
    { 0x04575292, 0x0000004b, 0x045752de, 0x00c },
    { 0x0000a4d1, 0x00000057, 0x0000a528, 0x004 },
    { 0x0000a4d1, 0x00000057, 0x0000a529, 0x008 },
    { 0xdab93b69, 0x00000007, 0xdab93b70, 0x090 },
    { 0xdab93b69, 0x00000007, 0xdab93b71, 0x09c },
    { 0x658bb6bc, 0xffffffe5, 0x658bb6a1, 0x011 },
    { 0x658bb6bc, 0xffffffe5, 0x658bb6a2, 0x019 },
    { 0x0605ecb3, 0xffffffdb, 0x0605ec8e, 0x005 },
    { 0x0605ecb3, 0xffffffdb, 0x0605ec8f, 0x009 },
    { 0x51a134c7, 0xffffffdb, 0x51a134a2, 0x011 },
    { 0x51a134c7, 0xffffffdb, 0x51a134a3, 0x01d },
    { 0x000ea48c, 0x00000031, 0x000ea4bd, 0x004 },
    { 0x000ea48c, 0x00000031, 0x000ea4be, 0x00c },
    { 0x30128b14, 0xffffffb4, 0x30128ac8, 0x001 },
    { 0x30128b14, 0xffffffb4, 0x30128ac9, 0x00d },
    { 0xfe023c59, 0xffffffb0, 0xfe023c09, 0x085 },
    { 0xfe023c59, 0xffffffb0, 0xfe023c0a, 0x08d },
    { 0xb4c02717, 0x00000015, 0xb4c0272c, 0x080 },
    { 0xb4c02717, 0x00000015, 0xb4c0272d, 0x08c },
    { 0xca7165c4, 0x00000037, 0xca7165fb, 0x080 },
    { 0xca7165c4, 0x00000037, 0xca7165fc, 0x08c },
    { 0x003efbb0, 0xffffff9c, 0x003efb4c, 0x001 },
    { 0x003efbb0, 0xffffff9c, 0x003efb4d, 0x00d },
    { 0x6d6915f9, 0xffffff8d, 0x6d691586, 0x011 },
    { 0x6d6915f9, 0xffffff8d, 0x6d691587, 0x01d },
    { 0x0b725a3a, 0xffffff88, 0x0b7259c2, 0x011 },
    { 0x0b725a3a, 0xffffff88, 0x0b7259c3, 0x01d },
    { 0x0580a5ce, 0x00000034, 0x0580a602, 0x010 },
    { 0x0580a5ce, 0x00000034, 0x0580a603, 0x01c },
    { 0x4e9a0d45, 0x00000053, 0x4e9a0d98, 0x000 },
    { 0x4e9a0d45, 0x00000053, 0x4e9a0d99, 0x00c },
    { 0x1936efd4, 0xffffffa4, 0x1936ef78, 0x005 },
    { 0x1936efd4, 0xffffffa4, 0x1936ef79, 0x009 },
    { 0xd1cc6ec0, 0x00000061, 0xd1cc6f21, 0x084 },
    { 0xd1cc6ec0, 0x00000061, 0xd1cc6f22, 0x08c },
    { 0x29631a93, 0x0000001f, 0x29631ab2, 0x014 },
    { 0x29631a93, 0x0000001f, 0x29631ab3, 0x018 },
    { 0x96a4fa74, 0x0000001c, 0x96a4fa90, 0x094 },
    { 0x96a4fa74, 0x0000001c, 0x96a4fa91, 0x098 },
    { 0x9a6bb23b, 0x0000000a, 0x9a6bb245, 0x090 },
    { 0x9a6bb23b, 0x0000000a, 0x9a6bb246, 0x098 },
    { 0x00006755, 0x0000003d, 0x00006792, 0x010 },
    { 0x00006755, 0x0000003d, 0x00006793, 0x01c },
    { 0x7e7728c0, 0x0000004a, 0x7e77290a, 0x004 },
    { 0x7e7728c0, 0x0000004a, 0x7e77290b, 0x008 },
    { 0xa6204dd3, 0x00000006, 0xa6204dd9, 0x080 },
    { 0xa6204dd3, 0x00000006, 0xa6204dda, 0x088 },
    { 0xc1dc0866, 0x00000044, 0xc1dc08aa, 0x084 },
    { 0xc1dc0866, 0x00000044, 0xc1dc08ab, 0x088 },
    { 0x1bd52e46, 0xfffffff0, 0x1bd52e36, 0x005 },
    { 0x1bd52e46, 0xfffffff0, 0x1bd52e37, 0x009 },
    { 0x00001468, 0xffffff8c, 0x000013f4, 0x011 },
    { 0x00001468, 0xffffff8c, 0x000013f5, 0x01d },
};

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 },
    { 0xa4, 0x60, 0x44, 0x804 },
    { 0x9e, 0x1c, 0x82, 0x084 },
    { 0x65, 0x25, 0x40, 0x000 },
    { 0x19, 0xbd, 0x5c, 0x015 },
    { 0x86, 0xed, 0x99, 0x095 },
    { 0x71, 0x13, 0x5e, 0x010 },
    { 0xd2, 0x7f, 0x53, 0x814 },
    { 0x73, 0x4d, 0x26, 0x010 },
    { 0x96, 0xda, 0xbc, 0x091 },
    { 0xf4, 0x96, 0x5e, 0x010 },
    { 0xa0, 0x77, 0x29, 0x810 },
    { 0x79, 0xf6, 0x83, 0x881 },
    { 0x43, 0x01, 0x42, 0x004 },
    { 0x27, 0x6a, 0xbd, 0x095 },
    { 0x17, 0x6a, 0xad, 0x091 },
    { 0x37, 0x30, 0x07, 0x000 },
    { 0x77, 0x48, 0x2f, 0x010 },
    { 0x9e, 0x42, 0x5c, 0x804 },
    { 0x55, 0x50, 0x05, 0x004 },
    { 0x28, 0x97, 0x91, 0x881 },
    { 0xd5, 0xef, 0xe6, 0x091 },
    { 0x3c, 0x3f, 0xfd, 0x091 },
    { 0x25, 0x17, 0x0e, 0x010 },
    { 0x87, 0x1e, 0x69, 0x814 },
    { 0xa9, 0x1c, 0x8d, 0x094 },
    { 0x6a, 0x22, 0x48, 0x004 },
    { 0xe0, 0xd2, 0x0e, 0x010 },
    { 0x42, 0x4c, 0xf6, 0x095 },
    { 0x96, 0x57, 0x3f, 0x814 },
};

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 },
    { 0x1a88, 0x0032, 0x1a56, 0x004 },
    { 0x41cb, 0x991f, 0xa8ac, 0x895 },
    { 0xef71, 0xed77, 0x01fa, 0x014 },
    { 0x00ab, 0x005a, 0x0051, 0x000 },
    { 0x2b58, 0xb7f1, 0x7367, 0x001 },
    { 0x3684, 0x2ef0, 0x0794, 0x000 },
    { 0x2019, 0x01b3, 0x1e66, 0x004 },
    { 0x5839, 0x3f71, 0x18c8, 0x000 },
    { 0x3b2f, 0xc8c5, 0x726a, 0x005 },
    { 0x0025, 0x0731, 0xf8f4, 0x081 },
    { 0x0bc7, 0x6683, 0xa544, 0x085 },
    { 0x5634, 0x76c7, 0xdf6d, 0x091 },
    { 0x0317, 0x09de, 0xf939, 0x095 },
    { 0x32ce, 0xa090, 0x923e, 0x881 },
    { 0x571e, 0x9174, 0xc5aa, 0x885 },
    { 0x0a33, 0x3907, 0xd12c, 0x091 },
    { 0xf003, 0x5ac1, 0x9542, 0x084 },
    { 0x6c01, 0xe4ad, 0x8754, 0x891 },
    { 0x0035, 0x017c, 0xfeb9, 0x091 },
    { 0x8357, 0xe313, 0xa044, 0x085 },
    { 0x1d8e, 0x80b5, 0x9cd9, 0x881 },
    { 0x0764, 0x003a, 0x072a, 0x010 },
    { 0xa8c5, 0x2ac5, 0x7e00, 0x804 },
    { 0xfc5b, 0xc1a8, 0x3ab3, 0x000 },
    { 0x0014, 0x017a, 0xfe9a, 0x095 },
    { 0xdf47, 0xb0b5, 0x2e92, 0x000 },
    { 0x51e6, 0x0fcd, 0x4219, 0x010 },
    { 0x0002, 0x3036, 0xcfcc, 0x095 },
    { 0x81bc, 0x76cf, 0x0aed, 0x814 },
    /* r/m16, imm8: */
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0x0000, 0x044 },
    { 0x0000, 0xffff, 0x0001, 0x011 },
    { 0x0462, 0x0076, 0x03ec, 0x010 },
    { 0x29d4, 0xffff, 0x29d5, 0x011 },
    { 0xbe31, 0xffa3, 0xbe8e, 0x095 },
    { 0x0005, 0xfff8, 0x000d, 0x011 },
    { 0x4f60, 0xffce, 0x4f92, 0x011 },
    { 0xabef, 0x002a, 0xabc5, 0x084 },
    { 0x0579, 0xffdd, 0x059c, 0x015 },
    { 0xe505, 0x0070, 0xe495, 0x084 },
    { 0x4522, 0xffb7, 0x456b, 0x011 },
    { 0x3a0d, 0xffcf, 0x3a3e, 0x011 },
    { 0x9cc8, 0xffd3, 0x9cf5, 0x085 },
    { 0x9bac, 0xff87, 0x9c25, 0x081 },
    { 0x001a, 0x006f, 0xffab, 0x091 },
    { 0x9228, 0x0069, 0x91bf, 0x090 },
    { 0x7a96, 0xff93, 0x7b03, 0x005 },
    { 0x01fb, 0xffa7, 0x0254, 0x001 },
    { 0x76f8, 0x0040, 0x76b8, 0x004 },
    { 0x8aac, 0xff96, 0x8b16, 0x081 },
    { 0x8034, 0x006a, 0x7fca, 0x814 },
    { 0x2bdd, 0x000a, 0x2bd3, 0x000 },
    { 0x42e3, 0xffe4, 0x42ff, 0x015 },
    { 0x07ec, 0xff99, 0x0853, 0x005 },
    { 0x7c25, 0xff82, 0x7ca3, 0x005 },
    { 0x43a5, 0x0045, 0x4360, 0x004 },
    { 0x304f, 0xffd1, 0x307e, 0x005 },
    { 0xf0c6, 0xffa1, 0xf125, 0x081 },
    { 0x4c09, 0x001c, 0x4bed, 0x014 },
    { 0x0152, 0xffe2, 0x0170, 0x001 },
    { 0xfc81, 0xffd4, 0xfcad, 0x091 },
};

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 },
    { 0x40ff480c, 0xb7d32d2d, 0x892c1adf, 0x891 },
    { 0xc93a3d08, 0x4e7cdcf3, 0x7abd6015, 0x800 },
    { 0x00000747, 0x00000402, 0x00000345, 0x000 },
    { 0x5dadba1a, 0x7895102e, 0xe518a9ec, 0x091 },
    { 0x425979db, 0x804f1a11, 0xc20a5fca, 0x885 },
    { 0x89387313, 0x590ae91f, 0x302d89f4, 0x810 },
    { 0xa7b6e091, 0x175163f5, 0x90657c9c, 0x094 },
    { 0x008eec6c, 0x000344e0, 0x008ba78c, 0x000 },
    { 0xea330cdb, 0xfd913455, 0xeca1d886, 0x081 },
    { 0xc802d807, 0xf2b4b7ac, 0xd54e205b, 0x091 },
    { 0x3686b809, 0x869c72d6, 0xafea4533, 0x885 },
    { 0xc93763d1, 0x537a53e4, 0x75bd0fed, 0x814 },
    { 0x00002315, 0x007df455, 0xff822ec0, 0x085 },
    { 0xa133fedb, 0x9ca0ece4, 0x049311f7, 0x000 },
    { 0x49209c3e, 0xfbf1cff3, 0x4d2ecc4b, 0x005 },
    { 0x008b9a17, 0xac0cc008, 0x547eda0f, 0x015 },
    { 0xf91363cf, 0x27fde922, 0xd1157aad, 0x080 },
    { 0x0000028a, 0x00000025, 0x00000265, 0x004 },
    { 0xaf80f968, 0xbc763335, 0xf30ac633, 0x085 },
    { 0xf41bfb95, 0xd9222ec0, 0x1af9ccd5, 0x000 },
    { 0x932b6cf7, 0x07fef6c9, 0x8b2c762e, 0x094 },
    { 0xb3fc2b0c, 0x706e3b7d, 0x438def8f, 0x810 },
    { 0x0000062d, 0x00001806, 0xffffee27, 0x085 },
    { 0xb753cb77, 0x9e530e01, 0x1900bd76, 0x000 },
    { 0x5ebc9408, 0xee9aa8fb, 0x7021eb0d, 0x011 },
    { 0xea4064eb, 0xa9a195f8, 0x409ecef3, 0x004 },
    { 0xef7d02f5, 0xb84d5c01, 0x372fa6f4, 0x000 },
    { 0x00000b2c, 0x00035aad, 0xfffcb07f, 0x091 },
    { 0xc4564279, 0x7b261828, 0x49302a51, 0x800 },
    { 0x41fc086e, 0x098d8f9a, 0x386e78d4, 0x004 },
    { 0xaccecc5c, 0x7ccac2ff, 0x3004095d, 0x810 },
    { 0xa3c81287, 0xe4386f6b, 0xbf8fa31c, 0x091 },
    { 0x0014ceb0, 0x00001949, 0x0014b567, 0x010 },
    /* r/m32, imm8: */
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0x00000000, 0x044 },
    { 0x00000000, 0xffffffff, 0x00000001, 0x011 },
    { 0x7fffffff, 0xffffffdb, 0x80000024, 0x885 },
    { 0x4e369421, 0xffffffd1, 0x4e369450, 0x005 },
    { 0x0000004b, 0x00000010, 0x0000003b, 0x000 },
    { 0x617e53b8, 0x00000009, 0x617e53af, 0x014 },
    { 0xaf8776c7, 0x00000005, 0xaf8776c2, 0x080 },
    { 0xaa28060b, 0xffffff9f, 0xaa28066c, 0x095 },
    { 0x0c34dae8, 0x0000006e, 0x0c34da7a, 0x010 },
    { 0x014e6d4f, 0x0000003c, 0x014e6d13, 0x000 },
    { 0x2a54af98, 0xffffffde, 0x2a54afba, 0x011 },
    { 0x18232d1e, 0xffffffc6, 0x18232d58, 0x001 },
    { 0x94022e47, 0xffffff94, 0x94022eb3, 0x081 },
    { 0xf685697b, 0x00000007, 0xf6856974, 0x084 },
    { 0x00000328, 0xffffffe4, 0x00000344, 0x005 },
    { 0x69d6667d, 0x00000000, 0x69d6667d, 0x004 },
    { 0xb80da033, 0xffffffd8, 0xb80da05b, 0x091 },
    { 0xc58c0019, 0xfffffffa, 0xc58c001f, 0x091 },
    { 0x1edda7a2, 0x00000056, 0x1edda74c, 0x010 },
    { 0x33004f0c, 0xfffffffc, 0x33004f10, 0x001 },
    { 0x2ff0882d, 0xffffffc5, 0x2ff08868, 0x001 },
    { 0x94a1cf12, 0xffffffda, 0x94a1cf38, 0x091 },
    { 0x49bd94c2, 0xffffff8c, 0x49bd9536, 0x015 },
    { 0x9aa0feab, 0x00000035, 0x9aa0fe76, 0x080 },
    { 0x01eeb814, 0xffffffa3, 0x01eeb871, 0x005 },
    { 0x94b86eef, 0x0000005d, 0x94b86e92, 0x080 },
    { 0x81b16e39, 0xffffffe0, 0x81b16e59, 0x085 },
    { 0x074bce54, 0x0000005d, 0x074bcdf7, 0x010 },
    { 0x8eb51270, 0xffffff9b, 0x8eb512d5, 0x091 },
    { 0x00000980, 0x0000002c, 0x00000954, 0x010 },
    { 0x77675512, 0x00000028, 0x776754ea, 0x010 },
    { 0xd5e2ced9, 0xffffff9c, 0xd5e2cf3d, 0x091 },
    { 0x0213fce2, 0x00000052, 0x0213fc90, 0x004 },
    { 0x09b95c36, 0x0000000a, 0x09b95c2c, 0x010 },
    { 0x0002417e, 0xffffffc2, 0x000241bc, 0x001 },
};

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 },
    { 0x10, 0x0f, 0x01, 0x010 },
    { 0x10, 0x0f, 0x00, 0x05c },
    { 0x66, 0xe8, 0x7e, 0x015 },
    { 0x66, 0xe8, 0x7d, 0x01d },
    { 0x34, 0xf1, 0x43, 0x001 },
    { 0x34, 0xf1, 0x42, 0x00d },
    { 0x1c, 0xcb, 0x51, 0x001 },
    { 0x1c, 0xcb, 0x50, 0x00d },
    { 0x40, 0x98, 0xa8, 0x891 },
    { 0x40, 0x98, 0xa7, 0x899 },
    { 0xef, 0xf2, 0xfd, 0x081 },
    { 0xef, 0xf2, 0xfc, 0x08d },
    { 0xef, 0xfd, 0xf2, 0x081 },
    { 0xef, 0xfd, 0xf1, 0x089 },
    { 0x88, 0x59, 0x2f, 0x810 },
    { 0x88, 0x59, 0x2e, 0x81c },
    { 0xe2, 0x08, 0xda, 0x090 },
    { 0xe2, 0x08, 0xd9, 0x098 },
    { 0x62, 0x9c, 0xc6, 0x895 },
    { 0x62, 0x9c, 0xc5, 0x89d },
    { 0xc4, 0x55, 0x6f, 0x814 },
    { 0xc4, 0x55, 0x6e, 0x818 },
    { 0x51, 0x0e, 0x43, 0x010 },
    { 0x51, 0x0e, 0x42, 0x01c },
    { 0xf2, 0x13, 0xdf, 0x090 },
    { 0xf2, 0x13, 0xde, 0x09c },
    { 0x62, 0xc3, 0x9f, 0x895 },
    { 0x62, 0xc3, 0x9e, 0x899 },
    { 0xe0, 0x5c, 0x84, 0x094 },
    { 0xe0, 0x5c, 0x83, 0x098 },
    { 0x56, 0xb3, 0xa3, 0x885 },
    { 0x56, 0xb3, 0xa2, 0x889 },
    { 0x3e, 0xad, 0x91, 0x881 },
    { 0x3e, 0xad, 0x90, 0x88d },
    { 0x00, 0x65, 0x9b, 0x091 },
    { 0x00, 0x65, 0x9a, 0x09d },
    { 0x3a, 0xa4, 0x96, 0x885 },
    { 0x3a, 0xa4, 0x95, 0x88d },
    { 0xc7, 0x54, 0x73, 0x800 },
    { 0xc7, 0x54, 0x72, 0x80c },
    { 0x3e, 0x22, 0x1c, 0x000 },
    { 0x3e, 0x22, 0x1b, 0x00c },
    { 0x55, 0x46, 0x0f, 0x014 },
    { 0x55, 0x46, 0x0e, 0x018 },
    { 0x80, 0xe4, 0x9c, 0x095 },
    { 0x80, 0xe4, 0x9b, 0x099 },
    { 0x06, 0x8d, 0x79, 0x011 },
    { 0x06, 0x8d, 0x78, 0x01d },
    { 0x17, 0x43, 0xd4, 0x085 },
    { 0x17, 0x43, 0xd3, 0x089 },
    { 0xc8, 0x10, 0xb8, 0x084 },
    { 0xc8, 0x10, 0xb7, 0x08c },
    { 0xaa, 0x51, 0x59, 0x804 },
    { 0xaa, 0x51, 0x58, 0x808 },
    { 0xdb, 0x22, 0xb9, 0x080 },
    { 0xdb, 0x22, 0xb8, 0x08c },
    { 0xd6, 0x71, 0x65, 0x804 },
    { 0xd6, 0x71, 0x64, 0x808 },
};

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 },
    { 0x346e, 0x0007, 0x3467, 0x000 },
    { 0x346e, 0x0007, 0x3466, 0x00c },
    { 0xe75e, 0x0062, 0xe6fc, 0x084 },
    { 0xe75e, 0x0062, 0xe6fb, 0x088 },
    { 0x3c56, 0x5d00, 0xdf56, 0x085 },
    { 0x3c56, 0x5d00, 0xdf55, 0x08d },
    { 0x1fe7, 0x0a82, 0x1565, 0x004 },
    { 0x1fe7, 0x0a82, 0x1564, 0x008 },
    { 0xc70c, 0xf125, 0xd5e7, 0x085 },
    { 0xc70c, 0xf125, 0xd5e6, 0x089 },
    { 0xe639, 0xd5b8, 0x1081, 0x004 },
    { 0xe639, 0xd5b8, 0x1080, 0x008 },
    { 0x0619, 0x0672, 0xffa7, 0x081 },
    { 0x0619, 0x0672, 0xffa6, 0x08d },
    { 0x1a10, 0x23d0, 0xf640, 0x081 },
    { 0x1a10, 0x23d0, 0xf63f, 0x09d },
    { 0x4696, 0x60c7, 0xe5cf, 0x095 },
    { 0x4696, 0x60c7, 0xe5ce, 0x099 },
    { 0x0e59, 0x06a8, 0x07b1, 0x004 },
    { 0x0e59, 0x06a8, 0x07b0, 0x008 },
    { 0xca8a, 0x4da1, 0x7ce9, 0x800 },
    { 0xca8a, 0x4da1, 0x7ce8, 0x80c },
    { 0x9969, 0xdcbc, 0xbcad, 0x091 },
    { 0x9969, 0xdcbc, 0xbcac, 0x09d },
    { 0x0077, 0x019d, 0xfeda, 0x091 },
    { 0x0077, 0x019d, 0xfed9, 0x099 },
    { 0x7344, 0xa877, 0xcacd, 0x891 },
    { 0x7344, 0xa877, 0xcacc, 0x89d },
    { 0x3e3f, 0xb6c2, 0x877d, 0x885 },
    { 0x3e3f, 0xb6c2, 0x877c, 0x889 },
    { 0x1592, 0x0066, 0x152c, 0x010 },
    { 0x1592, 0x0066, 0x152b, 0x01c },
    { 0x8ae7, 0x733b, 0x17ac, 0x814 },
    { 0x8ae7, 0x733b, 0x17ab, 0x818 },
    { 0x4caa, 0x5b8d, 0xf11d, 0x095 },
    { 0x4caa, 0x5b8d, 0xf11c, 0x099 },
    { 0x0090, 0x01c0, 0xfed0, 0x081 },
    { 0x0090, 0x01c0, 0xfecf, 0x09d },
    { 0x689a, 0x7a29, 0xee71, 0x085 },
    { 0x689a, 0x7a29, 0xee70, 0x089 },
    { 0x49ed, 0x932c, 0xb6c1, 0x881 },
    { 0x49ed, 0x932c, 0xb6c0, 0x88d },
    { 0x050f, 0x1c97, 0xe878, 0x085 },
    { 0x050f, 0x1c97, 0xe877, 0x08d },
    { 0x2a8c, 0x4f51, 0xdb3b, 0x081 },
    { 0x2a8c, 0x4f51, 0xdb3a, 0x08d },
    { 0x8b06, 0x532c, 0x37da, 0x810 },
    { 0x8b06, 0x532c, 0x37d9, 0x818 },
    { 0x0017, 0x0049, 0xffce, 0x091 },
    { 0x0017, 0x0049, 0xffcd, 0x099 },
    { 0x0a6b, 0x2c05, 0xde66, 0x085 },
    { 0x0a6b, 0x2c05, 0xde65, 0x08d },
    { 0x3992, 0xa6ea, 0x92a8, 0x891 },
    { 0x3992, 0xa6ea, 0x92a7, 0x899 },
    { 0x00ae, 0x003a, 0x0074, 0x004 },
    { 0x00ae, 0x003a, 0x0073, 0x008 },
    { 0x7cfe, 0x3a7d, 0x4281, 0x004 },
    { 0x7cfe, 0x3a7d, 0x4280, 0x008 },
    /* 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 },
    { 0x00eb, 0xffb9, 0x0132, 0x001 },
    { 0x00eb, 0xffb9, 0x0131, 0x009 },
    { 0x049d, 0x0072, 0x042b, 0x004 },
    { 0x049d, 0x0072, 0x042a, 0x008 },
    { 0x0d05, 0xffe9, 0x0d1c, 0x011 },
    { 0x0d05, 0xffe9, 0x0d1b, 0x01d },
    { 0x02ce, 0x002e, 0x02a0, 0x004 },
    { 0x02ce, 0x002e, 0x029f, 0x01c },
    { 0x87b0, 0xffef, 0x87c1, 0x091 },
    { 0x87b0, 0xffef, 0x87c0, 0x09d },
    { 0x1f6c, 0x0048, 0x1f24, 0x004 },
    { 0x1f6c, 0x0048, 0x1f23, 0x008 },
    { 0x0361, 0xffeb, 0x0376, 0x011 },
    { 0x0361, 0xffeb, 0x0375, 0x019 },
    { 0x3b40, 0x004e, 0x3af2, 0x010 },
    { 0x3b40, 0x004e, 0x3af1, 0x018 },
    { 0xe58c, 0xff87, 0xe605, 0x085 },
    { 0xe58c, 0xff87, 0xe604, 0x089 },
    { 0x0011, 0xfff7, 0x001a, 0x011 },
    { 0x0011, 0xfff7, 0x0019, 0x019 },
    { 0xc7bb, 0x0019, 0xc7a2, 0x080 },
    { 0xc7bb, 0x0019, 0xc7a1, 0x088 },
    { 0xbb5d, 0x005a, 0xbb03, 0x084 },
    { 0xbb5d, 0x005a, 0xbb02, 0x088 },
    { 0x01bb, 0xffc5, 0x01f6, 0x005 },
    { 0x01bb, 0xffc5, 0x01f5, 0x00d },
    { 0xdf90, 0xff8b, 0xe005, 0x095 },
    { 0xdf90, 0xff8b, 0xe004, 0x099 },
    { 0x7f1c, 0x0068, 0x7eb4, 0x004 },
    { 0x7f1c, 0x0068, 0x7eb3, 0x008 },
    { 0x1e37, 0x003a, 0x1dfd, 0x010 },
    { 0x1e37, 0x003a, 0x1dfc, 0x01c },
    { 0x39c4, 0x002b, 0x3999, 0x014 },
    { 0x39c4, 0x002b, 0x3998, 0x018 },
    { 0x1dd6, 0xffa2, 0x1e34, 0x001 },
    { 0x1dd6, 0xffa2, 0x1e33, 0x00d },
    { 0x7fb6, 0xff89, 0x802d, 0x895 },
    { 0x7fb6, 0xff89, 0x802c, 0x899 },
    { 0x1618, 0xff88, 0x1690, 0x005 },
    { 0x1618, 0xff88, 0x168f, 0x019 },
    { 0xbab6, 0x0067, 0xba4f, 0x090 },
    { 0xbab6, 0x0067, 0xba4e, 0x09c },
    { 0x06d5, 0xff98, 0x073d, 0x011 },
    { 0x06d5, 0xff98, 0x073c, 0x01d },
    { 0xe35b, 0x0064, 0xe2f7, 0x080 },
    { 0xe35b, 0x0064, 0xe2f6, 0x08c },
    { 0x2db2, 0x0014, 0x2d9e, 0x010 },
    { 0x2db2, 0x0014, 0x2d9d, 0x018 },
    { 0x3a75, 0x003a, 0x3a3b, 0x010 },
    { 0x3a75, 0x003a, 0x3a3a, 0x01c },
    { 0x7ab8, 0xffd2, 0x7ae6, 0x001 },
    { 0x7ab8, 0xffd2, 0x7ae5, 0x009 },
    { 0xc061, 0x0032, 0xc02f, 0x090 },
    { 0xc061, 0x0032, 0xc02e, 0x09c },
    { 0x00f2, 0xff9a, 0x0158, 0x011 },
    { 0x00f2, 0xff9a, 0x0157, 0x019 },
    { 0x9c54, 0xffdf, 0x9c75, 0x091 },
    { 0x9c54, 0xffdf, 0x9c74, 0x09d },
};

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 },
    { 0x7a2fa6df, 0x8e749855, 0xebbb0e8a, 0x881 },
    { 0x7a2fa6df, 0x8e749855, 0xebbb0e89, 0x889 },
    { 0xabe282e1, 0xa3feb91c, 0x07e3c9c5, 0x014 },
    { 0xabe282e1, 0xa3feb91c, 0x07e3c9c4, 0x018 },
    { 0x234bce68, 0x0000022b, 0x234bcc3d, 0x010 },
    { 0x234bce68, 0x0000022b, 0x234bcc3c, 0x01c },
    { 0xf14f2d6d, 0x452f8939, 0xac1fa434, 0x080 },
    { 0xf14f2d6d, 0x452f8939, 0xac1fa433, 0x08c },
    { 0xf3d9ffd7, 0x6d2bb7ac, 0x86ae482b, 0x094 },
    { 0xf3d9ffd7, 0x6d2bb7ac, 0x86ae482a, 0x098 },
    { 0x5127b532, 0x05e90f3e, 0x4b3ea5f4, 0x010 },
    { 0x5127b532, 0x05e90f3e, 0x4b3ea5f3, 0x01c },
    { 0x47e7b27a, 0xfc766ba3, 0x4b7146d7, 0x005 },
    { 0x47e7b27a, 0xfc766ba3, 0x4b7146d6, 0x009 },
    { 0x00032b46, 0x00166eba, 0xffecbc8c, 0x091 },
    { 0x00032b46, 0x00166eba, 0xffecbc8b, 0x09d },
    { 0x493f772d, 0x65a93019, 0xe3964714, 0x085 },
    { 0x493f772d, 0x65a93019, 0xe3964713, 0x089 },
    { 0x4694cca0, 0x13061fc0, 0x338eace0, 0x000 },
    { 0x4694cca0, 0x13061fc0, 0x338eacdf, 0x018 },
    { 0x770e8001, 0xd8f5feb7, 0x9e18814a, 0x891 },
    { 0x770e8001, 0xd8f5feb7, 0x9e188149, 0x899 },
    { 0xbe25ce01, 0x63f7e45a, 0x5a2de9a7, 0x810 },
    { 0xbe25ce01, 0x63f7e45a, 0x5a2de9a6, 0x81c },
    { 0x003ca9bf, 0x005b6846, 0xffe14179, 0x081 },
    { 0x003ca9bf, 0x005b6846, 0xffe14178, 0x08d },
    { 0x8a9ad13b, 0xba1e9ec0, 0xd07c327b, 0x085 },
    { 0x8a9ad13b, 0xba1e9ec0, 0xd07c327a, 0x089 },
    { 0x30488de2, 0x6b5b2a05, 0xc4ed63dd, 0x095 },
    { 0x30488de2, 0x6b5b2a05, 0xc4ed63dc, 0x099 },
    { 0x6e23c47f, 0x2e39a656, 0x3fea1e29, 0x000 },
    { 0x6e23c47f, 0x2e39a656, 0x3fea1e28, 0x00c },
    { 0x4ad790a3, 0xa5632eeb, 0xa57461b8, 0x895 },
    { 0x4ad790a3, 0xa5632eeb, 0xa57461b7, 0x89d },
    { 0x000d6222, 0x0001899e, 0x000bd884, 0x014 },
    { 0x000d6222, 0x0001899e, 0x000bd883, 0x018 },
    { 0x1dce06d4, 0xc1227869, 0x5cab8e6b, 0x011 },
    { 0x1dce06d4, 0xc1227869, 0x5cab8e6a, 0x01d },
    { 0x7e0f3613, 0x58a75a0d, 0x2567dc06, 0x014 },
    { 0x7e0f3613, 0x58a75a0d, 0x2567dc05, 0x01c },
    { 0x13091820, 0xba0ee6a3, 0x58fa317d, 0x015 },
    { 0x13091820, 0xba0ee6a3, 0x58fa317c, 0x019 },
    { 0x6847f51c, 0x0c2d15ed, 0x5c1adf2f, 0x010 },
    { 0x6847f51c, 0x0c2d15ed, 0x5c1adf2e, 0x01c },
    { 0x132159d6, 0x00015bba, 0x131ffe1c, 0x010 },
    { 0x132159d6, 0x00015bba, 0x131ffe1b, 0x01c },
    { 0xd66b3bb7, 0x5a1d76e0, 0x7c4dc4d7, 0x804 },
    { 0xd66b3bb7, 0x5a1d76e0, 0x7c4dc4d6, 0x808 },
    { 0xc4679a58, 0xad0facd8, 0x1757ed80, 0x000 },
    { 0xc4679a58, 0xad0facd8, 0x1757ed7f, 0x018 },
    { 0xe01cd0d8, 0xc3d32560, 0x1c49ab78, 0x004 },
    { 0xe01cd0d8, 0xc3d32560, 0x1c49ab77, 0x00c },
    { 0x1b3ae469, 0x7769d849, 0xa3d10c20, 0x081 },
    { 0x1b3ae469, 0x7769d849, 0xa3d10c1f, 0x099 },
    { 0x00003db4, 0x39e2c500, 0xc61d78b4, 0x085 },
    { 0x00003db4, 0x39e2c500, 0xc61d78b3, 0x089 },
    { 0xd6f3a0b0, 0x14baaf69, 0xc238f147, 0x094 },
    { 0xd6f3a0b0, 0x14baaf69, 0xc238f146, 0x098 },
    { 0xac522120, 0xc3fcf36f, 0xe8552db1, 0x095 },
    { 0xac522120, 0xc3fcf36f, 0xe8552db0, 0x099 },
    { 0x93d1fe74, 0x7f989ca9, 0x143961cb, 0x810 },
    { 0x93d1fe74, 0x7f989ca9, 0x143961ca, 0x81c },
    { 0xfc555cb0, 0xaed6e53d, 0x4d7e7773, 0x010 },
    { 0xfc555cb0, 0xaed6e53d, 0x4d7e7772, 0x01c },
    { 0x00000f66, 0x00039e4a, 0xfffc711c, 0x091 },
    { 0x00000f66, 0x00039e4a, 0xfffc711b, 0x09d },
    /* 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 },
    { 0x7ffffffe, 0xffffffee, 0x80000010, 0x881 },
    { 0x7ffffffe, 0xffffffee, 0x8000000f, 0x89d },
    { 0xa5e1244d, 0xffffffa8, 0xa5e124a5, 0x085 },
    { 0xa5e1244d, 0xffffffa8, 0xa5e124a4, 0x089 },
    { 0x0001b787, 0x0000000b, 0x0001b77c, 0x010 },
    { 0x0001b787, 0x0000000b, 0x0001b77b, 0x01c },
    { 0x2832cbe1, 0x00000065, 0x2832cb7c, 0x010 },
    { 0x2832cbe1, 0x00000065, 0x2832cb7b, 0x01c },
    { 0x5d6289bc, 0xffffff89, 0x5d628a33, 0x005 },
    { 0x5d6289bc, 0xffffff89, 0x5d628a32, 0x009 },
    { 0xec68def2, 0xffffffa5, 0xec68df4d, 0x095 },
    { 0xec68def2, 0xffffffa5, 0xec68df4c, 0x099 },
    { 0x15602578, 0x0000003e, 0x1560253a, 0x014 },
    { 0x15602578, 0x0000003e, 0x15602539, 0x01c },
    { 0x009b2b25, 0xffffffa7, 0x009b2b7e, 0x015 },
    { 0x009b2b25, 0xffffffa7, 0x009b2b7d, 0x01d },
    { 0xecf7304b, 0xfffffffd, 0xecf7304e, 0x095 },
    { 0xecf7304b, 0xfffffffd, 0xecf7304d, 0x09d },
    { 0x2a419c9d, 0xffffffea, 0x2a419cb3, 0x001 },
    { 0x2a419c9d, 0xffffffea, 0x2a419cb2, 0x00d },
    { 0x2e780c00, 0xffffffd5, 0x2e780c2b, 0x015 },
    { 0x2e780c00, 0xffffffd5, 0x2e780c2a, 0x019 },
    { 0xffd81399, 0x00000061, 0xffd81338, 0x080 },
    { 0xffd81399, 0x00000061, 0xffd81337, 0x088 },
    { 0x00000af3, 0xffffffad, 0x00000b46, 0x011 },
    { 0x00000af3, 0xffffffad, 0x00000b45, 0x019 },
    { 0x4a21c51c, 0x00000076, 0x4a21c4a6, 0x004 },
    { 0x4a21c51c, 0x00000076, 0x4a21c4a5, 0x00c },
    { 0x3730151f, 0xffffff87, 0x37301598, 0x001 },
    { 0x3730151f, 0xffffff87, 0x37301597, 0x009 },
    { 0x3839489f, 0x00000062, 0x3839483d, 0x000 },
    { 0x3839489f, 0x00000062, 0x3839483c, 0x00c },
    { 0x5d1bc3e4, 0x0000007d, 0x5d1bc367, 0x010 },
    { 0x5d1bc3e4, 0x0000007d, 0x5d1bc366, 0x01c },
    { 0x00000a9c, 0x00000047, 0x00000a55, 0x004 },
    { 0x00000a9c, 0x00000047, 0x00000a54, 0x008 },
    { 0xe1605ff6, 0xffffff8c, 0xe160606a, 0x095 },
    { 0xe1605ff6, 0xffffff8c, 0xe1606069, 0x09d },
    { 0x6d98a2c6, 0x00000060, 0x6d98a266, 0x004 },
    { 0x6d98a2c6, 0x00000060, 0x6d98a265, 0x00c },
    { 0x41809a66, 0x00000022, 0x41809a44, 0x004 },
    { 0x41809a66, 0x00000022, 0x41809a43, 0x008 },
    { 0xc6ee2a7e, 0xffffff93, 0xc6ee2aeb, 0x085 },
    { 0xc6ee2a7e, 0xffffff93, 0xc6ee2aea, 0x089 },
    { 0x000014f5, 0x00000073, 0x00001482, 0x004 },
    { 0x000014f5, 0x00000073, 0x00001481, 0x00c },
    { 0x8539b96c, 0x00000022, 0x8539b94a, 0x080 },
    { 0x8539b96c, 0x00000022, 0x8539b949, 0x088 },
    { 0x0051fcc3, 0x00000032, 0x0051fc91, 0x000 },
    { 0x0051fcc3, 0x00000032, 0x0051fc90, 0x00c },
    { 0x23eb07dc, 0xfffffff0, 0x23eb07ec, 0x001 },
    { 0x23eb07dc, 0xfffffff0, 0x23eb07eb, 0x00d },
    { 0xa6abbc92, 0xffffffe7, 0xa6abbcab, 0x091 },
    { 0xa6abbc92, 0xffffffe7, 0xa6abbcaa, 0x09d },
    { 0x0000015c, 0x00000000, 0x0000015c, 0x004 },
    { 0x0000015c, 0x00000000, 0x0000015b, 0x008 },
    { 0x3da73d41, 0xffffffd9, 0x3da73d68, 0x011 },
    { 0x3da73d41, 0xffffffd9, 0x3da73d67, 0x019 },
    { 0x832e9950, 0xffffffd1, 0x832e997f, 0x091 },
    { 0x832e9950, 0xffffffd1, 0x832e997e, 0x09d },
    { 0xf6e59ad9, 0xffffffb7, 0xf6e59b22, 0x085 },
    { 0xf6e59ad9, 0xffffffb7, 0xf6e59b21, 0x08d },
    { 0x7bda84ca, 0x00000079, 0x7bda8451, 0x000 },
    { 0x7bda84ca, 0x00000079, 0x7bda8450, 0x00c },
    { 0x00000e0e, 0xffffffff, 0x00000e0f, 0x015 },
    { 0x00000e0e, 0xffffffff, 0x00000e0e, 0x019 },
};

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 },
    { 0x95, 0x68, 0x95, 0x814 },
    { 0xfe, 0x41, 0xfe, 0x084 },
    { 0x07, 0x33, 0x07, 0x085 },
    { 0xae, 0x71, 0xae, 0x800 },
    { 0xe0, 0xab, 0xe0, 0x014 },
    { 0xf8, 0x59, 0xf8, 0x094 },
    { 0x17, 0x0c, 0x17, 0x010 },
    { 0xab, 0x49, 0xab, 0x800 },
    { 0xde, 0xdf, 0xde, 0x095 },
    { 0x8c, 0x60, 0x8c, 0x800 },
    { 0xe3, 0x96, 0xe3, 0x014 },
    { 0xac, 0x5b, 0xac, 0x800 },
    { 0xbd, 0x0f, 0xbd, 0x090 },
    { 0x29, 0x65, 0x29, 0x081 },
    { 0xaf, 0xdf, 0xaf, 0x081 },
    { 0x35, 0x4e, 0x35, 0x095 },
    { 0x83, 0x65, 0x83, 0x814 },
    { 0xf8, 0x4d, 0xf8, 0x090 },
    { 0xfe, 0x07, 0xfe, 0x080 },
    { 0x28, 0xe2, 0x28, 0x001 },
    { 0xd4, 0x9f, 0xd4, 0x014 },
    { 0x92, 0x35, 0x92, 0x810 },
    { 0x17, 0xd5, 0x17, 0x005 },
    { 0x67, 0x96, 0x67, 0x885 },
    { 0xc7, 0x14, 0xc7, 0x080 },
    { 0xf0, 0x1c, 0xf0, 0x094 },
    { 0x0c, 0xf9, 0x0c, 0x001 },
    { 0xb3, 0xc5, 0xb3, 0x095 },
    { 0x81, 0x22, 0x81, 0x814 },
};

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 },
    { 0x7031, 0x06ff, 0x7031, 0x010 },
    { 0xf53c, 0x6088, 0xf53c, 0x084 },
    { 0xa954, 0x0218, 0xa954, 0x094 },
    { 0x3928, 0x1ce1, 0x3928, 0x004 },
    { 0x7f73, 0x66f2, 0x7f73, 0x004 },
    { 0xd3bb, 0xbcbb, 0xd3bb, 0x004 },
    { 0x012e, 0x0a3a, 0x012e, 0x081 },
    { 0xcf18, 0x36b7, 0xcf18, 0x080 },
    { 0x67b2, 0xfc96, 0x67b2, 0x011 },
    { 0x1f78, 0x0157, 0x1f78, 0x004 },
    { 0x6f3c, 0x0718, 0x6f3c, 0x004 },
    { 0xddf7, 0x9dae, 0xddf7, 0x010 },
    { 0x0006, 0x118b, 0x0006, 0x095 },
    { 0x5d2e, 0xb83a, 0x5d2e, 0x881 },
    { 0x23a9, 0x62bb, 0x23a9, 0x095 },
    { 0x0000, 0x0014, 0x0000, 0x091 },
    { 0x662d, 0x3720, 0x662d, 0x000 },
    { 0x24bc, 0xebb0, 0x24bc, 0x005 },
    { 0x00cd, 0x1a51, 0x00cd, 0x081 },
    { 0x3fb2, 0xc8b3, 0x3fb2, 0x015 },
    { 0x7821, 0xd56f, 0x7821, 0x895 },
    { 0x021a, 0x00de, 0x021a, 0x014 },
    { 0xa265, 0x97fa, 0xa265, 0x010 },
    { 0xceeb, 0xe477, 0xceeb, 0x085 },
    { 0x0020, 0x29db, 0x0020, 0x091 },
    { 0x9872, 0xa143, 0x9872, 0x091 },
    { 0x3f56, 0x60a2, 0x3f56, 0x085 },
    { 0x1e23, 0x3713, 0x1e23, 0x081 },
    { 0x66d8, 0x1670, 0x66d8, 0x000 },
    /* r/m16, imm8: */
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x044 },
    { 0x0000, 0xffff, 0x0000, 0x011 },
    { 0x057b, 0x0036, 0x057b, 0x000 },
    { 0x68a3, 0xfff3, 0x68a3, 0x001 },
    { 0xe3e2, 0xffed, 0xe3e2, 0x095 },
    { 0x0b50, 0x0004, 0x0b50, 0x010 },
    { 0x1ad8, 0x0049, 0x1ad8, 0x010 },
    { 0xc386, 0x0034, 0xc386, 0x080 },
    { 0x000f, 0xffb1, 0x000f, 0x001 },
    { 0x4e6e, 0x0017, 0x4e6e, 0x000 },
    { 0xb1e7, 0x0028, 0xb1e7, 0x090 },
    { 0x015f, 0xffef, 0x015f, 0x001 },
    { 0x0eb8, 0x0073, 0x0eb8, 0x000 },
    { 0xd4d4, 0x005b, 0xd4d4, 0x090 },
    { 0x2813, 0xffa7, 0x2813, 0x015 },
    { 0x68b1, 0xffc7, 0x68b1, 0x011 },
    { 0xd888, 0x0058, 0xd888, 0x084 },
    { 0x2ca3, 0xffc6, 0x2ca3, 0x015 },
    { 0x71a1, 0xffd0, 0x71a1, 0x005 },
    { 0x1434, 0xffa1, 0x1434, 0x005 },
    { 0x7fee, 0xffb7, 0x7fee, 0x881 },
    { 0x6c17, 0x005f, 0x6c17, 0x014 },
    { 0x3117, 0xffb5, 0x3117, 0x001 },
    { 0x002a, 0x006e, 0x002a, 0x091 },
    { 0x21f7, 0x0010, 0x21f7, 0x004 },
    { 0x04c3, 0x0035, 0x04c3, 0x014 },
    { 0x09bb, 0x0022, 0x09bb, 0x004 },
    { 0x1df3, 0xffa8, 0x1df3, 0x015 },
    { 0x8700, 0xffda, 0x8700, 0x091 },
    { 0x003e, 0xffb5, 0x003e, 0x001 },
    { 0xafc6, 0x005f, 0xafc6, 0x090 },
};

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 },
    { 0x770a3f3b, 0x81bd7796, 0x770a3f3b, 0x885 },
    { 0xf74abdd5, 0x0bf52822, 0xf74abdd5, 0x080 },
    { 0x034c41df, 0x0000b3a6, 0x034c41df, 0x004 },
    { 0xb1286d55, 0x552200a9, 0xb1286d55, 0x814 },
    { 0xab5982e9, 0xc1a1a53b, 0xab5982e9, 0x091 },
    { 0xdb66c553, 0xb824da32, 0xdb66c553, 0x004 },
    { 0xfb71463d, 0x89ba6d48, 0xfb71463d, 0x004 },
    { 0x0044c9a9, 0x04c0c7ee, 0x0044c9a9, 0x095 },
    { 0x4c85fd85, 0xf0c74e02, 0x4c85fd85, 0x001 },
    { 0xacd29f26, 0x37ce8ec7, 0xacd29f26, 0x814 },
    { 0x59ffc770, 0xa77eb839, 0x59ffc770, 0x891 },
    { 0xf070ba70, 0xb8e048bb, 0xf070ba70, 0x010 },
    { 0x00172dc5, 0x00000c46, 0x00172dc5, 0x010 },
    { 0x0e13b5c1, 0xf001991f, 0x0e13b5c1, 0x011 },
    { 0x78ebdad8, 0x446cb81a, 0x78ebdad8, 0x014 },
    { 0x5260334a, 0xe9c76986, 0x5260334a, 0x001 },
    { 0x62e0f1d7, 0x9e258cf8, 0x62e0f1d7, 0x891 },
    { 0x0e910bc0, 0x00f06887, 0x0e910bc0, 0x014 },
    { 0x525e866c, 0x7bcb25df, 0x525e866c, 0x095 },
    { 0x562392f7, 0x7985c24f, 0x562392f7, 0x091 },
    { 0xfc97ee09, 0x9a8cd0c6, 0xfc97ee09, 0x000 },
    { 0xd2dea59b, 0x174a8d9e, 0xd2dea59b, 0x090 },
    { 0x0000092e, 0x00000366, 0x0000092e, 0x000 },
    { 0x8da4bdb8, 0x3aa3a2da, 0x8da4bdb8, 0x814 },
    { 0x0d18d51d, 0x194f69a2, 0x0d18d51d, 0x085 },
    { 0xaca0387c, 0x4adc8c9b, 0xaca0387c, 0x804 },
    { 0x159319af, 0xec7b3b39, 0x159319af, 0x001 },
    { 0x0000000b, 0x0000aac1, 0x0000000b, 0x081 },
    { 0xe19e6c1b, 0xa7cb92ae, 0xe19e6c1b, 0x010 },
    { 0x260b12be, 0xe0fbac48, 0x260b12be, 0x001 },
    { 0xeaebdcb6, 0xe2e746bd, 0xeaebdcb6, 0x014 },
    { 0x3dd55505, 0x75685378, 0x3dd55505, 0x095 },
    { 0x07e14ee2, 0x50b8a831, 0x07e14ee2, 0x085 },
    /* r/m32, imm8: */
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x044 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x011 },
    { 0x7ffffffa, 0xffffffa1, 0x7ffffffa, 0x885 },
    { 0x6530fa42, 0xfffffff4, 0x6530fa42, 0x015 },
    { 0x004c6a4f, 0x00000019, 0x004c6a4f, 0x004 },
    { 0x0a4f964a, 0xffffff8f, 0x0a4f964a, 0x015 },
    { 0x00307442, 0x00000026, 0x00307442, 0x010 },
    { 0xb726c5c2, 0xffffffab, 0xb726c5c2, 0x095 },
    { 0x7426640a, 0x00000019, 0x7426640a, 0x000 },
    { 0x0002fb3d, 0x0000004c, 0x0002fb3d, 0x000 },
    { 0x38cd7570, 0x00000005, 0x38cd7570, 0x010 },
    { 0x018acc3f, 0xffffffe3, 0x018acc3f, 0x005 },
    { 0x92ce7b9a, 0x0000004c, 0x92ce7b9a, 0x094 },
    { 0x555e16d7, 0x0000000a, 0x555e16d7, 0x010 },
    { 0x0001e12c, 0xffffffc8, 0x0001e12c, 0x001 },
    { 0xc4bd6eb8, 0x00000049, 0xc4bd6eb8, 0x094 },
    { 0x3845a56b, 0xffffffa9, 0x3845a56b, 0x001 },
    { 0xbfe3dac2, 0x00000053, 0xbfe3dac2, 0x094 },
    { 0x8ba44e57, 0xffffff8d, 0x8ba44e57, 0x095 },
    { 0x0041a18d, 0x0000004c, 0x0041a18d, 0x004 },
    { 0x2063a424, 0x00000018, 0x2063a424, 0x014 },
    { 0x8b5857e9, 0xffffffd0, 0x8b5857e9, 0x081 },
    { 0x40599442, 0x0000000f, 0x40599442, 0x014 },
    { 0xb78e6c0f, 0x0000001b, 0xb78e6c0f, 0x080 },
    { 0x00010cd3, 0x0000002e, 0x00010cd3, 0x014 },
    { 0xb022b1f2, 0x00000061, 0xb022b1f2, 0x080 },
    { 0x1c065cb4, 0xffffff9f, 0x1c065cb4, 0x011 },
    { 0x1d90de0d, 0x00000078, 0x1d90de0d, 0x004 },
    { 0x62dcb147, 0x00000006, 0x62dcb147, 0x004 },
    { 0x00025b2a, 0x00000072, 0x00025b2a, 0x004 },
    { 0xb60e6b73, 0xffffff92, 0xb60e6b73, 0x085 },
    { 0xb9949929, 0x0000002a, 0xb9949929, 0x094 },
    { 0x5e0a4941, 0xffffffcf, 0x5e0a4941, 0x015 },
    { 0xec914060, 0x0000004f, 0xec914060, 0x094 },
    { 0x000001ed, 0xffffffa2, 0x000001ed, 0x005 },
};

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 },
    { 0x0075, 0x02d7, 0x0075, 0x000 },
    { 0x5437, 0x047a, 0x5437, 0x001 },
    { 0xfe09, 0x24f4, 0xfe09, 0x000 },
    { 0x0011, 0x11d6, 0x0011, 0x000 },
    { 0x9511, 0x9b86, 0x9511, 0x000 },
    { 0xb71a, 0x42db, 0xb71a, 0x000 },
    { 0x03ed, 0x0060, 0x03ed, 0x001 },
    { 0x9baa, 0xec43, 0x9baa, 0x001 },
    { 0x48fa, 0x38fe, 0x48fa, 0x001 },
    { 0x0074, 0x00f7, 0x0074, 0x000 },
    { 0x270b, 0x6493, 0x270b, 0x001 },
    { 0x00a1, 0x8aa6, 0x00a1, 0x000 },
    { 0x003a, 0x08f5, 0x003a, 0x001 },
    { 0xe72c, 0x3666, 0xe72c, 0x000 },
    { 0x636d, 0xc04a, 0x636d, 0x000 },
    { 0x01b1, 0x0020, 0x01b1, 0x001 },
    { 0x5fe6, 0x1e9c, 0x5fe6, 0x001 },
    { 0xb731, 0x2875, 0xb731, 0x001 },
    { 0x3310, 0x2388, 0x3310, 0x001 },
    { 0x40e4, 0x4cf2, 0x40e4, 0x001 },
    { 0xbb32, 0xee32, 0xbb32, 0x000 },
    { 0x00a9, 0x0177, 0x00a9, 0x001 },
    { 0xf569, 0xc1bd, 0xf569, 0x001 },
    { 0x7fce, 0xc51d, 0x7fce, 0x001 },
    { 0x0061, 0x010f, 0x0061, 0x000 },
    { 0xbb30, 0x521c, 0xbb30, 0x001 },
    { 0xdc6b, 0x31e8, 0xdc6b, 0x000 },
    { 0x022b, 0x00f7, 0x022b, 0x000 },
    { 0x8b21, 0x2ef8, 0x8b21, 0x001 },
};

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 },
    { 0x26ecbcb7, 0x8059c72b, 0x26ecbcb7, 0x005 },
    { 0x0622f90e, 0xa20d2a1b, 0x0622f90e, 0x004 },
    { 0x00fb645e, 0x26d74d5c, 0x00fb645e, 0x004 },
    { 0x4117e6f0, 0x483a971f, 0x4117e6f0, 0x004 },
    { 0x3e979944, 0x74ef83eb, 0x3e979944, 0x005 },
    { 0x58bdf547, 0x9f321501, 0x58bdf547, 0x005 },
    { 0x1101257a, 0x22439622, 0x1101257a, 0x004 },
    { 0x0000018c, 0x0021506f, 0x0000018c, 0x004 },
    { 0x0d67c205, 0x16f2dd23, 0x0d67c205, 0x004 },
    { 0xe294309a, 0xef02e032, 0xe294309a, 0x005 },
    { 0x65cd0aba, 0xb87b6d8c, 0x65cd0aba, 0x004 },
    { 0x6f55401f, 0x45e4ec53, 0x6f55401f, 0x004 },
    { 0x0020e097, 0x0000010e, 0x0020e097, 0x005 },
    { 0x904f1a89, 0xb95720bc, 0x904f1a89, 0x005 },
    { 0x9d234525, 0x7690afe8, 0x9d234525, 0x005 },
    { 0x150cc454, 0x392d926b, 0x150cc454, 0x004 },
    { 0x9ee7cc20, 0x840a798d, 0x9ee7cc20, 0x004 },
    { 0x000003c6, 0x0000897d, 0x000003c6, 0x004 },
    { 0x667282bb, 0x27e4f788, 0x667282bb, 0x004 },
    { 0xe9373701, 0x27fc589e, 0xe9373701, 0x005 },
    { 0x681e0194, 0x89f9b01f, 0x681e0194, 0x004 },
    { 0xe799e92a, 0x299ad8b5, 0xe799e92a, 0x004 },
    { 0x01111eff, 0x00f892e3, 0x01111eff, 0x005 },
    { 0x5873b6b8, 0x7d5c16c6, 0x5873b6b8, 0x004 },
    { 0xa8db6176, 0x1adb9eee, 0xa8db6176, 0x005 },
    { 0x489f49dc, 0xd1aa0ef0, 0x489f49dc, 0x005 },
    { 0xb3bab79f, 0xe76d4241, 0xb3bab79f, 0x005 },
    { 0x0003be4b, 0x000030ee, 0x0003be4b, 0x004 },
    { 0x674a778e, 0x09ef1fc9, 0x674a778e, 0x005 },
    { 0x320fca37, 0xeaa4fa8e, 0x320fca37, 0x005 },
    { 0x753d9681, 0x9e640a75, 0x753d9681, 0x005 },
    { 0xb9eab7bc, 0x60c4d62c, 0xb9eab7bc, 0x005 },
    { 0x08f5c197, 0x18ef8274, 0x08f5c197, 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 },
    { 0x000c, 0x0331, 0x000e, 0x004 },
    { 0x17a5, 0x6d02, 0x17a1, 0x005 },
    { 0xb92c, 0x0d2f, 0x392c, 0x005 },
    { 0x0be1, 0x038f, 0x8be1, 0x004 },
    { 0xf919, 0x1767, 0xf999, 0x004 },
    { 0x8cf6, 0x72d0, 0x8cf7, 0x004 },
    { 0x01e9, 0x0034, 0x01f9, 0x004 },
    { 0xd1e1, 0x2adf, 0x51e1, 0x005 },
    { 0xa354, 0xfb89, 0xa154, 0x005 },
    { 0x002b, 0x3d3f, 0x802b, 0x004 },
    { 0xc2cf, 0xc3bb, 0xcacf, 0x004 },
    { 0x5203, 0x75c5, 0x5223, 0x004 },
    { 0x2e98, 0x00c0, 0x2e99, 0x004 },
    { 0xb86c, 0xf99b, 0xb06c, 0x005 },
    { 0x61cd, 0xde59, 0x63cd, 0x004 },
    { 0x0841, 0x001f, 0x8841, 0x004 },
    { 0xc301, 0xafa8, 0xc201, 0x005 },
    { 0x4948, 0x454f, 0xc948, 0x004 },
    { 0x0821, 0x0068, 0x0921, 0x004 },
    { 0x69ab, 0x6635, 0x698b, 0x005 },
    { 0x5426, 0xafe2, 0x5422, 0x005 },
    { 0x241f, 0x0017, 0x249f, 0x004 },
    { 0x339f, 0x1ff9, 0x319f, 0x005 },
    { 0x3af7, 0x6562, 0x3af3, 0x005 },
    { 0x0152, 0x017d, 0x2152, 0x004 },
    { 0xe8ba, 0x2aaa, 0xecba, 0x004 },
    { 0x1346, 0x9296, 0x1306, 0x005 },
    { 0x00aa, 0x02d4, 0x00ba, 0x004 },
    { 0xcb16, 0x274a, 0xcf16, 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 },
    { 0xf92c9d26, 0x600167f0, 0xf92d9d26, 0x004 },
    { 0x3c4eeecd, 0x6220147d, 0x1c4eeecd, 0x005 },
    { 0x19d2bb95, 0x00000065, 0x19d2bbb5, 0x004 },
    { 0xf50b0e90, 0xe8e94bf8, 0xf40b0e90, 0x005 },
    { 0x658856d8, 0x19fdb2fb, 0x6d8856d8, 0x004 },
    { 0x9ef1aae5, 0xcc0ab042, 0x9ef1aae1, 0x005 },
    { 0x51b9c33b, 0xfac05f94, 0x51a9c33b, 0x005 },
    { 0x000002f4, 0x0020e333, 0x000802f4, 0x004 },
    { 0x14a459ce, 0x7203edf8, 0x15a459ce, 0x004 },
    { 0x5ffc4e6f, 0xed8169d0, 0x5ffd4e6f, 0x004 },
    { 0xcb4a0eda, 0x2b1530d3, 0xcb420eda, 0x005 },
    { 0xbc38a391, 0x6a7aa37a, 0xb838a391, 0x005 },
    { 0x000006e2, 0x0000018c, 0x000016e2, 0x004 },
    { 0xc61ee0a6, 0xad8932cb, 0xc61ee8a6, 0x004 },
    { 0x4a65e59b, 0xe7c54945, 0x4a65e5bb, 0x004 },
    { 0x894d863c, 0x80a7f2bd, 0xa94d863c, 0x004 },
    { 0x923156a1, 0x652e6d5b, 0x9a3156a1, 0x004 },
    { 0x001cb68c, 0x001d5bbf, 0x801cb68c, 0x004 },
    { 0x62128c23, 0xefae8022, 0x62128c27, 0x004 },
    { 0x695e50a2, 0x6efff1b9, 0x6b5e50a2, 0x004 },
    { 0xa556c0ca, 0xa28b20ec, 0xa556d0ca, 0x004 },
    { 0x9c1e987f, 0x5cadc845, 0x9c1e985f, 0x005 },
    { 0x000001df, 0x00007c13, 0x000801df, 0x004 },
    { 0x2834c4e1, 0xe069a466, 0x2834c4a1, 0x005 },
    { 0x77a83529, 0x443a541e, 0x37a83529, 0x005 },
    { 0x1168a090, 0xec0577b1, 0x116aa090, 0x004 },
    { 0x5af51c0b, 0x92042400, 0x5af51c0a, 0x005 },
    { 0x00000d30, 0x000001f6, 0x00400d30, 0x004 },
    { 0xeb88564b, 0x83d96c41, 0xeb885649, 0x005 },
    { 0x77522160, 0xb10d41ff, 0xf7522160, 0x004 },
    { 0x9d680655, 0x9877c588, 0x9d680755, 0x004 },
    { 0xdf497044, 0x7cf2c0b4, 0xdf597044, 0x004 },
    { 0x000028ee, 0x000007fe, 0x400028ee, 0x004 },
};

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 },
    { 0x01b9, 0x001f, 0x01b9, 0x000 },
    { 0xf791, 0x9085, 0xf791, 0x000 },
    { 0x4753, 0x9d30, 0x4752, 0x001 },
    { 0x0464, 0x0008, 0x0464, 0x000 },
    { 0x47dc, 0xbd63, 0x47d4, 0x001 },
    { 0xbf9c, 0x9ffd, 0x9f9c, 0x001 },
    { 0x00f6, 0x0004, 0x00e6, 0x001 },
    { 0x8770, 0xe1d6, 0x8730, 0x001 },
    { 0xe7bd, 0x38f9, 0xe5bd, 0x001 },
    { 0x3853, 0x0028, 0x3853, 0x000 },
    { 0xc37e, 0x9430, 0xc37e, 0x000 },
    { 0xfb6e, 0x2358, 0xfa6e, 0x001 },
    { 0x00a1, 0x086f, 0x00a1, 0x000 },
    { 0xdb90, 0xfd93, 0xdb90, 0x000 },
    { 0xca33, 0xecc5, 0xca13, 0x001 },
    { 0x0474, 0x213a, 0x0074, 0x001 },
    { 0x709d, 0x5780, 0x709c, 0x001 },
    { 0x95e3, 0x7131, 0x95e1, 0x001 },
    { 0x65eb, 0x0437, 0x656b, 0x001 },
    { 0x662a, 0x52a4, 0x662a, 0x000 },
    { 0xb4a7, 0x7200, 0xb4a6, 0x001 },
    { 0x2a99, 0x000b, 0x2299, 0x001 },
    { 0x3203, 0x804c, 0x2203, 0x001 },
    { 0x06ae, 0xa3ec, 0x06ae, 0x000 },
    { 0x1d15, 0x0040, 0x1d14, 0x001 },
    { 0x276c, 0x6399, 0x256c, 0x001 },
    { 0xea32, 0x8e17, 0xea32, 0x000 },
    { 0x0145, 0x1b2b, 0x0145, 0x000 },
    { 0x8c4f, 0x9a99, 0x8c4f, 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 },
    { 0xc88ed109, 0x583dcb16, 0xc88ed109, 0x000 },
    { 0x80e01dc9, 0x39c37791, 0x80e01dc9, 0x000 },
    { 0x0054a350, 0x000235f1, 0x0054a350, 0x000 },
    { 0xb75b818c, 0x58962ab8, 0xb65b818c, 0x001 },
    { 0xeacec377, 0x2c82f069, 0xeacec177, 0x001 },
    { 0x48759453, 0xdf5cfa4f, 0x48751453, 0x001 },
    { 0x1135689f, 0xc967a78c, 0x1135689f, 0x000 },
    { 0x000242d6, 0x0000d870, 0x000242d6, 0x000 },
    { 0x484fbd05, 0xeb02b859, 0x484fbd05, 0x000 },
    { 0x13cd26a7, 0x81a4a819, 0x11cd26a7, 0x001 },
    { 0xe1180226, 0xef353e96, 0xe1180226, 0x000 },
    { 0x10a022e4, 0x8152af43, 0x10a022e4, 0x000 },
    { 0x00bab8d4, 0x00423b74, 0x00aab8d4, 0x001 },
    { 0x1fcd55ae, 0xa1b422d1, 0x1fcd55ae, 0x000 },
    { 0xb959f973, 0x82082b43, 0xb959f973, 0x000 },
    { 0x26503cbf, 0xddc45413, 0x26503cbf, 0x000 },
    { 0xc46bbaa9, 0xfcabd056, 0xc42bbaa9, 0x001 },
    { 0x003cbfa9, 0x00006751, 0x003cbfa9, 0x000 },
    { 0x1c0ef8dc, 0x1a12f42b, 0x1c0ef0dc, 0x001 },
    { 0x525c406c, 0xe6899cb2, 0x5258406c, 0x001 },
    { 0xd48e7de2, 0x16ea8af9, 0xd48e7de2, 0x000 },
    { 0x0049ed30, 0xb572ea75, 0x0049ed30, 0x000 },
    { 0x178e29a8, 0x00000118, 0x168e29a8, 0x001 },
    { 0xfcec5d57, 0x41e43ad4, 0xfcec5d57, 0x000 },
    { 0x6ed23544, 0xeaa71b5f, 0x6ed23544, 0x000 },
    { 0x80f630ad, 0x2f8966fd, 0x80f630ad, 0x000 },
    { 0xe5c8846c, 0x8f6e02a8, 0xe5c8846c, 0x000 },
    { 0x000000fc, 0x000001e0, 0x000000fc, 0x000 },
    { 0x063cbcb6, 0xfd8974c0, 0x063cbcb6, 0x000 },
    { 0x4b5008d0, 0x7372957d, 0x4b5008d0, 0x000 },
    { 0xe7b45bee, 0xb1ff7a9f, 0x67b45bee, 0x001 },
    { 0xbbcb765d, 0xeac81329, 0xbbcb745d, 0x001 },
    { 0x00030da9, 0x00000279, 0x00030da9, 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 },
    { 0x021d, 0x72d6, 0x025d, 0x004 },
    { 0xd6dc, 0x3d14, 0xd6dc, 0x005 },
    { 0x295d, 0xc6a5, 0x297d, 0x004 },
    { 0x000a, 0x0bf2, 0x000e, 0x004 },
    { 0x70ab, 0x1ee6, 0x70eb, 0x004 },
    { 0xaf8c, 0x2ec8, 0xaf8c, 0x005 },
    { 0x044f, 0x001a, 0x044f, 0x005 },
    { 0x79be, 0xd659, 0x7bbe, 0x004 },
    { 0xa0ac, 0xbd29, 0xa2ac, 0x004 },
    { 0x378e, 0x0210, 0x378f, 0x004 },
    { 0x39cf, 0x4880, 0x39cf, 0x005 },
    { 0x0a9a, 0x3410, 0x0a9b, 0x004 },
    { 0x0042, 0x0009, 0x0242, 0x004 },
    { 0xe705, 0x2623, 0xe70d, 0x004 },
    { 0xc95d, 0x28a7, 0xc9dd, 0x004 },
    { 0x00e6, 0x259a, 0x04e6, 0x004 },
    { 0x8941, 0x31d9, 0x8b41, 0x004 },
    { 0xb988, 0xc759, 0xbb88, 0x004 },
    { 0x0033, 0x1a30, 0x0033, 0x005 },
    { 0x51bc, 0x3515, 0x51bc, 0x005 },
    { 0x08ad, 0xaeca, 0x0cad, 0x004 },
    { 0x1f4e, 0x0045, 0x1f6e, 0x004 },
    { 0x0d81, 0xc0c2, 0x0d85, 0x004 },
    { 0x2f37, 0xe62d, 0x2f37, 0x005 },
    { 0x10fc, 0x006f, 0x90fc, 0x004 },
    { 0xe801, 0xa9eb, 0xe801, 0x005 },
    { 0xb604, 0xc69c, 0xb604, 0x005 },
    { 0x0ca2, 0x064c, 0x1ca2, 0x004 },
    { 0x8b5d, 0xb9fc, 0x9b5d, 0x004 },
};

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 },
    { 0x5f3a6ab0, 0x743258d4, 0x5f3a6ab0, 0x001 },
    { 0x1565e111, 0x139b4ee4, 0x1565e111, 0x001 },
    { 0x0b73acf3, 0x00592b41, 0x0b73acf3, 0x001 },
    { 0x6026d02c, 0x942d2a05, 0x6026d02c, 0x001 },
    { 0x2121b89c, 0xecdf1ac2, 0x2121b89c, 0x001 },
    { 0x2b55cd91, 0x0e2b21a4, 0x2b55cd91, 0x001 },
    { 0xf1adbe13, 0x859a0bb3, 0xf1adbe13, 0x001 },
    { 0x00355091, 0x00000f1d, 0x20355091, 0x000 },
    { 0xa4eec4de, 0x37befe96, 0xa4eec4de, 0x001 },
    { 0xdc3c6745, 0x419ff17e, 0xdc3c6745, 0x001 },
    { 0x4c3eb76d, 0xe97c7c36, 0x4c7eb76d, 0x000 },
    { 0xabbed281, 0x7cee2996, 0xabfed281, 0x000 },
    { 0x0001ff1d, 0x00607a1a, 0x0401ff1d, 0x000 },
    { 0x00f0648b, 0x665902fb, 0x08f0648b, 0x000 },
    { 0x5dd2e13b, 0xffc1189c, 0x5dd2e13b, 0x001 },
    { 0xde36ca77, 0x1f265a20, 0xde36ca77, 0x001 },
    { 0x4ee6fada, 0xde5f05da, 0x4ee6fada, 0x001 },
    { 0x002db947, 0x0047b7c1, 0x002db947, 0x001 },
    { 0x5270f17c, 0x74fe0d59, 0x5270f17c, 0x001 },
    { 0x931e693d, 0x2efab13a, 0x971e693d, 0x000 },
    { 0xcc896eee, 0x12d1f283, 0xcc896eee, 0x001 },
    { 0xd588a0ef, 0xbcfdd6c7, 0xd588a0ef, 0x001 },
    { 0x000b3421, 0x000160cb, 0x000b3c21, 0x000 },
    { 0x681db886, 0x773d79fd, 0x681db886, 0x001 },
    { 0xa513ed60, 0xff454ca4, 0xa513ed70, 0x000 },
    { 0x5eaac36f, 0x1d04dcf7, 0x5eaac36f, 0x001 },
    { 0xea46eb03, 0x15ef27a4, 0xea46eb13, 0x000 },
    { 0x00021448, 0x481b9522, 0x0002144c, 0x000 },
    { 0xad3e1d7f, 0x8902940d, 0xad3e3d7f, 0x000 },
    { 0xc84606ed, 0x6d70d6ac, 0xc84616ed, 0x000 },
    { 0xcb1dee56, 0xda0a55cd, 0xcb1dee56, 0x001 },
    { 0x5c8733e9, 0xf0613574, 0x5c9733e9, 0x000 },
    { 0x0000b9af, 0x0000014f, 0x0000b9af, 0x001 },
};