#pragma D option quiet
int g_cErrors;

dtrace:::BEGIN
{
    g_cErrors = 0;
}

dtrace:::BEGIN
/sizeof(X86CPUIDFEATECX) != 4/
{
    printf("error: sizeof(X86CPUIDFEATECX) should be 4, not %u\n", sizeof(X86CPUIDFEATECX));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(CPUM) != 616/
{
    printf("error: sizeof(CPUM) should be 616, not %u\n", sizeof(CPUM));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUM, fHostUseFlags) != 0/
{
    printf("error: offsetof(CPUM, fHostUseFlags) should be 0, not %u\n", offsetof(CPUM, fHostUseFlags));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUM, CR4) != 4/
{
    printf("error: offsetof(CPUM, CR4) should be 4, not %u\n", offsetof(CPUM, CR4));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUM, aGuestCpuIdPatmStd) != 240/
{
    printf("error: offsetof(CPUM, aGuestCpuIdPatmStd) should be 240, not %u\n", offsetof(CPUM, aGuestCpuIdPatmStd));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUM, aGuestCpuIdPatmExt) != 336/
{
    printf("error: offsetof(CPUM, aGuestCpuIdPatmExt) should be 336, not %u\n", offsetof(CPUM, aGuestCpuIdPatmExt));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUM, aGuestCpuIdPatmCentaur) != 496/
{
    printf("error: offsetof(CPUM, aGuestCpuIdPatmCentaur) should be 496, not %u\n", offsetof(CPUM, aGuestCpuIdPatmCentaur));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(CPUMCPU) != 2368/
{
    printf("error: sizeof(CPUMCPU) should be 2368, not %u\n", sizeof(CPUMCPU));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, Hyper) != 2240/
{
    printf("error: offsetof(CPUMCPU, Hyper) should be 2240, not %u\n", offsetof(CPUMCPU, Hyper));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, Host) != 1920/
{
    printf("error: offsetof(CPUMCPU, Host) should be 1920, not %u\n", offsetof(CPUMCPU, Host));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, Guest) != 0/
{
    printf("error: offsetof(CPUMCPU, Guest) should be 0, not %u\n", offsetof(CPUMCPU, Guest));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, GuestMsrs) != 1344/
{
    printf("error: offsetof(CPUMCPU, GuestMsrs) should be 1344, not %u\n", offsetof(CPUMCPU, GuestMsrs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, fUseFlags) != 1872/
{
    printf("error: offsetof(CPUMCPU, fUseFlags) should be 1872, not %u\n", offsetof(CPUMCPU, fUseFlags));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, fChanged) != 1876/
{
    printf("error: offsetof(CPUMCPU, fChanged) should be 1876, not %u\n", offsetof(CPUMCPU, fChanged));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, u32RetCode) != 1880/
{
    printf("error: offsetof(CPUMCPU, u32RetCode) should be 1880, not %u\n", offsetof(CPUMCPU, u32RetCode));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, pvApicBase) != 1888/
{
    printf("error: offsetof(CPUMCPU, pvApicBase) should be 1888, not %u\n", offsetof(CPUMCPU, pvApicBase));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, fApicDisVectors) != 1884/
{
    printf("error: offsetof(CPUMCPU, fApicDisVectors) should be 1884, not %u\n", offsetof(CPUMCPU, fApicDisVectors));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, fX2Apic) != 1896/
{
    printf("error: offsetof(CPUMCPU, fX2Apic) should be 1896, not %u\n", offsetof(CPUMCPU, fX2Apic));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCPU, fRemEntered) != 1897/
{
    printf("error: offsetof(CPUMCPU, fRemEntered) should be 1897, not %u\n", offsetof(CPUMCPU, fRemEntered));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(CPUMHOSTCTX) != 320/
{
    printf("error: sizeof(CPUMHOSTCTX) should be 320, not %u\n", sizeof(CPUMHOSTCTX));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, pXStateR3) != 296/
{
    printf("error: offsetof(CPUMHOSTCTX, pXStateR3) should be 296, not %u\n", offsetof(CPUMHOSTCTX, pXStateR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, pXStateR0) != 288/
{
    printf("error: offsetof(CPUMHOSTCTX, pXStateR0) should be 288, not %u\n", offsetof(CPUMHOSTCTX, pXStateR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, rbx) != 0/
{
    printf("error: offsetof(CPUMHOSTCTX, rbx) should be 0, not %u\n", offsetof(CPUMHOSTCTX, rbx));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, rdi) != 8/
{
    printf("error: offsetof(CPUMHOSTCTX, rdi) should be 8, not %u\n", offsetof(CPUMHOSTCTX, rdi));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, rsi) != 16/
{
    printf("error: offsetof(CPUMHOSTCTX, rsi) should be 16, not %u\n", offsetof(CPUMHOSTCTX, rsi));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, rbp) != 24/
{
    printf("error: offsetof(CPUMHOSTCTX, rbp) should be 24, not %u\n", offsetof(CPUMHOSTCTX, rbp));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, rsp) != 32/
{
    printf("error: offsetof(CPUMHOSTCTX, rsp) should be 32, not %u\n", offsetof(CPUMHOSTCTX, rsp));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, r10) != 40/
{
    printf("error: offsetof(CPUMHOSTCTX, r10) should be 40, not %u\n", offsetof(CPUMHOSTCTX, r10));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, r11) != 48/
{
    printf("error: offsetof(CPUMHOSTCTX, r11) should be 48, not %u\n", offsetof(CPUMHOSTCTX, r11));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, r12) != 56/
{
    printf("error: offsetof(CPUMHOSTCTX, r12) should be 56, not %u\n", offsetof(CPUMHOSTCTX, r12));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, r13) != 64/
{
    printf("error: offsetof(CPUMHOSTCTX, r13) should be 64, not %u\n", offsetof(CPUMHOSTCTX, r13));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, r14) != 72/
{
    printf("error: offsetof(CPUMHOSTCTX, r14) should be 72, not %u\n", offsetof(CPUMHOSTCTX, r14));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, r15) != 80/
{
    printf("error: offsetof(CPUMHOSTCTX, r15) should be 80, not %u\n", offsetof(CPUMHOSTCTX, r15));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, rflags) != 88/
{
    printf("error: offsetof(CPUMHOSTCTX, rflags) should be 88, not %u\n", offsetof(CPUMHOSTCTX, rflags));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, ss) != 96/
{
    printf("error: offsetof(CPUMHOSTCTX, ss) should be 96, not %u\n", offsetof(CPUMHOSTCTX, ss));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, gs) != 100/
{
    printf("error: offsetof(CPUMHOSTCTX, gs) should be 100, not %u\n", offsetof(CPUMHOSTCTX, gs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, fs) != 104/
{
    printf("error: offsetof(CPUMHOSTCTX, fs) should be 104, not %u\n", offsetof(CPUMHOSTCTX, fs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, es) != 108/
{
    printf("error: offsetof(CPUMHOSTCTX, es) should be 108, not %u\n", offsetof(CPUMHOSTCTX, es));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, ds) != 112/
{
    printf("error: offsetof(CPUMHOSTCTX, ds) should be 112, not %u\n", offsetof(CPUMHOSTCTX, ds));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, cs) != 116/
{
    printf("error: offsetof(CPUMHOSTCTX, cs) should be 116, not %u\n", offsetof(CPUMHOSTCTX, cs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, cr0) != 120/
{
    printf("error: offsetof(CPUMHOSTCTX, cr0) should be 120, not %u\n", offsetof(CPUMHOSTCTX, cr0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, cr3) != 128/
{
    printf("error: offsetof(CPUMHOSTCTX, cr3) should be 128, not %u\n", offsetof(CPUMHOSTCTX, cr3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, cr4) != 136/
{
    printf("error: offsetof(CPUMHOSTCTX, cr4) should be 136, not %u\n", offsetof(CPUMHOSTCTX, cr4));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, cr8) != 144/
{
    printf("error: offsetof(CPUMHOSTCTX, cr8) should be 144, not %u\n", offsetof(CPUMHOSTCTX, cr8));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, dr0) != 152/
{
    printf("error: offsetof(CPUMHOSTCTX, dr0) should be 152, not %u\n", offsetof(CPUMHOSTCTX, dr0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, dr1) != 160/
{
    printf("error: offsetof(CPUMHOSTCTX, dr1) should be 160, not %u\n", offsetof(CPUMHOSTCTX, dr1));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, dr2) != 168/
{
    printf("error: offsetof(CPUMHOSTCTX, dr2) should be 168, not %u\n", offsetof(CPUMHOSTCTX, dr2));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, dr3) != 176/
{
    printf("error: offsetof(CPUMHOSTCTX, dr3) should be 176, not %u\n", offsetof(CPUMHOSTCTX, dr3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, dr6) != 184/
{
    printf("error: offsetof(CPUMHOSTCTX, dr6) should be 184, not %u\n", offsetof(CPUMHOSTCTX, dr6));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, dr7) != 192/
{
    printf("error: offsetof(CPUMHOSTCTX, dr7) should be 192, not %u\n", offsetof(CPUMHOSTCTX, dr7));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, gdtr) != 200/
{
    printf("error: offsetof(CPUMHOSTCTX, gdtr) should be 200, not %u\n", offsetof(CPUMHOSTCTX, gdtr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, idtr) != 212/
{
    printf("error: offsetof(CPUMHOSTCTX, idtr) should be 212, not %u\n", offsetof(CPUMHOSTCTX, idtr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, ldtr) != 224/
{
    printf("error: offsetof(CPUMHOSTCTX, ldtr) should be 224, not %u\n", offsetof(CPUMHOSTCTX, ldtr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, tr) != 228/
{
    printf("error: offsetof(CPUMHOSTCTX, tr) should be 228, not %u\n", offsetof(CPUMHOSTCTX, tr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, SysEnter) != 232/
{
    printf("error: offsetof(CPUMHOSTCTX, SysEnter) should be 232, not %u\n", offsetof(CPUMHOSTCTX, SysEnter));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, FSbase) != 256/
{
    printf("error: offsetof(CPUMHOSTCTX, FSbase) should be 256, not %u\n", offsetof(CPUMHOSTCTX, FSbase));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, GSbase) != 264/
{
    printf("error: offsetof(CPUMHOSTCTX, GSbase) should be 264, not %u\n", offsetof(CPUMHOSTCTX, GSbase));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMHOSTCTX, efer) != 272/
{
    printf("error: offsetof(CPUMHOSTCTX, efer) should be 272, not %u\n", offsetof(CPUMHOSTCTX, efer));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(CPUMCTX) != 1344/
{
    printf("error: sizeof(CPUMCTX) should be 1344, not %u\n", sizeof(CPUMCTX));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt) != 736/
{
    printf("error: offsetof(CPUMCTX, hwvirt) should be 736, not %u\n", offsetof(CPUMCTX, hwvirt));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.uMsrHSavePa) != 736/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.uMsrHSavePa) should be 736, not %u\n", offsetof(CPUMCTX, hwvirt.svm.uMsrHSavePa));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.GCPhysVmcb) != 744/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.GCPhysVmcb) should be 744, not %u\n", offsetof(CPUMCTX, hwvirt.svm.GCPhysVmcb));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.pVmcbR0) != 752/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.pVmcbR0) should be 752, not %u\n", offsetof(CPUMCTX, hwvirt.svm.pVmcbR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.pVmcbR3) != 760/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.pVmcbR3) should be 760, not %u\n", offsetof(CPUMCTX, hwvirt.svm.pVmcbR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.HostState) != 768/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.HostState) should be 768, not %u\n", offsetof(CPUMCTX, hwvirt.svm.HostState));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.uPrevPauseTick) != 952/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.uPrevPauseTick) should be 952, not %u\n", offsetof(CPUMCTX, hwvirt.svm.uPrevPauseTick));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.cPauseFilter) != 960/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.cPauseFilter) should be 960, not %u\n", offsetof(CPUMCTX, hwvirt.svm.cPauseFilter));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.cPauseFilterThreshold) != 962/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.cPauseFilterThreshold) should be 962, not %u\n", offsetof(CPUMCTX, hwvirt.svm.cPauseFilterThreshold));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.fInterceptEvents) != 964/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.fInterceptEvents) should be 964, not %u\n", offsetof(CPUMCTX, hwvirt.svm.fInterceptEvents));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.pvMsrBitmapR0) != 968/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.pvMsrBitmapR0) should be 968, not %u\n", offsetof(CPUMCTX, hwvirt.svm.pvMsrBitmapR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.pvMsrBitmapR3) != 976/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.pvMsrBitmapR3) should be 976, not %u\n", offsetof(CPUMCTX, hwvirt.svm.pvMsrBitmapR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.pvIoBitmapR0) != 984/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.pvIoBitmapR0) should be 984, not %u\n", offsetof(CPUMCTX, hwvirt.svm.pvIoBitmapR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.pvIoBitmapR3) != 992/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.pvIoBitmapR3) should be 992, not %u\n", offsetof(CPUMCTX, hwvirt.svm.pvIoBitmapR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.svm.HCPhysVmcb) != 1000/
{
    printf("error: offsetof(CPUMCTX, hwvirt.svm.HCPhysVmcb) should be 1000, not %u\n", offsetof(CPUMCTX, hwvirt.svm.HCPhysVmcb));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.GCPhysVmxon) != 736/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.GCPhysVmxon) should be 736, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.GCPhysVmxon));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.GCPhysVmcs) != 744/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.GCPhysVmcs) should be 744, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.GCPhysVmcs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.enmDiag) != 760/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.enmDiag) should be 760, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.enmDiag));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.enmAbort) != 764/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.enmAbort) should be 764, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.enmAbort));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.uDiagAux) != 768/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.uDiagAux) should be 768, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.uDiagAux));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.uAbortAux) != 776/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.uAbortAux) should be 776, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.uAbortAux));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.fInVmxRootMode) != 780/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.fInVmxRootMode) should be 780, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.fInVmxRootMode));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.fInVmxNonRootMode) != 781/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.fInVmxNonRootMode) should be 781, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.fInVmxNonRootMode));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.fInterceptEvents) != 782/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.fInterceptEvents) should be 782, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.fInterceptEvents));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.fNmiUnblockingIret) != 783/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.fNmiUnblockingIret) should be 783, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.fNmiUnblockingIret));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pVmcsR0) != 784/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pVmcsR0) should be 784, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pVmcsR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pVmcsR3) != 792/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pVmcsR3) should be 792, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pVmcsR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pShadowVmcsR0) != 800/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pShadowVmcsR0) should be 800, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pShadowVmcsR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pShadowVmcsR3) != 808/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pShadowVmcsR3) should be 808, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pShadowVmcsR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvVirtApicPageR0) != 816/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvVirtApicPageR0) should be 816, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvVirtApicPageR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvVirtApicPageR3) != 824/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvVirtApicPageR3) should be 824, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvVirtApicPageR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvVmreadBitmapR0) != 832/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvVmreadBitmapR0) should be 832, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvVmreadBitmapR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvVmreadBitmapR3) != 840/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvVmreadBitmapR3) should be 840, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvVmreadBitmapR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvVmwriteBitmapR0) != 848/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvVmwriteBitmapR0) should be 848, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvVmwriteBitmapR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvVmwriteBitmapR3) != 856/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvVmwriteBitmapR3) should be 856, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvVmwriteBitmapR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pEntryMsrLoadAreaR0) != 864/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pEntryMsrLoadAreaR0) should be 864, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pEntryMsrLoadAreaR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pEntryMsrLoadAreaR3) != 872/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pEntryMsrLoadAreaR3) should be 872, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pEntryMsrLoadAreaR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pExitMsrStoreAreaR0) != 880/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pExitMsrStoreAreaR0) should be 880, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pExitMsrStoreAreaR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pExitMsrStoreAreaR3) != 888/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pExitMsrStoreAreaR3) should be 888, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pExitMsrStoreAreaR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pExitMsrLoadAreaR0) != 896/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pExitMsrLoadAreaR0) should be 896, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pExitMsrLoadAreaR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pExitMsrLoadAreaR3) != 904/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pExitMsrLoadAreaR3) should be 904, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pExitMsrLoadAreaR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvMsrBitmapR0) != 912/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvMsrBitmapR0) should be 912, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvMsrBitmapR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvMsrBitmapR3) != 920/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvMsrBitmapR3) should be 920, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvMsrBitmapR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvIoBitmapR0) != 928/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvIoBitmapR0) should be 928, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvIoBitmapR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.pvIoBitmapR3) != 936/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.pvIoBitmapR3) should be 936, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.pvIoBitmapR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.uFirstPauseLoopTick) != 944/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.uFirstPauseLoopTick) should be 944, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.uFirstPauseLoopTick));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.uPrevPauseTick) != 952/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.uPrevPauseTick) should be 952, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.uPrevPauseTick));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.uEntryTick) != 960/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.uEntryTick) should be 960, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.uEntryTick));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.offVirtApicWrite) != 968/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.offVirtApicWrite) should be 968, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.offVirtApicWrite));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.fVirtNmiBlocking) != 970/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.fVirtNmiBlocking) should be 970, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.fVirtNmiBlocking));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.Msrs) != 976/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.Msrs) should be 976, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.Msrs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.HCPhysVmcs) != 1200/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.HCPhysVmcs) should be 1200, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.HCPhysVmcs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.HCPhysShadowVmcs) != 1208/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.HCPhysShadowVmcs) should be 1208, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.HCPhysShadowVmcs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.HCPhysVmreadBitmap) != 1224/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.HCPhysVmreadBitmap) should be 1224, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.HCPhysVmreadBitmap));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.HCPhysVmwriteBitmap) != 1232/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.HCPhysVmwriteBitmap) should be 1232, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.HCPhysVmwriteBitmap));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.HCPhysEntryMsrLoadArea) != 1240/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.HCPhysEntryMsrLoadArea) should be 1240, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.HCPhysEntryMsrLoadArea));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.HCPhysExitMsrStoreArea) != 1248/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.HCPhysExitMsrStoreArea) should be 1248, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.HCPhysExitMsrStoreArea));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.HCPhysExitMsrLoadArea) != 1256/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.HCPhysExitMsrLoadArea) should be 1256, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.HCPhysExitMsrLoadArea));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.HCPhysMsrBitmap) != 1264/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.HCPhysMsrBitmap) should be 1264, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.HCPhysMsrBitmap));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.vmx.HCPhysIoBitmap) != 1272/
{
    printf("error: offsetof(CPUMCTX, hwvirt.vmx.HCPhysIoBitmap) should be 1272, not %u\n", offsetof(CPUMCTX, hwvirt.vmx.HCPhysIoBitmap));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.enmHwvirt) != 1280/
{
    printf("error: offsetof(CPUMCTX, hwvirt.enmHwvirt) should be 1280, not %u\n", offsetof(CPUMCTX, hwvirt.enmHwvirt));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.fGif) != 1284/
{
    printf("error: offsetof(CPUMCTX, hwvirt.fGif) should be 1284, not %u\n", offsetof(CPUMCTX, hwvirt.fGif));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, hwvirt.fLocalForcedActions) != 1288/
{
    printf("error: offsetof(CPUMCTX, hwvirt.fLocalForcedActions) should be 1288, not %u\n", offsetof(CPUMCTX, hwvirt.fLocalForcedActions));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, pXStateR0) != 576/
{
    printf("error: offsetof(CPUMCTX, pXStateR0) should be 576, not %u\n", offsetof(CPUMCTX, pXStateR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, pXStateR3) != 584/
{
    printf("error: offsetof(CPUMCTX, pXStateR3) should be 584, not %u\n", offsetof(CPUMCTX, pXStateR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rdi) != 56/
{
    printf("error: offsetof(CPUMCTX, rdi) should be 56, not %u\n", offsetof(CPUMCTX, rdi));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rsi) != 48/
{
    printf("error: offsetof(CPUMCTX, rsi) should be 48, not %u\n", offsetof(CPUMCTX, rsi));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rbp) != 40/
{
    printf("error: offsetof(CPUMCTX, rbp) should be 40, not %u\n", offsetof(CPUMCTX, rbp));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rax) != 0/
{
    printf("error: offsetof(CPUMCTX, rax) should be 0, not %u\n", offsetof(CPUMCTX, rax));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rbx) != 24/
{
    printf("error: offsetof(CPUMCTX, rbx) should be 24, not %u\n", offsetof(CPUMCTX, rbx));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rdx) != 16/
{
    printf("error: offsetof(CPUMCTX, rdx) should be 16, not %u\n", offsetof(CPUMCTX, rdx));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rcx) != 8/
{
    printf("error: offsetof(CPUMCTX, rcx) should be 8, not %u\n", offsetof(CPUMCTX, rcx));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rsp) != 32/
{
    printf("error: offsetof(CPUMCTX, rsp) should be 32, not %u\n", offsetof(CPUMCTX, rsp));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, es) != 128/
{
    printf("error: offsetof(CPUMCTX, es) should be 128, not %u\n", offsetof(CPUMCTX, es));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, cs) != 152/
{
    printf("error: offsetof(CPUMCTX, cs) should be 152, not %u\n", offsetof(CPUMCTX, cs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, ss) != 176/
{
    printf("error: offsetof(CPUMCTX, ss) should be 176, not %u\n", offsetof(CPUMCTX, ss));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, ds) != 200/
{
    printf("error: offsetof(CPUMCTX, ds) should be 200, not %u\n", offsetof(CPUMCTX, ds));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, fs) != 224/
{
    printf("error: offsetof(CPUMCTX, fs) should be 224, not %u\n", offsetof(CPUMCTX, fs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, gs) != 248/
{
    printf("error: offsetof(CPUMCTX, gs) should be 248, not %u\n", offsetof(CPUMCTX, gs));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rflags) != 280/
{
    printf("error: offsetof(CPUMCTX, rflags) should be 280, not %u\n", offsetof(CPUMCTX, rflags));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, rip) != 272/
{
    printf("error: offsetof(CPUMCTX, rip) should be 272, not %u\n", offsetof(CPUMCTX, rip));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, r8) != 64/
{
    printf("error: offsetof(CPUMCTX, r8) should be 64, not %u\n", offsetof(CPUMCTX, r8));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, r9) != 72/
{
    printf("error: offsetof(CPUMCTX, r9) should be 72, not %u\n", offsetof(CPUMCTX, r9));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, r10) != 80/
{
    printf("error: offsetof(CPUMCTX, r10) should be 80, not %u\n", offsetof(CPUMCTX, r10));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, r11) != 88/
{
    printf("error: offsetof(CPUMCTX, r11) should be 88, not %u\n", offsetof(CPUMCTX, r11));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, r12) != 96/
{
    printf("error: offsetof(CPUMCTX, r12) should be 96, not %u\n", offsetof(CPUMCTX, r12));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, r13) != 104/
{
    printf("error: offsetof(CPUMCTX, r13) should be 104, not %u\n", offsetof(CPUMCTX, r13));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, r14) != 112/
{
    printf("error: offsetof(CPUMCTX, r14) should be 112, not %u\n", offsetof(CPUMCTX, r14));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, r15) != 120/
{
    printf("error: offsetof(CPUMCTX, r15) should be 120, not %u\n", offsetof(CPUMCTX, r15));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, cr0) != 288/
{
    printf("error: offsetof(CPUMCTX, cr0) should be 288, not %u\n", offsetof(CPUMCTX, cr0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, cr2) != 296/
{
    printf("error: offsetof(CPUMCTX, cr2) should be 296, not %u\n", offsetof(CPUMCTX, cr2));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, cr3) != 304/
{
    printf("error: offsetof(CPUMCTX, cr3) should be 304, not %u\n", offsetof(CPUMCTX, cr3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, cr4) != 312/
{
    printf("error: offsetof(CPUMCTX, cr4) should be 312, not %u\n", offsetof(CPUMCTX, cr4));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, dr) != 320/
{
    printf("error: offsetof(CPUMCTX, dr) should be 320, not %u\n", offsetof(CPUMCTX, dr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, gdtr) != 390/
{
    printf("error: offsetof(CPUMCTX, gdtr) should be 390, not %u\n", offsetof(CPUMCTX, gdtr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, idtr) != 406/
{
    printf("error: offsetof(CPUMCTX, idtr) should be 406, not %u\n", offsetof(CPUMCTX, idtr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, ldtr) != 416/
{
    printf("error: offsetof(CPUMCTX, ldtr) should be 416, not %u\n", offsetof(CPUMCTX, ldtr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, tr) != 440/
{
    printf("error: offsetof(CPUMCTX, tr) should be 440, not %u\n", offsetof(CPUMCTX, tr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, SysEnter) != 464/
{
    printf("error: offsetof(CPUMCTX, SysEnter) should be 464, not %u\n", offsetof(CPUMCTX, SysEnter));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, msrEFER) != 488/
{
    printf("error: offsetof(CPUMCTX, msrEFER) should be 488, not %u\n", offsetof(CPUMCTX, msrEFER));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, msrSTAR) != 496/
{
    printf("error: offsetof(CPUMCTX, msrSTAR) should be 496, not %u\n", offsetof(CPUMCTX, msrSTAR));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, msrPAT) != 504/
{
    printf("error: offsetof(CPUMCTX, msrPAT) should be 504, not %u\n", offsetof(CPUMCTX, msrPAT));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, msrLSTAR) != 512/
{
    printf("error: offsetof(CPUMCTX, msrLSTAR) should be 512, not %u\n", offsetof(CPUMCTX, msrLSTAR));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, msrCSTAR) != 520/
{
    printf("error: offsetof(CPUMCTX, msrCSTAR) should be 520, not %u\n", offsetof(CPUMCTX, msrCSTAR));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, msrSFMASK) != 528/
{
    printf("error: offsetof(CPUMCTX, msrSFMASK) should be 528, not %u\n", offsetof(CPUMCTX, msrSFMASK));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, msrKERNELGSBASE) != 536/
{
    printf("error: offsetof(CPUMCTX, msrKERNELGSBASE) should be 536, not %u\n", offsetof(CPUMCTX, msrKERNELGSBASE));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, ldtr) != 416/
{
    printf("error: offsetof(CPUMCTX, ldtr) should be 416, not %u\n", offsetof(CPUMCTX, ldtr));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(CPUMCTX, tr) != 440/
{
    printf("error: offsetof(CPUMCTX, tr) should be 440, not %u\n", offsetof(CPUMCTX, tr));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(CPUMCTXMSRS) != 512/
{
    printf("error: sizeof(CPUMCTXMSRS) should be 512, not %u\n", sizeof(CPUMCTXMSRS));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(CPUMCTXCORE) != 288/
{
    printf("error: sizeof(CPUMCTXCORE) should be 288, not %u\n", sizeof(CPUMCTXCORE));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(APIC) != 64/
{
    printf("error: sizeof(APIC) should be 64, not %u\n", sizeof(APIC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APIC, pvApicPibR0) != 32/
{
    printf("error: offsetof(APIC, pvApicPibR0) should be 32, not %u\n", offsetof(APIC, pvApicPibR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APIC, pvApicPibR3) != 40/
{
    printf("error: offsetof(APIC, pvApicPibR3) should be 40, not %u\n", offsetof(APIC, pvApicPibR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APIC, cbApicPib) != 48/
{
    printf("error: offsetof(APIC, cbApicPib) should be 48, not %u\n", offsetof(APIC, cbApicPib));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APIC, enmMaxMode) != 60/
{
    printf("error: offsetof(APIC, enmMaxMode) should be 60, not %u\n", offsetof(APIC, enmMaxMode));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, pvApicPageR0) != 24/
{
    printf("error: offsetof(APICCPU, pvApicPageR0) should be 24, not %u\n", offsetof(APICCPU, pvApicPageR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, pvApicPageR3) != 32/
{
    printf("error: offsetof(APICCPU, pvApicPageR3) should be 32, not %u\n", offsetof(APICCPU, pvApicPageR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, cbApicPage) != 40/
{
    printf("error: offsetof(APICCPU, cbApicPage) should be 40, not %u\n", offsetof(APICCPU, cbApicPage));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, pvApicPibR0) != 64/
{
    printf("error: offsetof(APICCPU, pvApicPibR0) should be 64, not %u\n", offsetof(APICCPU, pvApicPibR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, pvApicPibR3) != 72/
{
    printf("error: offsetof(APICCPU, pvApicPibR3) should be 72, not %u\n", offsetof(APICCPU, pvApicPibR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, ApicPibLevel) != 80/
{
    printf("error: offsetof(APICCPU, ApicPibLevel) should be 80, not %u\n", offsetof(APICCPU, ApicPibLevel));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(APICCPU, hTimer) != 1240/
{
    printf("error: offsetof(APICCPU, hTimer) should be 1240, not %u\n", offsetof(APICCPU, hTimer));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(VM) != 57344/
{
    printf("error: sizeof(VM) should be 57344, not %u\n", sizeof(VM));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, enmVMState) != 0/
{
    printf("error: offsetof(VM, enmVMState) should be 0, not %u\n", offsetof(VM, enmVMState));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, fGlobalForcedActions) != 4/
{
    printf("error: offsetof(VM, fGlobalForcedActions) should be 4, not %u\n", offsetof(VM, fGlobalForcedActions));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, paVMPagesR3) != 8/
{
    printf("error: offsetof(VM, paVMPagesR3) should be 8, not %u\n", offsetof(VM, paVMPagesR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, pSession) != 16/
{
    printf("error: offsetof(VM, pSession) should be 16, not %u\n", offsetof(VM, pSession));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, pUVM) != 24/
{
    printf("error: offsetof(VM, pUVM) should be 24, not %u\n", offsetof(VM, pUVM));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, pVMR3) != 32/
{
    printf("error: offsetof(VM, pVMR3) should be 32, not %u\n", offsetof(VM, pVMR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, pVMR0ForCall) != 40/
{
    printf("error: offsetof(VM, pVMR0ForCall) should be 40, not %u\n", offsetof(VM, pVMR0ForCall));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, pVMRC) != 48/
{
    printf("error: offsetof(VM, pVMRC) should be 48, not %u\n", offsetof(VM, pVMRC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, hSelf) != 56/
{
    printf("error: offsetof(VM, hSelf) should be 56, not %u\n", offsetof(VM, hSelf));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, cCpus) != 60/
{
    printf("error: offsetof(VM, cCpus) should be 60, not %u\n", offsetof(VM, cCpus));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, uCpuExecutionCap) != 64/
{
    printf("error: offsetof(VM, uCpuExecutionCap) should be 64, not %u\n", offsetof(VM, uCpuExecutionCap));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, cbSelf) != 68/
{
    printf("error: offsetof(VM, cbSelf) should be 68, not %u\n", offsetof(VM, cbSelf));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, bMainExecutionEngine) != 80/
{
    printf("error: offsetof(VM, bMainExecutionEngine) should be 80, not %u\n", offsetof(VM, bMainExecutionEngine));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, fHMEnabled) != 81/
{
    printf("error: offsetof(VM, fHMEnabled) should be 81, not %u\n", offsetof(VM, fHMEnabled));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, fUseLargePages) != 82/
{
    printf("error: offsetof(VM, fUseLargePages) should be 82, not %u\n", offsetof(VM, fUseLargePages));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, hTraceBufR3) != 88/
{
    printf("error: offsetof(VM, hTraceBufR3) should be 88, not %u\n", offsetof(VM, hTraceBufR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, hTraceBufR0) != 96/
{
    printf("error: offsetof(VM, hTraceBufR0) should be 96, not %u\n", offsetof(VM, hTraceBufR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, cpum) != 128/
{
    printf("error: offsetof(VM, cpum) should be 128, not %u\n", offsetof(VM, cpum));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, vmm) != 1664/
{
    printf("error: offsetof(VM, vmm) should be 1664, not %u\n", offsetof(VM, vmm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, pgm) != 3264/
{
    printf("error: offsetof(VM, pgm) should be 3264, not %u\n", offsetof(VM, pgm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, hm) != 24384/
{
    printf("error: offsetof(VM, hm) should be 24384, not %u\n", offsetof(VM, hm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, trpm) != 29888/
{
    printf("error: offsetof(VM, trpm) should be 29888, not %u\n", offsetof(VM, trpm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, selm) != 35136/
{
    printf("error: offsetof(VM, selm) should be 35136, not %u\n", offsetof(VM, selm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, mm) != 35904/
{
    printf("error: offsetof(VM, mm) should be 35904, not %u\n", offsetof(VM, mm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, pdm) != 36096/
{
    printf("error: offsetof(VM, pdm) should be 36096, not %u\n", offsetof(VM, pdm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, iom) != 43904/
{
    printf("error: offsetof(VM, iom) should be 43904, not %u\n", offsetof(VM, iom));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, em) != 45056/
{
    printf("error: offsetof(VM, em) should be 45056, not %u\n", offsetof(VM, em));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, tm) != 45440/
{
    printf("error: offsetof(VM, tm) should be 45440, not %u\n", offsetof(VM, tm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, dbgf) != 53312/
{
    printf("error: offsetof(VM, dbgf) should be 53312, not %u\n", offsetof(VM, dbgf));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, ssm) != 55744/
{
    printf("error: offsetof(VM, ssm) should be 55744, not %u\n", offsetof(VM, ssm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, gim) != 55872/
{
    printf("error: offsetof(VM, gim) should be 55872, not %u\n", offsetof(VM, gim));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, vm) != 56448/
{
    printf("error: offsetof(VM, vm) should be 56448, not %u\n", offsetof(VM, vm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, cfgm) != 56480/
{
    printf("error: offsetof(VM, cfgm) should be 56480, not %u\n", offsetof(VM, cfgm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VM, apic) != 56320/
{
    printf("error: offsetof(VM, apic) should be 56320, not %u\n", offsetof(VM, apic));
    g_cErrors++;
}

dtrace:::BEGIN
/sizeof(VMCPU) != 86016/
{
    printf("error: sizeof(VMCPU) should be 86016, not %u\n", sizeof(VMCPU));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, fLocalForcedActions) != 0/
{
    printf("error: offsetof(VMCPU, fLocalForcedActions) should be 0, not %u\n", offsetof(VMCPU, fLocalForcedActions));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, enmState) != 8/
{
    printf("error: offsetof(VMCPU, enmState) should be 8, not %u\n", offsetof(VMCPU, enmState));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, pUVCpu) != 18584/
{
    printf("error: offsetof(VMCPU, pUVCpu) should be 18584, not %u\n", offsetof(VMCPU, pUVCpu));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, pVMR3) != 18560/
{
    printf("error: offsetof(VMCPU, pVMR3) should be 18560, not %u\n", offsetof(VMCPU, pVMR3));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, pVCpuR0ForVtg) != 18568/
{
    printf("error: offsetof(VMCPU, pVCpuR0ForVtg) should be 18568, not %u\n", offsetof(VMCPU, pVCpuR0ForVtg));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, pVMRC) != 18576/
{
    printf("error: offsetof(VMCPU, pVMRC) should be 18576, not %u\n", offsetof(VMCPU, pVMRC));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, idCpu) != 18608/
{
    printf("error: offsetof(VMCPU, idCpu) should be 18608, not %u\n", offsetof(VMCPU, idCpu));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, hNativeThread) != 18592/
{
    printf("error: offsetof(VMCPU, hNativeThread) should be 18592, not %u\n", offsetof(VMCPU, hNativeThread));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, hNativeThreadR0) != 18600/
{
    printf("error: offsetof(VMCPU, hNativeThreadR0) should be 18600, not %u\n", offsetof(VMCPU, hNativeThreadR0));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, idHostCpu) != 12/
{
    printf("error: offsetof(VMCPU, idHostCpu) should be 12, not %u\n", offsetof(VMCPU, idHostCpu));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, fTraceGroups) != 35136/
{
    printf("error: offsetof(VMCPU, fTraceGroups) should be 35136, not %u\n", offsetof(VMCPU, fTraceGroups));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, uAdHoc) != 35140/
{
    printf("error: offsetof(VMCPU, uAdHoc) should be 35140, not %u\n", offsetof(VMCPU, uAdHoc));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, aStatAdHoc) != 35144/
{
    printf("error: offsetof(VMCPU, aStatAdHoc) should be 35144, not %u\n", offsetof(VMCPU, aStatAdHoc));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, hm) != 18624/
{
    printf("error: offsetof(VMCPU, hm) should be 18624, not %u\n", offsetof(VMCPU, hm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, em) != 45056/
{
    printf("error: offsetof(VMCPU, em) should be 45056, not %u\n", offsetof(VMCPU, em));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, iem) != 64/
{
    printf("error: offsetof(VMCPU, iem) should be 64, not %u\n", offsetof(VMCPU, iem));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, trpm) != 25024/
{
    printf("error: offsetof(VMCPU, trpm) should be 25024, not %u\n", offsetof(VMCPU, trpm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, tm) != 25152/
{
    printf("error: offsetof(VMCPU, tm) should be 25152, not %u\n", offsetof(VMCPU, tm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, vmm) != 30912/
{
    printf("error: offsetof(VMCPU, vmm) should be 30912, not %u\n", offsetof(VMCPU, vmm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, pdm) != 31808/
{
    printf("error: offsetof(VMCPU, pdm) should be 31808, not %u\n", offsetof(VMCPU, pdm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, iom) != 32064/
{
    printf("error: offsetof(VMCPU, iom) should be 32064, not %u\n", offsetof(VMCPU, iom));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, dbgf) != 32576/
{
    printf("error: offsetof(VMCPU, dbgf) should be 32576, not %u\n", offsetof(VMCPU, dbgf));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, gim) != 32832/
{
    printf("error: offsetof(VMCPU, gim) should be 32832, not %u\n", offsetof(VMCPU, gim));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, apic) != 33344/
{
    printf("error: offsetof(VMCPU, apic) should be 33344, not %u\n", offsetof(VMCPU, apic));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, pgm) != 36864/
{
    printf("error: offsetof(VMCPU, pgm) should be 36864, not %u\n", offsetof(VMCPU, pgm));
    g_cErrors++;
}

dtrace:::BEGIN
/offsetof(VMCPU, cpum) != 40960/
{
    printf("error: offsetof(VMCPU, cpum) should be 40960, not %u\n", offsetof(VMCPU, cpum));
    g_cErrors++;
}

dtrace:::BEGIN
/g_cErrors != 0/
{
    printf("%u errors!\n", g_cErrors);
    exit(1);
}

dtrace:::BEGIN
{
    printf("Success!\n");
    exit(0);
}

