/* $Id: bs3-cpu-instr-2-data16-amd.c16 104007 2024-03-22 23:42:08Z vboxsync $ */
/** @file
 * BS3Kit - bs3-cpu-instr-2, bs3-cpu-instr-2-data16-amd.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_amd_TestDataU8 = 28;
const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_shl_amd_TestDataU8[28] =
{
    { 0x00, 0x00, 0x015, 0x00, 0x015 },
    { 0xff, 0x08, 0x0c1, 0x00, 0x85d },
    { 0x00, 0x01, 0x015, 0x00, 0x054 },
    { 0xba, 0x08, 0x0d1, 0x00, 0x054 },
    { 0xca, 0x02, 0x081, 0x28, 0x81d },
    { 0x70, 0x0b, 0x055, 0x00, 0x054 },
    { 0x7c, 0x07, 0x0c1, 0x00, 0x054 },
    { 0x4e, 0x0f, 0x050, 0x00, 0x054 },
    { 0x69, 0x04, 0x084, 0x90, 0x89c },
    { 0x93, 0x00, 0x054, 0x93, 0x054 },
    { 0xe4, 0x00, 0x0d4, 0xe4, 0x0d4 },
    { 0xe8, 0x07, 0x000, 0x00, 0x054 },
    { 0xd7, 0x06, 0x0c5, 0xc0, 0x095 },
    { 0x58, 0x04, 0x0d0, 0x80, 0x091 },
    { 0x6e, 0x05, 0x015, 0xc0, 0x095 },
    { 0x2f, 0x09, 0x055, 0x00, 0x054 },
    { 0xce, 0x09, 0x050, 0x00, 0x054 },
    { 0xd8, 0x09, 0x890, 0x00, 0x054 },
    { 0x53, 0x09, 0x011, 0x00, 0x054 },
    { 0xef, 0x09, 0x004, 0x00, 0x054 },
    { 0x9b, 0x09, 0x011, 0x00, 0x054 },
    { 0x15, 0x09, 0x081, 0x00, 0x054 },
    { 0x3e, 0x00, 0x095, 0x3e, 0x095 },
    { 0x63, 0x09, 0x091, 0x00, 0x054 },
    { 0xd3, 0x00, 0x0c0, 0xd3, 0x0c0 },
    { 0xa9, 0x0b, 0x001, 0x00, 0x054 },
    { 0xfa, 0x02, 0x800, 0xe8, 0x095 },
    { 0x90, 0x00, 0x0d5, 0x90, 0x0d5 },
};

const uint16_t g_cBs3CpuInstr2_shl_amd_TestDataU16 = 28;
const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_shl_amd_TestDataU16[28] =
{
    { 0x0000, 0x0f, 0x005, 0x0000, 0x054 },
    { 0xffff, 0x07, 0x005, 0xff80, 0x091 },
    { 0x0000, 0x01, 0x010, 0x0000, 0x054 },
    { 0x000f, 0x04, 0x005, 0x00f0, 0x014 },
    { 0xecb6, 0x04, 0x051, 0xcb60, 0x89c },
    { 0xa5a4, 0x05, 0x0c1, 0xb480, 0x898 },
    { 0x0001, 0x1e, 0x015, 0x0000, 0x054 },
    { 0x3c5b, 0x11, 0x010, 0x0000, 0x054 },
    { 0x07c3, 0xf2, 0x001, 0x0000, 0x054 },
    { 0x022b, 0x0e, 0x084, 0xc000, 0x89c },
    { 0xb512, 0x01, 0x094, 0x6a24, 0x81d },
    { 0xe071, 0x06, 0x810, 0x1c40, 0x010 },
    { 0x0034, 0x0d, 0x0d4, 0x8000, 0x89c },
    { 0xea50, 0x0c, 0x080, 0x0000, 0x85d },
    { 0xdaf2, 0x08, 0x0c1, 0xf200, 0x89c },
    { 0x017b, 0x00, 0x0c4, 0x017b, 0x0c4 },
    { 0x2a68, 0x10, 0x0d5, 0x0000, 0x054 },
    { 0x5ca0, 0x08, 0x051, 0xa000, 0x89c },
    { 0x00d9, 0x13, 0x085, 0x0000, 0x054 },
    { 0x41eb, 0x0c, 0x015, 0xb000, 0x89c },
    { 0x4d07, 0x05, 0x0c1, 0xa0e0, 0x091 },
    { 0x0258, 0x04, 0x0d0, 0x2580, 0x010 },
    { 0x169f, 0x42, 0x041, 0x5a7c, 0x010 },
    { 0x5a7c, 0xfd, 0x005, 0x0000, 0x054 },
    { 0x2d81, 0x06, 0x050, 0x6040, 0x819 },
    { 0x874b, 0x07, 0x081, 0xa580, 0x091 },
    { 0xce1a, 0x0c, 0x040, 0xa000, 0x095 },
    { 0x03de, 0x13, 0x884, 0x0000, 0x054 },
};

const uint16_t g_cBs3CpuInstr2_shl_amd_TestDataU32 = 32;
const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_shl_amd_TestDataU32[32] =
{
    { 0x00000000, 0x1b, 0x000, 0x00000000, 0x054 },
    { 0xffffffff, 0x35, 0x081, 0xffe00000, 0x095 },
    { 0x00000000, 0x0c, 0x041, 0x00000000, 0x054 },
    { 0x9e3c3abd, 0xbb, 0x0c4, 0xe8000000, 0x095 },
    { 0xa652240a, 0x01, 0x091, 0x4ca44814, 0x81d },
    { 0x0000016c, 0x0b, 0x884, 0x000b6000, 0x014 },
    { 0x86c1bf62, 0x35, 0x0d5, 0xec400000, 0x095 },
    { 0x815ebfe7, 0x3c, 0x084, 0x70000000, 0x014 },
    { 0xab190947, 0x10, 0x090, 0x09470000, 0x81d },
    { 0x20727b5b, 0x0d, 0x845, 0x4f6b6000, 0x014 },
    { 0x00775cde, 0x01, 0x084, 0x00eeb9bc, 0x010 },
    { 0x38729e0f, 0x1d, 0x094, 0xe0000000, 0x095 },
    { 0xc5ed8515, 0x14, 0x041, 0x51500000, 0x014 },
    { 0xc5be6f15, 0x07, 0x084, 0xdf378a80, 0x898 },
    { 0x2337a582, 0x84, 0x050, 0x337a5820, 0x010 },
    { 0x0eda3ed9, 0x1a, 0x000, 0x64000000, 0x81d },
    { 0x92aa10b8, 0x3d, 0x041, 0x00000000, 0x85d },
    { 0x3a92bec7, 0x00, 0x084, 0x3a92bec7, 0x084 },
    { 0x3e408f33, 0x20, 0x0d0, 0x3e408f33, 0x0d0 },
    { 0x5590f087, 0x21, 0x0d5, 0xab21e10e, 0x898 },
    { 0x0000156f, 0x21, 0x0d5, 0x00002ade, 0x014 },
    { 0x1d3191a6, 0x21, 0x014, 0x3a63234c, 0x010 },
    { 0x20b99aa4, 0x21, 0x000, 0x41733548, 0x014 },
    { 0x6e42277d, 0x21, 0x054, 0xdc844efa, 0x89c },
    { 0xf9dfbf88, 0x00, 0x804, 0xf9dfbf88, 0x80c },
    { 0x001ae66e, 0x21, 0x0c1, 0x0035ccdc, 0x010 },
    { 0x7a00e7b7, 0x21, 0x094, 0xf401cf6e, 0x898 },
    { 0xe2496524, 0x21, 0x055, 0xc492ca48, 0x095 },
    { 0xda804f93, 0x21, 0x091, 0xb5009f26, 0x091 },
    { 0x3b1ff688, 0x21, 0x011, 0x763fed10, 0x010 },
    { 0x0ae44b3c, 0x21, 0x040, 0x15c89678, 0x014 },
    { 0x74e76150, 0x21, 0x015, 0xe9cec2a0, 0x89c },
};

const uint16_t g_cBs3CpuInstr2_shr_amd_TestDataU8 = 28;
const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_shr_amd_TestDataU8[28] =
{
    { 0x00, 0x01, 0x0d0, 0x00, 0x054 },
    { 0xff, 0x0b, 0x091, 0x00, 0x054 },
    { 0x00, 0x00, 0x0c0, 0x00, 0x0c0 },
    { 0xf8, 0x05, 0x0c0, 0x07, 0x011 },
    { 0x39, 0x03, 0x084, 0x07, 0x010 },
    { 0x37, 0x06, 0x010, 0x00, 0x055 },
    { 0xdf, 0x06, 0x055, 0x03, 0x014 },
    { 0x0d, 0x37, 0x0c5, 0x00, 0x054 },
    { 0xd3, 0x06, 0x040, 0x03, 0x014 },
    { 0x44, 0x01, 0x880, 0x22, 0x014 },
    { 0xd0, 0x04, 0x010, 0x0d, 0x010 },
    { 0xf2, 0x08, 0x094, 0x00, 0x055 },
    { 0x41, 0x0c, 0x014, 0x00, 0x054 },
    { 0x84, 0x06, 0x054, 0x02, 0x010 },
    { 0x85, 0x0f, 0x094, 0x00, 0x054 },
    { 0xc2, 0x09, 0x085, 0x00, 0x054 },
    { 0x0f, 0x09, 0x040, 0x00, 0x054 },
    { 0xdf, 0x01, 0x015, 0x6f, 0x81d },
    { 0x4a, 0x01, 0x010, 0x25, 0x010 },
    { 0xbe, 0x06, 0x0c1, 0x02, 0x011 },
    { 0x42, 0x01, 0x041, 0x21, 0x014 },
    { 0x5a, 0xf2, 0x851, 0x00, 0x054 },
    { 0xc6, 0x05, 0x804, 0x06, 0x014 },
    { 0xc1, 0x06, 0x080, 0x03, 0x014 },
    { 0x60, 0x05, 0x081, 0x03, 0x014 },
    { 0x03, 0x00, 0x855, 0x03, 0x85d },
    { 0x85, 0x07, 0x0d5, 0x01, 0x010 },
    { 0x8c, 0x0f, 0x094, 0x00, 0x054 },
};

const uint16_t g_cBs3CpuInstr2_shr_amd_TestDataU16 = 28;
const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_shr_amd_TestDataU16[28] =
{
    { 0x0000, 0x42, 0x054, 0x0000, 0x054 },
    { 0xffff, 0x0a, 0x015, 0x003f, 0x015 },
    { 0x0000, 0xc6, 0x085, 0x0000, 0x054 },
    { 0x0009, 0x05, 0x010, 0x0000, 0x054 },
    { 0x1b36, 0x18, 0x085, 0x0000, 0x054 },
    { 0xda49, 0x1b, 0x004, 0x0000, 0x054 },
    { 0x1c3a, 0x00, 0x894, 0x1c3a, 0x89c },
    { 0xb0fe, 0x09, 0x005, 0x0058, 0x010 },
    { 0xa4fc, 0x05, 0x894, 0x0527, 0x015 },
    { 0x003e, 0xf2, 0x055, 0x0000, 0x054 },
    { 0x1fa9, 0x01, 0x000, 0x0fd4, 0x015 },
    { 0xabb9, 0x07, 0x015, 0x0157, 0x010 },
    { 0x35b9, 0x0a, 0x010, 0x000d, 0x010 },
    { 0x897e, 0x0a, 0x0d1, 0x0022, 0x014 },
    { 0x7f8d, 0x0d, 0x0d0, 0x0003, 0x015 },
    { 0x0038, 0x10, 0x055, 0x0000, 0x054 },
    { 0x2162, 0x11, 0x000, 0x0000, 0x054 },
    { 0x2862, 0x11, 0x080, 0x0000, 0x054 },
    { 0x3ce1, 0x11, 0x0c4, 0x0000, 0x054 },
    { 0x6c1f, 0x11, 0x091, 0x0000, 0x054 },
    { 0xcf86, 0x11, 0x051, 0x0000, 0x054 },
    { 0x0223, 0x11, 0x015, 0x0000, 0x054 },
    { 0xab4a, 0x11, 0x0c4, 0x0000, 0x054 },
    { 0x7a0d, 0x11, 0x011, 0x0000, 0x054 },
    { 0x0074, 0x00, 0x881, 0x0074, 0x889 },
    { 0x0060, 0x11, 0x001, 0x0000, 0x054 },
    { 0xd6da, 0x11, 0x814, 0x0000, 0x054 },
    { 0x094d, 0x11, 0x880, 0x0000, 0x054 },
};

const uint16_t g_cBs3CpuInstr2_shr_amd_TestDataU32 = 32;
const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_shr_amd_TestDataU32[32] =
{
    { 0x00000000, 0x16, 0x014, 0x00000000, 0x054 },
    { 0xffffffff, 0x09, 0x0d0, 0x007fffff, 0x015 },
    { 0x00000000, 0x32, 0x095, 0x00000000, 0x054 },
    { 0x6da70247, 0x1f, 0x091, 0x00000000, 0x055 },
    { 0x4663e2e3, 0x1c, 0x0c0, 0x00000004, 0x010 },
    { 0x0096989c, 0x39, 0x0d4, 0x00000000, 0x054 },
    { 0x5f6b47d9, 0x0a, 0x0d1, 0x0017dad1, 0x015 },
    { 0xd8f2bb7f, 0x08, 0x0d5, 0x00d8f2bb, 0x014 },
    { 0xae889be6, 0x03, 0x0d4, 0x15d1137c, 0x011 },
    { 0x4723a408, 0x04, 0x090, 0x04723a40, 0x011 },
    { 0x7ffffc52, 0x1a, 0x085, 0x0000001f, 0x011 },
    { 0xd64ae28e, 0x09, 0x0d1, 0x006b2571, 0x014 },
    { 0xe955c618, 0x0f, 0x085, 0x0001d2ab, 0x011 },
    { 0xf6c9df26, 0x3f, 0x095, 0x00000001, 0x011 },
    { 0xc0cbca8a, 0x9a, 0x800, 0x00000030, 0x014 },
    { 0x00006277, 0x0c, 0x041, 0x00000006, 0x014 },
    { 0x6bdcaea2, 0x12, 0x005, 0x00001af7, 0x010 },
    { 0x6202de64, 0x00, 0x0d4, 0x6202de64, 0x0d4 },
    { 0xb91aaabb, 0x01, 0x004, 0x5c8d555d, 0x819 },
    { 0xdd87b57b, 0x20, 0x0c1, 0xdd87b57b, 0x0c1 },
    { 0x0279e831, 0x00, 0x095, 0x0279e831, 0x095 },
    { 0xab9e2e1b, 0x21, 0x011, 0x55cf170d, 0x819 },
    { 0x03660d95, 0x21, 0x095, 0x01b306ca, 0x015 },
    { 0x7a9ac009, 0x01, 0x050, 0x3d4d6004, 0x011 },
    { 0x32bba1b2, 0x21, 0x091, 0x195dd0d9, 0x010 },
    { 0x00005665, 0x21, 0x080, 0x00002b32, 0x011 },
    { 0x7a7856cc, 0x21, 0x045, 0x3d3c2b66, 0x014 },
    { 0xe17a03fd, 0x21, 0x894, 0x70bd01fe, 0x819 },
    { 0x17762b84, 0x21, 0x050, 0x0bbb15c2, 0x010 },
    { 0x5b89b12a, 0x21, 0x001, 0x2dc4d895, 0x014 },
    { 0x05f492c1, 0x21, 0x0d1, 0x02fa4960, 0x015 },
    { 0xa39bc0c4, 0x21, 0x055, 0x51cde062, 0x818 },
};

const uint16_t g_cBs3CpuInstr2_sar_amd_TestDataU8 = 28;
const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_sar_amd_TestDataU8[28] =
{
    { 0x00, 0x04, 0x085, 0x00, 0x054 },
    { 0xff, 0x0b, 0x0c1, 0xff, 0x095 },
    { 0x00, 0x04, 0x0c4, 0x00, 0x054 },
    { 0x5b, 0x07, 0x040, 0x00, 0x055 },
    { 0x66, 0x06, 0x004, 0x01, 0x011 },
    { 0x42, 0x01, 0x094, 0x21, 0x014 },
    { 0x50, 0x01, 0x094, 0x28, 0x014 },
    { 0x5a, 0x04, 0x045, 0x05, 0x015 },
    { 0xea, 0x01, 0x010, 0xf5, 0x094 },
    { 0x74, 0x07, 0x094, 0x00, 0x055 },
    { 0xbb, 0x02, 0x045, 0xee, 0x095 },
    { 0xee, 0x02, 0x0c4, 0xfb, 0x091 },
    { 0x97, 0x01, 0x0c0, 0xcb, 0x091 },
    { 0xf2, 0x4d, 0x084, 0xff, 0x095 },
    { 0xc1, 0x01, 0x040, 0xe0, 0x091 },
    { 0x78, 0x00, 0x011, 0x78, 0x011 },
    { 0xc0, 0x08, 0x005, 0xff, 0x095 },
    { 0x4a, 0x00, 0x884, 0x4a, 0x88c },
    { 0x4c, 0x02, 0x0d4, 0x13, 0x010 },
    { 0xfd, 0x05, 0x811, 0xff, 0x095 },
    { 0x70, 0x05, 0x004, 0x03, 0x015 },
    { 0x25, 0x0a, 0x051, 0x00, 0x054 },
    { 0xe6, 0x05, 0x091, 0xff, 0x094 },
    { 0xc1, 0x84, 0x0d1, 0xfc, 0x094 },
    { 0xb9, 0x01, 0x891, 0xdc, 0x091 },
    { 0x7f, 0x0c, 0x041, 0x00, 0x054 },
    { 0x0b, 0x01, 0x090, 0x05, 0x015 },
    { 0x9f, 0x05, 0x000, 0xfc, 0x095 },
};

const uint16_t g_cBs3CpuInstr2_sar_amd_TestDataU16 = 28;
const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_sar_amd_TestDataU16[28] =
{
    { 0x0000, 0x1b, 0x015, 0x0000, 0x054 },
    { 0xffff, 0x02, 0x815, 0xffff, 0x095 },
    { 0x0000, 0x00, 0x005, 0x0000, 0x005 },
    { 0x2bc5, 0x0a, 0x0d5, 0x000a, 0x015 },
    { 0x3a7d, 0x0c, 0x001, 0x0003, 0x015 },
    { 0xdf07, 0x0c, 0x044, 0xfffd, 0x091 },
    { 0x1fb9, 0x0a, 0x045, 0x0007, 0x011 },
    { 0x0f0d, 0x06, 0x0c1, 0x003c, 0x014 },
    { 0xeeb4, 0x09, 0x0c0, 0xfff7, 0x090 },
    { 0x024d, 0x06, 0x0c1, 0x0009, 0x014 },
    { 0xdbe9, 0x01, 0x095, 0xedf4, 0x091 },
    { 0x808f, 0x09, 0x0d0, 0xffc0, 0x094 },
    { 0x00ae, 0x15, 0x000, 0x0000, 0x054 },
    { 0x2f25, 0xe7, 0x011, 0x005e, 0x010 },
    { 0x88a6, 0x03, 0x054, 0xf114, 0x095 },
    { 0x003a, 0x10, 0x085, 0x0000, 0x054 },
    { 0xa89e, 0x11, 0x854, 0xffff, 0x095 },
    { 0x0065, 0x00, 0x854, 0x0065, 0x85c },
    { 0x02c7, 0x0f, 0x005, 0x0000, 0x054 },
    { 0xf01f, 0x05, 0x045, 0xff80, 0x091 },
    { 0x90bf, 0x05, 0x0d4, 0xfc85, 0x091 },
    { 0x0012, 0x0a, 0x011, 0x0000, 0x054 },
    { 0x536f, 0x09, 0x0c0, 0x0029, 0x011 },
    { 0xcb4f, 0x0e, 0x005, 0xffff, 0x094 },
    { 0x181c, 0x0a, 0x041, 0x0006, 0x014 },
    { 0x11da, 0x15, 0x850, 0x0000, 0x054 },
    { 0x05af, 0xfd, 0x014, 0x0000, 0x054 },
    { 0x0487, 0x01, 0x0c1, 0x0243, 0x011 },
};

const uint16_t g_cBs3CpuInstr2_sar_amd_TestDataU32 = 32;
const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_sar_amd_TestDataU32[32] =
{
    { 0x00000000, 0x0d, 0x044, 0x00000000, 0x054 },
    { 0xffffffff, 0xd1, 0x041, 0xffffffff, 0x095 },
    { 0x00000000, 0x07, 0x0d4, 0x00000000, 0x054 },
    { 0x13414b64, 0x37, 0x090, 0x00000026, 0x011 },
    { 0x19718c16, 0x0b, 0x091, 0x00032e31, 0x011 },
    { 0x00000099, 0x1e, 0x085, 0x00000000, 0x054 },
    { 0x636b4dde, 0x02, 0x054, 0x18dad377, 0x015 },
    { 0xc76db72d, 0x0c, 0x804, 0xfffc76db, 0x094 },
    { 0xa97a5c08, 0x10, 0x814, 0xffffa97a, 0x090 },
    { 0x183840bd, 0x15, 0x094, 0x000000c1, 0x011 },
    { 0x000066fa, 0x84, 0x080, 0x0000066f, 0x015 },
    { 0x29482914, 0x36, 0x095, 0x000000a5, 0x014 },
    { 0xd2fc08bd, 0x21, 0x005, 0xe97e045e, 0x091 },
    { 0x8b5dc996, 0x18, 0x040, 0xffffff8b, 0x094 },
    { 0x3b7a0e67, 0x0c, 0x0d4, 0x0003b7a0, 0x015 },
    { 0x000f586b, 0x0d, 0x041, 0x0000007a, 0x011 },
    { 0x308bf137, 0x02, 0x005, 0x0c22fc4d, 0x015 },
    { 0xb88ec035, 0x00, 0x0c0, 0xb88ec035, 0x0c0 },
    { 0x2c3411a2, 0x01, 0x0d4, 0x161a08d1, 0x014 },
    { 0x60b0e0fa, 0x20, 0x080, 0x60b0e0fa, 0x080 },
    { 0x00017fa0, 0x1e, 0x081, 0x00000000, 0x054 },
    { 0x60f5703d, 0x00, 0x845, 0x60f5703d, 0x84d },
    { 0x294081ac, 0x1b, 0x011, 0x00000005, 0x014 },
    { 0xc571ba90, 0x19, 0x040, 0xffffffe2, 0x095 },
    { 0x798a9271, 0x12, 0x890, 0x00001e62, 0x011 },
    { 0x0000193d, 0x0c, 0x044, 0x00000001, 0x011 },
    { 0x79136779, 0x20, 0x0d1, 0x79136779, 0x0d1 },
    { 0xea400bb9, 0x15, 0x084, 0xffffff52, 0x090 },
    { 0x531f684e, 0x8f, 0x010, 0x0000a63e, 0x011 },
    { 0x16b6807f, 0x03, 0x014, 0x02d6d00f, 0x015 },
    { 0x000004f8, 0x1a, 0x045, 0x00000000, 0x054 },
    { 0x0da19b96, 0x08, 0x0c4, 0x000da19b, 0x011 },
};

const uint16_t g_cBs3CpuInstr2_rol_amd_TestDataU8 = 28;
const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_rol_amd_TestDataU8[28] =
{
    { 0x00, 0x03, 0x011, 0x00, 0x010 },
    { 0xff, 0x04, 0x805, 0xff, 0x005 },
    { 0x00, 0x03, 0x015, 0x00, 0x014 },
    { 0x2c, 0x00, 0x891, 0x2c, 0x899 },
    { 0xc7, 0x01, 0x041, 0x8f, 0x041 },
    { 0x1c, 0x03, 0x085, 0xe0, 0x88c },
    { 0xae, 0x06, 0x0d5, 0xab, 0x0d5 },
    { 0x50, 0x16, 0x091, 0x14, 0x090 },
    { 0x4c, 0x08, 0x000, 0x4c, 0x000 },
    { 0xf1, 0x05, 0x084, 0x3e, 0x084 },
    { 0xfe, 0x03, 0x090, 0xf7, 0x091 },
    { 0xc6, 0x05, 0x894, 0xd8, 0x89c },
    { 0xbf, 0x03, 0x015, 0xfd, 0x015 },
    { 0x48, 0x03, 0x894, 0x42, 0x094 },
    { 0xed, 0x05, 0x090, 0xbd, 0x091 },
    { 0xba, 0x09, 0x084, 0x75, 0x88d },
    { 0x61, 0x00, 0x045, 0x61, 0x045 },
    { 0x18, 0x09, 0x080, 0x30, 0x080 },
    { 0xdb, 0x09, 0x055, 0xb7, 0x055 },
    { 0xca, 0x09, 0x044, 0x95, 0x045 },
    { 0x97, 0x09, 0x004, 0x2f, 0x80d },
    { 0x66, 0x09, 0x0c1, 0xcc, 0x8c8 },
    { 0x7f, 0x09, 0x040, 0xfe, 0x848 },
    { 0xa8, 0x09, 0x055, 0x51, 0x85d },
    { 0xbe, 0x09, 0x095, 0x7d, 0x89d },
    { 0xc2, 0x09, 0x015, 0x85, 0x015 },
    { 0xdb, 0x01, 0x041, 0xb7, 0x041 },
    { 0x38, 0x08, 0x045, 0x38, 0x044 },
};

const uint16_t g_cBs3CpuInstr2_rol_amd_TestDataU16 = 28;
const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_rol_amd_TestDataU16[28] =
{
    { 0x0000, 0x0e, 0x015, 0x0000, 0x014 },
    { 0xffff, 0xd1, 0x084, 0xffff, 0x085 },
    { 0x0000, 0x0f, 0x084, 0x0000, 0x084 },
    { 0x0003, 0x03, 0x095, 0x0018, 0x094 },
    { 0xbc65, 0x09, 0x0d4, 0xcb78, 0x8dc },
    { 0xa5ea, 0x19, 0x8d1, 0xd54b, 0x0d1 },
    { 0x00a3, 0x0e, 0x045, 0xc028, 0x84c },
    { 0xd46b, 0x09, 0x895, 0xd7a8, 0x89c },
    { 0x0628, 0x0c, 0x000, 0x8062, 0x808 },
    { 0x0069, 0x05, 0x000, 0x0d20, 0x000 },
    { 0x9305, 0x00, 0x051, 0x9305, 0x051 },
    { 0xca4e, 0x1b, 0x8d5, 0x7652, 0x0d4 },
    { 0x06da, 0x0a, 0x054, 0x681b, 0x85d },
    { 0xae4d, 0x05, 0x0c5, 0xc9b5, 0x0c5 },
    { 0x2f55, 0x04, 0x011, 0xf552, 0x818 },
    { 0x0b52, 0x01, 0x004, 0x16a4, 0x004 },
    { 0x02f1, 0x10, 0x055, 0x02f1, 0x85d },
    { 0xc1c5, 0x11, 0x0c4, 0x838b, 0x0c5 },
    { 0x32fe, 0x11, 0x0c4, 0x65fc, 0x0c4 },
    { 0x589b, 0x11, 0x0d5, 0xb136, 0x8dc },
    { 0x90c8, 0x11, 0x014, 0x2191, 0x81d },
    { 0x00f6, 0x11, 0x004, 0x01ec, 0x004 },
    { 0x085d, 0x11, 0x010, 0x10ba, 0x010 },
    { 0x65af, 0x11, 0x000, 0xcb5e, 0x808 },
    { 0x0441, 0x11, 0x015, 0x0882, 0x014 },
    { 0xfed1, 0x11, 0x041, 0xfda3, 0x041 },
    { 0x632b, 0x01, 0x0c1, 0xc656, 0x8c8 },
    { 0x0003, 0x11, 0x854, 0x0006, 0x054 },
};

const uint16_t g_cBs3CpuInstr2_rol_amd_TestDataU32 = 32;
const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_rol_amd_TestDataU32[32] =
{
    { 0x00000000, 0x1a, 0x084, 0x00000000, 0x084 },
    { 0xffffffff, 0x11, 0x051, 0xffffffff, 0x051 },
    { 0x00000000, 0x24, 0x0d4, 0x00000000, 0x0d4 },
    { 0xe7b0a77b, 0x09, 0x094, 0x614ef7cf, 0x89d },
    { 0x94c00665, 0x12, 0x055, 0x19965300, 0x054 },
    { 0x169ca9fd, 0x1f, 0x054, 0x8b4e54fe, 0x85c },
    { 0x1d97f73d, 0x1a, 0x010, 0xf4765fdc, 0x818 },
    { 0xf22bf929, 0x0e, 0x051, 0xfe4a7c8a, 0x858 },
    { 0x082ec0c0, 0x1b, 0x095, 0x00417606, 0x094 },
    { 0x3f6da6b4, 0x0a, 0x005, 0xb69ad0fd, 0x005 },
    { 0x000304cd, 0x09, 0x055, 0x06099a00, 0x054 },
    { 0x0b0d2604, 0x17, 0x001, 0x02058693, 0x809 },
    { 0x51959f0e, 0x04, 0x001, 0x1959f0e5, 0x809 },
    { 0x47ec7558, 0x0d, 0x041, 0x8eab08fd, 0x041 },
    { 0x875c8d88, 0x10, 0x044, 0x8d88875c, 0x84c },
    { 0x02c9af3d, 0x2e, 0x094, 0x6bcf40b2, 0x094 },
    { 0x24267800, 0x05, 0x010, 0x84cf0004, 0x818 },
    { 0xde69073e, 0x00, 0x051, 0xde69073e, 0x051 },
    { 0xd989dd88, 0x01, 0x010, 0xb313bb11, 0x011 },
    { 0x2a77200b, 0x20, 0x005, 0x2a77200b, 0x005 },
    { 0x00000828, 0x21, 0x004, 0x00001050, 0x004 },
    { 0xf2123f6c, 0x21, 0x0d1, 0xe4247ed9, 0x0d1 },
    { 0xbeee6088, 0x21, 0x015, 0x7ddcc111, 0x81d },
    { 0x79e47777, 0x21, 0x015, 0xf3c8eeee, 0x81c },
    { 0xac56d286, 0x21, 0x0d4, 0x58ada50d, 0x8dd },
    { 0x0025ae38, 0x21, 0x015, 0x004b5c70, 0x014 },
    { 0x89664d5e, 0x21, 0x085, 0x12cc9abd, 0x88d },
    { 0x3de60ec9, 0x21, 0x0c0, 0x7bcc1d92, 0x0c0 },
    { 0x43fd768e, 0x21, 0x014, 0x87faed1c, 0x81c },
    { 0x7d530623, 0x21, 0x040, 0xfaa60c46, 0x848 },
    { 0x00894d74, 0x21, 0x0c5, 0x01129ae8, 0x0c4 },
    { 0xb5766753, 0x21, 0x054, 0x6aeccea7, 0x85d },
};

const uint16_t g_cBs3CpuInstr2_ror_amd_TestDataU8 = 28;
const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_ror_amd_TestDataU8[28] =
{
    { 0x00, 0x07, 0x080, 0x00, 0x080 },
    { 0xff, 0x09, 0x095, 0xff, 0x095 },
    { 0x00, 0x01, 0x0c5, 0x00, 0x0c4 },
    { 0x89, 0x06, 0x885, 0x26, 0x084 },
    { 0xbc, 0x0c, 0x001, 0xcb, 0x001 },
    { 0x49, 0x01, 0x085, 0xa4, 0x88d },
    { 0x32, 0x07, 0x050, 0x64, 0x858 },
    { 0xe3, 0x01, 0x051, 0xf1, 0x051 },
    { 0xf6, 0x02, 0x015, 0xbd, 0x81d },
    { 0xca, 0x02, 0x010, 0xb2, 0x819 },
    { 0x6e, 0x0d, 0x090, 0x73, 0x898 },
    { 0xfd, 0x04, 0x004, 0xdf, 0x005 },
    { 0xe8, 0x04, 0x040, 0x8e, 0x849 },
    { 0x3c, 0x04, 0x095, 0xc3, 0x095 },
    { 0x5d, 0x0b, 0x095, 0xab, 0x89d },
    { 0xa6, 0x00, 0x0c0, 0xa6, 0x0c0 },
    { 0xf5, 0x08, 0x041, 0xf5, 0x041 },
    { 0x48, 0x05, 0x051, 0x42, 0x858 },
    { 0x2f, 0x04, 0x055, 0xf2, 0x055 },
    { 0x48, 0xfd, 0x080, 0x42, 0x888 },
    { 0x1a, 0x01, 0x081, 0x0d, 0x080 },
    { 0x21, 0x00, 0x841, 0x21, 0x849 },
    { 0x1f, 0x05, 0x015, 0xf8, 0x015 },
    { 0xc3, 0x8f, 0x015, 0x87, 0x81d },
    { 0x03, 0x05, 0x045, 0x18, 0x044 },
    { 0xda, 0x07, 0x084, 0xb5, 0x88d },
    { 0x2f, 0x00, 0x015, 0x2f, 0x015 },
    { 0x0f, 0x0b, 0x0d5, 0xe1, 0x0d5 },
};

const uint16_t g_cBs3CpuInstr2_ror_amd_TestDataU16 = 28;
const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_ror_amd_TestDataU16[28] =
{
    { 0x0000, 0x17, 0x045, 0x0000, 0x044 },
    { 0xffff, 0x0a, 0x0d1, 0xffff, 0x0d1 },
    { 0x0000, 0x03, 0x045, 0x0000, 0x044 },
    { 0x002c, 0xb0, 0x010, 0x002c, 0x010 },
    { 0x7ceb, 0x01, 0x094, 0xbe75, 0x89d },
    { 0x14de, 0x84, 0x095, 0xe14d, 0x095 },
    { 0x076c, 0xd1, 0x001, 0x03b6, 0x000 },
    { 0x1ec9, 0x0e, 0x000, 0x7b24, 0x808 },
    { 0x4279, 0xe7, 0x011, 0xf284, 0x011 },
    { 0x04c6, 0x14, 0x0c5, 0x604c, 0x8cc },
    { 0x502c, 0x15, 0x051, 0x6281, 0x858 },
    { 0x1f92, 0x13, 0x051, 0x43f2, 0x858 },
    { 0x105b, 0x00, 0x0c5, 0x105b, 0x0c5 },
    { 0x7db1, 0x84, 0x095, 0x17db, 0x094 },
    { 0x6ee5, 0x1a, 0x044, 0xb95b, 0x84d },
    { 0x0244, 0x00, 0x841, 0x0244, 0x849 },
    { 0xf88a, 0x10, 0x084, 0xf88a, 0x085 },
    { 0xf21b, 0x11, 0x0d4, 0xf90d, 0x0d5 },
    { 0x0044, 0x11, 0x014, 0x0022, 0x014 },
    { 0x6a5e, 0x11, 0x811, 0x352f, 0x010 },
    { 0xedc9, 0x11, 0x0d5, 0xf6e4, 0x0d5 },
    { 0x0049, 0x11, 0x045, 0x8024, 0x84d },
    { 0x5cbc, 0x11, 0x090, 0x2e5e, 0x090 },
    { 0x5e66, 0x11, 0x000, 0x2f33, 0x000 },
    { 0x0071, 0x11, 0x041, 0x8038, 0x849 },
    { 0xe91e, 0x11, 0x815, 0x748f, 0x81c },
    { 0xbd66, 0x11, 0x041, 0x5eb3, 0x848 },
    { 0x01e8, 0x11, 0x0d1, 0x00f4, 0x0d0 },
};

const uint16_t g_cBs3CpuInstr2_ror_amd_TestDataU32 = 32;
const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_ror_amd_TestDataU32[32] =
{
    { 0x00000000, 0x1f, 0x095, 0x00000000, 0x094 },
    { 0xffffffff, 0x17, 0x014, 0xffffffff, 0x015 },
    { 0x00000000, 0x1b, 0x014, 0x00000000, 0x014 },
    { 0xb6eacec3, 0x03, 0x011, 0x76dd59d8, 0x818 },
    { 0xe84bc0b3, 0x1e, 0x051, 0xa12f02cf, 0x859 },
    { 0x0000972c, 0x39, 0x041, 0x004b9600, 0x040 },
    { 0xdddadf0e, 0x07, 0x054, 0x1dbbb5be, 0x054 },
    { 0xa12e8ba2, 0x11, 0x000, 0x45d15097, 0x808 },
    { 0x368f5a93, 0x1a, 0x044, 0xa3d6a4cd, 0x84d },
    { 0x126a6ba8, 0x20, 0x0d1, 0x126a6ba8, 0x0d1 },
    { 0x0000341c, 0x32, 0x005, 0x0d070000, 0x004 },
    { 0x1dac8fbd, 0x11, 0x015, 0x47de8ed6, 0x81c },
    { 0x6e54b64c, 0xfd, 0x081, 0x72a5b263, 0x888 },
    { 0xeeaed664, 0x16, 0x044, 0xbb5993ba, 0x84d },
    { 0xfe209858, 0x06, 0x0d0, 0x63f88261, 0x8d8 },
    { 0x20355f08, 0x0b, 0x081, 0xe10406ab, 0x081 },
    { 0xd9deb810, 0x2a, 0x001, 0x043677ae, 0x000 },
    { 0x849eb483, 0x00, 0x045, 0x849eb483, 0x045 },
    { 0x533947ab, 0x01, 0x0c0, 0xa99ca3d5, 0x8c9 },
    { 0x3a46f9b4, 0x21, 0x054, 0x1d237cda, 0x054 },
    { 0x033c6ba2, 0x21, 0x0d5, 0x019e35d1, 0x0d4 },
    { 0x54904547, 0x21, 0x081, 0xaa4822a3, 0x889 },
    { 0x0930026c, 0x21, 0x804, 0x04980136, 0x004 },
    { 0xe095d7d6, 0x21, 0x014, 0x704aebeb, 0x81c },
    { 0xf43be565, 0x21, 0x054, 0xfa1df2b2, 0x055 },
    { 0x18c6635a, 0x21, 0x0d5, 0x0c6331ad, 0x0d4 },
    { 0xe3fc902a, 0x21, 0x0d5, 0x71fe4815, 0x8dc },
    { 0xa769616d, 0x21, 0x051, 0xd3b4b0b6, 0x051 },
    { 0x071d255c, 0x21, 0x801, 0x038e92ae, 0x000 },
    { 0x5642d658, 0x21, 0x081, 0x2b216b2c, 0x080 },
    { 0x058526fe, 0x21, 0x000, 0x02c2937f, 0x000 },
    { 0x4997725c, 0x21, 0x004, 0x24cbb92e, 0x004 },
};

const uint16_t g_cBs3CpuInstr2_rcl_amd_TestDataU8 = 56;
const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_rcl_amd_TestDataU8[56] =
{
    { 0x00, 0x04, 0x050, 0x00, 0x050 },
    { 0x00, 0x04, 0x051, 0x08, 0x050 },
    { 0xff, 0x05, 0x000, 0xef, 0x001 },
    { 0xff, 0x05, 0x001, 0xff, 0x001 },
    { 0x00, 0x0a, 0x894, 0x00, 0x094 },
    { 0x00, 0x0a, 0x895, 0x01, 0x094 },
    { 0x75, 0x0e, 0x044, 0xa7, 0x84c },
    { 0x75, 0x0e, 0x045, 0xb7, 0x84c },
    { 0x0f, 0x06, 0x040, 0xc1, 0x041 },
    { 0x0f, 0x06, 0x041, 0xe1, 0x041 },
    { 0x7c, 0x01, 0x094, 0xf8, 0x89c },
    { 0x7c, 0x01, 0x095, 0xf9, 0x89c },
    { 0x04, 0x06, 0x0d0, 0x00, 0x8d9 },
    { 0x04, 0x06, 0x0d1, 0x20, 0x8d9 },
    { 0xa8, 0x06, 0x080, 0x15, 0x080 },
    { 0xa8, 0x06, 0x081, 0x35, 0x080 },
    { 0xfa, 0x02, 0x0d4, 0xe9, 0x0d5 },
    { 0xfa, 0x02, 0x0d5, 0xeb, 0x0d5 },
    { 0x84, 0x0f, 0x090, 0x10, 0x899 },
    { 0x84, 0x0f, 0x091, 0x30, 0x899 },
    { 0x01, 0x05, 0x010, 0x20, 0x010 },
    { 0x01, 0x05, 0x011, 0x30, 0x010 },
    { 0x7b, 0xb0, 0x094, 0x9e, 0x095 },
    { 0x7b, 0xb0, 0x095, 0xde, 0x095 },
    { 0xdc, 0x02, 0x044, 0x71, 0x84d },
    { 0xdc, 0x02, 0x045, 0x73, 0x84d },
    { 0x42, 0x02, 0x004, 0x08, 0x80d },
    { 0x42, 0x02, 0x005, 0x0a, 0x80d },
    { 0x1d, 0x06, 0x054, 0x43, 0x85d },
    { 0x1d, 0x06, 0x055, 0x63, 0x85d },
    { 0xc9, 0x00, 0x000, 0xc9, 0x000 },
    { 0xc9, 0x00, 0x001, 0xc9, 0x001 },
    { 0x0e, 0x08, 0x044, 0x07, 0x044 },
    { 0x0e, 0x08, 0x045, 0x87, 0x84c },
    { 0x87, 0x09, 0x090, 0x87, 0x898 },
    { 0x87, 0x09, 0x091, 0x87, 0x091 },
    { 0x00, 0x09, 0x054, 0x00, 0x054 },
    { 0x00, 0x09, 0x055, 0x00, 0x85d },
    { 0x27, 0x09, 0x014, 0x27, 0x014 },
    { 0x27, 0x09, 0x015, 0x27, 0x81d },
    { 0x2e, 0x09, 0x054, 0x2e, 0x054 },
    { 0x2e, 0x09, 0x055, 0x2e, 0x85d },
    { 0x1c, 0x09, 0x000, 0x1c, 0x000 },
    { 0x1c, 0x09, 0x001, 0x1c, 0x809 },
    { 0xb2, 0x09, 0x084, 0xb2, 0x88c },
    { 0xb2, 0x09, 0x085, 0xb2, 0x085 },
    { 0x9c, 0x09, 0x044, 0x9c, 0x84c },
    { 0x9c, 0x09, 0x045, 0x9c, 0x045 },
    { 0xea, 0x09, 0x040, 0xea, 0x848 },
    { 0xea, 0x09, 0x041, 0xea, 0x041 },
    { 0xae, 0x01, 0x050, 0x5c, 0x859 },
    { 0xae, 0x01, 0x051, 0x5d, 0x859 },
    { 0x3e, 0x01, 0x080, 0x7c, 0x080 },
    { 0x3e, 0x01, 0x081, 0x7d, 0x080 },
    { 0xc3, 0x00, 0x010, 0xc3, 0x010 },
    { 0xc3, 0x00, 0x011, 0xc3, 0x011 },
};

const uint16_t g_cBs3CpuInstr2_rcl_amd_TestDataU16 = 56;
const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_rcl_amd_TestDataU16[56] =
{
    { 0x0000, 0x06, 0x840, 0x0000, 0x040 },
    { 0x0000, 0x06, 0x841, 0x0020, 0x040 },
    { 0xffff, 0x0b, 0x0d4, 0xfbff, 0x0d5 },
    { 0xffff, 0x0b, 0x0d5, 0xffff, 0x0d5 },
    { 0x0000, 0x0b, 0x090, 0x0000, 0x090 },
    { 0x0000, 0x0b, 0x091, 0x0400, 0x090 },
    { 0x00ea, 0x07, 0x014, 0x7500, 0x014 },
    { 0x00ea, 0x07, 0x015, 0x7540, 0x014 },
    { 0xb7d5, 0x00, 0x080, 0xb7d5, 0x080 },
    { 0xb7d5, 0x00, 0x081, 0xb7d5, 0x081 },
    { 0x3b72, 0x18, 0x004, 0xb90e, 0x005 },
    { 0x3b72, 0x18, 0x005, 0xb94e, 0x005 },
    { 0x0ded, 0x02, 0x084, 0x37b4, 0x084 },
    { 0x0ded, 0x02, 0x085, 0x37b6, 0x084 },
    { 0x15fe, 0x0f, 0x814, 0x057f, 0x81d },
    { 0x15fe, 0x0f, 0x815, 0x457f, 0x81d },
    { 0xe681, 0xb0, 0x040, 0x7340, 0x849 },
    { 0xe681, 0xb0, 0x041, 0xf340, 0x041 },
    { 0x543d, 0x02, 0x054, 0x50f4, 0x85d },
    { 0x543d, 0x02, 0x055, 0x50f6, 0x85d },
    { 0xfe5d, 0xe7, 0x0c0, 0x2ebf, 0x8c9 },
    { 0xfe5d, 0xe7, 0x0c1, 0x2eff, 0x8c9 },
    { 0x14d7, 0x01, 0x0d0, 0x29ae, 0x0d0 },
    { 0x14d7, 0x01, 0x0d1, 0x29af, 0x0d0 },
    { 0x044e, 0xf2, 0x040, 0x089c, 0x040 },
    { 0x044e, 0xf2, 0x041, 0x089d, 0x040 },
    { 0x9c3e, 0x0f, 0x000, 0x270f, 0x809 },
    { 0x9c3e, 0x0f, 0x001, 0x670f, 0x809 },
    { 0xb604, 0x01, 0x010, 0x6c08, 0x819 },
    { 0xb604, 0x01, 0x011, 0x6c09, 0x819 },
    { 0x0e51, 0x10, 0x0d0, 0x0728, 0x8d9 },
    { 0x0e51, 0x10, 0x0d1, 0x8728, 0x0d1 },
    { 0x376d, 0x01, 0x040, 0x6eda, 0x040 },
    { 0x376d, 0x01, 0x041, 0x6edb, 0x040 },
    { 0x9904, 0x11, 0x040, 0x9904, 0x848 },
    { 0x9904, 0x11, 0x041, 0x9904, 0x041 },
    { 0x068d, 0x11, 0x000, 0x068d, 0x000 },
    { 0x068d, 0x11, 0x001, 0x068d, 0x809 },
    { 0xb6c3, 0x11, 0x050, 0xb6c3, 0x858 },
    { 0xb6c3, 0x11, 0x051, 0xb6c3, 0x051 },
    { 0xd637, 0x11, 0x014, 0xd637, 0x81c },
    { 0xd637, 0x11, 0x015, 0xd637, 0x015 },
    { 0x0013, 0x11, 0x844, 0x0013, 0x044 },
    { 0x0013, 0x11, 0x845, 0x0013, 0x84d },
    { 0xb5fc, 0x11, 0x884, 0xb5fc, 0x88c },
    { 0xb5fc, 0x11, 0x885, 0xb5fc, 0x085 },
    { 0xbfd8, 0x11, 0x014, 0xbfd8, 0x81c },
    { 0xbfd8, 0x11, 0x015, 0xbfd8, 0x015 },
    { 0x023a, 0x11, 0x090, 0x023a, 0x090 },
    { 0x023a, 0x11, 0x091, 0x023a, 0x899 },
    { 0x4a65, 0x11, 0x804, 0x4a65, 0x004 },
    { 0x4a65, 0x11, 0x805, 0x4a65, 0x80d },
    { 0x7b69, 0x11, 0x0c4, 0x7b69, 0x0c4 },
    { 0x7b69, 0x11, 0x0c5, 0x7b69, 0x8cd },
    { 0x0010, 0x11, 0x010, 0x0010, 0x010 },
    { 0x0010, 0x11, 0x011, 0x0010, 0x819 },
};

const uint16_t g_cBs3CpuInstr2_rcl_amd_TestDataU32 = 64;
const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_rcl_amd_TestDataU32[64] =
{
    { 0x00000000, 0x10, 0x840, 0x00000000, 0x040 },
    { 0x00000000, 0x10, 0x841, 0x00008000, 0x040 },
    { 0xffffffff, 0x04, 0x850, 0xfffffff7, 0x051 },
    { 0xffffffff, 0x04, 0x851, 0xffffffff, 0x051 },
    { 0x00000000, 0x10, 0x844, 0x00000000, 0x044 },
    { 0x00000000, 0x10, 0x845, 0x00008000, 0x044 },
    { 0x0df16aa9, 0x37, 0x004, 0x54837c5a, 0x80d },
    { 0x0df16aa9, 0x37, 0x005, 0x54c37c5a, 0x80d },
    { 0x59c43ef9, 0x05, 0x044, 0x3887df25, 0x84d },
    { 0x59c43ef9, 0x05, 0x045, 0x3887df35, 0x84d },
    { 0x00000352, 0x1e, 0x0d0, 0x8000006a, 0x8d8 },
    { 0x00000352, 0x1e, 0x0d1, 0xa000006a, 0x8d8 },
    { 0xaae7ce38, 0x0b, 0x090, 0x3e71c2ab, 0x899 },
    { 0xaae7ce38, 0x0b, 0x091, 0x3e71c6ab, 0x899 },
    { 0x44066b48, 0x16, 0x890, 0xd20880cd, 0x898 },
    { 0x44066b48, 0x16, 0x891, 0xd22880cd, 0x898 },
    { 0xbcae822c, 0x1d, 0x010, 0x8bcae822, 0x011 },
    { 0xbcae822c, 0x1d, 0x011, 0x9bcae822, 0x011 },
    { 0x7bc0de3e, 0x33, 0x044, 0xf1f1ef03, 0x84c },
    { 0x7bc0de3e, 0x33, 0x045, 0xf1f5ef03, 0x84c },
    { 0x000001cb, 0x3c, 0x8c4, 0xb000000e, 0x8cc },
    { 0x000001cb, 0x3c, 0x8c5, 0xb800000e, 0x8cc },
    { 0xfabaea5d, 0x1f, 0x044, 0xbeaeba97, 0x84c },
    { 0xfabaea5d, 0x1f, 0x045, 0xfeaeba97, 0x84c },
    { 0xd9add652, 0x10, 0x054, 0xd6526cd6, 0x055 },
    { 0xd9add652, 0x10, 0x055, 0xd652ecd6, 0x055 },
    { 0xaecc4bae, 0x0d, 0x0d4, 0x8975caec, 0x0d5 },
    { 0xaecc4bae, 0x0d, 0x0d5, 0x8975daec, 0x0d5 },
    { 0x4ef76abc, 0x14, 0x000, 0xabc277bb, 0x808 },
    { 0x4ef76abc, 0x14, 0x001, 0xabca77bb, 0x808 },
    { 0x056f0ce3, 0x0e, 0x090, 0xc338c0ad, 0x091 },
    { 0x056f0ce3, 0x0e, 0x091, 0xc338e0ad, 0x091 },
    { 0xe3cb3741, 0x0f, 0x054, 0x9ba0b8f2, 0x055 },
    { 0xe3cb3741, 0x0f, 0x055, 0x9ba0f8f2, 0x055 },
    { 0xb8358bbe, 0x00, 0x054, 0xb8358bbe, 0x054 },
    { 0xb8358bbe, 0x00, 0x055, 0xb8358bbe, 0x055 },
    { 0xe880efd1, 0x01, 0x080, 0xd101dfa2, 0x081 },
    { 0xe880efd1, 0x01, 0x081, 0xd101dfa3, 0x081 },
    { 0xef121c9e, 0x20, 0x044, 0xef121c9e, 0x044 },
    { 0xef121c9e, 0x20, 0x045, 0xef121c9e, 0x045 },
    { 0x000b5c3a, 0x21, 0x040, 0x0016b874, 0x040 },
    { 0x000b5c3a, 0x21, 0x041, 0x0016b875, 0x040 },
    { 0xa9cc7bfd, 0x21, 0x0c0, 0x5398f7fa, 0x8c9 },
    { 0xa9cc7bfd, 0x21, 0x0c1, 0x5398f7fb, 0x8c9 },
    { 0xb01e6d49, 0x21, 0x050, 0x603cda92, 0x859 },
    { 0xb01e6d49, 0x21, 0x051, 0x603cda93, 0x859 },
    { 0x37331e6a, 0x21, 0x050, 0x6e663cd4, 0x050 },
    { 0x37331e6a, 0x21, 0x051, 0x6e663cd5, 0x050 },
    { 0x3ac64553, 0x01, 0x050, 0x758c8aa6, 0x050 },
    { 0x3ac64553, 0x01, 0x051, 0x758c8aa7, 0x050 },
    { 0x03af72f6, 0x21, 0x890, 0x075ee5ec, 0x090 },
    { 0x03af72f6, 0x21, 0x891, 0x075ee5ed, 0x090 },
    { 0x448551f6, 0x21, 0x004, 0x890aa3ec, 0x80c },
    { 0x448551f6, 0x21, 0x005, 0x890aa3ed, 0x80c },
    { 0xdb5e2e8a, 0x21, 0x000, 0xb6bc5d14, 0x001 },
    { 0xdb5e2e8a, 0x21, 0x001, 0xb6bc5d15, 0x001 },
    { 0x6795540c, 0x21, 0x040, 0xcf2aa818, 0x848 },
    { 0x6795540c, 0x21, 0x041, 0xcf2aa819, 0x848 },
    { 0x0c8c3cdf, 0x21, 0x094, 0x191879be, 0x094 },
    { 0x0c8c3cdf, 0x21, 0x095, 0x191879bf, 0x094 },
    { 0x003cd8fd, 0x21, 0x044, 0x0079b1fa, 0x044 },
    { 0x003cd8fd, 0x21, 0x045, 0x0079b1fb, 0x044 },
    { 0xca92a283, 0x21, 0x010, 0x95254506, 0x011 },
    { 0xca92a283, 0x21, 0x011, 0x95254507, 0x011 },
};

const uint16_t g_cBs3CpuInstr2_rcr_amd_TestDataU8 = 56;
const BS3CPUINSTR2SHIFT8 g_aBs3CpuInstr2_rcr_amd_TestDataU8[56] =
{
    { 0x00, 0x00, 0x890, 0x00, 0x898 },
    { 0x00, 0x00, 0x891, 0x00, 0x899 },
    { 0xff, 0xbb, 0x010, 0xff, 0x010 },
    { 0xff, 0xbb, 0x011, 0xff, 0x011 },
    { 0x00, 0x0a, 0x040, 0x00, 0x040 },
    { 0x00, 0x0a, 0x041, 0x80, 0x848 },
    { 0x91, 0x0c, 0x084, 0x52, 0x88c },
    { 0x91, 0x0c, 0x085, 0x72, 0x88c },
    { 0xa8, 0x03, 0x0d4, 0x15, 0x0d4 },
    { 0xa8, 0x03, 0x0d5, 0x35, 0x0d4 },
    { 0x1d, 0x04, 0x080, 0xa1, 0x889 },
    { 0x1d, 0x04, 0x081, 0xb1, 0x889 },
    { 0xe2, 0x0d, 0x080, 0x4e, 0x888 },
    { 0xe2, 0x0d, 0x081, 0x5e, 0x888 },
    { 0x45, 0x01, 0x014, 0x22, 0x015 },
    { 0x45, 0x01, 0x015, 0xa2, 0x81d },
    { 0xe9, 0x06, 0x080, 0x4b, 0x889 },
    { 0xe9, 0x06, 0x081, 0x4f, 0x889 },
    { 0xaa, 0x02, 0x0d4, 0x2a, 0x0d5 },
    { 0xaa, 0x02, 0x0d5, 0x6a, 0x8dd },
    { 0x90, 0x01, 0x0c4, 0x48, 0x8cc },
    { 0x90, 0x01, 0x0c5, 0xc8, 0x0c4 },
    { 0x63, 0x07, 0x040, 0x8c, 0x849 },
    { 0x63, 0x07, 0x041, 0x8e, 0x849 },
    { 0x83, 0x58, 0x080, 0x1a, 0x080 },
    { 0x83, 0x58, 0x081, 0x1e, 0x080 },
    { 0x70, 0x58, 0x010, 0x81, 0x819 },
    { 0x70, 0x58, 0x011, 0x85, 0x819 },
    { 0xaa, 0x08, 0x090, 0x54, 0x899 },
    { 0xaa, 0x08, 0x091, 0x55, 0x899 },
    { 0xb2, 0x09, 0x0c4, 0xb2, 0x8cc },
    { 0xb2, 0x09, 0x0c5, 0xb2, 0x8cd },
    { 0x98, 0x01, 0x800, 0x4c, 0x808 },
    { 0x98, 0x01, 0x801, 0xcc, 0x000 },
    { 0xff, 0x01, 0x040, 0x7f, 0x849 },
    { 0xff, 0x01, 0x041, 0xff, 0x041 },
    { 0x90, 0x09, 0x0c0, 0x90, 0x8c8 },
    { 0x90, 0x09, 0x0c1, 0x90, 0x8c9 },
    { 0x53, 0x09, 0x0d0, 0x53, 0x8d8 },
    { 0x53, 0x09, 0x0d1, 0x53, 0x8d9 },
    { 0xfc, 0x08, 0x084, 0xf8, 0x085 },
    { 0xfc, 0x08, 0x085, 0xf9, 0x085 },
    { 0x41, 0x00, 0x010, 0x41, 0x010 },
    { 0x41, 0x00, 0x011, 0x41, 0x011 },
    { 0x5a, 0x01, 0x0d4, 0x2d, 0x0d4 },
    { 0x5a, 0x01, 0x0d5, 0xad, 0x8dc },
    { 0xfc, 0x09, 0x080, 0xfc, 0x080 },
    { 0xfc, 0x09, 0x081, 0xfc, 0x081 },
    { 0x57, 0x00, 0x800, 0x57, 0x808 },
    { 0x57, 0x00, 0x801, 0x57, 0x809 },
    { 0xa2, 0x09, 0x0c4, 0xa2, 0x8cc },
    { 0xa2, 0x09, 0x0c5, 0xa2, 0x8cd },
    { 0xde, 0x09, 0x090, 0xde, 0x090 },
    { 0xde, 0x09, 0x091, 0xde, 0x091 },
    { 0x2e, 0x09, 0x0d0, 0x2e, 0x0d0 },
    { 0x2e, 0x09, 0x0d1, 0x2e, 0x0d1 },
};

const uint16_t g_cBs3CpuInstr2_rcr_amd_TestDataU16 = 56;
const BS3CPUINSTR2SHIFT16 g_aBs3CpuInstr2_rcr_amd_TestDataU16[56] =
{
    { 0x0000, 0x0a, 0x084, 0x0000, 0x084 },
    { 0x0000, 0x0a, 0x085, 0x0040, 0x084 },
    { 0xffff, 0x06, 0x080, 0xfbff, 0x081 },
    { 0xffff, 0x06, 0x081, 0xffff, 0x081 },
    { 0x0000, 0x10, 0x000, 0x0000, 0x000 },
    { 0x0000, 0x10, 0x001, 0x0001, 0x000 },
    { 0x0015, 0x02, 0x0c0, 0x8005, 0x8c8 },
    { 0x0015, 0x02, 0x0c1, 0xc005, 0x0c0 },
    { 0xdd32, 0x1f, 0x044, 0xe993, 0x044 },
    { 0xdd32, 0x1f, 0x045, 0xe997, 0x044 },
    { 0x847a, 0x1f, 0x090, 0x23d2, 0x090 },
    { 0x847a, 0x1f, 0x091, 0x23d6, 0x090 },
    { 0x0013, 0x06, 0x044, 0x9800, 0x84c },
    { 0x0013, 0x06, 0x045, 0x9c00, 0x84c },
    { 0xdcd9, 0x1f, 0x000, 0xe6cb, 0x000 },
    { 0xdcd9, 0x1f, 0x001, 0xe6cf, 0x000 },
    { 0xde45, 0x09, 0x084, 0x456f, 0x88c },
    { 0xde45, 0x09, 0x085, 0x45ef, 0x88c },
    { 0x0f89, 0x01, 0x044, 0x07c4, 0x045 },
    { 0x0f89, 0x01, 0x045, 0x87c4, 0x84d },
    { 0x884a, 0x0b, 0x004, 0x1291, 0x004 },
    { 0x884a, 0x0b, 0x005, 0x12b1, 0x004 },
    { 0x87d0, 0x09, 0x0d0, 0xd043, 0x0d1 },
    { 0x87d0, 0x09, 0x0d1, 0xd0c3, 0x0d1 },
    { 0x34c8, 0x1c, 0x044, 0x3206, 0x045 },
    { 0x34c8, 0x1c, 0x045, 0x3226, 0x045 },
    { 0x686b, 0x02, 0x0c0, 0x9a1a, 0x8c9 },
    { 0x686b, 0x02, 0x0c1, 0xda1a, 0x0c1 },
    { 0xe410, 0x00, 0x080, 0xe410, 0x080 },
    { 0xe410, 0x00, 0x081, 0xe410, 0x081 },
    { 0x23c8, 0x11, 0x000, 0x23c8, 0x000 },
    { 0x23c8, 0x11, 0x001, 0x23c8, 0x001 },
    { 0xc911, 0x11, 0x084, 0xc911, 0x084 },
    { 0xc911, 0x11, 0x085, 0xc911, 0x085 },
    { 0xd674, 0x11, 0x0c4, 0xd674, 0x0c4 },
    { 0xd674, 0x11, 0x0c5, 0xd674, 0x0c5 },
    { 0x0581, 0x11, 0x010, 0x0581, 0x010 },
    { 0x0581, 0x11, 0x011, 0x0581, 0x011 },
    { 0x1b0e, 0x11, 0x014, 0x1b0e, 0x014 },
    { 0x1b0e, 0x11, 0x015, 0x1b0e, 0x015 },
    { 0x915c, 0x11, 0x004, 0x915c, 0x80c },
    { 0x915c, 0x11, 0x005, 0x915c, 0x80d },
    { 0x001b, 0x11, 0x090, 0x001b, 0x090 },
    { 0x001b, 0x11, 0x091, 0x001b, 0x091 },
    { 0x36ee, 0x11, 0x084, 0x36ee, 0x084 },
    { 0x36ee, 0x11, 0x085, 0x36ee, 0x085 },
    { 0x62a8, 0x00, 0x0c4, 0x62a8, 0x0c4 },
    { 0x62a8, 0x00, 0x0c5, 0x62a8, 0x0c5 },
    { 0x7e82, 0x10, 0x054, 0xfd04, 0x054 },
    { 0x7e82, 0x10, 0x055, 0xfd05, 0x054 },
    { 0x9c63, 0x11, 0x000, 0x9c63, 0x808 },
    { 0x9c63, 0x11, 0x001, 0x9c63, 0x809 },
    { 0xbe4a, 0x11, 0x050, 0xbe4a, 0x858 },
    { 0xbe4a, 0x11, 0x051, 0xbe4a, 0x859 },
    { 0x0050, 0x11, 0x010, 0x0050, 0x010 },
    { 0x0050, 0x11, 0x011, 0x0050, 0x011 },
};

const uint16_t g_cBs3CpuInstr2_rcr_amd_TestDataU32 = 64;
const BS3CPUINSTR2SHIFT32 g_aBs3CpuInstr2_rcr_amd_TestDataU32[64] =
{
    { 0x00000000, 0x09, 0x040, 0x00000000, 0x040 },
    { 0x00000000, 0x09, 0x041, 0x00800000, 0x040 },
    { 0xffffffff, 0x18, 0x090, 0xfffffeff, 0x091 },
    { 0xffffffff, 0x18, 0x091, 0xffffffff, 0x091 },
    { 0x00000000, 0x3a, 0x040, 0x00000000, 0x040 },
    { 0x00000000, 0x3a, 0x041, 0x00000040, 0x040 },
    { 0x835debdf, 0x1a, 0x080, 0xaef5efa0, 0x889 },
    { 0x835debdf, 0x1a, 0x081, 0xaef5efe0, 0x889 },
    { 0xf812a7f4, 0x17, 0x040, 0x4a9fd1f0, 0x848 },
    { 0xf812a7f4, 0x17, 0x041, 0x4a9fd3f0, 0x848 },
    { 0x18526304, 0x09, 0x000, 0x040c2931, 0x001 },
    { 0x18526304, 0x09, 0x001, 0x048c2931, 0x001 },
    { 0xde05e7fd, 0x0d, 0x090, 0x7fd6f02f, 0x898 },
    { 0xde05e7fd, 0x0d, 0x091, 0x7fdef02f, 0x898 },
    { 0x7fb8aa0a, 0x1a, 0x0d0, 0xdc55051f, 0x0d1 },
    { 0x7fb8aa0a, 0x1a, 0x0d1, 0xdc55055f, 0x0d1 },
    { 0x038b1369, 0x04, 0x014, 0x2038b136, 0x015 },
    { 0x038b1369, 0x04, 0x015, 0x3038b136, 0x015 },
    { 0x285d080f, 0x1d, 0x054, 0x85d080f1, 0x85c },
    { 0x285d080f, 0x1d, 0x055, 0x85d080f9, 0x85c },
    { 0x0002cff9, 0x12, 0x050, 0x67fc8000, 0x859 },
    { 0x0002cff9, 0x12, 0x051, 0x67fcc000, 0x859 },
    { 0x2b9a09b6, 0x07, 0x090, 0xd8573413, 0x090 },
    { 0x2b9a09b6, 0x07, 0x091, 0xda573413, 0x090 },
    { 0x58fd09b2, 0x2a, 0x004, 0xd9163f42, 0x004 },
    { 0x58fd09b2, 0x2a, 0x005, 0xd9563f42, 0x004 },
    { 0xeef70576, 0x0d, 0x894, 0x576777b8, 0x89c },
    { 0xeef70576, 0x0d, 0x895, 0x576f77b8, 0x89c },
    { 0x737b0176, 0x19, 0x054, 0x7b017639, 0x85d },
    { 0x737b0176, 0x19, 0x055, 0x7b0176b9, 0x85d },
    { 0x00041f4f, 0x01, 0x014, 0x00020fa7, 0x015 },
    { 0x00041f4f, 0x01, 0x015, 0x80020fa7, 0x81d },
    { 0x574c7d42, 0x06, 0x084, 0x115d31f5, 0x084 },
    { 0x574c7d42, 0x06, 0x085, 0x155d31f5, 0x084 },
    { 0x1c5d3ebc, 0x00, 0x050, 0x1c5d3ebc, 0x050 },
    { 0x1c5d3ebc, 0x00, 0x051, 0x1c5d3ebc, 0x051 },
    { 0x4644c175, 0x20, 0x054, 0x4644c175, 0x054 },
    { 0x4644c175, 0x20, 0x055, 0x4644c175, 0x055 },
    { 0x38222278, 0x21, 0x840, 0x1c11113c, 0x040 },
    { 0x38222278, 0x21, 0x841, 0x9c11113c, 0x848 },
    { 0x000003f9, 0x21, 0x884, 0x000001fc, 0x085 },
    { 0x000003f9, 0x21, 0x885, 0x800001fc, 0x88d },
    { 0xe8e4ca2b, 0x21, 0x010, 0x74726515, 0x819 },
    { 0xe8e4ca2b, 0x21, 0x011, 0xf4726515, 0x011 },
    { 0xa36c408d, 0x21, 0x010, 0x51b62046, 0x819 },
    { 0xa36c408d, 0x21, 0x011, 0xd1b62046, 0x011 },
    { 0x41ac185f, 0x21, 0x0c4, 0x20d60c2f, 0x0c5 },
    { 0x41ac185f, 0x21, 0x0c5, 0xa0d60c2f, 0x8cd },
    { 0x757c5e36, 0x21, 0x0c0, 0x3abe2f1b, 0x0c0 },
    { 0x757c5e36, 0x21, 0x0c1, 0xbabe2f1b, 0x8c8 },
    { 0x00db0fcc, 0x21, 0x080, 0x006d87e6, 0x080 },
    { 0x00db0fcc, 0x21, 0x081, 0x806d87e6, 0x888 },
    { 0x2f70ce8d, 0x21, 0x094, 0x17b86746, 0x095 },
    { 0x2f70ce8d, 0x21, 0x095, 0x97b86746, 0x89d },
    { 0xd1383ecc, 0x21, 0x044, 0x689c1f66, 0x84c },
    { 0xd1383ecc, 0x21, 0x045, 0xe89c1f66, 0x044 },
    { 0x7c9c640c, 0x21, 0x054, 0x3e4e3206, 0x054 },
    { 0x7c9c640c, 0x21, 0x055, 0xbe4e3206, 0x85c },
    { 0x1ce1e618, 0x21, 0x014, 0x0e70f30c, 0x014 },
    { 0x1ce1e618, 0x21, 0x015, 0x8e70f30c, 0x81c },
    { 0x00147b5c, 0x21, 0x0c4, 0x000a3dae, 0x0c4 },
    { 0x00147b5c, 0x21, 0x0c5, 0x800a3dae, 0x8cc },
    { 0xdd7b22ba, 0x21, 0x084, 0x6ebd915d, 0x88c },
    { 0xdd7b22ba, 0x21, 0x085, 0xeebd915d, 0x084 },
};