/* $Id: bs3-cpu-instr-2-data16-intel.c16 104006 2024-03-22 23:09:25Z vboxsync $ */
/** @file
 * BS3Kit - bs3-cpu-instr-2, bs3-cpu-instr-2-data16-intel.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_shl_intel_TestDataU8 = 32;
const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_shl_intel_TestDataU8[32] =
{
    { 0x00, 0x02, 0x0d4, 0x00, 0x044 },
    { 0xff, 0x06, 0x011, 0xc0, 0x085 },
    { 0x00, 0x07, 0x0d0, 0x00, 0x044 },
    { 0xe4, 0x02, 0x010, 0x90, 0x085 },
    { 0x79, 0x04, 0x010, 0x90, 0x88d },
    { 0xc6, 0x00, 0x0d4, 0xc6, 0x0d4 },
    { 0xc7, 0x0e, 0x054, 0x00, 0x044 },
    { 0xc9, 0x01, 0x010, 0x92, 0x081 },
    { 0x4b, 0x01, 0x084, 0x96, 0x88c },
    { 0x11, 0x03, 0x010, 0x88, 0x084 },
    { 0x80, 0x08, 0x094, 0x00, 0x84c },
    { 0xbc, 0x06, 0x081, 0x00, 0x84d },
    { 0x59, 0x0e, 0x050, 0x00, 0x84c },
    { 0xb5, 0x00, 0x010, 0xb5, 0x010 },
    { 0xcc, 0x06, 0x044, 0x00, 0x045 },
    { 0x63, 0x00, 0x811, 0x63, 0x819 },
    { 0xff, 0x09, 0x080, 0x00, 0x044 },
    { 0xca, 0x03, 0x090, 0x50, 0x004 },
    { 0x8e, 0x01, 0x880, 0x1c, 0x809 },
    { 0xc1, 0x01, 0x0d4, 0x82, 0x085 },
    { 0xdc, 0x00, 0x045, 0xdc, 0x045 },
    { 0x98, 0x00, 0x0d4, 0x98, 0x0d4 },
    { 0xdf, 0x03, 0x055, 0xf8, 0x080 },
    { 0x79, 0x06, 0x054, 0x40, 0x808 },
    { 0x6f, 0x0c, 0x090, 0x00, 0x84c },
    { 0x98, 0x05, 0x004, 0x00, 0x84d },
    { 0xfe, 0x0e, 0x084, 0x00, 0x044 },
    { 0x6f, 0x07, 0x0c4, 0x80, 0x889 },
    { 0xb8, 0x05, 0x0c1, 0x00, 0x84d },
    { 0x75, 0x01, 0x0d4, 0xea, 0x888 },
    { 0x28, 0x06, 0x840, 0x00, 0x044 },
    { 0xd1, 0x07, 0x804, 0x80, 0x080 },
};

const uint16_t g_cBs3CpuInstr2_shl_intel_TestDataU16 = 32;
const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_shl_intel_TestDataU16[32] =
{
    { 0x0000, 0x01, 0x055, 0x0000, 0x044 },
    { 0xffff, 0x01, 0x090, 0xfffe, 0x081 },
    { 0x0000, 0x2c, 0x055, 0x0000, 0x044 },
    { 0x0098, 0x09, 0x005, 0x3000, 0x005 },
    { 0x9c87, 0x0c, 0x054, 0x7000, 0x80c },
    { 0x85aa, 0x14, 0x040, 0x0000, 0x84c },
    { 0x1441, 0x06, 0x005, 0x1040, 0x001 },
    { 0xcf47, 0x0c, 0x084, 0x7000, 0x004 },
    { 0xe7a8, 0x16, 0x094, 0x0000, 0x044 },
    { 0x00d7, 0x01, 0x085, 0x01ae, 0x000 },
    { 0x329e, 0x42, 0x0c5, 0xca78, 0x084 },
    { 0xa025, 0x05, 0x090, 0x04a0, 0x80c },
    { 0x004e, 0x0c, 0x891, 0xe000, 0x084 },
    { 0x6b47, 0x0d, 0x0d5, 0xe000, 0x88c },
    { 0x4a01, 0x07, 0x080, 0x0080, 0x809 },
    { 0x01dd, 0x07, 0x011, 0xee80, 0x080 },
    { 0x8050, 0x0c, 0x0c5, 0x0000, 0x84d },
    { 0x6491, 0x00, 0x0c1, 0x6491, 0x0c1 },
    { 0x00d6, 0x10, 0x051, 0x0000, 0x044 },
    { 0x1121, 0x11, 0x011, 0x0000, 0x044 },
    { 0x3934, 0x01, 0x0c5, 0x7268, 0x000 },
    { 0x000a, 0x11, 0x855, 0x0000, 0x044 },
    { 0x6450, 0x11, 0x014, 0x0000, 0x84c },
    { 0xe40d, 0x11, 0x0d4, 0x0000, 0x044 },
    { 0x38a5, 0x11, 0x091, 0x0000, 0x044 },
    { 0x7cb5, 0x11, 0x011, 0x0000, 0x84c },
    { 0x003f, 0x11, 0x014, 0x0000, 0x044 },
    { 0x3b05, 0x00, 0x015, 0x3b05, 0x015 },
    { 0x4840, 0x1b, 0x095, 0x0000, 0x84c },
    { 0x7f8c, 0x0d, 0x055, 0x8000, 0x88d },
    { 0x0006, 0x04, 0x0d5, 0x0060, 0x004 },
    { 0x9a40, 0x2c, 0x090, 0x0000, 0x84c },
};

const uint16_t g_cBs3CpuInstr2_shl_intel_TestDataU32 = 36;
const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_shl_intel_TestDataU32[36] =
{
    { 0x00000000, 0x1d, 0x004, 0x00000000, 0x044 },
    { 0xffffffff, 0x0b, 0x091, 0xfffff800, 0x085 },
    { 0x00000000, 0x0d, 0x015, 0x00000000, 0x044 },
    { 0x3757abf2, 0x14, 0x0c0, 0xbf200000, 0x084 },
    { 0x55025998, 0x0e, 0x045, 0x96660000, 0x88c },
    { 0x00009ada, 0x0d, 0x010, 0x135b4000, 0x004 },
    { 0x98a2edfc, 0x1a, 0x0c0, 0xf0000000, 0x88d },
    { 0xbc1e6dba, 0x3f, 0x0c0, 0x00000000, 0x84d },
    { 0xf542e812, 0x0f, 0x0d4, 0x74090000, 0x005 },
    { 0xa6bf6ae3, 0x08, 0x014, 0xbf6ae300, 0x88c },
    { 0x00093e1e, 0x03, 0x051, 0x0049f0f0, 0x004 },
    { 0x8c1088ae, 0x05, 0x085, 0x821115c0, 0x88d },
    { 0x83b4505b, 0x16, 0x801, 0x16c00000, 0x80c },
    { 0x8e0aa49f, 0x00, 0x8c5, 0x8e0aa49f, 0x8cd },
    { 0x564156d8, 0x05, 0x084, 0xc82adb00, 0x88c },
    { 0x0511fb61, 0x1d, 0x055, 0x20000000, 0x004 },
    { 0xdaa8004a, 0x05, 0x0d0, 0x55000940, 0x001 },
    { 0x32000d8d, 0x13, 0x054, 0x6c680000, 0x004 },
    { 0x1114d8b4, 0x0e, 0x044, 0x362d0000, 0x005 },
    { 0xf1d8c5f9, 0x01, 0x011, 0xe3b18bf2, 0x081 },
    { 0x000007e8, 0x20, 0x0d5, 0x000007e8, 0x0d5 },
    { 0x45ef42e4, 0x21, 0x001, 0x8bde85c8, 0x888 },
    { 0x5e38d984, 0x21, 0x8c0, 0xbc71b308, 0x888 },
    { 0xe487121d, 0x21, 0x001, 0xc90e243a, 0x085 },
    { 0x555a6507, 0x21, 0x0c1, 0xaab4ca0e, 0x888 },
    { 0x000000c7, 0x21, 0x0c1, 0x0000018e, 0x004 },
    { 0x0c734a00, 0x21, 0x095, 0x18e69400, 0x004 },
    { 0xe335e590, 0x21, 0x045, 0xc66bcb20, 0x081 },
    { 0xf3d32043, 0x21, 0x004, 0xe7a64086, 0x081 },
    { 0x5eb112d1, 0x21, 0x090, 0xbd6225a2, 0x888 },
    { 0x00000020, 0x21, 0x0d0, 0x00000040, 0x000 },
    { 0xe35e7064, 0x21, 0x085, 0xc6bce0c8, 0x081 },
    { 0x470a7852, 0x21, 0x045, 0x8e14f0a4, 0x888 },
    { 0x88a70a39, 0x21, 0x085, 0x114e1472, 0x80d },
    { 0x761a7ee8, 0x21, 0x091, 0xec34fdd0, 0x888 },
    { 0x00000a2d, 0x21, 0x094, 0x0000145a, 0x004 },
};

const uint16_t g_cBs3CpuInstr2_shr_intel_TestDataU8 = 32;
const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_shr_intel_TestDataU8[32] =
{
    { 0x00, 0x04, 0x040, 0x00, 0x044 },
    { 0xff, 0x03, 0x0d0, 0x1f, 0x809 },
    { 0x00, 0x02, 0x041, 0x00, 0x044 },
    { 0x0f, 0x03, 0x095, 0x01, 0x001 },
    { 0x92, 0x05, 0x090, 0x04, 0x809 },
    { 0xf0, 0x01, 0x0c4, 0x78, 0x80c },
    { 0xe4, 0x04, 0x010, 0x0e, 0x808 },
    { 0x75, 0x03, 0x001, 0x0e, 0x001 },
    { 0xff, 0x04, 0x041, 0x0f, 0x80d },
    { 0xb7, 0x00, 0x0c0, 0xb7, 0x0c0 },
    { 0x6c, 0x07, 0x095, 0x00, 0x045 },
    { 0xcf, 0x03, 0x004, 0x19, 0x809 },
    { 0xaf, 0x84, 0x0c4, 0x0a, 0x80d },
    { 0xd5, 0x4d, 0x094, 0x00, 0x84c },
    { 0x32, 0x07, 0x0c0, 0x00, 0x044 },
    { 0xe1, 0x01, 0x084, 0x70, 0x809 },
    { 0x47, 0x05, 0x080, 0x02, 0x000 },
    { 0xa0, 0x08, 0x044, 0x00, 0x84d },
    { 0x2c, 0x01, 0x0c0, 0x16, 0x000 },
    { 0xdf, 0x09, 0x0d4, 0x00, 0x84c },
    { 0xee, 0x09, 0x014, 0x00, 0x84c },
    { 0x25, 0x01, 0x0d5, 0x12, 0x005 },
    { 0x1c, 0x09, 0x0d4, 0x00, 0x044 },
    { 0xdc, 0x09, 0x090, 0x00, 0x84c },
    { 0xfe, 0x00, 0x884, 0xfe, 0x88c },
    { 0x83, 0x09, 0x091, 0x00, 0x84c },
    { 0x92, 0x01, 0x0c4, 0x49, 0x808 },
    { 0x56, 0x00, 0x0d5, 0x56, 0x0d5 },
    { 0x4b, 0x09, 0x0d0, 0x00, 0x044 },
    { 0xa7, 0x09, 0x091, 0x00, 0x84c },
    { 0x51, 0x09, 0x040, 0x00, 0x044 },
    { 0x9e, 0x09, 0x045, 0x00, 0x84c },
};

const uint16_t g_cBs3CpuInstr2_shr_intel_TestDataU16 = 32;
const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_shr_intel_TestDataU16[32] =
{
    { 0x0000, 0x37, 0x040, 0x0000, 0x044 },
    { 0xffff, 0x00, 0x015, 0xffff, 0x015 },
    { 0x0000, 0x0e, 0x010, 0x0000, 0x044 },
    { 0x00ba, 0x0b, 0x0c0, 0x0000, 0x044 },
    { 0x86e8, 0x04, 0x010, 0x086e, 0x809 },
    { 0x68bd, 0x15, 0x014, 0x0000, 0x044 },
    { 0x00bd, 0x04, 0x811, 0x000b, 0x001 },
    { 0x3081, 0x02, 0x041, 0x0c20, 0x000 },
    { 0x57d6, 0x05, 0x011, 0x02be, 0x005 },
    { 0x01b1, 0x00, 0x0c4, 0x01b1, 0x0c4 },
    { 0xe901, 0x04, 0x054, 0x0e90, 0x80c },
    { 0xb013, 0x17, 0x0d1, 0x0000, 0x84c },
    { 0x00ba, 0x9a, 0x084, 0x0000, 0x044 },
    { 0xf576, 0x09, 0x0c4, 0x007a, 0x809 },
    { 0x032b, 0x19, 0x050, 0x0000, 0x044 },
    { 0x0101, 0x0e, 0x0d0, 0x0000, 0x044 },
    { 0x1b76, 0x0d, 0x801, 0x0000, 0x045 },
    { 0xf452, 0x01, 0x050, 0x7a29, 0x808 },
    { 0x001b, 0x10, 0x081, 0x0000, 0x044 },
    { 0x5edb, 0x11, 0x880, 0x0000, 0x044 },
    { 0x21da, 0x11, 0x841, 0x0000, 0x044 },
    { 0x0030, 0x11, 0x0c4, 0x0000, 0x044 },
    { 0xae3f, 0x11, 0x8c5, 0x0000, 0x84c },
    { 0x7b55, 0x11, 0x0c1, 0x0000, 0x044 },
    { 0x2b24, 0x11, 0x081, 0x0000, 0x044 },
    { 0xae4a, 0x11, 0x004, 0x0000, 0x84c },
    { 0x40dc, 0x00, 0x050, 0x40dc, 0x050 },
    { 0x07ed, 0x11, 0x014, 0x0000, 0x044 },
    { 0x008b, 0x11, 0x805, 0x0000, 0x044 },
    { 0xa14d, 0x11, 0x801, 0x0000, 0x84c },
    { 0x0061, 0x11, 0x010, 0x0000, 0x044 },
    { 0xfaa9, 0x11, 0x091, 0x0000, 0x84c },
};

const uint16_t g_cBs3CpuInstr2_shr_intel_TestDataU32 = 36;
const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_shr_intel_TestDataU32[36] =
{
    { 0x00000000, 0x24, 0x005, 0x00000000, 0x044 },
    { 0xffffffff, 0x18, 0x054, 0x000000ff, 0x80d },
    { 0x00000000, 0x1b, 0x0c0, 0x00000000, 0x044 },
    { 0x2f652c5b, 0x0c, 0x0d1, 0x0002f652, 0x001 },
    { 0x1f6ca10d, 0x19, 0x0c4, 0x0000000f, 0x005 },
    { 0x000003b4, 0x0b, 0x050, 0x00000000, 0x044 },
    { 0x79b88dd4, 0xe7, 0x0d5, 0x00f3711b, 0x005 },
    { 0xfae3e6df, 0x01, 0x081, 0x7d71f36f, 0x80d },
    { 0x5090cbf5, 0x05, 0x081, 0x0284865f, 0x005 },
    { 0xbcc8b373, 0x05, 0x811, 0x05e6459b, 0x809 },
    { 0x000145d8, 0x35, 0x054, 0x00000000, 0x044 },
    { 0x15ff0689, 0x1a, 0x850, 0x00000005, 0x004 },
    { 0x4a7a41c4, 0x1b, 0x055, 0x00000009, 0x004 },
    { 0x90d82967, 0x14, 0x054, 0x0000090d, 0x809 },
    { 0x88679726, 0x2d, 0x804, 0x0004433c, 0x80d },
    { 0x00000016, 0x0d, 0x015, 0x00000000, 0x044 },
    { 0x68649bfe, 0x1d, 0x004, 0x00000003, 0x004 },
    { 0xe78a241c, 0x08, 0x045, 0x00e78a24, 0x80c },
    { 0x6849c20d, 0x18, 0x000, 0x00000068, 0x000 },
    { 0x5afe30d6, 0x00, 0x054, 0x5afe30d6, 0x054 },
    { 0x0007ed54, 0x20, 0x080, 0x0007ed54, 0x080 },
    { 0x0205c653, 0x21, 0x091, 0x0102e329, 0x001 },
    { 0x6f5cf282, 0x21, 0x0d5, 0x37ae7941, 0x004 },
    { 0xc7cc6b58, 0x21, 0x040, 0x63e635ac, 0x80c },
    { 0xe68e7550, 0x21, 0x005, 0x73473aa8, 0x808 },
    { 0x00001564, 0x21, 0x005, 0x00000ab2, 0x004 },
    { 0x79a5b597, 0x21, 0x041, 0x3cd2dacb, 0x001 },
    { 0x4df861f2, 0x21, 0x081, 0x26fc30f9, 0x004 },
    { 0x3841c9fd, 0x21, 0x090, 0x1c20e4fe, 0x001 },
    { 0x42331b66, 0x21, 0x000, 0x21198db3, 0x000 },
    { 0x000011b5, 0x21, 0x040, 0x000008da, 0x001 },
    { 0xa46cf738, 0x21, 0x010, 0x52367b9c, 0x80c },
    { 0x2b052cdb, 0x01, 0x0d1, 0x1582966d, 0x001 },
    { 0xf2f09d32, 0x21, 0x014, 0x79784e99, 0x80c },
    { 0xdcce6612, 0x21, 0x854, 0x6e673309, 0x80c },
    { 0x0015dbcd, 0x21, 0x081, 0x000aede6, 0x001 },
};

const uint16_t g_cBs3CpuInstr2_sar_intel_TestDataU8 = 32;
const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_sar_intel_TestDataU8[32] =
{
    { 0x00, 0x06, 0x0c0, 0x00, 0x044 },
    { 0xff, 0x02, 0x005, 0xff, 0x085 },
    { 0x00, 0x03, 0x010, 0x00, 0x044 },
    { 0x81, 0x06, 0x044, 0xfe, 0x080 },
    { 0x6b, 0x58, 0x081, 0x00, 0x044 },
    { 0x6a, 0x02, 0x011, 0x1a, 0x001 },
    { 0x5c, 0x07, 0x0d5, 0x00, 0x045 },
    { 0x06, 0x06, 0x0c0, 0x00, 0x044 },
    { 0x63, 0x00, 0x040, 0x63, 0x040 },
    { 0x5c, 0x06, 0x090, 0x01, 0x000 },
    { 0x48, 0x07, 0x055, 0x00, 0x045 },
    { 0x51, 0x02, 0x050, 0x14, 0x004 },
    { 0x46, 0x01, 0x010, 0x23, 0x000 },
    { 0x4b, 0x0a, 0x051, 0x00, 0x044 },
    { 0x94, 0x06, 0x854, 0xfe, 0x080 },
    { 0x94, 0x08, 0x015, 0xff, 0x085 },
    { 0x1b, 0x0f, 0x080, 0x00, 0x044 },
    { 0x62, 0x09, 0x005, 0x00, 0x044 },
    { 0x8c, 0x09, 0x084, 0xff, 0x085 },
    { 0xbd, 0x09, 0x001, 0xff, 0x085 },
    { 0x25, 0x09, 0x0c5, 0x00, 0x044 },
    { 0xc1, 0x00, 0x884, 0xc1, 0x88c },
    { 0x42, 0x06, 0x840, 0x01, 0x000 },
    { 0xd1, 0x04, 0x080, 0xfd, 0x080 },
    { 0x66, 0x01, 0x0d4, 0x33, 0x004 },
    { 0x3c, 0x05, 0x0d4, 0x01, 0x001 },
    { 0xf2, 0xe7, 0x010, 0xff, 0x085 },
    { 0x51, 0x00, 0x015, 0x51, 0x015 },
    { 0x9d, 0x0d, 0x081, 0xff, 0x085 },
    { 0xdb, 0x01, 0x0c5, 0xed, 0x085 },
    { 0x84, 0x58, 0x810, 0xff, 0x085 },
    { 0x0d, 0x02, 0x0d0, 0x03, 0x004 },
};

const uint16_t g_cBs3CpuInstr2_sar_intel_TestDataU16 = 32;
const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_sar_intel_TestDataU16[32] =
{
    { 0x0000, 0x04, 0x010, 0x0000, 0x044 },
    { 0xffff, 0x08, 0x0c4, 0xffff, 0x085 },
    { 0x0000, 0x13, 0x0d1, 0x0000, 0x044 },
    { 0x02b3, 0x08, 0x0d1, 0x0002, 0x001 },
    { 0x1279, 0x19, 0x055, 0x0000, 0x044 },
    { 0x6ee1, 0x15, 0x0c0, 0x0000, 0x044 },
    { 0x1243, 0x0a, 0x011, 0x0004, 0x001 },
    { 0x13cf, 0x14, 0x090, 0x0000, 0x044 },
    { 0x07c0, 0x1f, 0x890, 0x0000, 0x044 },
    { 0x0066, 0x08, 0x0c1, 0x0000, 0x044 },
    { 0x1034, 0x0a, 0x094, 0x0004, 0x000 },
    { 0x6f36, 0x02, 0x054, 0x1bcd, 0x001 },
    { 0x0017, 0x08, 0x0d5, 0x0000, 0x044 },
    { 0x6384, 0x18, 0x080, 0x0000, 0x044 },
    { 0x7788, 0x84, 0x094, 0x0778, 0x005 },
    { 0x07d7, 0x0a, 0x0d4, 0x0001, 0x001 },
    { 0xdb91, 0x0a, 0x0d0, 0xfff6, 0x085 },
    { 0x6e2c, 0x00, 0x0c0, 0x6e2c, 0x0c0 },
    { 0x02fa, 0x01, 0x044, 0x017d, 0x004 },
    { 0x3cf0, 0x10, 0x091, 0x0000, 0x044 },
    { 0x144d, 0x11, 0x0c5, 0x0000, 0x044 },
    { 0x7292, 0x00, 0x811, 0x7292, 0x819 },
    { 0x49f7, 0x07, 0x085, 0x0093, 0x005 },
    { 0xca99, 0x0c, 0x0d5, 0xfffc, 0x085 },
    { 0x001a, 0x1f, 0x015, 0x0000, 0x044 },
    { 0x1f50, 0x42, 0x084, 0x07d4, 0x004 },
    { 0xf184, 0x0a, 0x084, 0xfffc, 0x084 },
    { 0x00d8, 0x12, 0x000, 0x0000, 0x044 },
    { 0xbeb4, 0x09, 0x0c5, 0xffdf, 0x080 },
    { 0xda8a, 0x05, 0x090, 0xfed4, 0x084 },
    { 0x03d0, 0x06, 0x840, 0x000f, 0x004 },
    { 0x28b7, 0x04, 0x801, 0x028b, 0x004 },
};

const uint16_t g_cBs3CpuInstr2_sar_intel_TestDataU32 = 36;
const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_sar_intel_TestDataU32[36] =
{
    { 0x00000000, 0x1e, 0x0c0, 0x00000000, 0x044 },
    { 0xffffffff, 0x13, 0x090, 0xffffffff, 0x085 },
    { 0x00000000, 0xe7, 0x891, 0x00000000, 0x044 },
    { 0x6df75da9, 0x09, 0x0c0, 0x0036fbae, 0x001 },
    { 0x7a8b6453, 0x2c, 0x040, 0x0007a8b6, 0x000 },
    { 0x031b51bf, 0x3d, 0x005, 0x00000000, 0x044 },
    { 0x21a2c383, 0x15, 0x845, 0x0000010d, 0x000 },
    { 0xda6314cc, 0x10, 0x0c5, 0xffffda63, 0x084 },
    { 0x1215b43b, 0x17, 0x044, 0x00000024, 0x004 },
    { 0x1db07b0f, 0x16, 0x0d1, 0x00000076, 0x001 },
    { 0x004c60ae, 0x1e, 0x0c4, 0x00000000, 0x044 },
    { 0xf6dd7ddf, 0x1d, 0x051, 0xffffffff, 0x085 },
    { 0x162f5f2f, 0x0a, 0x091, 0x00058bd7, 0x005 },
    { 0x5d779fe9, 0x0f, 0x051, 0x0000baef, 0x000 },
    { 0x9005efae, 0x19, 0x001, 0xffffffc8, 0x080 },
    { 0x00000511, 0x0f, 0x000, 0x00000000, 0x044 },
    { 0x531bb829, 0x0c, 0x084, 0x000531bb, 0x005 },
    { 0x65f9dc4e, 0x0f, 0x095, 0x0000cbf3, 0x005 },
    { 0x199fe046, 0x3e, 0x004, 0x00000000, 0x044 },
    { 0x495749b3, 0x00, 0x0c4, 0x495749b3, 0x0c4 },
    { 0x00000129, 0x01, 0x0c5, 0x00000094, 0x001 },
    { 0x3279bfbd, 0x20, 0x0d4, 0x3279bfbd, 0x0d4 },
    { 0x5ca117a9, 0x21, 0x000, 0x2e508bd4, 0x005 },
    { 0xdfe380f8, 0x21, 0x0c4, 0xeff1c07c, 0x080 },
    { 0x1c3b2bb1, 0x21, 0x090, 0x0e1d95d8, 0x005 },
    { 0x73f2d6ed, 0x00, 0x855, 0x73f2d6ed, 0x85d },
    { 0x5beb176c, 0x19, 0x814, 0x0000002d, 0x005 },
    { 0x61aba258, 0x00, 0x050, 0x61aba258, 0x050 },
    { 0xb2449da0, 0x1b, 0x005, 0xfffffff6, 0x084 },
    { 0x39c88b3f, 0x8f, 0x091, 0x00007391, 0x000 },
    { 0x0003ec96, 0x15, 0x094, 0x00000000, 0x044 },
    { 0x76681f6c, 0x1b, 0x0d5, 0x0000000e, 0x001 },
    { 0x72af5c72, 0x1d, 0x0c1, 0x00000003, 0x005 },
    { 0xc48c351f, 0x0c, 0x891, 0xfffc48c3, 0x084 },
    { 0x05d9a7ef, 0x09, 0x011, 0x0002ecd3, 0x001 },
    { 0x0e3ea7a4, 0x0a, 0x055, 0x00038fa9, 0x005 },
};

const uint16_t g_cBs3CpuInstr2_rol_intel_TestDataU8 = 32;
const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_rol_intel_TestDataU8[32] =
{
    { 0x00, 0x8f, 0x001, 0x00, 0x000 },
    { 0xff, 0x07, 0x004, 0xff, 0x005 },
    { 0x00, 0x03, 0x890, 0x00, 0x098 }, /* OF/Ib */
    { 0xc2, 0x07, 0x0d4, 0x61, 0x0d5 },
    { 0x4d, 0x02, 0x040, 0x35, 0x841 }, /* OF/Ib */
    { 0x70, 0xbb, 0x091, 0x83, 0x891 }, /* OF/Ib */
    { 0x7b, 0x06, 0x085, 0xde, 0x884 }, /* OF/Ib */
    { 0x7c, 0x00, 0x0c4, 0x7c, 0x0c4 },
    { 0x46, 0x08, 0x014, 0x46, 0x814 }, /* OF/Ib */
    { 0xc9, 0x03, 0x001, 0x4e, 0x000 },
    { 0x81, 0x0c, 0x0c4, 0x18, 0x8c4 }, /* OF/Ib */
    { 0x72, 0x05, 0x095, 0x4e, 0x894 }, /* OF/Ib */
    { 0x9d, 0x02, 0x050, 0x76, 0x850 }, /* OF/Ib */
    { 0x12, 0x0b, 0x090, 0x90, 0x090 },
    { 0x52, 0x01, 0x044, 0xa4, 0x84c },
    { 0xd9, 0x05, 0x095, 0x3b, 0x095 },
    { 0xc2, 0x07, 0x011, 0x61, 0x011 },
    { 0xd7, 0x09, 0x0c5, 0xaf, 0x0c5 },
    { 0x68, 0x01, 0x0d4, 0xd0, 0x8dc },
    { 0x25, 0x01, 0x0c0, 0x4a, 0x0c0 },
    { 0x6d, 0x09, 0x055, 0xda, 0x854 }, /* OF/Ib */
    { 0xc8, 0x09, 0x044, 0x91, 0x045 },
    { 0xfe, 0x09, 0x011, 0xfd, 0x011 },
    { 0xd9, 0x09, 0x044, 0xb3, 0x045 },
    { 0x29, 0x09, 0x014, 0x52, 0x014 },
    { 0xd3, 0x09, 0x004, 0xa7, 0x005 },
    { 0x35, 0x09, 0x0c4, 0x6a, 0x0c4 },
    { 0xbf, 0x09, 0x085, 0x7f, 0x885 }, /* OF/Ib */
    { 0xc5, 0x09, 0x081, 0x8b, 0x081 },
    { 0xba, 0x09, 0x094, 0x75, 0x895 }, /* OF/Ib */
    { 0x18, 0x00, 0x0c0, 0x18, 0x0c0 },
    { 0xf1, 0x09, 0x095, 0xe3, 0x095 },
}; /* Note! 8-bit rol reg,imm8 results differed 11 times from the other form */

const uint16_t g_cBs3CpuInstr2_rol_intel_TestDataU16 = 32;
const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_rol_intel_TestDataU16[32] =
{
    { 0x0000, 0x2c, 0x011, 0x0000, 0x010 },
    { 0xffff, 0x0b, 0x085, 0xffff, 0x085 },
    { 0x0000, 0x00, 0x091, 0x0000, 0x091 },
    { 0x0004, 0x01, 0x084, 0x0008, 0x084 },
    { 0xb5ee, 0x07, 0x085, 0xf75a, 0x884 }, /* OF/Ib */
    { 0xf8d8, 0x01, 0x090, 0xf1b1, 0x091 },
    { 0x01dd, 0x0b, 0x095, 0xe80e, 0x094 },
    { 0xebe1, 0x2c, 0x014, 0x1ebe, 0x014 },
    { 0x9bf1, 0x1a, 0x011, 0xc66f, 0x811 }, /* OF/Ib */
    { 0x006a, 0x07, 0x004, 0x3500, 0x004 },
    { 0x12d1, 0x03, 0x0c0, 0x9688, 0x0c0 },
    { 0x6a71, 0x0b, 0x091, 0x8b53, 0x891 }, /* OF/Ib */
    { 0x001e, 0x0c, 0x050, 0xe001, 0x051 },
    { 0x6b19, 0x0c, 0x0d5, 0x96b1, 0x8d5 }, /* OF/Ib */
    { 0x2f52, 0x1b, 0x0c5, 0x917a, 0x0c4 },
    { 0x17b8, 0x16, 0x0d4, 0xee05, 0x0d5 },
    { 0xda84, 0x12, 0x010, 0x6a13, 0x011 },
    { 0x20bc, 0x10, 0x085, 0x20bc, 0x084 },
    { 0x003d, 0x11, 0x050, 0x007a, 0x050 },
    { 0x48b4, 0x11, 0x0d1, 0x9168, 0x8d0 }, /* OF/Ib */
    { 0x0bc1, 0x11, 0x050, 0x1782, 0x050 },
    { 0x01b8, 0x11, 0x084, 0x0370, 0x084 },
    { 0x9b67, 0x11, 0x054, 0x36cf, 0x855 }, /* OF/Ib */
    { 0xa3ba, 0x11, 0x054, 0x4775, 0x855 }, /* OF/Ib */
    { 0x0007, 0x11, 0x094, 0x000e, 0x094 },
    { 0xb545, 0x11, 0x055, 0x6a8b, 0x855 }, /* OF/Ib */
    { 0x55c5, 0x11, 0x080, 0xab8a, 0x880 }, /* OF/Ib */
    { 0x0013, 0x11, 0x055, 0x0026, 0x054 },
    { 0x42a6, 0x11, 0x040, 0x854c, 0x840 }, /* OF/Ib */
    { 0x57c4, 0x11, 0x091, 0xaf88, 0x890 }, /* OF/Ib */
    { 0x03fd, 0x11, 0x000, 0x07fa, 0x000 },
    { 0x3c54, 0x11, 0x080, 0x78a8, 0x080 },
}; /* Note! 16-bit rol reg,imm8 results differed 11 times from the other form */

const uint16_t g_cBs3CpuInstr2_rol_intel_TestDataU32 = 36;
const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_rol_intel_TestDataU32[36] =
{
    { 0x00000000, 0x02, 0x040, 0x00000000, 0x040 },
    { 0xffffffff, 0x2f, 0x015, 0xffffffff, 0x015 },
    { 0x00000000, 0x0f, 0x014, 0x00000000, 0x014 },
    { 0x136ef312, 0x09, 0x084, 0xdde62426, 0x084 },
    { 0x454511da, 0x09, 0x094, 0x8a23b48a, 0x894 }, /* OF/Ib */
    { 0x00000606, 0x0e, 0x084, 0x01818000, 0x084 },
    { 0x77af735a, 0x05, 0x010, 0xf5ee6b4e, 0x810 }, /* OF/Ib */
    { 0xf4a2bdd6, 0x2c, 0x081, 0x2bdd6f4a, 0x080 },
    { 0x419a1ef3, 0x17, 0x051, 0x79a0cd0f, 0x851 }, /* OF/Ib */
    { 0xa95a63b3, 0x1a, 0x004, 0xcea5698e, 0x804 }, /* OF/Ib */
    { 0x0007324a, 0x00, 0x0d0, 0x0007324a, 0x0d0 },
    { 0xee027162, 0x07, 0x055, 0x0138b177, 0x055 },
    { 0x5411cebb, 0x08, 0x015, 0x11cebb54, 0x814 }, /* OF/Ib */
    { 0x30d5081e, 0x11, 0x080, 0x103c61aa, 0x080 },
    { 0xa8bbb874, 0x10, 0x040, 0xb874a8bb, 0x841 }, /* OF/Ib */
    { 0x00245fee, 0x05, 0x041, 0x048bfdc0, 0x040 },
    { 0x57281a0c, 0x34, 0x090, 0xa0c57281, 0x891 }, /* OF/Ib */
    { 0x8291724f, 0x0d, 0x045, 0x2e49f052, 0x844 }, /* OF/Ib */
    { 0x6edc9488, 0x01, 0x005, 0xddb92910, 0x80c },
    { 0x3d65f552, 0x20, 0x894, 0x3d65f552, 0x89c },
    { 0x001d229f, 0x21, 0x001, 0x003a453e, 0x000 },
    { 0x5597eb30, 0x21, 0x054, 0xab2fd660, 0x85c },
    { 0x0f6b886f, 0x21, 0x040, 0x1ed710de, 0x040 },
    { 0xc4d100fa, 0x21, 0x000, 0x89a201f5, 0x001 },
    { 0xb82b75f5, 0x21, 0x000, 0x7056ebeb, 0x809 },
    { 0x00000085, 0x21, 0x041, 0x0000010a, 0x040 },
    { 0x1189ae0d, 0x21, 0x041, 0x23135c1a, 0x040 },
    { 0x3730b214, 0x21, 0x050, 0x6e616428, 0x050 },
    { 0xb5ec1aa8, 0x21, 0x080, 0x6bd83551, 0x889 },
    { 0xbe3dc331, 0x21, 0x801, 0x7c7b8663, 0x809 },
    { 0x00005dd1, 0x21, 0x010, 0x0000bba2, 0x010 },
    { 0xc2473fc9, 0x21, 0x055, 0x848e7f93, 0x055 },
    { 0xb830eaed, 0x00, 0x015, 0xb830eaed, 0x015 },
    { 0xe98a8754, 0x21, 0x054, 0xd3150ea9, 0x055 },
    { 0x16247e46, 0x21, 0x094, 0x2c48fc8c, 0x094 },
    { 0x00000269, 0x21, 0x010, 0x000004d2, 0x010 },
}; /* Note! 32-bit rol reg,imm8 results differed 8 times from the other form */

const uint16_t g_cBs3CpuInstr2_ror_intel_TestDataU8 = 32;
const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_ror_intel_TestDataU8[32] =
{
    { 0x00, 0x0e, 0x091, 0x00, 0x090 },
    { 0xff, 0x05, 0x055, 0xff, 0x055 },
    { 0x00, 0x02, 0x094, 0x00, 0x094 },
    { 0x93, 0x02, 0x0d4, 0xe4, 0x0d5 },
    { 0x84, 0x01, 0x894, 0x42, 0x89c },
    { 0x27, 0x07, 0x044, 0x4e, 0x844 }, /* OF/Ib */
    { 0x11, 0x07, 0x011, 0x22, 0x810 }, /* OF/Ib */
    { 0xd6, 0x06, 0x081, 0x5b, 0x880 }, /* OF/Ib */
    { 0xbb, 0x04, 0x014, 0xbb, 0x015 },
    { 0x97, 0x06, 0x000, 0x5e, 0x000 },
    { 0x53, 0x02, 0x085, 0xd4, 0x885 }, /* OF/Ib */
    { 0xf4, 0x04, 0x881, 0x4f, 0x888 },
    { 0x15, 0x02, 0x015, 0x45, 0x814 }, /* OF/Ib */
    { 0x6c, 0x00, 0x045, 0x6c, 0x045 },
    { 0x7f, 0x01, 0x0c4, 0xbf, 0x8cd },
    { 0x53, 0x02, 0x805, 0xd4, 0x80d },
    { 0x36, 0x01, 0x004, 0x1b, 0x004 },
    { 0x31, 0x08, 0x044, 0x31, 0x844 }, /* OF/Ib */
    { 0x05, 0x09, 0x054, 0x82, 0x855 }, /* OF/Ib */
    { 0x97, 0x09, 0x810, 0xcb, 0x019 }, /* OF/Ib */
    { 0x52, 0x09, 0x045, 0x29, 0x044 },
    { 0x50, 0x09, 0x041, 0x28, 0x040 },
    { 0x8d, 0x09, 0x010, 0xc6, 0x011 },
    { 0x47, 0x09, 0x085, 0xa3, 0x885 }, /* OF/Ib */
    { 0x85, 0x09, 0x0d5, 0xc2, 0x0d5 },
    { 0x78, 0x09, 0x044, 0x3c, 0x044 },
    { 0x72, 0x00, 0x085, 0x72, 0x085 },
    { 0x69, 0x09, 0x090, 0xb4, 0x891 }, /* OF/Ib */
    { 0x8e, 0x09, 0x0d5, 0x47, 0x8d4 }, /* OF/Ib */
    { 0x9c, 0x09, 0x041, 0x4e, 0x840 }, /* OF/Ib */
    { 0xdb, 0x09, 0x010, 0xed, 0x011 },
    { 0xcf, 0x09, 0x044, 0xe7, 0x045 },
}; /* Note! 8-bit ror reg,imm8 results differed 12 times from the other form */

const uint16_t g_cBs3CpuInstr2_ror_intel_TestDataU16 = 32;
const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_ror_intel_TestDataU16[32] =
{
    { 0x0000, 0x0d, 0x084, 0x0000, 0x084 },
    { 0xffff, 0x04, 0x051, 0xffff, 0x051 },
    { 0x0000, 0x09, 0x015, 0x0000, 0x014 },
    { 0x0009, 0x0d, 0x055, 0x0048, 0x854 }, /* OF/Ib */
    { 0xc375, 0x04, 0x040, 0x5c37, 0x040 },
    { 0x64e7, 0x0a, 0x054, 0x39d9, 0x854 }, /* OF/Ib */
    { 0x0254, 0x0d, 0x045, 0x12a0, 0x044 },
    { 0xd180, 0x0a, 0x015, 0x6034, 0x814 }, /* OF/Ib */
    { 0x6a2e, 0x07, 0x045, 0x5cd4, 0x044 },
    { 0x00e0, 0x06, 0x894, 0x8003, 0x09d }, /* OF/Ib */
    { 0x112d, 0x00, 0x845, 0x112d, 0x84d },
    { 0xf427, 0x1f, 0x0d0, 0xe84f, 0x0d1 },
    { 0x0051, 0x02, 0x084, 0x4014, 0x884 }, /* OF/Ib */
    { 0xc97f, 0x08, 0x084, 0x7fc9, 0x084 },
    { 0x62e5, 0x05, 0x054, 0x2b17, 0x854 }, /* OF/Ib */
    { 0x0017, 0x00, 0x091, 0x0017, 0x091 },
    { 0x2a08, 0x12, 0x0c5, 0x0a82, 0x0c4 },
    { 0x4589, 0x01, 0x044, 0xa2c4, 0x84d },
    { 0x0061, 0x10, 0x090, 0x0061, 0x890 }, /* OF/Ib */
    { 0xd193, 0x11, 0x080, 0xe8c9, 0x081 },
    { 0xae20, 0x11, 0x050, 0x5710, 0x850 }, /* OF/Ib */
    { 0x15ab, 0x11, 0x044, 0x8ad5, 0x845 }, /* OF/Ib */
    { 0x1013, 0x11, 0x014, 0x8809, 0x815 }, /* OF/Ib */
    { 0x45c2, 0x11, 0x044, 0x22e1, 0x044 },
    { 0x01da, 0x11, 0x051, 0x00ed, 0x050 },
    { 0x64b3, 0x11, 0x015, 0xb259, 0x815 }, /* OF/Ib */
    { 0x2b67, 0x11, 0x000, 0x95b3, 0x801 }, /* OF/Ib */
    { 0x0596, 0x11, 0x080, 0x02cb, 0x080 },
    { 0x3a6e, 0x0a, 0x041, 0x9b8e, 0x041 },
    { 0x89f8, 0x1f, 0x854, 0x13f1, 0x85c },
    { 0x0005, 0x12, 0x0c5, 0x4001, 0x8c4 }, /* OF/Ib */
    { 0x7b34, 0x19, 0x010, 0x9a3d, 0x011 },
}; /* Note! 16-bit ror reg,imm8 results differed 13 times from the other form */

const uint16_t g_cBs3CpuInstr2_ror_intel_TestDataU32 = 36;
const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_ror_intel_TestDataU32[36] =
{
    { 0x00000000, 0x36, 0x081, 0x00000000, 0x080 },
    { 0xffffffff, 0x1f, 0x090, 0xffffffff, 0x091 },
    { 0x00000000, 0x03, 0x090, 0x00000000, 0x090 },
    { 0x8e1411d2, 0x0a, 0x854, 0x74a38504, 0x85c },
    { 0xe3194a80, 0x14, 0x004, 0x94a80e31, 0x805 }, /* OF/Ib */
    { 0x0000d9f0, 0x15, 0x0d5, 0x06cf8000, 0x0d4 },
    { 0x1dd35912, 0x0a, 0x0c5, 0x448774d6, 0x0c4 },
    { 0x8a65e77f, 0x01, 0x044, 0xc532f3bf, 0x045 },
    { 0x5beabe6e, 0xe7, 0x0c5, 0xdcb7d57c, 0x0c5 },
    { 0x880347cc, 0x03, 0x000, 0x910068f9, 0x801 }, /* OF/Ib */
    { 0x0000037c, 0x1b, 0x0d0, 0x00006f80, 0x0d0 },
    { 0x46f703fb, 0x03, 0x014, 0x68dee07f, 0x814 }, /* OF/Ib */
    { 0x4c1b1bbb, 0x06, 0x000, 0xed306c6e, 0x801 }, /* OF/Ib */
    { 0xe5caafd6, 0x0f, 0x0d4, 0x5fadcb95, 0x8d4 }, /* OF/Ib */
    { 0x75d6e983, 0x12, 0x010, 0xba60dd75, 0x811 }, /* OF/Ib */
    { 0x0884fc51, 0x05, 0x084, 0x884427e2, 0x885 }, /* OF/Ib */
    { 0x022d0690, 0x0d, 0x015, 0x34801168, 0x014 },
    { 0x8b28344b, 0x79, 0x081, 0x941a25c5, 0x081 },
    { 0xf29db7c3, 0x1e, 0x0c1, 0xca76df0f, 0x0c1 },
    { 0x72278a60, 0x00, 0x854, 0x72278a60, 0x85c },
    { 0x01349536, 0x20, 0x081, 0x01349536, 0x081 },
    { 0xb95cd06c, 0x21, 0x084, 0x5cae6836, 0x88c },
    { 0xa4412805, 0x21, 0x050, 0xd2209402, 0x051 },
    { 0x19162c5d, 0x21, 0x0c0, 0x8c8b162e, 0x8c9 },
    { 0x9309b7ae, 0x21, 0x0c5, 0x4984dbd7, 0x8cc },
    { 0x00002569, 0x21, 0x895, 0x800012b4, 0x89d },
    { 0xa2638e78, 0x21, 0x811, 0x5131c73c, 0x818 },
    { 0x7be06757, 0x21, 0x081, 0xbdf033ab, 0x889 },
    { 0x63711c5c, 0x21, 0x004, 0x31b88e2e, 0x004 },
    { 0xaa7a8ad3, 0x21, 0x081, 0xd53d4569, 0x081 },
    { 0x0021ccec, 0x21, 0x051, 0x0010e676, 0x050 },
    { 0x7d878a26, 0x21, 0x091, 0x3ec3c513, 0x090 },
    { 0xb5276a6c, 0x21, 0x041, 0x5a93b536, 0x848 },
    { 0x75a371eb, 0x21, 0x001, 0xbad1b8f5, 0x809 },
    { 0x7f9a01be, 0x21, 0x0d0, 0x3fcd00df, 0x0d0 },
    { 0x001575dd, 0x21, 0x081, 0x800abaee, 0x889 },
}; /* Note! 32-bit ror reg,imm8 results differed 7 times from the other form */

const uint16_t g_cBs3CpuInstr2_rcl_intel_TestDataU8 = 64;
const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_rcl_intel_TestDataU8[64] =
{
    { 0x00, 0x0f, 0x040, 0x00, 0x040 },
    { 0x00, 0x0f, 0x041, 0x20, 0x040 },
    { 0xff, 0x02, 0x894, 0xfd, 0x095 },
    { 0xff, 0x02, 0x895, 0xff, 0x095 },
    { 0x00, 0x01, 0x044, 0x00, 0x044 },
    { 0x00, 0x01, 0x045, 0x01, 0x044 },
    { 0xbc, 0x06, 0x090, 0x17, 0x899 },
    { 0xbc, 0x06, 0x091, 0x37, 0x899 },
    { 0x5d, 0x07, 0x004, 0x97, 0x80c },
    { 0x5d, 0x07, 0x005, 0xd7, 0x80c },
    { 0x53, 0x07, 0x090, 0x94, 0x899 },
    { 0x53, 0x07, 0x091, 0xd4, 0x899 },
    { 0xdf, 0x06, 0x094, 0xdb, 0x095 },
    { 0xdf, 0x06, 0x095, 0xfb, 0x095 },
    { 0x06, 0x04, 0x0d0, 0x60, 0x0d0 },
    { 0x06, 0x04, 0x0d1, 0x68, 0x0d0 },
    { 0xac, 0x06, 0x850, 0x15, 0x859 },
    { 0xac, 0x06, 0x851, 0x35, 0x859 },
    { 0x71, 0x06, 0x090, 0x4e, 0x898 },
    { 0x71, 0x06, 0x091, 0x6e, 0x898 },
    { 0xbd, 0x05, 0x084, 0xab, 0x88d },
    { 0xbd, 0x05, 0x085, 0xbb, 0x88d },
    { 0xf2, 0x01, 0x080, 0xe4, 0x081 },
    { 0xf2, 0x01, 0x081, 0xe5, 0x081 },
    { 0xc5, 0x01, 0x004, 0x8a, 0x005 },
    { 0xc5, 0x01, 0x005, 0x8b, 0x005 },
    { 0x16, 0x00, 0x090, 0x16, 0x090 },
    { 0x16, 0x00, 0x091, 0x16, 0x091 },
    { 0x86, 0x0f, 0x090, 0x90, 0x899 },
    { 0x86, 0x0f, 0x091, 0xb0, 0x899 },
    { 0xf7, 0x0a, 0x0c0, 0xee, 0x0c1 },
    { 0xf7, 0x0a, 0x0c1, 0xef, 0x0c1 },
    { 0x8c, 0x02, 0x044, 0x31, 0x84c },
    { 0x8c, 0x02, 0x045, 0x33, 0x84c },
    { 0x6c, 0x08, 0x884, 0x36, 0x88c },
    { 0x6c, 0x08, 0x885, 0xb6, 0x88c },
    { 0x43, 0x09, 0x010, 0x43, 0x010 },
    { 0x43, 0x09, 0x011, 0x43, 0x011 },
    { 0x9d, 0x09, 0x054, 0x9d, 0x054 },
    { 0x9d, 0x09, 0x055, 0x9d, 0x055 },
    { 0xb0, 0x09, 0x010, 0xb0, 0x010 },
    { 0xb0, 0x09, 0x011, 0xb0, 0x011 },
    { 0xb5, 0x00, 0x0c4, 0xb5, 0x0c4 },
    { 0xb5, 0x00, 0x0c5, 0xb5, 0x0c5 },
    { 0x0f, 0x09, 0x0d0, 0x0f, 0x0d0 },
    { 0x0f, 0x09, 0x0d1, 0x0f, 0x0d1 },
    { 0xf7, 0x01, 0x0d4, 0xee, 0x0d5 },
    { 0xf7, 0x01, 0x0d5, 0xef, 0x0d5 },
    { 0xbd, 0x09, 0x0c0, 0xbd, 0x0c0 },
    { 0xbd, 0x09, 0x0c1, 0xbd, 0x0c1 },
    { 0xca, 0x09, 0x040, 0xca, 0x040 },
    { 0xca, 0x09, 0x041, 0xca, 0x041 },
    { 0x2f, 0x09, 0x080, 0x2f, 0x080 },
    { 0x2f, 0x09, 0x081, 0x2f, 0x081 },
    { 0xc3, 0x09, 0x014, 0xc3, 0x014 },
    { 0xc3, 0x09, 0x015, 0xc3, 0x015 },
    { 0x6a, 0x09, 0x000, 0x6a, 0x000 },
    { 0x6a, 0x09, 0x001, 0x6a, 0x001 },
    { 0xcc, 0x09, 0x010, 0xcc, 0x010 },
    { 0xcc, 0x09, 0x011, 0xcc, 0x011 },
    { 0xe9, 0x09, 0x804, 0xe9, 0x80c },
    { 0xe9, 0x09, 0x805, 0xe9, 0x80d },
    { 0x6b, 0x00, 0x040, 0x6b, 0x040 },
    { 0x6b, 0x00, 0x041, 0x6b, 0x041 },
};

const uint16_t g_cBs3CpuInstr2_rcl_intel_TestDataU16 = 64;
const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_rcl_intel_TestDataU16[64] =
{
    { 0x0000, 0x58, 0x0d0, 0x0000, 0x0d0 },
    { 0x0000, 0x58, 0x0d1, 0x0040, 0x0d0 },
    { 0xffff, 0x0e, 0x014, 0xdfff, 0x015 },
    { 0xffff, 0x0e, 0x015, 0xffff, 0x015 },
    { 0x0000, 0x0d, 0x054, 0x0000, 0x054 },
    { 0x0000, 0x0d, 0x055, 0x1000, 0x054 },
    { 0x01a2, 0x08, 0x090, 0xa200, 0x091 },
    { 0x01a2, 0x08, 0x091, 0xa280, 0x091 },
    { 0x023e, 0x00, 0x014, 0x023e, 0x014 },
    { 0x023e, 0x00, 0x015, 0x023e, 0x015 },
    { 0x36eb, 0x0f, 0x040, 0x8dba, 0x041 },
    { 0x36eb, 0x0f, 0x041, 0xcdba, 0x041 },
    { 0x00cf, 0x02, 0x890, 0x033c, 0x090 },
    { 0x00cf, 0x02, 0x891, 0x033e, 0x090 },
    { 0x6856, 0x04, 0x054, 0x8563, 0x85c },
    { 0x6856, 0x04, 0x055, 0x856b, 0x85c },
    { 0xbcb3, 0x0a, 0x040, 0xcd79, 0x848 },
    { 0xbcb3, 0x0a, 0x041, 0xcf79, 0x848 },
    { 0x003a, 0x0c, 0x010, 0xa001, 0x011 },
    { 0x003a, 0x0c, 0x011, 0xa801, 0x011 },
    { 0x31c4, 0x1c, 0x004, 0x20c7, 0x004 },
    { 0x31c4, 0x1c, 0x005, 0x24c7, 0x004 },
    { 0xc854, 0x04, 0x010, 0x8546, 0x010 },
    { 0xc854, 0x04, 0x011, 0x854e, 0x010 },
    { 0x0243, 0x58, 0x010, 0x2180, 0x011 },
    { 0x0243, 0x58, 0x011, 0x21c0, 0x011 },
    { 0xb9d1, 0x0f, 0x884, 0xae74, 0x88c },
    { 0xb9d1, 0x0f, 0x885, 0xee74, 0x88c },
    { 0x6270, 0x18, 0x000, 0x3818, 0x809 },
    { 0x6270, 0x18, 0x001, 0x3858, 0x809 },
    { 0x3494, 0x03, 0x000, 0xa4a0, 0x001 },
    { 0x3494, 0x03, 0x001, 0xa4a4, 0x001 },
    { 0x6034, 0x07, 0x0c0, 0x1a18, 0x8c8 },
    { 0x6034, 0x07, 0x0c1, 0x1a58, 0x8c8 },
    { 0xaa86, 0x01, 0x0d0, 0x550c, 0x8d9 },
    { 0xaa86, 0x01, 0x0d1, 0x550d, 0x8d9 },
    { 0x12a2, 0x01, 0x040, 0x2544, 0x040 },
    { 0x12a2, 0x01, 0x041, 0x2545, 0x040 },
    { 0xf781, 0x10, 0x014, 0x7bc0, 0x015 },
    { 0xf781, 0x10, 0x015, 0xfbc0, 0x015 },
    { 0x2bb3, 0x11, 0x0c4, 0x2bb3, 0x0c4 },
    { 0x2bb3, 0x11, 0x0c5, 0x2bb3, 0x0c5 },
    { 0x016f, 0x11, 0x014, 0x016f, 0x014 },
    { 0x016f, 0x11, 0x015, 0x016f, 0x015 },
    { 0xa1e9, 0x11, 0x840, 0xa1e9, 0x848 },
    { 0xa1e9, 0x11, 0x841, 0xa1e9, 0x849 },
    { 0x0a1f, 0x11, 0x800, 0x0a1f, 0x808 },
    { 0x0a1f, 0x11, 0x801, 0x0a1f, 0x809 },
    { 0x0015, 0x11, 0x850, 0x0015, 0x858 },
    { 0x0015, 0x11, 0x851, 0x0015, 0x859 },
    { 0x1ebc, 0x11, 0x0c0, 0x1ebc, 0x0c0 },
    { 0x1ebc, 0x11, 0x0c1, 0x1ebc, 0x0c1 },
    { 0x4d38, 0x11, 0x004, 0x4d38, 0x004 },
    { 0x4d38, 0x11, 0x005, 0x4d38, 0x005 },
    { 0x1fb3, 0x11, 0x050, 0x1fb3, 0x050 },
    { 0x1fb3, 0x11, 0x051, 0x1fb3, 0x051 },
    { 0x0607, 0x11, 0x044, 0x0607, 0x044 },
    { 0x0607, 0x11, 0x045, 0x0607, 0x045 },
    { 0x901a, 0x11, 0x044, 0x901a, 0x044 },
    { 0x901a, 0x11, 0x045, 0x901a, 0x045 },
    { 0x1c73, 0x11, 0x000, 0x1c73, 0x000 },
    { 0x1c73, 0x11, 0x001, 0x1c73, 0x001 },
    { 0x9dd9, 0x11, 0x0c0, 0x9dd9, 0x0c0 },
    { 0x9dd9, 0x11, 0x0c1, 0x9dd9, 0x0c1 },
};

const uint16_t g_cBs3CpuInstr2_rcl_intel_TestDataU32 = 72;
const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_rcl_intel_TestDataU32[72] =
{
    { 0x00000000, 0x3f, 0x080, 0x00000000, 0x080 },
    { 0x00000000, 0x3f, 0x081, 0x40000000, 0x080 },
    { 0xffffffff, 0x16, 0x014, 0xffdfffff, 0x015 },
    { 0xffffffff, 0x16, 0x015, 0xffffffff, 0x015 },
    { 0x00000000, 0x0e, 0x010, 0x00000000, 0x010 },
    { 0x00000000, 0x0e, 0x011, 0x00002000, 0x010 },
    { 0xad1acf63, 0x37, 0x004, 0xb1ab46b3, 0x80d },
    { 0xad1acf63, 0x37, 0x005, 0xb1eb46b3, 0x80d },
    { 0x80ea23b2, 0x29, 0x844, 0xd4476480, 0x84d },
    { 0x80ea23b2, 0x29, 0x845, 0xd4476580, 0x84d },
    { 0x0eb61ca2, 0x0d, 0x000, 0xc39440eb, 0x000 },
    { 0x0eb61ca2, 0x0d, 0x001, 0xc39450eb, 0x000 },
    { 0xc6e2a573, 0x0d, 0x014, 0x54ae6c6e, 0x014 },
    { 0xc6e2a573, 0x0d, 0x015, 0x54ae7c6e, 0x014 },
    { 0xc7b05fe6, 0x1b, 0x014, 0x331ec17f, 0x015 },
    { 0xc7b05fe6, 0x1b, 0x015, 0x371ec17f, 0x015 },
    { 0xd829226d, 0x12, 0x054, 0x89b5b052, 0x054 },
    { 0xd829226d, 0x12, 0x055, 0x89b7b052, 0x054 },
    { 0x9c87c613, 0x07, 0x090, 0x43e309a7, 0x898 },
    { 0x9c87c613, 0x07, 0x091, 0x43e309e7, 0x898 },
    { 0x00000192, 0x01, 0x040, 0x00000324, 0x040 },
    { 0x00000192, 0x01, 0x041, 0x00000325, 0x040 },
    { 0xb4244475, 0x11, 0x080, 0x88eab424, 0x888 },
    { 0xb4244475, 0x11, 0x081, 0x88ebb424, 0x888 },
    { 0x47c5a8c8, 0x14, 0x044, 0x8c823e2d, 0x84c },
    { 0x47c5a8c8, 0x14, 0x045, 0x8c8a3e2d, 0x84c },
    { 0x10c9d734, 0x09, 0x004, 0x93ae6810, 0x005 },
    { 0x10c9d734, 0x09, 0x005, 0x93ae6910, 0x005 },
    { 0x2eaaf30e, 0x11, 0x094, 0xe61c2eaa, 0x095 },
    { 0x2eaaf30e, 0x11, 0x095, 0xe61d2eaa, 0x095 },
    { 0x00000099, 0x14, 0x050, 0x09900000, 0x050 },
    { 0x00000099, 0x14, 0x051, 0x09980000, 0x050 },
    { 0x4886e1f6, 0x0d, 0x080, 0xdc3ec488, 0x888 },
    { 0x4886e1f6, 0x0d, 0x081, 0xdc3ed488, 0x888 },
    { 0x17ce0dc6, 0x1f, 0x010, 0x05f38371, 0x011 },
    { 0x17ce0dc6, 0x1f, 0x011, 0x45f38371, 0x011 },
    { 0xc97167e7, 0x1c, 0x894, 0x764b8b3f, 0x094 },
    { 0xc97167e7, 0x1c, 0x895, 0x7e4b8b3f, 0x094 },
    { 0xd08fb80c, 0x00, 0x0d4, 0xd08fb80c, 0x0d4 },
    { 0xd08fb80c, 0x00, 0x0d5, 0xd08fb80c, 0x0d5 },
    { 0x0000062a, 0x01, 0x050, 0x00000c54, 0x050 },
    { 0x0000062a, 0x01, 0x051, 0x00000c55, 0x050 },
    { 0xd25d66d9, 0x20, 0x040, 0xd25d66d9, 0x040 },
    { 0xd25d66d9, 0x20, 0x041, 0xd25d66d9, 0x041 },
    { 0x05456169, 0x21, 0x054, 0x0a8ac2d2, 0x054 },
    { 0x05456169, 0x21, 0x055, 0x0a8ac2d3, 0x054 },
    { 0xcba88dcc, 0x21, 0x0c4, 0x97511b98, 0x0c5 },
    { 0xcba88dcc, 0x21, 0x0c5, 0x97511b99, 0x0c5 },
    { 0xc6c866fe, 0x21, 0x090, 0x8d90cdfc, 0x091 },
    { 0xc6c866fe, 0x21, 0x091, 0x8d90cdfd, 0x091 },
    { 0x0007345d, 0x21, 0x004, 0x000e68ba, 0x004 },
    { 0x0007345d, 0x21, 0x005, 0x000e68bb, 0x004 },
    { 0x597f7a89, 0x21, 0x000, 0xb2fef512, 0x808 },
    { 0x597f7a89, 0x21, 0x001, 0xb2fef513, 0x808 },
    { 0xbef1f324, 0x21, 0x010, 0x7de3e648, 0x819 },
    { 0xbef1f324, 0x21, 0x011, 0x7de3e649, 0x819 },
    { 0xa8bf12c8, 0x21, 0x000, 0x517e2590, 0x809 },
    { 0xa8bf12c8, 0x21, 0x001, 0x517e2591, 0x809 },
    { 0x66b2e83d, 0x21, 0x090, 0xcd65d07a, 0x898 },
    { 0x66b2e83d, 0x21, 0x091, 0xcd65d07b, 0x898 },
    { 0x000009fc, 0x21, 0x054, 0x000013f8, 0x054 },
    { 0x000009fc, 0x21, 0x055, 0x000013f9, 0x054 },
    { 0x9fcba1f3, 0x21, 0x8d0, 0x3f9743e6, 0x8d9 },
    { 0x9fcba1f3, 0x21, 0x8d1, 0x3f9743e7, 0x8d9 },
    { 0xf182baef, 0x21, 0x014, 0xe30575de, 0x015 },
    { 0xf182baef, 0x21, 0x015, 0xe30575df, 0x015 },
    { 0xa7e6237b, 0x21, 0x884, 0x4fcc46f6, 0x88d },
    { 0xa7e6237b, 0x21, 0x885, 0x4fcc46f7, 0x88d },
    { 0x4cfd92c7, 0x21, 0x054, 0x99fb258e, 0x85c },
    { 0x4cfd92c7, 0x21, 0x055, 0x99fb258f, 0x85c },
    { 0x00000ef5, 0x21, 0x014, 0x00001dea, 0x014 },
    { 0x00000ef5, 0x21, 0x015, 0x00001deb, 0x014 },
};

const uint16_t g_cBs3CpuInstr2_rcr_intel_TestDataU8 = 64;
const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_rcr_intel_TestDataU8[64] =
{
    { 0x00, 0x00, 0x0c4, 0x00, 0x0c4 },
    { 0x00, 0x00, 0x0c5, 0x00, 0x0c5 },
    { 0xff, 0x03, 0x010, 0xdf, 0x819 },
    { 0xff, 0x03, 0x011, 0xff, 0x011 },
    { 0x00, 0x09, 0x050, 0x00, 0x050 },
    { 0x00, 0x09, 0x051, 0x00, 0x051 },
    { 0x7f, 0x00, 0x080, 0x7f, 0x080 },
    { 0x7f, 0x00, 0x081, 0x7f, 0x081 },
    { 0xbe, 0x06, 0x014, 0xf2, 0x81d },
    { 0xbe, 0x06, 0x015, 0xf6, 0x015 },
    { 0xd5, 0x00, 0x8d0, 0xd5, 0x8d8 },
    { 0xd5, 0x00, 0x8d1, 0xd5, 0x8d9 },
    { 0xf3, 0x58, 0x044, 0x9b, 0x84d },
    { 0xf3, 0x58, 0x045, 0x9f, 0x045 },
    { 0xdc, 0x00, 0x094, 0xdc, 0x094 },
    { 0xdc, 0x00, 0x095, 0xdc, 0x095 },
    { 0x27, 0x6e, 0x040, 0x71, 0x040 },
    { 0x27, 0x6e, 0x041, 0x79, 0x848 },
    { 0xa3, 0x06, 0x880, 0x1a, 0x889 },
    { 0xa3, 0x06, 0x881, 0x1e, 0x081 },
    { 0x67, 0x0e, 0x000, 0x73, 0x000 },
    { 0x67, 0x0e, 0x001, 0x7b, 0x808 },
    { 0xb3, 0x04, 0x090, 0x6b, 0x898 },
    { 0xb3, 0x04, 0x091, 0x7b, 0x090 },
    { 0xe9, 0x03, 0x004, 0x5d, 0x80c },
    { 0xe9, 0x03, 0x005, 0x7d, 0x004 },
    { 0x11, 0x07, 0x014, 0x44, 0x014 },
    { 0x11, 0x07, 0x015, 0x46, 0x81c },
    { 0x4b, 0x02, 0x080, 0x92, 0x081 },
    { 0x4b, 0x02, 0x081, 0xd2, 0x889 },
    { 0x4e, 0x04, 0x044, 0xc4, 0x045 },
    { 0x4e, 0x04, 0x045, 0xd4, 0x84d },
    { 0xad, 0x0b, 0x050, 0xab, 0x858 },
    { 0xad, 0x0b, 0x051, 0xeb, 0x050 },
    { 0xa1, 0x01, 0x084, 0x50, 0x88d },
    { 0xa1, 0x01, 0x085, 0xd0, 0x085 },
    { 0xb5, 0x01, 0x0d4, 0x5a, 0x8dd },
    { 0xb5, 0x01, 0x0d5, 0xda, 0x0d5 },
    { 0x24, 0x08, 0x090, 0x48, 0x090 },
    { 0x24, 0x08, 0x091, 0x49, 0x898 },
    { 0xa2, 0x04, 0x080, 0x4a, 0x888 },
    { 0xa2, 0x04, 0x081, 0x5a, 0x080 },
    { 0x9b, 0x00, 0x0d4, 0x9b, 0x0d4 },
    { 0x9b, 0x00, 0x0d5, 0x9b, 0x0d5 },
    { 0x5c, 0xa5, 0x814, 0xc2, 0x015 },
    { 0x5c, 0xa5, 0x815, 0xca, 0x81d },
    { 0x2f, 0x63, 0x0c0, 0xc5, 0x0c1 },
    { 0x2f, 0x63, 0x0c1, 0xe5, 0x8c9 },
    { 0xae, 0x01, 0x054, 0x57, 0x85c },
    { 0xae, 0x01, 0x055, 0xd7, 0x054 },
    { 0xdd, 0x0b, 0x0c4, 0xb7, 0x8cc },
    { 0xdd, 0x0b, 0x0c5, 0xf7, 0x0c4 },
    { 0xda, 0x05, 0x090, 0xa6, 0x899 },
    { 0xda, 0x05, 0x091, 0xae, 0x091 },
    { 0xf8, 0x07, 0x040, 0xe1, 0x849 },
    { 0xf8, 0x07, 0x041, 0xe3, 0x041 },
    { 0x66, 0x03, 0x014, 0x8c, 0x015 },
    { 0x66, 0x03, 0x015, 0xac, 0x81d },
    { 0xa9, 0x07, 0x010, 0xa5, 0x818 },
    { 0xa9, 0x07, 0x011, 0xa7, 0x010 },
    { 0x97, 0x84, 0x090, 0xe9, 0x898 },
    { 0x97, 0x84, 0x091, 0xf9, 0x090 },
    { 0xf6, 0x05, 0x084, 0x67, 0x88d },
    { 0xf6, 0x05, 0x085, 0x6f, 0x085 },
};

const uint16_t g_cBs3CpuInstr2_rcr_intel_TestDataU16 = 64;
const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_rcr_intel_TestDataU16[64] =
{
    { 0x0000, 0x06, 0x050, 0x0000, 0x050 },
    { 0x0000, 0x06, 0x051, 0x0400, 0x858 },
    { 0xffff, 0x58, 0x0d0, 0xfdff, 0x8d9 },
    { 0xffff, 0x58, 0x0d1, 0xffff, 0x0d1 },
    { 0x0000, 0x03, 0x0d0, 0x0000, 0x0d0 },
    { 0x0000, 0x03, 0x0d1, 0x2000, 0x8d8 },
    { 0x07f6, 0x00, 0x0c4, 0x07f6, 0x0c4 },
    { 0x07f6, 0x00, 0x0c5, 0x07f6, 0x0c5 },
    { 0x77a1, 0x0c, 0x0c0, 0xf427, 0x0c0 },
    { 0x77a1, 0x0c, 0x0c1, 0xf437, 0x8c8 },
    { 0xfb73, 0x04, 0x004, 0x6fb7, 0x80c },
    { 0xfb73, 0x04, 0x005, 0x7fb7, 0x004 },
    { 0x01e2, 0x0a, 0x000, 0xf100, 0x000 },
    { 0x01e2, 0x0a, 0x001, 0xf140, 0x808 },
    { 0x1a08, 0x10, 0x050, 0x3410, 0x050 },
    { 0x1a08, 0x10, 0x051, 0x3411, 0x858 },
    { 0x7289, 0x14, 0x054, 0x4e51, 0x054 },
    { 0x7289, 0x14, 0x055, 0x6e51, 0x85c },
    { 0x0016, 0x08, 0x004, 0x2c00, 0x004 },
    { 0x0016, 0x08, 0x005, 0x2d00, 0x80c },
    { 0x7ca0, 0x1e, 0x040, 0xca03, 0x041 },
    { 0x7ca0, 0x1e, 0x041, 0xca0b, 0x849 },
    { 0x81f2, 0x0b, 0x000, 0x7c90, 0x808 },
    { 0x81f2, 0x0b, 0x001, 0x7cb0, 0x000 },
    { 0x0b83, 0x07, 0x084, 0x0c17, 0x084 },
    { 0x0b83, 0x07, 0x085, 0x0e17, 0x88c },
    { 0xa107, 0x02, 0x8c4, 0xa841, 0x8cd },
    { 0xa107, 0x02, 0x8c5, 0xe841, 0x0c5 },
    { 0x0e57, 0x01, 0x0d0, 0x072b, 0x0d1 },
    { 0x0e57, 0x01, 0x0d1, 0x872b, 0x8d9 },
    { 0x0016, 0x0c, 0x000, 0x02c0, 0x000 },
    { 0x0016, 0x0c, 0x001, 0x02d0, 0x808 },
    { 0xe12b, 0x11, 0x054, 0xe12b, 0x054 },
    { 0xe12b, 0x11, 0x055, 0xe12b, 0x055 },
    { 0xd45c, 0xc6, 0x004, 0xe351, 0x80c },
    { 0xd45c, 0xc6, 0x005, 0xe751, 0x004 },
    { 0x0123, 0x0e, 0x094, 0x0918, 0x094 },
    { 0x0123, 0x0e, 0x095, 0x091c, 0x89c },
    { 0xbffd, 0x05, 0x044, 0xd5ff, 0x84d },
    { 0xbffd, 0x05, 0x045, 0xddff, 0x045 },
    { 0xb6d0, 0x02, 0x090, 0x2db4, 0x898 },
    { 0xb6d0, 0x02, 0x091, 0x6db4, 0x090 },
    { 0x4b76, 0x01, 0x014, 0x25bb, 0x014 },
    { 0x4b76, 0x01, 0x015, 0xa5bb, 0x81c },
    { 0xb1a8, 0x04, 0x0c4, 0x0b1a, 0x8cd },
    { 0xb1a8, 0x04, 0x0c5, 0x1b1a, 0x0c5 },
    { 0xdf1e, 0x04, 0x814, 0xcdf1, 0x81d },
    { 0xdf1e, 0x04, 0x815, 0xddf1, 0x015 },
    { 0x093c, 0x0d, 0x0d0, 0x93c0, 0x0d0 },
    { 0x093c, 0x0d, 0x0d1, 0x93c8, 0x8d8 },
    { 0xcce8, 0x00, 0x004, 0xcce8, 0x004 },
    { 0xcce8, 0x00, 0x005, 0xcce8, 0x005 },
    { 0x8396, 0x84, 0x080, 0xc839, 0x888 },
    { 0x8396, 0x84, 0x081, 0xd839, 0x080 },
    { 0x208d, 0x0a, 0x050, 0x4688, 0x050 },
    { 0x208d, 0x0a, 0x051, 0x46c8, 0x858 },
    { 0xdf2b, 0x0a, 0x010, 0x95b7, 0x819 },
    { 0xdf2b, 0x0a, 0x011, 0x95f7, 0x011 },
    { 0xb887, 0x02, 0x0d4, 0xae21, 0x8dd },
    { 0xb887, 0x02, 0x0d5, 0xee21, 0x0d5 },
    { 0x0352, 0x1a, 0x800, 0x5201, 0x001 },
    { 0x0352, 0x1a, 0x801, 0x5281, 0x809 },
    { 0x631e, 0x42, 0x050, 0x18c7, 0x051 },
    { 0x631e, 0x42, 0x051, 0x58c7, 0x859 },
};

const uint16_t g_cBs3CpuInstr2_rcr_intel_TestDataU32 = 72;
const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_rcr_intel_TestDataU32[72] =
{
    { 0x00000000, 0x11, 0x084, 0x00000000, 0x084 },
    { 0x00000000, 0x11, 0x085, 0x00008000, 0x88c },
    { 0xffffffff, 0x84, 0x044, 0xefffffff, 0x84d },
    { 0xffffffff, 0x84, 0x045, 0xffffffff, 0x045 },
    { 0x00000000, 0x05, 0x8c4, 0x00000000, 0x0c4 },
    { 0x00000000, 0x05, 0x8c5, 0x08000000, 0x8cc },
    { 0x9622e89f, 0x13, 0x894, 0xba27d2c4, 0x89c },
    { 0x9622e89f, 0x13, 0x895, 0xba27f2c4, 0x094 },
    { 0x3244f50b, 0x15, 0x0c0, 0x4f50b192, 0x0c0 },
    { 0x3244f50b, 0x15, 0x0c1, 0x4f50b992, 0x8c8 },
    { 0x00021120, 0x1b, 0x054, 0x00844800, 0x054 },
    { 0x00021120, 0x1b, 0x055, 0x00844820, 0x85c },
    { 0x77af458f, 0x18, 0x004, 0x5e8b1e77, 0x005 },
    { 0x77af458f, 0x18, 0x005, 0x5e8b1f77, 0x80d },
    { 0xf99a6629, 0x1e, 0x844, 0xccd3314b, 0x84d },
    { 0xf99a6629, 0x1e, 0x845, 0xccd3314f, 0x045 },
    { 0x53b57054, 0xe7, 0x094, 0x50a76ae0, 0x095 },
    { 0x53b57054, 0xe7, 0x095, 0x52a76ae0, 0x89d },
    { 0x77350376, 0x1e, 0x044, 0xb9a81bb1, 0x045 },
    { 0x77350376, 0x1e, 0x045, 0xb9a81bb5, 0x84d },
    { 0x00000b38, 0x15, 0x0c0, 0x00b38000, 0x0c0 },
    { 0x00000b38, 0x15, 0x0c1, 0x00b38800, 0x8c8 },
    { 0xd79008d3, 0x0e, 0x040, 0x469b5e40, 0x848 },
    { 0xd79008d3, 0x0e, 0x041, 0x469f5e40, 0x040 },
    { 0xf003eba4, 0x1c, 0x010, 0x007d748f, 0x818 },
    { 0xf003eba4, 0x1c, 0x011, 0x007d749f, 0x010 },
    { 0x6c28c530, 0x09, 0x054, 0x30361462, 0x055 },
    { 0x6c28c530, 0x09, 0x055, 0x30b61462, 0x85d },
    { 0xda152dec, 0x08, 0x0d4, 0xd8da152d, 0x8dd },
    { 0xda152dec, 0x08, 0x0d5, 0xd9da152d, 0x0d5 },
    { 0x000d9c09, 0x1f, 0x094, 0x00367024, 0x094 },
    { 0x000d9c09, 0x1f, 0x095, 0x00367026, 0x89c },
    { 0xb3308ea2, 0x0f, 0x014, 0x3a896661, 0x81c },
    { 0xb3308ea2, 0x0f, 0x015, 0x3a8b6661, 0x014 },
    { 0xe0799ed7, 0x1c, 0x054, 0x0f33daee, 0x85c },
    { 0xe0799ed7, 0x1c, 0x055, 0x0f33dafe, 0x054 },
    { 0xb266bf88, 0x2f, 0x0d4, 0xfe2164cd, 0x8dc },
    { 0xb266bf88, 0x2f, 0x0d5, 0xfe2364cd, 0x0d4 },
    { 0x85762b44, 0x00, 0x0d0, 0x85762b44, 0x0d0 },
    { 0x85762b44, 0x00, 0x0d1, 0x85762b44, 0x0d1 },
    { 0x00008e60, 0x01, 0x090, 0x00004730, 0x090 },
    { 0x00008e60, 0x01, 0x091, 0x80004730, 0x898 },
    { 0x184a001d, 0x20, 0x000, 0x184a001d, 0x000 },
    { 0x184a001d, 0x20, 0x001, 0x184a001d, 0x001 },
    { 0xd5e2ef43, 0x21, 0x094, 0x6af177a1, 0x89d },
    { 0xd5e2ef43, 0x21, 0x095, 0xeaf177a1, 0x095 },
    { 0x2fe845aa, 0x21, 0x040, 0x17f422d5, 0x040 },
    { 0x2fe845aa, 0x21, 0x041, 0x97f422d5, 0x848 },
    { 0x9b6a381e, 0x21, 0x010, 0x4db51c0f, 0x818 },
    { 0x9b6a381e, 0x21, 0x011, 0xcdb51c0f, 0x010 },
    { 0x00320b3d, 0x21, 0x0d4, 0x0019059e, 0x0d5 },
    { 0x00320b3d, 0x21, 0x0d5, 0x8019059e, 0x8dd },
    { 0x9da2f01b, 0x21, 0x0d0, 0x4ed1780d, 0x8d9 },
    { 0x9da2f01b, 0x21, 0x0d1, 0xced1780d, 0x0d1 },
    { 0x627d3c5c, 0x21, 0x054, 0x313e9e2e, 0x054 },
    { 0x627d3c5c, 0x21, 0x055, 0xb13e9e2e, 0x85c },
    { 0x50e53b4d, 0x21, 0x0c4, 0x28729da6, 0x0c5 },
    { 0x50e53b4d, 0x21, 0x0c5, 0xa8729da6, 0x8cd },
    { 0x26f62b4a, 0x01, 0x0d0, 0x137b15a5, 0x0d0 },
    { 0x26f62b4a, 0x01, 0x0d1, 0x937b15a5, 0x8d8 },
    { 0x0000198e, 0x21, 0x0c4, 0x00000cc7, 0x0c4 },
    { 0x0000198e, 0x21, 0x0c5, 0x80000cc7, 0x8cc },
    { 0x41fecd90, 0x21, 0x0d0, 0x20ff66c8, 0x0d0 },
    { 0x41fecd90, 0x21, 0x0d1, 0xa0ff66c8, 0x8d8 },
    { 0x568af637, 0x21, 0x0d4, 0x2b457b1b, 0x0d5 },
    { 0x568af637, 0x21, 0x0d5, 0xab457b1b, 0x8dd },
    { 0xdbed10d2, 0x21, 0x014, 0x6df68869, 0x81c },
    { 0xdbed10d2, 0x21, 0x015, 0xedf68869, 0x014 },
    { 0xce783943, 0x21, 0x000, 0x673c1ca1, 0x809 },
    { 0xce783943, 0x21, 0x001, 0xe73c1ca1, 0x001 },
    { 0x00050066, 0x21, 0x0c4, 0x00028033, 0x0c4 },
    { 0x00050066, 0x21, 0x0c5, 0x80028033, 0x8cc },
};