/* $Id: bs3-cpu-instr-2-data16.c16 103602 2024-02-29 02:10:17Z 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 unsigned g_cBs3CpuInstr2_and_TestDataU8 = 48;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_and_TestDataU8[48] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0xff, 0xff, 0xff, 0x084 },
    { 0x00, 0xff, 0x00, 0x044 },
    { 0xb8, 0xa2, 0xa0, 0x084 },
    { 0x17, 0x84, 0x04, 0x000 },
    { 0x7b, 0x62, 0x62, 0x000 },
    { 0x09, 0x04, 0x00, 0x044 },
    { 0x39, 0xff, 0x39, 0x004 },
    { 0xb3, 0x2a, 0x22, 0x004 },
    { 0xfc, 0x60, 0x60, 0x004 },
    { 0x26, 0xf2, 0x22, 0x004 },
    { 0x8f, 0x62, 0x02, 0x000 },
    { 0x8f, 0x40, 0x00, 0x044 },
    { 0xcd, 0x2e, 0x0c, 0x004 },
    { 0x38, 0xa7, 0x20, 0x000 },
    { 0x2a, 0x52, 0x02, 0x000 },
    { 0x99, 0x4d, 0x09, 0x004 },
    { 0xbe, 0x02, 0x02, 0x000 },
    { 0x3e, 0x92, 0x12, 0x004 },
    { 0x3b, 0x45, 0x01, 0x000 },
    { 0xa7, 0xa1, 0xa1, 0x080 },
    { 0x95, 0x06, 0x04, 0x000 },
    { 0x25, 0xd6, 0x04, 0x000 },
    { 0x80, 0x28, 0x00, 0x044 },
    { 0x4b, 0xc8, 0x48, 0x004 },
    { 0x96, 0x42, 0x02, 0x000 },
    { 0xf6, 0x20, 0x20, 0x000 },
    { 0x49, 0xf1, 0x41, 0x004 },
    { 0x5c, 0x13, 0x10, 0x000 },
    { 0xa7, 0x13, 0x03, 0x004 },
    { 0x14, 0x65, 0x04, 0x000 },
    { 0x31, 0xc8, 0x00, 0x044 },
    { 0xeb, 0x92, 0x82, 0x084 },
    { 0x4a, 0x5f, 0x4a, 0x000 },
    { 0xa6, 0xac, 0xa4, 0x080 },
    { 0x3a, 0x35, 0x30, 0x004 },
    { 0x10, 0xf9, 0x10, 0x000 },
    { 0x8f, 0x7c, 0x0c, 0x004 },
    { 0x44, 0x90, 0x00, 0x044 },
    { 0x7c, 0x13, 0x10, 0x000 },
    { 0xc1, 0x50, 0x40, 0x000 },
    { 0x77, 0xc6, 0x46, 0x000 },
    { 0x96, 0x2a, 0x02, 0x000 },
    { 0x56, 0xa7, 0x06, 0x004 },
    { 0x43, 0xa6, 0x02, 0x000 },
    { 0x0f, 0x7e, 0x0e, 0x000 },
    { 0xe5, 0x7c, 0x64, 0x000 },
    { 0xbd, 0xc7, 0x85, 0x080 },
};

const unsigned g_cBs3CpuInstr2_and_TestDataU16 = 48;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_and_TestDataU16[48] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x084 },
    { 0x0000, 0xffff, 0x0000, 0x044 },
    { 0x016c, 0x001a, 0x0008, 0x000 },
    { 0x2040, 0x8a13, 0x0000, 0x044 },
    { 0xe5c9, 0x2416, 0x2400, 0x004 },
    { 0x0fac, 0x0592, 0x0580, 0x000 },
    { 0x4909, 0x164d, 0x0009, 0x004 },
    { 0x2224, 0x87ec, 0x0224, 0x004 },
    { 0x0243, 0x001c, 0x0000, 0x044 },
    { 0xc928, 0x7ba4, 0x4920, 0x000 },
    { 0x8af7, 0x8196, 0x8096, 0x084 },
    { 0x0056, 0x0018, 0x0010, 0x000 },
    { 0x2927, 0xe16c, 0x2124, 0x004 },
    { 0x7aa2, 0x461e, 0x4202, 0x000 },
    { 0x0035, 0x3d46, 0x0004, 0x000 },
    { 0xdb4e, 0xe81f, 0xc80e, 0x080 },
    { 0x876c, 0xd8eb, 0x8068, 0x080 },
    { 0x01a0, 0x020e, 0x0000, 0x044 },
    { 0x97b9, 0x2eac, 0x06a8, 0x000 },
    { 0x3295, 0xeeab, 0x2281, 0x004 },
    { 0x013e, 0x0152, 0x0112, 0x004 },
    { 0x5501, 0xe3c9, 0x4101, 0x000 },
    { 0xb84c, 0x9791, 0x9000, 0x084 },
    { 0x0034, 0x0016, 0x0014, 0x004 },
    { 0xe491, 0x1aad, 0x0081, 0x004 },
    { 0x8b3f, 0x141a, 0x001a, 0x000 },
    { 0x00e1, 0x3798, 0x0080, 0x000 },
    { 0x29bf, 0xdf30, 0x0930, 0x004 },
    { 0x0047, 0x3699, 0x0001, 0x000 },
    { 0x0834, 0x062c, 0x0024, 0x004 },
    { 0x07db, 0xc5c0, 0x05c0, 0x004 },
    { 0xec9e, 0x8997, 0x8896, 0x084 },
    { 0x016b, 0x4b25, 0x0121, 0x004 },
    { 0x24d5, 0x427f, 0x0055, 0x004 },
    { 0xde85, 0x0a7e, 0x0a04, 0x000 },
    { 0x003c, 0x0aed, 0x002c, 0x000 },
    { 0x2a8f, 0x2f5a, 0x2a0a, 0x004 },
    { 0xf78d, 0x5b3e, 0x530c, 0x004 },
    { 0x17c5, 0x4eaa, 0x0680, 0x000 },
    { 0x03b5, 0x6ab1, 0x02b1, 0x004 },
    { 0xa65a, 0x7887, 0x2002, 0x000 },
    { 0x017a, 0x1d07, 0x0102, 0x000 },
    { 0x08c0, 0x7b40, 0x0840, 0x000 },
    { 0xd43a, 0x3c82, 0x1402, 0x000 },
    { 0x61d8, 0x1480, 0x0080, 0x000 },
    { 0x5562, 0xbc3b, 0x1422, 0x004 },
    { 0x00f2, 0x2e3e, 0x0032, 0x000 },
};

const unsigned g_cBs3CpuInstr2_and_TestDataU32 = 48;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_and_TestDataU32[48] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x084 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x044 },
    { 0x000000bf, 0x00014a82, 0x00000082, 0x004 },
    { 0xf4c2ad38, 0xda446524, 0xd0402520, 0x080 },
    { 0x804c2bf5, 0x08d9e1fa, 0x004821f0, 0x004 },
    { 0x00766cf2, 0x18280a5a, 0x00200852, 0x000 },
    { 0xacbfa719, 0x1a739216, 0x08338210, 0x000 },
    { 0x597befeb, 0xd7c43a5f, 0x51402a4b, 0x004 },
    { 0x017ec7be, 0x00018fc5, 0x00008784, 0x004 },
    { 0xcc380771, 0x7270b2ce, 0x40300240, 0x000 },
    { 0x04eb2d14, 0xebdc9f65, 0x00c80d04, 0x000 },
    { 0x0000050e, 0x000004f0, 0x00000400, 0x004 },
    { 0xe9ad624e, 0x9f99c241, 0x89894240, 0x080 },
    { 0xa7a06a6f, 0x14abd28f, 0x04a0420f, 0x004 },
    { 0x0022cf32, 0x00ffdde2, 0x0022cd22, 0x004 },
    { 0x894050a4, 0x9d6e648e, 0x89404084, 0x084 },
    { 0x3a8bb5ba, 0x6a47e45d, 0x2a03a418, 0x004 },
    { 0x000001c2, 0x01a53469, 0x00000040, 0x000 },
    { 0x1d140fae, 0x1011983f, 0x1010082e, 0x004 },
    { 0xf322792a, 0x9c40cea0, 0x90004820, 0x080 },
    { 0x054a27d0, 0x004ab455, 0x004a2450, 0x004 },
    { 0xe0855d87, 0x93bf5abf, 0x80855887, 0x084 },
    { 0x77debbb9, 0x7ff6ac2a, 0x77d6a828, 0x004 },
    { 0x003f7aeb, 0x299275ca, 0x001270ca, 0x004 },
    { 0xce7356ec, 0xf64fa75d, 0xc643064c, 0x080 },
    { 0xa774e686, 0xebca7ba6, 0xa3406286, 0x080 },
    { 0x00001ae4, 0x02d247d4, 0x000002c4, 0x000 },
    { 0x3769e408, 0x88fa0677, 0x00680400, 0x004 },
    { 0xf9ea7073, 0x4e7cabb9, 0x48682031, 0x000 },
    { 0x093e8533, 0x004d59ea, 0x000c0122, 0x004 },
    { 0xa64a2a6c, 0x0f272c17, 0x06022804, 0x000 },
    { 0x54bfc29a, 0xf981171a, 0x5081021a, 0x000 },
    { 0x000f04aa, 0x0004d6bd, 0x000404a8, 0x000 },
    { 0xedae3b55, 0x49b981b4, 0x49a80114, 0x004 },
    { 0x71f2763c, 0xe53076c2, 0x61307600, 0x004 },
    { 0x00980da0, 0x0bbd23b4, 0x009801a0, 0x004 },
    { 0xdbae9360, 0xa24db2a6, 0x820c9220, 0x080 },
    { 0x9b0bc1e2, 0x60e5ea4d, 0x0001c040, 0x000 },
    { 0x00005150, 0x063bc30a, 0x00004100, 0x004 },
    { 0xad81f1c0, 0xee26ac6a, 0xac00a040, 0x080 },
    { 0x2d019ba5, 0xc49184b8, 0x040180a0, 0x004 },
    { 0x0fe494ab, 0x000005f4, 0x000004a0, 0x004 },
    { 0x4807e0cd, 0x3d37d7ac, 0x0807c08c, 0x000 },
    { 0x1d309d6d, 0x62af8ee7, 0x00208c65, 0x004 },
    { 0x014fdccf, 0x003be232, 0x000bc002, 0x000 },
    { 0x64ff6f27, 0x7dda9d3e, 0x64da0d26, 0x000 },
    { 0x9b89712b, 0xdc64ed00, 0x98006100, 0x084 },
};

const unsigned g_cBs3CpuInstr2_or_TestDataU8 = 48;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_or_TestDataU8[48] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0xff, 0xff, 0xff, 0x084 },
    { 0x00, 0xff, 0xff, 0x084 },
    { 0x90, 0x6f, 0xff, 0x084 },
    { 0x62, 0xce, 0xee, 0x084 },
    { 0x3f, 0x1b, 0x3f, 0x004 },
    { 0xbd, 0x03, 0xbf, 0x080 },
    { 0x52, 0x9a, 0xda, 0x080 },
    { 0xec, 0x5b, 0xff, 0x084 },
    { 0xb5, 0x56, 0xf7, 0x080 },
    { 0xd0, 0xf4, 0xf4, 0x080 },
    { 0xf9, 0x21, 0xf9, 0x084 },
    { 0x18, 0x0b, 0x1b, 0x004 },
    { 0xb0, 0x91, 0xb1, 0x084 },
    { 0x3d, 0x19, 0x3d, 0x000 },
    { 0x6d, 0xc7, 0xef, 0x080 },
    { 0x68, 0xd4, 0xfc, 0x084 },
    { 0x52, 0x03, 0x53, 0x004 },
    { 0xf7, 0x69, 0xff, 0x084 },
    { 0x57, 0x1a, 0x5f, 0x004 },
    { 0x4b, 0x04, 0x4f, 0x000 },
    { 0x50, 0xab, 0xfb, 0x080 },
    { 0xf6, 0xa3, 0xf7, 0x080 },
    { 0x13, 0xc9, 0xdb, 0x084 },
    { 0xfe, 0x70, 0xfe, 0x080 },
    { 0x15, 0x29, 0x3d, 0x000 },
    { 0x4e, 0xd6, 0xde, 0x084 },
    { 0xfa, 0xfb, 0xfb, 0x080 },
    { 0xf9, 0xc4, 0xfd, 0x080 },
    { 0x5d, 0x04, 0x5d, 0x000 },
    { 0x70, 0x17, 0x77, 0x004 },
    { 0x70, 0x36, 0x76, 0x000 },
    { 0x59, 0xd3, 0xdb, 0x084 },
    { 0x2f, 0xe7, 0xef, 0x080 },
    { 0x51, 0xda, 0xdb, 0x084 },
    { 0x0a, 0x0b, 0x0b, 0x000 },
    { 0xac, 0xda, 0xfe, 0x080 },
    { 0x5d, 0x99, 0xdd, 0x084 },
    { 0x4b, 0xfe, 0xff, 0x084 },
    { 0x48, 0x9e, 0xde, 0x084 },
    { 0xc9, 0xb0, 0xf9, 0x084 },
    { 0xd7, 0x87, 0xd7, 0x084 },
    { 0x01, 0x47, 0x47, 0x004 },
    { 0xaf, 0x88, 0xaf, 0x084 },
    { 0x55, 0x9a, 0xdf, 0x080 },
    { 0x55, 0xb8, 0xfd, 0x080 },
    { 0xb4, 0x4a, 0xfe, 0x080 },
    { 0x32, 0x29, 0x3b, 0x000 },
};

const unsigned g_cBs3CpuInstr2_or_TestDataU16 = 48;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_or_TestDataU16[48] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x084 },
    { 0x0000, 0xffff, 0xffff, 0x084 },
    { 0x0072, 0x000d, 0x007f, 0x000 },
    { 0x62c1, 0x768e, 0x76cf, 0x004 },
    { 0x7e71, 0x2ddd, 0x7ffd, 0x000 },
    { 0x001e, 0x0012, 0x001e, 0x004 },
    { 0xccb4, 0x6437, 0xecb7, 0x084 },
    { 0x6e0c, 0x16ff, 0x7eff, 0x004 },
    { 0x00e9, 0x023c, 0x02fd, 0x000 },
    { 0x274b, 0xb3a3, 0xb7eb, 0x084 },
    { 0xa794, 0x1763, 0xb7f7, 0x080 },
    { 0x0133, 0x1c97, 0x1db7, 0x004 },
    { 0xec78, 0xcceb, 0xecfb, 0x080 },
    { 0x5ae9, 0xa6fb, 0xfefb, 0x080 },
    { 0x078c, 0x303d, 0x37bd, 0x004 },
    { 0x9680, 0xaed2, 0xbed2, 0x084 },
    { 0x713f, 0xf5db, 0xf5ff, 0x084 },
    { 0x0025, 0x03b1, 0x03b5, 0x000 },
    { 0x985c, 0xf1c1, 0xf9dd, 0x084 },
    { 0xc79a, 0x500d, 0xd79f, 0x084 },
    { 0x063c, 0x02bc, 0x06bc, 0x000 },
    { 0x9fc2, 0xb417, 0xbfd7, 0x084 },
    { 0x925f, 0xc175, 0xd37f, 0x080 },
    { 0x00e2, 0x2fdb, 0x2ffb, 0x000 },
    { 0x24e3, 0xdb16, 0xfff7, 0x080 },
    { 0x96cb, 0x102f, 0x96ef, 0x080 },
    { 0x175d, 0x6244, 0x775d, 0x000 },
    { 0x9191, 0xf05e, 0xf1df, 0x080 },
    { 0xca18, 0x1fbd, 0xdfbd, 0x084 },
    { 0x235e, 0x409f, 0x63df, 0x000 },
    { 0x9994, 0xcb20, 0xdbb4, 0x084 },
    { 0xcc09, 0x86f5, 0xcefd, 0x080 },
    { 0x0057, 0x2c5d, 0x2c5f, 0x004 },
    { 0x2247, 0x8d4e, 0xaf4f, 0x080 },
    { 0x0287, 0x1497, 0x1697, 0x000 },
    { 0x2f48, 0x0982, 0x2fca, 0x004 },
    { 0x907d, 0x1ca6, 0x9cff, 0x084 },
    { 0xe74d, 0x9ce1, 0xffed, 0x084 },
    { 0x003e, 0x0038, 0x003e, 0x000 },
    { 0xc225, 0x4175, 0xc375, 0x080 },
    { 0xa2af, 0xba32, 0xbabf, 0x080 },
    { 0x0442, 0x03a5, 0x07e7, 0x004 },
    { 0x80a1, 0xe202, 0xe2a3, 0x084 },
    { 0x02af, 0x6cbb, 0x6ebf, 0x000 },
    { 0x0e33, 0x039c, 0x0fbf, 0x000 },
    { 0xf500, 0x102d, 0xf52d, 0x084 },
    { 0x0382, 0x4bd5, 0x4bd7, 0x004 },
};

const unsigned g_cBs3CpuInstr2_or_TestDataU32 = 48;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_or_TestDataU32[48] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x084 },
    { 0x00000000, 0xffffffff, 0xffffffff, 0x084 },
    { 0x000003ef, 0x3f892d52, 0x3f892fff, 0x004 },
    { 0x86fe8314, 0x6f4fba75, 0xefffbb75, 0x080 },
    { 0x56bf4e01, 0x699a2f51, 0x7fbf6f51, 0x000 },
    { 0x0000e993, 0x00000acb, 0x0000ebdb, 0x004 },
    { 0xe2e2dbb1, 0x1bc5535b, 0xfbe7dbfb, 0x080 },
    { 0x37e3aa6e, 0x83ca5940, 0xb7ebfb6e, 0x080 },
    { 0x05b62874, 0x0000016f, 0x05b6297f, 0x000 },
    { 0xe9d30acf, 0x9e6ab17c, 0xfffbbbff, 0x084 },
    { 0xaeaa7451, 0x78ba89c6, 0xfebafdd7, 0x084 },
    { 0x0000129c, 0x0012a614, 0x0012b69c, 0x004 },
    { 0xfc55a27a, 0x9a1e1688, 0xfe5fb6fa, 0x084 },
    { 0x808d7f2d, 0xc9988477, 0xc99dff7f, 0x080 },
    { 0x0000c9fe, 0x0004fe20, 0x0004fffe, 0x000 },
    { 0x220815f1, 0x00d8b37f, 0x22d8b7ff, 0x004 },
    { 0x12f05748, 0x60f241ae, 0x72f257ee, 0x004 },
    { 0x1b25caad, 0x000fd416, 0x1b2fdebf, 0x000 },
    { 0xe5ed16fa, 0xb07fab5d, 0xf5ffbfff, 0x084 },
    { 0x8dcb7f8b, 0xab2285c0, 0xafebffcb, 0x080 },
    { 0x0000000c, 0x00039905, 0x0003990d, 0x000 },
    { 0x45df439c, 0x84cfda9a, 0xc5dfdb9e, 0x080 },
    { 0x04fcd57e, 0x33246694, 0x37fcf7fe, 0x000 },
    { 0x2af43e8e, 0x3ee09918, 0x3ef4bf9e, 0x000 },
    { 0x0b6316e8, 0xd674df2f, 0xdf77dfef, 0x080 },
    { 0x12e8922d, 0x22d4f2e1, 0x32fcf2ed, 0x004 },
    { 0x000a8a3d, 0x00012766, 0x000baf7f, 0x000 },
    { 0x7d61d5be, 0x6217cc6d, 0x7f77ddff, 0x004 },
    { 0xc86e3a6b, 0xef8f2033, 0xefef3a7b, 0x084 },
    { 0x000038b2, 0x003751f3, 0x003779f3, 0x004 },
    { 0xe7e52cbb, 0x36dbde46, 0xf7fffeff, 0x084 },
    { 0x9cde02a0, 0x737e8601, 0xfffe86a1, 0x080 },
    { 0x003f7e68, 0x02b7b8c6, 0x02bffeee, 0x004 },
    { 0x7fc3d6b6, 0x9245676e, 0xffc7f7fe, 0x080 },
    { 0x8a8990f4, 0x8d8ba967, 0x8f8bb9f7, 0x080 },
    { 0x00bdf0df, 0x06e4106f, 0x06fdf0ff, 0x004 },
    { 0x86f31c2f, 0xc2bf5539, 0xc6ff5d3f, 0x084 },
    { 0x9f74336b, 0xdf9fd0ea, 0xdffff3eb, 0x084 },
    { 0x00000028, 0x75f6640c, 0x75f6642c, 0x000 },
    { 0x83228c55, 0x112b220e, 0x932bae5f, 0x084 },
    { 0xa6c8eec3, 0xd1b378ed, 0xf7fbfeef, 0x080 },
    { 0x3bcc986f, 0x00004f25, 0x3bccdf6f, 0x004 },
    { 0xeb600bac, 0xae9e8046, 0xeffe8bee, 0x084 },
    { 0x27f7ac66, 0xb55791dd, 0xb7f7bdff, 0x084 },
    { 0x000000f5, 0x00004ab6, 0x00004af7, 0x000 },
    { 0xe17c29d7, 0x1e9f1441, 0xffff3dd7, 0x084 },
    { 0x1deac71b, 0xe0b5edc8, 0xfdffefdb, 0x084 },
};

const unsigned g_cBs3CpuInstr2_xor_TestDataU8 = 48;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_xor_TestDataU8[48] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0xff, 0xff, 0x00, 0x044 },
    { 0x00, 0xff, 0xff, 0x084 },
    { 0x12, 0xb3, 0xa1, 0x080 },
    { 0x90, 0x01, 0x91, 0x080 },
    { 0x2e, 0x18, 0x36, 0x004 },
    { 0xed, 0x3a, 0xd7, 0x084 },
    { 0x31, 0x91, 0xa0, 0x084 },
    { 0x56, 0xd7, 0x81, 0x084 },
    { 0x7c, 0xa0, 0xdc, 0x080 },
    { 0x47, 0x11, 0x56, 0x004 },
    { 0xc0, 0x9d, 0x5d, 0x000 },
    { 0x90, 0xb7, 0x27, 0x004 },
    { 0x42, 0x2f, 0x6d, 0x000 },
    { 0xa8, 0x1e, 0xb6, 0x080 },
    { 0xb3, 0xb0, 0x03, 0x004 },
    { 0xcf, 0x0b, 0xc4, 0x080 },
    { 0x90, 0x56, 0xc6, 0x084 },
    { 0x10, 0xef, 0xff, 0x084 },
    { 0x23, 0x58, 0x7b, 0x004 },
    { 0x77, 0x14, 0x63, 0x004 },
    { 0xed, 0x57, 0xba, 0x080 },
    { 0xce, 0x48, 0x86, 0x080 },
    { 0x08, 0x79, 0x71, 0x004 },
    { 0x6c, 0xf7, 0x9b, 0x080 },
    { 0x49, 0x12, 0x5b, 0x000 },
    { 0x07, 0xb8, 0xbf, 0x080 },
    { 0x74, 0xe4, 0x90, 0x084 },
    { 0x42, 0xef, 0xad, 0x080 },
    { 0x91, 0x7d, 0xec, 0x080 },
    { 0xc3, 0x28, 0xeb, 0x084 },
    { 0x89, 0xe7, 0x6e, 0x000 },
    { 0x56, 0xfa, 0xac, 0x084 },
    { 0x0d, 0xf1, 0xfc, 0x084 },
    { 0xbf, 0x88, 0x37, 0x000 },
    { 0x1e, 0xd8, 0xc6, 0x084 },
    { 0x18, 0x4a, 0x52, 0x000 },
    { 0x2a, 0x3d, 0x17, 0x004 },
    { 0x4a, 0x47, 0x0d, 0x000 },
    { 0xcb, 0x51, 0x9a, 0x084 },
    { 0x49, 0xa8, 0xe1, 0x084 },
    { 0xf0, 0x07, 0xf7, 0x080 },
    { 0xda, 0x42, 0x98, 0x080 },
    { 0x8b, 0xeb, 0x60, 0x004 },
    { 0x1e, 0x1b, 0x05, 0x004 },
    { 0x95, 0xc6, 0x53, 0x004 },
    { 0x6d, 0xf9, 0x94, 0x080 },
    { 0xe5, 0x77, 0x92, 0x080 },
};

const unsigned g_cBs3CpuInstr2_xor_TestDataU16 = 48;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_xor_TestDataU16[48] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0x0000, 0x044 },
    { 0x0000, 0xffff, 0xffff, 0x084 },
    { 0x001b, 0x0292, 0x0289, 0x000 },
    { 0x587d, 0x9642, 0xce3f, 0x084 },
    { 0xe992, 0x7c46, 0x95d4, 0x084 },
    { 0x0e31, 0x00ff, 0x0ece, 0x000 },
    { 0xdac8, 0x9aec, 0x4024, 0x004 },
    { 0x1492, 0xbaa7, 0xae35, 0x084 },
    { 0x0055, 0x0017, 0x0042, 0x004 },
    { 0xbbfa, 0x4f13, 0xf4e9, 0x080 },
    { 0x7aba, 0x5b67, 0x21dd, 0x004 },
    { 0x0374, 0x0027, 0x0353, 0x004 },
    { 0xbb0f, 0xf23e, 0x4931, 0x000 },
    { 0xf496, 0xcf43, 0x3bd5, 0x000 },
    { 0x000a, 0x2838, 0x2832, 0x000 },
    { 0x370b, 0xeee3, 0xd9e8, 0x084 },
    { 0x8f18, 0x841a, 0x0b02, 0x000 },
    { 0x01c6, 0x0018, 0x01de, 0x004 },
    { 0x59cd, 0xa463, 0xfdae, 0x080 },
    { 0x94c3, 0xced1, 0x5a12, 0x004 },
    { 0x505e, 0x00d0, 0x508e, 0x004 },
    { 0x65da, 0xcdcb, 0xa811, 0x084 },
    { 0xe0fd, 0x146a, 0xf497, 0x080 },
    { 0x00a1, 0x04b3, 0x0412, 0x004 },
    { 0x0bef, 0x902f, 0x9bc0, 0x084 },
    { 0x3b78, 0x660c, 0x5d74, 0x004 },
    { 0x011f, 0x2e5b, 0x2f44, 0x004 },
    { 0x1400, 0x1180, 0x0580, 0x000 },
    { 0x0a89, 0xe784, 0xed0d, 0x080 },
    { 0x2d3c, 0x002d, 0x2d11, 0x004 },
    { 0x0f2e, 0xa2a7, 0xad89, 0x080 },
    { 0xc15d, 0x006d, 0xc130, 0x084 },
    { 0x0010, 0x0b50, 0x0b40, 0x000 },
    { 0x251d, 0xd355, 0xf648, 0x084 },
    { 0x77cb, 0xc3ab, 0xb460, 0x084 },
    { 0x06f8, 0x0439, 0x02c1, 0x000 },
    { 0x7122, 0x83f0, 0xf2d2, 0x084 },
    { 0x20d2, 0xe6f3, 0xc621, 0x084 },
    { 0x7de2, 0x03e7, 0x7e05, 0x004 },
    { 0x762c, 0x5767, 0x214b, 0x004 },
    { 0x535c, 0xfe9e, 0xadc2, 0x080 },
    { 0x0061, 0x1351, 0x1330, 0x004 },
    { 0x239f, 0xcf59, 0xecc6, 0x084 },
    { 0xe8eb, 0xcf5f, 0x27b4, 0x004 },
    { 0x22f3, 0x34ae, 0x165d, 0x000 },
    { 0x5592, 0x0a04, 0x5f96, 0x004 },
    { 0x8f78, 0x4ec3, 0xc1bb, 0x084 },
};

const unsigned g_cBs3CpuInstr2_xor_TestDataU32 = 48;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_xor_TestDataU32[48] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0x00000000, 0x044 },
    { 0x00000000, 0xffffffff, 0xffffffff, 0x084 },
    { 0x00014279, 0x000021d7, 0x000163ae, 0x000 },
    { 0xeba5e5e5, 0xd89833c6, 0x333dd623, 0x000 },
    { 0xb06f18c7, 0x8dc3c9a8, 0x3dacd16f, 0x004 },
    { 0x2dab8781, 0x0000ab2f, 0x2dab2cae, 0x000 },
    { 0x1529b6e1, 0x25a59975, 0x308c2f94, 0x000 },
    { 0x5afde3a2, 0x526bae86, 0x08964d24, 0x004 },
    { 0x023e294e, 0x0002c664, 0x023cef2a, 0x000 },
    { 0x99eaff65, 0xd3256e01, 0x4acf9164, 0x000 },
    { 0xbe592e4c, 0x50ee9f8e, 0xeeb7b1c2, 0x080 },
    { 0x0c23a8d7, 0x00256eb7, 0x0c06c660, 0x004 },
    { 0x5a87bc40, 0xc5581b5b, 0x9fdfa71b, 0x084 },
    { 0x5b6c16ee, 0x15557152, 0x4e3967bc, 0x000 },
    { 0x06e1c281, 0x0171d9bb, 0x07901b3a, 0x004 },
    { 0x0f8db2e4, 0xcb90cf11, 0xc41d7df5, 0x084 },
    { 0x900a6b05, 0x5bf83e50, 0xcbf25555, 0x084 },
    { 0x05c9be7b, 0x12648b22, 0x17ad3559, 0x004 },
    { 0xc6ea6e9d, 0x890408f7, 0x4fee666a, 0x004 },
    { 0xe7e894c0, 0xd67dfe8b, 0x31956a4b, 0x004 },
    { 0x00000125, 0x00000487, 0x000005a2, 0x000 },
    { 0xcfa0270b, 0x1b636c04, 0xd4c34b0f, 0x084 },
    { 0x1e03dc19, 0x4f671d87, 0x5164c19e, 0x000 },
    { 0x000f2abd, 0x000014e2, 0x000f3e5f, 0x004 },
    { 0x759d1e8d, 0x5e40d67a, 0x2bddc8f7, 0x000 },
    { 0x32c113ed, 0x62036776, 0x50c2749b, 0x000 },
    { 0x000199d7, 0x00caae5e, 0x00cb3789, 0x000 },
    { 0x0e7dc4b5, 0x62fd4e81, 0x6c808a34, 0x000 },
    { 0x242d29ec, 0x511b7855, 0x753651b9, 0x000 },
    { 0x00000056, 0x0071e506, 0x0071e550, 0x004 },
    { 0x9a72f6e3, 0x31aebea5, 0xabdc4846, 0x080 },
    { 0x87667cf2, 0xd994f7a9, 0x5ef28b5b, 0x000 },
    { 0x0067fd5c, 0x05c281d8, 0x05a57c84, 0x004 },
    { 0xf4dac84e, 0x479493fe, 0xb34e5bb0, 0x080 },
    { 0x6b800c95, 0x63ba2082, 0x083a2c17, 0x004 },
    { 0x00203b8c, 0x0000d2bb, 0x0020e937, 0x000 },
    { 0x67c50d83, 0x79fa27da, 0x1e3f2a59, 0x004 },
    { 0x964e97c6, 0x41ce539b, 0xd780c45d, 0x080 },
    { 0x003ca327, 0x0000073e, 0x003ca419, 0x000 },
    { 0x962b91b3, 0x066a8a24, 0x90411b97, 0x080 },
    { 0xe888423b, 0x09b4651a, 0xe13c2721, 0x084 },
    { 0x0000f9a6, 0x0d85cc2c, 0x0d85358a, 0x000 },
    { 0x0b1f63a3, 0xb9c688dc, 0xb2d9eb7f, 0x080 },
    { 0x994361f9, 0x56d55037, 0xcf9631ce, 0x080 },
    { 0x0000f86c, 0x03783743, 0x0378cf2f, 0x000 },
    { 0xb97419b1, 0x3542d0ee, 0x8c36c95f, 0x084 },
    { 0x75a2f566, 0x9d9d37e0, 0xe83fc286, 0x080 },
};

const unsigned g_cBs3CpuInstr2_test_TestDataU8 = 48;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_test_TestDataU8[48] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0xff, 0xff, 0xff, 0x084 },
    { 0x00, 0xff, 0x00, 0x044 },
    { 0x50, 0x58, 0x50, 0x004 },
    { 0x8b, 0x33, 0x8b, 0x004 },
    { 0x13, 0x35, 0x13, 0x004 },
    { 0xcf, 0x60, 0xcf, 0x000 },
    { 0x91, 0xc0, 0x91, 0x080 },
    { 0xb7, 0x73, 0xb7, 0x004 },
    { 0x4a, 0x05, 0x4a, 0x044 },
    { 0x88, 0xf4, 0x88, 0x080 },
    { 0x65, 0x73, 0x65, 0x000 },
    { 0xfa, 0x5f, 0xfa, 0x004 },
    { 0x83, 0xc6, 0x83, 0x084 },
    { 0x75, 0xf6, 0x75, 0x004 },
    { 0xd3, 0x77, 0xd3, 0x004 },
    { 0x56, 0xdb, 0x56, 0x000 },
    { 0x2b, 0x22, 0x2b, 0x004 },
    { 0x25, 0x83, 0x25, 0x000 },
    { 0xa3, 0x5e, 0xa3, 0x000 },
    { 0x7d, 0x31, 0x7d, 0x000 },
    { 0x6a, 0xb3, 0x6a, 0x004 },
    { 0xee, 0xb2, 0xee, 0x080 },
    { 0x2f, 0x9c, 0x2f, 0x004 },
    { 0x4f, 0xe2, 0x4f, 0x004 },
    { 0x54, 0x0b, 0x54, 0x044 },
    { 0x07, 0x08, 0x07, 0x044 },
    { 0x09, 0x15, 0x09, 0x000 },
    { 0xb6, 0xcd, 0xb6, 0x084 },
    { 0x30, 0xf6, 0x30, 0x004 },
    { 0x0d, 0x92, 0x0d, 0x044 },
    { 0x7b, 0x87, 0x7b, 0x004 },
    { 0x72, 0xe1, 0x72, 0x004 },
    { 0x1f, 0xaf, 0x1f, 0x004 },
    { 0x9f, 0x8a, 0x9f, 0x080 },
    { 0xde, 0x4f, 0xde, 0x004 },
    { 0xf8, 0xaa, 0xf8, 0x080 },
    { 0xa7, 0xfb, 0xa7, 0x084 },
    { 0x02, 0x55, 0x02, 0x044 },
    { 0xbb, 0xd7, 0xbb, 0x084 },
    { 0x4f, 0xee, 0x4f, 0x004 },
    { 0x5f, 0x96, 0x5f, 0x000 },
    { 0x91, 0x19, 0x91, 0x004 },
    { 0xb7, 0x5a, 0xb7, 0x004 },
    { 0x47, 0xd4, 0x47, 0x004 },
    { 0x5a, 0x60, 0x5a, 0x000 },
    { 0x6e, 0x36, 0x6e, 0x000 },
    { 0x5b, 0x7b, 0x5b, 0x000 },
};

const unsigned g_cBs3CpuInstr2_test_TestDataU16 = 48;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_test_TestDataU16[48] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x084 },
    { 0x0000, 0xffff, 0x0000, 0x044 },
    { 0x008b, 0x002e, 0x008b, 0x004 },
    { 0xd870, 0xac63, 0xd870, 0x084 },
    { 0xb182, 0x08e3, 0xb182, 0x004 },
    { 0x007e, 0x001a, 0x007e, 0x000 },
    { 0x338f, 0x2a75, 0x338f, 0x004 },
    { 0x865b, 0xe343, 0x865b, 0x080 },
    { 0x0ed5, 0x0c2a, 0x0ed5, 0x004 },
    { 0x6746, 0x496c, 0x6746, 0x004 },
    { 0x53b3, 0x3631, 0x53b3, 0x000 },
    { 0x1863, 0x0089, 0x1863, 0x000 },
    { 0xa74c, 0x86ab, 0xa74c, 0x080 },
    { 0x68ce, 0xc3d2, 0x68ce, 0x000 },
    { 0x03ff, 0x0019, 0x03ff, 0x000 },
    { 0xc655, 0x0ab0, 0xc655, 0x000 },
    { 0xdd8f, 0xefe7, 0xdd8f, 0x084 },
    { 0x0193, 0x05b2, 0x0193, 0x000 },
    { 0x302a, 0x4a8f, 0x302a, 0x004 },
    { 0xf975, 0xa9da, 0xf975, 0x084 },
    { 0x02be, 0x01d0, 0x02be, 0x004 },
    { 0xb5a8, 0x3739, 0xb5a8, 0x004 },
    { 0x868b, 0x1153, 0x868b, 0x004 },
    { 0x00e5, 0x0351, 0x00e5, 0x004 },
    { 0x042e, 0x6963, 0x042e, 0x004 },
    { 0x1eb0, 0xd446, 0x1eb0, 0x004 },
    { 0x1f97, 0x00f8, 0x1f97, 0x004 },
    { 0x3124, 0x43cb, 0x3124, 0x004 },
    { 0xede5, 0x6ab8, 0xede5, 0x004 },
    { 0x0259, 0x03d9, 0x0259, 0x004 },
    { 0x8b36, 0xb8c3, 0x8b36, 0x080 },
    { 0x44e4, 0x1574, 0x44e4, 0x000 },
    { 0x02e9, 0x0061, 0x02e9, 0x000 },
    { 0x1316, 0x4a44, 0x1316, 0x000 },
    { 0xeaec, 0x624a, 0xeaec, 0x004 },
    { 0x004d, 0x1a5e, 0x004d, 0x000 },
    { 0xa814, 0xf7bb, 0xa814, 0x080 },
    { 0x237e, 0x4630, 0x237e, 0x004 },
    { 0x0795, 0x0746, 0x0795, 0x000 },
    { 0xe019, 0x930d, 0xe019, 0x084 },
    { 0x486a, 0x2b4e, 0x486a, 0x000 },
    { 0x138c, 0x00c0, 0x138c, 0x000 },
    { 0x75d7, 0x92fc, 0x75d7, 0x004 },
    { 0x170e, 0xd315, 0x170e, 0x000 },
    { 0x0010, 0x0fa9, 0x0010, 0x044 },
    { 0x63a3, 0x6a7e, 0x63a3, 0x004 },
    { 0xaa1a, 0x9a7d, 0xaa1a, 0x084 },
};

const unsigned g_cBs3CpuInstr2_test_TestDataU32 = 48;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_test_TestDataU32[48] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x084 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x044 },
    { 0x00001140, 0x05f7291e, 0x00001140, 0x004 },
    { 0x532bb874, 0x1b5ad181, 0x532bb874, 0x004 },
    { 0xa7707a2e, 0x49659710, 0xa7707a2e, 0x004 },
    { 0x0000011e, 0x000edb9f, 0x0000011e, 0x004 },
    { 0x13a4c4bd, 0x66705e5e, 0x13a4c4bd, 0x000 },
    { 0x9b438109, 0x6ccc83da, 0x9b438109, 0x000 },
    { 0x00332cbb, 0x0000690c, 0x00332cbb, 0x000 },
    { 0x50ccb305, 0xeefd36b4, 0x50ccb305, 0x000 },
    { 0xb2127b85, 0x9b6b9345, 0xb2127b85, 0x084 },
    { 0x000000d8, 0x0009ecc6, 0x000000d8, 0x004 },
    { 0x25b7e8c4, 0x0e17c3ec, 0x25b7e8c4, 0x000 },
    { 0x7a3fe301, 0x3850955a, 0x7a3fe301, 0x004 },
    { 0x00006e86, 0x000069d3, 0x00006e86, 0x004 },
    { 0x3202b862, 0x10976468, 0x3202b862, 0x004 },
    { 0x8340f05a, 0x9c63c734, 0x8340f05a, 0x080 },
    { 0x06af6a36, 0x000102ab, 0x06af6a36, 0x004 },
    { 0x203e38e2, 0x9508aecb, 0x203e38e2, 0x000 },
    { 0xad0b9c36, 0x553cd528, 0xad0b9c36, 0x000 },
    { 0x000000c8, 0x04fe7330, 0x000000c8, 0x044 },
    { 0x88a10907, 0x8457cfd1, 0x88a10907, 0x080 },
    { 0xe10cc564, 0x0d735a03, 0xe10cc564, 0x004 },
    { 0x0043591f, 0x016f33ab, 0x0043591f, 0x000 },
    { 0xd7a95bc8, 0x2fc8d46e, 0xd7a95bc8, 0x004 },
    { 0xa9f29a44, 0xf66dfbdf, 0xa9f29a44, 0x084 },
    { 0x000000d4, 0x00001f7e, 0x000000d4, 0x000 },
    { 0x73adbdf0, 0x939112e5, 0x73adbdf0, 0x000 },
    { 0x996f826c, 0xe7db8d7f, 0x996f826c, 0x084 },
    { 0x00123f22, 0x00000548, 0x00123f22, 0x004 },
    { 0x78479d9b, 0x6c19a244, 0x78479d9b, 0x004 },
    { 0xc6ec34fa, 0xfd8a2d76, 0xc6ec34fa, 0x084 },
    { 0x00000d1f, 0x00000533, 0x00000d1f, 0x000 },
    { 0xf309bf32, 0xc4e785cb, 0xf309bf32, 0x080 },
    { 0x3c00f5c4, 0xa30735a2, 0x3c00f5c4, 0x000 },
    { 0x000005dd, 0x0027ba7c, 0x000005dd, 0x004 },
    { 0x31c4557d, 0x90c8bbe5, 0x31c4557d, 0x004 },
    { 0xeaa7bffe, 0x6b2df366, 0xeaa7bffe, 0x004 },
    { 0x04594227, 0x00001c1b, 0x04594227, 0x004 },
    { 0xcbdab299, 0x52cdf974, 0xcbdab299, 0x000 },
    { 0x10b43851, 0xe7dd5668, 0x10b43851, 0x000 },
    { 0x05204b1c, 0x002dbafd, 0x05204b1c, 0x000 },
    { 0xf64f4a99, 0x8faa9eaa, 0xf64f4a99, 0x084 },
    { 0x4a96b2ef, 0x2bbd6e57, 0x4a96b2ef, 0x004 },
    { 0x0acf788a, 0x0002e24b, 0x0acf788a, 0x004 },
    { 0x3206d905, 0x1f9211bf, 0x3206d905, 0x004 },
    { 0x5a5913c6, 0x4e2139ad, 0x5a5913c6, 0x004 },
};

const unsigned g_cBs3CpuInstr2_add_TestDataU8 = 48;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_add_TestDataU8[48] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0xff, 0xff, 0xfe, 0x091 },
    { 0x00, 0xff, 0xff, 0x084 },
    { 0xed, 0x99, 0x86, 0x091 },
    { 0xe8, 0xec, 0xd4, 0x095 },
    { 0x39, 0xdf, 0x18, 0x015 },
    { 0x29, 0xf1, 0x1a, 0x001 },
    { 0xf4, 0xda, 0xce, 0x081 },
    { 0xa6, 0x31, 0xd7, 0x084 },
    { 0xd5, 0xc6, 0x9b, 0x081 },
    { 0x4e, 0x1f, 0x6d, 0x010 },
    { 0xe9, 0x9d, 0x86, 0x091 },
    { 0x1e, 0xfd, 0x1b, 0x015 },
    { 0xe7, 0x33, 0x1a, 0x001 },
    { 0x91, 0x16, 0xa7, 0x080 },
    { 0x5e, 0x31, 0x8f, 0x880 },
    { 0x65, 0xd2, 0x37, 0x001 },
    { 0x1a, 0x85, 0x9f, 0x084 },
    { 0x97, 0xb5, 0x4c, 0x801 },
    { 0x4f, 0xa9, 0xf8, 0x090 },
    { 0x5d, 0x1f, 0x7c, 0x010 },
    { 0x20, 0xbd, 0xdd, 0x084 },
    { 0xee, 0x58, 0x46, 0x011 },
    { 0xc8, 0x1a, 0xe2, 0x094 },
    { 0x2b, 0x57, 0x82, 0x894 },
    { 0xa0, 0x12, 0xb2, 0x084 },
    { 0xfe, 0xb1, 0xaf, 0x085 },
    { 0xec, 0x1a, 0x06, 0x015 },
    { 0x36, 0xaa, 0xe0, 0x090 },
    { 0xe3, 0x99, 0x7c, 0x801 },
    { 0xe7, 0x92, 0x79, 0x801 },
    { 0x08, 0x66, 0x6e, 0x000 },
    { 0x7f, 0xf5, 0x74, 0x015 },
    { 0xfb, 0xfc, 0xf7, 0x091 },
    { 0x8e, 0x63, 0xf1, 0x090 },
    { 0x8e, 0xb4, 0x42, 0x815 },
    { 0x39, 0xd1, 0x0a, 0x005 },
    { 0xb4, 0x96, 0x4a, 0x801 },
    { 0xa4, 0x0c, 0xb0, 0x090 },
    { 0x7a, 0xfb, 0x75, 0x011 },
    { 0x58, 0x8d, 0xe5, 0x090 },
    { 0x71, 0x7c, 0xed, 0x884 },
    { 0xb1, 0x40, 0xf1, 0x080 },
    { 0xd5, 0xb2, 0x87, 0x085 },
    { 0xc4, 0x99, 0x5d, 0x801 },
    { 0x9a, 0xfc, 0x96, 0x095 },
    { 0x17, 0x0d, 0x24, 0x014 },
    { 0x57, 0x67, 0xbe, 0x884 },
};

const unsigned g_cBs3CpuInstr2_add_TestDataU16 = 48;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_add_TestDataU16[48] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xfffe, 0x091 },
    { 0x0000, 0xffff, 0xffff, 0x084 },
    { 0x01a3, 0x0015, 0x01b8, 0x004 },
    { 0xa095, 0xd189, 0x721e, 0x805 },
    { 0xa2ea, 0xb57c, 0x5866, 0x815 },
    { 0x0173, 0x0040, 0x01b3, 0x000 },
    { 0x3fc2, 0xd9eb, 0x19ad, 0x001 },
    { 0x144d, 0xda38, 0xee85, 0x090 },
    { 0x0790, 0x0022, 0x07b2, 0x004 },
    { 0x7b38, 0xc8c3, 0x43fb, 0x001 },
    { 0x7d70, 0x51f1, 0xcf61, 0x880 },
    { 0x0003, 0x08a0, 0x08a3, 0x004 },
    { 0x6df8, 0xe93a, 0x5732, 0x011 },
    { 0xe704, 0xe3e3, 0xcae7, 0x085 },
    { 0x119e, 0x0007, 0x11a5, 0x014 },
    { 0x1533, 0xdddd, 0xf310, 0x090 },
    { 0xdfd1, 0x4252, 0x2223, 0x001 },
    { 0x0852, 0x33b2, 0x3c04, 0x000 },
    { 0x70b0, 0x64b1, 0xd561, 0x880 },
    { 0xc84a, 0xa729, 0x6f73, 0x811 },
    { 0x0355, 0x12d4, 0x1629, 0x000 },
    { 0x4f37, 0xde05, 0x2d3c, 0x005 },
    { 0x2b89, 0x3ea7, 0x6a30, 0x014 },
    { 0x047b, 0x0010, 0x048b, 0x004 },
    { 0xb700, 0x8ad1, 0x41d1, 0x805 },
    { 0xd3fd, 0xa7d0, 0x7bcd, 0x801 },
    { 0x0072, 0x02e8, 0x035a, 0x004 },
    { 0x51e9, 0xa79a, 0xf983, 0x090 },
    { 0x9f0a, 0x62c0, 0x01ca, 0x005 },
    { 0x0031, 0x18b3, 0x18e4, 0x004 },
    { 0x08f5, 0x26af, 0x2fa4, 0x010 },
    { 0xd59a, 0x94f0, 0x6a8a, 0x801 },
    { 0x01d1, 0x01a0, 0x0371, 0x004 },
    { 0x4f52, 0xb4da, 0x042c, 0x001 },
    { 0x9222, 0x0b93, 0x9db5, 0x080 },
    { 0x0134, 0x00fa, 0x022e, 0x004 },
    { 0x8270, 0x9343, 0x15b3, 0x801 },
    { 0x2b98, 0x14fb, 0x4093, 0x014 },
    { 0x1769, 0x0008, 0x1771, 0x014 },
    { 0x4f22, 0x4849, 0x976b, 0x880 },
    { 0xcdf0, 0x496c, 0x175c, 0x005 },
    { 0x0120, 0x026d, 0x038d, 0x004 },
    { 0xda57, 0xa086, 0x7add, 0x805 },
    { 0xfa40, 0x92b1, 0x8cf1, 0x081 },
    { 0x1b79, 0x0001, 0x1b7a, 0x000 },
    { 0x4312, 0x7448, 0xb75a, 0x884 },
    { 0x3211, 0xfa35, 0x2c46, 0x001 },
};

const unsigned g_cBs3CpuInstr2_add_TestDataU32 = 48;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_add_TestDataU32[48] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xfffffffe, 0x091 },
    { 0x00000000, 0xffffffff, 0xffffffff, 0x084 },
    { 0x002496e7, 0x00001d39, 0x0024b420, 0x010 },
    { 0x9f548d67, 0x680f7542, 0x076402a9, 0x005 },
    { 0x4edb756d, 0x29fa6f8d, 0x78d5e4fa, 0x014 },
    { 0x000c85b5, 0x000003cd, 0x000c8982, 0x014 },
    { 0x7b44c9ea, 0xa124400c, 0x1c6909f6, 0x015 },
    { 0x52e8e4d3, 0x7807032b, 0xcaefe7fe, 0x880 },
    { 0x00a25f66, 0x0265f5bb, 0x03085521, 0x014 },
    { 0x5be7d587, 0x1173a061, 0x6d5b75e8, 0x004 },
    { 0x43919eb6, 0xcd4ae162, 0x10dc8018, 0x005 },
    { 0x00007cbe, 0x00004d5a, 0x0000ca18, 0x014 },
    { 0x79fa7338, 0xa9a2a018, 0x239d1350, 0x015 },
    { 0x33bc9d02, 0x63e829aa, 0x97a4c6ac, 0x884 },
    { 0x00000866, 0x0000008e, 0x000008f4, 0x010 },
    { 0x8871d292, 0x28b77392, 0xb1294624, 0x084 },
    { 0xe404abf3, 0x2eb511d1, 0x12b9bdc4, 0x001 },
    { 0x00050baf, 0x0c165aed, 0x0c1b669c, 0x014 },
    { 0xcfaba4a1, 0x0dc56ee4, 0xdd711385, 0x080 },
    { 0xa664c6ed, 0x6240054c, 0x08a4cc39, 0x015 },
    { 0x00000003, 0x0531e2a7, 0x0531e2aa, 0x004 },
    { 0x2e175504, 0xbdceb213, 0xebe60717, 0x084 },
    { 0x8d0d1d18, 0x57f13a2d, 0xe4fe5745, 0x090 },
    { 0x00002ff6, 0x0b19d321, 0x0b1a0317, 0x004 },
    { 0xbc74296d, 0xee4bd21c, 0xaabffb89, 0x091 },
    { 0x73cf64d6, 0xb4cb0ca8, 0x289a717e, 0x005 },
    { 0x0011d4fe, 0x02412785, 0x0252fc83, 0x010 },
    { 0x7f89c135, 0x6ceb9f29, 0xec75605e, 0x880 },
    { 0x211e749c, 0x1679df94, 0x37985430, 0x014 },
    { 0x000fdc61, 0x00000210, 0x000fde71, 0x004 },
    { 0xf003cecf, 0x49fe90a9, 0x3a025f78, 0x015 },
    { 0xa7cb6d32, 0x9c6e22da, 0x4439900c, 0x805 },
    { 0x00000247, 0x00000415, 0x0000065c, 0x004 },
    { 0x2fcff1e4, 0xfd11e915, 0x2ce1daf9, 0x005 },
    { 0x62dd8105, 0xbc41a1f8, 0x1f1f22fd, 0x001 },
    { 0x05b8b831, 0x002ecd7f, 0x05e785b0, 0x010 },
    { 0xf0354f3f, 0xfbe5eaa6, 0xec1b39e5, 0x091 },
    { 0x73905702, 0xc9407f94, 0x3cd0d696, 0x005 },
    { 0x008f2e5e, 0x00722e2c, 0x01015c8a, 0x010 },
    { 0x0e3570e3, 0x56864e5e, 0x64bbbf41, 0x014 },
    { 0x8b8329b3, 0x1026acac, 0x9ba9d65f, 0x084 },
    { 0x19da8112, 0x000000c4, 0x19da81d6, 0x000 },
    { 0x00b250ca, 0x7ad61ef4, 0x7b886fbe, 0x004 },
    { 0x96b6c61e, 0x7989080b, 0x103fce29, 0x011 },
    { 0x00000a6c, 0x0000d4c5, 0x0000df31, 0x010 },
    { 0x6330f38e, 0x22c62282, 0x85f71610, 0x890 },
    { 0xbe0396a3, 0x1d96e7f7, 0xdb9a7e9a, 0x084 },
};

const unsigned g_cBs3CpuInstr2_adc_TestDataU8 = 96;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_adc_TestDataU8[96] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0x00, 0x00, 0x01, 0x008 },
    { 0xff, 0xff, 0xfe, 0x091 },
    { 0xff, 0xff, 0xff, 0x09d },
    { 0x00, 0xff, 0xff, 0x084 },
    { 0x00, 0xff, 0x00, 0x05d },
    { 0x4e, 0x71, 0xbf, 0x880 },
    { 0x4e, 0x71, 0xc0, 0x89c },
    { 0x0d, 0xd5, 0xe2, 0x094 },
    { 0x0d, 0xd5, 0xe3, 0x098 },
    { 0xd9, 0x5c, 0x35, 0x015 },
    { 0xd9, 0x5c, 0x36, 0x01d },
    { 0x31, 0x36, 0x67, 0x000 },
    { 0x31, 0x36, 0x68, 0x008 },
    { 0xe8, 0x4a, 0x32, 0x011 },
    { 0xe8, 0x4a, 0x33, 0x01d },
    { 0xaa, 0xc1, 0x6b, 0x801 },
    { 0xaa, 0xc1, 0x6c, 0x80d },
    { 0x1a, 0x75, 0x8f, 0x880 },
    { 0x1a, 0x75, 0x90, 0x89c },
    { 0x39, 0x63, 0x9c, 0x884 },
    { 0x39, 0x63, 0x9d, 0x888 },
    { 0xf2, 0x8a, 0x7c, 0x801 },
    { 0xf2, 0x8a, 0x7d, 0x80d },
    { 0x12, 0xe8, 0xfa, 0x084 },
    { 0x12, 0xe8, 0xfb, 0x088 },
    { 0x1d, 0x8a, 0xa7, 0x090 },
    { 0x1d, 0x8a, 0xa8, 0x098 },
    { 0xc4, 0xe9, 0xad, 0x081 },
    { 0xc4, 0xe9, 0xae, 0x089 },
    { 0x67, 0x01, 0x68, 0x000 },
    { 0x67, 0x01, 0x69, 0x00c },
    { 0x58, 0x69, 0xc1, 0x890 },
    { 0x58, 0x69, 0xc2, 0x898 },
    { 0x2c, 0xb3, 0xdf, 0x080 },
    { 0x2c, 0xb3, 0xe0, 0x098 },
    { 0xe5, 0xfc, 0xe1, 0x095 },
    { 0xe5, 0xfc, 0xe2, 0x09d },
    { 0x01, 0x40, 0x41, 0x004 },
    { 0x01, 0x40, 0x42, 0x00c },
    { 0xda, 0xa3, 0x7d, 0x805 },
    { 0xda, 0xa3, 0x7e, 0x80d },
    { 0xf6, 0x93, 0x89, 0x081 },
    { 0xf6, 0x93, 0x8a, 0x089 },
    { 0xa5, 0xeb, 0x90, 0x095 },
    { 0xa5, 0xeb, 0x91, 0x099 },
    { 0x87, 0x36, 0xbd, 0x084 },
    { 0x87, 0x36, 0xbe, 0x08c },
    { 0x55, 0x7f, 0xd4, 0x894 },
    { 0x55, 0x7f, 0xd5, 0x898 },
    { 0xd4, 0x4e, 0x22, 0x015 },
    { 0xd4, 0x4e, 0x23, 0x019 },
    { 0x71, 0x29, 0x9a, 0x884 },
    { 0x71, 0x29, 0x9b, 0x888 },
    { 0x8a, 0xa5, 0x2f, 0x801 },
    { 0x8a, 0xa5, 0x30, 0x81d },
    { 0x3f, 0x6b, 0xaa, 0x894 },
    { 0x3f, 0x6b, 0xab, 0x898 },
    { 0xd3, 0x44, 0x17, 0x005 },
    { 0xd3, 0x44, 0x18, 0x00d },
    { 0x4f, 0x10, 0x5f, 0x004 },
    { 0x4f, 0x10, 0x60, 0x01c },
    { 0x54, 0x2a, 0x7e, 0x004 },
    { 0x54, 0x2a, 0x7f, 0x008 },
    { 0x55, 0x44, 0x99, 0x884 },
    { 0x55, 0x44, 0x9a, 0x88c },
    { 0x0e, 0x91, 0x9f, 0x084 },
    { 0x0e, 0x91, 0xa0, 0x09c },
    { 0xea, 0x7a, 0x64, 0x011 },
    { 0xea, 0x7a, 0x65, 0x01d },
    { 0x7a, 0xc9, 0x43, 0x011 },
    { 0x7a, 0xc9, 0x44, 0x01d },
    { 0x8f, 0xdc, 0x6b, 0x811 },
    { 0x8f, 0xdc, 0x6c, 0x81d },
    { 0xc3, 0xb2, 0x75, 0x801 },
    { 0xc3, 0xb2, 0x76, 0x809 },
    { 0x4f, 0x2b, 0x7a, 0x010 },
    { 0x4f, 0x2b, 0x7b, 0x01c },
    { 0xeb, 0x1c, 0x07, 0x011 },
    { 0xeb, 0x1c, 0x08, 0x019 },
    { 0x68, 0x88, 0xf0, 0x094 },
    { 0x68, 0x88, 0xf1, 0x098 },
    { 0x06, 0x80, 0x86, 0x080 },
    { 0x06, 0x80, 0x87, 0x08c },
    { 0x7e, 0xf8, 0x76, 0x011 },
    { 0x7e, 0xf8, 0x77, 0x01d },
    { 0xfe, 0x97, 0x95, 0x095 },
    { 0xfe, 0x97, 0x96, 0x09d },
    { 0xee, 0x2c, 0x1a, 0x011 },
    { 0xee, 0x2c, 0x1b, 0x01d },
    { 0x7b, 0xeb, 0x66, 0x015 },
    { 0x7b, 0xeb, 0x67, 0x019 },
    { 0x41, 0x7f, 0xc0, 0x894 },
    { 0x41, 0x7f, 0xc1, 0x898 },
    { 0x7f, 0x17, 0x96, 0x894 },
    { 0x7f, 0x17, 0x97, 0x898 },
};

const unsigned g_cBs3CpuInstr2_adc_TestDataU16 = 96;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_adc_TestDataU16[96] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0x0000, 0x0000, 0x0001, 0x008 },
    { 0xffff, 0xffff, 0xfffe, 0x091 },
    { 0xffff, 0xffff, 0xffff, 0x09d },
    { 0x0000, 0xffff, 0xffff, 0x084 },
    { 0x0000, 0xffff, 0x0000, 0x05d },
    { 0x1813, 0x1d14, 0x3527, 0x004 },
    { 0x1813, 0x1d14, 0x3528, 0x00c },
    { 0x2420, 0xcdfd, 0xf21d, 0x084 },
    { 0x2420, 0xcdfd, 0xf21e, 0x08c },
    { 0xc8b4, 0xaf4b, 0x77ff, 0x805 },
    { 0xc8b4, 0xaf4b, 0x7800, 0x81d },
    { 0x01e9, 0x23b4, 0x259d, 0x000 },
    { 0x01e9, 0x23b4, 0x259e, 0x008 },
    { 0x535c, 0xf5f8, 0x4954, 0x011 },
    { 0x535c, 0xf5f8, 0x4955, 0x01d },
    { 0x746c, 0x8e36, 0x02a2, 0x011 },
    { 0x746c, 0x8e36, 0x02a3, 0x01d },
    { 0x0626, 0x03da, 0x0a00, 0x014 },
    { 0x0626, 0x03da, 0x0a01, 0x018 },
    { 0x926e, 0x9bb0, 0x2e1e, 0x805 },
    { 0x926e, 0x9bb0, 0x2e1f, 0x809 },
    { 0x6522, 0xacb0, 0x11d2, 0x005 },
    { 0x6522, 0xacb0, 0x11d3, 0x009 },
    { 0x58f0, 0x0118, 0x5a08, 0x000 },
    { 0x58f0, 0x0118, 0x5a09, 0x00c },
    { 0x50a4, 0x48dd, 0x9981, 0x894 },
    { 0x50a4, 0x48dd, 0x9982, 0x89c },
    { 0xb9e2, 0xabbf, 0x65a1, 0x811 },
    { 0xb9e2, 0xabbf, 0x65a2, 0x819 },
    { 0x2d81, 0x0048, 0x2dc9, 0x004 },
    { 0x2d81, 0x0048, 0x2dca, 0x00c },
    { 0x78d5, 0x0a02, 0x82d7, 0x884 },
    { 0x78d5, 0x0a02, 0x82d8, 0x88c },
    { 0x1531, 0x6cc7, 0x81f8, 0x880 },
    { 0x1531, 0x6cc7, 0x81f9, 0x88c },
    { 0x022b, 0x0187, 0x03b2, 0x014 },
    { 0x022b, 0x0187, 0x03b3, 0x018 },
    { 0xb7d2, 0x68e2, 0x20b4, 0x005 },
    { 0xb7d2, 0x68e2, 0x20b5, 0x009 },
    { 0xf535, 0x8bac, 0x80e1, 0x095 },
    { 0xf535, 0x8bac, 0x80e2, 0x09d },
    { 0x0019, 0x00be, 0x00d7, 0x014 },
    { 0x0019, 0x00be, 0x00d8, 0x01c },
    { 0xe5b7, 0x7789, 0x5d40, 0x011 },
    { 0xe5b7, 0x7789, 0x5d41, 0x01d },
    { 0xf89c, 0xda8e, 0xd32a, 0x091 },
    { 0xf89c, 0xda8e, 0xd32b, 0x09d },
    { 0x03a2, 0x002e, 0x03d0, 0x010 },
    { 0x03a2, 0x002e, 0x03d1, 0x01c },
    { 0xf105, 0x8726, 0x782b, 0x805 },
    { 0xf105, 0x8726, 0x782c, 0x809 },
    { 0x04a9, 0x30cd, 0x3576, 0x010 },
    { 0x04a9, 0x30cd, 0x3577, 0x01c },
    { 0x3920, 0x0082, 0x39a2, 0x000 },
    { 0x3920, 0x0082, 0x39a3, 0x00c },
    { 0xa452, 0x06dc, 0xab2e, 0x084 },
    { 0xa452, 0x06dc, 0xab2f, 0x088 },
    { 0x5694, 0x4867, 0x9efb, 0x880 },
    { 0x5694, 0x4867, 0x9efc, 0x88c },
    { 0x01b7, 0x001d, 0x01d4, 0x014 },
    { 0x01b7, 0x001d, 0x01d5, 0x018 },
    { 0xd90c, 0xb6e1, 0x8fed, 0x085 },
    { 0xd90c, 0xb6e1, 0x8fee, 0x08d },
    { 0x96f9, 0xc847, 0x5f40, 0x811 },
    { 0x96f9, 0xc847, 0x5f41, 0x81d },
    { 0x00f6, 0x00e6, 0x01dc, 0x000 },
    { 0x00f6, 0x00e6, 0x01dd, 0x00c },
    { 0x6d3d, 0xfb93, 0x68d0, 0x011 },
    { 0x6d3d, 0xfb93, 0x68d1, 0x01d },
    { 0xab8b, 0x6917, 0x14a2, 0x011 },
    { 0xab8b, 0x6917, 0x14a3, 0x01d },
    { 0x0406, 0x0a44, 0x0e4a, 0x000 },
    { 0x0406, 0x0a44, 0x0e4b, 0x00c },
    { 0x769e, 0x9aaf, 0x114d, 0x015 },
    { 0x769e, 0x9aaf, 0x114e, 0x01d },
    { 0x8297, 0x8fa5, 0x123c, 0x805 },
    { 0x8297, 0x8fa5, 0x123d, 0x809 },
    { 0x0eec, 0x015f, 0x104b, 0x014 },
    { 0x0eec, 0x015f, 0x104c, 0x018 },
    { 0x5a24, 0x1bf8, 0x761c, 0x000 },
    { 0x5a24, 0x1bf8, 0x761d, 0x00c },
    { 0x73ac, 0x3a70, 0xae1c, 0x880 },
    { 0x73ac, 0x3a70, 0xae1d, 0x88c },
    { 0x003c, 0x002a, 0x0066, 0x014 },
    { 0x003c, 0x002a, 0x0067, 0x018 },
    { 0xf23d, 0x9981, 0x8bbe, 0x085 },
    { 0xf23d, 0x9981, 0x8bbf, 0x089 },
    { 0x1a0e, 0x937a, 0xad88, 0x094 },
    { 0x1a0e, 0x937a, 0xad89, 0x098 },
    { 0x0014, 0x0117, 0x012b, 0x004 },
    { 0x0014, 0x0117, 0x012c, 0x008 },
    { 0xbe3d, 0xbe8e, 0x7ccb, 0x811 },
    { 0xbe3d, 0xbe8e, 0x7ccc, 0x81d },
    { 0x6081, 0xca48, 0x2ac9, 0x005 },
    { 0x6081, 0xca48, 0x2aca, 0x00d },
};

const unsigned g_cBs3CpuInstr2_adc_TestDataU32 = 96;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_adc_TestDataU32[96] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0x00000000, 0x00000000, 0x00000001, 0x008 },
    { 0xffffffff, 0xffffffff, 0xfffffffe, 0x091 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x09d },
    { 0x00000000, 0xffffffff, 0xffffffff, 0x084 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x05d },
    { 0x00005f61, 0x0004fc1f, 0x00055b80, 0x010 },
    { 0x00005f61, 0x0004fc1f, 0x00055b81, 0x01c },
    { 0xfd9478aa, 0x1e7e214f, 0x1c1299f9, 0x015 },
    { 0xfd9478aa, 0x1e7e214f, 0x1c1299fa, 0x01d },
    { 0x6abcd92c, 0x54560e73, 0xbf12e79f, 0x884 },
    { 0x6abcd92c, 0x54560e73, 0xbf12e7a0, 0x89c },
    { 0x0000034e, 0x00000509, 0x00000857, 0x010 },
    { 0x0000034e, 0x00000509, 0x00000858, 0x018 },
    { 0x32e0292c, 0xdaaf21cc, 0x0d8f4af8, 0x011 },
    { 0x32e0292c, 0xdaaf21cc, 0x0d8f4af9, 0x01d },
    { 0xdfd3e5c3, 0xd091965b, 0xb0657c1e, 0x085 },
    { 0xdfd3e5c3, 0xd091965b, 0xb0657c1f, 0x089 },
    { 0x07ca34f7, 0x00010a54, 0x07cb3f4b, 0x004 },
    { 0x07ca34f7, 0x00010a54, 0x07cb3f4c, 0x008 },
    { 0xb78d1e84, 0x51cea96d, 0x095bc7f1, 0x011 },
    { 0xb78d1e84, 0x51cea96d, 0x095bc7f2, 0x019 },
    { 0x96d55d10, 0x11d0f1f9, 0xa8a64f09, 0x084 },
    { 0x96d55d10, 0x11d0f1f9, 0xa8a64f0a, 0x08c },
    { 0x016f42a9, 0x0032c5bb, 0x01a20864, 0x010 },
    { 0x016f42a9, 0x0032c5bb, 0x01a20865, 0x01c },
    { 0xc953a747, 0x930b2b19, 0x5c5ed260, 0x815 },
    { 0xc953a747, 0x930b2b19, 0x5c5ed261, 0x819 },
    { 0x423aa0e7, 0xd7199ed5, 0x19543fbc, 0x001 },
    { 0x423aa0e7, 0xd7199ed5, 0x19543fbd, 0x00d },
    { 0x0e9dc350, 0x0000196c, 0x0e9ddcbc, 0x000 },
    { 0x0e9dc350, 0x0000196c, 0x0e9ddcbd, 0x00c },
    { 0xb4b95c39, 0xf555bd39, 0xaa0f1972, 0x095 },
    { 0xb4b95c39, 0xf555bd39, 0xaa0f1973, 0x099 },
    { 0xafab25b0, 0xcd375e43, 0x7ce283f3, 0x805 },
    { 0xafab25b0, 0xcd375e43, 0x7ce283f4, 0x809 },
    { 0x1a39f582, 0x002f6341, 0x1a6958c3, 0x004 },
    { 0x1a39f582, 0x002f6341, 0x1a6958c4, 0x008 },
    { 0x285d4f3e, 0x45fd8426, 0x6e5ad364, 0x010 },
    { 0x285d4f3e, 0x45fd8426, 0x6e5ad365, 0x01c },
    { 0x06eedddc, 0x6c27bae5, 0x731698c1, 0x010 },
    { 0x06eedddc, 0x6c27bae5, 0x731698c2, 0x018 },
    { 0x0166cf2b, 0x52cb60b7, 0x54322fe2, 0x014 },
    { 0x0166cf2b, 0x52cb60b7, 0x54322fe3, 0x018 },
    { 0xe63ab8d8, 0x593d8083, 0x3f78395b, 0x001 },
    { 0xe63ab8d8, 0x593d8083, 0x3f78395c, 0x00d },
    { 0x14c0463a, 0xf88d21dd, 0x0d4d6817, 0x015 },
    { 0x14c0463a, 0xf88d21dd, 0x0d4d6818, 0x01d },
    { 0x00000147, 0x0002da8c, 0x0002dbd3, 0x010 },
    { 0x00000147, 0x0002da8c, 0x0002dbd4, 0x01c },
    { 0x684e1e51, 0xa0a88d56, 0x08f6aba7, 0x001 },
    { 0x684e1e51, 0xa0a88d56, 0x08f6aba8, 0x009 },
    { 0x99d73aad, 0x814d61ef, 0x1b249c9c, 0x815 },
    { 0x99d73aad, 0x814d61ef, 0x1b249c9d, 0x819 },
    { 0x006a4fae, 0x0037b337, 0x00a202e5, 0x010 },
    { 0x006a4fae, 0x0037b337, 0x00a202e6, 0x018 },
    { 0x97d70da3, 0x67c07562, 0xff978305, 0x084 },
    { 0x97d70da3, 0x67c07562, 0xff978306, 0x08c },
    { 0x4c5aaa25, 0x54586979, 0xa0b3139e, 0x880 },
    { 0x4c5aaa25, 0x54586979, 0xa0b3139f, 0x88c },
    { 0x0cf3cf46, 0x0000d099, 0x0cf49fdf, 0x000 },
    { 0x0cf3cf46, 0x0000d099, 0x0cf49fe0, 0x018 },
    { 0x674aed7d, 0xe82dde85, 0x4f78cc02, 0x011 },
    { 0x674aed7d, 0xe82dde85, 0x4f78cc03, 0x01d },
    { 0x5b6c2332, 0xe02ddfe3, 0x3b9a0315, 0x001 },
    { 0x5b6c2332, 0xe02ddfe3, 0x3b9a0316, 0x009 },
    { 0x1451e7ab, 0x000002b3, 0x1451ea5e, 0x000 },
    { 0x1451e7ab, 0x000002b3, 0x1451ea5f, 0x00c },
    { 0xbc07b0a9, 0x9cdf66dc, 0x58e71785, 0x811 },
    { 0xbc07b0a9, 0x9cdf66dc, 0x58e71786, 0x819 },
    { 0x4eda2526, 0x53bd0a3b, 0xa2972f61, 0x890 },
    { 0x4eda2526, 0x53bd0a3b, 0xa2972f62, 0x898 },
    { 0x019dc76e, 0x599d8b96, 0x5b3b5304, 0x010 },
    { 0x019dc76e, 0x599d8b96, 0x5b3b5305, 0x01c },
    { 0x363752d0, 0x2a1e1252, 0x60556522, 0x004 },
    { 0x363752d0, 0x2a1e1252, 0x60556523, 0x008 },
    { 0xdc44db18, 0xec8c1327, 0xc8d0ee3f, 0x085 },
    { 0xdc44db18, 0xec8c1327, 0xc8d0ee40, 0x099 },
    { 0x02804144, 0x00000e39, 0x02804f7d, 0x004 },
    { 0x02804144, 0x00000e39, 0x02804f7e, 0x00c },
    { 0xa46ca0c1, 0x97ae1269, 0x3c1ab32a, 0x801 },
    { 0xa46ca0c1, 0x97ae1269, 0x3c1ab32b, 0x80d },
    { 0xe53ab7a4, 0x31ee8314, 0x17293ab8, 0x005 },
    { 0xe53ab7a4, 0x31ee8314, 0x17293ab9, 0x009 },
    { 0x04854ff7, 0x000004b1, 0x048554a8, 0x000 },
    { 0x04854ff7, 0x000004b1, 0x048554a9, 0x00c },
    { 0x5c3ff6ae, 0x2b5c48d2, 0x879c3f80, 0x890 },
    { 0x5c3ff6ae, 0x2b5c48d2, 0x879c3f81, 0x89c },
    { 0x37b10a0e, 0x080b5a86, 0x3fbc6494, 0x010 },
    { 0x37b10a0e, 0x080b5a86, 0x3fbc6495, 0x01c },
    { 0x00000626, 0x0000a7d2, 0x0000adf8, 0x000 },
    { 0x00000626, 0x0000a7d2, 0x0000adf9, 0x00c },
    { 0xa368ea04, 0xbec996b9, 0x623280bd, 0x805 },
    { 0xa368ea04, 0xbec996b9, 0x623280be, 0x80d },
    { 0x24c68cb6, 0xa740346a, 0xcc06c120, 0x090 },
    { 0x24c68cb6, 0xa740346a, 0xcc06c121, 0x09c },
};

const unsigned g_cBs3CpuInstr2_sub_TestDataU8 = 48;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_sub_TestDataU8[48] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0xff, 0xff, 0x00, 0x044 },
    { 0x00, 0xff, 0x01, 0x011 },
    { 0x47, 0xc1, 0x86, 0x881 },
    { 0xf5, 0xa9, 0x4c, 0x010 },
    { 0x86, 0x60, 0x26, 0x800 },
    { 0x34, 0x51, 0xe3, 0x081 },
    { 0x57, 0x31, 0x26, 0x000 },
    { 0xd4, 0xeb, 0xe9, 0x091 },
    { 0xb6, 0xd0, 0xe6, 0x081 },
    { 0xa4, 0x9c, 0x08, 0x010 },
    { 0x35, 0x65, 0xd0, 0x081 },
    { 0x82, 0xc5, 0xbd, 0x095 },
    { 0x81, 0x3e, 0x43, 0x810 },
    { 0x0d, 0x77, 0x96, 0x085 },
    { 0xba, 0xa2, 0x18, 0x004 },
    { 0x4f, 0xc8, 0x87, 0x885 },
    { 0x45, 0xcd, 0x78, 0x015 },
    { 0x69, 0x46, 0x23, 0x000 },
    { 0x41, 0x01, 0x40, 0x000 },
    { 0xc2, 0x14, 0xae, 0x090 },
    { 0x5f, 0xa5, 0xba, 0x881 },
    { 0x02, 0x3f, 0xc3, 0x095 },
    { 0x71, 0xaf, 0xc2, 0x891 },
    { 0x17, 0x79, 0x9e, 0x091 },
    { 0xb1, 0xff, 0xb2, 0x095 },
    { 0x7b, 0xf4, 0x87, 0x885 },
    { 0xb2, 0xa4, 0x0e, 0x010 },
    { 0x18, 0x23, 0xf5, 0x085 },
    { 0x71, 0x29, 0x48, 0x014 },
    { 0x1b, 0x47, 0xd4, 0x085 },
    { 0xeb, 0x13, 0xd8, 0x084 },
    { 0x02, 0xb7, 0x4b, 0x015 },
    { 0x19, 0x45, 0xd4, 0x085 },
    { 0x80, 0x23, 0x5d, 0x810 },
    { 0xdb, 0xc2, 0x19, 0x000 },
    { 0x0f, 0xc4, 0x4b, 0x005 },
    { 0x70, 0x6c, 0x04, 0x010 },
    { 0x3c, 0x31, 0x0b, 0x000 },
    { 0xe4, 0x6b, 0x79, 0x810 },
    { 0x3b, 0xa0, 0x9b, 0x881 },
    { 0x09, 0x1e, 0xeb, 0x095 },
    { 0x93, 0x5a, 0x39, 0x814 },
    { 0x43, 0x98, 0xab, 0x891 },
    { 0x43, 0xb7, 0x8c, 0x891 },
    { 0x61, 0x97, 0xca, 0x895 },
    { 0xec, 0x01, 0xeb, 0x084 },
    { 0x92, 0xbb, 0xd7, 0x095 },
};

const unsigned g_cBs3CpuInstr2_sub_TestDataU16 = 48;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_sub_TestDataU16[48] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0x0000, 0x044 },
    { 0x0000, 0xffff, 0x0001, 0x011 },
    { 0x0ac4, 0x1e44, 0xec80, 0x081 },
    { 0xc69b, 0x0e9a, 0xb801, 0x080 },
    { 0xc0fd, 0x28fd, 0x9800, 0x084 },
    { 0x000b, 0x5ceb, 0xa320, 0x081 },
    { 0x8393, 0x4f17, 0x347c, 0x810 },
    { 0x82c6, 0x9731, 0xeb95, 0x085 },
    { 0x0004, 0x01ae, 0xfe56, 0x095 },
    { 0xb191, 0xd933, 0xd85e, 0x091 },
    { 0xbfdc, 0x0d3b, 0xb2a1, 0x080 },
    { 0x008a, 0x0007, 0x0083, 0x000 },
    { 0xded5, 0x9789, 0x474c, 0x010 },
    { 0xaa46, 0x0d62, 0x9ce4, 0x084 },
    { 0x001d, 0x0040, 0xffdd, 0x085 },
    { 0xfe5a, 0xeff6, 0x0e64, 0x000 },
    { 0x11c7, 0x397c, 0xd84b, 0x095 },
    { 0x03db, 0x001e, 0x03bd, 0x014 },
    { 0xab77, 0x1f0f, 0x8c68, 0x090 },
    { 0x4be3, 0x616b, 0xea78, 0x095 },
    { 0x02b3, 0x0192, 0x0121, 0x004 },
    { 0xdf64, 0x2e6a, 0xb0fa, 0x094 },
    { 0x3d70, 0xb7e1, 0x858f, 0x891 },
    { 0x003a, 0x0003, 0x0037, 0x000 },
    { 0x9603, 0xbc73, 0xd990, 0x085 },
    { 0x3708, 0x208a, 0x167e, 0x014 },
    { 0x07e1, 0x42c1, 0xc520, 0x081 },
    { 0x3b4d, 0x73eb, 0xc762, 0x081 },
    { 0x650d, 0x39dc, 0x2b31, 0x000 },
    { 0x00a0, 0x5caa, 0xa3f6, 0x095 },
    { 0xbf20, 0xdb98, 0xe388, 0x095 },
    { 0x0b95, 0x7529, 0x966c, 0x095 },
    { 0x000d, 0x0157, 0xfeb6, 0x081 },
    { 0x2116, 0x3995, 0xe781, 0x085 },
    { 0x762a, 0xfd2f, 0x78fb, 0x011 },
    { 0x07b1, 0x008b, 0x0726, 0x010 },
    { 0xaa2a, 0xd414, 0xd616, 0x081 },
    { 0x8a31, 0xc5a8, 0xc489, 0x091 },
    { 0x0051, 0x0913, 0xf73e, 0x091 },
    { 0x6e82, 0x21be, 0x4cc4, 0x010 },
    { 0x76d9, 0xda7f, 0x9c5a, 0x895 },
    { 0x03fd, 0x00a2, 0x035b, 0x000 },
    { 0x9a29, 0x1a5a, 0x7fcf, 0x814 },
    { 0x45ea, 0x2740, 0x1eaa, 0x004 },
    { 0x035e, 0x0e88, 0xf4d6, 0x081 },
    { 0x544a, 0xd4ff, 0x7f4b, 0x015 },
    { 0xb2e7, 0x9a85, 0x1862, 0x000 },
};

const unsigned g_cBs3CpuInstr2_sub_TestDataU32 = 48;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_sub_TestDataU32[48] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0x00000000, 0x044 },
    { 0x00000000, 0xffffffff, 0x00000001, 0x011 },
    { 0x0148a68a, 0x61b3dd77, 0x9f94c913, 0x081 },
    { 0x6790c0ea, 0xd06956f1, 0x972769f9, 0x885 },
    { 0x73caf0a1, 0xd07c156b, 0xa34edb36, 0x895 },
    { 0x01478173, 0x00001249, 0x01476f2a, 0x010 },
    { 0xa095afd9, 0x434be045, 0x5d49cf94, 0x800 },
    { 0xaa70f487, 0xddc5e0d5, 0xccab13b2, 0x085 },
    { 0x000000a1, 0x4c9c2b8c, 0xb363d515, 0x091 },
    { 0xa9935724, 0x483e32a2, 0x61552482, 0x804 },
    { 0x6b6e4ebb, 0xd6f30e17, 0x947b40a4, 0x881 },
    { 0x00004456, 0x00000008, 0x0000444e, 0x014 },
    { 0xc120a21c, 0x4572fdab, 0x7bada471, 0x804 },
    { 0xc06c092c, 0x74ce27eb, 0x4b9de141, 0x804 },
    { 0x00000034, 0x0000ab2d, 0xffff5507, 0x091 },
    { 0xdb564a2a, 0x7e1f3a3e, 0x5d370fec, 0x810 },
    { 0x3428fd22, 0x2f02ddee, 0x05261f34, 0x010 },
    { 0x000000b5, 0x010fe236, 0xfef01e7f, 0x091 },
    { 0x3f1ca05c, 0xb0643936, 0x8eb86726, 0x881 },
    { 0x03e8210c, 0xfcd19cd4, 0x07168438, 0x001 },
    { 0x0000471a, 0x0000001c, 0x000046fe, 0x010 },
    { 0xd0a10629, 0x3b9b9719, 0x95056f10, 0x080 },
    { 0xa3dd29b5, 0x4cdd3c78, 0x56ffed3d, 0x810 },
    { 0x01fa4c54, 0x00000d26, 0x01fa3f2e, 0x014 },
    { 0xe8650432, 0xbff68355, 0x286e80dd, 0x014 },
    { 0xbab5e07f, 0xbaa5f0c9, 0x000fefb6, 0x000 },
    { 0x00001dc2, 0x0000004e, 0x00001d74, 0x014 },
    { 0x011be498, 0x8e3cb7b9, 0x72df2cdf, 0x011 },
    { 0x7441facf, 0x17b967aa, 0x5c889325, 0x000 },
    { 0x0001fce5, 0x0f5a8b4a, 0xf0a7719b, 0x091 },
    { 0x616ee063, 0x764d94ba, 0xeb214ba9, 0x095 },
    { 0x9f5f7c03, 0x35c6d9df, 0x6998a224, 0x814 },
    { 0x05779adb, 0x00000ef6, 0x05778be5, 0x000 },
    { 0xb1e5ea81, 0x6d86f592, 0x445ef4ef, 0x810 },
    { 0xf7645b97, 0x1db953bd, 0xd9ab07da, 0x090 },
    { 0x04c2ae65, 0x000023ec, 0x04c28a79, 0x010 },
    { 0x80147cc7, 0x810becdb, 0xff088fec, 0x091 },
    { 0xb5eb3f39, 0xe783f3aa, 0xce674b8f, 0x091 },
    { 0x01bb884c, 0x000000a5, 0x01bb87a7, 0x000 },
    { 0x04c7b4f0, 0x53381bd7, 0xb18f9919, 0x091 },
    { 0x8662198a, 0xd27ab64c, 0xb3e7633e, 0x091 },
    { 0x08c91a00, 0x00003659, 0x08c8e3a7, 0x010 },
    { 0x790544e8, 0x88eef897, 0xf0164c51, 0x881 },
    { 0xc1028616, 0x4cb10ede, 0x74517738, 0x810 },
    { 0x03b7c82f, 0x03e18cd1, 0xffd63b5e, 0x081 },
    { 0x3ce4185c, 0x62fb8012, 0xd9e8984a, 0x081 },
    { 0x6d955082, 0x78e4508a, 0xf4b0fff8, 0x091 },
};

const unsigned g_cBs3CpuInstr2_sbb_TestDataU8 = 96;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_sbb_TestDataU8[96] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0x00, 0x00, 0xff, 0x09d },
    { 0xff, 0xff, 0x00, 0x044 },
    { 0xff, 0xff, 0xff, 0x09d },
    { 0x00, 0xff, 0x01, 0x011 },
    { 0x00, 0xff, 0x00, 0x05d },
    { 0x07, 0x5d, 0xaa, 0x095 },
    { 0x07, 0x5d, 0xa9, 0x09d },
    { 0x0d, 0x79, 0x94, 0x081 },
    { 0x0d, 0x79, 0x93, 0x08d },
    { 0x95, 0xc3, 0xd2, 0x085 },
    { 0x95, 0xc3, 0xd1, 0x08d },
    { 0x0a, 0xf1, 0x19, 0x001 },
    { 0x0a, 0xf1, 0x18, 0x00d },
    { 0x4f, 0xfa, 0x55, 0x005 },
    { 0x4f, 0xfa, 0x54, 0x009 },
    { 0x21, 0x82, 0x9f, 0x895 },
    { 0x21, 0x82, 0x9e, 0x899 },
    { 0x91, 0xa8, 0xe9, 0x091 },
    { 0x91, 0xa8, 0xe8, 0x09d },
    { 0xa7, 0x4c, 0x5b, 0x810 },
    { 0xa7, 0x4c, 0x5a, 0x81c },
    { 0x9f, 0x1c, 0x83, 0x080 },
    { 0x9f, 0x1c, 0x82, 0x08c },
    { 0x64, 0xdb, 0x89, 0x891 },
    { 0x64, 0xdb, 0x88, 0x89d },
    { 0x14, 0x67, 0xad, 0x091 },
    { 0x14, 0x67, 0xac, 0x09d },
    { 0xdf, 0xae, 0x31, 0x000 },
    { 0xdf, 0xae, 0x30, 0x00c },
    { 0xdb, 0xcf, 0x0c, 0x014 },
    { 0xdb, 0xcf, 0x0b, 0x018 },
    { 0x39, 0xf0, 0x49, 0x001 },
    { 0x39, 0xf0, 0x48, 0x00d },
    { 0xed, 0x8e, 0x5f, 0x014 },
    { 0xed, 0x8e, 0x5e, 0x018 },
    { 0xb6, 0x5a, 0x5c, 0x814 },
    { 0xb6, 0x5a, 0x5b, 0x818 },
    { 0x22, 0xd9, 0x49, 0x011 },
    { 0x22, 0xd9, 0x48, 0x01d },
    { 0x39, 0xd6, 0x63, 0x005 },
    { 0x39, 0xd6, 0x62, 0x009 },
    { 0xef, 0x35, 0xba, 0x080 },
    { 0xef, 0x35, 0xb9, 0x088 },
    { 0xaf, 0x2b, 0x84, 0x084 },
    { 0xaf, 0x2b, 0x83, 0x088 },
    { 0x1f, 0x5e, 0xc1, 0x081 },
    { 0x1f, 0x5e, 0xc0, 0x08d },
    { 0xc0, 0xb8, 0x08, 0x010 },
    { 0xc0, 0xb8, 0x07, 0x018 },
    { 0x9f, 0xb7, 0xe8, 0x085 },
    { 0x9f, 0xb7, 0xe7, 0x08d },
    { 0x24, 0x3b, 0xe9, 0x091 },
    { 0x24, 0x3b, 0xe8, 0x09d },
    { 0x05, 0x20, 0xe5, 0x081 },
    { 0x05, 0x20, 0xe4, 0x08d },
    { 0x70, 0xbc, 0xb4, 0x895 },
    { 0x70, 0xbc, 0xb3, 0x899 },
    { 0xf5, 0x73, 0x82, 0x084 },
    { 0xf5, 0x73, 0x81, 0x08c },
    { 0x0e, 0x56, 0xb8, 0x085 },
    { 0x0e, 0x56, 0xb7, 0x08d },
    { 0xb5, 0x04, 0xb1, 0x084 },
    { 0xb5, 0x04, 0xb0, 0x088 },
    { 0xdb, 0xac, 0x2f, 0x010 },
    { 0xdb, 0xac, 0x2e, 0x01c },
    { 0xb3, 0x02, 0xb1, 0x084 },
    { 0xb3, 0x02, 0xb0, 0x088 },
    { 0x2b, 0xf6, 0x35, 0x005 },
    { 0x2b, 0xf6, 0x34, 0x009 },
    { 0xaf, 0x22, 0x8d, 0x084 },
    { 0xaf, 0x22, 0x8c, 0x088 },
    { 0x3e, 0x99, 0xa5, 0x885 },
    { 0x3e, 0x99, 0xa4, 0x889 },
    { 0x70, 0x2c, 0x44, 0x014 },
    { 0x70, 0x2c, 0x43, 0x018 },
    { 0xce, 0xc5, 0x09, 0x004 },
    { 0xce, 0xc5, 0x08, 0x008 },
    { 0x86, 0x96, 0xf0, 0x085 },
    { 0x86, 0x96, 0xef, 0x099 },
    { 0xb6, 0x61, 0x55, 0x804 },
    { 0xb6, 0x61, 0x54, 0x808 },
    { 0x85, 0xdf, 0xa6, 0x095 },
    { 0x85, 0xdf, 0xa5, 0x09d },
    { 0x07, 0x0c, 0xfb, 0x091 },
    { 0x07, 0x0c, 0xfa, 0x09d },
    { 0x9a, 0xc6, 0xd4, 0x085 },
    { 0x9a, 0xc6, 0xd3, 0x089 },
    { 0xe1, 0xf2, 0xef, 0x091 },
    { 0xe1, 0xf2, 0xee, 0x09d },
    { 0xe1, 0xc7, 0x1a, 0x010 },
    { 0xe1, 0xc7, 0x19, 0x018 },
    { 0x65, 0x43, 0x22, 0x004 },
    { 0x65, 0x43, 0x21, 0x00c },
    { 0x7e, 0xbe, 0xc0, 0x885 },
    { 0x7e, 0xbe, 0xbf, 0x899 },
};

const unsigned g_cBs3CpuInstr2_sbb_TestDataU16 = 96;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_sbb_TestDataU16[96] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0x0000, 0x0000, 0xffff, 0x09d },
    { 0xffff, 0xffff, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x09d },
    { 0x0000, 0xffff, 0x0001, 0x011 },
    { 0x0000, 0xffff, 0x0000, 0x05d },
    { 0x0015, 0x0011, 0x0004, 0x000 },
    { 0x0015, 0x0011, 0x0003, 0x00c },
    { 0x2158, 0x27e2, 0xf976, 0x081 },
    { 0x2158, 0x27e2, 0xf975, 0x089 },
    { 0x9b08, 0x4b4f, 0x4fb9, 0x810 },
    { 0x9b08, 0x4b4f, 0x4fb8, 0x81c },
    { 0x0014, 0x000b, 0x0009, 0x014 },
    { 0x0014, 0x000b, 0x0008, 0x018 },
    { 0x2c9a, 0x3727, 0xf573, 0x081 },
    { 0x2c9a, 0x3727, 0xf572, 0x08d },
    { 0xf696, 0x08ec, 0xedaa, 0x094 },
    { 0xf696, 0x08ec, 0xeda9, 0x09c },
    { 0x01a0, 0x003a, 0x0166, 0x014 },
    { 0x01a0, 0x003a, 0x0165, 0x01c },
    { 0xafc6, 0xfa1e, 0xb5a8, 0x091 },
    { 0xafc6, 0xfa1e, 0xb5a7, 0x099 },
    { 0x0901, 0x25fa, 0xe307, 0x091 },
    { 0x0901, 0x25fa, 0xe306, 0x09d },
    { 0x3c37, 0x2f18, 0x0d1f, 0x010 },
    { 0x3c37, 0x2f18, 0x0d1e, 0x01c },
    { 0x1b25, 0x3eb9, 0xdc6c, 0x095 },
    { 0x1b25, 0x3eb9, 0xdc6b, 0x099 },
    { 0x1808, 0xd028, 0x47e0, 0x001 },
    { 0x1808, 0xd028, 0x47df, 0x019 },
    { 0x0171, 0x0776, 0xf9fb, 0x091 },
    { 0x0171, 0x0776, 0xf9fa, 0x09d },
    { 0xbb91, 0x47ba, 0x73d7, 0x814 },
    { 0xbb91, 0x47ba, 0x73d6, 0x818 },
    { 0x3416, 0xa434, 0x8fe2, 0x885 },
    { 0x3416, 0xa434, 0x8fe1, 0x88d },
    { 0x039c, 0x0150, 0x024c, 0x000 },
    { 0x039c, 0x0150, 0x024b, 0x00c },
    { 0xeb2e, 0x473c, 0xa3f2, 0x080 },
    { 0xeb2e, 0x473c, 0xa3f1, 0x088 },
    { 0xc83d, 0x4726, 0x8117, 0x084 },
    { 0xc83d, 0x4726, 0x8116, 0x088 },
    { 0x001d, 0x0033, 0xffea, 0x081 },
    { 0x001d, 0x0033, 0xffe9, 0x089 },
    { 0x5995, 0x58d3, 0x00c2, 0x000 },
    { 0x5995, 0x58d3, 0x00c1, 0x008 },
    { 0x8caf, 0x7672, 0x163d, 0x800 },
    { 0x8caf, 0x7672, 0x163c, 0x80c },
    { 0x0004, 0x013f, 0xfec5, 0x095 },
    { 0x0004, 0x013f, 0xfec4, 0x099 },
    { 0xd681, 0xbf2c, 0x1755, 0x014 },
    { 0xd681, 0xbf2c, 0x1754, 0x018 },
    { 0xeaad, 0x31f3, 0xb8ba, 0x080 },
    { 0xeaad, 0x31f3, 0xb8b9, 0x088 },
    { 0x1026, 0x0017, 0x100f, 0x014 },
    { 0x1026, 0x0017, 0x100e, 0x018 },
    { 0x749a, 0x5e03, 0x1697, 0x000 },
    { 0x749a, 0x5e03, 0x1696, 0x00c },
    { 0x2ff0, 0x603a, 0xcfb6, 0x091 },
    { 0x2ff0, 0x603a, 0xcfb5, 0x099 },
    { 0x042f, 0x002a, 0x0405, 0x004 },
    { 0x042f, 0x002a, 0x0404, 0x008 },
    { 0x9a61, 0x656b, 0x34f6, 0x814 },
    { 0x9a61, 0x656b, 0x34f5, 0x81c },
    { 0x8d3f, 0x5a51, 0x32ee, 0x804 },
    { 0x8d3f, 0x5a51, 0x32ed, 0x80c },
    { 0x3621, 0x0349, 0x32d8, 0x014 },
    { 0x3621, 0x0349, 0x32d7, 0x01c },
    { 0xda15, 0xbe8c, 0x1b89, 0x010 },
    { 0xda15, 0xbe8c, 0x1b88, 0x01c },
    { 0xec27, 0xff06, 0xed21, 0x085 },
    { 0xec27, 0xff06, 0xed20, 0x089 },
    { 0x0ef7, 0x0037, 0x0ec0, 0x004 },
    { 0x0ef7, 0x0037, 0x0ebf, 0x018 },
    { 0x7309, 0x6b5e, 0x07ab, 0x010 },
    { 0x7309, 0x6b5e, 0x07aa, 0x01c },
    { 0x1173, 0xa2ca, 0x6ea9, 0x015 },
    { 0x1173, 0xa2ca, 0x6ea8, 0x019 },
    { 0x0029, 0x1041, 0xefe8, 0x085 },
    { 0x0029, 0x1041, 0xefe7, 0x08d },
    { 0x7bb9, 0xda4a, 0xa16f, 0x895 },
    { 0x7bb9, 0xda4a, 0xa16e, 0x899 },
    { 0x3d45, 0x87d3, 0xb572, 0x885 },
    { 0x3d45, 0x87d3, 0xb571, 0x88d },
    { 0x0046, 0x00f1, 0xff55, 0x085 },
    { 0x0046, 0x00f1, 0xff54, 0x089 },
    { 0x6657, 0xe172, 0x84e5, 0x881 },
    { 0x6657, 0xe172, 0x84e4, 0x88d },
    { 0x3645, 0x0754, 0x2ef1, 0x000 },
    { 0x3645, 0x0754, 0x2ef0, 0x00c },
    { 0x1335, 0x06f5, 0x0c40, 0x000 },
    { 0x1335, 0x06f5, 0x0c3f, 0x01c },
    { 0xb5f7, 0x86d3, 0x2f24, 0x004 },
    { 0xb5f7, 0x86d3, 0x2f23, 0x008 },
    { 0xbc54, 0x38c9, 0x838b, 0x094 },
    { 0xbc54, 0x38c9, 0x838a, 0x098 },
};

const unsigned g_cBs3CpuInstr2_sbb_TestDataU32 = 96;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_sbb_TestDataU32[96] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0x00000000, 0x00000000, 0xffffffff, 0x09d },
    { 0xffffffff, 0xffffffff, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x09d },
    { 0x00000000, 0xffffffff, 0x00000001, 0x011 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x05d },
    { 0x000052ca, 0x0000033a, 0x00004f90, 0x004 },
    { 0x000052ca, 0x0000033a, 0x00004f8f, 0x018 },
    { 0x3fb655d0, 0x1bbc0c31, 0x23fa499f, 0x014 },
    { 0x3fb655d0, 0x1bbc0c31, 0x23fa499e, 0x018 },
    { 0x96c47330, 0xfb6680d0, 0x9b5df260, 0x085 },
    { 0x96c47330, 0xfb6680d0, 0x9b5df25f, 0x09d },
    { 0x0049bc1c, 0x0083df2a, 0xffc5dcf2, 0x081 },
    { 0x0049bc1c, 0x0083df2a, 0xffc5dcf1, 0x089 },
    { 0xd9b07c36, 0x51aaca67, 0x8805b1cf, 0x094 },
    { 0xd9b07c36, 0x51aaca67, 0x8805b1ce, 0x098 },
    { 0x63ce3940, 0x3810cbf0, 0x2bbd6d50, 0x004 },
    { 0x63ce3940, 0x3810cbf0, 0x2bbd6d4f, 0x018 },
    { 0x000369cc, 0x001224f2, 0xfff144da, 0x081 },
    { 0x000369cc, 0x001224f2, 0xfff144d9, 0x089 },
    { 0xc337aec8, 0xbcb3ce1e, 0x0683e0aa, 0x014 },
    { 0xc337aec8, 0xbcb3ce1e, 0x0683e0a9, 0x01c },
    { 0xc0a132b4, 0x9707e892, 0x29994a22, 0x004 },
    { 0xc0a132b4, 0x9707e892, 0x29994a21, 0x00c },
    { 0x00068e58, 0x000128b5, 0x000565a3, 0x004 },
    { 0x00068e58, 0x000128b5, 0x000565a2, 0x008 },
    { 0x317b9dbd, 0xeab0fcac, 0x46caa111, 0x005 },
    { 0x317b9dbd, 0xeab0fcac, 0x46caa110, 0x009 },
    { 0x07426910, 0xd8ffbdfc, 0x2e42ab14, 0x015 },
    { 0x07426910, 0xd8ffbdfc, 0x2e42ab13, 0x019 },
    { 0x0009de88, 0x00dabf86, 0xff2f1f02, 0x081 },
    { 0x0009de88, 0x00dabf86, 0xff2f1f01, 0x089 },
    { 0x3f540c64, 0x26f9ba8a, 0x185a51da, 0x010 },
    { 0x3f540c64, 0x26f9ba8a, 0x185a51d9, 0x018 },
    { 0xd545eed7, 0xa243702a, 0x33027ead, 0x010 },
    { 0xd545eed7, 0xa243702a, 0x33027eac, 0x01c },
    { 0x0000e215, 0x00036455, 0xfffd7dc0, 0x085 },
    { 0x0000e215, 0x00036455, 0xfffd7dbf, 0x099 },
    { 0x0db81dda, 0x72affb12, 0x9b0822c8, 0x081 },
    { 0x0db81dda, 0x72affb12, 0x9b0822c7, 0x089 },
    { 0xbf8c9590, 0xe6af625b, 0xd8dd3335, 0x095 },
    { 0xbf8c9590, 0xe6af625b, 0xd8dd3334, 0x099 },
    { 0x04f7fe77, 0x00021d42, 0x04f5e135, 0x004 },
    { 0x04f7fe77, 0x00021d42, 0x04f5e134, 0x008 },
    { 0x7a7f0dd1, 0xeb643257, 0x8f1adb7a, 0x891 },
    { 0x7a7f0dd1, 0xeb643257, 0x8f1adb79, 0x899 },
    { 0x9f955d29, 0x87175fc5, 0x187dfd64, 0x000 },
    { 0x9f955d29, 0x87175fc5, 0x187dfd63, 0x00c },
    { 0x0000023e, 0x00001786, 0xffffeab8, 0x085 },
    { 0x0000023e, 0x00001786, 0xffffeab7, 0x08d },
    { 0x9de97cc9, 0x4bff7f76, 0x51e9fd53, 0x804 },
    { 0x9de97cc9, 0x4bff7f76, 0x51e9fd52, 0x808 },
    { 0xb30942f4, 0x250adc2c, 0x8dfe66c8, 0x090 },
    { 0xb30942f4, 0x250adc2c, 0x8dfe66c7, 0x098 },
    { 0x002db5a0, 0x000005f1, 0x002dafaf, 0x014 },
    { 0x002db5a0, 0x000005f1, 0x002dafae, 0x018 },
    { 0x5d284654, 0xbf2143c0, 0x9e070294, 0x881 },
    { 0x5d284654, 0xbf2143c0, 0x9e070293, 0x88d },
    { 0xa0e712a1, 0x227818e7, 0x7e6ef9ba, 0x810 },
    { 0xa0e712a1, 0x227818e7, 0x7e6ef9b9, 0x818 },
    { 0x0000033c, 0x00000248, 0x000000f4, 0x000 },
    { 0x0000033c, 0x00000248, 0x000000f3, 0x00c },
    { 0x4d5df6ed, 0x93fe4876, 0xb95fae77, 0x885 },
    { 0x4d5df6ed, 0x93fe4876, 0xb95fae76, 0x889 },
    { 0xdb47453b, 0xe412327a, 0xf73512c1, 0x081 },
    { 0xdb47453b, 0xe412327a, 0xf73512c0, 0x08d },
    { 0x33b6ebaa, 0x000d6134, 0x33a98a76, 0x000 },
    { 0x33b6ebaa, 0x000d6134, 0x33a98a75, 0x008 },
    { 0xc9f8aa40, 0x247175b0, 0xa5873490, 0x084 },
    { 0xc9f8aa40, 0x247175b0, 0xa587348f, 0x098 },
    { 0x14e5a954, 0x31cff557, 0xe315b3fd, 0x091 },
    { 0x14e5a954, 0x31cff557, 0xe315b3fc, 0x09d },
    { 0x00030a30, 0x2efa043e, 0xd10905f2, 0x091 },
    { 0x00030a30, 0x2efa043e, 0xd10905f1, 0x099 },
    { 0x602c9a8a, 0x5055ea86, 0x0fd6b004, 0x000 },
    { 0x602c9a8a, 0x5055ea86, 0x0fd6b003, 0x00c },
    { 0x38982c9e, 0xce995619, 0x69fed685, 0x001 },
    { 0x38982c9e, 0xce995619, 0x69fed684, 0x00d },
    { 0x00005161, 0x00906d54, 0xff6fe40d, 0x091 },
    { 0x00005161, 0x00906d54, 0xff6fe40c, 0x09d },
    { 0x6cf9b910, 0xbee4e081, 0xae14d88f, 0x891 },
    { 0x6cf9b910, 0xbee4e081, 0xae14d88e, 0x89d },
    { 0x1470731e, 0x6295e1e1, 0xb1da913d, 0x081 },
    { 0x1470731e, 0x6295e1e1, 0xb1da913c, 0x08d },
    { 0x00003d8f, 0x0000707e, 0xffffcd11, 0x085 },
    { 0x00003d8f, 0x0000707e, 0xffffcd10, 0x089 },
    { 0xc7129a37, 0x964ab555, 0x30c7e4e2, 0x004 },
    { 0xc7129a37, 0x964ab555, 0x30c7e4e1, 0x00c },
    { 0x82c6eae2, 0x91669cda, 0xf1604e08, 0x091 },
    { 0x82c6eae2, 0x91669cda, 0xf1604e07, 0x099 },
    { 0x00001ddf, 0x01a795ad, 0xfe588832, 0x081 },
    { 0x00001ddf, 0x01a795ad, 0xfe588831, 0x089 },
    { 0x89539e03, 0x90aafc91, 0xf8a8a172, 0x085 },
    { 0x89539e03, 0x90aafc91, 0xf8a8a171, 0x08d },
    { 0xc9ab9c23, 0x6197e39e, 0x6813b885, 0x810 },
    { 0xc9ab9c23, 0x6197e39e, 0x6813b884, 0x81c },
};

const unsigned g_cBs3CpuInstr2_cmp_TestDataU8 = 48;
const BS3CPUINSTR2BIN8 g_aBs3CpuInstr2_cmp_TestDataU8[48] =
{
    { 0x00, 0x00, 0x00, 0x044 },
    { 0xff, 0xff, 0xff, 0x044 },
    { 0x00, 0xff, 0x00, 0x011 },
    { 0x4c, 0x9a, 0x4c, 0x885 },
    { 0x29, 0x08, 0x29, 0x004 },
    { 0x76, 0xc4, 0x76, 0x885 },
    { 0x67, 0x0e, 0x67, 0x014 },
    { 0x09, 0xdf, 0x09, 0x011 },
    { 0x19, 0xcd, 0x19, 0x011 },
    { 0x20, 0x76, 0x20, 0x095 },
    { 0x18, 0xbb, 0x18, 0x011 },
    { 0xa1, 0x99, 0xa1, 0x010 },
    { 0xd3, 0xd1, 0xd3, 0x000 },
    { 0x47, 0xcd, 0x47, 0x011 },
    { 0x08, 0xaa, 0x08, 0x011 },
    { 0x52, 0xa6, 0x52, 0x895 },
    { 0x55, 0x81, 0x55, 0x885 },
    { 0x50, 0xa1, 0x50, 0x895 },
    { 0xee, 0xae, 0xee, 0x000 },
    { 0x7f, 0x00, 0x7f, 0x000 },
    { 0x78, 0x45, 0x78, 0x004 },
    { 0x17, 0xe1, 0x17, 0x005 },
    { 0x61, 0x95, 0x61, 0x895 },
    { 0x6e, 0x72, 0x6e, 0x085 },
    { 0x9e, 0x42, 0x9e, 0x804 },
    { 0x13, 0x0b, 0x13, 0x010 },
    { 0x79, 0x64, 0x79, 0x000 },
    { 0xc1, 0xac, 0xc1, 0x010 },
    { 0x53, 0x4f, 0x53, 0x010 },
    { 0xe9, 0xa8, 0xe9, 0x004 },
    { 0xec, 0x82, 0xec, 0x004 },
    { 0x24, 0xb2, 0x24, 0x005 },
    { 0x4c, 0x46, 0x4c, 0x004 },
    { 0x7e, 0xf5, 0x7e, 0x881 },
    { 0x11, 0x4e, 0x11, 0x095 },
    { 0x13, 0xa2, 0x13, 0x005 },
    { 0xef, 0x97, 0xef, 0x000 },
    { 0xd7, 0xd4, 0xd7, 0x004 },
    { 0xb3, 0xc9, 0xb3, 0x091 },
    { 0x17, 0x11, 0x17, 0x004 },
    { 0x01, 0x92, 0x01, 0x015 },
    { 0x34, 0xaa, 0x34, 0x891 },
    { 0x8d, 0x8e, 0x8d, 0x095 },
    { 0x4c, 0x9e, 0x4c, 0x891 },
    { 0x27, 0x7c, 0x27, 0x091 },
    { 0xb3, 0xe5, 0xb3, 0x091 },
    { 0xec, 0x2f, 0xec, 0x094 },
    { 0x43, 0xa9, 0x43, 0x895 },
};

const unsigned g_cBs3CpuInstr2_cmp_TestDataU16 = 48;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_cmp_TestDataU16[48] =
{
    { 0x0000, 0x0000, 0x0000, 0x044 },
    { 0xffff, 0xffff, 0xffff, 0x044 },
    { 0x0000, 0xffff, 0x0000, 0x011 },
    { 0x3ccc, 0x044c, 0x3ccc, 0x000 },
    { 0x3ea2, 0x3061, 0x3ea2, 0x004 },
    { 0x64bc, 0x77ce, 0x64bc, 0x095 },
    { 0x000e, 0x3a77, 0x000e, 0x081 },
    { 0x5afc, 0x934e, 0x5afc, 0x891 },
    { 0xefe7, 0x5f85, 0xefe7, 0x080 },
    { 0x015b, 0x010e, 0x015b, 0x014 },
    { 0xe5f0, 0xf7ce, 0xe5f0, 0x095 },
    { 0x1aad, 0x659d, 0x1aad, 0x081 },
    { 0x004e, 0x0034, 0x004e, 0x000 },
    { 0x09ad, 0x7a1d, 0x09ad, 0x085 },
    { 0x13b6, 0x18ee, 0x13b6, 0x091 },
    { 0x003a, 0x000b, 0x003a, 0x010 },
    { 0xff20, 0xcead, 0xff20, 0x010 },
    { 0xe250, 0x0de3, 0xe250, 0x090 },
    { 0x009b, 0x1f64, 0x009b, 0x081 },
    { 0x7475, 0xce7e, 0x7475, 0x891 },
    { 0xf0ce, 0x7869, 0xf0ce, 0x804 },
    { 0x0005, 0x0016, 0x0005, 0x091 },
    { 0x40e9, 0xb324, 0x40e9, 0x885 },
    { 0x0e97, 0x0cca, 0x0e97, 0x010 },
    { 0x0018, 0x0068, 0x0018, 0x081 },
    { 0x6488, 0x5e44, 0x6488, 0x004 },
    { 0xe52a, 0x4579, 0xe52a, 0x084 },
    { 0x002f, 0x0410, 0x002f, 0x081 },
    { 0x8821, 0x685a, 0x8821, 0x810 },
    { 0x248b, 0x3eb8, 0x248b, 0x081 },
    { 0x02a7, 0x007c, 0x02a7, 0x014 },
    { 0xfae1, 0xe671, 0xfae1, 0x000 },
    { 0x1064, 0x42dc, 0x1064, 0x095 },
    { 0x038d, 0x0cd6, 0x038d, 0x085 },
    { 0x553f, 0xa5fd, 0x553f, 0x885 },
    { 0x9b9c, 0x4f45, 0x9b9c, 0x800 },
    { 0x0fd2, 0x0035, 0x0fd2, 0x010 },
    { 0x5461, 0xc224, 0x5461, 0x891 },
    { 0xed37, 0xddb9, 0xed37, 0x014 },
    { 0x0075, 0x01ac, 0x0075, 0x095 },
    { 0xcde4, 0x4718, 0xcde4, 0x094 },
    { 0x81c2, 0xfa71, 0x81c2, 0x081 },
    { 0x1051, 0x001a, 0x1051, 0x010 },
    { 0x08dc, 0xa72c, 0x08dc, 0x001 },
    { 0x3eba, 0x53fc, 0x3eba, 0x095 },
    { 0x054a, 0x0049, 0x054a, 0x000 },
    { 0x79e4, 0x72e0, 0x79e4, 0x000 },
    { 0xf2f9, 0xca31, 0xf2f9, 0x000 },
};

const unsigned g_cBs3CpuInstr2_cmp_TestDataU32 = 48;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_cmp_TestDataU32[48] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x044 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x044 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x011 },
    { 0x00000aaf, 0x3094f393, 0x00000aaf, 0x081 },
    { 0x030371a3, 0x9719a6b4, 0x030371a3, 0x011 },
    { 0xac6c95d0, 0x0cdfa179, 0xac6c95d0, 0x090 },
    { 0x000000e7, 0x0036b478, 0x000000e7, 0x095 },
    { 0xb9024c4a, 0x85decc57, 0xb9024c4a, 0x004 },
    { 0xe63966c3, 0xc289c0a3, 0xe63966c3, 0x000 },
    { 0x0015dc79, 0x00000325, 0x0015dc79, 0x000 },
    { 0xd14e5e3d, 0xb00cffab, 0xd14e5e3d, 0x000 },
    { 0xe5654c32, 0x5d6d79cc, 0xe5654c32, 0x094 },
    { 0x160ed0da, 0x00000042, 0x160ed0da, 0x000 },
    { 0x83624465, 0xa8786572, 0x83624465, 0x085 },
    { 0x5b5d3a65, 0x85a4caec, 0x5b5d3a65, 0x891 },
    { 0x48228ba6, 0x0003023b, 0x48228ba6, 0x010 },
    { 0xb4eb7cd2, 0x904fda22, 0xb4eb7cd2, 0x000 },
    { 0x2a7a175f, 0xb59473c2, 0x2a7a175f, 0x001 },
    { 0x003328f7, 0x0000234b, 0x003328f7, 0x014 },
    { 0x60d023a8, 0x80d4fb6c, 0x60d023a8, 0x895 },
    { 0x1ec690b4, 0x3e464a08, 0x1ec690b4, 0x095 },
    { 0x001284f9, 0x0038742b, 0x001284f9, 0x091 },
    { 0xcb52d794, 0x2bc75c2e, 0xcb52d794, 0x094 },
    { 0xd5c6644a, 0x93e26244, 0xd5c6644a, 0x004 },
    { 0x72429b69, 0x000089c6, 0x72429b69, 0x004 },
    { 0x38e95ba8, 0xe080b09c, 0x38e95ba8, 0x015 },
    { 0x60cae26f, 0xa7d8170e, 0x60cae26f, 0x881 },
    { 0x029892af, 0x01b4b618, 0x029892af, 0x000 },
    { 0xab1efd33, 0xff815636, 0xab1efd33, 0x091 },
    { 0x844313cc, 0x8fc8d917, 0x844313cc, 0x081 },
    { 0x00111ad9, 0x03a107a7, 0x00111ad9, 0x081 },
    { 0x3bc5f7d9, 0xc213070b, 0x3bc5f7d9, 0x011 },
    { 0x6f33643d, 0x16f9f900, 0x6f33643d, 0x000 },
    { 0x052e3a19, 0x00000492, 0x052e3a19, 0x004 },
    { 0xf34606ab, 0xfa5fded9, 0xf34606ab, 0x085 },
    { 0x6c1f967f, 0x0dd1a34e, 0x6c1f967f, 0x000 },
    { 0x000fbdb1, 0x0088fc8c, 0x000fbdb1, 0x091 },
    { 0x617c6c6d, 0xefb29a1b, 0x617c6c6d, 0x001 },
    { 0x66e5593e, 0x9b462a38, 0x66e5593e, 0x885 },
    { 0x00000755, 0x00327235, 0x00000755, 0x081 },
    { 0x27283295, 0x8010e848, 0x27283295, 0x895 },
    { 0x5601efd4, 0xd9285295, 0x5601efd4, 0x015 },
    { 0x01f3c30f, 0x52b9e95b, 0x01f3c30f, 0x085 },
    { 0x2b877fcb, 0x4cd6fec0, 0x2b877fcb, 0x081 },
    { 0x76ef16a9, 0xcab8cd6c, 0x76ef16a9, 0x891 },
    { 0x00000040, 0x0001ab24, 0x00000040, 0x091 },
    { 0x9412dc17, 0x222f744c, 0x9412dc17, 0x810 },
    { 0x3377f6a2, 0x88e12014, 0x3377f6a2, 0x895 },
};

const unsigned g_cBs3CpuInstr2_bt_TestDataU16 = 48;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_bt_TestDataU16[48] =
{
    { 0x0000, 0x0000, 0x0000, 0x000 },
    { 0xffff, 0xffff, 0xffff, 0x001 },
    { 0x0000, 0xffff, 0x0000, 0x000 },
    { 0x004e, 0x0100, 0x004e, 0x000 },
    { 0xa21b, 0xd05f, 0xa21b, 0x001 },
    { 0x1914, 0xacda, 0x1914, 0x000 },
    { 0x0294, 0x0014, 0x0294, 0x001 },
    { 0xd65b, 0x03dc, 0xd65b, 0x001 },
    { 0x8462, 0x44b9, 0x8462, 0x000 },
    { 0x050e, 0x0b67, 0x050e, 0x000 },
    { 0x7b24, 0x9c28, 0x7b24, 0x001 },
    { 0x2cd9, 0x7c11, 0x2cd9, 0x000 },
    { 0x1193, 0x054a, 0x1193, 0x000 },
    { 0xf500, 0x096e, 0xf500, 0x001 },
    { 0x41ec, 0xedbf, 0x41ec, 0x000 },
    { 0x0009, 0x032a, 0x0009, 0x000 },
    { 0x7411, 0x3776, 0x7411, 0x000 },
    { 0x6349, 0x6fcc, 0x6349, 0x000 },
    { 0x1d7d, 0x0082, 0x1d7d, 0x001 },
    { 0xd241, 0xc4f3, 0xd241, 0x000 },
    { 0x69dc, 0x16b3, 0x69dc, 0x001 },
    { 0x38b3, 0x00c8, 0x38b3, 0x000 },
    { 0xd807, 0xd82f, 0xd807, 0x001 },
    { 0x0d11, 0xe68a, 0x0d11, 0x001 },
    { 0x0247, 0x03a5, 0x0247, 0x000 },
    { 0x1714, 0x37c8, 0x1714, 0x001 },
    { 0x528c, 0xa14c, 0x528c, 0x001 },
    { 0x0057, 0x150b, 0x0057, 0x000 },
    { 0xaa5b, 0x75b5, 0xaa5b, 0x000 },
    { 0xd24a, 0x39eb, 0xd24a, 0x000 },
    { 0x003b, 0x0191, 0x003b, 0x001 },
    { 0x766c, 0xe300, 0x766c, 0x000 },
    { 0x2104, 0xa5e1, 0x2104, 0x000 },
    { 0x0079, 0x02da, 0x0079, 0x000 },
    { 0xb314, 0xfaf0, 0xb314, 0x000 },
    { 0xc0c7, 0x759e, 0xc0c7, 0x001 },
    { 0x000b, 0x020e, 0x000b, 0x000 },
    { 0x6126, 0x09ed, 0x6126, 0x001 },
    { 0xdf5c, 0x3f3f, 0xdf5c, 0x001 },
    { 0x0003, 0x0257, 0x0003, 0x000 },
    { 0x847c, 0x1616, 0x847c, 0x001 },
    { 0x3e91, 0xb488, 0x3e91, 0x000 },
    { 0x0001, 0x1e68, 0x0001, 0x000 },
    { 0xab4f, 0x09d6, 0xab4f, 0x001 },
    { 0x01cf, 0xe8d0, 0x01cf, 0x001 },
    { 0x0032, 0x0449, 0x0032, 0x000 },
    { 0x2a45, 0x518c, 0x2a45, 0x000 },
    { 0xf314, 0xc9ae, 0xf314, 0x001 },
};

const unsigned g_cBs3CpuInstr2_bt_TestDataU32 = 48;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_bt_TestDataU32[48] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x004 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x005 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x004 },
    { 0x0001e2ff, 0x00000131, 0x0001e2ff, 0x004 },
    { 0xf72b1d36, 0xef8ae085, 0xf72b1d36, 0x005 },
    { 0x469a74f9, 0xc6758ad2, 0x469a74f9, 0x004 },
    { 0x00000089, 0x001b042e, 0x00000089, 0x004 },
    { 0xab8f90a5, 0x1e6156fa, 0xab8f90a5, 0x004 },
    { 0x8895677e, 0xc8bda66c, 0x8895677e, 0x004 },
    { 0x0000170a, 0x00003038, 0x0000170a, 0x004 },
    { 0xf3b2b824, 0x9a575e00, 0xf3b2b824, 0x004 },
    { 0x1ddc5f82, 0xef027ff2, 0x1ddc5f82, 0x005 },
    { 0x000004a3, 0x0011f5ae, 0x000004a3, 0x004 },
    { 0x47188d37, 0xbb0458be, 0x47188d37, 0x005 },
    { 0x1a5e4037, 0x21c9e867, 0x1a5e4037, 0x004 },
    { 0x00002923, 0x78573ced, 0x00002923, 0x005 },
    { 0x27610880, 0x93754086, 0x27610880, 0x004 },
    { 0xf6df2764, 0xf4935334, 0xf6df2764, 0x005 },
    { 0x000d84df, 0x0000358e, 0x000d84df, 0x004 },
    { 0x9c411c61, 0x76ae5398, 0x9c411c61, 0x004 },
    { 0xaef23c33, 0xe14e712c, 0xaef23c33, 0x005 },
    { 0x00112c85, 0x00000eab, 0x00112c85, 0x005 },
    { 0x49ff6400, 0x1f65cc15, 0x49ff6400, 0x005 },
    { 0x1439a7a1, 0x552c4566, 0x1439a7a1, 0x004 },
    { 0x04de86ef, 0x0000b2e0, 0x04de86ef, 0x005 },
    { 0xb3fdc1b8, 0x18b95286, 0xb3fdc1b8, 0x004 },
    { 0xeed8e818, 0xe26d97af, 0xeed8e818, 0x005 },
    { 0x3e5ac3c8, 0x000011af, 0x3e5ac3c8, 0x005 },
    { 0xe9ebb7c2, 0xf26d57e1, 0xe9ebb7c2, 0x005 },
    { 0xd3fbe34d, 0xbe07de7a, 0xd3fbe34d, 0x004 },
    { 0x085fffda, 0x00000bee, 0x085fffda, 0x005 },
    { 0x608751d7, 0x540e2bc3, 0x608751d7, 0x004 },
    { 0x6e5b3a51, 0xa751d471, 0x6e5b3a51, 0x005 },
    { 0x000ca1d9, 0x014fd840, 0x000ca1d9, 0x005 },
    { 0x38fe66f0, 0x461833cb, 0x38fe66f0, 0x004 },
    { 0xdef07860, 0x0864072d, 0xdef07860, 0x005 },
    { 0x00837f5b, 0x01697ae0, 0x00837f5b, 0x005 },
    { 0xdc0235fc, 0x952641c1, 0xdc0235fc, 0x004 },
    { 0x02a71193, 0xa672ec14, 0x02a71193, 0x004 },
    { 0x00009ba6, 0x530ca67f, 0x00009ba6, 0x004 },
    { 0xa3870671, 0xb5b817c3, 0xa3870671, 0x004 },
    { 0xc9201ec2, 0xdbc3780f, 0xc9201ec2, 0x004 },
    { 0x00000022, 0x00082cc8, 0x00000022, 0x004 },
    { 0x2d643dfd, 0xd021c453, 0x2d643dfd, 0x004 },
    { 0x98e02d6b, 0xe5c5d88f, 0x98e02d6b, 0x004 },
    { 0x005337db, 0x00004ef2, 0x005337db, 0x004 },
    { 0xdfc4f88e, 0x7c9a42ed, 0xdfc4f88e, 0x005 },
    { 0xb39ff4b0, 0x8a79694a, 0xb39ff4b0, 0x005 },
};

const unsigned g_cBs3CpuInstr2_btc_TestDataU16 = 48;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_btc_TestDataU16[48] =
{
    { 0x0000, 0x0000, 0x0001, 0x004 },
    { 0xffff, 0xffff, 0x7fff, 0x005 },
    { 0x0000, 0xffff, 0x8000, 0x004 },
    { 0x351a, 0x001c, 0x251a, 0x005 },
    { 0xcac3, 0xd1d4, 0xcad3, 0x004 },
    { 0xcf39, 0xe730, 0xcf38, 0x005 },
    { 0x0134, 0x0094, 0x0124, 0x005 },
    { 0x7aaa, 0x62fe, 0x3aaa, 0x005 },
    { 0x2b5d, 0x0d3f, 0xab5d, 0x004 },
    { 0x0ccc, 0x0037, 0x0c4c, 0x005 },
    { 0x2b49, 0x0698, 0x2a49, 0x005 },
    { 0xf2fb, 0x63fb, 0xfafb, 0x004 },
    { 0x0cf8, 0x00c1, 0x0cfa, 0x004 },
    { 0x8836, 0xbfb6, 0x8876, 0x004 },
    { 0x7954, 0xb2b1, 0x7956, 0x004 },
    { 0x0071, 0x0011, 0x0073, 0x004 },
    { 0x6cf3, 0xf5ac, 0x7cf3, 0x004 },
    { 0x0e2a, 0x2830, 0x0e2b, 0x004 },
    { 0x098e, 0x0001, 0x098c, 0x005 },
    { 0xc3b8, 0xa051, 0xc3ba, 0x004 },
    { 0x5fa4, 0x38d4, 0x5fb4, 0x004 },
    { 0x713b, 0x0159, 0x733b, 0x004 },
    { 0x769a, 0x9574, 0x768a, 0x005 },
    { 0xf4a2, 0xf60f, 0x74a2, 0x005 },
    { 0x0019, 0x1fd4, 0x0009, 0x005 },
    { 0x9375, 0x0c21, 0x9377, 0x004 },
    { 0x84c3, 0x4f56, 0x8483, 0x005 },
    { 0x0452, 0x1306, 0x0412, 0x005 },
    { 0xfc8d, 0xc985, 0xfcad, 0x004 },
    { 0x5faf, 0xed2c, 0x4faf, 0x005 },
    { 0x296e, 0x00e1, 0x296c, 0x005 },
    { 0xc7e0, 0x463a, 0xc3e0, 0x005 },
    { 0xc4af, 0xf2a8, 0xc5af, 0x004 },
    { 0x0be3, 0x01a9, 0x09e3, 0x005 },
    { 0x47ab, 0x3250, 0x47aa, 0x005 },
    { 0x300e, 0x0519, 0x320e, 0x004 },
    { 0x00e9, 0x0013, 0x00e1, 0x005 },
    { 0x7a6e, 0xf788, 0x7b6e, 0x004 },
    { 0x1415, 0x82cf, 0x9415, 0x004 },
    { 0x0020, 0x0b40, 0x0021, 0x004 },
    { 0x805a, 0xd487, 0x80da, 0x004 },
    { 0x2923, 0xf121, 0x2921, 0x005 },
    { 0x0432, 0x0116, 0x0472, 0x004 },
    { 0xbb27, 0x159e, 0xfb27, 0x004 },
    { 0x40e1, 0x87ba, 0x44e1, 0x004 },
    { 0x2d1a, 0x37a3, 0x2d12, 0x005 },
    { 0xbd41, 0x074a, 0xb941, 0x005 },
    { 0x96ce, 0xe4f6, 0x968e, 0x005 },
};

const unsigned g_cBs3CpuInstr2_btc_TestDataU32 = 48;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_btc_TestDataU32[48] =
{
    { 0x00000000, 0x00000000, 0x00000001, 0x004 },
    { 0xffffffff, 0xffffffff, 0x7fffffff, 0x005 },
    { 0x00000000, 0xffffffff, 0x80000000, 0x004 },
    { 0x000d2061, 0x128b43b4, 0x001d2061, 0x004 },
    { 0xf50a08c2, 0xa5c513c2, 0xf50a08c6, 0x004 },
    { 0xed9438ed, 0x5e2566fb, 0xe59438ed, 0x005 },
    { 0x0000049a, 0x00000876, 0x0040049a, 0x004 },
    { 0xd9696b4a, 0x1802f522, 0xd9696b4e, 0x004 },
    { 0x2a2b977e, 0x93e707a6, 0x2a2b973e, 0x005 },
    { 0x00071d1e, 0x031c655d, 0x20071d1e, 0x004 },
    { 0x3d42df16, 0xb1445d99, 0x3f42df16, 0x004 },
    { 0x7f5d0113, 0x32f1c7b8, 0x7e5d0113, 0x005 },
    { 0x076030de, 0x0d7d016b, 0x076038de, 0x004 },
    { 0x4a6e55d9, 0x91c61ee8, 0x4a6e54d9, 0x005 },
    { 0xe6173b49, 0x7f354928, 0xe6173a49, 0x005 },
    { 0x437d61fe, 0x44716d11, 0x437f61fe, 0x004 },
    { 0x32af9a31, 0x66b441c9, 0x32af9831, 0x005 },
    { 0x844b27cc, 0x5f48611e, 0xc44b27cc, 0x004 },
    { 0x00c0be44, 0x00002855, 0x00e0be44, 0x004 },
    { 0xe1af3923, 0x36d05aef, 0xe1afb923, 0x004 },
    { 0xa9021d06, 0x89bf89f2, 0xa9061d06, 0x004 },
    { 0x0c911040, 0x00011411, 0x0c931040, 0x004 },
    { 0x357c713a, 0x3cedb244, 0x357c712a, 0x005 },
    { 0x5952ce6f, 0x0b6f0739, 0x5b52ce6f, 0x004 },
    { 0x0000d7ec, 0x00001ccb, 0x0000dfec, 0x004 },
    { 0x5aa4b26e, 0x32be823f, 0xdaa4b26e, 0x004 },
    { 0xb95930f3, 0xd4bb4467, 0xb9593073, 0x005 },
    { 0x0001f39e, 0x000000c1, 0x0001f39c, 0x005 },
    { 0x45d9c2cf, 0xdb84a709, 0x45d9c0cf, 0x005 },
    { 0x61f24dfc, 0xeaddeccd, 0x61f26dfc, 0x004 },
    { 0x0003db5b, 0x001ca6d2, 0x0007db5b, 0x004 },
    { 0xc70c5750, 0x7b3869a0, 0xc70c5751, 0x004 },
    { 0x749ec693, 0xa3fef7e2, 0x749ec697, 0x004 },
    { 0x0008ad98, 0x0007b55c, 0x1008ad98, 0x004 },
    { 0xd81bddaa, 0x0d75d043, 0xd81bdda2, 0x005 },
    { 0x71bc066f, 0xef4a9bbe, 0x31bc066f, 0x005 },
    { 0x00000151, 0x00002dd2, 0x00040151, 0x004 },
    { 0x5be0c556, 0xc1bbc03a, 0x5fe0c556, 0x004 },
    { 0x3c037952, 0xc8123619, 0x3e037952, 0x004 },
    { 0x00007dee, 0x00013d37, 0x00807dee, 0x004 },
    { 0x431a02bb, 0x60a96567, 0x431a023b, 0x005 },
    { 0x11407ec5, 0x2142c05c, 0x01407ec5, 0x005 },
    { 0x40b3f192, 0x3e4529ce, 0x40b3b192, 0x005 },
    { 0xaebbd425, 0x6d6501ee, 0xaebb9425, 0x005 },
    { 0x4261e85e, 0x4bb54653, 0x4269e85e, 0x004 },
    { 0x52824363, 0x000720ed, 0x52826363, 0x004 },
    { 0x8f72e4b0, 0x8003e6bc, 0x9f72e4b0, 0x004 },
    { 0xc0216179, 0x0f866fd3, 0xc0296179, 0x004 },
};

const unsigned g_cBs3CpuInstr2_btr_TestDataU16 = 48;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_btr_TestDataU16[48] =
{
    { 0x0000, 0x0000, 0x0000, 0x000 },
    { 0xffff, 0xffff, 0x7fff, 0x001 },
    { 0x0000, 0xffff, 0x0000, 0x000 },
    { 0x007f, 0x02f2, 0x007b, 0x001 },
    { 0xed08, 0xb588, 0xec08, 0x001 },
    { 0x2545, 0xfe35, 0x2545, 0x000 },
    { 0x1159, 0x0030, 0x1158, 0x001 },
    { 0x2532, 0x0ecf, 0x2532, 0x000 },
    { 0x51bc, 0x36b4, 0x51ac, 0x001 },
    { 0x011b, 0x00ec, 0x011b, 0x000 },
    { 0xce5d, 0x7c71, 0xce5d, 0x000 },
    { 0xeee4, 0xfba9, 0xece4, 0x001 },
    { 0x002a, 0x0015, 0x000a, 0x001 },
    { 0x95d4, 0x9abd, 0x95d4, 0x000 },
    { 0xf6a3, 0x4b75, 0xf683, 0x001 },
    { 0x000e, 0x0286, 0x000e, 0x000 },
    { 0x518e, 0x607f, 0x518e, 0x000 },
    { 0x32ad, 0x1f27, 0x322d, 0x001 },
    { 0x002b, 0x0484, 0x002b, 0x000 },
    { 0x5bac, 0x8350, 0x5bac, 0x000 },
    { 0x0e56, 0x52e2, 0x0e52, 0x001 },
    { 0x001d, 0x000b, 0x001d, 0x000 },
    { 0xcc09, 0x8b14, 0xcc09, 0x000 },
    { 0x0e45, 0xd80f, 0x0e45, 0x000 },
    { 0x0354, 0x009f, 0x0354, 0x000 },
    { 0x6f42, 0x64a5, 0x6f42, 0x000 },
    { 0x9b75, 0x4c68, 0x9a75, 0x001 },
    { 0x0536, 0x051e, 0x0536, 0x000 },
    { 0x7f30, 0x2ac6, 0x7f30, 0x000 },
    { 0x55dc, 0x135c, 0x45dc, 0x001 },
    { 0x007e, 0x00d9, 0x007e, 0x000 },
    { 0x8b19, 0x4ae9, 0x8919, 0x001 },
    { 0x3522, 0x883b, 0x3522, 0x000 },
    { 0x0014, 0x000c, 0x0014, 0x000 },
    { 0xda13, 0x4a60, 0xda12, 0x001 },
    { 0x1933, 0x7d08, 0x1833, 0x001 },
    { 0x0004, 0x0089, 0x0004, 0x000 },
    { 0x83ed, 0x7488, 0x82ed, 0x001 },
    { 0xb465, 0x6b1e, 0xb465, 0x000 },
    { 0x000a, 0x003f, 0x000a, 0x000 },
    { 0x681c, 0x44e4, 0x680c, 0x001 },
    { 0xe213, 0x5305, 0xe213, 0x000 },
    { 0x0e4d, 0x0001, 0x0e4d, 0x000 },
    { 0xd4b7, 0x6e98, 0xd4b7, 0x000 },
    { 0xd3de, 0xb868, 0xd2de, 0x001 },
    { 0x002e, 0x0e07, 0x002e, 0x000 },
    { 0xf1ae, 0xfa29, 0xf1ae, 0x000 },
    { 0xa5f2, 0xb8d4, 0xa5e2, 0x001 },
};

const unsigned g_cBs3CpuInstr2_btr_TestDataU32 = 48;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_btr_TestDataU32[48] =
{
    { 0x00000000, 0x00000000, 0x00000000, 0x000 },
    { 0xffffffff, 0xffffffff, 0x7fffffff, 0x001 },
    { 0x00000000, 0xffffffff, 0x00000000, 0x000 },
    { 0x0018ac89, 0x003596d4, 0x0008ac89, 0x001 },
    { 0xe64144b6, 0xc7063d2c, 0xe64144b6, 0x000 },
    { 0xaa9a3821, 0xf2db3534, 0xaa8a3821, 0x001 },
    { 0x00000082, 0x000c6d72, 0x00000082, 0x000 },
    { 0x2065657f, 0x60ea8576, 0x2025657f, 0x001 },
    { 0x44e037af, 0xa90b5f49, 0x44e035af, 0x001 },
    { 0x00075b8b, 0x00000322, 0x00075b8b, 0x000 },
    { 0xefba8de3, 0xc0b94a90, 0xefba8de3, 0x000 },
    { 0x84ce344f, 0xbdcc30ff, 0x04ce344f, 0x001 },
    { 0x0000377e, 0x01c972bb, 0x0000377e, 0x000 },
    { 0x388b810a, 0xcec4d486, 0x388b810a, 0x000 },
    { 0xdc5cd1d0, 0xd1d2de0f, 0xdc5c51d0, 0x001 },
    { 0x011fc019, 0x03236b09, 0x011fc019, 0x000 },
    { 0x32484a9d, 0xe81ac408, 0x32484a9d, 0x000 },
    { 0x353c1e9d, 0xbdfdf0b8, 0x343c1e9d, 0x001 },
    { 0x001be9e1, 0x00000053, 0x0013e9e1, 0x001 },
    { 0xf85f9d29, 0x0d470ba9, 0xf85f9d29, 0x000 },
    { 0xe98b5e72, 0x7ce5c480, 0xe98b5e72, 0x000 },
    { 0x0000213f, 0x01567cbb, 0x0000213f, 0x000 },
    { 0x291700a7, 0xa52c09d7, 0x291700a7, 0x000 },
    { 0x6e3a3625, 0x6fb8ced8, 0x6e3a3625, 0x000 },
    { 0x0001bf9f, 0x0000131c, 0x0001bf9f, 0x000 },
    { 0x0a93047e, 0x7a0bf19e, 0x0a93047e, 0x000 },
    { 0xe623d9d7, 0x7bb2e6a4, 0xe623d9c7, 0x001 },
    { 0x00000fcf, 0x001f0811, 0x00000fcf, 0x000 },
    { 0x88ea95e2, 0xa1162d00, 0x88ea95e2, 0x000 },
    { 0x76e48ccb, 0x96d7a068, 0x76e48ccb, 0x000 },
    { 0x000000f9, 0x000004d3, 0x000000f9, 0x000 },
    { 0x9d3d3952, 0xb404212e, 0x9d3d3952, 0x000 },
    { 0xfb1e8e83, 0xd31e58c7, 0xfb1e8e03, 0x001 },
    { 0x00009172, 0x00f635b0, 0x00009172, 0x000 },
    { 0xad3ebdff, 0xb22be861, 0xad3ebdfd, 0x001 },
    { 0x20a55202, 0x85ab32e0, 0x20a55202, 0x000 },
    { 0x27b08811, 0x0032706d, 0x27b08811, 0x000 },
    { 0xc2331c71, 0x29903fd7, 0xc2331c71, 0x000 },
    { 0xfd4f7265, 0xeadf8528, 0xfd4f7265, 0x000 },
    { 0x00003a36, 0x00002b20, 0x00003a36, 0x000 },
    { 0x634977d6, 0xf743a7fd, 0x434977d6, 0x001 },
    { 0x3ac9ef63, 0x1f836abc, 0x2ac9ef63, 0x001 },
    { 0x00013e8c, 0x00000208, 0x00013e8c, 0x000 },
    { 0xe0cea5a8, 0x9eddea3f, 0x60cea5a8, 0x001 },
    { 0xbb3ddded, 0x5ab531d1, 0xbb3ddded, 0x000 },
    { 0x00001936, 0x0000199e, 0x00001936, 0x000 },
    { 0x71db5540, 0x76b9f652, 0x71db5540, 0x000 },
    { 0xeada9d8f, 0xb69e4e17, 0xea5a9d8f, 0x001 },
};

const unsigned g_cBs3CpuInstr2_bts_TestDataU16 = 48;
const BS3CPUINSTR2BIN16 g_aBs3CpuInstr2_bts_TestDataU16[48] =
{
    { 0x0000, 0x0000, 0x0001, 0x004 },
    { 0xffff, 0xffff, 0xffff, 0x005 },
    { 0x0000, 0xffff, 0x8000, 0x004 },
    { 0x003b, 0x0033, 0x003b, 0x005 },
    { 0x6912, 0x25d3, 0x691a, 0x004 },
    { 0x7033, 0x61c4, 0x7033, 0x005 },
    { 0x002e, 0x3501, 0x002e, 0x005 },
    { 0x222e, 0x0323, 0x222e, 0x005 },
    { 0x2a67, 0x0760, 0x2a67, 0x005 },
    { 0x29f4, 0x0a56, 0x29f4, 0x005 },
    { 0xe2c7, 0xb6e8, 0xe3c7, 0x004 },
    { 0x7451, 0xa90d, 0x7451, 0x005 },
    { 0x004f, 0x2d97, 0x00cf, 0x004 },
    { 0xce79, 0x8063, 0xce79, 0x005 },
    { 0x09ee, 0xfe33, 0x09ee, 0x005 },
    { 0x0063, 0x002f, 0x8063, 0x004 },
    { 0xb2a9, 0xace0, 0xb2a9, 0x005 },
    { 0xd9d2, 0xa76b, 0xd9d2, 0x005 },
    { 0x08ac, 0x02a5, 0x08ac, 0x005 },
    { 0x098b, 0x9aa8, 0x098b, 0x005 },
    { 0xb6a8, 0x0271, 0xb6aa, 0x004 },
    { 0x0055, 0x1427, 0x00d5, 0x004 },
    { 0xe255, 0x4857, 0xe2d5, 0x004 },
    { 0x870b, 0xff19, 0x870b, 0x005 },
    { 0x0000, 0x0073, 0x0008, 0x004 },
    { 0x6675, 0xaec2, 0x6675, 0x005 },
    { 0x6437, 0x6556, 0x6477, 0x004 },
    { 0x0077, 0x001e, 0x4077, 0x004 },
    { 0x7164, 0x9a7e, 0x7164, 0x005 },
    { 0xff77, 0x12e7, 0xfff7, 0x004 },
    { 0x001e, 0x030a, 0x041e, 0x004 },
    { 0x0aca, 0x78f7, 0x0aca, 0x005 },
    { 0xa9fd, 0x3296, 0xa9fd, 0x005 },
    { 0x086e, 0x00fb, 0x086e, 0x005 },
    { 0x99c6, 0xb7aa, 0x9dc6, 0x004 },
    { 0x251f, 0x4f09, 0x271f, 0x004 },
    { 0x001f, 0x005a, 0x041f, 0x004 },
    { 0x3cdb, 0x852b, 0x3cdb, 0x005 },
    { 0xe843, 0xa252, 0xe847, 0x004 },
    { 0x0661, 0x0002, 0x0665, 0x004 },
    { 0x9f4d, 0x97f0, 0x9f4d, 0x005 },
    { 0x3600, 0x725a, 0x3600, 0x005 },
    { 0x57fe, 0x0007, 0x57fe, 0x005 },
    { 0xe612, 0xcbdd, 0xe612, 0x005 },
    { 0x2632, 0xd89a, 0x2632, 0x005 },
    { 0x0805, 0x04d1, 0x0807, 0x004 },
    { 0x16c3, 0x7c08, 0x17c3, 0x004 },
    { 0xf733, 0x696f, 0xf733, 0x005 },
};

const unsigned g_cBs3CpuInstr2_bts_TestDataU32 = 48;
const BS3CPUINSTR2BIN32 g_aBs3CpuInstr2_bts_TestDataU32[48] =
{
    { 0x00000000, 0x00000000, 0x00000001, 0x000 },
    { 0xffffffff, 0xffffffff, 0xffffffff, 0x001 },
    { 0x00000000, 0xffffffff, 0x80000000, 0x000 },
    { 0x000019b2, 0x000da150, 0x000119b2, 0x000 },
    { 0x0559963e, 0xbc96c330, 0x0559963e, 0x001 },
    { 0x4de8a363, 0x643ee08a, 0x4de8a763, 0x000 },
    { 0x008e0ea5, 0x00000327, 0x008e0ea5, 0x001 },
    { 0x0d840f38, 0x99034d4a, 0x0d840f38, 0x001 },
    { 0xe7c7421a, 0x8ac4cd5d, 0xe7c7421a, 0x001 },
    { 0x00350635, 0x039b75a0, 0x00350635, 0x001 },
    { 0xef47801a, 0xbf2b4335, 0xef67801a, 0x000 },
    { 0x71498dcc, 0xd3fc862f, 0x71498dcc, 0x001 },
    { 0x00000069, 0x0001e97f, 0x80000069, 0x000 },
    { 0xdfcca779, 0x35072a11, 0xdfcea779, 0x000 },
    { 0x295afe1d, 0x14e13721, 0x295afe1f, 0x000 },
    { 0x02d7791a, 0x01712cd8, 0x03d7791a, 0x000 },
    { 0x443d8e16, 0xa53b4886, 0x443d8e56, 0x000 },
    { 0xd7168956, 0x889278f1, 0xd7168956, 0x001 },
    { 0x00001a4c, 0x0061285c, 0x10001a4c, 0x000 },
    { 0x9fa0b1bf, 0xaef5a3a5, 0x9fa0b1bf, 0x001 },
    { 0xc0cabdb9, 0xbe6dbd16, 0xc0cabdb9, 0x001 },
    { 0x032b4f08, 0x01689a7b, 0x0b2b4f08, 0x000 },
    { 0xeaf33bca, 0x46da60cd, 0xeaf33bca, 0x001 },
    { 0xeb095712, 0x323374d0, 0xeb095712, 0x001 },
    { 0x000da907, 0x000002ac, 0x000db907, 0x000 },
    { 0x5f49b31b, 0x1f8dc1a9, 0x5f49b31b, 0x001 },
    { 0xd3a54e6e, 0x89c021d5, 0xd3a54e6e, 0x001 },
    { 0x00038eee, 0x000008f8, 0x01038eee, 0x000 },
    { 0xc0d0286c, 0x220dcade, 0xc0d0286c, 0x001 },
    { 0x7781e71c, 0xb16c1c8f, 0x7781e71c, 0x001 },
    { 0x0000012b, 0x0003ce0e, 0x0000412b, 0x000 },
    { 0x111d36c9, 0xd93068cb, 0x111d3ec9, 0x000 },
    { 0x392ff458, 0xfb52dabc, 0x392ff458, 0x001 },
    { 0x006f45a3, 0x0000acd7, 0x00ef45a3, 0x000 },
    { 0x6a1f6231, 0xf267b565, 0x6a1f6231, 0x001 },
    { 0x76b613bd, 0xabc9f95a, 0x76b613bd, 0x001 },
    { 0x000bc834, 0x00e51b9a, 0x040bc834, 0x000 },
    { 0xf9772005, 0xfbd7668f, 0xf977a005, 0x000 },
    { 0xba8e75cd, 0xded82497, 0xba8e75cd, 0x001 },
    { 0x00014c4b, 0x5415a5ec, 0x00015c4b, 0x000 },
    { 0x99405414, 0x6d1119fc, 0x99405414, 0x001 },
    { 0xbdc10681, 0x8b921ed3, 0xbdc90681, 0x000 },
    { 0x005d9195, 0x01430c63, 0x005d919d, 0x000 },
    { 0x6ee276cd, 0x55e5c59a, 0x6ee276cd, 0x001 },
    { 0xe0102d84, 0x061c6661, 0xe0102d86, 0x000 },
    { 0x000007e1, 0x00326120, 0x000007e1, 0x001 },
    { 0x2986a608, 0x06fe8d58, 0x2986a608, 0x001 },
    { 0xb1f18ffe, 0xaa24864f, 0xb1f18ffe, 0x001 },
};