# CVE-2026-62703 — dwmcore.dll patch diff

`dwmcore.dll` 10.0.26100.8875 -> 10.0.26100.9168 (ghidriff).

## `ConvertSDRBoostToSDRWhiteLevel`  (modified)

```diff
--- ConvertSDRBoostToSDRWhiteLevel
+++ ConvertSDRBoostToSDRWhiteLevel
@@ -1,37 +1,16 @@
 

-/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

-   guard_dispatch_icall */

-/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

+/* unsigned int __cdecl ConvertSDRBoostToSDRWhiteLevel(float,enum DXGI_COLOR_SPACE_TYPE) */

 

 uint __cdecl ConvertSDRBoostToSDRWhiteLevel(float param_1,DXGI_COLOR_SPACE_TYPE param_2)

 

 {

-  longlong *plVar1;

-  undefined8 *puVar2;

-  void *unaff_RDI;

-  uint unaff_R13D;

-  undefined8 *unaff_R14;

-  float fStack0000000000000030;

+  bool bVar1;

+  float extraout_XMM0_Da;

   

-  fStack0000000000000030 = param_1;

-  puVar2 = (undefined8 *)CCommonRenderingEffect::CCommonRenderingEffect();

-  plVar1 = _s_cpSolidColorEffect;

-  _s_cpSolidColorEffect = puVar2;

-  if (puVar2 != (undefined8 *)0x0) {

-    (**(code **)*puVar2)(puVar2);

+  if (((1.1920929e-06 <= ABS(param_1 - 1.0)) && (param_2 != 1)) &&

+     (bVar1 = IsDXGIColorSpaceRec2020(param_2), !bVar1)) {

+    return (uint)(longlong)(extraout_XMM0_Da * 80.0);

   }

-  if (plVar1 != (longlong *)0x0) {

-    (**(code **)(*plVar1 + 8))(plVar1);

-  }

-  if (_s_cpSolidColorEffect == (undefined8 *)0x0) {

-    unaff_R13D = 0x8007000e;

-    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,-0x7ff8fff2,0x59,unaff_RDI);

-    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,-0x7ff8fff2,0x49,unaff_RDI);

-  }

-  else {

-    *unaff_R14 = _s_cpSolidColorEffect;

-    (**(code **)*_s_cpSolidColorEffect)();

-  }

-  return unaff_R13D;

+  return 0;

 }
```

## `FUN_1802ef0d4`  (modified)

```diff
--- FUN_1802ef0d4
+++ FUN_1802ec746
@@ -1,515 +1,125 @@
 

-/* WARNING: Instruction at (ram,0x0001802ef0d5) overlaps instruction at (ram,0x0001802ef0d4)

-    */

-/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

-   guard_dispatch_icall */

 /* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

-/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

+/* PDB: Separated code (from the compiler): 1802ec746 - 1802ec7b6 for parent address: 180188bfc */

 

-ulonglong FUN_1802ef0d4(MILMatrix3x2 *param_1,undefined4 param_2,undefined4 param_3,

-                       MILMatrix3x2 *param_4,undefined8 param_5,undefined8 param_6,

-                       undefined8 param_7,undefined8 param_8,ID2D1PathGeometry *param_9,

-                       ID2D1Geometry *param_10)

+void FUN_1802ec746(void)

 

 {

-  undefined8 *puVar1;

-  int *piVar2;

-  undefined4 uVar3;

-  undefined4 uVar4;

-  float fVar5;

-  bool bVar6;

-  uint uVar7;

-  uint uVar8;

-  D2D1_COMPOSITOR_DRAWING_STATE *pDVar9;

-  DynArrayImpl<0> *pDVar10;

-  ulonglong uVar11;

-  DynArrayImpl<0> *in_RAX;

-  int iVar12;

-  ulonglong uVar13;

-  MILMatrix3x2 *this;

-  int iVar14;

-  longlong lVar15;

-  longlong in_RDX;

-  undefined8 unaff_RBX;

-  DynArrayImpl<0> *unaff_RBP;

-  ulonglong uVar16;

-  MILMatrix3x2 *unaff_RSI;

-  uint unaff_EDI;

-  int iVar17;

-  int iVar18;

-  D2D_RECT_F *pDVar19;

-  undefined8 uVar20;

-  byte bVar21;

-  ID2D1PathGeometry *unaff_R12;

-  MILMatrix3x2 *unaff_R14;

-  longlong unaff_R15;

-  float fVar22;

-  undefined4 uVar23;

-  float fVar24;

-  float fVar25;

-  undefined4 unaff_XMM6_Da;

-  undefined4 unaff_XMM6_Db;

-  float unaff_XMM7_Da;

-  uint uVar26;

-  int iStack0000000000000070;

-  int iStack0000000000000074;

-  int iStack0000000000000078;

-  int iStack000000000000007c;

+  undefined4 uVar1;

+  undefined4 uVar2;

+  bool bVar3;

+  undefined8 uVar4;

+  undefined8 uVar5;

+  __uint64 _Var6;

+  void *pvVar7;

+  D2D1_EDGE_FLAGS DVar8;

+  D2D_RECT_F *pDVar9;

+  longlong unaff_RBP;

+  Matrix3x3 *unaff_RSI;

+  D2D_RECT_F *unaff_RDI;

+  D2D_RECT_F *unaff_R14;

+  D2D1_EDGE_FLAGS unaff_R15D;

+  float unaff_XMM6_Da;

   

-  uVar11 = CONCAT71((int7)((ulonglong)unaff_RBX >> 8),

-                    (char)unaff_RBX + (char)((ulonglong)in_RDX >> 8));

-  uVar23 = *(undefined4 *)(param_4 + 8);

-code_r0x0001802ef0db:

-  *(undefined4 *)(unaff_RBP + 0x124) = param_2;

-  *(undefined4 *)(unaff_RBP + 300) = param_2;

-  uVar4 = *(undefined4 *)(param_4 + 0xc);

-  *(undefined4 *)(unaff_RBP + 0x134) = uVar4;

-  *(undefined4 *)(unaff_RBP + 0x13c) = uVar4;

-  *(undefined4 *)(unaff_RBP + 0x120) = param_3;

-  *(undefined4 *)(unaff_RBP + 0x128) = uVar23;

-  *(undefined4 *)(unaff_RBP + 0x130) = uVar23;

-  *(undefined4 *)(unaff_RBP + 0x138) = param_3;

-  do {

-    fVar25 = *(float *)in_RAX;

-    fVar22 = *(float *)(param_1 + 0xc);

-    fVar24 = *(float *)(param_1 + 4);

-    fVar5 = *(float *)(param_1 + 0x14);

-    *(float *)in_RAX =

-         *(float *)(in_RAX + 4) * *(float *)(param_1 + 8) + fVar25 * *(float *)param_1 +

-         *(float *)(param_1 + 0x10);

-    *(float *)(in_RAX + 4) = *(float *)(in_RAX + 4) * fVar22 + fVar25 * fVar24 + fVar5;

-    in_RAX = in_RAX + 8;

-    in_RDX = in_RDX + -1;

-  } while (in_RDX != 0);

-  do {

-    if (param_9 == unaff_R12) {

-      uVar11 = (**(code **)(*_g_DeviceManager + 0x50))();

-      uVar8 = (uint)uVar11;

-      uVar11 = uVar11 & 0xffffffff;

-      if ((int)uVar8 < 0) {

-        uVar26 = 0x3cb;

-        goto LAB_0;

-      }

-      uVar11 = (**(code **)(*(longlong *)param_9 + 0x88))();

-      uVar8 = (uint)uVar11;

-      uVar11 = uVar11 & 0xffffffff;

-      if ((int)uVar8 < 0) {

-        uVar26 = 0x3cd;

-        goto LAB_0;

-      }

-      (**(code **)(*(longlong *)param_10 + 0x18))(param_10,1);

-    }

-    CPrimitiveGroup::AddFilledPolygonToD2DSink

-              ((ID2D1GeometrySink *)param_10,(D2D_POINT_2F *)(unaff_RBP + 0x120));

-    uVar20 = 0x7fffffff;

-    param_4 = unaff_RSI;

-    while( true ) {

-      if (unaff_R14 <= param_4) {

-        uVar16 = (ulonglong)unaff_R12 & 0xff;

-        CPrimitiveGroup::DataIterator<D2D1_COMPOSITOR_PRIMITIVE_DRAWING_STATE,148>::

-        DataIterator<D2D1_COMPOSITOR_PRIMITIVE_DRAWING_STATE,148>

-                  ((DataIterator<D2D1_COMPOSITOR_PRIMITIVE_DRAWING_STATE,148> *)&stack0x00000058,

-                   *(void **)(unaff_R15 + 0x1d8),*(__uint64 *)(unaff_R15 + 0x1e0));

-        goto LAB_1;

-      }

-      param_1 = param_4 + 0x11;

-      if ((unaff_R14 < param_4 + 0x10) || (unaff_R14 < param_1)) {

-        uVar26 = 0x361;

-        goto LAB_2;

-      }

-      if (param_4[0x10] != SUB81(unaff_R12,0)) {

-        unaff_RSI = param_4 + 0x29;

-        if (unaff_R14 < unaff_RSI) {

-          uVar26 = 0x36c;

-          goto LAB_2;

-        }

-        bVar6 = MILMatrix3x2::Is2DAxisAlignedPreservingApprox(param_1);

-        if (!bVar6) {

-          param_2 = *(undefined4 *)(param_4 + 4);

-          in_RAX = unaff_RBP + 0x120;

-          param_3 = *(undefined4 *)param_4;

-          in_RDX = 4;

-          uVar23 = *(undefined4 *)(param_4 + 8);

-          goto code_r0x0001802ef0db;

-        }

-        param_7 = 0;

-        param_8 = 0;

-        MILMatrix3x2::Transform2DBounds(param_1,(D2D_RECT_F *)param_4,(D2D_RECT_F *)&param_7);

-        bVar6 = IsPixelAligned((D2D_RECT_F *)&param_7);

-        if (!bVar6) {

-          *(float *)(unaff_RBP + 0x124) = param_7._4_4_;

-          *(float *)(unaff_RBP + 300) = param_7._4_4_;

-          fVar22 = (float)param_8;

-          fVar24 = param_8._4_4_;

-          fVar25 = (float)param_7;

-          goto LAB_3;

-        }

-        uVar8 = (uint)uVar20;

-        if (unaff_EDI < ((uint)param_8._4_4_ & uVar8)) {

-          iVar12 = (int)ROUND(param_8._4_4_) +

-                   (uint)((float)(int)ROUND(param_8._4_4_) - param_8._4_4_ <= unaff_XMM7_Da);

+  uVar4 = *(undefined8 *)(unaff_RDI + 8);

+  DVar8 = *(D2D1_EDGE_FLAGS *)(unaff_RDI + 0x10);

+  *(undefined8 *)(unaff_RBP + -0x40) = *(undefined8 *)unaff_RDI;

+  *(undefined8 *)(unaff_RBP + -0x38) = uVar4;

+  std::

+  _Variant_base<std::monostate,CEdgeFlagsMap::CRectangleMapStrategy,CEdgeFlagsMap::CPolygonMapStrategy>

+  ::_Reset((_Variant_base<std::monostate,CEdgeFlagsMap::CRectangleMapStrategy,CEdgeFlagsMap::CPolygonMapStrategy>

+            *)unaff_RDI);

+  pDVar9 = unaff_RDI;

+  std::

+  variant<std::monostate,CEdgeFlagsMap::CRectangleMapStrategy,CEdgeFlagsMap::CPolygonMapStrategy>::

+  _Emplace_valueless<0>

+            ((variant<std::monostate,CEdgeFlagsMap::CRectangleMapStrategy,CEdgeFlagsMap::CPolygonMapStrategy>

+              *)unaff_RDI);

+  std::

+  _Variant_base<std::monostate,CEdgeFlagsMap::CRectangleMapStrategy,CEdgeFlagsMap::CPolygonMapStrategy>

+  ::_Reset((_Variant_base<std::monostate,CEdgeFlagsMap::CRectangleMapStrategy,CEdgeFlagsMap::CPolygonMapStrategy>

+            *)pDVar9);

+  *(undefined8 *)unaff_RDI = 0;

+  *(undefined8 *)(unaff_RDI + 8) = 0;

+  _Var6 = std::_Get_size_of_n<48>(1);

+  pvVar7 = std::_Allocate<16,std::_Default_allocate_traits,0>(_Var6);

+  *(void **)pvVar7 = pvVar7;

+  *(void **)((longlong)pvVar7 + 8) = pvVar7;

+  *(void **)((longlong)pvVar7 + 0x10) = pvVar7;

+  *(undefined2 *)((longlong)pvVar7 + 0x18) = 0x101;

+  *(void **)unaff_RDI = pvVar7;

+  unaff_RDI[0x18] = (D2D_RECT_F)0x2;

+  CEdgeFlagsMap::CPolygonMapStrategy::AddEdgeFlags

+            ((CPolygonMapStrategy *)unaff_RDI,(D2D_RECT_F *)(unaff_RBP + -0x40),DVar8,

+             (Matrix3x3 *)0x0,unaff_XMM6_Da);

+  if (unaff_RDI[0x18] == (D2D_RECT_F)0x1) {

+    if (unaff_RDI != (D2D_RECT_F *)0x0) {

+      if (unaff_RSI == (Matrix3x3 *)0x0) {

+        bVar3 = 1.1920929e-06 < *(float *)unaff_R14 - *(float *)unaff_RDI;

+        if (bVar3) {

+          *(float *)(unaff_RBP + -0x40) = *(float *)unaff_R14;

         }

         else {

-          iVar12 = ((int)(float)((double)param_8._4_4_ +

-                                (double)CONCAT44(unaff_XMM6_Db,unaff_XMM6_Da)) << 10) >> 0xb;

+          *(float *)(unaff_RBP + -0x40) = *(float *)unaff_RDI;

         }

-        if (unaff_EDI < ((uint)(float)param_8 & uVar8)) {

-          iVar14 = (int)ROUND((float)param_8) +

-                   (uint)((float)(int)ROUND((float)param_8) - (float)param_8 <= unaff_XMM7_Da);

+        DVar8 = -(uint)bVar3 & 0x3000000;

+        if (*(float *)(unaff_R14 + 4) - *(float *)(unaff_RDI + 4) <= 1.1920929e-06) {

+          *(float *)(unaff_RBP + -0x3c) = *(float *)(unaff_RDI + 4);

         }

         else {

-          iVar14 = ((int)(float)((double)(float)param_8 +

-                                (double)CONCAT44(unaff_XMM6_Db,unaff_XMM6_Da)) << 10) >> 0xb;

+          *(float *)(unaff_RBP + -0x3c) = *(float *)(unaff_R14 + 4);

+          DVar8 = DVar8 | 3;

         }

-        if (unaff_EDI < ((uint)param_7._4_4_ & uVar8)) {

-          iVar17 = (int)ROUND(param_7._4_4_) +

-                   (uint)((float)(int)ROUND(param_7._4_4_) - param_7._4_4_ <= unaff_XMM7_Da);

+        if (*(float *)(unaff_RDI + 8) - *(float *)(unaff_R14 + 8) <= 1.1920929e-06) {

+          *(float *)(unaff_RBP + -0x38) = *(float *)(unaff_RDI + 8);

         }

         else {

-          iVar17 = ((int)(float)((double)param_7._4_4_ +

-                                (double)CONCAT44(unaff_XMM6_Db,unaff_XMM6_Da)) << 10) >> 0xb;

+          *(float *)(unaff_RBP + -0x38) = *(float *)(unaff_R14 + 8);

+          DVar8 = DVar8 | 0x300;

         }

-        if (unaff_EDI < ((uint)(float)param_7 & uVar8)) {

-          iVar18 = (int)ROUND((float)param_7) +

-                   (uint)((float)(int)ROUND((float)param_7) - (float)param_7 <= unaff_XMM7_Da);

+        if (*(float *)(unaff_RDI + 0xc) - *(float *)(unaff_R14 + 0xc) <= 1.1920929e-06) {

+          *(float *)(unaff_RBP + -0x34) = *(float *)(unaff_RDI + 0xc);

         }

         else {

-          iVar18 = ((int)(float)((double)(float)param_7 +

-                                (double)CONCAT44(unaff_XMM6_Db,unaff_XMM6_Da)) << 10) >> 0xb;

+          *(float *)(unaff_RBP + -0x34) = *(float *)(unaff_R14 + 0xc);

+          DVar8 = DVar8 | 0x30000;

         }

-        uVar8 = *(uint *)(unaff_RBP + 0x18);

-        *(int *)(unaff_RBP + -0x7c) = iVar17;

-        *(int *)(unaff_RBP + -0x80) = iVar18;

-        *(int *)(unaff_RBP + -0x78) = iVar14;

-        uVar26 = uVar8 + 1;

-        *(int *)(unaff_RBP + -0x74) = iVar12;

-        if (uVar26 < uVar8) {

-          uVar8 = 0x80070216;

-          uVar26 = 0xb5;

-          uVar11 = 0x80070216;

-        }

-        else {

-          if (uVar26 <= *(uint *)(unaff_RBP + 0x14)) {

-            iVar12 = *(int *)(unaff_RBP + -0x80);

-            iVar14 = *(int *)(unaff_RBP + -0x7c);

-            iVar17 = *(int *)(unaff_RBP + -0x78);

-            iVar18 = *(int *)(unaff_RBP + -0x74);

-            param_1 = unaff_RSI;

-            goto LAB_4;

-          }

-          uVar8 = DynArrayImpl<0>::AddMultipleAndSet(unaff_RBP,0x10,1,unaff_RBP + -0x80);

-          uVar11 = (ulonglong)uVar8;

-          if (-1 < (int)uVar8) goto LAB_5;

-          uVar26 = 0xc0;

-        }

-        MilInstrumentationCheckHR_MaybeFailFast

-                  (0x14,(long *)unaff_R12,(uint)unaff_R12,uVar8,uVar26,unaff_R12);

-        uVar26 = 0x37f;

-        goto LAB_0;

-      }

-      pDVar19 = (D2D_RECT_F *)param_4;

-      bVar6 = IsPixelAligned((D2D_RECT_F *)param_4);

-      unaff_RSI = param_1;

-      if (!bVar6) break;

-      fVar25 = *(float *)(pDVar19 + 0xc);

-      uVar8 = (uint)uVar20;

-      if (unaff_EDI < ((uint)fVar25 & uVar8)) {

-        iVar18 = (int)ROUND(fVar25) + (uint)((float)(int)ROUND(fVar25) - fVar25 <= unaff_XMM7_Da);

+        uVar4 = *(undefined8 *)(unaff_RBP + -0x40);

+        uVar5 = *(undefined8 *)(unaff_RBP + -0x38);

+        *(D2D1_EDGE_FLAGS *)(unaff_RDI + 0x10) =

+             ~DVar8 & *(D2D1_EDGE_FLAGS *)(unaff_RDI + 0x10) | DVar8 & unaff_R15D;

+        *(undefined8 *)unaff_RDI = uVar4;

+        *(undefined8 *)(unaff_RDI + 8) = uVar5;

       }

       else {

-        iVar18 = ((int)(float)((double)fVar25 + (double)CONCAT44(unaff_XMM6_Db,unaff_XMM6_Da)) << 10

-                 ) >> 0xb;

+        uVar1 = *(undefined4 *)(unaff_RSI + 4);

+        *(undefined4 *)(unaff_RBP + -0x30) = *(undefined4 *)unaff_RSI;

+        *(undefined4 *)(unaff_RBP + -0x28) = *(undefined4 *)(unaff_RSI + 0xc);

+        uVar2 = *(undefined4 *)(unaff_RSI + 0x18);

+        *(undefined4 *)(unaff_RBP + -0x2c) = uVar1;

+        uVar1 = *(undefined4 *)(unaff_RSI + 0x10);

+        *(undefined4 *)(unaff_RBP + -0x20) = uVar2;

+        *(undefined4 *)(unaff_RBP + -0x24) = uVar1;

+        uVar1 = *(undefined4 *)(unaff_RSI + 0x1c);

+        *(undefined8 *)(unaff_RBP + -0x40) = 0;

+        *(undefined8 *)(unaff_RBP + -0x38) = 0;

+        *(undefined4 *)(unaff_RBP + -0x1c) = uVar1;

+        D2DMatrixHelper::TransformRect_AxisAlignedPreserving

+                  (unaff_R14,(D2D_MATRIX_3X2_F *)(unaff_RBP + -0x30),

+                   (D2D_RECT_F *)(unaff_RBP + -0x40));

+        pDVar9 = unaff_RDI + 0x10;

+        DVar8 = D2DMatrixHelper::TransformEdgeFlags_AxisAlignedPreserving

+                          (unaff_R15D,(D2D_MATRIX_3X2_F *)(unaff_RBP + -0x30));

+        ClipRectAndEdgeFlags

+                  (unaff_RDI,*(D2D1_EDGE_FLAGS *)pDVar9,(D2D_RECT_F *)(unaff_RBP + -0x40),DVar8,

+                   unaff_RDI,(D2D1_EDGE_FLAGS *)pDVar9);

       }

-      fVar25 = *(float *)(param_4 + 8);

-      if (unaff_EDI < ((uint)fVar25 & uVar8)) {

-        iVar17 = (int)ROUND(fVar25) + (uint)((float)(int)ROUND(fVar25) - fVar25 <= unaff_XMM7_Da);

-      }

-      else {

-        iVar17 = ((int)(float)((double)fVar25 + (double)CONCAT44(unaff_XMM6_Db,unaff_XMM6_Da)) << 10

-                 ) >> 0xb;

-      }

-      fVar25 = *(float *)(param_4 + 4);

-      if (unaff_EDI < ((uint)fVar25 & uVar8)) {

-        iVar14 = (int)ROUND(fVar25) + (uint)((float)(int)ROUND(fVar25) - fVar25 <= unaff_XMM7_Da);

-      }

-      else {

-        iVar14 = ((int)(float)((double)fVar25 + (double)CONCAT44(unaff_XMM6_Db,unaff_XMM6_Da)) << 10

-                 ) >> 0xb;

-      }

-      fVar25 = *(float *)param_4;

-      if (unaff_EDI < ((uint)fVar25 & uVar8)) {

-        iVar12 = (int)ROUND(fVar25) + (uint)((float)(int)ROUND(fVar25) - fVar25 <= unaff_XMM7_Da);

-      }

-      else {

-        iVar12 = ((int)(float)((double)fVar25 + (double)CONCAT44(unaff_XMM6_Db,unaff_XMM6_Da)) << 10

-                 ) >> 0xb;

-      }

-      uVar8 = *(uint *)(unaff_RBP + 0x18);

-      uVar26 = uVar8 + 1;

-      iStack0000000000000070 = iVar12;

-      iStack0000000000000074 = iVar14;

-      iStack0000000000000078 = iVar17;

-      iStack000000000000007c = iVar18;

-      if (uVar26 < uVar8) {

-        uVar8 = 0x80070216;

-        uVar26 = 0xb5;

-        uVar11 = 0x80070216;

-LAB_6:

-        MilInstrumentationCheckHR_MaybeFailFast

-                  (0x14,(long *)unaff_R12,(uint)unaff_R12,uVar8,uVar26,unaff_R12);

-        uVar26 = 0x3b2;

-        goto LAB_0;

-      }

-      if (*(uint *)(unaff_RBP + 0x14) < uVar26) {

-        uVar8 = DynArrayImpl<0>::AddMultipleAndSet(unaff_RBP,0x10,1,&stack0x00000070);

-        uVar11 = (ulonglong)uVar8;

-        if ((int)uVar8 < 0) {

-          uVar26 = 0xc0;

-          goto LAB_6;

-        }

-LAB_5:

-        uVar11 = (ulonglong)uVar8;

-        uVar20 = 0x7fffffff;

-        param_1 = unaff_RSI;

-      }

-      else {

-LAB_4:

-        uVar11 = (ulonglong)unaff_R12 & 0xffffffff;

-        piVar2 = (int *)(*(longlong *)unaff_RBP + (ulonglong)uVar8 * 0x10);

-        *piVar2 = iVar12;

-        piVar2[1] = iVar14;

-        piVar2[2] = iVar17;

-        piVar2[3] = iVar18;

-        *(uint *)(unaff_RBP + 0x18) = uVar26;

-      }

-      unaff_EDI = 0x497ffff0;

-      param_4 = param_1;

     }

-    fVar24 = *(float *)(param_4 + 4);

-    fVar25 = *(float *)param_4;

-    fVar22 = *(float *)(param_4 + 8);

-    *(float *)(unaff_RBP + 0x124) = fVar24;

-    *(float *)(unaff_RBP + 300) = fVar24;

-    fVar24 = *(float *)(pDVar19 + 0xc);

-LAB_3:

-    *(float *)(unaff_RBP + 0x13c) = fVar24;

-    *(float *)(unaff_RBP + 0x138) = fVar25;

-    *(float *)(unaff_RBP + 0x134) = fVar24;

-    *(float *)(unaff_RBP + 0x130) = fVar22;

-    *(float *)(unaff_RBP + 0x128) = fVar22;

-    *(float *)(unaff_RBP + 0x120) = fVar25;

-  } while( true );

-LAB_1:

-  bVar6 = CPrimitiveGroup::DataIterator<D2D1_COMPOSITOR_DRAWING_STATE_const_,144>::HasMore

-                    ((DataIterator<D2D1_COMPOSITOR_DRAWING_STATE_const_,144> *)&stack0x00000058);

-  if (!bVar6) goto LAB_7;

-  pDVar9 = CPrimitiveGroup::DataIterator<D2D1_COMPOSITOR_DRAWING_STATE_const_,144>::CurrentItem

-                     ((DataIterator<D2D1_COMPOSITOR_DRAWING_STATE_const_,144> *)&stack0x00000058);

-  uVar26 = *(uint *)(pDVar9 + 4);

-  uVar8 = *(uint *)(pDVar9 + 0x10);

-  if (((uVar26 & 0x20) != 0) && (uVar8 != *(uint *)(unaff_R15 + 0x1b4))) {

-    unaff_R12 = (ID2D1PathGeometry *)0x1;

-LAB_8:

-    if (((ulonglong)uVar8 < *(ulonglong *)(unaff_R15 + 0x1f0)) &&

-       (((uVar13 = (ulonglong)*(uint *)(pDVar9 + 0x14) * 0x94, uVar13 < 0x100000000 &&

-         (uVar7 = (uint)uVar13 + uVar8, (uint)uVar13 <= uVar7)) &&

-        ((ulonglong)uVar7 <= *(ulonglong *)(unaff_R15 + 0x1f0))))) {

-      CPrimitiveGroup::DataIterator<D2D1_COMPOSITOR_PRIMITIVE_DRAWING_STATE,148>::

-      DataIterator<D2D1_COMPOSITOR_PRIMITIVE_DRAWING_STATE,148>

-                ((DataIterator<D2D1_COMPOSITOR_PRIMITIVE_DRAWING_STATE,148> *)(unaff_RBP + -0x80),

-                 (void *)(*(longlong *)(unaff_R15 + 0x1e8) + (ulonglong)uVar8),uVar13 & 0xffffffff);

-      while( true ) {

-        bVar6 = CPrimitiveGroup::DataIterator<D2D1_COMPOSITOR_PRIMITIVE_DRAWING_STATE_const_,148>::

-                HasMore((DataIterator<D2D1_COMPOSITOR_PRIMITIVE_DRAWING_STATE_const_,148> *)

-                        (unaff_RBP + -0x80));

-        uVar8 = (uint)uVar20;

-        if (!bVar6) break;

-        pDVar9 = CPrimitiveGroup::DataIterator<D2D1_COMPOSITOR_DRAWING_STATE_const_,144>::

-                 CurrentItem((DataIterator<D2D1_COMPOSITOR_DRAWING_STATE_const_,144> *)

-                             (unaff_RBP + -0x80));

-        this = (MILMatrix3x2 *)(pDVar9 + 0x10);

-        bVar6 = MILMatrix3x2::Is2DAxisAlignedPreservingApprox(this);

-        if (!bVar6) {

-          uVar23 = *(undefined4 *)(pDVar9 + 4);

-          pDVar10 = unaff_RBP + 0x120;

-          uVar4 = *(undefined4 *)pDVar9;

-          uVar3 = *(undefined4 *)(pDVar9 + 8);

-          *(undefined4 *)(unaff_RBP + 0x124) = uVar23;

-          *(undefined4 *)(unaff_RBP + 300) = uVar23;

-          uVar23 = *(undefined4 *)(pDVar9 + 0xc);

-          lVar15 = 4;

-          *(undefined4 *)(unaff_RBP + 0x134) = uVar23;

-          *(undefined4 *)(unaff_RBP + 0x13c) = uVar23;

-          *(undefined4 *)(unaff_RBP + 0x120) = uVar4;

-          *(undefined4 *)(unaff_RBP + 0x128) = uVar3;

-          *(undefined4 *)(unaff_RBP + 0x130) = uVar3;

-          *(undefined4 *)(unaff_RBP + 0x138) = uVar4;

-          do {

-            fVar25 = *(float *)pDVar10;

-            fVar22 = *(float *)(this + 0xc);

-            fVar24 = *(float *)(this + 4);

-            fVar5 = *(float *)(this + 0x14);

-            *(float *)pDVar10 =

-                 *(float *)(pDVar10 + 4) * *(float *)(this + 8) + fVar25 * *(float *)this +

-                 *(float *)(this + 0x10);

-            *(float *)(pDVar10 + 4) = *(float *)(pDVar10 + 4) * fVar22 + fVar25 * fVar24 + fVar5;

-            pDVar10 = pDVar10 + 8;

-            lVar15 = lVar15 + -1;

-          } while (lVar15 != 0);

-          uVar11 = FUN_1802ef408();

-          return uVar11;

-        }

-        param_7 = 0;

-        param_8 = 0;

-        MILMatrix3x2::Transform2DBounds(this,(D2D_RECT_F *)pDVar9,(D2D_RECT_F *)&param_7);

-        bVar6 = IsPixelAligned((D2D_RECT_F *)&param_7);

-        if (!bVar6) {

-          *(float *)(unaff_RBP + 0x124) = param_7._4_4_;

-          *(float *)(unaff_RBP + 300) = param_7._4_4_;

-          *(float *)(unaff_RBP + 0x134) = param_8._4_4_;

-          *(float *)(unaff_RBP + 0x13c) = param_8._4_4_;

-          *(float *)(unaff_RBP + 0x120) = (float)param_7;

-          *(float *)(unaff_RBP + 0x128) = (float)param_8;

-          *(float *)(unaff_RBP + 0x130) = (float)param_8;

-          *(float *)(unaff_RBP + 0x138) = (float)param_7;

-          uVar11 = FUN_1802ef408();

-          return uVar11;

-        }

-        if (unaff_EDI < ((uint)param_8._4_4_ & uVar8)) {

-          iStack000000000000007c =

-               (int)ROUND(param_8._4_4_) +

-               (uint)((float)(int)ROUND(param_8._4_4_) - param_8._4_4_ <= unaff_XMM7_Da);

-        }

-        else {

-          iStack000000000000007c =

-               ((int)(float)((double)param_8._4_4_ + (double)CONCAT44(unaff_XMM6_Db,unaff_XMM6_Da))

-               << 10) >> 0xb;

-        }

-        if (unaff_EDI < ((uint)(float)param_8 & uVar8)) {

-          iStack0000000000000078 =

-               (int)ROUND((float)param_8) +

-               (uint)((float)(int)ROUND((float)param_8) - (float)param_8 <= unaff_XMM7_Da);

-        }

-        else {

-          iStack0000000000000078 =

-               ((int)(float)((double)(float)param_8 + (double)CONCAT44(unaff_XMM6_Db,unaff_XMM6_Da))

-               << 10) >> 0xb;

-        }

-        if (unaff_EDI < ((uint)param_7._4_4_ & uVar8)) {

-          iStack0000000000000074 =

-               (int)ROUND(param_7._4_4_) +

-               (uint)((float)(int)ROUND(param_7._4_4_) - param_7._4_4_ <= unaff_XMM7_Da);

-        }

-        else {

-          iStack0000000000000074 =

-               ((int)(float)((double)param_7._4_4_ + (double)CONCAT44(unaff_XMM6_Db,unaff_XMM6_Da))

-               << 10) >> 0xb;

-        }

-        if (unaff_EDI < ((uint)(float)param_7 & uVar8)) {

-          iStack0000000000000070 =

-               (int)ROUND((float)param_7) +

-               (uint)((float)(int)ROUND((float)param_7) - (float)param_7 <= unaff_XMM7_Da);

-        }

-        else {

-          iStack0000000000000070 =

-               ((int)(float)((double)(float)param_7 + (double)CONCAT44(unaff_XMM6_Db,unaff_XMM6_Da))

-               << 10) >> 0xb;

-        }

-        uVar7 = *(uint *)(unaff_RBP + 0x18);

-        uVar8 = uVar7 + 1;

-        if (uVar8 < uVar7) {

-          uVar8 = 0x80070216;

-          uVar26 = 0xb5;

-          uVar11 = 0x80070216;

-LAB_9:

-          MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,uVar8,uVar26,(void *)0x0);

-          unaff_R12 = (ID2D1PathGeometry *)0x0;

-          uVar26 = 0x419;

-          goto LAB_0;

-        }

-        if (*(uint *)(unaff_RBP + 0x14) < uVar8) {

-          uVar8 = DynArrayImpl<0>::AddMultipleAndSet(unaff_RBP,0x10,1,&stack0x00000070);

-          uVar11 = (ulonglong)uVar8;

-          uVar13 = (ulonglong)uVar8;

-          if ((int)uVar8 < 0) {

-            uVar26 = 0xc0;

-            goto LAB_9;

-          }

-        }

-        else {

-          puVar1 = (undefined8 *)(*(longlong *)unaff_RBP + (ulonglong)uVar7 * 0x10);

-          *puVar1 = CONCAT44(iStack0000000000000074,iStack0000000000000070);

-          puVar1[1] = CONCAT44(iStack000000000000007c,iStack0000000000000078);

-          *(uint *)(unaff_RBP + 0x18) = uVar8;

-          uVar13 = 0;

-        }

-        uVar11 = uVar13;

-        unaff_EDI = 0x497ffff0;

-        CPrimitiveGroup::DataIterator<D2D1_COMPOSITOR_PRIMITIVE_DRAWING_STATE_const_,148>::Step

-                  ((DataIterator<D2D1_COMPOSITOR_PRIMITIVE_DRAWING_STATE_const_,148> *)

-                   (unaff_RBP + -0x80));

-        uVar20 = 0x7fffffff;

-      }

-      goto LAB_10;

-    }

-    unaff_R12 = (ID2D1PathGeometry *)0x0;

-    uVar26 = 0x3fb;

-LAB_2:

-    uVar8 = 0x80004005;

-    uVar11 = 0x80004005;

-    goto LAB_0;

   }

-  if (((byte)uVar16 == 0) && (((byte)pDVar9[4] & 2) == 0)) goto LAB_8;

-LAB_10:

-  CPrimitiveGroup::DataIterator<D2D1_COMPOSITOR_DRAWING_STATE_const_,144>::Step

-            ((DataIterator<D2D1_COMPOSITOR_DRAWING_STATE_const_,144> *)&stack0x00000058);

-  bVar21 = (byte)unaff_R12;

-  unaff_R12 = (ID2D1PathGeometry *)0x0;

-  if ((uVar26 & 0x20) == 0) {

-    bVar21 = (byte)uVar16;

+  else if ((unaff_RDI[0x18] == (D2D_RECT_F)0x2) && (unaff_RDI != (D2D_RECT_F *)0x0)) {

+    CEdgeFlagsMap::CPolygonMapStrategy::AddEdgeFlags

+              ((CPolygonMapStrategy *)unaff_RDI,unaff_R14,unaff_R15D,unaff_RSI,unaff_XMM6_Da);

   }

-  uVar16 = (ulonglong)bVar21;

-  goto LAB_1;

-LAB_7:

-  if (param_10 != (ID2D1Geometry *)0x0) {

-    uVar11 = (**(code **)(*(longlong *)param_10 + 0x48))();

-    uVar8 = (uint)uVar11;

-    uVar11 = uVar11 & 0xffffffff;

-    if ((int)uVar8 < 0) {

-      uVar26 = 0x460;

-LAB_0:

-      MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,uVar8,uVar26,unaff_R12);

-      goto LAB_11;

-    }

-    *(ID2D1PathGeometry **)(unaff_R15 + 0x60) = param_9;

-    param_9 = unaff_R12;

-  }

-  if (*(uint *)(unaff_RBP + 0x18) != 0) {

-    *(undefined ***)(unaff_RBP + -0x60) = &CRegionShape::_vftable_;

-    *(ID2D1PathGeometry **)(unaff_RBP + -0x58) = unaff_R12;

-    *(DynArrayImpl<0> **)(unaff_RBP + -0x50) = unaff_RBP + -0x48;

-    *(int *)(unaff_RBP + -0x48) = (int)unaff_R12;

-    *(ID2D1PathGeometry **)(unaff_RBP + -8) = unaff_R12;

-    CRegionShape::BuildFromRects

-              ((CRegionShape *)(unaff_RBP + -0x60),

-               *(TMilRect_<int,tagRECT,D2D_POINTANDSIZE_L,Mil3DRectL,RectUniqueness::_CMilRectL_> **

-                )unaff_RBP,*(uint *)(unaff_RBP + 0x18));

-    uVar8 = CRegionShape::GetD2DGeometry

-                      ((CRegionShape *)(unaff_RBP + -0x60),(CMILMatrix *)0x0,

-                       (ID2D1Geometry **)(unaff_R15 + 0x58));

-    uVar11 = (ulonglong)uVar8;

-    if ((int)uVar8 < 0) {

-      MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,uVar8,0x471,unaff_R12);

-      CRegionShape::~CRegionShape((CRegionShape *)(unaff_RBP + -0x60));

-      goto LAB_11;

-    }

-    CRegionShape::~CRegionShape((CRegionShape *)(unaff_RBP + -0x60));

-  }

-  *(undefined1 *)(unaff_R15 + 0x68) = 1;

-LAB_11:

-  ReleaseInterfaceNoNULL<ID2D1Geometry>(param_10);

-  ReleaseInterfaceNoNULL<ID2D1PathGeometry>(param_9);

-  DynArrayImpl<0>::~DynArrayImpl<0>(unaff_RBP);

-  return uVar11 & 0xffffffff;

+  return;

 }
```

## `CCompositionMagnifierBrush::GetBackdropSourceRect`  (modified)

```diff
--- CCompositionMagnifierBrush::GetBackdropSourceRect
+++ CCompositionMagnifierBrush::GetBackdropSourceRect
@@ -1,2 +1,142 @@
-Failed to decompile dwmcore.dll - .ProgramDB CCompositionMagnifierBrush::GetBackdropSourceRect : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: class TMilRect_<float,struct D2D_RECT_F,struct D3D_RECT_F,struct

+   D2D_POINTANDSIZE_F,struct RectUniqueness::NotNeeded> __cdecl

+   CCompositionMagnifierBrush::GetBackdropSourceRect(class CVisualTree const * __ptr64,class

+   TMilRect_<float,struct D2D_RECT_F,struct D3D_RECT_F,struct D2D_POINTANDSIZE_F,struct

+   RectUniqueness::NotNeeded> const & __ptr64)const __ptr64 */

+

+CVisualTree * __thiscall

+CCompositionMagnifierBrush::GetBackdropSourceRect

+          (CCompositionMagnifierBrush *this,CVisualTree *param_1,

+          TMilRect_<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_D2D_POINTANDSIZE_F,struct_RectUniqueness::NotNeeded>

+          *param_2)

+

+{

+  int *piVar1;

+  float fVar2;

+  float fVar3;

+  float fVar4;

+  float fVar5;

+  longlong lVar6;

+  float fVar7;

+  float fVar8;

+  int *piVar9;

+  char cVar10;

+  bool bVar11;

+  CVisualTree *this_00;

+  CVisual *pCVar12;

+  undefined8 uVar13;

+  undefined1 *puVar14;

+  int *piVar15;

+  uint uVar16;

+  CVisualTree *pCVar17;

+  float *in_R9;

+  float fVar18;

+  float fVar19;

+  undefined4 uVar20;

+  undefined4 uVar21;

+  float local_res8;

+  float fStackX_c;

+  undefined1 auStack_108 [32];

+  undefined8 local_e8;

+  uint local_e0;

+  longlong local_d8;

+  uint local_d0;

+  undefined4 uStack_cc;

+  

+  fVar2 = in_R9[2];

+  fVar3 = *in_R9;

+  fVar4 = in_R9[3];

+  fVar5 = in_R9[1];

+  fVar18 = (fVar2 - fVar3) / *(float *)(this + 0x68);

+  fVar19 = (fVar4 - fVar5) / *(float *)(this + 0x68);

+  _local_res8 = CONCAT44(fVar19,fVar18);

+  puVar14 = (undefined1 *)register0x00000020;

+  if (this[200] == (CCompositionMagnifierBrush)0x0) {

+    if (this[0xcc] != (CCompositionMagnifierBrush)0x0) {

+      CComposition::GetCursorVisuals(*(CComposition **)(this + 0x18));

+      this_00 = CVisualTree::GetRootVisualTree((CVisualTree *)param_2);

+      piVar9 = (int *)CONCAT44(uStack_cc,local_d0);

+      if (piVar9 != piVar9 + local_d8 * 0xc) {

+        uVar20 = (undefined4)local_d8;

+        uVar21 = (undefined4)((ulonglong)local_d8 >> 0x20);

+        piVar15 = piVar9 + 8;

+        do {

+          pCVar12 = CExcludeVisualReference::GetVisualNoRef

+                              ((CExcludeVisualReference *)(piVar15 + -8));

+          local_e0 = local_e0 & 0xffffff00;

+          cVar10 = (**(code **)(*(longlong *)pCVar12 + 0x40))(pCVar12,0x30);

+          if (cVar10 == '\0') {

+            if (((*(uint *)(pCVar12 + 0x60) & 0x100) != 0) &&

+               (bVar11 = CVisualTree::_IsInTree(this_00,pCVar12,0), bVar11)) {

+              if (pCVar12 == *(CVisual **)(this_00 + 0x48)) {

+                pCVar17 = this_00 + 0x50;

+              }

+              else {

+                pCVar17 = (CVisualTree *)(pCVar12 + 0x98);

+              }

+              fVar7 = *(float *)pCVar17;

+              fVar8 = *(float *)(pCVar17 + 4);

+              local_e8 = *(undefined8 *)pCVar17;

+              uVar16 = 1;

+              local_e0 = CONCAT31(local_e0._1_3_,1);

+              bVar11 = wil::details::

+                       FeatureImpl<__WilFeatureTraits_Feature_CompositionMagnifier_Iter2>::

+                       __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_CompositionMagnifier_Iter2>

+                                            *)&`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_CompositionMagnifier_Iter2>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_CompositionMagnifier_Iter2>::GetImpl(void)'

+                                               ::__l2::impl);

+              puVar14 = auStack_108;

+              if (((bVar11) &&

+                  (bVar11 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>::

+                            __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>

+                                                 *)&

+                                                  `private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DesktopDWMCursor>::GetImpl(void)'

+                                                  ::__l2::impl), puVar14 = auStack_108, !bVar11)) &&

+                 (puVar14 = auStack_108, (char)piVar15[2] != '\0')) {

+                local_e8 = CONCAT44((float)piVar15[1] + fVar8,(float)*piVar15 + fVar7);

+                goto LAB_0;

+              }

+              goto LAB_1;

+            }

+          }

+          else {

+            lVar6 = *(longlong *)(pCVar12 + 0x2c8);

+            uVar16 = local_d0 >> 8;

+            local_d0 = local_d0 & 0xffffff00;

+            if (lVar6 != 0) {

+              uVar21 = *(undefined4 *)(lVar6 + 0xe0);

+              uVar20 = *(undefined4 *)(lVar6 + 0xdc);

+              local_d0 = CONCAT31((int3)uVar16,1);

+            }

+            local_e0 = local_d0;

+            local_e8 = CONCAT44(uVar21,uVar20);

+            uVar16 = local_d0;

+LAB_0:

+            puVar14 = auStack_108;

+            if ((char)uVar16 != '\0') goto LAB_1;

+          }

+          piVar1 = piVar15 + 4;

+          piVar15 = piVar15 + 0xc;

+        } while (piVar1 != piVar9 + local_d8 * 0xc);

+      }

+    }

+    local_res8 = ((fVar2 - fVar3) - fVar18) * 0.5 + *in_R9;

+    fStackX_c = ((fVar4 - fVar5) - fVar19) * 0.5 + in_R9[1];

+  }

+  else {

+LAB_1:

+    uVar13 = ClampMagnificationRectToClientBounds

+                       ((CVisualTree *)param_2,(D2D_POINT_2F *)(puVar14 + 0x20),

+                        (D2D_SIZE_F *)&local_res8);

+    local_res8 = (float)uVar13;

+    fStackX_c = (float)((ulonglong)uVar13 >> 0x20);

+  }

+  *(float *)param_1 = local_res8;

+  *(float *)(param_1 + 4) = fStackX_c;

+  *(float *)(param_1 + 8) = local_res8 + fVar18;

+  *(float *)(param_1 + 0xc) = fStackX_c + fVar19;

+  return param_1;

+}

+
```

## `CSurfaceBrush::OnChanged`  (modified)

```diff
--- CSurfaceBrush::OnChanged
+++ CSurfaceBrush::OnChanged
@@ -1,2 +1,70 @@
-Failed to decompile dwmcore.dll - .ProgramDB CSurfaceBrush::OnChanged : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* protected: virtual int __cdecl CSurfaceBrush::OnChanged(enum NotificationEventArgs::Flags,struct

+   IUnknown * __ptr64) __ptr64 */

+

+int __thiscall CSurfaceBrush::OnChanged(CSurfaceBrush *this,Flags param_1,IUnknown *param_2)

+

+{

+  longlong *plVar1;

+  code *pcVar2;

+  bool bVar3;

+  char cVar4;

+  CResource *pCVar5;

+  undefined **ppuVar6;

+  

+  bVar3 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2>::__private_IsEnabled

+                    ((FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2> *)

+                     &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DCompChromiumK2>::GetImpl(void)'

+                      ::__l2::impl);

+  if ((!bVar3) || (plVar1 = *(longlong **)(this + 0x80), plVar1 == (longlong *)0x0)) {

+LAB_0:

+    if (((param_1 != 0) && (*(longlong *)(this + 0x80) != 0)) &&

+       (*(longlong *)(this + 0x58) == *(longlong *)(this + 0x80))) {

+      plVar1 = *(longlong **)(this + 0x88);

+      pcVar2 = *(code **)(*plVar1 + 0x30);

+      pCVar5 = GetSurface(this);

+      cVar4 = (*pcVar2)(plVar1,pCVar5);

+      return (int)(cVar4 != '\0');

+    }

+    return 1;

+  }

+  cVar4 = (**(code **)(*plVar1 + 0x40))(plVar1,0x22);

+  if ((cVar4 == '\0') || (*(longlong *)(this + 0x58) != *(longlong *)(this + 0x80)))

+  goto LAB_0;

+  pCVar5 = GetSurface(this);

+  if (pCVar5 == (CResource *)0x0) {

+    ppuVar6 = &PTR__vftable__1802fc048;

+  }

+  else {

+    cVar4 = (**(code **)(*(longlong *)pCVar5 + 0x40))(pCVar5,0x29);

+    if (cVar4 == '\0') {

+      cVar4 = (**(code **)(*(longlong *)pCVar5 + 0x40))(pCVar5,0x29);

+      if (cVar4 == '\0') {

+        cVar4 = (**(code **)(*(longlong *)pCVar5 + 0x40))(pCVar5,0xd);

+        if (cVar4 == '\0') {

+          cVar4 = (**(code **)(*(longlong *)pCVar5 + 0x40))(pCVar5,0xba);

+          if (cVar4 == '\0') {

+            cVar4 = (**(code **)(*(longlong *)pCVar5 + 0x40))(pCVar5,0x74);

+            if (cVar4 == '\0') goto LAB_1;

+            ppuVar6 = &PTR__vftable__1802fe360;

+          }

+          else {

+            ppuVar6 = &PTR__vftable__1802fe358;

+          }

+          goto LAB_2;

+        }

+      }

+      ppuVar6 = &PTR__vftable__1802fc050;

+    }

+    else {

+      ppuVar6 = &PTR__vftable__1802fe368;

+    }

+  }

+LAB_2:

+  *(undefined ***)(this + 0x88) = ppuVar6;

+LAB_1:

+  return (int)(param_1 != 0x11);

+}

+
```

## `CSurfaceBrush::ProcessSetSurface`  (modified)

```diff
--- CSurfaceBrush::ProcessSetSurface
+++ CSurfaceBrush::ProcessSetSurface
@@ -1,2 +1,124 @@
-Failed to decompile dwmcore.dll - .ProgramDB CSurfaceBrush::ProcessSetSurface : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: long __cdecl CSurfaceBrush::ProcessSetSurface(class CResourceTable * __ptr64,struct

+   tagMILCMD_SURFACEBRUSH_SETSURFACE const * __ptr64) __ptr64 */

+

+long __thiscall

+CSurfaceBrush::ProcessSetSurface

+          (CSurfaceBrush *this,CResourceTable *param_1,tagMILCMD_SURFACEBRUSH_SETSURFACE *param_2)

+

+{

+  uint uVar1;

+  bool bVar2;

+  long lVar3;

+  CResource *pCVar4;

+  TMilRect_<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_D2D_POINTANDSIZE_F,struct_RectUniqueness::NotNeeded>

+  *pTVar5;

+  TMilRect_<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_D2D_POINTANDSIZE_F,struct_RectUniqueness::NotNeeded>

+  *pTVar7;

+  undefined **ppuVar8;

+  undefined1 auStackY_d8 [32];

+  float local_a8;

+  float local_a4;

+  float local_a0;

+  float local_9c;

+  float local_98;

+  float fStack_94;

+  float fStack_90;

+  float fStack_8c;

+  ulonglong local_88;

+  TMilRect_<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_D2D_POINTANDSIZE_F,struct_RectUniqueness::NotNeeded>

+  *pTVar6;

+  

+  local_88 = __security_cookie ^ (ulonglong)auStackY_d8;

+  uVar1 = *(uint *)(param_2 + 8);

+  if (((uVar1 == 0) || (*(uint *)(param_1 + 0x1c) <= uVar1)) ||

+     (*(int *)((ulonglong)(uVar1 * *(int *)(param_1 + 0x18)) + *(longlong *)(param_1 + 0x28)) == 0))

+  {

+    pCVar4 = (CResource *)0x0;

+  }

+  else {

+    pCVar4 = *(CResource **)

+              ((ulonglong)(uVar1 * *(int *)(param_1 + 0x18)) + 8 + *(longlong *)(param_1 + 0x28));

+  }

+  pTVar6 = (TMilRect_<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_D2D_POINTANDSIZE_F,struct_RectUniqueness::NotNeeded>

+            *)0x0;

+  pTVar5 = (TMilRect_<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_D2D_POINTANDSIZE_F,struct_RectUniqueness::NotNeeded>

+            *)0x0;

+  ppuVar8 = (undefined **)0x0;

+  local_a8 = (float)*(int *)(param_2 + 0xc);

+  local_a4 = (float)*(int *)(param_2 + 0x10);

+  local_a0 = (float)*(int *)(param_2 + 0x14);

+  local_9c = (float)*(int *)(param_2 + 0x18);

+  local_98 = 0.0;

+  fStack_94 = 0.0;

+  fStack_90 = 0.0;

+  fStack_8c = 0.0;

+  pTVar7 = pTVar6;

+  if (param_2[0x2c] != (tagMILCMD_SURFACEBRUSH_SETSURFACE)0x0) {

+    ppuVar8 = &PTR__vftable__1802fc050;

+    if ((float)*(int *)(param_2 + 0x1c) <= -3.4028235e+38) {

+      local_98 = -3.4028235e+38;

+    }

+    else {

+      local_98 = (float)*(int *)(param_2 + 0x1c) - 0.5;

+    }

+    if ((float)*(int *)(param_2 + 0x20) <= -3.4028235e+38) {

+      fStack_94 = -3.4028235e+38;

+    }

+    else {

+      fStack_94 = (float)*(int *)(param_2 + 0x20) - 0.5;

+    }

+    if (3.4028235e+38 <= (float)*(int *)(param_2 + 0x24)) {

+      fStack_90 = 3.4028235e+38;

+    }

+    else {

+      fStack_90 = (float)*(int *)(param_2 + 0x24) + 0.5;

+    }

+    if (3.4028235e+38 <= (float)*(int *)(param_2 + 0x28)) {

+      fStack_8c = 3.4028235e+38;

+    }

+    else {

+      fStack_8c = (float)*(int *)(param_2 + 0x28) + 0.5;

+    }

+    if (local_98 < local_a8) {

+      local_98 = local_a8;

+    }

+    if (fStack_94 < local_a4) {

+      fStack_94 = local_a4;

+    }

+    if (local_a0 < fStack_90) {

+      fStack_90 = local_a0;

+    }

+    if (local_9c < fStack_8c) {

+      fStack_8c = local_9c;

+    }

+    if ((fStack_90 <= local_98) || (fStack_8c <= fStack_94)) {

+      fStack_8c = 0.0;

+      fStack_90 = 0.0;

+      fStack_94 = 0.0;

+      local_98 = 0.0;

+      pTVar7 = pTVar5;

+    }

+    else if (((((local_98 != local_a8) || (fStack_94 != local_a4)) ||

+              ((fStack_90 != local_a0 || (fStack_8c != local_9c)))) &&

+             (((local_98 < fStack_90 && (fStack_94 < fStack_8c)) ||

+              ((pTVar7 = pTVar5, local_a8 < local_a0 && (local_a4 < local_9c)))))) &&

+            ((((-3.4028235e+38 < local_98 || (fStack_90 < 3.4028235e+38)) &&

+              ((-3.4028235e+38 < fStack_94 || (fStack_8c < 3.4028235e+38)))) ||

+             (bVar2 = TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded>::IsInfinite

+                                ((TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded> *)

+                                 &local_a8), pTVar7 = pTVar6, !bVar2)))) {

+      pTVar7 = (TMilRect_<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_D2D_POINTANDSIZE_F,struct_RectUniqueness::NotNeeded>

+                *)&local_98;

+    }

+  }

+  lVar3 = SetSurface(this,pCVar4,

+                     (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                      *)&local_a8,pTVar7,(CSurfaceRenderStrategy *)ppuVar8);

+  if (lVar3 < 0) {

+    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar3,0xf5,(void *)0x0);

+  }

+  return lVar3;

+}

+
```

## `CCompositionSurfaceBitmap::UseLayoutSizeForBounds`  (modified)

```diff
--- CCompositionSurfaceBitmap::UseLayoutSizeForBounds
+++ CCompositionSurfaceBitmap::UseLayoutSizeForBounds
@@ -1,21 +1,33 @@
 

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* private: bool __cdecl CCompositionSurfaceBitmap::UseLayoutSizeForBounds(struct D2D_SIZE_F const &

+   __ptr64)const __ptr64 */

 

 bool __thiscall

-ShrinkableArray<CBatchCommand*___ptr64,UniqueLifetime<CBatchCommand*___ptr64>_>::

-UseLayoutSizeForBounds(CCompositionSurfaceBitmap *this,D2D_SIZE_F *param_1)

+CCompositionSurfaceBitmap::UseLayoutSizeForBounds

+          (CCompositionSurfaceBitmap *this,D2D_SIZE_F *param_1)

 

 {

-  longlong unaff_RDI;

-  long unaff_R14D;

-  void *in_stack_00000028;

+  bool bVar1;

+  SizePreference SVar2;

+  bool bVar3;

   

-  MilInstrumentationCheckHR_MaybeFailFast

-            ((int)param_1 + 0x14,(long *)param_1,0,unaff_R14D,0x1212,in_stack_00000028);

-  if (*(int *)(unaff_RDI + 0x110) != 0) {

-    *(int *)(unaff_RDI + 0x110) = *(int *)(unaff_RDI + 0x110) + -1;

+  if ((0.0 < *(float *)param_1) && (0.0 < *(float *)(param_1 + 4))) {

+    bVar1 = HasSwapChainAttributes(this);

+    bVar3 = true;

+    if (bVar1) goto LAB_0;

   }

-  MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,unaff_R14D,0x11f9,(void *)0x0);

-  return SUB41(unaff_R14D,0);

+  bVar3 = false;

+LAB_0:

+  bVar1 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2>::__private_IsEnabled

+                    ((FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2> *)

+                     &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DCompChromiumK2>::GetImpl(void)'

+                      ::__l2::impl);

+  if ((bVar1) && (bVar3 != false)) {

+    SVar2 = GetSizePreference(this);

+    if (SVar2 == 3) {

+      bVar3 = false;

+    }

+  }

+  return bVar3;

 }
```

## `CSwapchainRenderStrategy::HasSwapChainContent`  (modified)

```diff
--- CSwapchainRenderStrategy::HasSwapChainContent
+++ CSwapchainRenderStrategy::HasSwapChainContent
@@ -1,2 +1,16 @@
-Failed to decompile dwmcore.dll - .ProgramDB CSwapchainRenderStrategy::HasSwapChainContent : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: virtual bool __cdecl CSwapchainRenderStrategy::HasSwapChainContent(class CSurfaceBrush

+   const * __ptr64)const __ptr64 */

+

+bool __thiscall

+CSwapchainRenderStrategy::HasSwapChainContent(CSwapchainRenderStrategy *this,CSurfaceBrush *param_1)

+

+{

+  bool bVar1;

+  CResource *this_00;

+  

+  this_00 = CSurfaceBrush::GetSurface(param_1);

+  bVar1 = CCompositionSurfaceBitmap::HasSwapChainAttributes((CCompositionSurfaceBitmap *)this_00);

+  return bVar1;

+}

+
```

## `CVisualSurfaceRenderStrategy::IsReadyToDraw`  (modified)

```diff
--- CVisualSurfaceRenderStrategy::IsReadyToDraw
+++ CVisualSurfaceRenderStrategy::IsReadyToDraw
@@ -1,2 +1,23 @@
-Failed to decompile dwmcore.dll - .ProgramDB CVisualSurfaceRenderStrategy::IsReadyToDraw : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: virtual bool __cdecl CVisualSurfaceRenderStrategy::IsReadyToDraw(class CSurfaceBrush

+   const * __ptr64,class CDrawingContext * __ptr64,bool * __ptr64)const __ptr64 */

+

+bool __thiscall

+CVisualSurfaceRenderStrategy::IsReadyToDraw

+          (CVisualSurfaceRenderStrategy *this,CSurfaceBrush *param_1,CDrawingContext *param_2,

+          bool *param_3)

+

+{

+  CResource *pCVar1;

+  bool bVar2;

+  

+  bVar2 = false;

+  *param_3 = false;

+  pCVar1 = CSurfaceBrush::GetSurface(param_1);

+  if (((*(longlong *)(pCVar1 + 0x48) != 0) && (0.0 < *(float *)(pCVar1 + 0xb8))) &&

+     (0.0 < *(float *)(pCVar1 + 0xbc))) {

+    bVar2 = true;

+  }

+  return bVar2;

+}

+
```

## `CSpriteVisual::HasNonEmptyContent`  (modified)

```diff
--- CSpriteVisual::HasNonEmptyContent
+++ CSpriteVisual::HasNonEmptyContent
@@ -1,2 +1,220 @@
-Failed to decompile dwmcore.dll - .ProgramDB CSpriteVisual::HasNonEmptyContent : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: virtual bool __cdecl CSpriteVisual::HasNonEmptyContent(void)const __ptr64 */

+

+bool __thiscall CSpriteVisual::HasNonEmptyContent(CSpriteVisual *this)

+

+{

+  uint uVar1;

+  uint *puVar2;

+  longlong lVar3;

+  bool bVar4;

+  char cVar5;

+  char cVar6;

+  CResource *pCVar7;

+  vector<CProjectedShadowReceiver*___ptr64,std::allocator<CProjectedShadowReceiver*___ptr64>_>

+  *pvVar8;

+  code *pcVar9;

+  uint uVar10;

+  CSurfaceBrush *pCVar11;

+  CEffectBrush *this_00;

+  uint *puVar13;

+  longlong *plVar14;

+  bool local_res8 [8];

+  bool local_res10 [8];

+  char local_res18 [8];

+  IBitmapResource *local_res20;

+  IBitmapResource *local_58 [4];

+  longlong *plVar12;

+  

+  pCVar11 = *(CSurfaceBrush **)(this + 0x100);

+  plVar14 = (longlong *)0x0;

+  if (pCVar11 == (CSurfaceBrush *)0x0) goto LAB_0;

+  pcVar9 = *(code **)(*(longlong *)pCVar11 + 0xd8);

+  if (pcVar9 == CBrush::IsEmptyDrawing) {

+    pcVar9 = *(code **)(*(longlong *)pCVar11 + 0x138);

+    local_res8[0] = false;

+    if (pcVar9 == CSurfaceBrush::IsReadyToDraw) {

+      pcVar9 = *(code **)**(undefined8 **)(pCVar11 + 0x88);

+      if (pcVar9 == CBitmapRenderStrategy::IsReadyToDraw) {

+        local_res20 = (IBitmapResource *)0x0;

+        wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::reset

+                  ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res20);

+        CBitmapRenderStrategy::GetBitmap(pCVar11,&local_res20);

+        cVar6 = CBitmapRenderStrategy::HasRenderingRealization(local_res20);

+        wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::

+        ~com_ptr_t<IBitmapResource,wil::err_returncode_policy>

+                  ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res20);

+      }

+      else if (pcVar9 == CPrimitiveGroupRenderStrategy::IsReadyToDraw) {

+LAB_1:

+        pCVar7 = CSurfaceBrush::GetSurface(pCVar11);

+        if (*(code **)(*(longlong *)pCVar7 + 0xd8) == CPrimitiveGroup::IsEmptyDrawing) {

+          local_res8[0] = CPrimitiveGroup::IsEmptyDrawing((CPrimitiveGroup *)pCVar7);

+        }

+        else {

+          local_res8[0] = (bool)(**(code **)(*(longlong *)pCVar7 + 0xd8))();

+        }

+        cVar6 = '\x01';

+      }

+      else if (pcVar9 == CVisualSurfaceRenderStrategy::IsReadyToDraw) {

+        pCVar7 = CSurfaceBrush::GetSurface(pCVar11);

+        cVar6 = CVisualSurface::HasSomethingToDraw((CVisualSurface *)pCVar7);

+      }

+      else {

+        cVar6 = (*pcVar9)(*(undefined8 **)(pCVar11 + 0x88),pCVar11,0,local_res8);

+      }

+      goto LAB_2;

+    }

+    if (pcVar9 == CMaskBrush::IsReadyToDraw) {

+      this_00 = *(CEffectBrush **)(pCVar11 + 0x78);

+      cVar6 = '\0';

+      local_res10[0] = false;

+      local_res18[0] = '\0';

+      if (this_00 != (CEffectBrush *)0x0) {

+        pcVar9 = *(code **)(*(longlong *)this_00 + 0x138);

+        if (pcVar9 == CGradientBrush::IsReadyToDraw) {

+          local_res10[0] =

+               std::vector<CColorGradientStop*___ptr64,std::allocator<CColorGradientStop*___ptr64>_>

+               ::empty((vector<CColorGradientStop*___ptr64,std::allocator<CColorGradientStop*___ptr64>_>

+                        *)(this_00 + 0xa8));

+          bVar4 = std::

+                  vector<CColorGradientStop*___ptr64,std::allocator<CColorGradientStop*___ptr64>_>::

+                  empty((vector<CColorGradientStop*___ptr64,std::allocator<CColorGradientStop*___ptr64>_>

+                         *)(this_00 + 0xa8));

+          cVar5 = !bVar4;

+LAB_3:

+          if (cVar5 != '\0') {

+LAB_4:

+            plVar12 = *(longlong **)(pCVar11 + 0x70);

+            if ((plVar12 == (longlong *)0x0) ||

+               (cVar5 = (**(code **)(*plVar12 + 0x138))(plVar12,0,local_res18), cVar5 != '\0')) {

+              cVar6 = '\x01';

+            }

+          }

+        }

+        else {

+          if (pcVar9 != CColorBrush::IsReadyToDraw) {

+            if (pcVar9 == CEffectBrush::IsReadyToDraw) {

+              cVar5 = CEffectBrush::IsReadyToDraw(this_00,(CDrawingContext *)0x0,local_res10);

+            }

+            else {

+              cVar5 = (*pcVar9)(this_00,0);

+            }

+            goto LAB_3;

+          }

+          local_res10[0] = IsCloseRealZero(*(float *)(this_00 + 0x74),1.1920929e-06);

+          if (!NAN(*(float *)(this_00 + 0x74))) goto LAB_4;

+        }

+        if ((local_res10[0] != false) || (local_res18[0] != '\0')) {

+          local_res8[0] = true;

+          goto LAB_2;

+        }

+      }

+      local_res8[0] = false;

+    }

+    else if (pcVar9 == CNineGridBrush::IsReadyToDraw) {

+      pCVar11 = *(CSurfaceBrush **)(pCVar11 + 0x68);

+      if (pCVar11 == (CSurfaceBrush *)0x0) goto LAB_0;

+      pcVar9 = *(code **)(*(longlong *)pCVar11 + 0x138);

+      if (pcVar9 == CSurfaceBrush::IsReadyToDraw) {

+        pcVar9 = *(code **)**(undefined8 **)(pCVar11 + 0x88);

+        if (pcVar9 == CBitmapRenderStrategy::IsReadyToDraw) {

+          local_58[0] = (IBitmapResource *)0x0;

+          wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::reset

+                    ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)local_58);

+          CBitmapRenderStrategy::GetBitmap(pCVar11,local_58);

+          cVar6 = CBitmapRenderStrategy::HasRenderingRealization(local_58[0]);

+          wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::

+          ~com_ptr_t<IBitmapResource,wil::err_returncode_policy>

+                    ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)local_58);

+        }

+        else {

+          if (pcVar9 == CPrimitiveGroupRenderStrategy::IsReadyToDraw) goto LAB_1;

+          if (pcVar9 == CVisualSurfaceRenderStrategy::IsReadyToDraw) {

+            pCVar7 = CSurfaceBrush::GetSurface(pCVar11);

+            cVar6 = CVisualSurface::HasSomethingToDraw((CVisualSurface *)pCVar7);

+          }

+          else {

+            cVar6 = (*pcVar9)(*(undefined8 **)(pCVar11 + 0x88),pCVar11,0,local_res8);

+          }

+        }

+      }

+      else {

+        if (pcVar9 != CColorBrush::IsReadyToDraw) goto LAB_5;

+        cVar6 = CColorBrush::IsReadyToDraw((CColorBrush *)pCVar11,(CDrawingContext *)0x0,local_res8)

+        ;

+      }

+    }

+    else {

+LAB_5:

+      cVar6 = (*pcVar9)(pCVar11,0,local_res8);

+    }

+LAB_2:

+    cVar5 = local_res8[0];

+    if (cVar6 == '\0') goto LAB_0;

+  }

+  else if (pcVar9 == CColorBrush::IsEmptyDrawing) {

+    cVar5 = IsCloseRealZero(*(float *)(pCVar11 + 0x74),1.1920929e-06);

+  }

+  else {

+    cVar5 = (*pcVar9)(pCVar11);

+  }

+  if (cVar5 == '\0') {

+    return true;

+  }

+LAB_0:

+  if (((**(uint **)(this + 0xe8) & 0x40000) != 0) &&

+     (pvVar8 = CVisual::GetProjectedShadowReceivers((CVisual *)this),

+     *(longlong *)pvVar8 != *(longlong *)(pvVar8 + 8))) {

+    return true;

+  }

+  puVar2 = *(uint **)(this + 0xe8);

+  if ((*puVar2 & 0x20000) != 0) {

+    uVar1 = puVar2[1];

+    puVar13 = puVar2 + 2;

+    uVar10 = 0;

+    plVar12 = plVar14;

+    if (uVar1 != 0) {

+      do {

+        uVar10 = (uint)plVar12;

+        if ((char)*puVar13 == '\x0f') break;

+        uVar10 = uVar10 + 1;

+        plVar12 = (longlong *)(ulonglong)uVar10;

+        puVar13 = (uint *)((longlong)puVar13 + 1);

+      } while (uVar10 < uVar1);

+    }

+    if (uVar10 < uVar1) {

+      plVar14 = (longlong *)

+                (((ulonglong)uVar10 * 8 - (ulonglong)((uint)((ulonglong)uVar1 + 0xf) & 7)) +

+                 (ulonglong)uVar1 + 0xf + (longlong)puVar2);

+    }

+    lVar3 = *plVar14;

+    local_res8[0] = false;

+    if (1.1920929e-06 <= ABS(*(float *)(lVar3 + 0x5c))) {

+      if (*(int *)(lVar3 + 0x7c) != 1) {

+        pCVar11 = *(CSurfaceBrush **)(lVar3 + 0xb0);

+        cVar5 = '\0';

+        if (pCVar11 != (CSurfaceBrush *)0x0) {

+          if (*(code **)(*(longlong *)pCVar11 + 0x138) == CSurfaceBrush::IsReadyToDraw) {

+            cVar6 = CSurfaceBrush::IsReadyToDraw(pCVar11,(CDrawingContext *)0x0,local_res8);

+          }

+          else {

+            cVar6 = (**(code **)(*(longlong *)pCVar11 + 0x138))();

+          }

+          cVar5 = local_res8[0];

+          if (cVar6 == '\0') {

+            return false;

+          }

+        }

+        if (cVar5 != '\0') {

+          return false;

+        }

+      }

+      return true;

+    }

+  }

+  return false;

+}

+
```

## `CD3DDevice::PinResources`  (modified)

```diff
--- CD3DDevice::PinResources
+++ CD3DDevice::PinResources
@@ -1,2 +1,146 @@
-Failed to decompile dwmcore.dll - .ProgramDB CD3DDevice::PinResources : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: long __cdecl CD3DDevice::PinResources(class gsl::span<class ISwapChainRealization *

+   __ptr64,-1>,struct _LUID,unsigned int) __ptr64 */

+

+long __thiscall

+CD3DDevice::PinResources(CD3DDevice *this,longlong *param_2,_LUID param_3,uint param_4)

+

+{

+  longlong lVar1;

+  ISwapChainRealization *pIVar2;

+  longlong *plVar3;

+  longlong lVar4;

+  longlong lVar5;

+  char cVar6;

+  int iVar7;

+  long lVar8;

+  CDelayUnpin *this_00;

+  com_ptr_t<IMonitorTarget,wil::err_returncode_policy> *pcVar9;

+  longlong *plVar10;

+  com_ptr_t<IMonitorTarget,wil::err_returncode_policy> *this_01;

+  longlong *plVar11;

+  int local_88 [2];

+  longlong *local_80;

+  IDXGIResource *local_78;

+  ISwapChainRealization *local_70;

+  com_ptr_t<IMonitorTarget,wil::err_returncode_policy> *local_68;

+  com_ptr_t<IMonitorTarget,wil::err_returncode_policy> *pcStack_60;

+  com_ptr_t<IMonitorTarget,wil::err_returncode_policy> *local_58;

+  longlong local_50;

+  longlong lStack_48;

+  undefined8 local_40;

+  

+  local_40 = 0;

+  pcVar9 = (com_ptr_t<IMonitorTarget,wil::err_returncode_policy> *)0x0;

+  local_50 = 0;

+  lStack_48 = 0;

+  local_58 = (com_ptr_t<IMonitorTarget,wil::err_returncode_policy> *)0x0;

+  local_68 = (com_ptr_t<IMonitorTarget,wil::err_returncode_policy> *)0x0;

+  pcStack_60 = (com_ptr_t<IMonitorTarget,wil::err_returncode_policy> *)0x0;

+  if (*(int *)(this + 0x458) == 0) {

+    plVar10 = (longlong *)param_2[1];

+    iVar7 = 0;

+    lVar1 = *param_2;

+    this_01 = (com_ptr_t<IMonitorTarget,wil::err_returncode_policy> *)0x0;

+    plVar3 = plVar10 + lVar1;

+    lVar4 = local_50;

+    lVar5 = lStack_48;

+    for (plVar11 = plVar10; local_80 = plVar3, local_50 = lVar4, lStack_48 = lVar5,

+        plVar11 != plVar10 + lVar1; plVar11 = plVar11 + 1) {

+      pIVar2 = (ISwapChainRealization *)*plVar11;

+      local_70 = pIVar2;

+      cVar6 = (**(code **)(*(longlong *)(pIVar2 + 0x10) + 0x38))();

+      if (cVar6 == '\0') {

+        local_88[0] = 0;

+        local_78 = (IDXGIResource *)

+                   (**(code **)(*(longlong *)(pIVar2 + 0x10) + 0x28))(pIVar2 + 0x10,local_88);

+        if ((local_78 != (IDXGIResource *)0x0) && (local_88[0] == 0)) {

+          std::

+          vector<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>_>_>

+          ::emplace_back<IDXGIResource*___ptr64&___ptr64>

+                    ((vector<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>_>_>

+                      *)&local_50,&local_78);

+          if (this_01 == pcVar9) {

+            std::

+            vector<wil::com_ptr_t<IOverlayPlaneResource,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<IOverlayPlaneResource,wil::err_returncode_policy>_>_>

+            ::_Emplace_reallocate<ISwapChainRealization*___ptr64&___ptr64>

+                      ((vector<wil::com_ptr_t<IOverlayPlaneResource,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<IOverlayPlaneResource,wil::err_returncode_policy>_>_>

+                        *)&local_68,

+                       (com_ptr_t<class_IOverlayPlaneResource,struct_wil::err_returncode_policy> *)

+                       this_01,&local_70);

+            this_01 = pcStack_60;

+            pcVar9 = local_58;

+          }

+          else {

+            wil::com_ptr_t<IMonitorTarget,wil::err_returncode_policy>::

+            com_ptr_t<IMonitorTarget,wil::err_returncode_policy>

+                      (this_01,(IMonitorTarget *)

+                               (-(ulonglong)(pIVar2 != (ISwapChainRealization *)0x0) &

+                               (ulonglong)(pIVar2 + 0x10)));

+            pcStack_60 = this_01 + 8;

+            this_01 = pcStack_60;

+          }

+        }

+      }

+      plVar3 = local_80;

+      lVar4 = local_50;

+      lVar5 = lStack_48;

+    }

+    pcVar9 = local_68;

+    if (lVar4 != lVar5) {

+      if (((byte)Microsoft_Windows_Dwm_CompositorEnableBits & 2) != 0) {

+        McTemplateU0t_EventWriteTransfer

+                  (&Microsoft_Windows_Dwm_Compositor_Context,&Pinning_Start,lVar5 - lVar4 >> 3);

+      }

+      iVar7 = (**(code **)(**(longlong **)(this + 0x220) + 0x18))

+                        (*(longlong **)(this + 0x220),lVar4,lVar5 - lVar4 >> 3 & 0xffffffff);

+      if (iVar7 < 0) {

+        MilInstrumentationCheckHR_MaybeFailFast

+                  (0x14,(long *)&DAT_0,2,iVar7,0x3d0,(void *)0x0);

+      }

+      if (((byte)Microsoft_Windows_Dwm_CompositorEnableBits & 2) != 0) {

+        McTemplateU0t_EventWriteTransfer

+                  (&Microsoft_Windows_Dwm_Compositor_Context,&Pinning_Stop,iVar7);

+      }

+      pcVar9 = local_68;

+      if (iVar7 < 0) goto LAB_1;

+    }

+    for (; local_68 = pcVar9, plVar10 != plVar3; plVar10 = plVar10 + 1) {

+      cVar6 = (**(code **)(*(longlong *)(*plVar10 + 0x10) + 0x38))();

+      if (cVar6 != '\0') {

+        for (this_00 = *(CDelayUnpin **)(this + 0x4c0); this_00 != *(CDelayUnpin **)(this + 0x4c8);

+            this_00 = this_00 + 0x40) {

+          if (*(ulonglong *)this_00 == (-(ulonglong)(*plVar10 != 0) & *plVar10 + 0x10U)) {

+            CDelayUnpin::AddUnpinTarget(this_00,param_3,param_4,0xffffffff);

+            break;

+          }

+        }

+        (**(code **)(*(longlong *)(*plVar10 + 0x10) + 0x40))();

+      }

+      this_01 = pcStack_60;

+      pcVar9 = local_68;

+    }

+    for (; pcVar9 != this_01; pcVar9 = pcVar9 + 8) {

+      (**(code **)(**(longlong **)pcVar9 + 0x40))();

+    }

+  }

+  else {

+    iVar7 = -0x7767ff73;

+    MilInstrumentationCheckHR_MaybeFailFast

+              (0x14,(long *)&DAT_0,2,-0x7767ff73,0x3ba,(void *)0x0);

+  }

+LAB_1:

+  lVar8 = TranslateDXGIorD3DErrorInContext(this,iVar7,0xe);

+  std::

+  vector<wil::com_ptr_t<CWeakReference<CGdiSpriteBitmap>,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<CWeakReference<CGdiSpriteBitmap>,wil::err_returncode_policy>_>_>

+  ::_Tidy((vector<wil::com_ptr_t<CWeakReference<CGdiSpriteBitmap>,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<CWeakReference<CGdiSpriteBitmap>,wil::err_returncode_policy>_>_>

+           *)&local_68);

+  std::

+  vector<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>_>_>

+  ::_Tidy((vector<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>_>_>

+           *)&local_50);

+  return lVar8;

+}

+
```

## `COverlayContext::UpdateHardwareCursor`  (modified)

```diff
--- COverlayContext::UpdateHardwareCursor
+++ COverlayContext::UpdateHardwareCursor
@@ -1,2 +1,90 @@
-Failed to decompile dwmcore.dll - .ProgramDB COverlayContext::UpdateHardwareCursor : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* private: void __cdecl COverlayContext::UpdateHardwareCursor(bool) __ptr64 */

+

+void __thiscall COverlayContext::UpdateHardwareCursor(COverlayContext *this,bool param_1)

+

+{

+  char cVar1;

+  int iVar2;

+  CCursorState *this_00;

+  bool bVar3;

+  CursorVisibility CVar4;

+  CMonitorTransform *pCVar5;

+  MonitorData *pMVar6;

+  code *pcVar7;

+  longlong *plVar8;

+  undefined1 auStackY_d8 [32];

+  undefined8 local_98;

+  undefined8 uStack_90;

+  undefined8 local_88;

+  undefined8 uStack_80;

+  undefined8 local_78;

+  undefined8 uStack_70;

+  undefined8 local_68;

+  undefined8 uStack_60;

+  undefined4 local_58;

+  undefined8 local_48;

+  undefined8 uStack_40;

+  ulonglong local_38;

+  

+  local_38 = __security_cookie ^ (ulonglong)auStackY_d8;

+  pCVar5 = GetMonitorTransform(this);

+  if (this[0x4c70] == (COverlayContext)0x0) {

+    local_48 = *(undefined8 *)(pCVar5 + 0x18);

+    uStack_40 = *(undefined8 *)(pCVar5 + 0x20);

+  }

+  else {

+    local_48 = *(undefined8 *)(this + 0x4a24);

+    uStack_40 = *(undefined8 *)(this + 0x4a2c);

+  }

+  local_98 = *(undefined8 *)(this + 0x4b2c);

+  uStack_90 = *(undefined8 *)(this + 0x4b34);

+  local_58 = *(undefined4 *)(this + 0x4b6c);

+  local_88 = *(undefined8 *)(this + 0x4b3c);

+  uStack_80 = *(undefined8 *)(this + 0x4b44);

+  local_78 = *(undefined8 *)(this + 0x4b4c);

+  uStack_70 = *(undefined8 *)(this + 0x4b54);

+  local_68 = *(undefined8 *)(this + 0x4b5c);

+  uStack_60 = *(undefined8 *)(this + 0x4b64);

+  CMILMatrix::Multiply

+            ((CMILMatrix *)&local_98,

+             (CMILMatrix *)

+             (pCVar5 + (ulonglong)(-(uint)(this[0x4c70] != (COverlayContext)0x0) & 0x88) + 0x34));

+  bVar3 = CCursorState::EnsureMonitorData

+                    (*(CCursorState **)(*(longlong *)(this + 0x4b18) + 0x2c8),

+                     *(_LUID *)(this + 0x4b20),*(uint *)(this + 0x4b28),

+                     (TMilRect<unsigned_int,MilRectU,Mil3DRectU,RectUniqueness::NotNeeded> *)

+                     &local_48,(bool)pCVar5[0x100],(bool)this[0x4c6b],(CMILMatrix *)&local_98);

+  this_00 = *(CCursorState **)(*(longlong *)(this + 0x4b18) + 0x2c8);

+  cVar1 = *(char *)(*(longlong *)(this + 0x4b18) + 0x2b8);

+  pMVar6 = CCursorState::GetMonitorData(this_00,*(_LUID *)(this + 0x4b20),*(uint *)(this + 0x4b28));

+  EnterCriticalSection((LPCRITICAL_SECTION)&g_CursorManager);

+  iVar2 = *(int *)(pMVar6 + 0x98);

+  CVar4 = CCursorState::UpdateHardwareCursor

+                    (this_00,pMVar6,(bool)(-(cVar1 != '\0') & param_1),bVar3);

+  LeaveCriticalSection((LPCRITICAL_SECTION)&g_CursorManager);

+  if ((CVar4 == 2) ||

+     (bVar3 = TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded>::IsEmpty

+                        ((TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded> *)

+                         (this + 0x4b70)), bVar3)) {

+    if (iVar2 == 2) {

+      return;

+    }

+    if (CVar4 != 2) {

+      return;

+    }

+    plVar8 = *(longlong **)this;

+    pcVar7 = *(code **)(*plVar8 + 0x128);

+    GetCursorBounds(this);

+  }

+  else {

+    plVar8 = *(longlong **)this;

+    pcVar7 = *(code **)(*plVar8 + 0x128);

+  }

+  (*pcVar7)(plVar8);

+  return;

+}

+
```

## `CCompositionMagnifierBrush::GetBVIBrushParameters`  (modified)

```diff
--- CCompositionMagnifierBrush::GetBVIBrushParameters
+++ CCompositionMagnifierBrush::GetBVIBrushParameters
@@ -1,2 +1,137 @@
-Failed to decompile dwmcore.dll - .ProgramDB CCompositionMagnifierBrush::GetBVIBrushParameters : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* private: long __cdecl CCompositionMagnifierBrush::GetBVIBrushParameters(class

+   CBrushDrawListGenerator * __ptr64)const __ptr64 */

+

+long __thiscall

+CCompositionMagnifierBrush::GetBVIBrushParameters

+          (CCompositionMagnifierBrush *this,CBrushDrawListGenerator *param_1)

+

+{

+  float fVar1;

+  float fVar2;

+  float fVar3;

+  bool bVar4;

+  int iVar5;

+  int iVar6;

+  Enum EVar7;

+  long lVar8;

+  CVisual *this_00;

+  CBackdropVisualImage *pCVar9;

+  CDrawingContext *this_01;

+  D2D1_INTERPOLATION_MODE DVar10;

+  float fVar11;

+  float fVar12;

+  float fVar13;

+  float fVar14;

+  float fVar15;

+  float fVar16;

+  void *unaff_retaddr;

+  undefined8 local_res8;

+  longlong local_res10;

+  undefined8 local_118;

+  undefined8 uStack_110;

+  undefined1 local_108;

+  CDrawListBitmap local_100 [16];

+  undefined1 local_f0;

+  float local_e8 [5];

+  undefined4 local_d4;

+  float local_d0;

+  float local_cc;

+  undefined4 local_c8;

+  

+  this_01 = *(CDrawingContext **)param_1;

+  this_00 = CDrawingContext::GetCurrentVisual(this_01);

+  pCVar9 = CVisual::GetBackdropVisualImage(this_00,*(CVisualTreePath **)(this_01 + 0x1f20));

+  fVar11 = *(float *)(pCVar9 + 0x828);

+  fVar12 = *(float *)(pCVar9 + 0x82c);

+  fVar13 = *(float *)(pCVar9 + 0x830);

+  fVar14 = *(float *)(pCVar9 + 0x834);

+  fVar1 = *(float *)(pCVar9 + 0x78);

+  fVar2 = *(float *)(pCVar9 + 0x7c);

+  iVar5 = PixelAlign(fVar11,0);

+  fVar15 = (float)iVar5;

+  iVar5 = PixelAlign(fVar12,0);

+  fVar16 = (float)iVar5;

+  iVar5 = PixelAlign((fVar13 - fVar11) + fVar11,1);

+  iVar6 = PixelAlign((fVar14 - fVar12) + fVar12,1);

+  fVar13 = (float)iVar5 - fVar15;

+  fVar14 = (float)iVar6 - fVar16;

+  bVar4 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_CompositionMagnifier_BVIScaleFix>::

+          __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_CompositionMagnifier_BVIScaleFix>

+                               *)&`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_CompositionMagnifier_BVIScaleFix>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_CompositionMagnifier_BVIScaleFix>::GetImpl(void)'

+                                  ::__l2::impl);

+  fVar11 = fVar14;

+  fVar12 = fVar13;

+  if (bVar4) {

+    fVar3 = *(float *)(pCVar9 + 0x840);

+    if ((8.138021e-05 <= ABS(fVar3 - 1.0)) && (8.138021e-05 <= ABS(fVar3))) {

+      fVar12 = fVar13 / fVar3;

+    }

+    fVar3 = *(float *)(pCVar9 + 0x844);

+    if ((8.138021e-05 <= ABS(fVar3 - 1.0)) && (8.138021e-05 <= ABS(fVar3))) {

+      fVar11 = fVar14 / fVar3;

+    }

+  }

+  DVar10 = 0;

+  if ((this[0x6c] == (CCompositionMagnifierBrush)0x0) &&

+     (fVar3 = *(float *)(this + 0x68), DVar10 = 0, 1.0 < fVar3)) {

+    fVar12 = fVar12 * fVar3;

+    DVar10 = 1;

+    fVar11 = fVar11 * fVar3;

+  }

+  local_res10 = 0;

+  local_e8[1] = 0.0;

+  local_e8[2] = 0.0;

+  local_e8[3] = 0.0;

+  local_d4 = 0;

+  local_c8 = 0x3f800000;

+  local_cc = fVar16 / fVar2;

+  local_e8[0] = fVar13 / (fVar1 * fVar12);

+  local_e8[4] = fVar14 / (fVar2 * fVar11);

+  local_d0 = fVar15 / fVar1;

+  CDrawListBitmap::CDrawListBitmap

+            (local_100,

+             (IBitmapResource *)

+             (-(ulonglong)(pCVar9 != (CBackdropVisualImage *)0x0) & (ulonglong)(pCVar9 + 0x48)));

+  uStack_110 = 0;

+  local_118 = &local_res10;

+  local_f0 = 1;

+  local_108 = 1;

+  EVar7 = InterpolationMode::FromD2D1InterpolationMode(DVar10);

+  local_res8._0_3_ = CONCAT21(0x101,(char)EVar7);

+  lVar8 = CSurfaceDrawListBrush::CreateWithTextureTransform

+                    (local_100,&local_res8,local_e8,&uStack_110);

+  wil::details::

+  out_param_t<std::unique_ptr<CSurfaceDrawListBrush,std::default_delete<CSurfaceDrawListBrush>_>_>::

+  ~out_param_t<std::unique_ptr<CSurfaceDrawListBrush,std::default_delete<CSurfaceDrawListBrush>_>_>

+            ((out_param_t<std::unique_ptr<CSurfaceDrawListBrush,std::default_delete<CSurfaceDrawListBrush>_>_>

+              *)&local_118);

+  if (lVar8 < 0) {

+    wil::details::in1diag3::Return_Hr

+              (unaff_retaddr,0x242,

+               "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp",lVar8);

+  }

+  else {

+    local_118 = (longlong *)CONCAT44(fVar16,fVar15);

+    uStack_110 = CONCAT44((float)iVar6,(float)iVar5);

+    *(longlong **)(local_res10 + 0x78) = local_118;

+    *(undefined8 *)(local_res10 + 0x80) = uStack_110;

+    CBrushDrawListGenerator::Reset(param_1);

+    local_res8 = local_res10;

+    local_res10 = 0;

+    CBrushDrawListGenerator::AttachInput

+              (param_1,0,

+               (unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_> *)&local_res8);

+    std::unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>::

+    ~unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>

+              ((unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_> *)&local_res8);

+    lVar8 = 0;

+  }

+  CDrawListBitmap::~CDrawListBitmap(local_100);

+  std::unique_ptr<CSurfaceDrawListBrush,std::default_delete<CSurfaceDrawListBrush>_>::

+  ~unique_ptr<CSurfaceDrawListBrush,std::default_delete<CSurfaceDrawListBrush>_>

+            ((unique_ptr<CSurfaceDrawListBrush,std::default_delete<CSurfaceDrawListBrush>_> *)

+             &local_res10);

+  return lVar8;

+}

+
```

## `CSurfaceBrush::SetSurface`  (modified)

```diff
--- CSurfaceBrush::SetSurface
+++ CSurfaceBrush::SetSurface
@@ -1,2 +1,126 @@
-Failed to decompile dwmcore.dll - .ProgramDB CSurfaceBrush::SetSurface : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: long __cdecl CSurfaceBrush::SetSurface(class CResource * __ptr64,class

+   TMilRect_<float,struct D2D_RECT_F,struct D3D_RECT_F,struct D2D_POINTANDSIZE_F,struct

+   RectUniqueness::NotNeeded> const & __ptr64,class TMilRect_<float,struct D2D_RECT_F,struct

+   D3D_RECT_F,struct D2D_POINTANDSIZE_F,struct RectUniqueness::NotNeeded> const * __ptr64,class

+   CSurfaceBrush::CSurfaceRenderStrategy const * __ptr64) __ptr64 */

+

+long __thiscall

+CSurfaceBrush::SetSurface

+          (CSurfaceBrush *this,CResource *param_1,

+          TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+          *param_2,TMilRect_<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_D2D_POINTANDSIZE_F,struct_RectUniqueness::NotNeeded>

+                   *param_3,CSurfaceRenderStrategy *param_4)

+

+{

+  undefined8 uVar1;

+  bool bVar2;

+  bool bVar3;

+  char cVar4;

+  bool bVar5;

+  long lVar6;

+  Flags FVar7;

+  TMilRect<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_RectUniqueness::NotNeeded> *pTVar8;

+  CResource *pCVar9;

+  undefined1 auStackY_c8 [32];

+  uint uVar10;

+  undefined **local_88;

+  undefined8 local_80;

+  undefined1 *local_78;

+  undefined1 *local_70;

+  undefined8 *local_68;

+  undefined1 local_60 [16];

+  undefined8 local_50;

+  ulonglong local_48;

+  

+  local_48 = __security_cookie ^ (ulonglong)auStackY_c8;

+  lVar6 = 0;

+  bVar3 = false;

+  bVar2 = false;

+  if (param_1 == *(CResource **)(this + 0x80)) {

+LAB_0:

+    pTVar8 = (TMilRect<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_RectUniqueness::NotNeeded> *

+             )(this + 0xb0);

+    bVar5 = TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded>::IsEquivalentTo

+                      ((TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded> *)param_2,

+                       pTVar8);

+    if (!bVar5) {

+      bVar2 = true;

+      if ((*(float *)(param_2 + 8) - *(float *)param_2 != *(float *)(pTVar8 + 8) - *(float *)pTVar8)

+         || (*(float *)(param_2 + 0xc) - *(float *)(param_2 + 4) !=

+             *(float *)(this + 0xbc) - *(float *)(this + 0xb4))) {

+        bVar3 = bVar2;

+      }

+      uVar1 = *(undefined8 *)(param_2 + 8);

+      *(undefined8 *)pTVar8 = *(undefined8 *)param_2;

+      *(undefined8 *)(pTVar8 + 8) = uVar1;

+    }

+    if (((bVar3) || (bVar2)) ||

+       (param_3 !=

+        (TMilRect_<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_D2D_POINTANDSIZE_F,struct_RectUniqueness::NotNeeded>

+         *)0x0)) {

+      local_80 = 0;

+      local_50 = 0;

+      local_88 = &CRectanglesShape::_vftable_;

+      local_78 = local_60;

+      local_70 = local_60;

+      local_68 = &local_50;

+      if (bVar3) {

+        FVar7 = 0;

+      }

+      else {

+        if (param_3 !=

+            (TMilRect_<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_D2D_POINTANDSIZE_F,struct_RectUniqueness::NotNeeded>

+             *)0x0) {

+          CRectanglesShape::SetSingleRect((CRectanglesShape *)&local_88,(D2D_RECT_F *)param_3);

+          *(undefined ****)(this + 0xc0) = &local_88;

+        }

+        FVar7 = (-(uint)bVar2 & 5) + 1;

+      }

+      CBrush::NotifyOnChanged((CBrush *)this,FVar7,(IUnknown *)this);

+      *(undefined8 *)(this + 0xc0) = 0;

+      CRectanglesShape::~CRectanglesShape((CRectanglesShape *)&local_88);

+    }

+  }

+  else {

+    bVar2 = true;

+    bVar3 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2>::

+            __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2> *)

+                                &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DCompChromiumK2>::GetImpl(void)'

+                                 ::__l2::impl);

+    pCVar9 = param_1;

+    if (((bVar3) && (param_1 != (CResource *)0x0)) &&

+       (cVar4 = (**(code **)(*(longlong *)param_1 + 0x40))(param_1), cVar4 != '\0')) {

+      pCVar9 = *(CResource **)(param_1 + 0x48);

+    }

+    if ((param_4 == (CSurfaceRenderStrategy *)0x0) &&

+       (param_4 = FindCommonRenderStrategy(pCVar9), param_4 == (CSurfaceRenderStrategy *)0x0)) {

+      lVar6 = -0x7767fbfd;

+      uVar10 = 0x192;

+    }

+    else {

+      lVar6 = 0;

+      if ((param_1 == (CResource *)0x0) ||

+         (lVar6 = CResource::RegisterNotifier((CResource *)this,param_1), -1 < lVar6)) {

+        CResource::UnRegisterNotifierInternal((CResource *)this,*(CResource **)(this + 0x80));

+        *(CResource **)(this + 0x80) = param_1;

+        *(CSurfaceRenderStrategy **)(this + 0x88) = param_4;

+        bVar5 = TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded>::IsEmpty

+                          ((TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded> *)

+                           param_2);

+        bVar3 = false;

+        if (bVar5) {

+          bVar3 = true;

+        }

+        goto LAB_0;

+      }

+      uVar10 = 0x197;

+    }

+    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar6,uVar10,(void *)0x0);

+  }

+  return lVar6;

+}

+
```

## `CMILMatrix::Multiply`  (modified)

```diff
--- CMILMatrix::Multiply
+++ CMILMatrix::Multiply
@@ -1,2 +1,1112 @@
-Failed to decompile dwmcore.dll - .ProgramDB CMILMatrix::Multiply : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Type propagation algorithm not settling */

+/* public: static void __cdecl CMILMatrix::Multiply(class CMILMatrix const & __ptr64,class

+   CMILMatrix const & __ptr64,class CMILMatrix * __ptr64) */

+

+void __cdecl CMILMatrix::Multiply(CMILMatrix *param_1,CMILMatrix *param_2,CMILMatrix *param_3)

+

+{

+  undefined4 uVar1;

+  float fVar2;

+  float fVar3;

+  float fVar4;

+  float fVar5;

+  float fVar6;

+  float fVar7;

+  float fVar8;

+  float fVar9;

+  float fVar10;

+  float fVar11;

+  float fVar12;

+  float fVar13;

+  float fVar14;

+  float fVar15;

+  float fVar16;

+  undefined8 uVar17;

+  undefined1 auVar18 [16];

+  ulonglong uVar19;

+  bool bVar20;

+  char cVar21;

+  byte bVar22;

+  CMILMatrix CVar23;

+  byte bVar24;

+  byte bVar25;

+  undefined1 uVar26;

+  uint uVar27;

+  CMILMatrix *pCVar28;

+  float fVar29;

+  float fVar30;

+  float fVar31;

+  float fVar32;

+  float fVar33;

+  float fVar34;

+  float fVar35;

+  float fVar36;

+  float fVar37;

+  float fVar38;

+  float fVar39;

+  float fVar40;

+  float fVar41;

+  float fVar42;

+  float fVar43;

+  float fVar44;

+  float fVar45;

+  float local_1b8;

+  float fStack_1b4;

+  undefined8 uStack_1b0;

+  float local_1a8;

+  float fStack_1a4;

+  undefined8 uStack_1a0;

+  undefined8 local_198;

+  float fStack_190;

+  float fStack_18c;

+  float local_188;

+  float fStack_184;

+  float fStack_180;

+  undefined8 uStack_17c;

+  undefined1 local_168 [8];

+  float fStack_160;

+  float fStack_15c;

+  undefined1 local_158 [8];

+  float fStack_150;

+  float fStack_14c;

+  undefined1 local_148 [16];

+  undefined1 local_138 [8];

+  float fStack_130;

+  float fStack_12c;

+  undefined1 local_128 [8];

+  float fStack_120;

+  float fStack_11c;

+  undefined1 local_108 [8];

+  float fStack_100;

+  float fStack_fc;

+  undefined1 local_f8 [8];

+  float fStack_f0;

+  float fStack_ec;

+  undefined1 local_e8 [8];

+  float fStack_e0;

+  float fStack_dc;

+  undefined1 local_d8 [8];

+  float fStack_d0;

+  float fStack_cc;

+  undefined1 local_c8 [16];

+  undefined1 local_b8 [8];

+  float fStack_b0;

+  float fStack_ac;

+  

+  if (param_3 != param_2) {

+    uVar17 = *(undefined8 *)(param_1 + 8);

+    *(undefined8 *)param_3 = *(undefined8 *)param_1;

+    *(undefined8 *)(param_3 + 8) = uVar17;

+    uVar17 = *(undefined8 *)(param_1 + 0x18);

+    *(undefined8 *)(param_3 + 0x10) = *(undefined8 *)(param_1 + 0x10);

+    *(undefined8 *)(param_3 + 0x18) = uVar17;

+    uVar17 = *(undefined8 *)(param_1 + 0x28);

+    *(undefined8 *)(param_3 + 0x20) = *(undefined8 *)(param_1 + 0x20);

+    *(undefined8 *)(param_3 + 0x28) = uVar17;

+    uVar17 = *(undefined8 *)(param_1 + 0x38);

+    *(undefined8 *)(param_3 + 0x30) = *(undefined8 *)(param_1 + 0x30);

+    *(undefined8 *)(param_3 + 0x38) = uVar17;

+    uVar1 = *(undefined4 *)(param_1 + 0x40);

+    *(undefined4 *)(param_3 + 0x40) = uVar1;

+    cVar21 = (char)((char)uVar1 << 6) >> 6;

+    if (cVar21 < '\x01') {

+      if (cVar21 < '\0') {

+LAB_0:

+        uVar17 = *(undefined8 *)(param_2 + 8);

+        *(undefined8 *)param_3 = *(undefined8 *)param_2;

+        *(undefined8 *)(param_3 + 8) = uVar17;

+        uVar17 = *(undefined8 *)(param_2 + 0x18);

+        *(undefined8 *)(param_3 + 0x10) = *(undefined8 *)(param_2 + 0x10);

+        *(undefined8 *)(param_3 + 0x18) = uVar17;

+        uVar17 = *(undefined8 *)(param_2 + 0x28);

+        *(undefined8 *)(param_3 + 0x20) = *(undefined8 *)(param_2 + 0x20);

+        *(undefined8 *)(param_3 + 0x28) = uVar17;

+        uVar17 = *(undefined8 *)(param_2 + 0x38);

+        *(undefined8 *)(param_3 + 0x30) = *(undefined8 *)(param_2 + 0x30);

+        *(undefined8 *)(param_3 + 0x38) = uVar17;

+        *(undefined4 *)(param_3 + 0x40) = *(undefined4 *)(param_2 + 0x40);

+        return;

+      }

+      pCVar28 = param_3;

+      bVar20 = IsTranslate<1>(param_3);

+      if ((((bVar20) && (ABS(*(float *)(param_3 + 0x30) - 0.0) < 8.138021e-05)) &&

+          (ABS(*(float *)(param_3 + 0x34) - 0.0) < 8.138021e-05)) &&

+         (ABS(*(float *)(param_3 + 0x38) - 0.0) < 8.138021e-05)) {

+        param_3[0x40] = (CMILMatrix)((byte)param_3[0x40] | 3);

+        goto LAB_0;

+      }

+      param_3[0x40] = (CMILMatrix)((byte)param_3[0x40] & 0xfd);

+      param_3[0x40] = (CMILMatrix)((byte)param_3[0x40] | 1);

+      param_3 = pCVar28;

+    }

+    bVar20 = IsIdentity<1>(param_2);

+    if (bVar20) {

+      return;

+    }

+    bVar20 = IsTranslate<1>(param_2);

+    if (!bVar20) {

+      bVar20 = IsTranslate<1>(param_3);

+      if (!bVar20) {

+        bVar20 = IsTranslateAndScale<1>(param_2);

+        if (!bVar20) {

+          bVar20 = IsPure2DUniformZ<1>(param_3);

+          if ((bVar20) && (bVar20 = IsPure2DUniformZ<1>(param_2), bVar20)) {

+            fVar36 = *(float *)param_2;

+            fVar45 = *(float *)(param_2 + 0x10);

+            fVar33 = *(float *)(param_2 + 4);

+            fVar44 = *(float *)(param_2 + 0x14);

+            fVar30 = *(float *)(param_2 + 0x30);

+            fVar31 = *(float *)(param_2 + 0x34);

+            *(undefined8 *)(param_3 + 8) = 0;

+            fVar39 = *(float *)(param_3 + 0x38);

+            fVar42 = *(float *)param_3;

+            fVar40 = *(float *)(param_3 + 0x10);

+            fVar41 = *(float *)(param_3 + 0x30);

+            fVar34 = *(float *)(param_3 + 0x28);

+            *(float *)(param_3 + 0x38) = 0.0;

+            *(undefined8 *)(param_3 + 0x18) = 0;

+            *(undefined8 *)(param_3 + 0x20) = 0;

+            *(undefined8 *)(param_3 + 0x3c) = 0x3f800000;

+            *(undefined8 *)(param_3 + 0x28) = 0x3f800000;

+            param_3[0x40] = (CMILMatrix)0x8;

+            *(float *)param_3 = fVar45 * *(float *)(param_3 + 4) + fVar36 * fVar42;

+            param_3[0x41] = (CMILMatrix)((byte)param_3[0x41] & 0xeb | 0x28);

+            *(float *)(param_3 + 4) = fVar33 * fVar42 + fVar44 * *(float *)(param_3 + 4);

+            *(float *)(param_3 + 0x10) = fVar45 * *(float *)(param_3 + 0x14) + fVar36 * fVar40;

+            *(float *)(param_3 + 0x30) =

+                 fVar36 * fVar41 + fVar45 * *(float *)(param_3 + 0x34) + fVar30;

+            *(float *)(param_3 + 0x14) = fVar33 * fVar40 + fVar44 * *(float *)(param_3 + 0x14);

+            *(float *)(param_3 + 0x34) =

+                 fVar44 * *(float *)(param_3 + 0x34) + fVar33 * fVar41 + fVar31;

+            *(float *)(param_3 + 0x28) = fVar34 * *(float *)(param_2 + 0x28);

+            *(float *)(param_3 + 0x38) =

+                 fVar39 * *(float *)(param_2 + 0x28) + *(float *)(param_2 + 0x38);

+            return;

+          }

+          fVar36 = *(float *)param_3;

+          fVar45 = *(float *)(param_3 + 4);

+          fVar33 = *(float *)(param_3 + 8);

+          fVar44 = *(float *)(param_3 + 0xc);

+          uStack_17c._4_4_ = 0.0;

+          fVar30 = *(float *)(param_3 + 0x10);

+          fVar31 = *(float *)(param_3 + 0x14);

+          fVar39 = *(float *)(param_3 + 0x18);

+          fVar42 = *(float *)(param_3 + 0x1c);

+          fVar40 = *(float *)(param_3 + 0x20);

+          fVar41 = *(float *)(param_3 + 0x24);

+          fVar34 = *(float *)(param_3 + 0x28);

+          fVar32 = *(float *)(param_3 + 0x2c);

+          fVar29 = *(float *)(param_3 + 0x30);

+          fVar43 = *(float *)(param_3 + 0x34);

+          fVar35 = *(float *)(param_3 + 0x38);

+          fVar37 = *(float *)(param_3 + 0x3c);

+          fVar38 = *(float *)param_2;

+          fVar2 = *(float *)(param_2 + 4);

+          fVar3 = *(float *)(param_2 + 8);

+          fVar4 = *(float *)(param_2 + 0xc);

+          fVar5 = *(float *)(param_2 + 0x10);

+          fVar6 = *(float *)(param_2 + 0x14);

+          fVar7 = *(float *)(param_2 + 0x18);

+          fVar8 = *(float *)(param_2 + 0x1c);

+          fVar9 = *(float *)(param_2 + 0x20);

+          fVar10 = *(float *)(param_2 + 0x24);

+          fVar11 = *(float *)(param_2 + 0x28);

+          fVar12 = *(float *)(param_2 + 0x2c);

+          fVar13 = *(float *)(param_2 + 0x30);

+          fVar14 = *(float *)(param_2 + 0x34);

+          fVar15 = *(float *)(param_2 + 0x38);

+          fVar16 = *(float *)(param_2 + 0x3c);

+          *(float *)param_3 = fVar44 * fVar13 + fVar45 * fVar5 + fVar33 * fVar9 + fVar36 * fVar38;

+          *(float *)(param_3 + 4) =

+               fVar44 * fVar14 + fVar45 * fVar6 + fVar33 * fVar10 + fVar36 * fVar2;

+          *(float *)(param_3 + 8) =

+               fVar44 * fVar15 + fVar45 * fVar7 + fVar33 * fVar11 + fVar36 * fVar3;

+          *(float *)(param_3 + 0xc) =

+               fVar44 * fVar16 + fVar45 * fVar8 + fVar33 * fVar12 + fVar36 * fVar4;

+          *(float *)(param_3 + 0x10) =

+               fVar42 * fVar13 + fVar31 * fVar5 + fVar39 * fVar9 + fVar30 * fVar38;

+          *(float *)(param_3 + 0x14) =

+               fVar42 * fVar14 + fVar31 * fVar6 + fVar39 * fVar10 + fVar30 * fVar2;

+          *(float *)(param_3 + 0x18) =

+               fVar42 * fVar15 + fVar31 * fVar7 + fVar39 * fVar11 + fVar30 * fVar3;

+          *(float *)(param_3 + 0x1c) =

+               fVar42 * fVar16 + fVar31 * fVar8 + fVar39 * fVar12 + fVar30 * fVar4;

+          *(float *)(param_3 + 0x20) =

+               fVar32 * fVar13 + fVar41 * fVar5 + fVar34 * fVar9 + fVar40 * fVar38;

+          *(float *)(param_3 + 0x24) =

+               fVar32 * fVar14 + fVar41 * fVar6 + fVar34 * fVar10 + fVar40 * fVar2;

+          *(float *)(param_3 + 0x28) =

+               fVar32 * fVar15 + fVar41 * fVar7 + fVar34 * fVar11 + fVar40 * fVar3;

+          *(float *)(param_3 + 0x2c) =

+               fVar32 * fVar16 + fVar41 * fVar8 + fVar34 * fVar12 + fVar40 * fVar4;

+          *(float *)(param_3 + 0x30) =

+               fVar37 * fVar13 + fVar43 * fVar5 + fVar35 * fVar9 + fVar29 * fVar38;

+          *(float *)(param_3 + 0x34) =

+               fVar37 * fVar14 + fVar43 * fVar6 + fVar35 * fVar10 + fVar29 * fVar2;

+          *(float *)(param_3 + 0x38) =

+               fVar37 * fVar15 + fVar43 * fVar7 + fVar35 * fVar11 + fVar29 * fVar3;

+          *(float *)(param_3 + 0x3c) =

+               fVar37 * fVar16 + fVar43 * fVar8 + fVar35 * fVar12 + fVar29 * fVar4;

+          goto LAB_1;

+        }

+        fVar36 = *(float *)param_2;

+        fVar45 = *(float *)(param_2 + 0x30);

+        fVar33 = *(float *)(param_2 + 0x34);

+        fVar44 = *(float *)(param_2 + 0x38);

+        fVar30 = *(float *)(param_2 + 0x28);

+        fVar31 = *(float *)(param_2 + 0x14);

+        if (((8.138021e-05 <= ABS(fVar36 - 1.0)) || (8.138021e-05 <= ABS(fVar31 - 1.0))) ||

+           (8.138021e-05 <= ABS(fVar30 - 1.0))) {

+          *(float *)param_3 = fVar36 * *(float *)param_3;

+          *(float *)(param_3 + 0x10) = fVar36 * *(float *)(param_3 + 0x10);

+          *(float *)(param_3 + 0x20) = fVar36 * *(float *)(param_3 + 0x20);

+          *(float *)(param_3 + 0x30) = fVar36 * *(float *)(param_3 + 0x30);

+          *(float *)(param_3 + 4) = fVar31 * *(float *)(param_3 + 4);

+          *(float *)(param_3 + 0x14) = fVar31 * *(float *)(param_3 + 0x14);

+          *(float *)(param_3 + 0x24) = fVar31 * *(float *)(param_3 + 0x24);

+          *(float *)(param_3 + 0x34) = fVar31 * *(float *)(param_3 + 0x34);

+          if (8.138021e-05 <= ABS(fVar30 - 1.0)) {

+            *(float *)(param_3 + 8) = fVar30 * *(float *)(param_3 + 8);

+            *(float *)(param_3 + 0x18) = fVar30 * *(float *)(param_3 + 0x18);

+            *(float *)(param_3 + 0x28) = fVar30 * *(float *)(param_3 + 0x28);

+            *(float *)(param_3 + 0x38) = fVar30 * *(float *)(param_3 + 0x38);

+          }

+          param_3[0x40] = (CMILMatrix)((byte)param_3[0x40] & 0xcc);

+        }

+        if (((ABS(fVar45) < 8.138021e-05) && (ABS(fVar33) < 8.138021e-05)) &&

+           (ABS(fVar44) < 8.138021e-05)) {

+          return;

+        }

+        CVar23 = param_3[0x41];

+        cVar21 = (char)((char)CVar23 << 2) >> 6;

+        if (cVar21 < '\x01') {

+          if (cVar21 < '\0') {

+            fVar36 = *(float *)(param_3 + 0x2c);

+          }

+          else {

+            if (8.138021e-05 <=

+                ABS((ABS(*(float *)(param_3 + 0x1c)) * 61440.0 +

+                     ABS(*(float *)(param_3 + 0xc)) * 61440.0 + ABS(*(float *)(param_3 + 0x3c))) -

+                    1.0)) {

+              CVar23 = (CMILMatrix)((byte)CVar23 & 0xdf | 0x10);

+              goto LAB_2;

+            }

+            fVar36 = *(float *)(param_3 + 0x2c);

+            CVar23 = (CMILMatrix)((byte)CVar23 | 0x30);

+            param_3[0x41] = CVar23;

+          }

+          if (ABS(ABS(fVar36) * 61440.0 - 0.0) < 8.138021e-05) {

+            *(float *)(param_3 + 0x30) = fVar45 + *(float *)(param_3 + 0x30);

+            *(float *)(param_3 + 0x34) = fVar33 + *(float *)(param_3 + 0x34);

+            *(float *)(param_3 + 0x38) = fVar44 + *(float *)(param_3 + 0x38);

+            goto LAB_3;

+          }

+        }

+LAB_2:

+        fVar36 = *(float *)(param_3 + 0xc);

+        fVar30 = *(float *)(param_3 + 0x1c);

+        param_3[0x41] = (CMILMatrix)((byte)CVar23 & 0xf3);

+        *(float *)param_3 = fVar36 * fVar45 + *(float *)param_3;

+        *(float *)(param_3 + 4) = fVar36 * fVar33 + *(float *)(param_3 + 4);

+        *(float *)(param_3 + 8) = fVar36 * fVar44 + *(float *)(param_3 + 8);

+        fVar36 = *(float *)(param_3 + 0x2c);

+        *(float *)(param_3 + 0x10) = fVar30 * fVar45 + *(float *)(param_3 + 0x10);

+        *(float *)(param_3 + 0x14) = fVar30 * fVar33 + *(float *)(param_3 + 0x14);

+        *(float *)(param_3 + 0x18) = fVar30 * fVar44 + *(float *)(param_3 + 0x18);

+        *(float *)(param_3 + 0x28) = fVar36 * fVar44 + *(float *)(param_3 + 0x28);

+        fVar30 = *(float *)(param_3 + 0x3c);

+        *(float *)(param_3 + 0x20) = fVar36 * fVar45 + *(float *)(param_3 + 0x20);

+        *(float *)(param_3 + 0x24) = fVar36 * fVar33 + *(float *)(param_3 + 0x24);

+        *(float *)(param_3 + 0x30) = fVar30 * fVar45 + *(float *)(param_3 + 0x30);

+        *(float *)(param_3 + 0x34) = fVar30 * fVar33 + *(float *)(param_3 + 0x34);

+        *(float *)(param_3 + 0x38) = fVar30 * fVar44 + *(float *)(param_3 + 0x38);

+        goto LAB_3;

+      }

+      uVar17 = *(undefined8 *)(param_2 + 8);

+      fVar36 = *(float *)(param_3 + 0x30);

+      fVar45 = *(float *)(param_3 + 0x34);

+      fVar33 = *(float *)(param_3 + 0x38);

+      *(undefined8 *)param_3 = *(undefined8 *)param_2;

+      *(undefined8 *)(param_3 + 8) = uVar17;

+      uVar17 = *(undefined8 *)(param_2 + 0x18);

+      *(undefined8 *)(param_3 + 0x10) = *(undefined8 *)(param_2 + 0x10);

+      *(undefined8 *)(param_3 + 0x18) = uVar17;

+      uVar17 = *(undefined8 *)(param_2 + 0x28);

+      *(undefined8 *)(param_3 + 0x20) = *(undefined8 *)(param_2 + 0x20);

+      *(undefined8 *)(param_3 + 0x28) = uVar17;

+      uVar17 = *(undefined8 *)(param_2 + 0x38);

+      *(undefined8 *)(param_3 + 0x30) = *(undefined8 *)(param_2 + 0x30);

+      *(undefined8 *)(param_3 + 0x38) = uVar17;

+      *(float *)(param_3 + 0x40) = *(float *)(param_2 + 0x40);

+      if (((ABS(fVar36) < 8.138021e-05) && (ABS(fVar45) < 8.138021e-05)) &&

+         (ABS(fVar33) < 8.138021e-05)) {

+        return;

+      }

+      cVar21 = (char)((char)param_3[0x41] << 2) >> 6;

+      *(float *)(param_3 + 0x30) =

+           fVar45 * *(float *)(param_3 + 0x10) + fVar36 * *(float *)param_3 +

+           fVar33 * *(float *)(param_3 + 0x20) + *(float *)(param_3 + 0x30);

+      *(float *)(param_3 + 0x34) =

+           fVar45 * *(float *)(param_3 + 0x14) + fVar36 * *(float *)(param_3 + 4) +

+           fVar33 * *(float *)(param_3 + 0x24) + *(float *)(param_3 + 0x34);

+      *(float *)(param_3 + 0x38) =

+           fVar45 * *(float *)(param_3 + 0x18) + fVar36 * *(float *)(param_3 + 8) +

+           fVar33 * *(float *)(param_3 + 0x28) + *(float *)(param_3 + 0x38);

+      if (cVar21 < '\x01') {

+        if (cVar21 < '\0') {

+          fVar44 = *(float *)(param_3 + 0x2c);

+        }

+        else {

+          if (8.138021e-05 <=

+              ABS((ABS(*(float *)(param_3 + 0x1c)) * 61440.0 +

+                   ABS(*(float *)(param_3 + 0xc)) * 61440.0 + ABS(*(float *)(param_3 + 0x3c))) - 1.0

+                 )) goto LAB_4;

+          fVar44 = *(float *)(param_3 + 0x2c);

+          param_3[0x41] = (CMILMatrix)((byte)param_3[0x41] | 0x30);

+        }

+        if (ABS(ABS(fVar44) * 61440.0 - 0.0) < 8.138021e-05) {

+LAB_3:

+          param_3[0x40] = (CMILMatrix)((byte)param_3[0x40] & 0xfc);

+          return;

+        }

+      }

+LAB_4:

+      uStack_17c._4_4_ = 0.0;

+      *(float *)(param_3 + 0x3c) =

+           fVar45 * *(float *)(param_3 + 0x1c) + fVar36 * *(float *)(param_3 + 0xc) +

+           fVar33 * *(float *)(param_3 + 0x2c) + *(float *)(param_3 + 0x3c);

+      goto LAB_1;

+    }

+    fVar36 = *(float *)(param_2 + 0x30);

+    fVar45 = *(float *)(param_2 + 0x38);

+    fVar33 = *(float *)(param_2 + 0x34);

+    if (((ABS(fVar36) < 8.138021e-05) && (ABS(fVar33) < 8.138021e-05)) &&

+       (ABS(fVar45) < 8.138021e-05)) {

+      return;

+    }

+    CVar23 = param_3[0x41];

+    cVar21 = (char)((char)CVar23 << 2) >> 6;

+    if (cVar21 < '\x01') {

+      if (cVar21 < '\0') {

+        fVar44 = *(float *)(param_3 + 0x2c);

+      }

+      else {

+        if (8.138021e-05 <=

+            ABS((ABS(*(float *)(param_3 + 0x1c)) * 61440.0 +

+                 ABS(*(float *)(param_3 + 0xc)) * 61440.0 + ABS(*(float *)(param_3 + 0x3c))) - 1.0))

+        {

+          CVar23 = (CMILMatrix)((byte)CVar23 & 0xdf | 0x10);

+          goto LAB_5;

+        }

+        fVar44 = *(float *)(param_3 + 0x2c);

+        CVar23 = (CMILMatrix)((byte)CVar23 | 0x30);

+        param_3[0x41] = CVar23;

+      }

+      if (ABS(ABS(fVar44) * 61440.0 - 0.0) < 8.138021e-05) {

+        *(float *)(param_3 + 0x30) = fVar36 + *(float *)(param_3 + 0x30);

+        *(float *)(param_3 + 0x34) = fVar33 + *(float *)(param_3 + 0x34);

+        *(float *)(param_3 + 0x38) = fVar45 + *(float *)(param_3 + 0x38);

+        goto LAB_6;

+      }

+    }

+LAB_5:

+    fVar44 = *(float *)(param_3 + 0xc);

+    fVar30 = *(float *)(param_3 + 0x1c);

+    param_3[0x41] = (CMILMatrix)((byte)CVar23 & 0xf3);

+    *(float *)param_3 = fVar44 * fVar36 + *(float *)param_3;

+    *(float *)(param_3 + 4) = fVar44 * fVar33 + *(float *)(param_3 + 4);

+    *(float *)(param_3 + 8) = fVar44 * fVar45 + *(float *)(param_3 + 8);

+    fVar44 = *(float *)(param_3 + 0x2c);

+    *(float *)(param_3 + 0x10) = fVar30 * fVar36 + *(float *)(param_3 + 0x10);

+    *(float *)(param_3 + 0x14) = fVar30 * fVar33 + *(float *)(param_3 + 0x14);

+    *(float *)(param_3 + 0x18) = fVar30 * fVar45 + *(float *)(param_3 + 0x18);

+    fVar30 = *(float *)(param_3 + 0x3c);

+    *(float *)(param_3 + 0x20) = fVar44 * fVar36 + *(float *)(param_3 + 0x20);

+    *(float *)(param_3 + 0x24) = fVar44 * fVar33 + *(float *)(param_3 + 0x24);

+    *(float *)(param_3 + 0x28) = fVar44 * fVar45 + *(float *)(param_3 + 0x28);

+    *(float *)(param_3 + 0x30) = fVar30 * fVar36 + *(float *)(param_3 + 0x30);

+    *(float *)(param_3 + 0x34) = fVar30 * fVar33 + *(float *)(param_3 + 0x34);

+    *(float *)(param_3 + 0x38) = fVar30 * fVar45 + *(float *)(param_3 + 0x38);

+LAB_6:

+    param_3[0x40] = (CMILMatrix)((byte)param_3[0x40] & 0xfc);

+    return;

+  }

+  uVar27 = *(uint *)(param_1 + 0x40);

+  local_1b8 = *(float *)param_1;

+  fStack_1b4 = *(float *)(param_1 + 4);

+  fVar36 = *(float *)(param_1 + 8);

+  fVar45 = *(float *)(param_1 + 0xc);

+  uStack_1b0 = *(undefined8 *)(param_1 + 8);

+  bVar24 = (byte)uVar27;

+  local_1a8 = *(float *)(param_1 + 0x10);

+  fStack_1a4 = *(float *)(param_1 + 0x14);

+  fVar33 = *(float *)(param_1 + 0x18);

+  fVar44 = *(float *)(param_1 + 0x1c);

+  uStack_1a0 = *(undefined8 *)(param_1 + 0x18);

+  pCVar28 = param_1 + 0x20;

+  fVar30 = *(float *)pCVar28;

+  fVar31 = *(float *)(param_1 + 0x24);

+  local_198 = *(undefined8 *)pCVar28;

+  fStack_190 = *(float *)(param_1 + 0x28);

+  fStack_18c = *(float *)(param_1 + 0x2c);

+  auVar18 = *(undefined1 (*) [16])pCVar28;

+  local_188 = *(float *)(param_1 + 0x30);

+  fStack_184 = *(float *)(param_1 + 0x34);

+  fStack_180 = *(float *)(param_1 + 0x38);

+  fVar39 = *(float *)(param_1 + 0x3c);

+  uVar19 = *(ulonglong *)(param_1 + 0x3c);

+  cVar21 = (char)(bVar24 << 6) >> 6;

+  uStack_17c._5_1_ = (byte)(uVar19 >> 0x28);

+  bVar22 = uStack_17c._5_1_;

+  uStack_17c = uVar19;

+  if ('\0' < cVar21) {

+    local_158._0_4_ = fStack_184;

+    local_b8._0_4_ = fVar31;

+    local_168._0_4_ = fStack_180;

+    local_d8._0_4_ = fVar44;

+    local_128._0_4_ = fStack_190;

+    local_138._0_4_ = fStack_1a4;

+    local_f8._0_4_ = fVar33;

+    local_108._0_4_ = fVar36;

+    local_c8._0_4_ = fVar30;

+    local_e8._0_4_ = fVar45;

+    local_148._0_4_ = local_1b8;

+    goto LAB_7;

+  }

+  if (cVar21 < '\0') {

+LAB_8:

+    fVar40 = *(float *)param_2;

+    fVar41 = *(float *)(param_2 + 4);

+    fVar36 = *(float *)(param_2 + 8);

+    fVar45 = *(float *)(param_2 + 0xc);

+    fVar42 = *(float *)(param_2 + 0x40);

+    fVar34 = *(float *)(param_2 + 0x10);

+    fVar32 = *(float *)(param_2 + 0x14);

+    fVar33 = *(float *)(param_2 + 0x18);

+    fVar44 = *(float *)(param_2 + 0x1c);

+    fVar30 = *(float *)(param_2 + 0x20);

+    fVar31 = *(float *)(param_2 + 0x24);

+    fVar29 = *(float *)(param_2 + 0x28);

+    fVar43 = *(float *)(param_2 + 0x2c);

+    fVar35 = *(float *)(param_2 + 0x30);

+    fVar37 = *(float *)(param_2 + 0x34);

+    fVar38 = *(float *)(param_2 + 0x38);

+    fVar39 = *(float *)(param_2 + 0x3c);

+LAB_9:

+    uStack_17c = (ulonglong)(uint)fVar42 << 0x20;

+  }

+  else {

+    cVar21 = (char)(uStack_17c._5_1_ << 4) >> 6;

+    if (cVar21 < '\x01') {

+      local_b8._4_4_ = fVar31;

+      local_b8._0_4_ = fVar31;

+      fStack_b0 = fVar31;

+      fStack_ac = fVar31;

+      local_d8._4_4_ = fVar44;

+      local_d8._0_4_ = fVar44;

+      fStack_d0 = fVar44;

+      fStack_cc = fVar44;

+      local_e8._4_4_ = fVar45;

+      local_e8._0_4_ = fVar45;

+      fStack_e0 = fVar45;

+      fStack_dc = fVar45;

+      if (-1 < cVar21) {

+        cVar21 = (char)(uStack_17c._5_1_ << 2) >> 6;

+        uStack_17c._6_2_ = (undefined2)(uVar27 >> 0x10);

+        uStack_17c._0_5_ = (undefined5)uVar19;

+        if (cVar21 < '\x01') {

+          if (-1 < cVar21) {

+            if (8.138021e-05 <=

+                ABS((ABS(fVar44) * 61440.0 + ABS(fVar45) * 61440.0 + ABS(fVar39)) - 1.0)) {

+              uStack_17c._5_1_ = uStack_17c._5_1_ & 0xdf | 0x10;

+              goto LAB_10;

+            }

+            uStack_17c._5_1_ = uStack_17c._5_1_ | 0x30;

+          }

+          if (((ABS(ABS(fStack_18c) * 61440.0 - 0.0) < 8.138021e-05) &&

+              (ABS(fVar30 - 0.0) < 8.138021e-05)) && (ABS(fVar31 - 0.0) < 8.138021e-05)) {

+            bVar22 = uStack_17c._5_1_ | 0xc;

+            uStack_17c = CONCAT26(uStack_17c._6_2_,CONCAT15(uStack_17c._5_1_,(undefined5)uStack_17c)

+                                 ) | 0xc0000000000;

+            uVar19 = uStack_17c;

+            goto LAB_11;

+          }

+        }

+LAB_10:

+        bVar22 = uStack_17c._5_1_ & 0xf7 | 4;

+        uStack_17c = CONCAT26(uStack_17c._6_2_,CONCAT15(uStack_17c._5_1_,(undefined5)uStack_17c)) &

+                     0xfffff7ffffffffff | 0x40000000000;

+        goto LAB_12;

+      }

+LAB_11:

+      uStack_17c = uVar19;

+      cVar21 = (char)(bVar24 << 4) >> 6;

+      if ('\0' < cVar21) goto LAB_12;

+      local_108._4_4_ = fVar36;

+      local_108._0_4_ = fVar36;

+      fStack_100 = fVar36;

+      fStack_fc = fVar36;

+      local_f8._4_4_ = fVar33;

+      local_f8._0_4_ = fVar33;

+      fStack_f0 = fVar33;

+      fStack_ec = fVar33;

+      local_c8 = auVar18;

+      if (cVar21 < '\0') {

+LAB_13:

+        bVar24 = (byte)uVar27;

+        cVar21 = (char)(bVar24 << 2) >> 6;

+        if ('\0' < cVar21) goto LAB_14;

+        if (cVar21 < '\0') {

+          local_138._4_4_ = fStack_1a4;

+          local_138._0_4_ = fStack_1a4;

+          fStack_130 = fStack_1a4;

+          fStack_12c = fStack_1a4;

+          local_148 = *(undefined1 (*) [16])param_1;

+        }

+        else {

+          bVar20 = IsTranslateAndScaleIgnoreZ<1>((CMILMatrix *)&local_1b8);

+          local_148 = ZEXT416((uint)local_1b8);

+          _local_138 = ZEXT416((uint)fStack_1a4);

+          bVar22 = uStack_17c._5_1_;

+          fVar39 = (float)uStack_17c;

+          fVar30 = (float)local_198;

+          fVar31 = local_198._4_4_;

+          fVar33 = (float)uStack_1a0;

+          fVar44 = uStack_1a0._4_4_;

+          fVar36 = (float)uStack_1b0;

+          fVar45 = uStack_1b0._4_4_;

+          if (((!bVar20) || (8.138021e-05 <= ABS(local_1b8 - 1.0))) ||

+             (8.138021e-05 <= ABS(fStack_1a4 - 1.0))) {

+            uVar27 = (uint)(uStack_17c._4_1_ & 0xdd | 0x11);

+            _local_158 = ZEXT416((uint)fStack_184);

+            _local_b8 = ZEXT416((uint)local_198._4_4_);

+            _local_168 = ZEXT416((uint)fStack_180);

+            _local_d8 = ZEXT416((uint)uStack_1a0._4_4_);

+            _local_128 = ZEXT416((uint)fStack_190);

+            _local_e8 = ZEXT416((uint)uStack_1b0._4_4_);

+            _local_108 = ZEXT416((uint)(float)uStack_1b0);

+            _local_f8 = ZEXT416((uint)(float)uStack_1a0);

+            uStack_17c = uStack_17c & 0xffffffddffffffff | 0x1100000000;

+            local_c8 = ZEXT416((uint)(float)local_198);

+            goto LAB_7;

+          }

+          bVar24 = uStack_17c._4_1_ | 0x30;

+          _local_b8 = ZEXT416((uint)local_198._4_4_);

+          _local_d8 = ZEXT416((uint)uStack_1a0._4_4_);

+          _local_e8 = ZEXT416((uint)uStack_1b0._4_4_);

+          local_c8 = ZEXT416((uint)(float)local_198);

+          _local_108 = ZEXT416((uint)(float)uStack_1b0);

+          _local_f8 = ZEXT416((uint)(float)uStack_1a0);

+        }

+        local_128._4_4_ = fStack_190;

+        local_128._0_4_ = fStack_190;

+        fStack_120 = fStack_190;

+        fStack_11c = fStack_190;

+        if ((8.138021e-05 <= ABS(fStack_190 - 1.0)) || (8.138021e-05 <= ABS(local_188 - 0.0))) {

+          local_168._0_4_ = fStack_180;

+          local_158._0_4_ = fStack_184;

+        }

+        else {

+          local_158._4_4_ = fStack_184;

+          local_158._0_4_ = fStack_184;

+          fStack_150 = fStack_184;

+          fStack_14c = fStack_184;

+          if (8.138021e-05 <= ABS(fStack_184 - 0.0)) {

+            uVar27 = (uint)(bVar24 & 0xfd);

+            local_168._4_4_ = fStack_180;

+            local_168._0_4_ = fStack_180;

+            fStack_160 = fStack_180;

+            fStack_15c = fStack_180;

+            uStack_17c = CONCAT35(uStack_17c._5_3_,CONCAT14(bVar24,(float)uStack_17c)) &

+                         0xfffffffdffffffff | 0x100000000;

+            goto LAB_7;

+          }

+          local_168._4_4_ = fStack_180;

+          local_168._0_4_ = fStack_180;

+          fStack_160 = fStack_180;

+          fStack_15c = fStack_180;

+          if (ABS(fStack_180 - 0.0) < 8.138021e-05) goto LAB_8;

+        }

+        goto LAB_15;

+      }

+      cVar21 = (char)(bVar22 << 2) >> 6;

+      bVar25 = bVar22;

+      if (cVar21 < '\x01') {

+        if (-1 < cVar21) {

+          if (8.138021e-05 <=

+              ABS((ABS(fVar44) * 61440.0 + ABS(fVar45) * 61440.0 + ABS(fVar39)) - 1.0)) {

+            bVar25 = bVar22 & 0xdf | 0x10;

+            uStack_17c = CONCAT26(uStack_17c._6_2_,CONCAT15(bVar22,(undefined5)uStack_17c)) &

+                         0xffffdfffffffffff | 0x100000000000;

+            goto LAB_16;

+          }

+          uStack_17c = CONCAT26(uStack_17c._6_2_,CONCAT15(bVar22,(undefined5)uStack_17c)) |

+                       0x300000000000;

+          bVar22 = bVar22 | 0x30;

+        }

+        bVar25 = bVar22;

+        if ((ABS(fVar36 - 0.0) < 8.138021e-05) && (ABS(fVar33 - 0.0) < 8.138021e-05)) {

+          uVar27 = (uint)(bVar24 | 0xc);

+          uStack_17c = CONCAT35(uStack_17c._5_3_,CONCAT14(bVar24,(float)uStack_17c)) | 0xc00000000;

+          goto LAB_13;

+        }

+      }

+LAB_16:

+      uVar27 = (uint)(bVar24 & 0xf5 | 5);

+      local_168._4_4_ = fStack_180;

+      local_168._0_4_ = fStack_180;

+      fStack_160 = fStack_180;

+      fStack_15c = fStack_180;

+      uStack_17c = CONCAT35(uStack_17c._5_3_,CONCAT14(bVar24,(float)uStack_17c)) &

+                   0xfffffff5ffffffff | 0x500000000;

+      local_158._4_4_ = fStack_184;

+      local_158._0_4_ = fStack_184;

+      fStack_150 = fStack_184;

+      fStack_14c = fStack_184;

+      local_138._4_4_ = fStack_1a4;

+      local_138._0_4_ = fStack_1a4;

+      fStack_130 = fStack_1a4;

+      fStack_12c = fStack_1a4;

+      local_128._4_4_ = fStack_190;

+      local_128._0_4_ = fStack_190;

+      fStack_120 = fStack_190;

+      fStack_11c = fStack_190;

+      bVar22 = bVar25;

+      local_148 = *(undefined1 (*) [16])param_1;

+    }

+    else {

+      local_b8._4_4_ = fVar31;

+      local_b8._0_4_ = fVar31;

+      fStack_b0 = fVar31;

+      fStack_ac = fVar31;

+      local_e8._0_4_ = fVar45;

+      local_d8._0_4_ = fVar44;

+LAB_12:

+      local_f8._4_4_ = fVar33;

+      local_f8._0_4_ = fVar33;

+      fStack_f0 = fVar33;

+      fStack_ec = fVar33;

+      local_108._4_4_ = fVar36;

+      local_108._0_4_ = fVar36;

+      fStack_100 = fVar36;

+      fStack_fc = fVar36;

+LAB_14:

+      local_168._4_4_ = fStack_180;

+      local_168._0_4_ = fStack_180;

+      fStack_160 = fStack_180;

+      local_128._4_4_ = fStack_190;

+      local_128._0_4_ = fStack_190;

+      local_138._4_4_ = fStack_1a4;

+      local_138._0_4_ = fStack_1a4;

+      local_158._4_4_ = fStack_184;

+      local_158._0_4_ = fStack_184;

+      fStack_120 = fStack_190;

+      fStack_130 = fStack_1a4;

+      fStack_150 = fStack_184;

+      local_c8 = *(undefined1 (*) [16])pCVar28;

+      fStack_15c = fStack_180;

+      fStack_11c = fStack_190;

+      fStack_12c = fStack_1a4;

+      fStack_14c = fStack_184;

+      bVar24 = (byte)uVar27;

+      local_148 = *(undefined1 (*) [16])param_1;

+LAB_15:

+      uVar27 = (uint)(bVar24 & 0xfd);

+      uStack_17c = CONCAT35(uStack_17c._5_3_,CONCAT14(bVar24,(float)uStack_17c)) &

+                   0xfffffffdffffffff | 0x100000000;

+    }

+LAB_7:

+    fVar38 = fStack_180;

+    fVar37 = fStack_184;

+    fVar35 = local_188;

+    fVar43 = fStack_18c;

+    fVar29 = fStack_190;

+    fVar32 = fStack_1a4;

+    fVar34 = local_1a8;

+    fVar41 = fStack_1b4;

+    fVar40 = local_1b8;

+    uVar26 = (undefined1)uVar27;

+    bVar20 = IsIdentity<1>(param_2);

+    if (!bVar20) {

+      CVar23 = param_2[0x41];

+      if ((char)(((byte)CVar23 & 0xfc) << 4) < '\x01') {

+        if (((byte)CVar23 & 8) == 0) {

+          cVar21 = (char)((char)CVar23 << 2) >> 6;

+          if (cVar21 < '\x01') {

+            if (cVar21 < '\0') {

+              if (ABS(ABS(*(float *)(param_2 + 0x2c)) * 61440.0 - 0.0) < 8.138021e-05) {

+                CVar23 = param_2[0x41];

+LAB_17:

+                if ((ABS(*(float *)(param_2 + 0x20) - 0.0) < 8.138021e-05) &&

+                   (ABS(*(float *)(param_2 + 0x24) - 0.0) < 8.138021e-05)) {

+                  CVar23 = (CMILMatrix)((byte)CVar23 | 0xc);

+                  param_2[0x41] = CVar23;

+                  goto LAB_18;

+                }

+              }

+            }

+            else {

+              if (8.138021e-05 <=

+                  ABS((ABS(*(float *)(param_2 + 0x1c)) * 61440.0 +

+                       ABS(*(float *)(param_2 + 0xc)) * 61440.0 + ABS(*(float *)(param_2 + 0x3c))) -

+                      1.0)) {

+                param_2[0x41] = (CMILMatrix)((byte)CVar23 & 0xd7 | 0x14);

+                goto LAB_19;

+              }

+              CVar23 = (CMILMatrix)((byte)CVar23 | 0x30);

+              if (ABS(ABS(*(float *)(param_2 + 0x2c)) * 61440.0 - 0.0) < 8.138021e-05)

+              goto LAB_17;

+            }

+          }

+          param_2[0x41] = (CMILMatrix)((byte)CVar23 & 0xf7 | 4);

+        }

+        else {

+LAB_18:

+          cVar21 = (char)((char)param_2[0x40] << 4) >> 6;

+          if (cVar21 < '\x01') {

+            if (cVar21 < '\0') {

+LAB_20:

+              cVar21 = (char)((char)param_2[0x40] << 2) >> 6;

+              if (cVar21 < '\x01') {

+                if (-1 < cVar21) {

+                  bVar20 = IsTranslateAndScaleIgnoreZ<1>(param_2);

+                  if (((!bVar20) || (8.138021e-05 <= ABS(*(float *)param_2 - 1.0))) ||

+                     (8.138021e-05 <= ABS(*(float *)(param_2 + 0x14) - 1.0))) {

+                    param_2[0x40] = (CMILMatrix)((byte)param_2[0x40] & 0xdf | 0x10);

+                    goto LAB_19;

+                  }

+                  param_2[0x40] = (CMILMatrix)((byte)param_2[0x40] | 0x30);

+                }

+                if (ABS(*(float *)(param_2 + 0x28) - 1.0) < 8.138021e-05) {

+                  local_188 = *(float *)(param_2 + 0x30);

+                  fVar42 = *(float *)(param_2 + 0x38);

+                  fStack_184 = *(float *)(param_2 + 0x34);

+                  if (((ABS(local_188) < 8.138021e-05) && (ABS(fStack_184) < 8.138021e-05)) &&

+                     (ABS(fVar42) < 8.138021e-05)) goto LAB_21;

+                  cVar21 = (char)(bVar22 << 2) >> 6;

+                  if (cVar21 < '\x01') {

+                    if (-1 < cVar21) {

+                      if (ABS((ABS((float)local_d8._0_4_) * 61440.0 +

+                               ABS((float)local_e8._0_4_) * 61440.0 + ABS(fVar39)) - 1.0) <

+                          8.138021e-05) {

+                        uStack_17c = CONCAT26(uStack_17c._6_2_,

+                                              CONCAT15(bVar22,(undefined5)uStack_17c)) |

+                                     0x300000000000;

+                        bVar22 = bVar22 | 0x30;

+                        if (ABS(ABS(fVar43) * 61440.0 - 0.0) < 8.138021e-05) goto LAB_22;

+                      }

+                      else {

+                        bVar22 = bVar22 & 0xdf | 0x10;

+                      }

+                      goto LAB_23;

+                    }

+                    if (8.138021e-05 <= ABS(ABS(fVar43) * 61440.0 - 0.0)) goto LAB_23;

+                  }

+                  else {

+LAB_23:

+                    uStack_17c = CONCAT26(uStack_17c._6_2_,CONCAT15(bVar22,(undefined5)uStack_17c))

+                                 & 0xfffff3ffffffffff;

+                    fVar40 = (float)local_148._0_4_ + local_188 * (float)local_e8._0_4_;

+                    fVar41 = fStack_1b4 + fStack_184 * (float)local_e8._0_4_;

+                    fVar36 = (float)local_108._0_4_ + fVar42 * (float)local_e8._0_4_;

+                    fVar34 = local_1a8 + local_188 * (float)local_d8._0_4_;

+                    fVar32 = (float)local_138._0_4_ + fStack_184 * (float)local_d8._0_4_;

+                    fVar33 = (float)local_f8._0_4_ + fVar42 * (float)local_d8._0_4_;

+                    fStack_184 = *(float *)(param_2 + 0x34) * fVar39;

+                    fVar30 = (float)local_c8._0_4_ + local_188 * fVar43;

+                    fVar42 = *(float *)(param_2 + 0x38) * fVar39;

+                    fVar31 = (float)local_b8._0_4_ + *(float *)(param_2 + 0x34) * fVar43;

+                    fVar29 = (float)local_128._0_4_ + *(float *)(param_2 + 0x38) * fVar43;

+                    local_188 = *(float *)(param_2 + 0x30) * fVar39;

+                    fVar43 = fStack_18c;

+                    fVar44 = uStack_1a0._4_4_;

+                    fVar45 = uStack_1b0._4_4_;

+                  }

+LAB_22:

+                  fStack_184 = (float)local_158._0_4_ + fStack_184;

+                  local_188 = fVar35 + local_188;

+                  fVar39 = (float)uStack_17c;

+                  uStack_17c = (ulonglong)(CONCAT31(uStack_17c._5_3_,uVar26) & 0xfffffffc) << 0x20;

+                  fVar35 = local_188;

+                  fVar37 = fStack_184;

+                  fVar38 = (float)local_168._0_4_ + fVar42;

+                  goto LAB_21;

+                }

+              }

+            }

+            else {

+              cVar21 = (char)((char)CVar23 << 2) >> 6;

+              if (cVar21 < '\x01') {

+                if (-1 < cVar21) {

+                  if (8.138021e-05 <=

+                      ABS((ABS(*(float *)(param_2 + 0x1c)) * 61440.0 +

+                           ABS(*(float *)(param_2 + 0xc)) * 61440.0 +

+                          ABS(*(float *)(param_2 + 0x3c))) - 1.0)) {

+                    param_2[0x41] = (CMILMatrix)((byte)CVar23 & 0xdf | 0x10);

+                    param_2[0x40] = (CMILMatrix)((byte)param_2[0x40] & 0xf7 | 4);

+                    goto LAB_19;

+                  }

+                  param_2[0x41] = (CMILMatrix)((byte)CVar23 | 0x30);

+                }

+                if ((ABS(*(float *)(param_2 + 8) - 0.0) < 8.138021e-05) &&

+                   (ABS(*(float *)(param_2 + 0x18) - 0.0) < 8.138021e-05)) {

+                  param_2[0x40] = (CMILMatrix)((byte)param_2[0x40] | 0xc);

+                  goto LAB_20;

+                }

+              }

+              param_2[0x40] = (CMILMatrix)((byte)param_2[0x40] & 0xf7 | 4);

+            }

+          }

+        }

+      }

+LAB_19:

+      bVar20 = IsTranslate<1>((CMILMatrix *)&local_1b8);

+      if (bVar20) {

+        fVar35 = *(float *)(param_2 + 0x30);

+        fVar37 = *(float *)(param_2 + 0x34);

+        fVar38 = *(float *)(param_2 + 0x38);

+        fVar39 = *(float *)(param_2 + 0x3c);

+        uVar19 = *(ulonglong *)(param_2 + 0x3c);

+        fVar40 = *(float *)param_2;

+        fVar41 = *(float *)(param_2 + 4);

+        fVar36 = *(float *)(param_2 + 8);

+        fVar45 = *(float *)(param_2 + 0xc);

+        fVar34 = *(float *)(param_2 + 0x10);

+        fVar32 = *(float *)(param_2 + 0x14);

+        fVar33 = *(float *)(param_2 + 0x18);

+        fVar44 = *(float *)(param_2 + 0x1c);

+        fVar30 = *(float *)(param_2 + 0x20);

+        fVar31 = *(float *)(param_2 + 0x24);

+        fVar29 = *(float *)(param_2 + 0x28);

+        fVar43 = *(float *)(param_2 + 0x2c);

+        if (((8.138021e-05 <= ABS(local_188)) || (8.138021e-05 <= ABS(fStack_184))) ||

+           (uStack_17c = uVar19, 8.138021e-05 <= ABS(fStack_180))) {

+          uStack_17c._5_1_ = (byte)((uint)*(undefined4 *)(param_2 + 0x40) >> 8);

+          cVar21 = (char)(uStack_17c._5_1_ << 2) >> 6;

+          fVar35 = fVar35 + fStack_184 * fVar34 + local_188 * fVar40 + fStack_180 * fVar30;

+          fVar37 = fVar37 + local_188 * fVar41 + fStack_184 * fVar32 + fStack_180 * fVar31;

+          fVar38 = fVar38 + fStack_184 * fVar33 + local_188 * fVar36 + fStack_180 * fVar29;

+          if (cVar21 < '\x01') {

+            if (-1 < cVar21) {

+              if (8.138021e-05 <=

+                  ABS((ABS(fVar44) * 61440.0 + ABS(fVar45) * 61440.0 + ABS(fVar39)) - 1.0))

+              goto LAB_24;

+              uStack_17c._6_2_ = (undefined2)((uint)*(undefined4 *)(param_2 + 0x40) >> 0x10);

+              uStack_17c._0_5_ = (undefined5)uVar19;

+              uStack_17c = CONCAT26(uStack_17c._6_2_,

+                                    CONCAT15(uStack_17c._5_1_,(undefined5)uStack_17c)) |

+                           0x300000000000;

+              uVar19 = uStack_17c;

+            }

+            if (ABS(ABS(fVar43) * 61440.0 - 0.0) < 8.138021e-05) {

+              uStack_17c = uVar19 & 0xfffffffcffffffff;

+              fVar39 = (float)uStack_17c;

+              goto LAB_21;

+            }

+          }

+LAB_24:

+          fVar42 = 0.0;

+          fVar39 = fVar39 + fStack_184 * fVar44 + local_188 * fVar45 + fStack_180 * fVar43;

+          goto LAB_9;

+        }

+      }

+      else {

+        bVar20 = IsTranslateAndScale<1>(param_2);

+        if (bVar20) {

+          fVar36 = *(float *)param_2;

+          fVar45 = *(float *)(param_2 + 0x30);

+          fVar33 = *(float *)(param_2 + 0x34);

+          fVar44 = *(float *)(param_2 + 0x38);

+          fVar30 = *(float *)(param_2 + 0x28);

+          fVar31 = *(float *)(param_2 + 0x14);

+          if (((8.138021e-05 <= ABS(fVar36 - 1.0)) || (8.138021e-05 <= ABS(fVar31 - 1.0))) ||

+             (fVar39 = local_198._4_4_, fVar42 = (float)local_198, bVar22 = uStack_17c._4_1_,

+             8.138021e-05 <= ABS(fVar30 - 1.0))) {

+            local_1b8 = local_1b8 * fVar36;

+            local_1a8 = local_1a8 * fVar36;

+            fStack_1b4 = fStack_1b4 * fVar31;

+            fVar42 = (float)local_198 * fVar36;

+            local_188 = local_188 * fVar36;

+            fStack_1a4 = fStack_1a4 * fVar31;

+            fVar39 = local_198._4_4_ * fVar31;

+            fStack_184 = fStack_184 * fVar31;

+            local_198 = CONCAT44(fVar39,fVar42);

+            if (8.138021e-05 <= ABS(fVar30 - 1.0)) {

+              uStack_1b0 = CONCAT44(uStack_1b0._4_4_,(float)uStack_1b0 * fVar30);

+              fStack_190 = fStack_190 * fVar30;

+              fStack_180 = fStack_180 * fVar30;

+              uStack_1a0 = CONCAT44(uStack_1a0._4_4_,(float)uStack_1a0 * fVar30);

+            }

+            bVar22 = uStack_17c._4_1_ & 0xcc;

+            uStack_17c = uStack_17c & 0xffffffccffffffff;

+          }

+          if (((8.138021e-05 <= ABS(fVar45)) || (8.138021e-05 <= ABS(fVar33))) ||

+             (8.138021e-05 <= ABS(fVar44))) {

+            cVar21 = (char)(uStack_17c._5_1_ << 2) >> 6;

+            bVar24 = uStack_17c._5_1_;

+            if (cVar21 < '\x01') {

+              if (-1 < cVar21) {

+                if (ABS((ABS(uStack_1a0._4_4_) * 61440.0 + ABS(uStack_1b0._4_4_) * 61440.0 +

+                        ABS((float)uStack_17c)) - 1.0) < 8.138021e-05) {

+                  bVar24 = uStack_17c._5_1_ | 0x30;

+                  uStack_17c = uStack_17c | 0x300000000000;

+                  if (ABS(ABS(fStack_18c) * 61440.0 - 0.0) < 8.138021e-05) goto LAB_25;

+                }

+                else {

+                  bVar24 = uStack_17c._5_1_ & 0xdf | 0x10;

+                }

+                goto LAB_26;

+              }

+              if (8.138021e-05 <= ABS(ABS(fStack_18c) * 61440.0 - 0.0)) goto LAB_26;

+            }

+            else {

+LAB_26:

+              uStack_17c = CONCAT26(uStack_17c._6_2_,CONCAT15(bVar24,(undefined5)uStack_17c)) &

+                           0xfffff3ffffffffff;

+              local_1b8 = local_1b8 + fVar45 * uStack_1b0._4_4_;

+              fStack_1b4 = fStack_1b4 + fVar33 * uStack_1b0._4_4_;

+              uStack_1b0 = CONCAT44(uStack_1b0._4_4_,(float)uStack_1b0 + fVar44 * uStack_1b0._4_4_);

+              local_1a8 = local_1a8 + fVar45 * uStack_1a0._4_4_;

+              fStack_1a4 = fStack_1a4 + fVar33 * uStack_1a0._4_4_;

+              fVar36 = fVar45 * fStack_18c;

+              uStack_1a0 = CONCAT44(uStack_1a0._4_4_,(float)uStack_1a0 + fVar44 * uStack_1a0._4_4_);

+              fStack_190 = fStack_190 + fVar44 * fStack_18c;

+              fVar45 = fVar45 * (float)uStack_17c;

+              local_198 = CONCAT44(fVar39 + fVar33 * fStack_18c,fVar42 + fVar36);

+              fVar33 = fVar33 * (float)uStack_17c;

+              fVar44 = fVar44 * (float)uStack_17c;

+            }

+LAB_25:

+            fStack_180 = fStack_180 + fVar44;

+            fStack_184 = fStack_184 + fVar33;

+            uStack_17c = CONCAT35(uStack_17c._5_3_,CONCAT14(bVar22,(float)uStack_17c)) &

+                         0xfffffffcffffffff;

+            local_188 = local_188 + fVar45;

+          }

+          fVar35 = local_188;

+          fVar37 = fStack_184;

+          fVar38 = fStack_180;

+          fVar39 = (float)uStack_17c;

+          fVar30 = (float)local_198;

+          fVar31 = local_198._4_4_;

+          fVar29 = fStack_190;

+          fVar43 = fStack_18c;

+          fVar34 = local_1a8;

+          fVar32 = fStack_1a4;

+          fVar33 = (float)uStack_1a0;

+          fVar44 = uStack_1a0._4_4_;

+          fVar40 = local_1b8;

+          fVar41 = fStack_1b4;

+          fVar36 = (float)uStack_1b0;

+          fVar45 = uStack_1b0._4_4_;

+        }

+        else {

+          bVar20 = IsPure2DUniformZ<1>((CMILMatrix *)&local_1b8);

+          if ((!bVar20) || (bVar20 = IsPure2DUniformZ<1>(param_2), !bVar20)) {

+            fVar42 = 0.0;

+            fVar39 = *(float *)param_2;

+            fVar37 = *(float *)(param_2 + 4);

+            fVar38 = *(float *)(param_2 + 8);

+            fVar2 = *(float *)(param_2 + 0xc);

+            fVar35 = *(float *)(param_2 + 0x10);

+            fVar3 = *(float *)(param_2 + 0x14);

+            fVar4 = *(float *)(param_2 + 0x18);

+            fVar5 = *(float *)(param_2 + 0x1c);

+            fVar6 = *(float *)(param_2 + 0x20);

+            fVar7 = *(float *)(param_2 + 0x24);

+            fVar8 = *(float *)(param_2 + 0x28);

+            fVar9 = *(float *)(param_2 + 0x2c);

+            fVar10 = *(float *)(param_2 + 0x30);

+            fVar11 = *(float *)(param_2 + 0x34);

+            fVar12 = *(float *)(param_2 + 0x38);

+            fVar13 = *(float *)(param_2 + 0x3c);

+            fVar40 = uStack_1b0._4_4_ * fVar10 + fStack_1b4 * fVar35 +

+                     (float)uStack_1b0 * fVar6 + local_1b8 * fVar39;

+            fVar41 = uStack_1b0._4_4_ * fVar11 + fStack_1b4 * fVar3 +

+                     (float)uStack_1b0 * fVar7 + local_1b8 * fVar37;

+            fVar36 = uStack_1b0._4_4_ * fVar12 + fStack_1b4 * fVar4 +

+                     (float)uStack_1b0 * fVar8 + local_1b8 * fVar38;

+            fVar45 = uStack_1b0._4_4_ * fVar13 + fStack_1b4 * fVar5 +

+                     (float)uStack_1b0 * fVar9 + local_1b8 * fVar2;

+            fVar34 = uStack_1a0._4_4_ * fVar10 + fStack_1a4 * fVar35 +

+                     (float)uStack_1a0 * fVar6 + local_1a8 * fVar39;

+            fVar32 = uStack_1a0._4_4_ * fVar11 + fStack_1a4 * fVar3 +

+                     (float)uStack_1a0 * fVar7 + local_1a8 * fVar37;

+            fVar33 = uStack_1a0._4_4_ * fVar12 + fStack_1a4 * fVar4 +

+                     (float)uStack_1a0 * fVar8 + local_1a8 * fVar38;

+            fVar44 = uStack_1a0._4_4_ * fVar13 + fStack_1a4 * fVar5 +

+                     (float)uStack_1a0 * fVar9 + local_1a8 * fVar2;

+            fVar30 = fStack_18c * fVar10 + local_198._4_4_ * fVar35 +

+                     fStack_190 * fVar6 + (float)local_198 * fVar39;

+            fVar31 = fStack_18c * fVar11 + local_198._4_4_ * fVar3 +

+                     fStack_190 * fVar7 + (float)local_198 * fVar37;

+            fVar29 = fStack_18c * fVar12 + local_198._4_4_ * fVar4 +

+                     fStack_190 * fVar8 + (float)local_198 * fVar38;

+            fVar43 = fStack_18c * fVar13 + local_198._4_4_ * fVar5 +

+                     fStack_190 * fVar9 + (float)local_198 * fVar2;

+            fVar35 = (float)uStack_17c * fVar10 + fStack_184 * fVar35 +

+                     fStack_180 * fVar6 + local_188 * fVar39;

+            fVar37 = (float)uStack_17c * fVar11 + fStack_184 * fVar3 +

+                     fStack_180 * fVar7 + local_188 * fVar37;

+            fVar38 = (float)uStack_17c * fVar12 + fStack_184 * fVar4 +

+                     fStack_180 * fVar8 + local_188 * fVar38;

+            fVar39 = (float)uStack_17c * fVar13 + fStack_184 * fVar5 +

+                     fStack_180 * fVar9 + local_188 * fVar2;

+            goto LAB_9;

+          }

+          fVar36 = *(float *)param_2;

+          fVar45 = *(float *)(param_2 + 0x14);

+          fVar42 = *(float *)(param_2 + 4);

+          fVar40 = *(float *)(param_2 + 0x10);

+          fStack_18c = 0.0;

+          uStack_17c = 0x28083f800000;

+          uStack_17c._0_4_ = 1.0;

+          uStack_1a0._0_4_ = 0.0;

+          uStack_1a0._4_4_ = 0.0;

+          uStack_1b0._0_4_ = 0.0;

+          uStack_1b0._4_4_ = 0.0;

+          local_198._0_4_ = 0.0;

+          local_198._4_4_ = 0.0;

+          fVar35 = fVar40 * fStack_184 + fVar36 * local_188 + *(float *)(param_2 + 0x30);

+          fVar37 = fVar45 * fStack_184 + fVar42 * local_188 + *(float *)(param_2 + 0x34);

+          fVar38 = *(float *)(param_2 + 0x28) * fStack_180 + *(float *)(param_2 + 0x38);

+          fVar39 = (float)uStack_17c;

+          fVar30 = (float)local_198;

+          fVar31 = local_198._4_4_;

+          fVar29 = fStack_190 * *(float *)(param_2 + 0x28);

+          fVar43 = fStack_18c;

+          fVar34 = fVar40 * fStack_1a4 + fVar36 * local_1a8;

+          fVar32 = fVar45 * fStack_1a4 + fVar42 * local_1a8;

+          fVar33 = (float)uStack_1a0;

+          fVar44 = uStack_1a0._4_4_;

+          fVar40 = fVar40 * fStack_1b4 + fVar36 * local_1b8;

+          fVar41 = fVar45 * fStack_1b4 + fVar42 * local_1b8;

+          fVar36 = (float)uStack_1b0;

+          fVar45 = uStack_1b0._4_4_;

+        }

+      }

+    }

+  }

+LAB_21:

+  *(float *)param_3 = fVar40;

+  *(float *)(param_3 + 4) = fVar41;

+  *(float *)(param_3 + 8) = fVar36;

+  *(float *)(param_3 + 0xc) = fVar45;

+  *(float *)(param_3 + 0x10) = fVar34;

+  *(float *)(param_3 + 0x14) = fVar32;

+  *(float *)(param_3 + 0x18) = fVar33;

+  *(float *)(param_3 + 0x1c) = fVar44;

+  *(float *)(param_3 + 0x20) = fVar30;

+  *(float *)(param_3 + 0x24) = fVar31;

+  *(float *)(param_3 + 0x28) = fVar29;

+  *(float *)(param_3 + 0x2c) = fVar43;

+  *(float *)(param_3 + 0x30) = fVar35;

+  *(float *)(param_3 + 0x34) = fVar37;

+  *(float *)(param_3 + 0x38) = fVar38;

+  *(float *)(param_3 + 0x3c) = fVar39;

+LAB_1:

+  *(float *)(param_3 + 0x40) = uStack_17c._4_4_;

+  return;

+}

+
```

## `CHitTestContext::PostSubgraph`  (modified)

```diff
--- CHitTestContext::PostSubgraph
+++ CHitTestContext::PostSubgraph
@@ -1,2 +1,378 @@
-Failed to decompile dwmcore.dll - .ProgramDB CHitTestContext::PostSubgraph : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: long __cdecl CHitTestContext::PostSubgraph(class CVisualTree const * __ptr64,bool *

+   __ptr64) __ptr64 */

+

+long __thiscall

+CHitTestContext::PostSubgraph(CHitTestContext *this,CVisualTree *param_1,bool *param_2)

+

+{

+  float fVar1;

+  float fVar2;

+  longlong lVar3;

+  code *pcVar4;

+  uint *puVar5;

+  undefined8 *puVar6;

+  ISceneNotificationListener **ppIVar7;

+  bool bVar8;

+  char cVar9;

+  long lVar10;

+  uint uVar11;

+  uint uVar12;

+  int *piVar13;

+  longlong *plVar14;

+  undefined8 *puVar15;

+  CEffect *pCVar16;

+  CTransform3D *this_00;

+  CMILMatrix *this_01;

+  longlong lVar17;

+  CInteraction *pCVar18;

+  ulonglong uVar19;

+  uint *puVar20;

+  int *piVar21;

+  CVisual *pCVar22;

+  CVisual *this_02;

+  uint *puVar23;

+  long lVar24;

+  CVisual *this_03;

+  float fVar25;

+  float fVar26;

+  bool local_res8 [8];

+  float local_res10 [2];

+  CVisual *local_res18;

+  float local_c8;

+  float local_c4;

+  float local_bc;

+  float local_b8;

+  float local_b4;

+  float local_ac;

+  float local_98;

+  float local_94;

+  float local_8c;

+  

+  this_02 = *(CVisual **)(this + 0x10);

+  lVar17 = *(longlong *)param_1;

+  lVar3 = *(longlong *)(this + 0x18);

+  *param_2 = true;

+  lVar24 = 0;

+  local_res18 = this_02;

+  cVar9 = (**(code **)(lVar17 + 0xb8))();

+  if (cVar9 == '\0') {

+    piVar13 = *(int **)(this_02 + 0xe8);

+    pCVar22 = (CVisual *)0x0;

+    if (*piVar13 < 0) {

+      uVar12 = piVar13[1];

+      piVar21 = piVar13 + 2;

+      uVar19 = 0;

+      if (uVar12 != 0) {

+        do {

+          if ((char)*piVar21 == '\x01') break;

+          uVar11 = (int)uVar19 + 1;

+          uVar19 = (ulonglong)uVar11;

+          piVar21 = (int *)((longlong)piVar21 + 1);

+        } while (uVar11 < uVar12);

+      }

+      if ((uint)uVar19 < uVar12) {

+        plVar14 = (longlong *)

+                  ((uVar19 * 8 - (ulonglong)((uint)((ulonglong)uVar12 + 0xf) & 7)) +

+                   (ulonglong)uVar12 + 0xf + (longlong)piVar13);

+      }

+      else {

+        plVar14 = (longlong *)0x0;

+      }

+      puVar6 = (undefined8 *)*plVar14;

+      if (puVar6 != (undefined8 *)0x0) {

+        for (puVar15 = (undefined8 *)*puVar6; pCVar22 = (CVisual *)0x0, puVar15 != puVar6;

+            puVar15 = (undefined8 *)*puVar15) {

+          if ((CVisualTree *)puVar15[4] == param_1) {

+            pCVar22 = (CVisual *)(puVar15 + -0x2c);

+            break;

+          }

+        }

+      }

+    }

+  }

+  else {

+    pCVar22 = this_02 + 0x148;

+  }

+  lVar10 = 0;

+  if (*(longlong *)(this + 0x68) == 0) {

+    if (*(int *)(this_02 + 0x70) == 1) {

+      if ((lVar3 == 0) || (*(int *)(lVar3 + 0x70) != 1)) {

+        local_res8[0] = false;

+      }

+      else {

+        local_res8[0] = true;

+      }

+      if (*(code **)(*(longlong *)this_02 + 0xe0) == CLayerVisual::GetTreeEffect) {

+        lVar17 = *(longlong *)(this_02 + 0x2b0);

+      }

+      else {

+        lVar17 = (**(code **)(*(longlong *)this_02 + 0xe0))(this_02);

+      }

+      if (lVar17 == 0) {

+        if ((**(uint **)(this_02 + 0xe8) & 0x800000) != 0) {

+          pCVar16 = CVisual::GetEffectInternal(this_02);

+          cVar9 = (**(code **)(*(longlong *)pCVar16 + 0x40))(pCVar16);

+          if (cVar9 != '\0') goto LAB_0;

+        }

+        bVar8 = false;

+      }

+      else {

+LAB_0:

+        bVar8 = true;

+      }

+      if (local_res8[0] == false) {

+        uVar19 = *(ulonglong *)(this_02 + 0x50);

+        if ((uVar19 & 2) == 0) {

+          uVar12 = (uint)uVar19 & 1;

+        }

+        else {

+          uVar12 = (uint)*(undefined8 *)(uVar19 & 0xfffffffffffffffc);

+        }

+        bVar8 = uVar12 == 0;

+      }

+      else {

+        bVar8 = !bVar8;

+      }

+      lVar10 = lVar24;

+      if (!bVar8) goto LAB_1;

+    }

+    lVar10 = 0;

+    if (this_02[0x6c] != (CVisual)0x0) {

+      pcVar4 = *(code **)(*(longlong *)this_02 + 0x100);

+      if (pcVar4 == CSpriteVisual::HasContent) {

+        bVar8 = CVisual::HasContent(this_02);

+        if ((bVar8) || (lVar10 = lVar24, (**(uint **)(this_02 + 0xe8) & 0x20000) != 0)) {

+LAB_2:

+          piVar13 = (int *)0x0;

+          if (*(int *)(this + 0xb0) != 0) {

+            piVar13 = (int *)(*(longlong *)(this + 0xa8) +

+                             (ulonglong)(*(int *)(this + 0xb0) - 1) * 4);

+          }

+          if ((*piVar13 == 1) &&

+             (this_00 = CVisual::GetTransform3DEffectNoRef(this_02), this_00 != (CTransform3D *)0x0)

+             ) {

+            this_01 = CTransform3D::GetMatrix(this_00,(D2D_SIZE_F *)(this_02 + 0x90));

+            bVar8 = CMILMatrix::IsFacingUser(this_01);

+            lVar10 = lVar24;

+            if (!bVar8) goto LAB_1;

+          }

+          local_res10[0] = 0.0;

+          local_res10[1] = 0.0;

+          cVar9 = (**(code **)(*(longlong *)param_1 + 0xb8))();

+          if (cVar9 == '\0') {

+            piVar13 = *(int **)(this_02 + 0xe8);

+            if (*piVar13 < 0) {

+              uVar12 = piVar13[1];

+              piVar21 = piVar13 + 2;

+              uVar19 = 0;

+              if (uVar12 != 0) {

+                do {

+                  if ((char)*piVar21 == '\x01') break;

+                  uVar11 = (int)uVar19 + 1;

+                  uVar19 = (ulonglong)uVar11;

+                  piVar21 = (int *)((longlong)piVar21 + 1);

+                } while (uVar11 < uVar12);

+              }

+              if ((uint)uVar19 < uVar12) {

+                plVar14 = (longlong *)

+                          ((uVar19 * 8 - (ulonglong)((uint)((ulonglong)uVar12 + 0xf) & 7)) +

+                           (ulonglong)uVar12 + 0xf + (longlong)piVar13);

+              }

+              else {

+                plVar14 = (longlong *)0x0;

+              }

+              puVar6 = (undefined8 *)*plVar14;

+              if (puVar6 != (undefined8 *)0x0) {

+                for (puVar15 = (undefined8 *)*puVar6; puVar15 != puVar6;

+                    puVar15 = (undefined8 *)*puVar15) {

+                  this_03 = (CVisual *)(puVar15 + -0x2c);

+                  if ((CVisualTree *)puVar15[4] == param_1) goto LAB_3;

+                }

+              }

+            }

+LAB_4:

+            MilInstrumentationCheckHR_MaybeFailFast

+                      (0x14,(long *)0x0,0,-0x7767d0fc,0x6a9,(void *)0x0);

+            MilInstrumentationCheckHR_MaybeFailFast

+                      (0x14,(long *)0x0,0,-0x7767d0fc,0x10f,(void *)0x0);

+            return -0x7767d0fc;

+          }

+          this_03 = this_02 + 0x148;

+LAB_3:

+          if (this_03 == (CVisual *)0x0) goto LAB_4;

+          local_res8[0] = false;

+          CVisual::EnsureWorldTransform(this_02,param_1,(CTreeData *)this_03);

+          CTreeData::GetWorldTransform

+                    ((CTreeData *)this_03,(CMILMatrix *)&local_c8,local_res8,(CMILMatrix *)0x0);

+          fVar1 = *(float *)(this + 0x50);

+          fVar2 = *(float *)(this + 0x54);

+          local_c8 = local_bc * fVar1 - local_c8;

+          local_b8 = local_ac * fVar1 - local_b8;

+          local_b4 = local_ac * fVar2 - local_b4;

+          local_c4 = local_bc * fVar2 - local_c4;

+          fVar26 = local_c8 * local_b4;

+          fVar25 = local_b8 * local_c4;

+          lVar10 = 0;

+          if (fVar26 != fVar25) {

+            fVar26 = fVar26 - fVar25;

+            local_res8[0] = false;

+            local_98 = local_8c * fVar1 - local_98;

+            local_94 = local_8c * fVar2 - local_94;

+            local_res10[1] = (local_98 * local_c4 - local_94 * local_c8) / fVar26;

+            local_res10[0] = (local_94 * local_b8 - local_98 * local_b4) / fVar26;

+            pcVar4 = *(code **)(*(longlong *)this_02 + 0x138);

+            if (pcVar4 == CVisual::HitTestContent) {

+              lVar10 = CVisual::HitTestContent

+                                 (this_02,(bool)((byte)this[0xd8] & 1),(D2D_POINT_2F *)local_res10,

+                                  local_res8);

+            }

+            else if (pcVar4 == CWindowNode::HitTestContent) {

+              lVar10 = CWindowNode::HitTestContent

+                                 ((CWindowNode *)this_02,(bool)((byte)this[0xd8] & 1),

+                                  (D2D_POINT_2F *)local_res10,local_res8);

+            }

+            else {

+              lVar10 = (*pcVar4)();

+            }

+            if (lVar10 < 0) {

+              MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar10,0x117,(void *)0x0);

+              return lVar10;

+            }

+            if (local_res8[0] != false) {

+              *(CVisual **)(this + 0x68) = this_02;

+            }

+          }

+        }

+      }

+      else {

+        if (pcVar4 == CVisual::HasContent) {

+          cVar9 = CVisual::HasContent(this_02);

+        }

+        else {

+          cVar9 = (*pcVar4)();

+        }

+        lVar10 = lVar24;

+        if (cVar9 != '\0') goto LAB_2;

+      }

+    }

+  }

+LAB_1:

+  if ((*(int *)(this_02 + 0xd4) != -1) && (*(int *)(this + 0xb0) != 0)) {

+    *(int *)(this + 0xb0) = *(int *)(this + 0xb0) + -1;

+  }

+  if ((pCVar22[0xe] != (CVisual)0x0) && (*(int *)(this + 200) != 0)) {

+    *(int *)(this + 200) = *(int *)(this + 200) + -1;

+  }

+  if (*(longlong *)(this + 0x70) != 0) goto LAB_5;

+  pCVar22 = *(CVisual **)(this + 0x68);

+  if (pCVar22 == this_02) {

+    for (; pCVar22 != *(CVisual **)(*(longlong *)(param_1 + 0x48) + 0x58);

+        pCVar22 = *(CVisual **)(pCVar22 + 0x58)) {

+      puVar5 = *(uint **)(pCVar22 + 0xe8);

+      if ((*puVar5 & 0x1000000) != 0) {

+        uVar12 = puVar5[1];

+        puVar23 = puVar5 + 2;

+        uVar11 = 0;

+        puVar20 = puVar23;

+        if (uVar12 != 0) {

+          do {

+            if ((char)*puVar20 == '\b') break;

+            uVar11 = uVar11 + 1;

+            puVar20 = (uint *)((longlong)puVar20 + 1);

+          } while (uVar11 < uVar12);

+        }

+        if (uVar11 < uVar12) {

+          lVar17 = (ulonglong)uVar12 + 0xf;

+          plVar14 = (longlong *)

+                    ((longlong)puVar5 +

+                    lVar17 + ((ulonglong)uVar11 * 8 - (ulonglong)((uint)lVar17 & 7)));

+        }

+        else {

+          plVar14 = (longlong *)0x0;

+        }

+        if (((*plVar14 != 0) && (lVar17 = *(longlong *)(*plVar14 + 0x70), lVar17 != 0)) &&

+           (*(longlong *)(lVar17 + 0x40) != 0)) {

+          uVar11 = 0;

+          if (uVar12 == 0) goto LAB_6;

+          goto LAB_7;

+        }

+      }

+    }

+  }

+  goto LAB_8;

+  while( true ) {

+    uVar11 = uVar11 + 1;

+    puVar23 = (uint *)((longlong)puVar23 + 1);

+    if (uVar12 <= uVar11) break;

+LAB_7:

+    if ((char)*puVar23 == '\b') break;

+  }

+LAB_6:

+  if (uVar11 < uVar12) {

+    lVar17 = (ulonglong)uVar12 + 0xf;

+    plVar14 = (longlong *)

+              (lVar17 + ((ulonglong)uVar11 * 8 - (ulonglong)((uint)lVar17 & 7)) + (longlong)puVar5);

+  }

+  else {

+    plVar14 = (longlong *)0x0;

+  }

+  lVar17 = *plVar14;

+  if (((lVar17 == 0) || (*(longlong *)(lVar17 + 0x70) == 0)) ||

+     ((*(longlong *)(*(longlong *)(lVar17 + 0x70) + 0x40) == 0 ||

+      ((*(byte *)(lVar17 + 200) & 4) == 0)))) {

+    *(undefined8 *)(this + 0xa0) = 0;

+  }

+  else {

+    *(undefined8 *)(this + 0x68) = 0;

+    *(CVisual **)(this + 0xa0) = pCVar22;

+  }

+LAB_8:

+  if (this_02 == *(CVisual **)(this + 0xa0)) {

+    if (this_02 == *(CVisual **)(this + 0x98)) {

+      pCVar18 = CVisual::GetInteractionInternal(this_02);

+      bVar8 = false;

+    }

+    else {

+      ppIVar7 = *(ISceneNotificationListener ***)(this + 0x88);

+      if (ppIVar7 == *(ISceneNotificationListener ***)(this + 0x90)) {

+        std::

+        vector<ISceneNotificationListener*___ptr64,std::allocator<ISceneNotificationListener*___ptr64>_>

+        ::_Emplace_reallocate<ISceneNotificationListener*___ptr64_const&___ptr64>

+                  ((vector<ISceneNotificationListener*___ptr64,std::allocator<ISceneNotificationListener*___ptr64>_>

+                    *)(this + 0x80),ppIVar7,(ISceneNotificationListener **)&local_res18);

+        this_02 = local_res18;

+      }

+      else {

+        *ppIVar7 = (ISceneNotificationListener *)this_02;

+        *(longlong *)(this + 0x88) = *(longlong *)(this + 0x88) + 8;

+      }

+      *(CVisual **)(this + 0x98) = this_02;

+      pCVar18 = CVisual::GetInteractionInternal(this_02);

+      bVar8 = true;

+    }

+    InputTraceLogging::DWM::MarkForFurtherEvaluation(pCVar18,bVar8);

+    *(undefined8 *)(this + 0xa0) = 0;

+  }

+  if (*(CVisual **)(this + 0x98) == this_02) {

+    *(longlong *)(this + 0x98) = lVar3;

+  }

+LAB_5:

+  if (*(longlong *)(this + 0x68) != 0) {

+    if (*(CVisual **)(this + 0x70) == this_02) {

+      *(undefined8 *)(this + 0x68) = 0;

+      this[0x78] = (CHitTestContext)0x1;

+      InputTraceLogging::GestureTargeting::ForcePalmRejection();

+    }

+    else {

+      *param_2 = false;

+    }

+  }

+  if (*(CVisual **)(this + 0x70) == this_02) {

+    *(undefined8 *)(this + 0x70) = 0;

+  }

+  return lVar10;

+}

+
```

## `COverlayContext::SetHardwareCursor`  (modified)

```diff
--- COverlayContext::SetHardwareCursor
+++ COverlayContext::SetHardwareCursor
@@ -1,2 +1,71 @@
-Failed to decompile dwmcore.dll - .ProgramDB COverlayContext::SetHardwareCursor : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: void __cdecl COverlayContext::SetHardwareCursor(class CCursorVisual * __ptr64,class

+   CMILMatrix const & __ptr64,bool) __ptr64 */

+

+void __thiscall

+COverlayContext::SetHardwareCursor

+          (COverlayContext *this,CCursorVisual *param_1,CMILMatrix *param_2,bool param_3)

+

+{

+  longlong *plVar1;

+  code *pcVar2;

+  CMILCOMBaseWeakRefSource<CResourceDeleter> *this_00;

+  bool bVar3;

+  undefined4 uVar4;

+  longlong *plVar5;

+  undefined8 uVar6;

+  undefined8 *puVar7;

+  undefined1 auStack_68 [32];

+  undefined1 local_48 [16];

+  ulonglong local_38;

+  

+  local_38 = __security_cookie ^ (ulonglong)auStack_68;

+  plVar5 = (longlong *)(**(code **)(**(longlong **)this + 0x118))();

+  if (plVar5 != (longlong *)0x0) {

+    if (*(CCursorVisual **)(this + 0x4b18) != param_1) {

+      if (*(CCursorVisual **)(this + 0x4b18) != (CCursorVisual *)0x0) {

+        plVar1 = *(longlong **)this;

+        pcVar2 = *(code **)(*plVar1 + 0x128);

+        uVar6 = GetCursorBounds(this);

+        (*pcVar2)(plVar1,uVar6);

+        ClearHardwareCursor(this);

+      }

+      puVar7 = (undefined8 *)(**(code **)(*plVar5 + 0xd8))(plVar5,local_48);

+      *(undefined8 *)(this + 0x4b20) = *puVar7;

+      uVar4 = (**(code **)(*plVar5 + 0xe0))(plVar5);

+      *(undefined4 *)(this + 0x4b28) = uVar4;

+      this_00 = *(CMILCOMBaseWeakRefSource<CResourceDeleter> **)(this + 0x4b18);

+      *(CCursorVisual **)(this + 0x4b18) = param_1;

+      if (param_1 != (CCursorVisual *)0x0) {

+        CMILRefCountImpl::AddReference((CMILRefCountImpl *)(param_1 + 8));

+      }

+      if (this_00 != (CMILCOMBaseWeakRefSource<CResourceDeleter> *)0x0) {

+        CMILCOMBaseWeakRefSource<CResourceDeleter>::InternalRelease(this_00);

+      }

+    }

+    this[0x4c77] = (COverlayContext)param_3;

+    this[0x4c7a] = (COverlayContext)0x1;

+    uVar6 = *(undefined8 *)(param_2 + 8);

+    *(undefined8 *)(this + 0x4b2c) = *(undefined8 *)param_2;

+    *(undefined8 *)(this + 0x4b34) = uVar6;

+    uVar6 = *(undefined8 *)(param_2 + 0x18);

+    *(undefined8 *)(this + 0x4b3c) = *(undefined8 *)(param_2 + 0x10);

+    *(undefined8 *)(this + 0x4b44) = uVar6;

+    uVar6 = *(undefined8 *)(param_2 + 0x28);

+    *(undefined8 *)(this + 0x4b4c) = *(undefined8 *)(param_2 + 0x20);

+    *(undefined8 *)(this + 0x4b54) = uVar6;

+    uVar6 = *(undefined8 *)(param_2 + 0x38);

+    *(undefined8 *)(this + 0x4b5c) = *(undefined8 *)(param_2 + 0x30);

+    *(undefined8 *)(this + 0x4b64) = uVar6;

+    *(undefined4 *)(this + 0x4b6c) = *(undefined4 *)(param_2 + 0x40);

+    bVar3 = DelayCursorUpdateForMPO(this);

+    if (!bVar3) {

+      UpdateHardwareCursor(this,param_3);

+    }

+  }

+  return;

+}

+
```

## `std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::_Emplace_reallocate<CursorVisualData>`  (modified)

```diff
--- std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::_Emplace_reallocate<CursorVisualData>
+++ std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::_Emplace_reallocate<CursorVisualData>
@@ -1,2 +1,61 @@
-Failed to decompile dwmcore.dll - .ProgramDB std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::_Emplace_reallocate<CursorVisualData> : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* private: struct CursorVisualData * __ptr64 __cdecl std::vector<struct CursorVisualData,class

+   std::allocator<struct CursorVisualData> >::_Emplace_reallocate<struct CursorVisualData>(struct

+   CursorVisualData * __ptr64 const,struct CursorVisualData && __ptr64) __ptr64 */

+

+CursorVisualData * __thiscall

+std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::

+_Emplace_reallocate<CursorVisualData>

+          (vector<CursorVisualData,std::allocator<CursorVisualData>_> *this,

+          CursorVisualData *param_1,CursorVisualData *param_2)

+

+{

+  ulonglong uVar1;

+  __uint64 _Var2;

+  CursorVisualData *pCVar3;

+  ulonglong uVar4;

+  CursorVisualData *pCVar5;

+  longlong lVar6;

+  CursorVisualData *pCVar7;

+  ulonglong uVar8;

+  longlong lVar9;

+  ulonglong uVar10;

+  CursorVisualData *pCVar11;

+  allocator<CursorVisualData> *paVar12;

+  CursorVisualData *this_00;

+  

+  paVar12 = (allocator<CursorVisualData> *)(param_1 + -*(longlong *)this);

+  lVar6 = (longlong)paVar12 / 6 + ((longlong)paVar12 >> 0x3f);

+  lVar9 = (*(longlong *)(this + 8) - *(longlong *)this >> 4) * -0x5555555555555555;

+  if (lVar9 != 0x555555555555555) {

+    uVar10 = lVar9 + 1;

+    uVar4 = (*(longlong *)(this + 0x10) - *(longlong *)this >> 4) * -0x5555555555555555;

+    uVar1 = 0x555555555555555 - (uVar4 >> 1);

+    uVar8 = 0x555555555555555;

+    if ((uVar4 < uVar1 || uVar4 - uVar1 == 0) && (uVar8 = (uVar4 >> 1) + uVar4, uVar8 < uVar10)) {

+      uVar8 = uVar10;

+    }

+    _Var2 = _Get_size_of_n<48>(uVar8);

+    pCVar3 = _Allocate<16,std::_Default_allocate_traits,0>(_Var2);

+    this_00 = pCVar3 + ((lVar6 >> 3) - (lVar6 >> 0x3f)) * 0x30;

+    CursorVisualData::CursorVisualData(this_00,param_2);

+    pCVar7 = *(CursorVisualData **)(this + 8);

+    pCVar5 = *(CursorVisualData **)this;

+    pCVar11 = pCVar3;

+    if (param_1 != pCVar7) {

+      _Uninitialized_move<CursorVisualData*___ptr64,std::allocator<CursorVisualData>_>

+                (*(CursorVisualData **)this,param_1,pCVar3,paVar12);

+      pCVar7 = *(CursorVisualData **)(this + 8);

+      pCVar11 = this_00 + 0x30;

+      pCVar5 = param_1;

+    }

+    _Uninitialized_move<CursorVisualData*___ptr64,std::allocator<CursorVisualData>_>

+              (pCVar5,pCVar7,pCVar11,paVar12);

+    _Change_array(this,pCVar3,uVar10,uVar8);

+    return this_00;

+  }

+                    /* WARNING: Subroutine does not return */

+  vector<CursorVisualData_const*___ptr64,std::allocator<CursorVisualData_const*___ptr64>_>::_Xlength

+            ();

+}

+
```

## `std::uninitialized_move<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_>`  (modified)

```diff
--- std::uninitialized_move<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_>
+++ std::uninitialized_move<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_>
@@ -1,2 +1,35 @@
-Failed to decompile dwmcore.dll - .ProgramDB std::uninitialized_move<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_> : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* class stdext::checked_array_iterator<class CD3DDevice::CDelayUnpin * __ptr64> __cdecl

+   std::uninitialized_move<class std::move_iterator<class CD3DDevice::CDelayUnpin * __ptr64>,class

+   stdext::checked_array_iterator<class CD3DDevice::CDelayUnpin * __ptr64> >(class

+   std::move_iterator<class CD3DDevice::CDelayUnpin * __ptr64>,class std::move_iterator<class

+   CD3DDevice::CDelayUnpin * __ptr64>,class stdext::checked_array_iterator<class

+   CD3DDevice::CDelayUnpin * __ptr64>) */

+

+undefined8 * __cdecl

+std::

+uninitialized_move<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_>

+          (undefined8 *param_1,CDelayUnpin *param_2,CDelayUnpin *param_3,

+          checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64> *param_4)

+

+{

+  undefined8 uVar1;

+  undefined8 uVar2;

+  CDelayUnpin *this;

+  

+  this = (CDelayUnpin *)

+         _Get_unwrapped_n<stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>&___ptr64,__int64>

+                   (param_4,(longlong)param_3 - (longlong)param_2 >> 6);

+  for (; param_2 != param_3; param_2 = param_2 + 0x40) {

+    CD3DDevice::CDelayUnpin::CDelayUnpin(this,param_2);

+    this = this + 0x40;

+  }

+  *(longlong *)(param_4 + 0x10) = (longlong)this - *(longlong *)param_4 >> 6;

+  uVar2 = *(undefined8 *)(param_4 + 8);

+  uVar1 = *(undefined8 *)(param_4 + 0x10);

+  *param_1 = *(undefined8 *)param_4;

+  param_1[1] = uVar2;

+  param_1[2] = uVar1;

+  return param_1;

+}

+
```

## `std::_Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_>::_Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_><std::pair<IDXGIResource*___ptr64,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>_>`  (modified)

```diff
--- std::_Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_>::_Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_><std::pair<IDXGIResource*___ptr64,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>_>
+++ std::_Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_>::_Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_><std::pair<IDXGIResource*___ptr64,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>_>
@@ -1,2 +1,57 @@
-Failed to decompile dwmcore.dll - .ProgramDB std::_Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_>::_Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_><std::pair<IDXGIResource*___ptr64,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>_> : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: __cdecl std::_Tree_temp_node<class std::allocator<struct std::_Tree_node<struct

+   std::pair<struct IDXGIResource * __ptr64 const,class wil::com_ptr_t<class

+   IRenderTargetBitmap,struct wil::err_returncode_policy> >,void * __ptr64> >

+   >::_Tree_temp_node<class std::allocator<struct std::_Tree_node<struct std::pair<struct

+   IDXGIResource * __ptr64 const,class wil::com_ptr_t<class IRenderTargetBitmap,struct

+   wil::err_returncode_policy> >,void * __ptr64> > ><struct std::pair<struct IDXGIResource *

+   __ptr64,class wil::com_ptr_t<class IRenderTargetBitmap,struct wil::err_returncode_policy> >

+   >(class std::allocator<struct std::_Tree_node<struct std::pair<struct IDXGIResource * __ptr64

+   const,class wil::com_ptr_t<class IRenderTargetBitmap,struct wil::err_returncode_policy> >,void *

+   __ptr64> > & __ptr64,struct std::_Tree_node<struct std::pair<struct IDXGIResource * __ptr64

+   const,class wil::com_ptr_t<class IRenderTargetBitmap,struct wil::err_returncode_policy> >,void *

+   __ptr64> * __ptr64,struct std::pair<struct IDXGIResource * __ptr64,class wil::com_ptr_t<class

+   IRenderTargetBitmap,struct wil::err_returncode_policy> > && __ptr64) __ptr64 */

+

+_Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_>

+* __thiscall

+std::

+_Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_>

+::

+_Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_><std::pair<IDXGIResource*___ptr64,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>_>

+          (_Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_>

+           *this,allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>

+                 *param_1,

+          _Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>

+          *param_2,pair<IDXGIResource*___ptr64,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>

+                   *param_3)

+

+{

+  undefined8 uVar1;

+  __uint64 _Var2;

+  void *pvVar3;

+  longlong lVar4;

+  

+  *(allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>

+    **)this = param_1;

+  *(undefined8 *)(this + 8) = 0;

+  _Var2 = _Get_size_of_n<48>(1);

+  pvVar3 = _Allocate<16,std::_Default_allocate_traits,0>(_Var2);

+  *(void **)(this + 8) = pvVar3;

+  *(undefined8 *)((longlong)pvVar3 + 0x20) = *(undefined8 *)param_3;

+  uVar1 = *(undefined8 *)(param_3 + 8);

+  *(undefined8 *)(param_3 + 8) = 0;

+  *(undefined8 *)((longlong)pvVar3 + 0x28) = uVar1;

+  lVar4 = 0;

+  **(undefined8 **)(this + 8) = param_2;

+  *(_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>

+    **)(*(longlong *)(this + 8) + 8) = param_2;

+  *(_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>

+    **)(*(longlong *)(this + 8) + 0x10) = param_2;

+  do {

+    *(undefined1 *)(*(longlong *)(this + 8) + 0x18 + lVar4) = 0;

+    lVar4 = lVar4 + 1;

+  } while (lVar4 < 2);

+  return this;

+}

+
```

## `COcclusionContext::PostSubgraph`  (modified)

```diff
--- COcclusionContext::PostSubgraph
+++ COcclusionContext::PostSubgraph
@@ -1,2 +1,368 @@
-Failed to decompile dwmcore.dll - .ProgramDB COcclusionContext::PostSubgraph : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: long __cdecl COcclusionContext::PostSubgraph(class CVisualTree const * __ptr64,bool *

+   __ptr64) __ptr64 */

+

+long __thiscall

+COcclusionContext::PostSubgraph(COcclusionContext *this,CVisualTree *param_1,bool *param_2)

+

+{

+  float *pfVar1;

+  undefined8 *puVar2;

+  COverlayContext *this_00;

+  bool bVar3;

+  bool bVar4;

+  bool bVar5;

+  char cVar6;

+  char cVar7;

+  long lVar8;

+  CursorVisibility CVar9;

+  COcclusionInfo *pCVar10;

+  CBackdropVisualImage *pCVar11;

+  longlong lVar12;

+  CMonitorTransform *pCVar13;

+  CTreeData *pCVar14;

+  CVisual *pCVar15;

+  undefined8 *puVar16;

+  CVisualTree *pCVar17;

+  longlong lVar18;

+  float fVar19;

+  float fVar20;

+  float fVar21;

+  float fVar22;

+  float fVar23;

+  float fVar24;

+  float fVar25;

+  float fVar26;

+  undefined1 auStackY_108 [32];

+  undefined8 local_d8;

+  undefined8 uStack_d0;

+  int local_c8;

+  CVisualTree *local_c0;

+  long local_b8;

+  int local_b4;

+  CTreeData *local_b0;

+  bool *local_a8;

+  COcclusionInfo *local_a0;

+  undefined8 local_98;

+  undefined8 uStack_90;

+  ulonglong local_88;

+  

+  local_88 = __security_cookie ^ (ulonglong)auStackY_108;

+  pCVar15 = *(CVisual **)(this + 0x40);

+  lVar18 = 0;

+  local_b8 = 0;

+  local_c0 = param_1;

+  local_a8 = param_2;

+  local_b0 = CVisual::FindTreeData(pCVar15,param_1);

+  pCVar10 = CTreeData::GetOcclusionInfo(local_b0,*(uint *)(this + 0x5d8),false);

+  local_c8 = *(int *)(this + 0x688);

+  local_a0 = pCVar10;

+  (**(code **)(*(longlong *)pCVar10 + 8))(pCVar10,*(undefined4 *)(this + 0x684));

+  if (*(CBackdropVisualImage **)(this + 0x5e8) == (CBackdropVisualImage *)0x0) {

+LAB_0:

+    cVar6 = (**(code **)(*(longlong *)pCVar15 + 0x108))(pCVar15);

+    if ((this[0x5f6] == (COcclusionContext)0x0) ||

+       (cVar7 = (**(code **)(*(longlong *)pCVar15 + 0x110))(pCVar15), cVar7 == '\0')) {

+      lVar8 = 0;

+      if (cVar6 != '\0') {

+        lVar8 = 0;

+        if (local_c8 == 0) goto LAB_1;

+LAB_2:

+        this[0x5f7] = (COcclusionContext)0x1;

+      }

+    }

+    else {

+LAB_1:

+      lVar8 = CollectOcclusion(this,pCVar10,pCVar15);

+      if (lVar8 < 0) {

+        MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar8,0x26b,(void *)0x0);

+        pCVar17 = local_c0;

+        goto LAB_3;

+      }

+      local_b8 = lVar8;

+      if (cVar6 != '\0') goto LAB_2;

+    }

+    if ((local_c8 == 0) ||

+       ((pCVar17 = local_c0, *(int *)(this + 0x688) == 1 &&

+        ((*(uint *)(pCVar15 + 0x60) & 0x100) != 0)))) {

+      local_d8 = 0;

+      uStack_d0 = 0;

+      if (pCVar10[0x18] == (COcclusionInfo)0x0) {

+        bVar5 = CalcNodeWorldBounds(this,pCVar15,

+                                    (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                                     *)&local_d8);

+        fVar23 = local_d8._4_4_;

+        fVar24 = uStack_d0._4_4_;

+        fVar25 = (float)local_d8;

+        fVar26 = (float)uStack_d0;

+      }

+      else {

+        if (*(int *)(this + 0x6a0) == 0) {

+          uStack_d0._0_4_ = 0.0;

+          local_d8._0_4_ = 0.0;

+          fVar25 = (float)local_d8;

+          fVar26 = (float)uStack_d0;

+LAB_4:

+          fVar23 = local_d8._4_4_;

+          fVar24 = uStack_d0._4_4_;

+        }

+        else {

+          pfVar1 = (float *)(*(longlong *)(this + 0x698) +

+                            (ulonglong)(*(int *)(this + 0x6a0) - 1) * 0x10);

+          fVar25 = *pfVar1;

+          fVar23 = pfVar1[1];

+          local_d8 = *(undefined8 *)pfVar1;

+          fVar26 = pfVar1[2];

+          fVar24 = pfVar1[3];

+          uStack_d0 = *(undefined8 *)(pfVar1 + 2);

+          if (fVar26 <= fVar25) goto LAB_4;

+          if (fVar23 < fVar24) {

+            bVar5 = true;

+            goto LAB_5;

+          }

+        }

+        bVar5 = false;

+      }

+LAB_5:

+      if (bVar5 != false) {

+        puVar16 = *(undefined8 **)(this + 0x6e0);

+        puVar2 = *(undefined8 **)(this + 0x6e8);

+        while (param_2 = local_a8, pCVar10 = local_a0, lVar8 = local_b8, puVar16 != puVar2) {

+          local_b4 = *(int *)(this + 0x690);

+          this_00 = (COverlayContext *)*puVar16;

+          lVar12 = (**(code **)(**(longlong **)this_00 + 0x100))();

+          fVar19 = *(float *)(lVar12 + 8);

+          if (*(float *)(lVar12 + 8) < fVar25) {

+            fVar19 = fVar25;

+          }

+          fVar22 = *(float *)(lVar12 + 0xc);

+          if (*(float *)(lVar12 + 0xc) < fVar23) {

+            fVar22 = fVar23;

+          }

+          local_d8 = CONCAT44(fVar22,fVar19);

+          fVar21 = *(float *)(lVar12 + 0x10);

+          if (fVar26 < *(float *)(lVar12 + 0x10)) {

+            fVar21 = fVar26;

+          }

+          fVar20 = *(float *)(lVar12 + 0x14);

+          if (fVar24 < *(float *)(lVar12 + 0x14)) {

+            fVar20 = fVar24;

+          }

+          uStack_d0 = CONCAT44(fVar20,fVar21);

+          if ((fVar21 <= fVar19) || (fVar20 <= fVar22)) {

+LAB_6:

+            puVar16 = puVar16 + 1;

+          }

+          else {

+            if (pCVar15 == *(CVisual **)(this_00 + 0x4b18)) {

+              CVar9 = COverlayContext::GetCursorVisibility(this_00);

+              if ((CVar9 == 2) || (*(char *)(*(longlong *)(this_00 + 0x4b18) + 0x2f1) != '\0')) {

+                lVar12 = *(longlong *)(*(longlong *)(this_00 + 0x4b18) + 0x2c8);

+                if ((lVar12 == 0) || (*(longlong *)(lVar12 + 0xb8) == 0)) {

+                  cVar6 = '\0';

+                }

+                else {

+                  cVar6 = *(char *)(lVar12 + 0x59);

+                }

+              }

+              else {

+                if ((((((CCommonRegistryData::m_dwOverlayTestMode == 5) ||

+                       (*(uint *)(this_00 + 0x28) < 2)) || (this_00[0x4c6f] != (COverlayContext)0x0)

+                      ) || ((lVar12 = *(longlong *)(*(longlong *)(this_00 + 0x4b18) + 0x2c8),

+                            lVar12 == 0 || (*(longlong *)(lVar12 + 0xb8) == 0)))) ||

+                    (*(char *)(lVar12 + 0x59) == '\0')) || (CVar9 != 1)) goto LAB_6;

+                cVar6 = *(char *)(*(longlong *)(*(longlong *)(this_00 + 0x4b18) + 0x2c8) + 0x59);

+              }

+            }

+            else {

+              cVar6 = (**(code **)(*(longlong *)pCVar15 + 0x118))(pCVar15);

+            }

+            local_98 = 0;

+            uStack_90 = 0;

+            pCVar13 = COverlayContext::GetMonitorTransform(this_00);

+            CMILMatrix::Transform2DBoundsHelper<0>

+                      ((CMILMatrix *)(pCVar13 + 0x34),(D2D_RECT_F *)&local_d8,

+                       (D2D_RECT_F *)&local_98);

+            bVar5 = false;

+            if ((*(float *)(this_00 + 0x4b98) <= *(float *)(this_00 + 0x4b90)) ||

+               (bVar3 = bVar5,

+               *(float *)(this_00 + 0x4b9c) < *(float *)(this_00 + 0x4b94) ||

+               *(float *)(this_00 + 0x4b9c) == *(float *)(this_00 + 0x4b94))) {

+              bVar3 = true;

+            }

+            if (((float)uStack_90 <= (float)local_98) ||

+               (bVar4 = bVar5, uStack_90._4_4_ <= local_98._4_4_)) {

+              bVar4 = true;

+            }

+            if (bVar3) {

+              if ((((bVar4) || (NAN((float)local_98))) || (NAN(local_98._4_4_))) ||

+                 ((NAN((float)uStack_90) || (NAN(uStack_90._4_4_))))) {

+                *(undefined8 *)(this_00 + 0x4b98) = 0;

+                *(undefined8 *)(this_00 + 0x4b90) = 0;

+              }

+              else {

+                *(undefined8 *)(this_00 + 0x4b90) = local_98;

+                *(undefined8 *)(this_00 + 0x4b98) = uStack_90;

+              }

+            }

+            else if (!bVar4) {

+              if ((float)local_98 < *(float *)(this_00 + 0x4b90)) {

+                *(float *)(this_00 + 0x4b90) = (float)local_98;

+              }

+              if (local_98._4_4_ < *(float *)(this_00 + 0x4b94)) {

+                *(float *)(this_00 + 0x4b94) = local_98._4_4_;

+              }

+              if (*(float *)(this_00 + 0x4b98) <= (float)uStack_90 &&

+                  (float)uStack_90 != *(float *)(this_00 + 0x4b98)) {

+                *(float *)(this_00 + 0x4b98) = (float)uStack_90;

+              }

+              if (*(float *)(this_00 + 0x4b9c) <= uStack_90._4_4_ &&

+                  uStack_90._4_4_ != *(float *)(this_00 + 0x4b9c)) {

+                *(float *)(this_00 + 0x4b9c) = uStack_90._4_4_;

+              }

+            }

+            if (cVar6 != '\0') {

+              if ((*(float *)(this_00 + 0x4ba8) <= *(float *)(this_00 + 0x4ba0)) ||

+                 (bVar3 = bVar5,

+                 *(float *)(this_00 + 0x4bac) < *(float *)(this_00 + 0x4ba4) ||

+                 *(float *)(this_00 + 0x4bac) == *(float *)(this_00 + 0x4ba4))) {

+                bVar3 = true;

+              }

+              if (((float)uStack_d0 <= (float)local_d8) || (uStack_d0._4_4_ <= local_d8._4_4_)) {

+                bVar5 = true;

+              }

+              if (bVar3) {

+                if ((((bVar5) || (NAN((float)local_d8))) || (NAN(local_d8._4_4_))) ||

+                   ((NAN((float)uStack_d0) || (NAN(uStack_d0._4_4_))))) {

+                  *(undefined8 *)(this_00 + 0x4ba8) = 0;

+                  *(undefined8 *)(this_00 + 0x4ba0) = 0;

+                }

+                else {

+                  *(undefined8 *)(this_00 + 0x4ba0) = local_d8;

+                  *(undefined8 *)(this_00 + 0x4ba8) = uStack_d0;

+                }

+              }

+              else if (!bVar5) {

+                if ((float)local_d8 < *(float *)(this_00 + 0x4ba0)) {

+                  *(float *)(this_00 + 0x4ba0) = (float)local_d8;

+                }

+                if (local_d8._4_4_ < *(float *)(this_00 + 0x4ba4)) {

+                  *(float *)(this_00 + 0x4ba4) = local_d8._4_4_;

+                }

+                if (*(float *)(this_00 + 0x4ba8) <= (float)uStack_d0 &&

+                    (float)uStack_d0 != *(float *)(this_00 + 0x4ba8)) {

+                  *(float *)(this_00 + 0x4ba8) = (float)uStack_d0;

+                }

+                if (*(float *)(this_00 + 0x4bac) <= uStack_d0._4_4_ &&

+                    uStack_d0._4_4_ != *(float *)(this_00 + 0x4bac)) {

+                  *(float *)(this_00 + 0x4bac) = uStack_d0._4_4_;

+                }

+              }

+            }

+            if (local_b4 == 0) {

+              this_00[0x4bb1] = (COverlayContext)0x1;

+              goto LAB_6;

+            }

+            this_00[0x4bb0] = (COverlayContext)0x1;

+            puVar16 = puVar16 + 1;

+          }

+        }

+      }

+      pCVar17 = local_c0;

+      if (((local_c8 == 0) &&

+          (CLightStack::PopLightsFromVisual((CLightStack *)(this + 200),pCVar15,local_c0),

+          pCVar10[0x1b] != (COcclusionInfo)0x0)) && (*(int *)(this + 0x6d0) != 0)) {

+        *(int *)(this + 0x6d0) = *(int *)(this + 0x6d0) + -1;

+      }

+    }

+    if (pCVar10[0x1a] != (COcclusionInfo)0x0) {

+      if (*(int *)(this + 0x6b8) != 0) {

+        *(int *)(this + 0x6b8) = *(int *)(this + 0x6b8) + -1;

+      }

+      if (*(int *)(this + 0x88) != 0) {

+        *(int *)(this + 0x88) = *(int *)(this + 0x88) + -1;

+      }

+      if (*(int *)(this + 0xb8) != 0) {

+        *(int *)(this + 0xb8) = *(int *)(this + 0xb8) + -1;

+      }

+      if (*(int *)(this + 0xa0) != 0) {

+        *(int *)(this + 0xa0) = *(int *)(this + 0xa0) + -1;

+      }

+    }

+    if ((pCVar10[0x19] != (COcclusionInfo)0x0) && (*(int *)(this + 0x28) != 0)) {

+      *(int *)(this + 0x28) = *(int *)(this + 0x28) + -1;

+    }

+    if ((pCVar10[0x18] != (COcclusionInfo)0x0) && (*(int *)(this + 0x6a0) != 0)) {

+      *(int *)(this + 0x6a0) = *(int *)(this + 0x6a0) + -1;

+    }

+    if (((byte)pCVar15[0x6a] & 4) != 0) {

+      *(int *)(this + 0x690) = *(int *)(this + 0x690) + -1;

+    }

+    bVar5 = CVisual::RequiresExternalLayer(pCVar15);

+    if (bVar5) {

+      *(int *)(this + 0x68c) = *(int *)(this + 0x68c) + -1;

+    }

+  }

+  else {

+    bVar5 = CBackdropVisualImage::IsVisualInAncestorList

+                      (*(CBackdropVisualImage **)(this + 0x5e8),pCVar15,

+                       *(CVisualTreePath **)(this + 0x10));

+    pCVar11 = CVisual::GetBackdropVisualImage(pCVar15,*(CVisualTreePath **)(this + 0x10));

+    pCVar17 = local_c0;

+    lVar8 = 0;

+    if (pCVar11 != *(CBackdropVisualImage **)(this + 0x5e8)) {

+      if (this[0x5f8] == (COcclusionContext)0x0) {

+        lVar8 = 0;

+        if (!bVar5) goto LAB_3;

+        this[0x5f8] = (COcclusionContext)0x1;

+      }

+      goto LAB_0;

+    }

+  }

+LAB_3:

+  if (local_c8 != 0) {

+    *(int *)(this + 0x688) = *(int *)(this + 0x688) + -1;

+  }

+  *(int *)(this + 0x684) = *(int *)(this + 0x684) + 2;

+  if (**(int **)(this + 0x1b0) == 0) {

+    if (g_pComposition != (CComposition *)0x0) {

+      lVar18 = *(longlong *)(g_pComposition + 0x3a0);

+    }

+    bVar5 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>::

+            __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor> *)

+                                &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DesktopDWMCursor>::GetImpl(void)'

+                                 ::__l2::impl);

+    if (bVar5) {

+      if (*(longlong *)(local_b0 + 0xd0) != lVar18) {

+        pCVar15 = *(CVisual **)(this + 0x48);

+        if (pCVar15 == (CVisual *)0x0) goto LAB_7;

+        if ((this[0x5f6] == (COcclusionContext)0x0) || ((*(uint *)(pCVar15 + 0x60) & 0x8000) == 0))

+        goto LAB_8;

+      }

+LAB_9:

+      bVar5 = true;

+    }

+    else {

+      if (*(longlong *)(local_b0 + 0xd0) == lVar18) goto LAB_10;

+      pCVar15 = *(CVisual **)(this + 0x48);

+      if (pCVar15 != (CVisual *)0x0) {

+LAB_8:

+        pCVar14 = CVisual::FindTreeData(pCVar15,pCVar17);

+        if ((pCVar14 != (CTreeData *)0x0) && (*(longlong *)(pCVar14 + 0xd0) == lVar18))

+        goto LAB_9;

+      }

+LAB_7:

+      bVar5 = false;

+    }

+    *param_2 = bVar5;

+  }

+  else {

+LAB_10:

+    *param_2 = true;

+  }

+  return lVar8;

+}

+
```

## `CSceneMeshRendererComponent::CSceneMeshRendererComponent`  (modified)

```diff
--- CSceneMeshRendererComponent::CSceneMeshRendererComponent
+++ CSceneMeshRendererComponent::CSceneMeshRendererComponent
@@ -1,2 +1,44 @@
-Failed to decompile dwmcore.dll - .ProgramDB CSceneMeshRendererComponent::CSceneMeshRendererComponent : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: __cdecl CSceneMeshRendererComponent::CSceneMeshRendererComponent(class CComposition *

+   __ptr64) __ptr64 */

+

+CSceneMeshRendererComponent * __thiscall

+CSceneMeshRendererComponent::CSceneMeshRendererComponent

+          (CSceneMeshRendererComponent *this,CComposition *param_1)

+

+{

+  allocator<std::_Tree_node<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>,void*___ptr64>_>

+  *paVar1;

+  void *pvVar2;

+  _Tree_node<struct_std::pair<enum_SceneMaterialInputType::Enum_const_,unsigned_int>,void*___ptr64>

+  *p_Var3;

+  

+  *(undefined4 *)(this + 8) = 0;

+  *(undefined8 *)(this + 0x10) = 0;

+  *(CComposition **)(this + 0x18) = param_1;

+  *(undefined8 *)(this + 0x20) = 0;

+  *(undefined8 *)(this + 0x30) = 0;

+  *(undefined4 *)(this + 0x28) = 0;

+  *(undefined ***)this = &CSceneComponent::_vftable_;

+  *(undefined8 *)(this + 0x48) = 0;

+  *(undefined8 *)(this + 0x50) = 0;

+  paVar1 = (allocator<std::_Tree_node<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>,void*___ptr64>_>

+            *)std::_Get_size_of_n<48>(1);

+  pvVar2 = std::_Allocate<16,std::_Default_allocate_traits,0>((__uint64)paVar1);

+  *(void **)pvVar2 = pvVar2;

+  *(void **)((longlong)pvVar2 + 8) = pvVar2;

+  *(void **)((longlong)pvVar2 + 0x10) = pvVar2;

+  *(undefined2 *)((longlong)pvVar2 + 0x18) = 0x101;

+  *(void **)(this + 0x48) = pvVar2;

+  *(undefined ***)this = &_vftable_;

+  *(undefined8 *)(this + 0x68) = 0;

+  *(undefined8 *)(this + 0x70) = 0;

+  p_Var3 = std::

+           _Tree_node<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>,void*___ptr64>::

+           _Buyheadnode<std::allocator<std::_Tree_node<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>,void*___ptr64>_>_>

+                     (paVar1);

+  *(_Tree_node<struct_std::pair<enum_SceneMaterialInputType::Enum_const_,unsigned_int>,void*___ptr64>

+    **)(this + 0x68) = p_Var3;

+  return this;

+}

+
```

## `std::_Move_unchecked<CursorVisualData*___ptr64,CursorVisualData*___ptr64>`  (modified)

```diff
--- std::_Move_unchecked<CursorVisualData*___ptr64,CursorVisualData*___ptr64>
+++ std::_Move_unchecked<CursorVisualData*___ptr64,CursorVisualData*___ptr64>
@@ -1,2 +1,46 @@
-Failed to decompile dwmcore.dll - .ProgramDB std::_Move_unchecked<CursorVisualData*___ptr64,CursorVisualData*___ptr64> : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* struct CursorVisualData * __ptr64 __cdecl std::_Move_unchecked<struct CursorVisualData *

+   __ptr64,struct CursorVisualData * __ptr64>(struct CursorVisualData * __ptr64,struct

+   CursorVisualData * __ptr64,struct CursorVisualData * __ptr64) */

+

+CursorVisualData * __cdecl

+std::_Move_unchecked<CursorVisualData*___ptr64,CursorVisualData*___ptr64>

+          (CursorVisualData *param_1,CursorVisualData *param_2,CursorVisualData *param_3)

+

+{

+  CursorVisualData *pCVar1;

+  longlong *plVar2;

+  longlong *plVar3;

+  CursorVisualData *pCVar4;

+  longlong lVar5;

+  

+  if (param_1 != param_2) {

+    pCVar4 = param_1 + 0x10;

+    lVar5 = (longlong)param_1 - (longlong)param_3;

+    do {

+      plVar2 = *(longlong **)(pCVar4 + -8);

+      plVar3 = *(longlong **)(param_3 + 8);

+      *(longlong **)(param_3 + 8) = plVar2;

+      if (plVar2 != (longlong *)0x0) {

+        (**(code **)(*plVar2 + 8))();

+      }

+      if (plVar3 != (longlong *)0x0) {

+        (**(code **)(*plVar3 + 0x10))(plVar3);

+      }

+      *(undefined4 *)(param_3 + 0x10) = *(undefined4 *)pCVar4;

+      param_3[0x14] = pCVar4[4];

+      wil::com_ptr_t<CD2DInk,wil::err_returncode_policy>::operator=

+                ((com_ptr_t<CD2DInk,wil::err_returncode_policy> *)(param_3 + 0x18),

+                 (com_ptr_t<class_CD2DInk,struct_wil::err_returncode_policy> *)(pCVar4 + 8));

+      *(undefined8 *)(param_3 + 0x20) = *(undefined8 *)(pCVar4 + 0x10);

+      pCVar1 = pCVar4 + 0x18;

+      pCVar4 = pCVar4 + 0x30;

+      *(undefined4 *)(param_3 + 0x28) = *(undefined4 *)pCVar1;

+      param_3 = param_3 + 0x30;

+    } while (param_3 + lVar5 != param_2);

+  }

+  return param_3;

+}

+
```

## `CSurfaceBrush::IsReadyToDraw`  (modified)

```diff
--- CSurfaceBrush::IsReadyToDraw
+++ CSurfaceBrush::IsReadyToDraw
@@ -1,2 +1,51 @@
-Failed to decompile dwmcore.dll - .ProgramDB CSurfaceBrush::IsReadyToDraw : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: virtual bool __cdecl CSurfaceBrush::IsReadyToDraw(class CDrawingContext * __ptr64,bool *

+   __ptr64)const __ptr64 */

+

+bool __thiscall

+CSurfaceBrush::IsReadyToDraw(CSurfaceBrush *this,CDrawingContext *param_1,bool *param_2)

+

+{

+  code *pcVar1;

+  undefined1 uVar2;

+  bool bVar3;

+  CResource *pCVar4;

+  IBitmapResource *local_res8;

+  

+  pcVar1 = *(code **)**(undefined8 **)(this + 0x88);

+  if (pcVar1 == CBitmapRenderStrategy::IsReadyToDraw) {

+    *param_2 = false;

+    local_res8 = (IBitmapResource *)0x0;

+    wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::reset

+              ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res8);

+    CBitmapRenderStrategy::GetBitmap(this,&local_res8);

+    uVar2 = CBitmapRenderStrategy::HasRenderingRealization(local_res8);

+    wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::

+    ~com_ptr_t<IBitmapResource,wil::err_returncode_policy>

+              ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res8);

+  }

+  else {

+    if (pcVar1 == CPrimitiveGroupRenderStrategy::IsReadyToDraw) {

+      pCVar4 = GetSurface(this);

+      if (*(code **)(*(longlong *)pCVar4 + 0xd8) == CPrimitiveGroup::IsEmptyDrawing) {

+        uVar2 = CPrimitiveGroup::IsEmptyDrawing((CPrimitiveGroup *)pCVar4);

+      }

+      else {

+        uVar2 = (**(code **)(*(longlong *)pCVar4 + 0xd8))();

+      }

+      *param_2 = (bool)uVar2;

+      return true;

+    }

+    if (pcVar1 == CVisualSurfaceRenderStrategy::IsReadyToDraw) {

+      *param_2 = false;

+      pCVar4 = GetSurface(this);

+      bVar3 = CVisualSurface::HasSomethingToDraw((CVisualSurface *)pCVar4);

+      return bVar3;

+    }

+    uVar2 = (*pcVar1)(*(undefined8 **)(this + 0x88),this,param_1,param_2);

+  }

+  return (bool)uVar2;

+}

+
```

## `CCompositionSurfaceBitmap::IsOfType`  (modified)

```diff
--- CCompositionSurfaceBitmap::IsOfType
+++ CCompositionSurfaceBitmap::IsOfType
@@ -1,309 +1,11 @@
 

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

-/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

-   guard_dispatch_icall */

-/* WARNING: Removing unreachable block (ram,0x000180050ed0) */

-/* WARNING: Removing unreachable block (ram,0x000180050ee0) */

+/* public: virtual bool __cdecl CCompositionSurfaceBitmap::IsOfType(enum MIL_RESOURCE_TYPE)const

+   __ptr64 */

 

 bool __thiscall

-ShrinkableArray<CBatchCommand*___ptr64,UniqueLifetime<CBatchCommand*___ptr64>_>::IsOfType

-          (CCompositionSurfaceBitmap *this,MIL_RESOURCE_TYPE param_1)

+CCompositionSurfaceBitmap::IsOfType(CCompositionSurfaceBitmap *this,MIL_RESOURCE_TYPE param_1)

 

 {

-  undefined4 uVar1;

-  undefined4 uVar2;

-  float fVar3;

-  float fVar4;

-  uint *puVar5;

-  CGeometry *this_00;

-  code *pcVar6;

-  undefined8 *puVar7;

-  CEffectGeneratedT<CEffect,CPropertyChangeResource> *this_01;

-  undefined8 uVar8;

-  bool bVar9;

-  char cVar10;

-  uint uVar11;

-  long lVar12;

-  CMILMatrix *pCVar13;

-  char *in_RAX;

-  longlong lVar14;

-  uint *puVar15;

-  TMil3DRect<float,TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,D3D_RECT_F,MilPointAndSizeF,RectUniqueness::NotNeeded>

-  *unaff_RBX;

-  TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded> *unaff_RBP;

-  CRoundedRectangleShape *pCVar16;

-  ulonglong uVar17;

-  longlong unaff_RDI;

-  uint uVar18;

-  CRoundedRectangleShape *unaff_R12;

-  code *unaff_R13;

-  longlong lVar19;

-  char unaff_R15B;

-  float fVar20;

-  float fVar21;

-  float fVar22;

-  uint uVar23;

-  char cStack0000000000000040;

-  undefined8 in_stack_00000050;

-  undefined8 in_stack_00000058;

-  undefined8 in_stack_00000060;

-  undefined8 in_stack_00000068;

-  undefined8 in_stack_00000070;

-  undefined8 in_stack_00000078;

-  

-  lVar12 = CTreeEffect::GetBounds

-                     ((CTreeEffect *)CONCAT71((int7)((ulonglong)in_RAX >> 8),(char)in_RAX - *in_RAX)

-                      ,(TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

-                        *)(unaff_RDI + 0xb0),(D2D_SIZE_F *)(unaff_RBP + -0x10),

-                      (TMilRect_<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_D2D_POINTANDSIZE_F,struct_RectUniqueness::NotNeeded>

-                       *)unaff_RBP);

-  if (lVar12 < 0) {

-    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar12,0x18c3,unaff_R12);

-  }

-  else {

-    bVar9 = TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded>::IsInfinite(unaff_RBP);

-    if (bVar9) {

-      uVar8 = *(undefined8 *)(unaff_RDI + 0xb8);

-      *(undefined8 *)unaff_RBP = *(undefined8 *)(unaff_RDI + 0xb0);

-      *(undefined8 *)(unaff_RBP + 8) = uVar8;

-    }

-  }

-  uVar8 = *(undefined8 *)(unaff_RBP + 8);

-  uVar1 = *(undefined4 *)(unaff_RDI + 0xc0);

-  uVar2 = *(undefined4 *)(unaff_RDI + 0xc4);

-  *(undefined8 *)unaff_RBX = *(undefined8 *)unaff_RBP;

-  *(undefined8 *)(unaff_RBX + 8) = uVar8;

-  *(undefined4 *)(unaff_RBX + 0x10) = uVar1;

-  *(undefined4 *)(unaff_RBX + 0x14) = uVar2;

-  puVar5 = *(uint **)(unaff_RDI + 0xe8);

-  uVar18 = (uint)unaff_R12;

-  pCVar16 = unaff_R12;

-  if ((*puVar5 & 0x800000) != 0) {

-    uVar11 = puVar5[1];

-    puVar15 = puVar5 + 2;

-    uVar17 = (ulonglong)unaff_R12 & 0xffffffff;

-    uVar23 = uVar18;

-    if (uVar11 != 0) {

-      do {

-        uVar23 = (uint)uVar17;

-        if ((char)*puVar15 == '\t') break;

-        uVar23 = uVar23 + 1;

-        uVar17 = (ulonglong)uVar23;

-        puVar15 = (uint *)((longlong)puVar15 + 1);

-      } while (uVar23 < uVar11);

-    }

-    if (uVar23 < uVar11) {

-      pCVar16 = (CRoundedRectangleShape *)

-                ((longlong)puVar5 +

-                (ulonglong)uVar11 + 0xf +

-                ((ulonglong)uVar23 * 8 - (ulonglong)((uint)((ulonglong)uVar11 + 0xf) & 7)));

-    }

-    this_01 = *(CEffectGeneratedT<CEffect,CPropertyChangeResource> **)pCVar16;

-    pCVar16 = (CRoundedRectangleShape *)this_01;

-    if (*(code **)(*(longlong *)this_01 + 0x40) == unaff_R13) {

-      bVar9 = CEffectGeneratedT<CEffect,CPropertyChangeResource>::IsOfType(this_01,0xab);

-      if (!bVar9) {

-LAB_0:

-        if ((*(code **)(*(longlong *)this_01 + 0x40) == unaff_R13) ||

-           (cVar10 = (**(code **)(*(longlong *)this_01 + 0x40))(this_01,0x38), pCVar16 = unaff_R12,

-           cVar10 != '\0')) {

-          pCVar16 = (CRoundedRectangleShape *)*(CTransform3D **)(this_01 + 0x58);

-        }

-      }

-    }

-    else {

-      cVar10 = (**(code **)(*(longlong *)this_01 + 0x40))();

-      if (cVar10 == '\0') goto LAB_0;

-    }

-  }

-  if (pCVar16 != (CRoundedRectangleShape *)0x0) {

-    pCVar13 = CTransform3D::GetMatrix((CTransform3D *)pCVar16,(D2D_SIZE_F *)(unaff_RDI + 0x90));

-    uVar8 = *(undefined8 *)(pCVar13 + 8);

-    *(undefined8 *)(unaff_RBP + -0x60) = *(undefined8 *)pCVar13;

-    *(undefined8 *)(unaff_RBP + -0x58) = uVar8;

-    uVar8 = *(undefined8 *)(pCVar13 + 0x18);

-    *(undefined8 *)(unaff_RBP + -0x50) = *(undefined8 *)(pCVar13 + 0x10);

-    *(undefined8 *)(unaff_RBP + -0x48) = uVar8;

-    uVar8 = *(undefined8 *)(pCVar13 + 0x28);

-    *(undefined8 *)(unaff_RBP + -0x40) = *(undefined8 *)(pCVar13 + 0x20);

-    *(undefined8 *)(unaff_RBP + -0x38) = uVar8;

-    uVar8 = *(undefined8 *)(pCVar13 + 0x38);

-    *(undefined8 *)(unaff_RBP + -0x30) = *(undefined8 *)(pCVar13 + 0x30);

-    *(undefined8 *)(unaff_RBP + -0x28) = uVar8;

-    *(undefined4 *)(unaff_RBP + -0x20) = *(undefined4 *)(pCVar13 + 0x40);

-    if ((*(uint *)(unaff_RDI + 0x70) == uVar18) || (unaff_R15B != '\0')) {

-      in_stack_00000050 = 0x3f800000;

-      in_stack_00000058 = 0;

-      in_stack_00000060 = 0x3f80000000000000;

-      in_stack_00000068 = 0;

-      *(uint *)(unaff_RBP + -0x70) = uVar18;

-      *(undefined8 *)(unaff_RBP + -0x80) = 0;

-      *(undefined8 *)(unaff_RBP + -0x78) = 0x3f80000000000000;

-      in_stack_00000070 = 0;

-      in_stack_00000078 = 0;

-      *(undefined2 *)(unaff_RBP + -0x70) = 0x29a1;

-      CMILMatrix::Multiply((CMILMatrix *)(unaff_RBP + -0x60),(CMILMatrix *)&stack0x00000050);

-    }

-    CMILMatrix::Transform3DBoundsHelper<0>

-              ((CMILMatrix *)(unaff_RBP + -0x60),unaff_RBX,

-               (TMil3DRect<float,class_TMilRect_<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_D2D_POINTANDSIZE_F,struct_RectUniqueness::NotNeeded>,struct_D3D_RECT_F,struct_MilPointAndSizeF,struct_RectUniqueness::NotNeeded>

-                *)unaff_RBX);

-  }

-  this_00 = *(CGeometry **)(unaff_RDI + 0xf8);

-  cVar10 = (char)unaff_R12;

-  if (this_00 == (CGeometry *)0x0) {

-    return (bool)cVar10;

-  }

-  if (*(char *)(unaff_RDI + 0x69) < cVar10) {

-    return (bool)cVar10;

-  }

-  if (*(uint *)(unaff_RDI + 0x70) != uVar18) {

-    return (bool)cVar10;

-  }

-  *(undefined8 *)(unaff_RBP + -0x10) = 0;

-  *(undefined8 *)(unaff_RBP + -8) = 0;

-  cStack0000000000000040 = cVar10;

-  uVar11 = CGeometry::GetShapeData

-                     (this_00,(D2D_SIZE_F *)(unaff_RDI + 0x90),(CShapePtr *)&stack0x00000038);

-  if ((int)uVar11 < 0) {

-    uVar23 = 0x66;

-LAB_1:

-    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,uVar11,uVar23,unaff_R12);

-  }

-  else {

-    uVar11 = 0x8898008b;

-    if (unaff_R12 != (CRoundedRectangleShape *)0x0) {

-      pcVar6 = *(code **)(*(longlong *)unaff_R12 + 0x30);

-      if (pcVar6 == CRectanglesShape::GetTightBounds) {

-        puVar7 = *(undefined8 **)(unaff_R12 + 0x10);

-        uVar11 = uVar18;

-        if (*(undefined8 **)(unaff_R12 + 0x18) != puVar7) {

-          uVar8 = puVar7[1];

-          uVar17 = 1;

-          *(undefined8 *)(unaff_RBP + -0x10) = *puVar7;

-          *(undefined8 *)(unaff_RBP + -8) = uVar8;

-          lVar14 = *(longlong *)(unaff_R12 + 0x10);

-          if (1 < (ulonglong)(*(longlong *)(unaff_R12 + 0x18) - lVar14 >> 4)) {

-            lVar19 = 0x10;

-            do {

-              TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded>::UnionUnsafe

-                        (unaff_RBP + -0x10,

-                         (TMilRect<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_RectUniqueness::NotNeeded>

-                          *)(lVar14 + lVar19));

-              lVar14 = *(longlong *)(unaff_R12 + 0x10);

-              lVar19 = lVar19 + 0x10;

-              uVar17 = uVar17 + 1;

-            } while (uVar17 < (ulonglong)(*(longlong *)(unaff_R12 + 0x18) - lVar14 >> 4));

-          }

-        }

-        goto LAB_2;

-      }

-      if (pcVar6 == CRegionShape::GetTightBounds) {

-        *(undefined8 *)(unaff_RBP + 0x10) = 0;

-        *(undefined8 *)(unaff_RBP + 0x18) = 0;

-        bVar9 = FastRegion::CRegion::GetBoundingRect

-                          ((CRegion *)(unaff_R12 + 0x10),(tagRECT *)(unaff_RBP + 0x10));

-        uVar11 = uVar18;

-        if (bVar9) {

-          *(float *)(unaff_RBP + -0x10) = (float)*(int *)(unaff_RBP + 0x10);

-          *(float *)(unaff_RBP + -0xc) = (float)*(int *)(unaff_RBP + 0x14);

-          *(float *)(unaff_RBP + -8) = (float)*(int *)(unaff_RBP + 0x18);

-          *(float *)(unaff_RBP + -4) = (float)*(int *)(unaff_RBP + 0x1c);

-        }

-        goto LAB_2;

-      }

-      if (pcVar6 == CRoundedRectangleShape::GetTightBounds) {

-        uVar11 = CRoundedRectangleShape::GetTightBounds

-                           (unaff_R12,

-                            (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

-                             *)(unaff_RBP + -0x10),(CMILMatrix *)0x0);

-      }

-      else {

-        uVar11 = (*pcVar6)();

-      }

-      if (-1 < (int)uVar11) goto LAB_3;

-      MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,uVar11,0x140,unaff_R12);

-LAB_4:

-      uVar23 = 0x67;

-      goto LAB_1;

-    }

-LAB_3:

-    if ((int)uVar11 < 0) goto LAB_4;

-  }

-  if ((uVar11 == 0x8898000a) || (uVar11 == 0x8898008b)) {

-    *(undefined4 *)(unaff_RBP + -0x10) = 0xff7fffff;

-    *(undefined4 *)(unaff_RBP + -0xc) = 0xff7fffff;

-    *(undefined4 *)(unaff_RBP + -8) = 0x7f7fffff;

-    *(undefined4 *)(unaff_RBP + -4) = 0x7f7fffff;

-    *(undefined4 *)(unaff_RBP + -0x10) = 0xff7fffff;

-    *(undefined4 *)(unaff_RBP + -4) = 0x7f7fffff;

-    *(undefined4 *)(unaff_RBP + -0xc) = 0xff7fffff;

-    *(undefined4 *)(unaff_RBP + -8) = 0x7f7fffff;

-    uVar11 = uVar18;

-  }

-LAB_2:

-  if ((cStack0000000000000040 != cVar10) && (unaff_R12 != (CRoundedRectangleShape *)0x0)) {

-    pcVar6 = (code *)**(undefined8 **)unaff_R12;

-    if (pcVar6 == CRectanglesShape::_scalar_deleting_destructor_) {

-      CRectanglesShape::~CRectanglesShape((CRectanglesShape *)unaff_R12);

-      CThreadLocalObjectCache<CRectanglesShape,CRectanglesShape>::Free(unaff_R12);

-    }

-    else if (pcVar6 == CRoundedRectangleShape::_scalar_deleting_destructor_) {

-      CRoundedRectangleShape::~CRoundedRectangleShape(unaff_R12);

-      CThreadLocalObjectCache<CRoundedRectangleShape,CRoundedRectangleShape>::Free(unaff_R12);

-    }

-    else if (pcVar6 == CPolygonShape::_scalar_deleting_destructor_) {

-      CPolygonShape::_scalar_deleting_destructor_((CPolygonShape *)unaff_R12,1);

-    }

-    else {

-      (*pcVar6)();

-    }

-  }

-  if ((int)uVar11 < 0) {

-    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,uVar11,0x612,unaff_R12);

-  }

-  else {

-    fVar3 = *(float *)(unaff_RBP + -0x10);

-    fVar20 = *(float *)unaff_RBX;

-    if (*(float *)unaff_RBX < fVar3) {

-      *(float *)unaff_RBX = fVar3;

-      fVar20 = fVar3;

-    }

-    fVar3 = *(float *)(unaff_RBP + -0xc);

-    fVar22 = *(float *)(unaff_RBX + 4);

-    if (*(float *)(unaff_RBX + 4) < fVar3) {

-      *(float *)(unaff_RBX + 4) = fVar3;

-      fVar22 = fVar3;

-    }

-    fVar3 = *(float *)(unaff_RBP + -8);

-    fVar21 = *(float *)(unaff_RBX + 8);

-    if (fVar3 < *(float *)(unaff_RBX + 8)) {

-      *(float *)(unaff_RBX + 8) = fVar3;

-      fVar21 = fVar3;

-    }

-    fVar3 = *(float *)(unaff_RBP + -4);

-    fVar4 = *(float *)(unaff_RBX + 0xc);

-    if (fVar3 < *(float *)(unaff_RBX + 0xc)) {

-      *(float *)(unaff_RBX + 0xc) = fVar3;

-      fVar4 = fVar3;

-    }

-    if (*(float *)(unaff_RBX + 0x14) <= *(float *)(unaff_RBX + 0x10)) {

-      uVar18 = 1;

-    }

-    uVar23 = uVar18 + 1;

-    if (fVar20 < fVar21) {

-      uVar23 = uVar18;

-    }

-    uVar18 = uVar23 + 1;

-    if (fVar22 < fVar4) {

-      uVar18 = uVar23;

-    }

-    if (1 < uVar18) {

-      *(CRoundedRectangleShape **)(unaff_RBX + 0x10) = unaff_R12;

-      *(CRoundedRectangleShape **)(unaff_RBX + 8) = unaff_R12;

-      *(CRoundedRectangleShape **)unaff_RBX = unaff_R12;

-    }

-  }

-  return (bool)(char)uVar11;

+  return (param_1 - 0x29 & 0xfffffffb) == 0;

 }
```

## `CBitmapRenderStrategy::GetBrushParameters`  (modified)

```diff
--- CBitmapRenderStrategy::GetBrushParameters
+++ CBitmapRenderStrategy::GetBrushParameters
@@ -1,2 +1,218 @@
-Failed to decompile dwmcore.dll - .ProgramDB CBitmapRenderStrategy::GetBrushParameters : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* WARNING: Removing unreachable block (ram,0x000180045b44) */

+/* public: virtual long __cdecl CBitmapRenderStrategy::GetBrushParameters(class CSurfaceBrush const

+   * __ptr64,class CBrushDrawListGenerator * __ptr64)const __ptr64 */

+

+long __thiscall

+CBitmapRenderStrategy::GetBrushParameters

+          (CBitmapRenderStrategy *this,CSurfaceBrush *param_1,CBrushDrawListGenerator *param_2)

+

+{

+  D2D1_INTERPOLATION_MODE DVar1;

+  code *pcVar2;

+  CCompositionSurfaceBitmap *this_00;

+  CMILRefCountBaseT<IBitmapResource,CMilObjectDeleter> *this_01;

+  long lVar3;

+  Enum EVar4;

+  CResource *this_02;

+  CSurfaceDrawListBrush *pCVar5;

+  longlong lVar6;

+  ulonglong *puVar7;

+  IBitmapRealization *pIVar8;

+  ulonglong uVar9;

+  undefined4 uVar10;

+  float fVar11;

+  float fVar12;

+  undefined8 local_res18;

+  CCompositionSurfaceBitmap *local_res20;

+  uint uVar13;

+  CMILRefCountBaseT<IBitmapResource,CMilObjectDeleter> *local_d8;

+  IBitmapRealization *local_d0;

+  undefined1 local_c8;

+  undefined1 local_c0 [8];

+  float local_b8;

+  float fStack_b4;

+  float fStack_b0;

+  float fStack_ac;

+  float local_a8 [5];

+  undefined4 local_94;

+  float local_90;

+  float local_8c;

+  undefined4 local_88;

+  undefined8 local_80;

+  undefined8 uStack_78;

+  undefined8 local_70;

+  undefined8 uStack_68;

+  undefined8 local_60;

+  

+  local_res20 = (CCompositionSurfaceBitmap *)0x0;

+  local_res18 = 0;

+  this_02 = CSurfaceBrush::GetSurface(param_1);

+  if ((code *)**(undefined8 **)this_02 ==

+      CMILCOMBaseWeakRefSource<CResourceDeleter>::InternalQueryInterface) {

+    CMILCOMBaseWeakRefSource<CResourceDeleter>::InternalQueryInterface

+              ((CMILCOMBaseWeakRefSource<CResourceDeleter> *)this_02,

+               (_GUID *)&_GUID_b35f2031_4b76_4d4e_b98c_6771dfcc753c,&local_res20);

+  }

+  else {

+    (*(code *)**(undefined8 **)this_02)();

+  }

+  wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::

+  ~com_ptr_t<IBitmapResource,wil::err_returncode_policy>

+            ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res18);

+  local_60 = 0;

+  local_80 = 0;

+  uStack_78 = 0;

+  local_70 = 0;

+  uStack_68 = 0;

+  lVar3 = CSurfaceBrush::ComputeLayout

+                    (param_1,(D2D_SIZE_F *)(param_2 + 0x2c),(LayoutData *)&local_80,(CShape **)0x0);

+  this_00 = local_res20;

+  if (lVar3 < 0) {

+    uVar13 = 0x464;

+  }

+  else {

+    DVar1 = *(D2D1_INTERPOLATION_MODE *)(param_1 + 0x7c);

+    CBrushDrawListGenerator::Reset(param_2);

+    local_d8 = (CMILRefCountBaseT<IBitmapResource,CMilObjectDeleter> *)0x0;

+    local_d0 = (IBitmapRealization *)0x0;

+    local_c8 = 0;

+    pcVar2 = *(code **)(*(longlong *)this_00 + 0x40);

+    if (pcVar2 == CCompositionSurfaceBitmap::GetCurrentRenderingRealization) {

+      CCompositionSurfaceBitmap::GetCurrentRenderingRealization(this_00,&local_d0);

+    }

+    else if (pcVar2 == CCachedVisualImage::GetCurrentRenderingRealization) {

+      CCachedVisualImage::GetCurrentRenderingRealization((CCachedVisualImage *)this_00,&local_d0);

+    }

+    else if (pcVar2 == CCachedImageProducer::GetCurrentRenderingRealization) {

+      CCachedImageProducer::GetCurrentRenderingRealization

+                ((CCachedImageProducer *)this_00,&local_d0);

+    }

+    else {

+      (*pcVar2)();

+    }

+    this_01 = local_d8;

+    local_d8 = (CMILRefCountBaseT<IBitmapResource,CMilObjectDeleter> *)this_00;

+    if (*(code **)(*(longlong *)this_00 + 8) == CMILRefCountImpl::AddReference) {

+      CMILRefCountImpl::AddReference((CMILRefCountImpl *)this_00);

+    }

+    else {

+      (**(code **)(*(longlong *)this_00 + 8))();

+    }

+    if (this_01 != (CMILRefCountBaseT<IBitmapResource,CMilObjectDeleter> *)0x0) {

+      if (*(code **)(*(longlong *)this_01 + 0x10) ==

+          CMILRefCountBaseT<IBitmapResource,CMilObjectDeleter>::InternalRelease) {

+        CMILRefCountBaseT<IBitmapResource,CMilObjectDeleter>::InternalRelease(this_01);

+      }

+      else {

+        (**(code **)(*(longlong *)this_01 + 0x10))();

+      }

+    }

+    EVar4 = InterpolationMode::FromD2D1InterpolationMode(DVar1);

+    uVar9 = 0;

+    pIVar8 = local_d0;

+    if (local_d0 != (IBitmapRealization *)0x0) {

+      pcVar2 = *(code **)(*(longlong *)local_d0 + 0x20);

+      if (pcVar2 == IBitmapRealizationMethodsT<CDxHandleBitmapRealization,IGDIBitmapRealization>::

+                    GetSize_adjustor_320__) {

+        puVar7 = (ulonglong *)

+                 IBitmapRealizationMethodsT<CDxHandleBitmapRealization,IGDIBitmapRealization>::

+                 GetSize_adjustor_320__

+                           ((IBitmapRealizationMethodsT<CDxHandleBitmapRealization,IGDIBitmapRealization>

+                             *)local_d0);

+      }

+      else if (pcVar2 == CDxHandleBitmapRealization::GetSize_adjustor_256__) {

+        puVar7 = (ulonglong *)

+                 CDxHandleBitmapRealization::GetSize_adjustor_256__

+                           ((CDxHandleBitmapRealization *)local_d0);

+      }

+      else {

+        puVar7 = (ulonglong *)(*pcVar2)(local_d0,local_c0);

+      }

+      uVar9 = *puVar7;

+    }

+    local_a8[1] = 0.0;

+    local_a8[2] = 0.0;

+    local_a8[3] = 0.0;

+    local_94 = 0;

+    local_88 = 0x3f800000;

+    fVar12 = 1.0 / (float)(uVar9 & 0xffffffff);

+    fVar11 = 1.0 / (float)(uVar9 >> 0x20);

+    local_90 = 0.0 - fVar12 * 0.0;

+    local_8c = 0.0 - fVar11 * 0.0;

+    local_a8[0] = fVar12;

+    local_a8[4] = fVar11;

+    pCVar5 = CThreadLocalObjectCache<CSurfaceDrawListBrush,CSurfaceDrawListBrush>::Alloc

+                       ((__uint64)pIVar8);

+    if (pCVar5 == (CSurfaceDrawListBrush *)0x0) {

+LAB_0:

+      lVar3 = -0x7ff8fff2;

+      MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,-0x7ff8fff2,0x1f,(void *)0x0);

+      MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,-0x7ff8fff2,0x3b2,(void *)0x0);

+    }

+    else {

+      local_res18._0_3_ = CONCAT21(0x101,(char)EVar4);

+      lVar6 = CSurfaceDrawListBrush::CSurfaceDrawListBrush(pCVar5,&local_d8,&local_res18,local_a8,1)

+      ;

+      if (lVar6 == 0) goto LAB_0;

+      *(undefined1 *)(lVar6 + 0x34) = 1;

+      *(undefined4 *)(lVar6 + 0x30) = 0x3030303;

+      local_b8 = (float)uStack_68 * fVar12;

+      fStack_b4 = uStack_68._4_4_ * fVar11;

+      fStack_b0 = (float)local_60 * fVar12;

+      fStack_ac = local_60._4_4_ * fVar11;

+      *(float *)(lVar6 + 0x20) = (float)uStack_68;

+      *(float *)(lVar6 + 0x24) = uStack_68._4_4_;

+      *(float *)(lVar6 + 0x28) = (float)local_60;

+      *(float *)(lVar6 + 0x2c) = local_60._4_4_;

+      *(ulonglong *)(lVar6 + 0x78) = CONCAT44(fStack_b4,local_b8);

+      *(ulonglong *)(lVar6 + 0x80) = CONCAT44(fStack_ac,fStack_b0);

+      lVar3 = 0;

+      *(undefined4 *)(lVar6 + 8) = (undefined4)local_80;

+      *(undefined4 *)(lVar6 + 0xc) = local_80._4_4_;

+      *(undefined4 *)(lVar6 + 0x10) = (undefined4)uStack_78;

+      *(undefined4 *)(lVar6 + 0x14) = uStack_78._4_4_;

+      *(undefined8 *)(lVar6 + 0x18) = local_70;

+      if (param_1[200] != (CSurfaceBrush)0x0) {

+        *(undefined1 *)(lVar6 + 0x93) = 1;

+        *(float *)(lVar6 + 0x88) = (float)uStack_68;

+        *(float *)(lVar6 + 0x8c) = uStack_68._4_4_;

+      }

+      pCVar5 = *(CSurfaceDrawListBrush **)(param_2 + 8);

+      *(longlong *)(param_2 + 8) = lVar6;

+      if (pCVar5 != (CSurfaceDrawListBrush *)0x0) {

+        pcVar2 = (code *)**(undefined8 **)pCVar5;

+        if (pcVar2 == CMultiPrimitiveDrawListBrush::_vector_deleting_destructor_) {

+          CMultiPrimitiveDrawListBrush::_vector_deleting_destructor_

+                    ((CMultiPrimitiveDrawListBrush *)pCVar5,1);

+        }

+        else if (pcVar2 == CSurfaceDrawListBrush::_vector_deleting_destructor_) {

+          CSurfaceDrawListBrush::_vector_deleting_destructor_(pCVar5,1);

+        }

+        else if (pcVar2 == CDrawListPrimitive0::_scalar_deleting_destructor_) {

+          CDrawListPrimitive0::_scalar_deleting_destructor_((CDrawListPrimitive0 *)pCVar5,1);

+        }

+        else {

+          (*pcVar2)();

+        }

+      }

+      uVar10 = 1;

+      if (1 < *(uint *)(param_2 + 0x28)) {

+        uVar10 = *(undefined4 *)(param_2 + 0x28);

+      }

+      *(undefined4 *)(param_2 + 0x28) = uVar10;

+    }

+    CDrawListBitmap::~CDrawListBitmap((CDrawListBitmap *)&local_d8);

+    if (-1 < lVar3) goto LAB_1;

+    uVar13 = 0x466;

+  }

+  MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar3,uVar13,(void *)0x0);

+LAB_1:

+  wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::

+  ~com_ptr_t<IBitmapResource,wil::err_returncode_policy>

+            ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res20);

+  return lVar3;

+}

+
```

## `CVisual::GetRootTransform`  (modified)

```diff
--- CVisual::GetRootTransform
+++ CVisual::GetRootTransform
@@ -1,2 +1,1010 @@
-Failed to decompile dwmcore.dll - .ProgramDB CVisual::GetRootTransform : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: bool __cdecl CVisual::GetRootTransform(class CMILMatrix * __ptr64,bool,bool)const __ptr64

+    */

+

+bool __thiscall

+CVisual::GetRootTransform(CVisual *this,CMILMatrix *param_1,bool param_2,bool param_3)

+

+{

+  CComponentTransform3D *pCVar1;

+  CComponentTransform3D *pCVar2;

+  D2D_SIZE_F *pDVar3;

+  CComponentTransform3D *pCVar4;

+  undefined4 uVar5;

+  int iVar6;

+  undefined4 uVar7;

+  CComponentTransform3D *this_00;

+  code *pcVar8;

+  uint *puVar9;

+  float fVar10;

+  float fVar11;

+  float fVar12;

+  float fVar13;

+  float fVar14;

+  float fVar15;

+  float fVar16;

+  float fVar17;

+  undefined1 auVar18 [16];

+  undefined8 uVar19;

+  byte bVar20;

+  bool bVar21;

+  bool bVar22;

+  char cVar23;

+  uint uVar24;

+  __uint64 _Var25;

+  CEffect *pCVar27;

+  longlong lVar28;

+  CMILMatrix CVar29;

+  uint *puVar30;

+  CEffectGeneratedT<CEffect,CPropertyChangeResource> *this_01;

+  byte bVar31;

+  uint uVar32;

+  float fVar33;

+  float fVar34;

+  float fVar35;

+  float fVar36;

+  float fVar37;

+  float fVar38;

+  float fVar39;

+  float fVar40;

+  float fVar41;

+  float fVar42;

+  float fVar43;

+  float fVar44;

+  float fVar45;

+  float fVar46;

+  float fVar47;

+  float fVar48;

+  float fVar49;

+  float fVar50;

+  float fVar51;

+  float fVar52;

+  undefined8 local_1f8;

+  undefined8 uStack_1f0;

+  undefined8 local_1e8;

+  undefined8 uStack_1e0;

+  undefined8 local_1d8;

+  undefined8 uStack_1d0;

+  undefined8 local_1c8;

+  float fStack_1c0;

+  float fStack_1bc;

+  byte bStack_1b8;

+  byte bStack_1b7;

+  undefined2 uStack_1b6;

+  undefined1 local_1a8 [8];

+  float fStack_1a0;

+  float fStack_19c;

+  undefined1 local_198 [8];

+  float fStack_190;

+  float fStack_18c;

+  undefined1 local_188 [16];

+  undefined1 local_178 [8];

+  float fStack_170;

+  float fStack_16c;

+  undefined1 local_168 [8];

+  float fStack_160;

+  float fStack_15c;

+  float local_158;

+  undefined1 local_148 [8];

+  float fStack_140;

+  float fStack_13c;

+  undefined1 local_138 [8];

+  float fStack_130;

+  float fStack_12c;

+  undefined1 local_128 [8];

+  float fStack_120;

+  float fStack_11c;

+  undefined1 local_118 [8];

+  float fStack_110;

+  float fStack_10c;

+  undefined1 local_108 [8];

+  float fStack_100;

+  float fStack_fc;

+  undefined1 local_f8 [8];

+  float fStack_f0;

+  float fStack_ec;

+  undefined1 local_e8 [16];

+  CEffectGeneratedT<CEffect,CPropertyChangeResource> *pCVar26;

+  

+  *(undefined8 *)param_1 = 0x3f800000;

+  this_01 = (CEffectGeneratedT<CEffect,CPropertyChangeResource> *)0x0;

+  *(undefined8 *)(param_1 + 8) = 0;

+  uVar24 = 0;

+  *(undefined4 *)(param_1 + 0x10) = 0;

+  bVar21 = false;

+  *(undefined8 *)(param_1 + 0x14) = 0x3f800000;

+  *(undefined8 *)(param_1 + 0x1c) = 0;

+  *(undefined4 *)(param_1 + 0x24) = 0;

+  *(undefined8 *)(param_1 + 0x28) = 0x3f800000;

+  *(undefined8 *)(param_1 + 0x30) = 0;

+  *(undefined4 *)(param_1 + 0x38) = 0;

+  *(undefined4 *)(param_1 + 0x3c) = 0x3f800000;

+  CVar29 = (CMILMatrix)((byte)param_1[0x41] & 0xe9 | 0x29);

+  param_1[0x41] = CVar29;

+  param_1[0x40] = (CMILMatrix)0xaa;

+  if (!param_3) {

+    if (((*(float *)(this + 0x80) != 0.0) || (*(float *)(this + 0x84) != 0.0)) ||

+       (*(float *)(this + 0x7c) != 0.0)) {

+      uVar7 = *(undefined4 *)(this + 0x84);

+      uVar5 = *(undefined4 *)(this + 0x7c);

+      *(float *)(param_1 + 0x30) = *(float *)(this + 0x80);

+      bVar21 = true;

+      *(undefined4 *)(param_1 + 0x34) = uVar7;

+      *(undefined4 *)(param_1 + 0x38) = uVar5;

+      param_1[0x40] = (CMILMatrix)0xa8;

+      param_1[0x41] = CVar29;

+    }

+    this_00 = *(CComponentTransform3D **)(this + 0xf0);

+    if (this_00 != (CComponentTransform3D *)0x0) {

+      pDVar3 = (D2D_SIZE_F *)(this + 0x90);

+      bVar20 = (byte)this_00[0x28] & 1;

+      if (pDVar3 != (D2D_SIZE_F *)0x0) {

+        if (((bVar20 == 0) && (this_00[0x9c] != (CComponentTransform3D)0x0)) &&

+           ((*(float *)(this_00 + 0x94) != *(float *)pDVar3 ||

+            (*(float *)(this_00 + 0x98) != *(float *)(this + 0x94))))) {

+          bVar20 = 1;

+        }

+        *(undefined8 *)(this_00 + 0x94) = *(undefined8 *)pDVar3;

+      }

+      if (bVar20 != 0) {

+        pcVar8 = *(code **)(*(longlong *)this_00 + 200);

+        if (pcVar8 == CComponentTransform3D::GetRealization) {

+          CComponentTransform3D::GetRealization(this_00,pDVar3,(CMILMatrix *)(this_00 + 0x50));

+        }

+        else if (pcVar8 == CMatrixTransform::GetRealization) {

+          CMatrixTransform::GetRealization

+                    ((CMatrixTransform *)this_00,pDVar3,(CMILMatrix *)(this_00 + 0x50));

+        }

+        else {

+          (*pcVar8)();

+        }

+        *(uint *)(this_00 + 0x28) = *(uint *)(this_00 + 0x28) & 0xfffffffe;

+      }

+      uVar32 = *(uint *)(this_00 + 0x90);

+      bStack_1b8 = (byte)uVar32;

+      pCVar1 = this_00 + 0x50;

+      fVar46 = *(float *)pCVar1;

+      fVar47 = *(float *)(this_00 + 0x54);

+      local_1f8 = *(undefined8 *)pCVar1;

+      fVar45 = *(float *)(this_00 + 0x58);

+      fVar40 = *(float *)(this_00 + 0x5c);

+      uStack_1f0 = *(undefined8 *)(this_00 + 0x58);

+      fVar44 = *(float *)(this_00 + 0x60);

+      fVar42 = *(float *)(this_00 + 100);

+      local_1e8 = *(undefined8 *)(this_00 + 0x60);

+      fVar43 = *(float *)(this_00 + 0x68);

+      fVar51 = *(float *)(this_00 + 0x6c);

+      uStack_1e0 = *(undefined8 *)(this_00 + 0x68);

+      bStack_1b7 = (byte)(uVar32 >> 8);

+      uStack_1b6 = (undefined2)(uVar32 >> 0x10);

+      pCVar2 = this_00 + 0x70;

+      fVar37 = *(float *)pCVar2;

+      fVar39 = *(float *)(this_00 + 0x74);

+      local_1d8 = *(undefined8 *)pCVar2;

+      fVar49 = *(float *)(this_00 + 0x78);

+      fVar52 = *(float *)(this_00 + 0x7c);

+      auVar18 = *(undefined1 (*) [16])pCVar2;

+      uStack_1d0 = *(ulonglong *)(this_00 + 0x78);

+      pCVar4 = this_00 + 0x80;

+      fVar38 = *(float *)pCVar4;

+      fVar41 = *(float *)(this_00 + 0x84);

+      local_1c8 = *(undefined8 *)pCVar4;

+      fStack_1c0 = *(float *)(this_00 + 0x88);

+      fStack_1bc = *(float *)(this_00 + 0x8c);

+      cVar23 = (char)(bStack_1b8 << 6) >> 6;

+      if ('\0' < cVar23) {

+        local_f8._0_4_ = fStack_1bc;

+        local_138._0_4_ = fVar52;

+        local_108._0_4_ = fVar39;

+        local_118._0_4_ = fVar51;

+        local_1a8._0_4_ = fStack_1c0;

+        local_178._0_4_ = fVar42;

+        local_168._0_4_ = fVar43;

+        local_148._0_4_ = fVar45;

+        local_198._0_4_ = fVar38;

+        local_e8._0_4_ = fVar37;

+        local_128._0_4_ = fVar40;

+        local_188._0_4_ = fVar46;

+        goto LAB_0;

+      }

+      if (cVar23 < '\0') {

+LAB_1:

+        uVar7 = *(undefined4 *)(param_1 + 0x40);

+        fVar46 = *(float *)param_1;

+        fVar47 = *(float *)(param_1 + 4);

+        fVar45 = *(float *)(param_1 + 8);

+        fVar40 = *(float *)(param_1 + 0xc);

+        bStack_1b8 = (byte)uVar7;

+        bStack_1b7 = (byte)((uint)uVar7 >> 8);

+        uStack_1b6 = (undefined2)((uint)uVar7 >> 0x10);

+        fVar44 = *(float *)(param_1 + 0x10);

+        fVar42 = *(float *)(param_1 + 0x14);

+        fVar43 = *(float *)(param_1 + 0x18);

+        fVar51 = *(float *)(param_1 + 0x1c);

+        fVar37 = *(float *)(param_1 + 0x20);

+        fVar39 = *(float *)(param_1 + 0x24);

+        fVar49 = *(float *)(param_1 + 0x28);

+        fVar52 = *(float *)(param_1 + 0x2c);

+        fVar38 = *(float *)(param_1 + 0x30);

+        fVar41 = *(float *)(param_1 + 0x34);

+        fVar34 = *(float *)(param_1 + 0x38);

+        fVar50 = *(float *)(param_1 + 0x3c);

+        uVar19 = local_1c8;

+        fVar36 = fStack_1c0;

+      }

+      else {

+        cVar23 = (char)(bStack_1b7 << 4) >> 6;

+        if (cVar23 < '\x01') {

+          local_f8._4_4_ = fStack_1bc;

+          local_f8._0_4_ = fStack_1bc;

+          fStack_f0 = fStack_1bc;

+          fStack_ec = fStack_1bc;

+          local_138._4_4_ = fVar52;

+          local_138._0_4_ = fVar52;

+          fStack_130 = fVar52;

+          fStack_12c = fVar52;

+          local_108._4_4_ = fVar39;

+          local_108._0_4_ = fVar39;

+          fStack_100 = fVar39;

+          fStack_fc = fVar39;

+          local_118._4_4_ = fVar51;

+          local_118._0_4_ = fVar51;

+          fStack_110 = fVar51;

+          fStack_10c = fVar51;

+          local_128._4_4_ = fVar40;

+          local_128._0_4_ = fVar40;

+          fStack_120 = fVar40;

+          fStack_11c = fVar40;

+          if (-1 < cVar23) {

+            cVar23 = (char)(bStack_1b7 << 2) >> 6;

+            if (cVar23 < '\x01') {

+              if (-1 < cVar23) {

+                if (8.138021e-05 <=

+                    ABS((ABS(fVar51) * 61440.0 + ABS(fVar40) * 61440.0 + ABS(fStack_1bc)) - 1.0)) {

+                  bStack_1b7 = bStack_1b7 & 0xdf | 0x10;

+                  goto LAB_2;

+                }

+                bStack_1b7 = bStack_1b7 | 0x30;

+              }

+              if (((ABS(ABS(fVar52) * 61440.0 - 0.0) < 8.138021e-05) &&

+                  (ABS(fVar37 - 0.0) < 8.138021e-05)) && (ABS(fVar39 - 0.0) < 8.138021e-05)) {

+                bStack_1b7 = bStack_1b7 | 0xc;

+                goto LAB_3;

+              }

+            }

+LAB_2:

+            bStack_1b7 = bStack_1b7 & 0xf7 | 4;

+            goto LAB_4;

+          }

+LAB_3:

+          cVar23 = (char)(bStack_1b8 << 4) >> 6;

+          if ('\0' < cVar23) goto LAB_4;

+          local_148._4_4_ = fVar45;

+          local_148._0_4_ = fVar45;

+          fStack_140 = fVar45;

+          fStack_13c = fVar45;

+          local_168._4_4_ = fVar43;

+          local_168._0_4_ = fVar43;

+          fStack_160 = fVar43;

+          fStack_15c = fVar43;

+          local_e8 = auVar18;

+          if (-1 < cVar23) {

+            cVar23 = (char)(bStack_1b7 << 2) >> 6;

+            if (cVar23 < '\x01') {

+              if (-1 < cVar23) {

+                if (8.138021e-05 <=

+                    ABS((ABS(fVar51) * 61440.0 + ABS(fVar40) * 61440.0 + ABS(fStack_1bc)) - 1.0)) {

+                  bStack_1b7 = bStack_1b7 & 0xdf | 0x10;

+                  goto LAB_5;

+                }

+                bStack_1b7 = bStack_1b7 | 0x30;

+              }

+              if ((ABS(fVar45 - 0.0) < 8.138021e-05) && (ABS(fVar43 - 0.0) < 8.138021e-05)) {

+                bStack_1b8 = bStack_1b8 | 0xc;

+                uVar32 = (uint)bStack_1b8;

+                goto LAB_6;

+              }

+            }

+LAB_5:

+            local_1a8._4_4_ = fStack_1c0;

+            local_1a8._0_4_ = fStack_1c0;

+            fStack_1a0 = fStack_1c0;

+            fStack_19c = fStack_1c0;

+            bStack_1b8 = bStack_1b8 & 0xf5 | 5;

+            uVar32 = (uint)bStack_1b8;

+            local_178._4_4_ = fVar42;

+            local_178._0_4_ = fVar42;

+            fStack_170 = fVar42;

+            fStack_16c = fVar42;

+            _local_198 = *(undefined1 (*) [16])pCVar4;

+            local_188 = *(undefined1 (*) [16])pCVar1;

+            goto LAB_0;

+          }

+LAB_6:

+          bVar20 = (byte)uVar32;

+          cVar23 = (char)(bVar20 << 2) >> 6;

+          if ('\0' < cVar23) goto LAB_7;

+          if (cVar23 < '\0') {

+            local_178._4_4_ = fVar42;

+            local_178._0_4_ = fVar42;

+            fStack_170 = fVar42;

+            fStack_16c = fVar42;

+            local_188 = *(undefined1 (*) [16])pCVar1;

+          }

+          else {

+            bVar21 = CMILMatrix::IsTranslateAndScaleIgnoreZ<1>((CMILMatrix *)&local_1f8);

+            _local_178 = ZEXT416((uint)local_1e8._4_4_);

+            local_188 = ZEXT416((uint)(float)local_1f8);

+            fVar52 = uStack_1d0._4_4_;

+            fVar38 = (float)local_1c8;

+            fVar41 = local_1c8._4_4_;

+            fVar46 = (float)local_1f8;

+            fVar47 = local_1f8._4_4_;

+            fVar45 = (float)uStack_1f0;

+            fVar40 = uStack_1f0._4_4_;

+            fVar37 = (float)local_1d8;

+            fVar39 = local_1d8._4_4_;

+            fVar49 = (float)uStack_1d0;

+            fVar44 = (float)local_1e8;

+            fVar42 = local_1e8._4_4_;

+            fVar43 = (float)uStack_1e0;

+            fVar51 = uStack_1e0._4_4_;

+            if (((!bVar21) || (8.138021e-05 <= ABS((float)local_1f8 - 1.0))) ||

+               (8.138021e-05 <= ABS(local_1e8._4_4_ - 1.0))) {

+              bStack_1b8 = bStack_1b8 & 0xdd | 0x11;

+              uVar32 = (uint)bStack_1b8;

+              _local_f8 = ZEXT416((uint)fStack_1bc);

+              _local_138 = ZEXT416((uint)uStack_1d0._4_4_);

+              _local_108 = ZEXT416((uint)local_1d8._4_4_);

+              _local_118 = ZEXT416((uint)uStack_1e0._4_4_);

+              _local_1a8 = ZEXT416((uint)fStack_1c0);

+              _local_128 = ZEXT416((uint)uStack_1f0._4_4_);

+              _local_148 = ZEXT416((uint)(float)uStack_1f0);

+              _local_168 = ZEXT416((uint)(float)uStack_1e0);

+              _local_198 = ZEXT416((uint)(float)local_1c8);

+              local_e8 = ZEXT416((uint)(float)local_1d8);

+              goto LAB_0;

+            }

+            bVar20 = bStack_1b8 | 0x30;

+            _local_f8 = ZEXT416((uint)fStack_1bc);

+            _local_138 = ZEXT416((uint)uStack_1d0._4_4_);

+            _local_108 = ZEXT416((uint)local_1d8._4_4_);

+            _local_118 = ZEXT416((uint)uStack_1e0._4_4_);

+            _local_128 = ZEXT416((uint)uStack_1f0._4_4_);

+            local_e8 = ZEXT416((uint)(float)local_1d8);

+            _local_148 = ZEXT416((uint)(float)uStack_1f0);

+            _local_168 = ZEXT416((uint)(float)uStack_1e0);

+          }

+          if (8.138021e-05 <= ABS(fVar49 - 1.0)) {

+            local_198._0_4_ = fVar38;

+            local_1a8._0_4_ = fStack_1c0;

+            goto LAB_8;

+          }

+          local_198._4_4_ = fVar41;

+          local_198._0_4_ = fVar38;

+          fStack_190 = fStack_1c0;

+          fStack_18c = fStack_1bc;

+          if (ABS(fVar38 - 0.0) < 8.138021e-05) {

+            if (ABS(fVar41 - 0.0) < 8.138021e-05) {

+              local_1a8._4_4_ = fStack_1c0;

+              local_1a8._0_4_ = fStack_1c0;

+              fStack_1a0 = fStack_1c0;

+              fStack_19c = fStack_1c0;

+              if (ABS(fStack_1c0 - 0.0) < 8.138021e-05) goto LAB_1;

+              goto LAB_8;

+            }

+            bStack_1b8 = bVar20 & 0xfd | 1;

+            uVar32 = (uint)bStack_1b8;

+            local_1a8._4_4_ = fStack_1c0;

+            local_1a8._0_4_ = fStack_1c0;

+            fStack_1a0 = fStack_1c0;

+            fStack_19c = fStack_1c0;

+          }

+          else {

+            bStack_1b8 = bVar20 & 0xfd | 1;

+            uVar32 = (uint)bStack_1b8;

+            local_1a8._0_4_ = fStack_1c0;

+          }

+        }

+        else {

+          local_f8._0_4_ = fStack_1bc;

+          local_138._0_4_ = fVar52;

+          local_108._4_4_ = fVar39;

+          local_108._0_4_ = fVar39;

+          fStack_100 = fVar39;

+          fStack_fc = fVar39;

+          local_118._0_4_ = fVar51;

+          local_128._0_4_ = fVar40;

+LAB_4:

+          local_168._4_4_ = fVar43;

+          local_168._0_4_ = fVar43;

+          fStack_160 = fVar43;

+          fStack_15c = fVar43;

+          local_148._4_4_ = fVar45;

+          local_148._0_4_ = fVar45;

+          fStack_140 = fVar45;

+          fStack_13c = fVar45;

+LAB_7:

+          _local_198 = *(undefined1 (*) [16])pCVar4;

+          local_178._4_4_ = fVar42;

+          local_178._0_4_ = fVar42;

+          local_1a8._4_4_ = fStack_1c0;

+          local_1a8._0_4_ = fStack_1c0;

+          fStack_170 = fVar42;

+          fStack_1a0 = fStack_1c0;

+          local_e8 = *(undefined1 (*) [16])pCVar2;

+          fStack_16c = fVar42;

+          fStack_19c = fStack_1c0;

+          bVar20 = (byte)uVar32;

+          local_188 = *(undefined1 (*) [16])pCVar1;

+LAB_8:

+          bStack_1b8 = bVar20 & 0xfd | 1;

+          uVar32 = (uint)bStack_1b8;

+        }

+LAB_0:

+        fVar50 = fStack_1bc;

+        fVar34 = fStack_1c0;

+        bVar31 = (byte)uVar32;

+        bVar20 = bStack_1b7;

+        bVar21 = CMILMatrix::IsIdentity<1>(param_1);

+        uVar19 = local_1c8;

+        fVar36 = fStack_1c0;

+        if (!bVar21) {

+          CVar29 = param_1[0x41];

+          if ((char)(((byte)CVar29 & 0xfc) << 4) < '\x01') {

+            if (((byte)CVar29 & 8) == 0) {

+              cVar23 = (char)((char)CVar29 << 2) >> 6;

+              if (cVar23 < '\x01') {

+                if (cVar23 < '\0') {

+                  if (ABS(ABS(*(float *)(param_1 + 0x2c)) * 61440.0 - 0.0) < 8.138021e-05) {

+                    CVar29 = param_1[0x41];

+LAB_9:

+                    if ((ABS(*(float *)(param_1 + 0x20) - 0.0) < 8.138021e-05) &&

+                       (ABS(*(float *)(param_1 + 0x24) - 0.0) < 8.138021e-05)) {

+                      CVar29 = (CMILMatrix)((byte)CVar29 | 0xc);

+                      param_1[0x41] = CVar29;

+                      goto LAB_10;

+                    }

+                  }

+                }

+                else if (ABS((ABS(*(float *)(param_1 + 0x1c)) * 61440.0 +

+                              ABS(*(float *)(param_1 + 0xc)) * 61440.0 +

+                             ABS(*(float *)(param_1 + 0x3c))) - 1.0) < 8.138021e-05) {

+                  CVar29 = (CMILMatrix)((byte)CVar29 | 0x30);

+                  if (ABS(ABS(*(float *)(param_1 + 0x2c)) * 61440.0 - 0.0) < 8.138021e-05)

+                  goto LAB_9;

+                }

+                else {

+                  CVar29 = (CMILMatrix)((byte)CVar29 & 0xdf | 0x10);

+                }

+              }

+              param_1[0x41] = (CMILMatrix)((byte)CVar29 & 0xf7 | 4);

+            }

+            else {

+LAB_10:

+              cVar23 = (char)((char)param_1[0x40] << 4) >> 6;

+              if (cVar23 < '\x01') {

+                if (cVar23 < '\0') {

+LAB_11:

+                  cVar23 = (char)((char)param_1[0x40] << 2) >> 6;

+                  if (cVar23 < '\x01') {

+                    if (-1 < cVar23) {

+                      bVar21 = CMILMatrix::IsTranslateAndScaleIgnoreZ<1>(param_1);

+                      if (((!bVar21) || (8.138021e-05 <= ABS(*(float *)param_1 - 1.0))) ||

+                         (8.138021e-05 <= ABS(*(float *)(param_1 + 0x14) - 1.0))) {

+                        param_1[0x40] = (CMILMatrix)((byte)param_1[0x40] & 0xdf | 0x10);

+                        goto LAB_12;

+                      }

+                      param_1[0x40] = (CMILMatrix)((byte)param_1[0x40] | 0x30);

+                    }

+                    if (ABS(*(float *)(param_1 + 0x28) - 1.0) < 8.138021e-05) {

+                      fVar33 = *(float *)(param_1 + 0x30);

+                      fVar48 = *(float *)(param_1 + 0x38);

+                      fVar35 = *(float *)(param_1 + 0x34);

+                      if (((ABS(fVar33) < 8.138021e-05) && (ABS(fVar35) < 8.138021e-05)) &&

+                         (uVar19 = local_1c8, fVar36 = fStack_1c0, ABS(fVar48) < 8.138021e-05))

+                      goto LAB_13;

+                      cVar23 = (char)(bVar20 << 2) >> 6;

+                      if (cVar23 < '\x01') {

+                        if (-1 < cVar23) {

+                          if (8.138021e-05 <=

+                              ABS((ABS((float)local_118._0_4_) * 61440.0 +

+                                   ABS((float)local_128._0_4_) * 61440.0 +

+                                  ABS((float)local_f8._0_4_)) - 1.0)) {

+                            bVar20 = bVar20 & 0xdf | 0x10;

+                          }

+                          else {

+                            bVar20 = bVar20 | 0x30;

+                            bStack_1b7 = bVar20;

+                            if (ABS(ABS((float)local_138._0_4_) * 61440.0 - 0.0) < 8.138021e-05)

+                            goto LAB_14;

+                          }

+                          goto LAB_15;

+                        }

+                        if (8.138021e-05 <= ABS(ABS((float)local_138._0_4_) * 61440.0 - 0.0))

+                        goto LAB_15;

+                      }

+                      else {

+LAB_15:

+                        fVar46 = (float)local_188._0_4_ + (float)local_128._0_4_ * fVar33;

+                        fVar47 = local_1f8._4_4_ + (float)local_128._0_4_ * fVar35;

+                        fVar45 = (float)local_148._0_4_ + (float)local_128._0_4_ * fVar48;

+                        fVar44 = (float)local_1e8 + (float)local_118._0_4_ * fVar33;

+                        fVar42 = (float)local_178._0_4_ + (float)local_118._0_4_ * fVar35;

+                        fVar43 = (float)local_168._0_4_ + (float)local_118._0_4_ * fVar48;

+                        fVar37 = (float)local_e8._0_4_ + (float)local_138._0_4_ * fVar33;

+                        fVar39 = (float)local_108._0_4_ +

+                                 (float)local_138._0_4_ * *(float *)(param_1 + 0x34);

+                        fVar49 = fVar49 + (float)local_138._0_4_ * fVar48;

+                        fVar33 = (float)local_f8._0_4_ * *(float *)(param_1 + 0x30);

+                        local_1e8 = CONCAT44(fVar42,fVar44);

+                        uStack_1e0 = CONCAT44(uStack_1e0._4_4_,fVar43);

+                        local_1d8 = CONCAT44(fVar39,fVar37);

+                        uStack_1d0 = CONCAT44(uStack_1d0._4_4_,fVar49);

+                        fVar48 = (float)local_f8._0_4_ * *(float *)(param_1 + 0x38);

+                        fVar35 = (float)local_f8._0_4_ * *(float *)(param_1 + 0x34);

+                        local_1f8 = CONCAT44(fVar47,fVar46);

+                        uStack_1f0 = CONCAT44(uStack_1f0._4_4_,fVar45);

+                        fVar40 = uStack_1f0._4_4_;

+                        fVar52 = uStack_1d0._4_4_;

+                        fVar51 = uStack_1e0._4_4_;

+                        bStack_1b7 = bVar20 & 0xf3;

+                      }

+LAB_14:

+                      bStack_1b8 = bVar31 & 0xfc;

+                      local_1c8 = CONCAT44(fVar41 + fVar35,(float)local_198._0_4_ + fVar33);

+                      fVar38 = (float)local_198._0_4_ + fVar33;

+                      fVar41 = fVar41 + fVar35;

+                      fVar34 = (float)local_1a8._0_4_ + fVar48;

+                      fVar50 = fStack_1bc;

+                      uVar19 = local_1c8;

+                      fVar36 = (float)local_1a8._0_4_ + fVar48;

+                      goto LAB_13;

+                    }

+                  }

+                }

+                else {

+                  cVar23 = (char)((char)CVar29 << 2) >> 6;

+                  if (cVar23 < '\x01') {

+                    if (-1 < cVar23) {

+                      if (8.138021e-05 <=

+                          ABS((ABS(*(float *)(param_1 + 0x1c)) * 61440.0 +

+                               ABS(*(float *)(param_1 + 0xc)) * 61440.0 +

+                              ABS(*(float *)(param_1 + 0x3c))) - 1.0)) {

+                        param_1[0x41] = (CMILMatrix)((byte)CVar29 & 0xdf | 0x10);

+                        param_1[0x40] = (CMILMatrix)((byte)param_1[0x40] & 0xf7 | 4);

+                        goto LAB_12;

+                      }

+                      param_1[0x41] = (CMILMatrix)((byte)CVar29 | 0x30);

+                    }

+                    if ((ABS(*(float *)(param_1 + 8) - 0.0) < 8.138021e-05) &&

+                       (ABS(*(float *)(param_1 + 0x18) - 0.0) < 8.138021e-05)) {

+                      param_1[0x40] = (CMILMatrix)((byte)param_1[0x40] | 0xc);

+                      goto LAB_11;

+                    }

+                  }

+                  param_1[0x40] = (CMILMatrix)((byte)param_1[0x40] & 0xf7 | 4);

+                }

+              }

+            }

+          }

+LAB_12:

+          bVar21 = CMILMatrix::IsTranslate<1>((CMILMatrix *)&local_1f8);

+          if (bVar21) {

+            fVar33 = (float)local_1c8;

+            fVar48 = local_1c8._4_4_;

+            local_158 = local_1c8._4_4_;

+            fVar38 = *(float *)(param_1 + 0x30);

+            fVar41 = *(float *)(param_1 + 0x34);

+            fVar34 = *(float *)(param_1 + 0x38);

+            fVar50 = *(float *)(param_1 + 0x3c);

+            uVar7 = *(undefined4 *)(param_1 + 0x40);

+            bStack_1b8 = (byte)uVar7;

+            bStack_1b7 = (byte)((uint)uVar7 >> 8);

+            uStack_1b6 = (undefined2)((uint)uVar7 >> 0x10);

+            fVar46 = *(float *)param_1;

+            fVar47 = *(float *)(param_1 + 4);

+            fVar45 = *(float *)(param_1 + 8);

+            fVar40 = *(float *)(param_1 + 0xc);

+            fVar44 = *(float *)(param_1 + 0x10);

+            fVar42 = *(float *)(param_1 + 0x14);

+            fVar43 = *(float *)(param_1 + 0x18);

+            fVar51 = *(float *)(param_1 + 0x1c);

+            fVar37 = *(float *)(param_1 + 0x20);

+            fVar39 = *(float *)(param_1 + 0x24);

+            fVar49 = *(float *)(param_1 + 0x28);

+            fVar52 = *(float *)(param_1 + 0x2c);

+            fStack_1bc = fVar50;

+            if (((8.138021e-05 <= ABS((float)local_1c8)) || (8.138021e-05 <= ABS(local_1c8._4_4_)))

+               || (uVar19 = *(undefined8 *)(param_1 + 0x30), fVar36 = fVar34,

+                  8.138021e-05 <= ABS(fStack_1c0))) {

+              fVar38 = fVar38 + fVar44 * local_1c8._4_4_ + fVar46 * (float)local_1c8 +

+                                fStack_1c0 * fVar37;

+              fVar41 = fVar41 + fVar47 * (float)local_1c8 + fVar42 * local_1c8._4_4_ +

+                                fStack_1c0 * fVar39;

+              fVar36 = fVar43 * local_1c8._4_4_;

+              local_1c8 = CONCAT44(fVar41,fVar38);

+              fVar34 = fVar34 + fVar36 + fVar45 * fVar33 + fStack_1c0 * fVar49;

+              cVar23 = (char)(bStack_1b7 << 2) >> 6;

+              fVar36 = fVar34;

+              if (cVar23 < '\x01') {

+                if (-1 < cVar23) {

+                  if (8.138021e-05 <=

+                      ABS((ABS(fVar51) * 61440.0 + ABS(fVar40) * 61440.0 + ABS(fVar50)) - 1.0))

+                  goto LAB_16;

+                  bStack_1b7 = bStack_1b7 | 0x30;

+                }

+                if (ABS(ABS(fVar52) * 61440.0 - 0.0) < 8.138021e-05) {

+                  bStack_1b8 = bStack_1b8 & 0xfc;

+                  uVar19 = local_1c8;

+                  goto LAB_13;

+                }

+              }

+LAB_16:

+              bStack_1b8 = 0;

+              bStack_1b7 = 0;

+              uStack_1b6 = 0;

+              fVar50 = fVar50 + fVar51 * fVar48 + fVar40 * fVar33 + fStack_1c0 * fVar52;

+              uVar19 = CONCAT44(fVar41,fVar38);

+              fStack_1bc = fVar50;

+            }

+          }

+          else {

+            bVar21 = CMILMatrix::IsTranslateAndScale<1>(param_1);

+            if (bVar21) {

+              fVar46 = *(float *)param_1;

+              fVar47 = *(float *)(param_1 + 0x28);

+              fVar45 = *(float *)(param_1 + 0x14);

+              if (((8.138021e-05 <= ABS(fVar46 - 1.0)) || (8.138021e-05 <= ABS(fVar45 - 1.0))) ||

+                 (fVar40 = local_1c8._4_4_, fVar44 = (float)local_1c8, fVar42 = local_1d8._4_4_,

+                 fVar43 = (float)local_1d8, fVar51 = local_1e8._4_4_, fVar37 = (float)local_1e8,

+                 fVar39 = local_1f8._4_4_, 8.138021e-05 <= ABS(fVar47 - 1.0))) {

+                fVar37 = (float)local_1e8 * fVar46;

+                fVar43 = (float)local_1d8 * fVar46;

+                fVar44 = (float)local_1c8 * fVar46;

+                fVar39 = local_1f8._4_4_ * fVar45;

+                fVar51 = local_1e8._4_4_ * fVar45;

+                fVar42 = local_1d8._4_4_ * fVar45;

+                fVar40 = local_1c8._4_4_ * fVar45;

+                local_1f8 = CONCAT44(fVar39,(float)local_1f8 * fVar46);

+                local_1e8 = CONCAT44(fVar51,fVar37);

+                local_1d8 = CONCAT44(fVar42,fVar43);

+                local_1c8 = CONCAT44(fVar40,fVar44);

+                if (8.138021e-05 <= ABS(fVar47 - 1.0)) {

+                  uStack_1f0 = CONCAT44(uStack_1f0._4_4_,(float)uStack_1f0 * fVar47);

+                  fStack_1c0 = fStack_1c0 * fVar47;

+                  uStack_1d0 = CONCAT44(uStack_1d0._4_4_,(float)uStack_1d0 * fVar47);

+                  uStack_1e0 = CONCAT44(uStack_1e0._4_4_,(float)uStack_1e0 * fVar47);

+                }

+                bStack_1b8 = bStack_1b8 & 0xcc;

+              }

+              if (((8.138021e-05 <= ABS(*(float *)(param_1 + 0x30))) ||

+                  (8.138021e-05 <= ABS(*(float *)(param_1 + 0x34)))) ||

+                 (8.138021e-05 <= ABS(*(float *)(param_1 + 0x38)))) {

+                cVar23 = (char)(bStack_1b7 << 2) >> 6;

+                if (cVar23 < '\x01') {

+                  if (-1 < cVar23) {

+                    if (8.138021e-05 <=

+                        ABS((ABS(uStack_1e0._4_4_) * 61440.0 + ABS(uStack_1f0._4_4_) * 61440.0 +

+                            ABS(fStack_1bc)) - 1.0)) {

+                      bStack_1b7 = bStack_1b7 & 0xdf | 0x10;

+                    }

+                    else {

+                      bStack_1b7 = bStack_1b7 | 0x30;

+                      if (ABS(ABS(uStack_1d0._4_4_) * 61440.0 - 0.0) < 8.138021e-05)

+                      goto LAB_17;

+                    }

+                    goto LAB_18;

+                  }

+                  if (8.138021e-05 <= ABS(ABS(uStack_1d0._4_4_) * 61440.0 - 0.0))

+                  goto LAB_18;

+LAB_17:

+                  fVar47 = *(float *)(param_1 + 0x30);

+                  fVar45 = *(float *)(param_1 + 0x34);

+                  fVar49 = *(float *)(param_1 + 0x38);

+                }

+                else {

+LAB_18:

+                  bStack_1b7 = bStack_1b7 & 0xf3;

+                  fVar47 = *(float *)(param_1 + 0x30);

+                  fVar49 = *(float *)(param_1 + 0x38);

+                  fVar46 = *(float *)(param_1 + 0x34);

+                  local_1f8 = CONCAT44(fVar39 + uStack_1f0._4_4_ * fVar46,

+                                       (float)local_1f8 + uStack_1f0._4_4_ * fVar47);

+                  uStack_1f0 = CONCAT44(uStack_1f0._4_4_,

+                                        (float)uStack_1f0 + uStack_1f0._4_4_ * fVar49);

+                  local_1e8 = CONCAT44(fVar51 + uStack_1e0._4_4_ * fVar46,

+                                       fVar37 + uStack_1e0._4_4_ * fVar47);

+                  uStack_1e0 = CONCAT44(uStack_1e0._4_4_,

+                                        (float)uStack_1e0 + uStack_1e0._4_4_ * fVar49);

+                  fVar45 = fStack_1bc * fVar46;

+                  local_1d8 = CONCAT44(fVar42 + uStack_1d0._4_4_ * fVar46,

+                                       fVar43 + uStack_1d0._4_4_ * fVar47);

+                  uStack_1d0 = CONCAT44(uStack_1d0._4_4_,

+                                        (float)uStack_1d0 + uStack_1d0._4_4_ * fVar49);

+                  fVar47 = fStack_1bc * fVar47;

+                  fVar49 = fStack_1bc * fVar49;

+                }

+                fStack_1c0 = fStack_1c0 + fVar49;

+                bStack_1b8 = bStack_1b8 & 0xfc;

+                local_1c8 = CONCAT44(fVar40 + fVar45,fVar44 + fVar47);

+              }

+              fVar38 = (float)local_1c8;

+              fVar41 = local_1c8._4_4_;

+              fVar34 = fStack_1c0;

+              fVar50 = fStack_1bc;

+              fVar46 = (float)local_1f8;

+              fVar47 = local_1f8._4_4_;

+              fVar45 = (float)uStack_1f0;

+              fVar40 = uStack_1f0._4_4_;

+              fVar37 = (float)local_1d8;

+              fVar39 = local_1d8._4_4_;

+              fVar49 = (float)uStack_1d0;

+              fVar52 = uStack_1d0._4_4_;

+              fVar44 = (float)local_1e8;

+              fVar42 = local_1e8._4_4_;

+              fVar43 = (float)uStack_1e0;

+              fVar51 = uStack_1e0._4_4_;

+              uVar19 = local_1c8;

+              fVar36 = fStack_1c0;

+            }

+            else {

+              bVar21 = CMILMatrix::IsPure2DUniformZ<1>((CMILMatrix *)&local_1f8);

+              if ((bVar21) && (bVar21 = CMILMatrix::IsPure2DUniformZ<1>(param_1), bVar21)) {

+                fVar45 = *(float *)(param_1 + 0x10);

+                fVar40 = *(float *)(param_1 + 4);

+                fVar43 = *(float *)(param_1 + 0x14);

+                fVar51 = *(float *)param_1;

+                fStack_1bc = 1.0;

+                uStack_1b6 = 0;

+                bStack_1b7 = 0x28;

+                uStack_1e0._0_4_ = 0.0;

+                uStack_1e0._4_4_ = 0.0;

+                fVar49 = (float)uStack_1d0;

+                local_1d8._0_4_ = 0.0;

+                local_1d8._4_4_ = 0.0;

+                uStack_1d0._4_4_ = 0.0;

+                fVar52 = uStack_1d0._4_4_;

+                fVar42 = local_1e8._4_4_ * fVar43 + (float)local_1e8 * fVar40;

+                fVar44 = local_1e8._4_4_ * fVar45 + (float)local_1e8 * fVar51;

+                bStack_1b8 = 8;

+                fVar46 = local_1f8._4_4_ * fVar45 + (float)local_1f8 * fVar51;

+                fVar34 = fStack_1c0 * *(float *)(param_1 + 0x28) + *(float *)(param_1 + 0x38);

+                uStack_1f0._0_4_ = 0.0;

+                uStack_1f0._4_4_ = 0.0;

+                local_1e8 = CONCAT44(fVar42,fVar44);

+                uStack_1e0 = 0;

+                fVar47 = local_1f8._4_4_ * fVar43 + (float)local_1f8 * fVar40;

+                fVar38 = local_1c8._4_4_ * fVar45 + (float)local_1c8 * fVar51 +

+                         *(float *)(param_1 + 0x30);

+                fVar49 = fVar49 * *(float *)(param_1 + 0x28);

+                fVar41 = local_1c8._4_4_ * fVar43 + (float)local_1c8 * fVar40 +

+                         *(float *)(param_1 + 0x34);

+                local_1d8 = 0;

+                uStack_1d0 = (ulonglong)(uint)fVar49;

+                local_1f8 = CONCAT44(fVar47,fVar46);

+                uStack_1f0 = 0;

+                local_1c8 = CONCAT44(fVar41,fVar38);

+                fVar50 = fStack_1bc;

+                fVar45 = (float)uStack_1f0;

+                fVar40 = uStack_1f0._4_4_;

+                fVar37 = (float)local_1d8;

+                fVar39 = local_1d8._4_4_;

+                fVar43 = (float)uStack_1e0;

+                fVar51 = uStack_1e0._4_4_;

+                uVar19 = local_1c8;

+                fVar36 = fVar34;

+              }

+              else {

+                fVar44 = *(float *)param_1;

+                fVar42 = *(float *)(param_1 + 4);

+                fVar43 = *(float *)(param_1 + 8);

+                fVar51 = *(float *)(param_1 + 0xc);

+                bStack_1b8 = 0;

+                bStack_1b7 = 0;

+                uStack_1b6 = 0;

+                fVar36 = *(float *)(param_1 + 0x10);

+                fVar33 = *(float *)(param_1 + 0x14);

+                fVar48 = *(float *)(param_1 + 0x18);

+                fVar35 = *(float *)(param_1 + 0x1c);

+                fVar10 = *(float *)(param_1 + 0x20);

+                fVar11 = *(float *)(param_1 + 0x24);

+                fVar12 = *(float *)(param_1 + 0x28);

+                fVar13 = *(float *)(param_1 + 0x2c);

+                fVar14 = *(float *)(param_1 + 0x30);

+                fVar15 = *(float *)(param_1 + 0x34);

+                fVar16 = *(float *)(param_1 + 0x38);

+                fVar17 = *(float *)(param_1 + 0x3c);

+                fVar38 = fStack_1bc * fVar14 + local_1c8._4_4_ * fVar36 +

+                         fStack_1c0 * fVar10 + (float)local_1c8 * fVar44;

+                fVar41 = fStack_1bc * fVar15 + local_1c8._4_4_ * fVar33 +

+                         fStack_1c0 * fVar11 + (float)local_1c8 * fVar42;

+                fVar34 = fStack_1bc * fVar16 + local_1c8._4_4_ * fVar48 +

+                         fStack_1c0 * fVar12 + (float)local_1c8 * fVar43;

+                fVar50 = fStack_1bc * fVar17 + local_1c8._4_4_ * fVar35 +

+                         fStack_1c0 * fVar13 + (float)local_1c8 * fVar51;

+                fVar46 = uStack_1f0._4_4_ * fVar14 + local_1f8._4_4_ * fVar36 +

+                         (float)uStack_1f0 * fVar10 + (float)local_1f8 * fVar44;

+                fVar47 = uStack_1f0._4_4_ * fVar15 + local_1f8._4_4_ * fVar33 +

+                         (float)uStack_1f0 * fVar11 + (float)local_1f8 * fVar42;

+                fVar45 = uStack_1f0._4_4_ * fVar16 + local_1f8._4_4_ * fVar48 +

+                         (float)uStack_1f0 * fVar12 + (float)local_1f8 * fVar43;

+                fVar40 = uStack_1f0._4_4_ * fVar17 + local_1f8._4_4_ * fVar35 +

+                         (float)uStack_1f0 * fVar13 + (float)local_1f8 * fVar51;

+                fVar37 = uStack_1d0._4_4_ * fVar14 + local_1d8._4_4_ * fVar36 +

+                         (float)uStack_1d0 * fVar10 + (float)local_1d8 * fVar44;

+                fVar39 = uStack_1d0._4_4_ * fVar15 + local_1d8._4_4_ * fVar33 +

+                         (float)uStack_1d0 * fVar11 + (float)local_1d8 * fVar42;

+                fVar49 = uStack_1d0._4_4_ * fVar16 + local_1d8._4_4_ * fVar48 +

+                         (float)uStack_1d0 * fVar12 + (float)local_1d8 * fVar43;

+                fVar52 = uStack_1d0._4_4_ * fVar17 + local_1d8._4_4_ * fVar35 +

+                         (float)uStack_1d0 * fVar13 + (float)local_1d8 * fVar51;

+                fVar44 = uStack_1e0._4_4_ * fVar14 + local_1e8._4_4_ * fVar36 +

+                         (float)uStack_1e0 * fVar10 + (float)local_1e8 * fVar44;

+                fVar42 = uStack_1e0._4_4_ * fVar15 + local_1e8._4_4_ * fVar33 +

+                         (float)uStack_1e0 * fVar11 + (float)local_1e8 * fVar42;

+                fVar43 = uStack_1e0._4_4_ * fVar16 + local_1e8._4_4_ * fVar48 +

+                         (float)uStack_1e0 * fVar12 + (float)local_1e8 * fVar43;

+                fVar51 = uStack_1e0._4_4_ * fVar17 + local_1e8._4_4_ * fVar35 +

+                         (float)uStack_1e0 * fVar13 + (float)local_1e8 * fVar51;

+                uVar19 = local_1c8;

+                fVar36 = fStack_1c0;

+              }

+            }

+          }

+        }

+      }

+LAB_13:

+      fStack_1c0 = fVar36;

+      local_1c8 = uVar19;

+      bVar21 = true;

+      *(float *)param_1 = fVar46;

+      *(float *)(param_1 + 4) = fVar47;

+      *(float *)(param_1 + 8) = fVar45;

+      *(float *)(param_1 + 0xc) = fVar40;

+      *(float *)(param_1 + 0x10) = fVar44;

+      *(float *)(param_1 + 0x14) = fVar42;

+      *(float *)(param_1 + 0x18) = fVar43;

+      *(float *)(param_1 + 0x1c) = fVar51;

+      *(float *)(param_1 + 0x20) = fVar37;

+      *(float *)(param_1 + 0x24) = fVar39;

+      *(float *)(param_1 + 0x28) = fVar49;

+      *(float *)(param_1 + 0x2c) = fVar52;

+      *(float *)(param_1 + 0x30) = fVar38;

+      *(float *)(param_1 + 0x34) = fVar41;

+      *(float *)(param_1 + 0x38) = fVar34;

+      *(float *)(param_1 + 0x3c) = fVar50;

+      *(uint *)(param_1 + 0x40) = CONCAT22(uStack_1b6,CONCAT11(bStack_1b7,bStack_1b8));

+    }

+  }

+  if (param_2) {

+    return bVar21;

+  }

+  puVar9 = *(uint **)(this + 0xe8);

+  if ((*puVar9 & 0x800000) != 0) {

+    puVar30 = puVar9 + 2;

+    pCVar26 = this_01;

+    if (puVar9[1] != 0) {

+      do {

+        uVar24 = (uint)pCVar26;

+        if ((char)*puVar30 == '\t') break;

+        uVar24 = uVar24 + 1;

+        pCVar26 = (CEffectGeneratedT<CEffect,CPropertyChangeResource> *)(ulonglong)uVar24;

+        puVar30 = (uint *)((longlong)puVar30 + 1);

+      } while (uVar24 < puVar9[1]);

+    }

+    pCVar26 = this_01;

+    if (uVar24 < puVar9[1]) {

+      lVar28 = (ulonglong)puVar9[1] + 0xf;

+      pCVar26 = (CEffectGeneratedT<CEffect,CPropertyChangeResource> *)

+                (((ulonglong)uVar24 * 8 - (ulonglong)((uint)lVar28 & 7)) + lVar28 + (longlong)puVar9

+                );

+    }

+    pCVar26 = *(CEffectGeneratedT<CEffect,CPropertyChangeResource> **)pCVar26;

+    if (*(code **)(*(longlong *)pCVar26 + 0x40) ==

+        CEffectGroupGeneratedT<CEffectGroup,CEffect>::IsOfType) {

+      bVar22 = CEffectGeneratedT<CEffect,CPropertyChangeResource>::IsOfType(pCVar26,0xab);

+      if (!bVar22) {

+LAB_19:

+        if ((*(code **)(*(longlong *)pCVar26 + 0x40) !=

+             CEffectGroupGeneratedT<CEffectGroup,CEffect>::IsOfType) &&

+           (cVar23 = (**(code **)(*(longlong *)pCVar26 + 0x40))(pCVar26,0x38), cVar23 == '\0'))

+        goto LAB_20;

+        pCVar26 = *(CEffectGeneratedT<CEffect,CPropertyChangeResource> **)(pCVar26 + 0x58);

+      }

+    }

+    else {

+      cVar23 = (**(code **)(*(longlong *)pCVar26 + 0x40))();

+      if (cVar23 == '\0') goto LAB_19;

+    }

+    this_01 = pCVar26;

+    if (pCVar26 != (CEffectGeneratedT<CEffect,CPropertyChangeResource> *)0x0) goto LAB_21;

+  }

+LAB_20:

+  if (*(longlong *)(this + 0x58) == 0) {

+    return bVar21;

+  }

+  if (*(int *)(*(longlong *)(this + 0x58) + 0x70) != 1) {

+    return bVar21;

+  }

+  iVar6 = *(int *)(this + 0x70);

+  _Var25 = CPtrArray<CVisual>::GetCount((CPtrArray<CVisual> *)(this + 0x50));

+  if ((**(uint **)(this + 0xe8) & 0x800000) == 0) {

+LAB_22:

+    bVar22 = false;

+  }

+  else {

+    pCVar27 = GetEffectInternal(this);

+    cVar23 = (**(code **)(*(longlong *)pCVar27 + 0x40))(pCVar27,0x3b);

+    if (cVar23 == '\0') goto LAB_22;

+    bVar22 = true;

+  }

+  if (*(code **)(*(longlong *)this + 0xe0) == CLayerVisual::GetTreeEffect) {

+    lVar28 = *(longlong *)(this + 0x2b0);

+  }

+  else {

+    lVar28 = (**(code **)(*(longlong *)this + 0xe0))(this);

+  }

+  if ((((iVar6 == 1) || ((int)_Var25 == 0)) && (!bVar22)) && (lVar28 == 0)) {

+    return bVar21;

+  }

+LAB_21:

+  *(undefined8 *)(param_1 + 0x20) = 0;

+  *(undefined8 *)(param_1 + 0x28) = 0;

+  param_1[0x40] = (CMILMatrix)((byte)param_1[0x40] & 0xf1 | 1);

+  if (this_01 != (CEffectGeneratedT<CEffect,CPropertyChangeResource> *)0x0) {

+    pDVar3 = (D2D_SIZE_F *)(this + 0x90);

+    bVar20 = (byte)*(CComponentTransform3D *)(this_01 + 0x28) & 1;

+    if (pDVar3 != (D2D_SIZE_F *)0x0) {

+      if (((bVar20 == 0) &&

+          (*(CComponentTransform3D *)(this_01 + 0x9c) != (CComponentTransform3D)0x0)) &&

+         ((*(float *)(this_01 + 0x94) != *(float *)pDVar3 ||

+          (*(float *)(this_01 + 0x98) != *(float *)(this + 0x94))))) {

+        bVar20 = 1;

+      }

+      *(undefined8 *)(this_01 + 0x94) = *(undefined8 *)pDVar3;

+    }

+    if (bVar20 != 0) {

+      pcVar8 = *(code **)(*(longlong *)this_01 + 200);

+      if (pcVar8 == CComponentTransform3D::GetRealization) {

+        CComponentTransform3D::GetRealization

+                  ((CComponentTransform3D *)this_01,pDVar3,(CMILMatrix *)(this_01 + 0x50));

+      }

+      else if (pcVar8 == CMatrixTransform::GetRealization) {

+        CMatrixTransform::GetRealization

+                  ((CMatrixTransform *)this_01,pDVar3,(CMILMatrix *)(this_01 + 0x50));

+      }

+      else {

+        (*pcVar8)();

+      }

+      *(uint *)(this_01 + 0x28) = *(uint *)(this_01 + 0x28) & 0xfffffffe;

+    }

+    local_1f8 = *(undefined8 *)(this_01 + 0x50);

+    uStack_1f0 = *(undefined8 *)(this_01 + 0x58);

+    uVar7 = *(undefined4 *)(this_01 + 0x90);

+    local_1e8 = *(undefined8 *)(this_01 + 0x60);

+    uStack_1e0 = *(undefined8 *)(this_01 + 0x68);

+    bStack_1b8 = (byte)uVar7;

+    bStack_1b7 = (byte)((uint)uVar7 >> 8);

+    uStack_1b6 = (undefined2)((uint)uVar7 >> 0x10);

+    local_1d8 = *(undefined8 *)(this_01 + 0x70);

+    uStack_1d0 = *(ulonglong *)(this_01 + 0x78);

+    local_1c8 = *(undefined8 *)(this_01 + 0x80);

+    fStack_1c0 = (float)*(undefined8 *)(this_01 + 0x88);

+    fStack_1bc = (float)((ulonglong)*(undefined8 *)(this_01 + 0x88) >> 0x20);

+    CMILMatrix::Multiply((CMILMatrix *)&local_1f8,param_1);

+    *(undefined8 *)param_1 = local_1f8;

+    *(undefined8 *)(param_1 + 8) = uStack_1f0;

+    *(undefined8 *)(param_1 + 0x10) = local_1e8;

+    *(undefined8 *)(param_1 + 0x18) = uStack_1e0;

+    *(undefined8 *)(param_1 + 0x20) = local_1d8;

+    *(ulonglong *)(param_1 + 0x28) = uStack_1d0;

+    *(undefined8 *)(param_1 + 0x30) = local_1c8;

+    *(ulonglong *)(param_1 + 0x38) = CONCAT44(fStack_1bc,fStack_1c0);

+    *(uint *)(param_1 + 0x40) = CONCAT22(uStack_1b6,CONCAT11(bStack_1b7,bStack_1b8));

+  }

+  return true;

+}

+
```

## `CBackdropVisualImage::RequiresRendering`  (modified)

```diff
--- CBackdropVisualImage::RequiresRendering
+++ CBackdropVisualImage::RequiresRendering
@@ -1,25 +1,105 @@
+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: bool __cdecl CBackdropVisualImage::RequiresRendering(class RenderTargetInfo const &

+   __ptr64)const __ptr64 */

 

 bool __thiscall

-gsl::span<AnimationHelper::AnimatedProperty_const*___ptr64_const,-1>::

-storage_type<gsl::details::extent_type<-1>_>::RequiresRendering

-          (CBackdropVisualImage *this,RenderTargetInfo *param_1)

+CBackdropVisualImage::RequiresRendering(CBackdropVisualImage *this,RenderTargetInfo *param_1)

 

 {

-  char *pcVar1;

-  byte bVar2;

-  byte in_AL;

-  undefined7 in_register_00000001;

-  byte *unaff_RSI;

-  longlong unaff_RDI;

+  CComposition CVar1;

+  longlong *plVar2;

+  code *pcVar3;

+  CCachedTarget *this_00;

+  bool bVar4;

+  CDeviceTextureTarget CVar5;

+  longlong lVar6;

+  CDeviceTextureTarget *this_01;

+  longlong *plVar7;

+  int local_58;

+  int local_54;

+  int local_50;

+  undefined4 local_4c;

+  float local_48;

+  char local_44;

+  undefined2 local_43;

+  undefined1 local_41;

   

-  *(byte *)(CONCAT71(in_register_00000001,in_AL) & 0xffffffffffffffb0) =

-       *(char *)(CONCAT71(in_register_00000001,in_AL) & 0xffffffffffffffb0) + (in_AL & 0xb0);

-  pcVar1 = (char *)((CONCAT71(in_register_00000001,in_AL) & 0xffffffffffffffb0) - 0x75);

-  *pcVar1 = *pcVar1 + (char)this;

-  bVar2 = *unaff_RSI;

-  *(byte *)(CONCAT71(in_register_00000001,bVar2) & 0xffffffffffffffa8) =

-       *(char *)(CONCAT71(in_register_00000001,bVar2) & 0xffffffffffffffa8) + (bVar2 & 0xa8);

-  this[unaff_RDI + 0x28] = (CBackdropVisualImage)((char)this[unaff_RDI + 0x28] + (bVar2 & 0xa8));

-  return (bool)(bVar2 & 0x20);

+  if (((*(longlong *)(this + 0x88) != 0) &&

+      (1.0 <= *(float *)(this + 0x68) - *(float *)(this + 0x60))) &&

+     (1.0 <= *(float *)(this + 0x6c) - *(float *)(this + 100))) {

+    if ((((*(float *)(this + 0x828) <= *(float *)(this + 0x830)) &&

+         (*(float *)(this + 0x82c) <= *(float *)(this + 0x834))) &&

+        ((1.0 <= *(float *)(this + 0x830) - *(float *)(this + 0x828) &&

+         ((1.0 <= *(float *)(this + 0x834) - *(float *)(this + 0x82c) &&

+          (0.5 < *(float *)(this + 0x78))))))) && (0.5 < *(float *)(this + 0x7c))) {

+      plVar2 = *(longlong **)(this + 0xc0);

+      plVar7 = *(longlong **)(this + 0xb8);

+      CVar1 = g_pComposition[0x196a];

+      do {

+        if (plVar7 == plVar2) {

+          return true;

+        }

+        lVar6 = (**(code **)(**(longlong **)(*plVar7 + 8) + 0x90))();

+        pcVar3 = *(code **)(*(longlong *)(lVar6 + 0x10) + 0x78);

+        if (pcVar3 == CDeviceTextureTarget::GetRenderTargetInfo) {

+          CD2DResource::GetAdapterLuid((CD2DResource *)(lVar6 + -0xf0));

+          local_50 = *(int *)(lVar6 + -0xc);

+          local_4c = *(undefined4 *)(lVar6 + 0x28);

+          local_48 = *(float *)(lVar6 + 0x2c);

+          local_44 = CDeviceTextureTarget::IsHardwareProtected

+                               ((CDeviceTextureTarget *)(lVar6 + -0xf0));

+          local_43 = 0;

+          local_41 = 0;

+        }

+        else {

+          (*pcVar3)(lVar6 + 0x10,&local_58);

+        }

+        if ((((local_58 == *(int *)param_1) && (local_54 == *(int *)(param_1 + 4))) &&

+            (((local_50 == -1 ||

+              ((local_50 == *(int *)(param_1 + 8) || (*(int *)(param_1 + 8) == -3)))) &&

+             ((local_48 != 0.0) == (*(float *)(param_1 + 0x10) != 0.0))))) &&

+           ((local_44 == '\0' || (param_1[0x14] != (RenderTargetInfo)0x0)))) {

+          this_01 = (CDeviceTextureTarget *)(**(code **)(**(longlong **)(*plVar7 + 8) + 0x90))();

+          if (CVar1 == (CComposition)0x0) {

+            pcVar3 = *(code **)(*(longlong *)this_01 + 0xb0);

+            if (pcVar3 == CDeviceTextureTarget::IsBlackedOutForReadback) {

+              CVar5 = this_01[0x33];

+            }

+            else {

+              CVar5 = (CDeviceTextureTarget)(*pcVar3)(this_01);

+            }

+          }

+          else {

+            pcVar3 = *(code **)(*(longlong *)this_01 + 0xa0);

+            if (pcVar3 == CDeviceTextureTarget::IsProtected_adjustor_152__) {

+              CVar5 = (CDeviceTextureTarget)

+                      CDeviceTextureTarget::IsProtected_adjustor_152__(this_01);

+            }

+            else {

+              CVar5 = (CDeviceTextureTarget)(*pcVar3)();

+            }

+          }

+          if (CVar5 == (CDeviceTextureTarget)0x0) {

+            this_00 = (CCachedTarget *)*plVar7;

+            if (this_00 == (CCachedTarget *)0x0) {

+              return true;

+            }

+            bVar4 = CCachedVisualImage::CCachedTarget::IsValid(this_00);

+            if (!bVar4) {

+              return true;

+            }

+            if (this_00[0x38] != (CCachedTarget)0x0) {

+              return true;

+            }

+            return false;

+          }

+        }

+        plVar7 = plVar7 + 1;

+      } while( true );

+    }

+  }

+  return false;

 }
```

## `CSceneMaterial::CSceneMaterial`  (modified)

```diff
--- CSceneMaterial::CSceneMaterial
+++ CSceneMaterial::CSceneMaterial
@@ -1,2 +1,34 @@
-Failed to decompile dwmcore.dll - .ProgramDB CSceneMaterial::CSceneMaterial : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: __cdecl CSceneMaterial::CSceneMaterial(class CComposition * __ptr64) __ptr64 */

+

+CSceneMaterial * __thiscall

+CSceneMaterial::CSceneMaterial(CSceneMaterial *this,CComposition *param_1)

+

+{

+  __uint64 _Var1;

+  void *pvVar2;

+  

+  *(undefined4 *)(this + 8) = 0;

+  *(undefined8 *)(this + 0x10) = 0;

+  *(CComposition **)(this + 0x18) = param_1;

+  *(undefined8 *)(this + 0x20) = 0;

+  *(undefined8 *)(this + 0x30) = 0;

+  *(undefined4 *)(this + 0x28) = 0;

+  *(undefined ***)this = &_vftable__for__CSceneMaterialGeneratedT<CSceneMaterial,CSceneObject>__;

+  *(undefined ***)(this + 0x48) = &_vftable__for__ISceneNotificationListener__;

+  *(undefined8 *)(this + 0x50) = 0;

+  *(undefined8 *)(this + 0x58) = 0;

+  _Var1 = std::_Get_size_of_n<48>(1);

+  pvVar2 = std::_Allocate<16,std::_Default_allocate_traits,0>(_Var1);

+  *(void **)pvVar2 = pvVar2;

+  *(void **)((longlong)pvVar2 + 8) = pvVar2;

+  *(void **)((longlong)pvVar2 + 0x10) = pvVar2;

+  *(undefined2 *)((longlong)pvVar2 + 0x18) = 0x101;

+  *(void **)(this + 0x50) = pvVar2;

+  CSceneResourceManager::RegisterSceneListener

+            (*(CSceneResourceManager **)(*(longlong *)(this + 0x18) + 0x2d0),

+             (ISceneNotificationListener *)

+             (-(ulonglong)(this != (CSceneMaterial *)0x0) & (ulonglong)(this + 0x48)));

+  return this;

+}

+
```

## `CColorBrush::ProcessSetGreen`  (modified)

```diff
--- CColorBrush::ProcessSetGreen
+++ CContent::IsDrawListCacheDirty
@@ -1,26 +1,98 @@
 

-/* public: long __cdecl CColorBrush::ProcessSetGreen(class CResourceTable * __ptr64,struct

-   tagMILCMD_COLORBRUSH_SETGREEN const * __ptr64) __ptr64 */

+/* public: virtual bool __cdecl CContent::IsDrawListCacheDirty(class CDrawListCache * __ptr64,class

+   CDrawingContext * __ptr64,struct D2D_SIZE_F const & __ptr64) __ptr64 */

 

-long __thiscall

-CColorBrush::ProcessSetGreen

-          (CColorBrush *this,CResourceTable *param_1,tagMILCMD_COLORBRUSH_SETGREEN *param_2)

+bool __thiscall

+CContent::IsDrawListCacheDirty

+          (CContent *this,CDrawListCache *param_1,CDrawingContext *param_2,D2D_SIZE_F *param_3)

 

 {

   bool bVar1;

-  long lVar2;

+  CVisual *pCVar2;

+  CTreeData *pCVar3;

+  CCpuClippingData *pCVar4;

+  undefined1 uVar5;

+  CDrawingContext *pCVar7;

+  float local_res10 [2];

+  undefined8 local_88;

+  undefined8 uStack_80;

+  CMILMatrix local_78 [16];

+  CShapePtr local_68 [48];

+  undefined4 local_38;

+  CMILMatrix *pCVar6;

   

-  lVar2 = 0;

-  bVar1 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2>::__private_IsEnabled

-                    ((FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2> *)

-                     &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DCompChromiumK2>::GetImpl(void)'

-                      ::__l2::impl);

-  if (bVar1) {

-    lVar2 = CResource::SetPropertyImpl((CResource *)this,&sc_Green,param_2 + 8);

-    if (lVar2 < 0) {

-      MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar2,0x6f,(void *)0x0);

+  if (*(longlong *)(param_1 + 0x18) == 0) {

+    return true;

+  }

+  if (*(uint *)(param_1 + 0x50) != (uint)(*(int *)(param_2 + 0xf4) != 0)) {

+    return true;

+  }

+  if ((*(uint *)(param_1 + 0x48) & 0x238) != 0) {

+    if ((*(uint *)(param_1 + 0x48) & 0x200) != 0) {

+      pCVar7 = param_2;

+      pCVar2 = CDrawingContext::GetCurrentVisual(param_2);

+      pCVar3 = CVisual::FindTreeData(pCVar2,*(CVisualTree **)(pCVar7 + 0x1f08));

+      if (*(ulonglong *)(param_1 + 0x18) < *(ulonglong *)(pCVar3 + 0xe0)) {

+        return true;

+      }

+      if ((((byte)pCVar2[0x6b] & 2) != 0) &&

+         (*(ulonglong *)(param_1 + 0x18) < *(ulonglong *)(g_pComposition + 0x2e8))) {

+        return true;

+      }

+    }

+    local_38 = 0;

+    pCVar6 = local_78;

+    CMatrixStack::Top((CMatrixStack *)(param_2 + 0x120),pCVar6);

+    uVar5 = SUB81(pCVar6,0);

+    if ((((byte)param_1[0x48] & 8) != 0) &&

+       (bVar1 = CMILMatrix::Is2DAxisAlignedPreserving(local_78), !bVar1)) {

+      return true;

+    }

+    if (((byte)param_1[0x48] & 0x10) != 0) {

+      bVar1 = CMILMatrix::Is2DAffineOrNaN(local_78,(bool)uVar5);

+      if (!bVar1) {

+        return true;

+      }

+      local_res10[0] = 0.0;

+      local_res10[1] = 0.0;

+      CMILMatrix::Get2DScaleDimensions(local_78,local_res10,local_res10 + 1);

+      if (8.138021e-05 < ABS(local_res10[0] - *(float *)(param_1 + 0x40))) {

+        return true;

+      }

+      if (8.138021e-05 < ABS(local_res10[1] - *(float *)(param_1 + 0x44))) {

+        return true;

+      }

+    }

+    if ((((byte)param_1[0x48] & 0x20) != 0) &&

+       (bVar1 = CMILMatrix::ProducesUniformZ<1>(local_78), !bVar1)) {

+      return true;

     }

   }

-  return lVar2;

+  if (((byte)param_1[0x4c] & 4) != 0) {

+    pCVar2 = CDrawingContext::GetCurrentVisual(param_2);

+    pCVar4 = CVisual::GetCpuClippingData(pCVar2,*(CVisualTree **)(param_2 + 0x1f08));

+    if (*(ulonglong *)(param_1 + 0x20) < *(ulonglong *)(pCVar4 + 0x18)) {

+      if (param_1[0x54] != (CDrawListCache)0x0) {

+        return true;

+      }

+      CCpuClip::CCpuClip((CCpuClip *)local_78);

+      CDrawingContext::GetCpuClip(param_2,(CCpuClip *)local_78);

+      bVar1 = CCpuClip::HasClip((CCpuClip *)local_78);

+      if (bVar1) {

+        local_88 = *(undefined8 *)(param_1 + 0x30);

+        uStack_80 = *(undefined8 *)(param_1 + 0x38);

+        bVar1 = CCpuClip::FullyContains

+                          ((CCpuClip *)local_78,

+                           (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                            *)&local_88,(D2D_MATRIX_3X2_F *)0x0);

+        if (!bVar1) {

+          CShapePtr::Release(local_68);

+          return true;

+        }

+      }

+      CShapePtr::Release(local_68);

+    }

+  }

+  return false;

 }
```

## `CCompositionSurfaceBitmap::AddOcclusionInformation`  (modified)

```diff
--- CCompositionSurfaceBitmap::AddOcclusionInformation
+++ CCompositionSurfaceBitmap::AddOcclusionInformation
@@ -1,1167 +1,368 @@
 

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

 /* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

    guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Removing unreachable block (ram,0x00018005e44a) */

+/* public: virtual long __cdecl CCompositionSurfaceBitmap::AddOcclusionInformation(class

+   COcclusionContext * __ptr64,struct D2D_SIZE_F const & __ptr64) __ptr64 */

 

 long __thiscall

-ShrinkableArray<CBatchCommand*___ptr64,UniqueLifetime<CBatchCommand*___ptr64>_>::

-AddOcclusionInformation

+CCompositionSurfaceBitmap::AddOcclusionInformation

           (CCompositionSurfaceBitmap *this,COcclusionContext *param_1,D2D_SIZE_F *param_2)

 

 {

-  CWatermarkStack<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,8,2,8>

-  *this_00;

-  float *pfVar1;

-  undefined1 uVar2;

-  uint uVar3;

-  code *pcVar4;

-  CRectanglesShape *this_01;

-  char *pcVar5;

-  longlong lVar6;

-  longlong *plVar7;

-  CMILCOMBaseWeakRefSource<CResourceDeleter> *this_02;

-  CMILRefCountBaseT<ID2D1GeometrySink,CMilObjectDeleter> *this_03;

-  undefined1 auVar8 [16];

-  float fVar9;

-  undefined4 uVar10;

-  undefined4 uVar11;

-  undefined4 uVar12;

-  undefined8 uVar13;

-  undefined8 uVar14;

-  undefined8 uVar15;

-  undefined8 uVar16;

-  bool bVar17;

-  byte bVar18;

-  char cVar19;

-  long lVar20;

-  uint uVar21;

-  int iVar22;

-  int iVar23;

-  int iVar24;

-  byte *in_RAX;

-  TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded> *this_04;

-  ulonglong uVar25;

-  undefined8 *puVar26;

-  longlong lVar27;

-  LPVOID lpTlsValue;

-  HANDLE pvVar28;

-  void *_Dst;

-  CThreadContext *this_05;

-  byte bVar29;

-  CShape *pCVar30;

-  CShape *pCVar31;

-  CMILMatrix *unaff_RBX;

-  ulonglong uVar32;

-  CRoundedRectangleShape *lpMem;

-  undefined8 *unaff_RBP;

-  CShape *unaff_RSI;

-  longlong *unaff_RDI;

-  CCpuClipAntialiasSink *pCVar33;

-  CMILMatrix *pCVar34;

-  D2D_POINT_2F *pDVar35;

-  uint uVar36;

-  CMILMatrix *in_R9;

-  CMILMatrix *in_R10;

-  longlong unaff_R12;

-  char unaff_R13B;

-  int iVar37;

-  CRoundedRectangleShape *unaff_R14;

-  CShape *unaff_R15;

-  float extraout_XMM0_Da;

-  float fVar38;

-  float fVar39;

-  float extraout_XMM0_Db;

-  undefined8 extraout_XMM0_Qb;

-  float fVar40;

-  float fVar41;

-  float fVar42;

-  float fVar43;

-  float fVar44;

-  float fVar45;

-  float unaff_XMM10_Da;

-  uint unaff_XMM14_Da;

-  char cStack0000000000000030;

-  char in_stack_00000031;

-  float in_stack_00000040;

-  float in_stack_00000044;

-  float fStack0000000000000048;

-  float fStack000000000000004c;

-  float in_stack_00000050;

-  float in_stack_00000054;

-  float fStack0000000000000058;

-  float fStack000000000000005c;

-  float fStack0000000000000060;

-  float fStack0000000000000064;

-  float in_stack_00000068;

-  float in_stack_0000006c;

-  float in_stack_00000070;

-  float in_stack_00000074;

-  float in_stack_00000078;

-  float in_stack_0000007c;

+  float fVar1;

+  char cVar2;

+  bool bVar3;

+  char cVar4;

+  int iVar5;

+  long lVar6;

+  CGlobalCompositionSurfaceInfo *pCVar7;

+  ISwapChainRealization *this_00;

+  code *pcVar8;

+  longlong *plVar9;

+  float fVar10;

+  float fVar11;

+  float fVar12;

+  float fVar13;

+  float fVar14;

+  float fVar15;

+  undefined1 auStackY_1e8 [32];

+  uint uVar16;

+  longlong *local_1a8;

+  IBitmapRealization *local_1a0;

+  float local_198;

+  float local_194;

+  float local_190;

+  float local_18c;

+  undefined8 local_188;

+  undefined8 uStack_180;

+  undefined8 local_178;

+  undefined8 uStack_170;

+  undefined8 local_168;

+  undefined8 uStack_160;

+  undefined8 local_158;

+  undefined8 uStack_150;

+  undefined4 local_148;

+  ulonglong local_138 [6];

+  undefined8 local_108;

+  undefined8 uStack_100;

+  undefined4 local_f8;

+  float local_e8 [4];

+  float local_d8 [4];

+  undefined8 local_c8;

+  undefined8 uStack_c0;

+  float local_b8 [4];

+  ulonglong local_a8;

   

-  *in_RAX = *in_RAX | (byte)in_RAX;

-  in_RAX[-0x73] = in_RAX[-0x73] + (char)this;

-  bVar17 = CMILMatrix::IsTranslate<1>((CMILMatrix *)this);

-  fVar45 = in_stack_00000044;

-  fVar44 = in_stack_00000040;

-  fVar39 = SUB84(unaff_RSI,0);

-  if ((((!bVar17) ||

-       (8.138021e-05 <= (float)((uint)(in_stack_00000070 - unaff_XMM10_Da) & unaff_XMM14_Da))) ||

-      (8.138021e-05 <= (float)((uint)(in_stack_00000074 - unaff_XMM10_Da) & unaff_XMM14_Da))) ||

-     (8.138021e-05 <= (float)((uint)(in_stack_00000078 - unaff_XMM10_Da) & unaff_XMM14_Da))) {

-    bVar18 = *(byte *)(unaff_RBP + -0x10) & 0xfd | 1;

-    *(byte *)(unaff_RBP + -0x10) = bVar18;

-    bVar17 = CMILMatrix::IsIdentity<1>(in_R10);

-    fVar38 = in_stack_00000070;

-    fVar40 = in_stack_00000074;

-    fVar42 = in_stack_00000078;

-    if (!bVar17) {

-      bVar17 = CMILMatrix::IsTranslate<1>(in_R10);

-      if (bVar17) {

-        fVar40 = *(float *)(in_R10 + 0x30);

-        fVar38 = *(float *)(in_R10 + 0x34);

-        fVar42 = *(float *)(in_R10 + 0x38);

-        *(float *)(unaff_RBP + -0xd) = fVar38;

-        if (((8.138021e-05 <= (float)((uint)fVar40 & unaff_XMM14_Da)) ||

-            (8.138021e-05 <= (float)((uint)fVar38 & unaff_XMM14_Da))) ||

-           (8.138021e-05 <= (float)((uint)fVar42 & unaff_XMM14_Da))) {

-          bVar29 = *(byte *)((longlong)unaff_RBP + -0x7f);

-          *(float *)(unaff_RBP + 0xc) = in_stack_0000006c;

-          *(float *)((longlong)unaff_RBP + 100) = in_stack_0000006c;

-          *(float *)(unaff_RBP + 0xd) = in_stack_0000006c;

-          *(float *)((longlong)unaff_RBP + 0x6c) = in_stack_0000006c;

-          cVar19 = (char)(bVar29 << 2) >> 6;

-          if (cVar19 < '\x01') {

-            if (-1 < cVar19) {

-              if ((float)((uint)(((float)((uint)fStack000000000000005c & unaff_XMM14_Da) * 61440.0 +

-                                  (float)((uint)fStack000000000000004c & unaff_XMM14_Da) * 61440.0 +

-                                 (float)((uint)in_stack_0000007c & unaff_XMM14_Da)) - 1.0) &

-                         unaff_XMM14_Da) < 8.138021e-05) {

-                bVar29 = bVar29 | 0x30;

-                *(byte *)((longlong)unaff_RBP + -0x7f) = bVar29;

-                if ((float)((uint)((float)((uint)in_stack_0000006c & unaff_XMM14_Da) * 61440.0 - 0.0

-                                  ) & unaff_XMM14_Da) < 8.138021e-05) {

-                  fVar38 = *(float *)(unaff_RBP + -0xd);

-                  goto LAB_0;

+  local_a8 = __security_cookie ^ (ulonglong)auStackY_1e8;

+  local_d8[0] = 0.0;

+  local_d8[1] = 0.0;

+  local_d8[2] = 0.0;

+  local_d8[3] = 0.0;

+  if (*(code **)(*(longlong *)this + 0xb8) == GetBounds) {

+    iVar5 = GetBounds(this,param_2,

+                      (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                       *)local_d8);

+  }

+  else {

+    iVar5 = (**(code **)(*(longlong *)this + 0xb8))();

+  }

+  if (iVar5 < 0) {

+    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,iVar5,0x98,(void *)0x0);

+    return iVar5;

+  }

+  if (local_d8[2] <= local_d8[0]) {

+    return iVar5;

+  }

+  if (local_d8[3] <= local_d8[1]) {

+    return iVar5;

+  }

+  if (*(code **)(*(longlong *)(this + 0x48) + 0x20) == IsOpaque) {

+    cVar2 = IsOpaque(this + 0x48);

+  }

+  else {

+    cVar2 = (**(code **)(*(longlong *)(this + 0x48) + 0x20))();

+  }

+  if (cVar2 == '\0') {

+    return iVar5;

+  }

+  pCVar7 = *(CGlobalCompositionSurfaceInfo **)(this + 0x60);

+  if (pCVar7 == (CGlobalCompositionSurfaceInfo *)0x0) {

+LAB_0:

+    COcclusionContext::AddOcclusionRect

+              (param_1,(TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                        *)local_d8,false);

+    return iVar5;

+  }

+  if (*(code **)(*(longlong *)pCVar7 + 0x128) == CGlobalCompositionSurfaceInfo::IsSwapChain) {

+    cVar2 = CGlobalCompositionSurfaceInfo::IsSwapChain(pCVar7);

+  }

+  else {

+    cVar2 = (**(code **)(*(longlong *)pCVar7 + 0x128))();

+  }

+  if (cVar2 == '\0') goto LAB_0;

+  COcclusionContext::AddOcclusionRect

+            (param_1,(TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                      *)local_d8,true);

+  bVar3 = COcclusionContext::IsOverlayCandidateCollectionEnabled(param_1);

+  if (!bVar3) {

+    return iVar5;

+  }

+  local_1a8 = (longlong *)0x0;

+  local_148 = 0;

+  local_1a0 = (IBitmapRealization *)0x0;

+  local_c8 = 0;

+  uStack_c0 = 0;

+  if (*(code **)(*(longlong *)(this + 0x48) + 0x40) == GetCurrentRenderingRealization) {

+    lVar6 = GetCurrentRenderingRealization(this + 0x48,&local_1a0);

+  }

+  else {

+    lVar6 = (**(code **)(*(longlong *)(this + 0x48) + 0x40))();

+  }

+  if (lVar6 < 0) {

+    uVar16 = 0xa9;

+  }

+  else {

+    if (local_1a8 != (longlong *)0x0) {

+      (**(code **)(*local_1a8 + 0x10))();

+    }

+    if ((code *)**(undefined8 **)local_1a0 ==

+        CMILCOMBaseT<IUnknown,IUnknown,CMilObjectDeleter>::InternalQueryInterface) {

+      lVar6 = CMILCOMBaseT<IUnknown,IUnknown,CMilObjectDeleter>::InternalQueryInterface

+                        ((CMILCOMBaseT<IUnknown,IUnknown,CMilObjectDeleter> *)local_1a0,

+                         (_GUID *)&_GUID_178d0f24_35be_4a99_bb8d_0ce831b03f8c,&local_1a8);

+    }

+    else {

+      lVar6 = (*(code *)**(undefined8 **)local_1a0)();

+    }

+    if (-1 < lVar6) {

+      pCVar7 = *(CGlobalCompositionSurfaceInfo **)(this + 0x60);

+      if (pCVar7 == (CGlobalCompositionSurfaceInfo *)0x0) {

+LAB_1:

+        local_188 = 0x3f800000;

+        uStack_180 = 0;

+        local_178 = 0x3f80000000000000;

+        uStack_170 = 0;

+        local_168 = 0;

+        uStack_160 = 0x3f800000;

+        local_158 = 0;

+        uStack_150 = 0x3f80000000000000;

+        local_148 = CONCAT31((uint3)(local_148 >> 8) & 0xffffe9,0xaa) | 0x2900;

+      }

+      else {

+        if (*(code **)(*(longlong *)pCVar7 + 0x30) ==

+            CGlobalCompositionSurfaceInfo::GetRenderingRealization) {

+          if (*(longlong *)(pCVar7 + 0xd0) == 0) {

+            CGlobalCompositionSurfaceInfo::ForceUpdateRenderingRealization(pCVar7);

+          }

+          plVar9 = (longlong *)(*(longlong *)(pCVar7 + 0xd0) + 8);

+          if (*(longlong *)(pCVar7 + 0xd0) == 0) {

+            plVar9 = (longlong *)0x0;

+          }

+        }

+        else {

+          plVar9 = (longlong *)(**(code **)(*(longlong *)pCVar7 + 0x30))(pCVar7);

+        }

+        if (plVar9 == (longlong *)0x0) goto LAB_1;

+        pCVar7 = *(CGlobalCompositionSurfaceInfo **)(this + 0x60);

+        if (pCVar7 == (CGlobalCompositionSurfaceInfo *)0x0) {

+LAB_2:

+          iVar5 = 1;

+        }

+        else {

+          pcVar8 = *(code **)(*(longlong *)pCVar7 + 0x1c8);

+          if (pcVar8 == CGlobalCompositionSurfaceInfo::GetSizePreference) {

+            pCVar7 = (CGlobalCompositionSurfaceInfo *)

+                     CGlobalCompositionSurfaceInfo::GetSwapChainRealization(pCVar7);

+            if (pCVar7 == (CGlobalCompositionSurfaceInfo *)0x0) goto LAB_2;

+            pcVar8 = *(code **)(*(longlong *)pCVar7 + 0x68);

+          }

+          iVar5 = (*pcVar8)(pCVar7);

+        }

+        cVar2 = (**(code **)(*plVar9 + 0x28))(plVar9,&local_188,&local_c8);

+        pCVar7 = *(CGlobalCompositionSurfaceInfo **)(this + 0x60);

+        fVar15 = 0.0;

+        local_e8[0] = 0.0;

+        local_e8[1] = 0.0;

+        local_e8[2] = 0.0;

+        local_e8[3] = 0.0;

+        if (pCVar7 == (CGlobalCompositionSurfaceInfo *)0x0) {

+LAB_3:

+          cVar4 = '\0';

+        }

+        else {

+          pcVar8 = *(code **)(*(longlong *)pCVar7 + 0x1e0);

+          if (pcVar8 == CGlobalCompositionSurfaceInfo::GetScaledLetterboxingMargins) {

+            this_00 = CGlobalCompositionSurfaceInfo::GetSwapChainRealization(pCVar7);

+            if (this_00 == (ISwapChainRealization *)0x0) goto LAB_3;

+            pcVar8 = *(code **)(*(longlong *)this_00 + 0x100);

+            if (pcVar8 == CDxHandleBitmapRealization::GetScaledLetterboxingMargins) {

+              cVar4 = CBitmapRealization::GetScaledLetterboxingMargins

+                                ((CBitmapRealization *)(this_00 + -0x148),

+                                 (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                                  *)local_e8);

+            }

+            else {

+              if (pcVar8 != CDxHandleYUVBitmapRealization::GetScaledLetterboxingMargins)

+              goto LAB_4;

+              cVar4 = CDxHandleYUVBitmapRealization::GetScaledLetterboxingMargins

+                                ((CDxHandleYUVBitmapRealization *)this_00,

+                                 (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                                  *)local_e8);

+            }

+          }

+          else if (pcVar8 == CDxHandleBitmapRealization::GetScaledLetterboxingMargins) {

+            cVar4 = CDxHandleBitmapRealization::GetScaledLetterboxingMargins

+                              ((CDxHandleBitmapRealization *)pCVar7,

+                               (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                                *)local_e8);

+          }

+          else if (pcVar8 == CDxHandleYUVBitmapRealization::GetScaledLetterboxingMargins) {

+            cVar4 = CDxHandleYUVBitmapRealization::GetScaledLetterboxingMargins

+                              ((CDxHandleYUVBitmapRealization *)pCVar7,

+                               (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                                *)local_e8);

+          }

+          else {

+LAB_4:

+            cVar4 = (*pcVar8)();

+          }

+          if (cVar4 != '\0') {

+            if ((8.138021e-05 <= ABS(local_e8[0])) || (8.138021e-05 <= ABS(local_e8[1]))) {

+              local_158 = CONCAT44(local_158._4_4_ +

+                                   local_188._4_4_ * local_e8[0] + local_178._4_4_ * local_e8[1] +

+                                   local_168._4_4_ * 0.0,

+                                   (float)local_158 +

+                                   (float)local_188 * local_e8[0] + (float)local_178 * local_e8[1] +

+                                   (float)local_168 * 0.0);

+              cVar2 = (char)(local_148._1_1_ << 2) >> 6;

+              if (cVar2 < '\x01') {

+                if (-1 < cVar2) {

+                  if (8.138021e-05 <=

+                      ABS((ABS(uStack_170._4_4_) * 61440.0 + ABS(uStack_180._4_4_) * 61440.0 +

+                          ABS(uStack_150._4_4_)) - 1.0)) goto LAB_5;

+                  local_148 = local_148 | 0x3000;

                 }

+                if (8.138021e-05 <= ABS(ABS(uStack_160._4_4_) * 61440.0 - 0.0)) goto LAB_5;

+                local_148 = local_148 & 0xfffffffc;

               }

               else {

-                bVar29 = bVar29 & 0xdf | 0x10;

+LAB_5:

+                local_148 = 0;

+                uStack_150._4_4_ =

+                     uStack_150._4_4_ +

+                     uStack_180._4_4_ * local_e8[0] + uStack_170._4_4_ * local_e8[1] +

+                     uStack_160._4_4_ * 0.0;

               }

-              goto LAB_1;

+              uStack_150 = CONCAT44(uStack_150._4_4_,

+                                    (float)uStack_150 +

+                                    (float)uStack_180 * local_e8[0] +

+                                    (float)uStack_170 * local_e8[1] + (float)uStack_160 * 0.0);

             }

-            if (8.138021e-05 <=

-                (float)((uint)((float)((uint)in_stack_0000006c & unaff_XMM14_Da) * 61440.0 - 0.0) &

-                       unaff_XMM14_Da)) goto LAB_1;

-          }

-          else {

-LAB_1:

-            fVar44 = *(float *)(in_R10 + 0x34);

-            *(byte *)((longlong)unaff_RBP + -0x7f) = bVar29 & 0xf3;

-            fStack0000000000000048 =

-                 fStack0000000000000048 + fStack000000000000004c * *(float *)(in_R10 + 0x38);

-            fVar45 = in_stack_00000044 + fStack000000000000004c * fVar44;

-            fVar44 = in_stack_00000040 + fStack000000000000004c * fVar40;

-            in_stack_00000054 =

-                 in_stack_00000054 + fStack000000000000005c * *(float *)(in_R10 + 0x34);

-            fStack0000000000000058 =

-                 fStack0000000000000058 + fStack000000000000005c * *(float *)(in_R10 + 0x38);

-            fVar43 = *(float *)(in_R10 + 0x34);

-            in_stack_00000050 =

-                 in_stack_00000050 + fStack000000000000005c * *(float *)(in_R10 + 0x30);

-            fVar38 = in_stack_0000007c * *(float *)(in_R10 + 0x34);

-            fVar9 = *(float *)(unaff_RBP + 0xc);

-            fVar41 = *(float *)(in_R10 + 0x38);

-            fVar42 = in_stack_0000007c * *(float *)(in_R10 + 0x38);

-            fVar40 = in_stack_0000007c * *(float *)(in_R10 + 0x30);

-            *(float *)(unaff_RBP + 0xc) =

-                 fStack0000000000000060 + in_stack_0000006c * *(float *)(in_R10 + 0x30);

-            *(float *)((longlong)unaff_RBP + 100) =

-                 fStack0000000000000064 + in_stack_0000006c * fVar43;

-            *(float *)(unaff_RBP + 0xd) = in_stack_00000068 + fVar9 * fVar41;

-            *(float *)((longlong)unaff_RBP + 0x6c) = in_stack_0000006c;

-            fStack0000000000000060 = *(float *)(unaff_RBP + 0xc);

-            fStack0000000000000064 = *(float *)((longlong)unaff_RBP + 100);

-            in_stack_00000068 = *(float *)(unaff_RBP + 0xd);

-            in_stack_0000006c = *(float *)((longlong)unaff_RBP + 0x6c);

-          }

-LAB_0:

-          in_stack_00000070 = in_stack_00000070 + fVar40;

-          in_stack_00000078 = in_stack_00000078 + fVar42;

-          in_stack_00000074 = in_stack_00000074 + fVar38;

-          *(byte *)(unaff_RBP + -0x10) = bVar18 & 0xfc;

-        }

-LAB_2:

-        unaff_XMM10_Da = 0.0;

-        fVar38 = in_stack_00000070;

-        fVar40 = in_stack_00000074;

-        fVar42 = in_stack_00000078;

-      }

-      else {

-        bVar17 = CMILMatrix::IsTranslate<1>((CMILMatrix *)&stack0x00000040);

-        if (bVar17) {

-          fVar38 = *(float *)(in_R10 + 0x30);

-          fVar40 = *(float *)(in_R10 + 0x34);

-          fVar42 = *(float *)(in_R10 + 0x38);

-          in_stack_0000007c = *(float *)(in_R10 + 0x3c);

-          *(undefined4 *)(unaff_RBP + -0x10) = *(undefined4 *)(in_R10 + 0x40);

-          fVar44 = *(float *)in_R10;

-          fVar45 = *(float *)(in_R10 + 4);

-          fStack0000000000000048 = *(float *)(in_R10 + 8);

-          fStack000000000000004c = *(float *)(in_R10 + 0xc);

-          in_stack_00000050 = *(float *)(in_R10 + 0x10);

-          in_stack_00000054 = *(float *)(in_R10 + 0x14);

-          fStack0000000000000058 = *(float *)(in_R10 + 0x18);

-          fStack000000000000005c = *(float *)(in_R10 + 0x1c);

-          fStack0000000000000060 = *(float *)(in_R10 + 0x20);

-          fStack0000000000000064 = *(float *)(in_R10 + 0x24);

-          in_stack_00000068 = *(float *)(in_R10 + 0x28);

-          in_stack_0000006c = *(float *)(in_R10 + 0x2c);

-          if (((8.138021e-05 <= (float)((uint)in_stack_00000070 & unaff_XMM14_Da)) ||

-              (8.138021e-05 <= (float)((uint)in_stack_00000074 & unaff_XMM14_Da))) ||

-             (8.138021e-05 <= (float)((uint)in_stack_00000078 & unaff_XMM14_Da))) {

-            fVar38 = fVar38 + in_stack_00000050 * in_stack_00000074 + fVar44 * in_stack_00000070 +

-                              fStack0000000000000060 * in_stack_00000078;

-            fVar40 = fVar40 + in_stack_00000054 * in_stack_00000074 + fVar45 * in_stack_00000070 +

-                              fStack0000000000000064 * in_stack_00000078;

-            fVar42 = fVar42 + fStack0000000000000058 * in_stack_00000074 +

-                              fStack0000000000000048 * in_stack_00000070 +

-                              in_stack_00000068 * in_stack_00000078;

-            cVar19 = (char)(*(byte *)((longlong)unaff_RBP + -0x7f) << 2) >> 6;

-            if (cVar19 < '\x01') {

-              if (-1 < cVar19) {

-                if (8.138021e-05 <=

-                    (float)((uint)(((float)((uint)fStack000000000000005c & unaff_XMM14_Da) * 61440.0

-                                    + (float)((uint)fStack000000000000004c & unaff_XMM14_Da) *

-                                      61440.0 + (float)((uint)in_stack_0000007c & unaff_XMM14_Da)) -

-                                  1.0) & unaff_XMM14_Da)) goto LAB_3;

-                *(byte *)((longlong)unaff_RBP + -0x7f) =

-                     *(byte *)((longlong)unaff_RBP + -0x7f) | 0x30;

-              }

-              if ((float)((uint)((float)((uint)in_stack_0000006c & unaff_XMM14_Da) * 61440.0 -

-                                unaff_XMM10_Da) & unaff_XMM14_Da) < 8.138021e-05) {

-                *(byte *)(unaff_RBP + -0x10) = *(byte *)(unaff_RBP + -0x10) & 0xfc;

-                goto LAB_4;

-              }

-            }

-LAB_3:

-            *(int *)(unaff_RBP + -0x10) = (int)unaff_R12;

-            in_stack_0000007c =

-                 in_stack_0000007c +

-                 fStack000000000000005c * in_stack_00000074 +

-                 fStack000000000000004c * in_stack_00000070 + in_stack_0000006c * in_stack_00000078;

-          }

-        }

-        else {

-          bVar17 = CMILMatrix::IsTranslateAndScale<1>(in_R10);

-          if (bVar17) {

-            fVar44 = *(float *)in_R10;

-            fVar45 = *(float *)(in_R10 + 0x30);

-            fVar38 = *(float *)(in_R10 + 0x34);

-            fVar40 = *(float *)(in_R10 + 0x28);

-            fVar42 = *(float *)(in_R10 + 0x14);

-            if (((8.138021e-05 <= (float)((uint)(fVar44 - 1.0) & unaff_XMM14_Da)) ||

-                (8.138021e-05 <= (float)((uint)(fVar42 - 1.0) & unaff_XMM14_Da))) ||

-               (8.138021e-05 <= (float)((uint)(fVar40 - 1.0) & unaff_XMM14_Da))) {

-              in_stack_00000044 = in_stack_00000044 * fVar42;

-              in_stack_00000054 = in_stack_00000054 * fVar42;

-              fVar43 = fStack0000000000000064 * fVar42;

-              in_stack_00000074 = in_stack_00000074 * fVar42;

-              in_stack_00000040 = in_stack_00000040 * fVar44;

-              in_stack_00000050 = in_stack_00000050 * fVar44;

-              fVar42 = fStack0000000000000060 * fVar44;

-              in_stack_00000070 = in_stack_00000070 * fVar44;

-              _fStack0000000000000060 = CONCAT44(fVar43,fVar42);

-              if (8.138021e-05 <= (float)((uint)(fVar40 - 1.0) & unaff_XMM14_Da)) {

-                _fStack0000000000000048 =

-                     CONCAT44(fStack000000000000004c,fStack0000000000000048 * fVar40);

-                in_stack_00000068 = in_stack_00000068 * fVar40;

-                in_stack_00000078 = in_stack_00000078 * fVar40;

-                _fStack0000000000000058 =

-                     CONCAT44(fStack000000000000005c,fStack0000000000000058 * fVar40);

-              }

-              bVar18 = *(byte *)(unaff_RBP + -0x10) & 0xcc;

-              *(byte *)(unaff_RBP + -0x10) = bVar18;

-            }

-            else {

-              bVar18 = *(byte *)(unaff_RBP + -0x10);

-              fVar43 = fStack0000000000000064;

-              fVar42 = fStack0000000000000060;

-            }

-            if (((8.138021e-05 <= (float)((uint)fVar45 & unaff_XMM14_Da)) ||

-                (8.138021e-05 <= (float)((uint)fVar38 & unaff_XMM14_Da))) ||

-               (8.138021e-05 <= (float)((uint)*(float *)(in_R10 + 0x38) & unaff_XMM14_Da))) {

-              bVar29 = *(byte *)((longlong)unaff_RBP + -0x7f);

-              cVar19 = (char)(bVar29 << 2) >> 6;

-              if (cVar19 < '\x01') {

-                if (-1 < cVar19) {

-                  if ((float)((uint)(((float)((uint)fStack000000000000005c & unaff_XMM14_Da) *

-                                      61440.0 + (float)((uint)fStack000000000000004c &

-                                                       unaff_XMM14_Da) * 61440.0 +

-                                     (float)((uint)in_stack_0000007c & unaff_XMM14_Da)) - 1.0) &

-                             unaff_XMM14_Da) < 8.138021e-05) {

-                    bVar29 = bVar29 | 0x30;

-                    *(byte *)((longlong)unaff_RBP + -0x7f) = bVar29;

-                    if ((float)((uint)((float)((uint)in_stack_0000006c & unaff_XMM14_Da) * 61440.0 -

-                                      0.0) & unaff_XMM14_Da) < 8.138021e-05) goto LAB_5;

-                  }

-                  else {

-                    bVar29 = bVar29 & 0xdf | 0x10;

-                  }

-                  goto LAB_6;

-                }

-                if (8.138021e-05 <=

-                    (float)((uint)((float)((uint)in_stack_0000006c & unaff_XMM14_Da) * 61440.0 - 0.0

-                                  ) & unaff_XMM14_Da)) goto LAB_6;

-LAB_5:

-                fVar44 = *(float *)(in_R10 + 0x38);

+            cVar2 = '\x01';

+          }

+        }

+        bVar3 = UseLayoutSizeForBounds(this,param_2);

+        if ((bVar3) && (iVar5 != 1)) {

+          local_b8[0] = 0.0;

+          local_b8[1] = 0.0;

+          local_b8[2] = 0.0;

+          local_b8[3] = 0.0;

+          local_194 = local_c8._4_4_;

+          local_198 = (float)local_c8;

+          local_190 = (float)uStack_c0;

+          local_18c = uStack_c0._4_4_;

+          if (cVar4 != '\0') {

+            local_198 = (float)local_c8 - local_e8[0];

+            local_194 = local_c8._4_4_ - local_e8[1];

+            local_190 = (float)uStack_c0 + local_e8[2];

+            local_18c = uStack_c0._4_4_ + local_e8[3];

+          }

+          fVar10 = local_194;

+          fVar11 = local_198;

+          fVar12 = local_190;

+          fVar13 = local_18c;

+          if (cVar2 != '\0') {

+            CMILMatrix::Transform2DBoundsHelper<0>

+                      ((CMILMatrix *)&local_188,(D2D_RECT_F *)&local_198,(D2D_RECT_F *)local_b8);

+            fVar10 = local_b8[1];

+            fVar11 = local_b8[0];

+            fVar12 = local_b8[2];

+            fVar13 = local_b8[3];

+          }

+          if ((fVar11 < fVar12) && (fVar10 < fVar13)) {

+            fVar1 = *(float *)param_2;

+            fVar13 = fVar13 - fVar10;

+            fVar12 = fVar12 - fVar11;

+            if ((0.00390625 < ABS(fVar1 - fVar12)) ||

+               (0.00390625 < ABS(*(float *)(param_2 + 4) - fVar13))) {

+              local_138[2] = 0x3f80000000000000;

+              local_138[3] = 0;

+              local_138[0] = 0x3f800000;

+              local_138[1] = 0;

+              local_108 = 0;

+              uStack_100 = 0x3f80000000000000;

+              local_138[4] = 0;

+              local_138[5] = 0x3f800000;

+              fVar10 = *(float *)(param_2 + 4);

+              local_f8 = 0x29aa;

+              fVar11 = fVar1 / fVar12;

+              if (iVar5 == 0) {

+                CMILMatrix::SetScale((CMILMatrix *)local_138,fVar11,fVar10 / fVar13,1.0,0.0,0.0,0.0)

+                ;

               }

               else {

+                fVar14 = 0.0;

+                if (fVar10 < fVar11 * fVar13) {

+                  fVar11 = fVar10 / fVar13;

+                  fVar15 = (fVar1 - fVar11 * fVar12) * 0.5;

+                }

+                else {

+                  fVar14 = (fVar10 - fVar11 * fVar13) * 0.5;

+                }

+                local_f8 = 0x2988;

+                local_138[0] = (ulonglong)(uint)fVar11;

+                local_138[2] = (ulonglong)(uint)fVar11 << 0x20;

+                local_108 = CONCAT44(fVar14,fVar15);

+              }

+              CMILMatrix::Multiply((CMILMatrix *)&local_188,(CMILMatrix *)local_138);

+            }

+          }

+        }

+      }

+      lVar6 = COcclusionContext::CheckAndRecordOverlayCandidate

+                        (param_1,*(undefined8 *)(param_1 + 0x5e0),*(undefined8 *)(this + 0x60),

+                         &local_188);

+      if (lVar6 < 0) {

+        MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar6,0xb1,(void *)0x0);

+        wil::

+        com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+        ::

+        ~com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+                  ((com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+                    *)&local_1a8);

+        wil::

+        com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+        ::

+        ~com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+                  ((com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+                    *)&local_1a0);

+        return lVar6;

+      }

+      goto LAB_6;

+    }

+    uVar16 = 0xab;

+  }

+  MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar6,uVar16,(void *)0x0);

 LAB_6:

-                fVar44 = *(float *)(in_R10 + 0x38);

-                *(byte *)((longlong)unaff_RBP + -0x7f) = bVar29 & 0xf3;

-                in_stack_00000040 = in_stack_00000040 + fStack000000000000004c * fVar45;

-                in_stack_00000044 = in_stack_00000044 + fStack000000000000004c * fVar38;

-                _fStack0000000000000048 =

-                     CONCAT44(fStack000000000000004c,

-                              fStack0000000000000048 + fStack000000000000004c * fVar44);

-                in_stack_00000050 = in_stack_00000050 + fStack000000000000005c * fVar45;

-                in_stack_00000054 = in_stack_00000054 + fStack000000000000005c * fVar38;

-                fVar40 = in_stack_0000006c * fVar38;

-                _fStack0000000000000058 =

-                     CONCAT44(fStack000000000000005c,

-                              fStack0000000000000058 + fStack000000000000005c * fVar44);

-                in_stack_00000068 = in_stack_00000068 + in_stack_0000006c * fVar44;

-                fVar38 = in_stack_0000007c * fVar38;

-                _fStack0000000000000060 =

-                     CONCAT44(fVar43 + fVar40,fVar42 + in_stack_0000006c * fVar45);

-                fVar45 = in_stack_0000007c * fVar45;

-                fVar44 = in_stack_0000007c * fVar44;

-              }

-              in_stack_00000070 = in_stack_00000070 + fVar45;

-              in_stack_00000074 = in_stack_00000074 + fVar38;

-              in_stack_00000078 = in_stack_00000078 + fVar44;

-              *(byte *)(unaff_RBP + -0x10) = bVar18 & 0xfc;

-            }

-            fVar44 = in_stack_00000040;

-            fVar45 = in_stack_00000044;

-            goto LAB_2;

-          }

-          bVar17 = CMILMatrix::IsPure2DUniformZ<1>((CMILMatrix *)&stack0x00000040);

-          if ((bVar17) && (bVar17 = CMILMatrix::IsPure2DUniformZ<1>(in_R10), bVar17)) {

-            fVar44 = *(float *)in_R10;

-            fVar45 = *(float *)(in_R10 + 0x10);

-            fVar38 = *(float *)(in_R10 + 4);

-            fVar40 = *(float *)(in_R10 + 0x14);

-            fStack000000000000005c = (float)((ulonglong)unaff_RSI >> 0x20);

-            fVar42 = in_stack_00000050 * fVar38;

-            in_stack_00000050 = in_stack_00000054 * fVar45 + in_stack_00000050 * fVar44;

-            *(undefined1 *)(unaff_RBP + -0x10) = 8;

-            *(byte *)((longlong)unaff_RBP + -0x7f) =

-                 *(byte *)((longlong)unaff_RBP + -0x7f) & 0xeb | 0x28;

-            in_stack_00000078 =

-                 in_stack_00000078 * *(float *)(in_R10 + 0x28) + *(float *)(in_R10 + 0x38);

-            in_stack_00000054 = in_stack_00000054 * fVar40 + fVar42;

-            fVar42 = in_stack_00000074 * fVar45;

-            in_stack_0000007c = 1.0;

-            in_stack_00000068 = in_stack_00000068 * *(float *)(in_R10 + 0x28);

-            in_stack_00000074 =

-                 in_stack_00000074 * fVar40 + in_stack_00000070 * fVar38 + *(float *)(in_R10 + 0x34)

-            ;

-            in_stack_00000070 = fVar42 + in_stack_00000070 * fVar44 + *(float *)(in_R10 + 0x30);

-            fStack0000000000000058 = fVar39;

-            fStack0000000000000060 = fVar39;

-            fStack0000000000000064 = fStack000000000000005c;

-            in_stack_0000006c = fVar39;

-            fVar44 = in_stack_00000044 * fVar45 + in_stack_00000040 * fVar44;

-            fVar45 = in_stack_00000044 * fVar40 + in_stack_00000040 * fVar38;

-            fStack0000000000000048 = fVar39;

-            fStack000000000000004c = fStack000000000000005c;

-            goto LAB_2;

-          }

-          uVar13 = *(undefined8 *)(in_R10 + 8);

-          uVar14 = *(undefined8 *)(in_R10 + 0x10);

-          uVar15 = *(undefined8 *)(in_R10 + 0x18);

-          unaff_RBP[2] = *(undefined8 *)in_R10;

-          unaff_RBP[3] = uVar13;

-          uVar13 = *(undefined8 *)(in_R10 + 0x20);

-          uVar16 = *(undefined8 *)(in_R10 + 0x28);

-          unaff_RBP[4] = uVar14;

-          unaff_RBP[5] = uVar15;

-          uVar14 = *(undefined8 *)(in_R10 + 0x30);

-          uVar15 = *(undefined8 *)(in_R10 + 0x38);

-          unaff_RBP[6] = uVar13;

-          unaff_RBP[7] = uVar16;

-          unaff_RBP[8] = uVar14;

-          unaff_RBP[9] = uVar15;

-          DirectX::XMMatrixMultiply();

-          *(int *)(unaff_RBP + -0x10) = (int)unaff_R12;

-          fStack0000000000000048 = (float)extraout_XMM0_Qb;

-          fStack000000000000004c = (float)((ulonglong)extraout_XMM0_Qb >> 0x20);

-          fVar38 = in_stack_00000070;

-          fVar40 = in_stack_00000074;

-          fVar42 = in_stack_00000078;

-          fVar44 = extraout_XMM0_Da;

-          fVar45 = extraout_XMM0_Db;

-        }

-      }

-    }

-  }

-  else {

-    fVar44 = *(float *)in_R10;

-    fVar45 = *(float *)(in_R10 + 4);

-    fStack0000000000000048 = *(float *)(in_R10 + 8);

-    fStack000000000000004c = *(float *)(in_R10 + 0xc);

-    *(undefined4 *)(unaff_RBP + -0x10) = *(undefined4 *)(in_R10 + 0x40);

-    in_stack_00000050 = *(float *)(in_R10 + 0x10);

-    in_stack_00000054 = *(float *)(in_R10 + 0x14);

-    fStack0000000000000058 = *(float *)(in_R10 + 0x18);

-    fStack000000000000005c = *(float *)(in_R10 + 0x1c);

-    fStack0000000000000060 = *(float *)(in_R10 + 0x20);

-    fStack0000000000000064 = *(float *)(in_R10 + 0x24);

-    in_stack_00000068 = *(float *)(in_R10 + 0x28);

-    in_stack_0000006c = *(float *)(in_R10 + 0x2c);

-    fVar38 = *(float *)(in_R10 + 0x30);

-    fVar40 = *(float *)(in_R10 + 0x34);

-    fVar42 = *(float *)(in_R10 + 0x38);

-    in_stack_0000007c = *(float *)(in_R10 + 0x3c);

-  }

-LAB_4:

-  *(float *)(unaff_RBP + -8) = in_stack_00000050;

-  *(float *)((longlong)unaff_RBP + -0x3c) = in_stack_00000054;

-  *(float *)(unaff_RBP + -7) = fStack0000000000000058;

-  *(float *)((longlong)unaff_RBP + -0x34) = fStack000000000000005c;

-  *(undefined4 *)(unaff_RBP + -2) = *(undefined4 *)(unaff_RBP + -0x10);

-  *(float *)(unaff_RBP + -10) = fVar44;

-  *(float *)((longlong)unaff_RBP + -0x4c) = fVar45;

-  *(float *)(unaff_RBP + -9) = fStack0000000000000048;

-  *(float *)((longlong)unaff_RBP + -0x44) = fStack000000000000004c;

-  *(float *)(unaff_RBP + -6) = fStack0000000000000060;

-  *(float *)((longlong)unaff_RBP + -0x2c) = fStack0000000000000064;

-  *(float *)(unaff_RBP + -5) = in_stack_00000068;

-  *(float *)((longlong)unaff_RBP + -0x24) = in_stack_0000006c;

-  *(float *)(unaff_RBP + -4) = fVar38;

-  *(float *)((longlong)unaff_RBP + -0x1c) = fVar40;

-  *(float *)(unaff_RBP + -3) = fVar42;

-  *(float *)((longlong)unaff_RBP + -0x14) = in_stack_0000007c;

-  if ((unaff_RDI[1] != *unaff_RDI) && (unaff_RSI < *(CShape **)(unaff_RDI[1] + -0xb0))) {

-    unaff_R12 = *(longlong *)(unaff_RDI[0xf4] + -0x18);

-  }

-  cStack0000000000000030 = (char)unaff_RSI;

-  pcVar4 = *(code **)(*(longlong *)unaff_R14 + 0x10);

-  if (pcVar4 == CRoundedRectangleShape::IsEmpty) {

-    this_04 = (TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded> *)

-              CRoundedRectangleGeometryData::GetBaseRect

-                        ((CRoundedRectangleGeometryData *)(*(longlong *)(unaff_R14 + 0x10) + 0x10));

-    cVar19 = TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded>::IsEmpty(this_04);

-  }

-  else if (pcVar4 == CRectanglesShape::IsEmpty) {

-    cVar19 = CRectanglesShape::IsEmpty((CRectanglesShape *)unaff_R14);

-  }

-  else if (pcVar4 == CShape::IsEmpty) {

-    cVar19 = CShape::IsEmpty((CShape *)unaff_R14);

-  }

-  else {

-    cVar19 = (*pcVar4)();

-  }

-  if (cVar19 == '\0') {

-    lVar27 = *(longlong *)unaff_R14;

-    *(float *)(unaff_RBP + -0xd) = fVar39;

-    pcVar4 = *(code **)(lVar27 + 0x40);

-    if (pcVar4 == CRoundedRectangleShape::IsRectangles) {

-      bVar17 = CRoundedRectangleGeometryData::HasAnyRoundedCorners

-                         ((CRoundedRectangleGeometryData *)(*(longlong *)(unaff_R14 + 0x10) + 0x10))

-      ;

-      if (!bVar17) {

-LAB_7:

-        bVar18 = *(byte *)(unaff_RBP + -2);

-        if ((char)bVar18 >> 6 < '\x01') {

-          if ((char)bVar18 >> 6 < '\0') goto LAB_8;

-          bVar29 = *(byte *)((longlong)unaff_RBP + -0xf);

-          cVar19 = (char)(bVar29 << 2) >> 6;

-          if (cVar19 < '\x01') {

-            if (-1 < cVar19) {

-              if (8.138021e-05 <=

-                  (float)((uint)(((float)(*(uint *)((longlong)unaff_RBP + -0x34) & unaff_XMM14_Da) *

-                                  61440.0 + (float)(*(uint *)((longlong)unaff_RBP + -0x44) &

-                                                   unaff_XMM14_Da) * 61440.0 +

-                                 (float)(*(uint *)((longlong)unaff_RBP + -0x14) & unaff_XMM14_Da)) -

-                                1.0) & unaff_XMM14_Da)) {

-                *(byte *)((longlong)unaff_RBP + -0xf) = bVar29 & 0xdf | 0x10;

-                goto LAB_9;

-              }

-              *(byte *)((longlong)unaff_RBP + -0xf) = bVar29 | 0x30;

-            }

-            if (((float)((uint)(*(float *)((longlong)unaff_RBP + -0x4c) - unaff_XMM10_Da) &

-                        unaff_XMM14_Da) < 8.138021e-05) &&

-               ((float)((uint)(*(float *)(unaff_RBP + -8) - unaff_XMM10_Da) & unaff_XMM14_Da) <

-                8.138021e-05)) {

-              cStack0000000000000030 = '\x01';

-              *(byte *)(unaff_RBP + -2) = bVar18 | 0xc0;

-              unaff_R12 = unaff_R12 + 1;

-              goto LAB_10;

-            }

-          }

-LAB_9:

-          *(byte *)(unaff_RBP + -2) = bVar18 & 0x3f | 0x40;

-        }

-        bVar17 = CMILMatrix::Is90Or270RotationWithTranslateAndScaleIgnoreZ<1>

-                           ((CMILMatrix *)(unaff_RBP + -10));

-        if (bVar17) goto LAB_8;

-      }

-    }

-    else {

-      if (pcVar4 == CRectanglesShape::IsRectangles) {

-        cVar19 = CRectanglesShape::IsRectangles

-                           ((CRectanglesShape *)unaff_R14,(uint *)(unaff_RBP + -0xd));

-      }

-      else if (pcVar4 == CRegionShape::IsRectangles) {

-        cVar19 = CRegionShape::IsRectangles((CRegionShape *)unaff_R14,(uint *)(unaff_RBP + -0xd));

-      }

-      else {

-        cVar19 = (*pcVar4)();

-      }

-      if ((cVar19 != '\0') && (*(int *)(unaff_RBP + -0xd) == 1)) goto LAB_7;

-    }

-  }

-  else {

-LAB_8:

-    cStack0000000000000030 = '\x01';

-    unaff_R12 = unaff_R12 + 1;

-  }

-LAB_10:

-  unaff_RBP[-0xc] = unaff_RSI;

-  if (unaff_R15 == (CShape *)0x0) {

-    if ((unaff_RDI[1] == *unaff_RDI) || (*(CShape **)(unaff_RDI[1] + -0xb0) <= unaff_RSI)) {

-      pCVar33 = (CCpuClipAntialiasSink *)(unaff_RBP + -0xc);

-      lVar20 = CShape::CopyShape((CShape *)unaff_R14,unaff_RBX,(CShape **)pCVar33);

-      if (-1 < lVar20) goto LAB_11;

-      uVar21 = 0x171;

-    }

-    else {

-      pCVar30 = *(CShape **)(unaff_RDI[0xf4] + -0x28);

-      unaff_RBP[10] = pCVar30;

-      pCVar33 = (CCpuClipAntialiasSink *)unaff_R14;

-      in_R9 = unaff_RBX;

-      lVar20 = CShape::TryOptimizedCombinePaths

-                         (pCVar30,(CMILMatrix *)0x0,(CShape *)unaff_R14,unaff_RBX,1,

-                          (CShape **)(unaff_RBP + -0xc));

-      if (lVar20 < 0) {

-        uVar21 = 0x1c8;

-      }

-      else {

-        pCVar30 = (CShape *)unaff_RBP[-0xc];

-        if (pCVar30 != (CShape *)0x0) goto LAB_12;

-        pCVar33 = (CCpuClipAntialiasSink *)unaff_R14;

-        lVar20 = CShape::D2DCombine((CShape *)unaff_RBP[10],(CMILMatrix *)0x0,(CShape *)unaff_R14,

-                                    unaff_RBX,1,(CShape **)(unaff_RBP + -0xc));

-        in_R9 = unaff_RBX;

-        if (-1 < lVar20) goto LAB_11;

-        uVar21 = 0x1d3;

-      }

-      MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar20,uVar21,(void *)0x0);

-      uVar21 = 0x16c;

-    }

-  }

-  else {

-    pCVar33 = (CCpuClipAntialiasSink *)(unaff_RBP + -0xc);

-    lVar20 = CShape::CopyShape(unaff_R15,(CMILMatrix *)0x0,(CShape **)pCVar33);

-    if (-1 < lVar20) {

-LAB_11:

-      pCVar30 = (CShape *)unaff_RBP[-0xc];

-LAB_12:

-      unaff_R13B = '\x01';

-      *(undefined1 *)(unaff_RBP + -0xe) = 1;

-      unaff_RSI = pCVar30;

-      if (*(char *)(unaff_RBP + 0x39) != '\0') {

-        lVar27 = unaff_RDI[1];

-        lVar6 = *(longlong *)(lVar27 + -0x10);

-        puVar26 = (undefined8 *)(lVar27 + -0x10);

-        unaff_RBP[10] = puVar26;

-        pCVar31 = pCVar30;

-        if (lVar6 == 0) {

-          unaff_RBP[0xc] = puVar26;

-          unaff_RBP[0xd] = 0;

-          *(undefined1 *)(unaff_RBP + 0xe) = 1;

-          lVar20 = CCpuClipAntialiasSinkContext::Create

-                             ((CCpuClipAntialiasSinkContext **)(unaff_RBP + 0xd));

-          if (*(char *)(unaff_RBP + 0xe) != '\0') {

-            plVar7 = *(longlong **)unaff_RBP[0xc];

-            *(undefined8 *)unaff_RBP[0xc] = unaff_RBP[0xd];

-            if (plVar7 != (longlong *)0x0) {

-              (**(code **)(*plVar7 + 8))();

-            }

-          }

-          if (lVar20 < 0) {

-            uVar21 = 0x17f;

-            goto LAB_13;

-          }

-          uVar13 = *(undefined8 *)(lVar27 + -0x4c);

-          lVar6 = *(longlong *)(lVar27 + -0x10);

-          *(undefined8 *)(lVar6 + 0x388) = *(undefined8 *)(lVar27 + -0x54);

-          *(undefined8 *)(lVar6 + 0x390) = uVar13;

-          uVar13 = *(undefined8 *)(lVar27 + -0x3c);

-          *(undefined8 *)(lVar6 + 0x398) = *(undefined8 *)(lVar27 + -0x44);

-          *(undefined8 *)(lVar6 + 0x3a0) = uVar13;

-          uVar13 = *(undefined8 *)(lVar27 + -0x2c);

-          *(undefined8 *)(lVar6 + 0x3a8) = *(undefined8 *)(lVar27 + -0x34);

-          *(undefined8 *)(lVar6 + 0x3b0) = uVar13;

-          uVar10 = *(undefined4 *)(lVar27 + -0x20);

-          uVar11 = *(undefined4 *)(lVar27 + -0x1c);

-          uVar12 = *(undefined4 *)(lVar27 + -0x18);

-          *(undefined4 *)(lVar6 + 0x3b8) = *(undefined4 *)(lVar27 + -0x24);

-          *(undefined4 *)(lVar6 + 0x3bc) = uVar10;

-          *(undefined4 *)(lVar6 + 0x3c0) = uVar11;

-          *(undefined4 *)(lVar6 + 0x3c4) = uVar12;

-          *(undefined4 *)(lVar6 + 0x3c8) = *(undefined4 *)(lVar27 + -0x14);

-          pCVar31 = (CShape *)unaff_RBP[-0xc];

-          puVar26 = (undefined8 *)unaff_RBP[10];

-        }

-        pCVar33 = (CCpuClipAntialiasSink *)unaff_RBP[0x10];

-        lVar20 = CCpuClipAntialiasSinkContext::PushSink

-                           ((CCpuClipAntialiasSinkContext *)*puVar26,pCVar31,pCVar33);

-        if (lVar20 < 0) {

-          uVar21 = 0x187;

-          goto LAB_13;

-        }

-        in_stack_00000031 = '\x01';

-      }

-      uVar36 = (uint)in_R9;

-      uVar21 = (uint)pCVar33;

-      lVar27 = *(longlong *)unaff_R14;

-      unaff_RBP[10] = 0;

-      unaff_RBP[0xb] = 0;

-      pcVar4 = *(code **)(lVar27 + 0x30);

-      if (pcVar4 == CRectanglesShape::GetTightBounds) {

-        puVar26 = *(undefined8 **)(unaff_R14 + 0x10);

-        uVar25 = *(longlong *)(unaff_R14 + 0x18) - (longlong)puVar26 >> 4;

-        if (uVar25 == 0) goto LAB_14;

-        uVar13 = puVar26[1];

-        uVar32 = 1;

-        unaff_RBP[10] = *puVar26;

-        unaff_RBP[0xb] = uVar13;

-        if (1 < uVar25) {

-          lVar27 = 0x10;

-          do {

-            TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded>::UnionUnsafe

-                      ((TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded> *)

-                       (unaff_RBP + 10),

-                       (TMilRect<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_RectUniqueness::NotNeeded>

-                        *)((longlong)puVar26 + lVar27));

-            uVar36 = (uint)in_R9;

-            uVar21 = (uint)pCVar33;

-            puVar26 = *(undefined8 **)(unaff_R14 + 0x10);

-            lVar27 = lVar27 + 0x10;

-            uVar32 = uVar32 + 1;

-          } while (uVar32 < (ulonglong)(*(longlong *)(unaff_R14 + 0x18) - (longlong)puVar26 >> 4));

-        }

-        bVar17 = CMILMatrix::IsIdentity<0>((CMILMatrix *)(unaff_RBP + -10));

-        if (bVar17) goto LAB_14;

-        bVar17 = CMILMatrix::IsTranslateIgnoreZ<1>((CMILMatrix *)(unaff_RBP + -10));

-        if (bVar17) {

-          unaff_XMM10_Da = *(float *)(unaff_RBP + 10) + *(float *)(unaff_RBP + -4);

-          fVar44 = *(float *)((longlong)unaff_RBP + 0x54) + *(float *)((longlong)unaff_RBP + -0x1c);

-          fVar45 = *(float *)(unaff_RBP + 0xb) + *(float *)(unaff_RBP + -4);

-          fVar39 = *(float *)((longlong)unaff_RBP + 0x5c) + *(float *)((longlong)unaff_RBP + -0x1c);

-          *(float *)(unaff_RBP + 10) = unaff_XMM10_Da;

-          *(float *)((longlong)unaff_RBP + 0x54) = fVar44;

-          *(float *)(unaff_RBP + 0xb) = fVar45;

-          *(float *)((longlong)unaff_RBP + 0x5c) = fVar39;

-        }

-        else {

-          bVar17 = CMILMatrix::IsTranslateAndScaleIgnoreZ<1>((CMILMatrix *)(unaff_RBP + -10));

-          if (!bVar17) {

-            pDVar35 = (D2D_POINT_2F *)(unaff_RBP + 0x10);

-            CMILMatrix::Transform2DRectToPerspective

-                      ((CMILMatrix *)(unaff_RBP + -10),(D2D_RECT_F *)(unaff_RBP + 10),pDVar35);

-            uVar21 = (uint)pDVar35;

-            unaff_RBP[0xc] = 4;

-            unaff_RBP[0xd] = unaff_RBP + 0x10;

-            TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded>::

-            SetToBoundsOfUnorderedPointSet<D2D_POINT_2F>

-                      ((TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded> *)

-                       (unaff_RBP + 10),unaff_RBP + 0xc);

-            goto LAB_14;

-          }

-          fVar38 = *(float *)(unaff_RBP + -10);

-          fVar40 = *(float *)((longlong)unaff_RBP + -0x3c);

-          unaff_XMM10_Da = fVar38 * *(float *)(unaff_RBP + 10) + *(float *)(unaff_RBP + -4);

-          fVar44 = fVar40 * *(float *)((longlong)unaff_RBP + 0x54) +

-                   *(float *)((longlong)unaff_RBP + -0x1c);

-          fVar45 = fVar38 * *(float *)(unaff_RBP + 0xb) + *(float *)(unaff_RBP + -4);

-          fVar42 = fVar40 * *(float *)((longlong)unaff_RBP + 0x5c) +

-                   *(float *)((longlong)unaff_RBP + -0x1c);

-          *(float *)(unaff_RBP + 10) = unaff_XMM10_Da;

-          *(float *)((longlong)unaff_RBP + 0x54) = fVar44;

-          *(float *)(unaff_RBP + 0xb) = fVar45;

-          *(float *)((longlong)unaff_RBP + 0x5c) = fVar42;

-          fVar39 = fVar42;

-          if ((fVar38 <= 0.0) || (fVar40 <= 0.0)) {

-            fVar38 = fVar45;

-            if (fVar45 < unaff_XMM10_Da) {

-              *(float *)(unaff_RBP + 10) = fVar45;

-              *(float *)(unaff_RBP + 0xb) = unaff_XMM10_Da;

-              fVar38 = unaff_XMM10_Da;

-              unaff_XMM10_Da = fVar45;

-            }

-            fVar45 = fVar38;

-            if (fVar42 < fVar44) {

-              *(float *)((longlong)unaff_RBP + 0x54) = fVar42;

-              *(float *)((longlong)unaff_RBP + 0x5c) = fVar44;

-              fVar39 = fVar44;

-              fVar44 = fVar42;

-            }

-          }

-        }

-      }

-      else {

-        pCVar34 = (CMILMatrix *)(unaff_RBP + -10);

-        if (pcVar4 == CRoundedRectangleShape::GetTightBounds) {

-          iVar22 = CRoundedRectangleShape::GetTightBounds

-                             (unaff_R14,

-                              (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

-                               *)(unaff_RBP + 10),pCVar34);

-          uVar21 = (uint)pCVar34;

-        }

-        else if (pcVar4 == CRegionShape::GetTightBounds) {

-          iVar22 = CRegionShape::GetTightBounds

-                             ((CRegionShape *)unaff_R14,

-                              (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

-                               *)(unaff_RBP + 10),pCVar34);

-          uVar21 = (uint)pCVar34;

-        }

-        else {

-          iVar22 = (*pcVar4)();

-          uVar21 = (uint)pCVar34;

-        }

-        if (iVar22 < 0) {

-          if (iVar22 != -0x7767fff6) {

-                    /* WARNING: Subroutine does not return */

-            ModuleFailFastForHRESULT(iVar22,unaff_RBP[0x33]);

-          }

-          *(float *)(unaff_RBP + 10) = unaff_XMM10_Da;

-          fVar45 = 0.0;

-          *(undefined4 *)((longlong)unaff_RBP + 0x5c) = 0;

-          fVar44 = 0.0;

-          *(undefined4 *)(unaff_RBP + 0xb) = 0;

-          *(undefined4 *)((longlong)unaff_RBP + 0x54) = 0;

-          fVar39 = 0.0;

-          goto LAB_15;

-        }

-LAB_14:

-        unaff_XMM10_Da = *(float *)(unaff_RBP + 10);

-        fVar44 = *(float *)((longlong)unaff_RBP + 0x54);

-        fVar45 = *(float *)(unaff_RBP + 0xb);

-        fVar39 = *(float *)((longlong)unaff_RBP + 0x5c);

-      }

-LAB_15:

-      cVar19 = cStack0000000000000030;

-      if (cStack0000000000000030 == '\0') {

-        if ((float)((uint)unaff_XMM10_Da & unaff_XMM14_Da) < 8388608.0) {

-          fVar38 = floorf(unaff_XMM10_Da);

-          unaff_XMM10_Da = (float)(int)fVar38;

-        }

-        *(float *)(unaff_RBP + 10) = unaff_XMM10_Da;

-        if ((float)((uint)fVar44 & unaff_XMM14_Da) < 8388608.0) {

-          fVar44 = floorf(fVar44);

-          fVar44 = (float)(int)fVar44;

-        }

-        *(float *)((longlong)unaff_RBP + 0x54) = fVar44;

-        if ((float)((uint)fVar45 & unaff_XMM14_Da) < 8388608.0) {

-          fVar45 = ceilf(fVar45);

-          fVar45 = (float)(int)fVar45;

-        }

-        *(float *)(unaff_RBP + 0xb) = fVar45;

-        if ((float)((uint)fVar39 & unaff_XMM14_Da) < 8388608.0) {

-          fVar39 = ceilf(fVar39);

-          fVar39 = (float)(int)fVar39;

-        }

-        *(float *)((longlong)unaff_RBP + 0x5c) = fVar39;

-      }

-      if ((unaff_RDI[1] == *unaff_RDI) || (*(longlong *)(unaff_RDI[1] + -0xa8) == 0)) {

-        iVar22 = *(int *)(unaff_RBP + 0x38);

-        if (iVar22 == 1) {

-          iVar37 = 0x7fffffff;

-          fVar38 = unaff_XMM10_Da - 0.5;

-          iVar24 = 0x7fffffff;

-          if (fVar38 < -2.1474836e+09) {

-            iVar23 = -0x80000000;

-          }

-          else {

-            iVar23 = iVar24;

-            if (fVar38 < 2.1474836e+09) {

-              fVar38 = ceilf(fVar38);

-              iVar23 = (int)fVar38;

-            }

-          }

-          fVar44 = fVar44 - 0.5;

-          *(float *)(unaff_RBP + 0xc) = (float)iVar23;

-          if (fVar44 < -2.1474836e+09) {

-            iVar23 = -0x80000000;

-          }

-          else {

-            iVar23 = iVar24;

-            if (fVar44 < 2.1474836e+09) {

-              fVar44 = ceilf(fVar44);

-              iVar23 = (int)fVar44;

-            }

-          }

-          fVar45 = fVar45 - 0.5;

-          *(float *)((longlong)unaff_RBP + 100) = (float)iVar23;

-          if (fVar45 < -2.1474836e+09) {

-            iVar24 = -0x80000000;

-          }

-          else if (fVar45 < 2.1474836e+09) {

-            fVar44 = ceilf(fVar45);

-            iVar24 = (int)fVar44;

-          }

-          fVar39 = fVar39 - 0.5;

-          *(float *)(unaff_RBP + 0xd) = (float)iVar24;

-          if (fVar39 < -2.1474836e+09) {

-            iVar37 = -0x80000000;

-          }

-          else if (fVar39 < 2.1474836e+09) {

-            fVar44 = ceilf(fVar39);

-            iVar37 = (int)fVar44;

-          }

-          *(float *)((longlong)unaff_RBP + 0x6c) = (float)iVar37;

-        }

-        else {

-          *(float *)(unaff_RBP + 0xc) = unaff_XMM10_Da;

-          *(float *)((longlong)unaff_RBP + 100) = fVar44;

-          *(float *)(unaff_RBP + 0xd) = fVar45;

-          *(float *)((longlong)unaff_RBP + 0x6c) = fVar39;

-        }

-        if (*(uint *)(unaff_RDI + 300) != *(uint *)((longlong)unaff_RDI + 0x964)) {

-LAB_16:

-          uVar13 = unaff_RBP[0xd];

-          puVar26 = (undefined8 *)(unaff_RDI[299] + (ulonglong)*(uint *)(unaff_RDI + 300) * 0x10);

-          *puVar26 = unaff_RBP[0xc];

-          puVar26[1] = uVar13;

-          *(int *)(unaff_RDI + 300) = (int)unaff_RDI[300] + 1;

-          uVar21 = *(uint *)((longlong)unaff_RDI + 0x96c);

-          if (*(uint *)((longlong)unaff_RDI + 0x96c) <= *(uint *)(unaff_RDI + 300)) {

-            uVar21 = *(uint *)(unaff_RDI + 300);

-          }

-          *(uint *)((longlong)unaff_RDI + 0x96c) = uVar21;

-LAB_17:

-          *(longlong *)(unaff_RDI[1] + -0xa8) = *(longlong *)(unaff_RDI[1] + -0xa8) + 1;

-          detail::

-          vector_facade<CScopedClipStack::CpuClipStackState,detail::buffer_impl<CScopedClipStack::CpuClipStackState,10,1,detail::liberal_expansion_policy>_>

-          ::emplace_back<>((vector_facade<CScopedClipStack::CpuClipStackState,detail::buffer_impl<CScopedClipStack::CpuClipStackState,10,1,detail::liberal_expansion_policy>_>

-                            *)(unaff_RDI + 0xf3));

-          *(longlong *)(unaff_RDI[1] + -0xb0) = *(longlong *)(unaff_RDI[1] + -0xb0) + 1;

-          lVar27 = unaff_RDI[0xf4];

-          if ((*(char *)(lVar27 + -0x20) != '\0') &&

-             (this_01 = *(CRectanglesShape **)(lVar27 + -0x28), this_01 != (CRectanglesShape *)0x0))

-          {

-            pcVar4 = (code *)**(undefined8 **)this_01;

-            if (pcVar4 == CRectanglesShape::_scalar_deleting_destructor_) {

-              CRectanglesShape::~CRectanglesShape(this_01);

-              CThreadLocalObjectCache<CRectanglesShape,CRectanglesShape>::Free(this_01);

-            }

-            else if (pcVar4 == CRoundedRectangleShape::_scalar_deleting_destructor_) {

-              CRoundedRectangleShape::~CRoundedRectangleShape((CRoundedRectangleShape *)this_01);

-              CThreadLocalObjectCache<CRoundedRectangleShape,CRoundedRectangleShape>::Free(this_01);

-            }

-            else if (pcVar4 == CPolygonShape::_scalar_deleting_destructor_) {

-              CPolygonShape::_scalar_deleting_destructor_((CPolygonShape *)this_01,1);

-            }

-            else {

-              (*pcVar4)();

-            }

-          }

-          uVar2 = *(undefined1 *)(unaff_RBP + 0x39);

-          *(CShape **)(lVar27 + -0x28) = pCVar30;

-          *(undefined1 *)(lVar27 + -0x20) = 1;

-          *(undefined1 *)(lVar27 + -4) = uVar2;

-          pcVar5 = (char *)*unaff_RBP;

-          *(longlong *)(lVar27 + -0x18) = unaff_R12;

-          *(undefined8 *)(lVar27 + -0x10) = 0;

-          *(int *)(lVar27 + -8) = iVar22;

-          *pcVar5 = cVar19;

-          return 0;

-        }

-        uVar25 = (ulonglong)*(uint *)((longlong)unaff_RDI + 0x964) * 2;

-        if (uVar25 < 0x100000000) {

-          uVar32 = uVar25 & 0xffffffff;

-          if ((uint)uVar25 < 9) {

-            uVar32 = 8;

-          }

-          uVar25 = (ulonglong)*(uint *)(unaff_RDI + 300) << 4;

-          if (0xffffffff < uVar25) {

-            uVar21 = 0x65;

-            goto LAB_18;

-          }

-          if (((int)uVar32 == 0) ||

-             (auVar8._8_8_ = 0, auVar8._0_8_ = uVar32,

-             SUB168((ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff)) / auVar8,0) < 0x11)) {

-            lVar20 = -0x7ff8ffa9;

-          }

-          else {

-            _Dst = _Alloc_DefaultHeap__SAPEAX_K_Z(uVar32 << 4);

-            unaff_RBP[0x10] = _Dst;

-            if (_Dst != (void *)0x0) {

-              memcpy(_Dst,(void *)unaff_RDI[299],uVar25 & 0xffffffff);

-              ___V_YAXPEAX_Z((void *)unaff_RDI[299]);

-              unaff_RDI[299] = unaff_RBP[0x10];

-              *(int *)((longlong)unaff_RDI + 0x964) = (int)uVar32;

-              goto LAB_16;

-            }

-            lVar20 = -0x7ff8fff2;

-          }

-          uVar21 = 0x68;

-        }

-        else {

-          uVar21 = 0x62;

-LAB_18:

-          lVar20 = -0x7ff8fdea;

-        }

-        wil::details::in1diag3::Return_Hr

-                  ((void *)unaff_RBP[0x33],uVar21,

-                   "onecoreuap\\windows\\DWM\\dwmcore\\common\\WatermarkStack.inl",lVar20);

-        wil::details::in1diag3::Return_Hr

-                  ((void *)unaff_RBP[0x33],0x83,

-                   "onecoreuap\\windows\\DWM\\dwmcore\\common\\WatermarkStack.inl",lVar20);

-        uVar21 = 0x201;

-      }

-      else {

-        iVar22 = *(int *)(unaff_RBP + 0x38);

-        this_00 = (CWatermarkStack<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,8,2,8>

-                   *)(unaff_RDI + 299);

-        if (iVar22 == 1) {

-          iVar37 = 0x7fffffff;

-          fVar38 = unaff_XMM10_Da - 0.5;

-          iVar24 = 0x7fffffff;

-          if (fVar38 < -2.1474836e+09) {

-            iVar23 = -0x80000000;

-          }

-          else {

-            iVar23 = iVar24;

-            if (fVar38 < 2.1474836e+09) {

-              fVar38 = ceilf(fVar38);

-              iVar23 = (int)fVar38;

-            }

-          }

-          fVar44 = fVar44 - 0.5;

-          unaff_XMM10_Da = (float)iVar23;

-          if (fVar44 < -2.1474836e+09) {

-            iVar23 = -0x80000000;

-          }

-          else {

-            iVar23 = iVar24;

-            if (fVar44 < 2.1474836e+09) {

-              fVar44 = ceilf(fVar44);

-              iVar23 = (int)fVar44;

-            }

-          }

-          fVar45 = fVar45 - 0.5;

-          fVar44 = (float)iVar23;

-          if (fVar45 < -2.1474836e+09) {

-            iVar24 = -0x80000000;

-          }

-          else if (fVar45 < 2.1474836e+09) {

-            fVar45 = ceilf(fVar45);

-            iVar24 = (int)fVar45;

-          }

-          fVar39 = fVar39 - 0.5;

-          fVar45 = (float)iVar24;

-          if (fVar39 < -2.1474836e+09) {

-            iVar37 = -0x80000000;

-          }

-          else if (fVar39 < 2.1474836e+09) {

-            fVar39 = ceilf(fVar39);

-            iVar37 = (int)fVar39;

-          }

-          fVar39 = (float)iVar37;

-        }

-        uVar3 = *(uint *)(unaff_RDI + 300);

-        unaff_RBP[0x10] = 0;

-        unaff_RBP[0x11] = 0;

-        if (uVar3 == 0) {

-          fVar38 = -3.4028235e+38;

-          fVar40 = -3.4028235e+38;

-          fVar42 = 3.4028235e+38;

-          fVar43 = 3.4028235e+38;

-        }

-        else {

-          pfVar1 = (float *)(*(longlong *)this_00 + (ulonglong)(uVar3 - 1) * 0x10);

-          fVar38 = *pfVar1;

-          fVar40 = pfVar1[1];

-          fVar42 = pfVar1[2];

-          fVar43 = pfVar1[3];

-        }

-        *(float *)(unaff_RBP + 0x10) = fVar38;

-        *(float *)((longlong)unaff_RBP + 0x84) = fVar40;

-        *(float *)(unaff_RBP + 0x11) = fVar42;

-        *(float *)((longlong)unaff_RBP + 0x8c) = fVar43;

-        if (fVar38 < unaff_XMM10_Da) {

-          *(float *)(unaff_RBP + 0x10) = unaff_XMM10_Da;

-          *(float *)((longlong)unaff_RBP + 0x84) = fVar40;

-          *(float *)(unaff_RBP + 0x11) = fVar42;

-          *(float *)((longlong)unaff_RBP + 0x8c) = fVar43;

-          fVar38 = unaff_XMM10_Da;

-        }

-        fVar41 = fVar38;

-        if (fVar40 < fVar44) {

-          fVar41 = *(float *)(unaff_RBP + 0x10);

-          fVar42 = *(float *)(unaff_RBP + 0x11);

-          fVar43 = *(float *)((longlong)unaff_RBP + 0x8c);

-          *(float *)(unaff_RBP + 0x10) = fVar41;

-          *(float *)((longlong)unaff_RBP + 0x84) = fVar44;

-          *(float *)(unaff_RBP + 0x11) = fVar42;

-          *(float *)((longlong)unaff_RBP + 0x8c) = fVar43;

-          fVar40 = fVar44;

-        }

-        fVar44 = fVar40;

-        if (fVar45 < fVar42) {

-          fVar41 = *(float *)(unaff_RBP + 0x10);

-          fVar44 = *(float *)((longlong)unaff_RBP + 0x84);

-          fVar43 = *(float *)((longlong)unaff_RBP + 0x8c);

-          *(float *)(unaff_RBP + 0x10) = fVar41;

-          *(float *)((longlong)unaff_RBP + 0x84) = fVar44;

-          *(float *)(unaff_RBP + 0x11) = fVar45;

-          *(float *)((longlong)unaff_RBP + 0x8c) = fVar43;

-          fVar42 = fVar45;

-        }

-        fVar45 = fVar42;

-        if (fVar39 < fVar43) {

-          fVar41 = *(float *)(unaff_RBP + 0x10);

-          fVar44 = *(float *)((longlong)unaff_RBP + 0x84);

-          fVar45 = *(float *)(unaff_RBP + 0x11);

-          *(float *)(unaff_RBP + 0x10) = fVar41;

-          *(float *)((longlong)unaff_RBP + 0x84) = fVar44;

-          *(float *)(unaff_RBP + 0x11) = fVar45;

-          *(float *)((longlong)unaff_RBP + 0x8c) = fVar39;

-          fVar43 = fVar39;

-        }

-        if ((fVar42 <= fVar38) || (fVar43 <= fVar40)) {

-          unaff_RBP[0x11] = 0;

-          unaff_RBP[0x10] = 0;

-          fVar41 = *(float *)(unaff_RBP + 0x10);

-          fVar44 = *(float *)((longlong)unaff_RBP + 0x84);

-          fVar45 = *(float *)(unaff_RBP + 0x11);

-          fVar43 = *(float *)((longlong)unaff_RBP + 0x8c);

-        }

-        if ((uVar3 != *(uint *)((longlong)unaff_RDI + 0x964)) ||

-           (lVar20 = CWatermarkStack<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,8,2,8>

-                     ::Grow(this_00,(ulonglong)uVar3,uVar21,uVar36,(void **)this_00),

-           cVar19 = cStack0000000000000030, -1 < lVar20)) {

-          pfVar1 = (float *)(*(longlong *)this_00 + (ulonglong)*(uint *)(unaff_RDI + 300) * 0x10);

-          *pfVar1 = fVar41;

-          pfVar1[1] = fVar44;

-          pfVar1[2] = fVar45;

-          pfVar1[3] = fVar43;

-          *(int *)(unaff_RDI + 300) = (int)unaff_RDI[300] + 1;

-          uVar21 = *(uint *)((longlong)unaff_RDI + 0x96c);

-          if (*(uint *)((longlong)unaff_RDI + 0x96c) <= *(uint *)(unaff_RDI + 300)) {

-            uVar21 = *(uint *)(unaff_RDI + 300);

-          }

-          *(uint *)((longlong)unaff_RDI + 0x96c) = uVar21;

-          goto LAB_17;

-        }

-        wil::details::in1diag3::Return_Hr

-                  ((void *)unaff_RBP[0x33],0x83,

-                   "onecoreuap\\windows\\DWM\\dwmcore\\common\\WatermarkStack.inl",lVar20);

-        MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar20,0x31,(void *)0x0);

-        uVar21 = 0x205;

-      }

-      MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar20,uVar21,(void *)0x0);

-      MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar20,0x1a9,(void *)0x0);

-      unaff_R13B = *(char *)(unaff_RBP + -0xe);

-      if (in_stack_00000031 != '\0') {

-        detail::

-        vector_facade<CCpuClipAntialiasSinkContext::SinkEntry,detail::buffer_impl<CCpuClipAntialiasSinkContext::SinkEntry,2,1,detail::liberal_expansion_policy>_>

-        ::pop_back((vector_facade<CCpuClipAntialiasSinkContext::SinkEntry,detail::buffer_impl<CCpuClipAntialiasSinkContext::SinkEntry,2,1,detail::liberal_expansion_policy>_>

-                    *)(*(longlong *)(unaff_RDI[1] + -0x10) + 0x10));

-      }

-      goto LAB_19;

-    }

-    uVar21 = 0x162;

-  }

-LAB_13:

-  MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar20,uVar21,(void *)0x0);

-LAB_19:

-  detail::

-  vector_facade<CScopedClipStack::CpuClipStackState,detail::buffer_impl<CScopedClipStack::CpuClipStackState,10,1,detail::liberal_expansion_policy>_>

-  ::pop_back((vector_facade<CScopedClipStack::CpuClipStackState,detail::buffer_impl<CScopedClipStack::CpuClipStackState,10,1,detail::liberal_expansion_policy>_>

-              *)(unaff_RDI + 0xf3));

-  if ((unaff_R13B != '\0') && (unaff_RSI != (CShape *)0x0)) {

-    pcVar4 = (code *)**(undefined8 **)unaff_RSI;

-    if (pcVar4 == CRectanglesShape::_scalar_deleting_destructor_) {

-      *(undefined ***)unaff_RSI = &CRectanglesShape::_vftable_;

-      lVar27 = *(longlong *)(unaff_RSI + 0x18) - *(longlong *)(unaff_RSI + 0x10) >> 4;

-      if (lVar27 != 0) {

-        *(longlong *)(unaff_RSI + 0x18) = *(longlong *)(unaff_RSI + 0x18) + lVar27 * -0x10;

-      }

-      this_02 = *(CMILCOMBaseWeakRefSource<CResourceDeleter> **)(unaff_RSI + 0x38);

-      if (this_02 != (CMILCOMBaseWeakRefSource<CResourceDeleter> *)0x0) {

-        if (*(code **)(*(longlong *)this_02 + 0x10) ==

-            CMILCOMBaseWeakRefSource<CResourceDeleter>::InternalRelease) {

-          CMILCOMBaseWeakRefSource<CResourceDeleter>::InternalRelease(this_02);

-        }

-        else {

-          (**(code **)(*(longlong *)this_02 + 0x10))();

-        }

-        *(undefined8 *)(unaff_RSI + 0x38) = 0;

-      }

-      lpMem = *(CRoundedRectangleShape **)(unaff_RSI + 0x10);

-      lVar27 = *(longlong *)(unaff_RSI + 0x18) - (longlong)lpMem >> 4;

-      if (lVar27 != 0) {

-        *(longlong *)(unaff_RSI + 0x18) = *(longlong *)(unaff_RSI + 0x18) + lVar27 * -0x10;

-      }

-      *(undefined8 *)(unaff_RSI + 0x10) = 0;

-      if (lpMem == (CRoundedRectangleShape *)(unaff_RSI + 0x28)) {

-        lpMem = (CRoundedRectangleShape *)0x0;

-      }

-      if (lpMem != (CRoundedRectangleShape *)0x0) {

-        pvVar28 = GetProcessHeap();

-        HeapFree(pvVar28,0,lpMem);

-      }

-      this_03 = *(CMILRefCountBaseT<ID2D1GeometrySink,CMilObjectDeleter> **)(unaff_RSI + 8);

-      if (this_03 != (CMILRefCountBaseT<ID2D1GeometrySink,CMilObjectDeleter> *)0x0) {

-        *(undefined8 *)(unaff_RSI + 8) = 0;

-        if (*(code **)(*(longlong *)this_03 + 0x10) ==

-            CMILCOMBaseT<ID2D1GeometrySink,ID2D1GeometrySink,CMilObjectDeleter>::Release) {

-          CMILRefCountBaseT<ID2D1GeometrySink,CMilObjectDeleter>::InternalRelease(this_03);

-        }

-        else {

-          (**(code **)(*(longlong *)this_03 + 0x10))();

-        }

-      }

-      lpTlsValue = TlsGetValue(CThreadContext::s_dwTlsIndex);

-      if (lpTlsValue == (LPVOID)0x0) {

-        this_05 = _Alloc_DefaultHeap__SAPEAX_K_Z(0x1c0);

-        if ((this_05 == (CThreadContext *)0x0) ||

-           (lpTlsValue = (LPVOID)CThreadContext::CThreadContext(this_05), lpTlsValue == (LPVOID)0x0)

-           ) {

-          MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,-0x7ff8fff2,0x28,(void *)0x0);

-                    /* WARNING: Subroutine does not return */

-          ModuleFailFastForHRESULT(0x8007000e,unaff_RBP[0x33]);

-        }

-        TlsSetValue(CThreadContext::s_dwTlsIndex,lpTlsValue);

-      }

-      if (*(uint *)((longlong)lpTlsValue + 0x34) < *(uint *)((longlong)lpTlsValue + 0x30)) {

-        *(undefined8 *)unaff_RSI = *(undefined8 *)((longlong)lpTlsValue + 0x38);

-        *(int *)((longlong)lpTlsValue + 0x34) = *(int *)((longlong)lpTlsValue + 0x34) + 1;

-        *(CShape **)((longlong)lpTlsValue + 0x38) = unaff_RSI;

-      }

-      else {

-        pvVar28 = GetProcessHeap();

-        HeapFree(pvVar28,0,unaff_RSI);

-      }

-    }

-    else if (pcVar4 == CRoundedRectangleShape::_scalar_deleting_destructor_) {

-      CRoundedRectangleShape::~CRoundedRectangleShape((CRoundedRectangleShape *)unaff_RSI);

-      CThreadLocalObjectCache<CRoundedRectangleShape,CRoundedRectangleShape>::Free(unaff_RSI);

-    }

-    else if (pcVar4 == CPolygonShape::_scalar_deleting_destructor_) {

-      CPolygonShape::_scalar_deleting_destructor_((CPolygonShape *)unaff_RSI,1);

-    }

-    else {

-      (*pcVar4)();

-    }

-  }

-  return lVar20;

+  if (local_1a8 != (longlong *)0x0) {

+    (**(code **)(*local_1a8 + 0x10))();

+  }

+  if (local_1a0 == (IBitmapRealization *)0x0) {

+    return lVar6;

+  }

+  (**(code **)(*(longlong *)local_1a0 + 0x10))();

+  return lVar6;

 }
```

## `CWindowNode::HasNonEmptyContent`  (modified)

```diff
--- CWindowNode::HasNonEmptyContent
+++ CWindowNode::HasNonEmptyContent
@@ -1,2 +1,194 @@
-Failed to decompile dwmcore.dll - .ProgramDB CWindowNode::HasNonEmptyContent : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: virtual bool __cdecl CWindowNode::HasNonEmptyContent(void)const __ptr64 */

+

+bool __thiscall CWindowNode::HasNonEmptyContent(CWindowNode *this)

+

+{

+  CEffectBrush *this_00;

+  longlong *plVar1;

+  bool bVar2;

+  char cVar3;

+  char cVar4;

+  ulonglong uVar5;

+  CResource *pCVar6;

+  vector<CProjectedShadowReceiver*___ptr64,std::allocator<CProjectedShadowReceiver*___ptr64>_>

+  *pvVar7;

+  code *pcVar8;

+  CSurfaceBrush *this_01;

+  bool local_res8 [8];

+  bool local_res10 [8];

+  char local_res18 [8];

+  IBitmapResource *local_res20;

+  IBitmapResource *local_38 [2];

+  

+  if ((*(longlong *)(this + 0x330) == 0) || (*(char *)(*(longlong *)(this + 0x330) + 0xa0) == '\0'))

+  {

+    if (this[0x2f1] == (CWindowNode)0x0) {

+      uVar5 = *(ulonglong *)(this + 0x340);

+      if ((uVar5 & 2) == 0) {

+        uVar5 = (ulonglong)((uint)uVar5 & 1);

+      }

+      else {

+        uVar5 = *(ulonglong *)(uVar5 & 0xfffffffffffffffc);

+      }

+      if (uVar5 != 0) {

+        return true;

+      }

+    }

+    uVar5 = *(ulonglong *)(this + 0x348);

+    if ((uVar5 & 2) == 0) {

+      uVar5 = (ulonglong)((uint)uVar5 & 1);

+    }

+    else {

+      uVar5 = *(ulonglong *)(uVar5 & 0xfffffffffffffffc);

+    }

+    if (uVar5 != 0) {

+      return true;

+    }

+  }

+  this_01 = *(CSurfaceBrush **)(this + 0x100);

+  if (this_01 == (CSurfaceBrush *)0x0) goto LAB_0;

+  pcVar8 = *(code **)(*(longlong *)this_01 + 0xd8);

+  if (pcVar8 == CBrush::IsEmptyDrawing) {

+    pcVar8 = *(code **)(*(longlong *)this_01 + 0x138);

+    local_res8[0] = false;

+    if (pcVar8 == CSurfaceBrush::IsReadyToDraw) {

+      pcVar8 = *(code **)**(undefined8 **)(this_01 + 0x88);

+      if (pcVar8 == CBitmapRenderStrategy::IsReadyToDraw) {

+        local_res20 = (IBitmapResource *)0x0;

+        wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::reset

+                  ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res20);

+        CBitmapRenderStrategy::GetBitmap(this_01,&local_res20);

+        cVar4 = CBitmapRenderStrategy::HasRenderingRealization(local_res20);

+        wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::

+        ~com_ptr_t<IBitmapResource,wil::err_returncode_policy>

+                  ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res20);

+      }

+      else if (pcVar8 == CPrimitiveGroupRenderStrategy::IsReadyToDraw) {

+LAB_1:

+        pCVar6 = CSurfaceBrush::GetSurface(this_01);

+        if (*(code **)(*(longlong *)pCVar6 + 0xd8) == CPrimitiveGroup::IsEmptyDrawing) {

+          local_res8[0] = CPrimitiveGroup::IsEmptyDrawing((CPrimitiveGroup *)pCVar6);

+        }

+        else {

+          local_res8[0] = (bool)(**(code **)(*(longlong *)pCVar6 + 0xd8))();

+        }

+        cVar4 = '\x01';

+      }

+      else if (pcVar8 == CVisualSurfaceRenderStrategy::IsReadyToDraw) {

+        pCVar6 = CSurfaceBrush::GetSurface(this_01);

+        cVar4 = CVisualSurface::HasSomethingToDraw((CVisualSurface *)pCVar6);

+      }

+      else {

+        cVar4 = (*pcVar8)(*(undefined8 **)(this_01 + 0x88),this_01,0,local_res8);

+      }

+      goto LAB_2;

+    }

+    if (pcVar8 == CMaskBrush::IsReadyToDraw) {

+      this_00 = *(CEffectBrush **)(this_01 + 0x78);

+      cVar4 = '\0';

+      local_res10[0] = false;

+      local_res18[0] = '\0';

+      if (this_00 != (CEffectBrush *)0x0) {

+        pcVar8 = *(code **)(*(longlong *)this_00 + 0x138);

+        if (pcVar8 == CGradientBrush::IsReadyToDraw) {

+          local_res10[0] =

+               std::vector<CColorGradientStop*___ptr64,std::allocator<CColorGradientStop*___ptr64>_>

+               ::empty((vector<CColorGradientStop*___ptr64,std::allocator<CColorGradientStop*___ptr64>_>

+                        *)(this_00 + 0xa8));

+          bVar2 = std::

+                  vector<CColorGradientStop*___ptr64,std::allocator<CColorGradientStop*___ptr64>_>::

+                  empty((vector<CColorGradientStop*___ptr64,std::allocator<CColorGradientStop*___ptr64>_>

+                         *)(this_00 + 0xa8));

+          cVar3 = !bVar2;

+LAB_3:

+          if (cVar3 != '\0') {

+LAB_4:

+            plVar1 = *(longlong **)(this_01 + 0x70);

+            if ((plVar1 == (longlong *)0x0) ||

+               (cVar3 = (**(code **)(*plVar1 + 0x138))(plVar1,0,local_res18), cVar3 != '\0')) {

+              cVar4 = '\x01';

+            }

+          }

+        }

+        else {

+          if (pcVar8 != CColorBrush::IsReadyToDraw) {

+            if (pcVar8 == CEffectBrush::IsReadyToDraw) {

+              cVar3 = CEffectBrush::IsReadyToDraw(this_00,(CDrawingContext *)0x0,local_res10);

+            }

+            else {

+              cVar3 = (*pcVar8)();

+            }

+            goto LAB_3;

+          }

+          local_res10[0] = IsCloseRealZero(*(float *)(this_00 + 0x74),1.1920929e-06);

+          if (!NAN(*(float *)(this_00 + 0x74))) goto LAB_4;

+        }

+        if ((local_res10[0] != false) || (local_res18[0] != '\0')) {

+          local_res8[0] = true;

+          goto LAB_2;

+        }

+      }

+      local_res8[0] = false;

+    }

+    else if (pcVar8 == CNineGridBrush::IsReadyToDraw) {

+      this_01 = *(CSurfaceBrush **)(this_01 + 0x68);

+      if (this_01 == (CSurfaceBrush *)0x0) goto LAB_0;

+      pcVar8 = *(code **)(*(longlong *)this_01 + 0x138);

+      if (pcVar8 == CSurfaceBrush::IsReadyToDraw) {

+        pcVar8 = *(code **)**(undefined8 **)(this_01 + 0x88);

+        if (pcVar8 == CBitmapRenderStrategy::IsReadyToDraw) {

+          local_38[0] = (IBitmapResource *)0x0;

+          wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::reset

+                    ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)local_38);

+          CBitmapRenderStrategy::GetBitmap(this_01,local_38);

+          cVar4 = CBitmapRenderStrategy::HasRenderingRealization(local_38[0]);

+          wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::

+          ~com_ptr_t<IBitmapResource,wil::err_returncode_policy>

+                    ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)local_38);

+        }

+        else {

+          if (pcVar8 == CPrimitiveGroupRenderStrategy::IsReadyToDraw) goto LAB_1;

+          if (pcVar8 == CVisualSurfaceRenderStrategy::IsReadyToDraw) {

+            pCVar6 = CSurfaceBrush::GetSurface(this_01);

+            cVar4 = CVisualSurface::HasSomethingToDraw((CVisualSurface *)pCVar6);

+          }

+          else {

+            cVar4 = (*pcVar8)(*(undefined8 **)(this_01 + 0x88),this_01,0,local_res8);

+          }

+        }

+      }

+      else {

+        if (pcVar8 != CColorBrush::IsReadyToDraw) goto LAB_5;

+        cVar4 = CColorBrush::IsReadyToDraw((CColorBrush *)this_01,(CDrawingContext *)0x0,local_res8)

+        ;

+      }

+    }

+    else {

+LAB_5:

+      cVar4 = (*pcVar8)(this_01,0,local_res8);

+    }

+LAB_2:

+    cVar3 = local_res8[0];

+    if (cVar4 == '\0') goto LAB_0;

+  }

+  else if (pcVar8 == CColorBrush::IsEmptyDrawing) {

+    cVar3 = IsCloseRealZero(*(float *)(this_01 + 0x74),1.1920929e-06);

+  }

+  else {

+    cVar3 = (*pcVar8)(this_01);

+  }

+  if (cVar3 == '\0') {

+    return true;

+  }

+LAB_0:

+  if (((**(uint **)(this + 0xe8) & 0x40000) != 0) &&

+     (pvVar7 = CVisual::GetProjectedShadowReceivers((CVisual *)this),

+     *(longlong *)pvVar7 != *(longlong *)(pvVar7 + 8))) {

+    return true;

+  }

+  return false;

+}

+
```

## `std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::_Change_array`  (modified)

```diff
--- std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::_Change_array
+++ std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::_Change_array
@@ -1,2 +1,23 @@
-Failed to decompile dwmcore.dll - .ProgramDB std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::_Change_array : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* private: void __cdecl std::vector<struct CursorVisualData,class std::allocator<struct

+   CursorVisualData> >::_Change_array(struct CursorVisualData * __ptr64 const,unsigned

+   __int64,unsigned __int64) __ptr64 */

+

+void __thiscall

+std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::_Change_array

+          (vector<CursorVisualData,std::allocator<CursorVisualData>_> *this,

+          CursorVisualData *param_1,__uint64 param_2,__uint64 param_3)

+

+{

+  if (*(CursorVisualData **)this != (CursorVisualData *)0x0) {

+    _Destroy_range<std::allocator<CursorVisualData>_>

+              (*(CursorVisualData **)this,*(CursorVisualData **)(this + 8),

+               (allocator<CursorVisualData> *)param_2);

+    _Deallocate<16,0>(*(void **)this,(*(longlong *)(this + 0x10) - *(longlong *)this >> 4) << 4);

+  }

+  *(CursorVisualData **)this = param_1;

+  *(CursorVisualData **)(this + 8) = param_1 + param_2 * 0x30;

+  *(CursorVisualData **)(this + 0x10) = param_1 + param_3 * 0x30;

+  return;

+}

+
```

## `CD3DDevice::CDelayUnpin::CDelayUnpin`  (modified)

```diff
--- CD3DDevice::CDelayUnpin::CDelayUnpin
+++ CD3DDevice::CDelayUnpin::CDelayUnpin
@@ -1,2 +1,35 @@
-Failed to decompile dwmcore.dll - .ProgramDB CD3DDevice::CDelayUnpin::CDelayUnpin : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: __cdecl CD3DDevice::CDelayUnpin::CDelayUnpin(class CD3DDevice::CDelayUnpin const &

+   __ptr64) __ptr64 */

+

+CDelayUnpin * __thiscall

+CD3DDevice::CDelayUnpin::CDelayUnpin(CDelayUnpin *this,CDelayUnpin *param_1)

+

+{

+  undefined8 *puVar1;

+  UnpinTarget *pUVar2;

+  undefined8 *puVar3;

+  

+  wil::com_ptr_t<IMonitorTarget,wil::err_returncode_policy>::

+  com_ptr_t<IMonitorTarget,wil::err_returncode_policy>

+            ((com_ptr_t<IMonitorTarget,wil::err_returncode_policy> *)this,

+             *(IMonitorTarget **)param_1);

+  *(CDelayUnpin **)(this + 8) = this + 0x20;

+  *(CDelayUnpin **)(this + 0x10) = this + 0x20;

+  *(CDelayUnpin **)(this + 0x18) = this + 0x40;

+  puVar1 = *(undefined8 **)(param_1 + 0x10);

+  puVar3 = *(undefined8 **)(param_1 + 8);

+  pUVar2 = detail::

+           vector_facade<CD3DDevice::CDelayUnpin::UnpinTarget,detail::buffer_impl<CD3DDevice::CDelayUnpin::UnpinTarget,2,1,detail::liberal_expansion_policy>_>

+           ::reserve_region((vector_facade<CD3DDevice::CDelayUnpin::UnpinTarget,detail::buffer_impl<CD3DDevice::CDelayUnpin::UnpinTarget,2,1,detail::liberal_expansion_policy>_>

+                             *)(this + 8),0,(longlong)puVar1 - (longlong)puVar3 >> 4);

+  pUVar2 = pUVar2 + 0xc;

+  for (; puVar3 != puVar1; puVar3 = puVar3 + 2) {

+    *(undefined8 *)(pUVar2 + -0xc) = *puVar3;

+    *(undefined4 *)(pUVar2 + -4) = *(undefined4 *)(puVar3 + 1);

+    *(undefined4 *)pUVar2 = *(undefined4 *)((longlong)puVar3 + 0xc);

+    pUVar2 = pUVar2 + 0x10;

+  }

+  return this;

+}

+
```

## `CD3DDevice::DelayUnpinResources`  (modified)

```diff
--- CD3DDevice::DelayUnpinResources
+++ CD3DDevice::DelayUnpinResources
@@ -1,2 +1,64 @@
-Failed to decompile dwmcore.dll - .ProgramDB CD3DDevice::DelayUnpinResources : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: void __cdecl CD3DDevice::DelayUnpinResources(class gsl::span<class ISwapChainRealization

+   * __ptr64,-1>,struct _LUID,unsigned int,unsigned int) __ptr64 */

+

+void __thiscall

+CD3DDevice::DelayUnpinResources

+          (CD3DDevice *this,longlong *param_2,_LUID param_3,uint param_4,uint param_5)

+

+{

+  longlong *plVar1;

+  vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>

+  *this_00;

+  longlong *plVar2;

+  longlong lVar3;

+  char cVar4;

+  CDelayUnpin *this_01;

+  _LUID *this_02;

+  longlong *plVar5;

+  _LUID _Var6;

+  _LUID _Var7;

+  

+  plVar5 = (longlong *)param_2[1];

+  _Var7.HighPart = 0;

+  _Var7.LowPart = param_4;

+  plVar2 = plVar5 + *param_2;

+  _Var6 = param_3;

+  do {

+    if (plVar5 == plVar2) {

+      return;

+    }

+    lVar3 = *plVar5;

+    plVar1 = (longlong *)(lVar3 + 0x10);

+    cVar4 = (**(code **)(*plVar1 + 0x38))(plVar1);

+    if (cVar4 != '\0') {

+      this_00 = (vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>

+                 *)(this + 0x4c0);

+      for (this_02 = *(_LUID **)this_00; this_02 != *(_LUID **)(this + 0x4c8); this_02 = this_02 + 8

+          ) {

+        _Var6 = (_LUID)(-(ulonglong)(lVar3 != 0) & (ulonglong)plVar1);

+        if (*this_02 == _Var6) {

+          CDelayUnpin::AddUnpinTarget((CDelayUnpin *)this_02,param_3,param_4,param_5);

+          return;

+        }

+      }

+      this_01 = detail::

+                vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>

+                ::reserve_region(this_00,(longlong)*(_LUID **)(this + 0x4c8) - *(longlong *)this_00

+                                         >> 6,(__uint64)_Var6);

+      wil::com_ptr_t<IMonitorTarget,wil::err_returncode_policy>::

+      com_ptr_t<IMonitorTarget,wil::err_returncode_policy>

+                ((com_ptr_t<IMonitorTarget,wil::err_returncode_policy> *)this_01,

+                 (IMonitorTarget *)(-(ulonglong)(lVar3 != 0) & (ulonglong)plVar1));

+      *(CDelayUnpin **)(this_01 + 8) = this_01 + 0x20;

+      *(CDelayUnpin **)(this_01 + 0x10) = this_01 + 0x20;

+      *(CDelayUnpin **)(this_01 + 0x18) = this_01 + 0x40;

+      _Var6 = _Var7;

+      CDelayUnpin::AddUnpinTarget(this_01,param_3,param_4,param_5);

+    }

+    plVar5 = plVar5 + 1;

+  } while( true );

+}

+
```

## `std::_Tree<std::_Tmap_traits<unsigned___int64,CCursorState*___ptr64,std::less<unsigned___int64>,std::allocator<std::pair<unsigned___int64_const_,CCursorState*___ptr64>_>,0>_>::_Emplace<std::pair<unsigned___int64,CCursorState*___ptr64>_>`  (modified)

```diff
--- std::_Tree<std::_Tmap_traits<unsigned___int64,CCursorState*___ptr64,std::less<unsigned___int64>,std::allocator<std::pair<unsigned___int64_const_,CCursorState*___ptr64>_>,0>_>::_Emplace<std::pair<unsigned___int64,CCursorState*___ptr64>_>
+++ std::_Tree<std::_Tmap_traits<unsigned___int64,CCursorState*___ptr64,std::less<unsigned___int64>,std::allocator<std::pair<unsigned___int64_const_,CCursorState*___ptr64>_>,0>_>::_Emplace<std::pair<unsigned___int64,CCursorState*___ptr64>_>
@@ -1,2 +1,73 @@
-Failed to decompile dwmcore.dll - .ProgramDB std::_Tree<std::_Tmap_traits<unsigned___int64,CCursorState*___ptr64,std::less<unsigned___int64>,std::allocator<std::pair<unsigned___int64_const_,CCursorState*___ptr64>_>,0>_>::_Emplace<std::pair<unsigned___int64,CCursorState*___ptr64>_> : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* protected: struct std::pair<struct std::_Tree_node<struct std::pair<unsigned __int64 const ,class

+   CCursorState * __ptr64>,void * __ptr64> * __ptr64,bool> __cdecl std::_Tree<class

+   std::_Tmap_traits<unsigned __int64,class CCursorState * __ptr64,struct std::less<unsigned

+   __int64>,class std::allocator<struct std::pair<unsigned __int64 const ,class CCursorState *

+   __ptr64> >,0> >::_Emplace<struct std::pair<unsigned __int64,class CCursorState * __ptr64>

+   >(struct std::pair<unsigned __int64,class CCursorState * __ptr64> && __ptr64) __ptr64 */

+

+pair<unsigned___int64,CCursorState*___ptr64> * __thiscall

+std::

+_Tree<std::_Tmap_traits<unsigned___int64,CCursorState*___ptr64,std::less<unsigned___int64>,std::allocator<std::pair<unsigned___int64_const_,CCursorState*___ptr64>_>,0>_>

+::_Emplace<std::pair<unsigned___int64,CCursorState*___ptr64>_>

+          (_Tree<std::_Tmap_traits<unsigned___int64,CCursorState*___ptr64,std::less<unsigned___int64>,std::allocator<std::pair<unsigned___int64_const_,CCursorState*___ptr64>_>,0>_>

+           *this,pair<unsigned___int64,CCursorState*___ptr64> *param_1)

+

+{

+  undefined8 uVar1;

+  _Tree<std::_Tmap_traits<unsigned___int64,CCursorState*___ptr64,std::less<unsigned___int64>,std::allocator<std::pair<unsigned___int64_const_,CCursorState*___ptr64>_>,0>_>

+  *p_Var2;

+  undefined8 uVar3;

+  undefined8 *puVar4;

+  __uint64 _Var5;

+  _Tree_node<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>,void*___ptr64> *p_Var6;

+  ulonglong *in_R8;

+  ulonglong *puVar7;

+  _Tree<std::_Tmap_traits<unsigned___int64,CCursorState*___ptr64,std::less<unsigned___int64>,std::allocator<std::pair<unsigned___int64_const_,CCursorState*___ptr64>_>,0>_>

+  *local_38;

+  undefined8 uStack_30;

+  longlong local_28;

+  

+  puVar7 = in_R8;

+  puVar4 = (undefined8 *)_Find_lower_bound<unsigned___int64>(this,(__uint64 *)&local_38);

+  local_28 = puVar4[2];

+  p_Var2 = (_Tree<std::_Tmap_traits<unsigned___int64,CCursorState*___ptr64,std::less<unsigned___int64>,std::allocator<std::pair<unsigned___int64_const_,CCursorState*___ptr64>_>,0>_>

+            *)*puVar4;

+  uVar3 = puVar4[1];

+  if ((*(char *)(local_28 + 0x19) == '\0') && (*(ulonglong *)(local_28 + 0x20) <= *puVar7)) {

+    *(longlong *)param_1 = local_28;

+    param_1[8] = (pair<unsigned___int64,CCursorState*___ptr64>)0x0;

+  }

+  else {

+    if (*(longlong *)(this + 8) == 0x555555555555555) {

+                    /* WARNING: Subroutine does not return */

+      _Throw_tree_length_error();

+    }

+    uVar1 = *(undefined8 *)this;

+    local_38 = this;

+    _Var5 = _Get_size_of_n<48>(1);

+    puVar4 = _Allocate<16,std::_Default_allocate_traits,0>(_Var5);

+    uStack_30 = 0;

+    puVar4[4] = *in_R8;

+    puVar4[5] = in_R8[1];

+    *puVar4 = uVar1;

+    puVar4[1] = uVar1;

+    puVar4[2] = uVar1;

+    *(undefined2 *)(puVar4 + 3) = 0;

+    _Alloc_construct_ptr<std::allocator<std::_Tree_node<std::pair<_LUID_const_,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>_>,void*___ptr64>_>_>

+    ::

+    ~_Alloc_construct_ptr<std::allocator<std::_Tree_node<std::pair<_LUID_const_,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>_>,void*___ptr64>_>_>

+              ((_Alloc_construct_ptr<std::allocator<std::_Tree_node<std::pair<_LUID_const_,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>_>,void*___ptr64>_>_>

+                *)&local_38);

+    local_38 = p_Var2;

+    uStack_30 = uVar3;

+    p_Var6 = _Tree_val<std::_Tree_simple_types<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>_>_>

+             ::_Insert_node((_Tree_val<std::_Tree_simple_types<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>_>_>

+                             *)this,&local_38,puVar4);

+    *(_Tree_node<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>,void*___ptr64> **)

+     param_1 = p_Var6;

+    param_1[8] = (pair<unsigned___int64,CCursorState*___ptr64>)0x1;

+  }

+  return param_1;

+}

+
```

## `COcclusionContext::CheckAndRecordOverlayCandidateForContext`  (modified)

```diff
--- COcclusionContext::CheckAndRecordOverlayCandidateForContext
+++ COcclusionContext::CheckAndRecordOverlayCandidateForContext
@@ -1,2 +1,369 @@
-Failed to decompile dwmcore.dll - .ProgramDB COcclusionContext::CheckAndRecordOverlayCandidateForContext : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: long __cdecl COcclusionContext::CheckAndRecordOverlayCandidateForContext(class

+   COverlayContext * __ptr64,class CVisual * __ptr64,class CCompositionSurfaceInfo * __ptr64,class

+   ISwapChainRealization * __ptr64,class CMILMatrix const & __ptr64,class CShape const *

+   __ptr64,struct TMILFlagsEnum<enum MilSourceModification::FlagsEnum>) __ptr64 */

+

+long __thiscall

+COcclusionContext::CheckAndRecordOverlayCandidateForContext

+          (COcclusionContext *this,COverlayContext *param_1,CVisual *param_2,

+          CCompositionSurfaceInfo *param_3,ISwapChainRealization *param_4,CMILMatrix *param_5,

+          CShape *param_6)

+

+{

+  float fVar1;

+  undefined1 uVar2;

+  char cVar3;

+  bool bVar4;

+  int iVar5;

+  CMILMatrix *this_00;

+  undefined8 *puVar6;

+  CMonitorTransform *pCVar7;

+  float *pfVar8;

+  undefined8 uVar9;

+  float fVar10;

+  float fVar11;

+  float fVar12;

+  float fVar13;

+  undefined1 auStackY_288 [32];

+  uint uVar14;

+  bool local_218 [4];

+  float local_214;

+  float local_210 [2];

+  CVisual *local_208;

+  float local_200;

+  float local_1fc;

+  CMILMatrix local_1f8 [64];

+  undefined4 local_1b8;

+  CMILMatrix local_1a8 [64];

+  undefined4 local_168;

+  undefined8 local_158;

+  undefined8 uStack_150;

+  undefined8 local_148;

+  undefined8 uStack_140;

+  undefined8 local_138;

+  float local_130;

+  float local_12c;

+  float local_128 [4];

+  undefined8 local_118;

+  undefined8 uStack_110;

+  undefined8 local_108;

+  undefined8 uStack_100;

+  undefined8 local_f8;

+  undefined8 uStack_f0;

+  undefined8 local_e8;

+  undefined8 uStack_e0;

+  undefined8 local_d8;

+  undefined8 uStack_d0;

+  undefined8 local_c8;

+  undefined8 uStack_c0;

+  undefined8 local_b8;

+  undefined8 uStack_b0;

+  undefined4 local_a8;

+  ulonglong local_98;

+  

+  local_98 = __security_cookie ^ (ulonglong)auStackY_288;

+  iVar5 = 0;

+  local_148 = param_5;

+  local_208 = param_2;

+  local_158 = this;

+  local_138 = param_3;

+  if ((Microsoft_Windows_Dwm_CoreEnableBits._1_1_ & 2) != 0) {

+    local_1b8 = 0;

+    local_128[0] = 0.0;

+    local_128[1] = 0.0;

+    local_128[2] = 0.0;

+    local_128[3] = 0.0;

+    (**(code **)(*(longlong *)(param_4 + 8) + 0x28))(param_4 + 8,local_1f8,local_128);

+    if ((Microsoft_Windows_Dwm_CoreEnableBits._1_1_ & 2) != 0) {

+      local_210[0] = local_128[3] + 6291456.0;

+      local_214 = local_128[2] + 6291456.0;

+      local_200 = local_128[1] + 6291456.0;

+      local_1fc = local_128[0] + 6291456.0;

+      (**(code **)(*(longlong *)param_4 + 0x98))(param_4);

+      (**(code **)(*(longlong *)param_4 + 0x90))(param_4);

+      (**(code **)(*(longlong *)param_3 + 0x70))(param_3);

+      uVar2 = (**(code **)(*(longlong *)param_4 + 0xa8))(param_4);

+      McTemplateU0xdddddddd_EventWriteTransfer

+                (((int)local_1fc << 10) >> 0xb,((int)local_200 << 10) >> 0xb,

+                 CONCAT44((int)((ulonglong)*(longlong *)(local_138 + 0x28) >> 0x20),

+                          *(undefined4 *)(local_138 + 0x28)),uVar2);

+      param_3 = local_138;

+      this = local_158;

+      param_5 = local_148;

+    }

+  }

+  cVar3 = (**(code **)(*(longlong *)param_3 + 0xb8))(param_3);

+  if (cVar3 == '\0') {

+    local_168 = 0;

+    CMatrixStack::Top((CMatrixStack *)(this + 0x20),local_1a8);

+    local_1b8 = 0;

+    CMILMatrix::Multiply(param_5,local_1a8,local_1f8);

+    local_a8 = 0;

+    this_00 = COverlayContext::GetDeviceTransform(param_1);

+    CMILMatrix::Multiply(local_1f8,this_00,(CMILMatrix *)&local_e8);

+    local_214 = 0.0;

+    local_218[0] = true;

+    local_210[0] = 1.4013e-45;

+    bVar4 = CMILMatrix::Is2DAxisAlignedPreserving((CMILMatrix *)&local_e8);

+    if ((!bVar4) ||

+       (bVar4 = COverlayContext::DeriveOverlayRotationParameters

+                          (param_1,(CMILMatrix *)&local_e8,(DXGI_MODE_ROTATION *)local_210,

+                           (uint *)&local_214,local_218), !bVar4)) {

+      if ((Microsoft_Windows_Dwm_CoreEnableBits._1_1_ & 2) == 0) {

+        return 0;

+      }

+      puVar6 = (undefined8 *)

+               (**(code **)(*(longlong *)(param_4 + 0x10) + 0x18))(param_4 + 0x10,&local_208);

+      uVar9 = 1;

+      goto LAB_0;

+    }

+    if ((param_6 != (CShape *)0x0) && (bVar4 = CShape::IsAxisAlignedRectangle(param_6), !bVar4)) {

+      if ((Microsoft_Windows_Dwm_CoreEnableBits._1_1_ & 2) == 0) {

+        return 0;

+      }

+      puVar6 = (undefined8 *)

+               (**(code **)(*(longlong *)(param_4 + 0x10) + 0x18))(param_4 + 0x10,&local_208);

+      uVar9 = 2;

+      iVar5 = 0;

+      goto LAB_0;

+    }

+    local_158 = (COcclusionContext *)0x0;

+    uStack_150 = 0;

+    CBaseClipStack::Top((CBaseClipStack *)(this + 0x80),

+                        (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                         *)&local_158);

+    if (param_6 == (CShape *)0x0) {

+      fVar10 = uStack_150._4_4_;

+      fVar11 = local_158._4_4_;

+      fVar12 = (float)uStack_150;

+      fVar13 = (float)local_158;

+    }

+    else {

+      local_128[0] = 0.0;

+      local_128[1] = 0.0;

+      local_128[2] = 0.0;

+      local_128[3] = 0.0;

+      local_148 = (CMILMatrix *)0x0;

+      uStack_140 = 0;

+      iVar5 = (**(code **)(*(longlong *)param_6 + 0x30))(param_6);

+      if (iVar5 < 0) {

+        uVar14 = 0xb4;

+        goto LAB_1;

+      }

+      CMILMatrix::Transform2DBoundsHelper<0>

+                (local_1a8,(D2D_RECT_F *)local_128,(D2D_RECT_F *)&local_148);

+      fVar13 = (float)local_158;

+      if ((float)local_158 < (float)local_148) {

+        local_158 = (COcclusionContext *)CONCAT44(local_158._4_4_,(float)local_148);

+        fVar13 = (float)local_148;

+      }

+      fVar11 = local_158._4_4_;

+      if (local_158._4_4_ < local_148._4_4_) {

+        local_158 = (COcclusionContext *)CONCAT44(local_148._4_4_,(float)local_158);

+        fVar11 = local_148._4_4_;

+      }

+      fVar12 = (float)uStack_150;

+      if ((float)uStack_140 < (float)uStack_150) {

+        uStack_150 = CONCAT44(uStack_150._4_4_,(float)uStack_140);

+        fVar12 = (float)uStack_140;

+      }

+      fVar10 = uStack_150._4_4_;

+      if (uStack_140._4_4_ < uStack_150._4_4_) {

+        uStack_150 = CONCAT44(uStack_140._4_4_,(float)uStack_150);

+        fVar10 = uStack_140._4_4_;

+      }

+      bVar4 = TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded>::IsEmpty

+                        ((TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded> *)

+                         &local_158);

+      if (bVar4) {

+        uStack_150 = 0;

+        local_158 = (COcclusionContext *)0x0;

+        fVar10 = 0.0;

+        fVar11 = 0.0;

+        fVar12 = 0.0;

+        fVar13 = 0.0;

+      }

+    }

+    pCVar7 = COverlayContext::GetMonitorTransform(param_1);

+    fVar1 = *(float *)(pCVar7 + 8);

+    if (fVar13 < fVar1) {

+      local_158 = (COcclusionContext *)CONCAT44(local_158._4_4_,fVar1);

+      fVar13 = fVar1;

+    }

+    fVar1 = *(float *)(pCVar7 + 0xc);

+    if (fVar11 < fVar1) {

+      local_158 = (COcclusionContext *)CONCAT44(fVar1,(float)local_158);

+      fVar11 = fVar1;

+    }

+    if (*(float *)(pCVar7 + 0x10) <= fVar12 && fVar12 != *(float *)(pCVar7 + 0x10)) {

+      fVar12 = *(float *)(pCVar7 + 0x10);

+      uStack_150 = CONCAT44(uStack_150._4_4_,fVar12);

+    }

+    if (*(float *)(pCVar7 + 0x14) <= fVar10 && fVar10 != *(float *)(pCVar7 + 0x14)) {

+      fVar10 = *(float *)(pCVar7 + 0x14);

+      uStack_150 = CONCAT44(fVar10,(float)uStack_150);

+    }

+    bVar4 = TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded>::IsEmpty

+                      ((TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded> *)&local_158

+                      );

+    if (!bVar4) {

+      local_f8 = 0;

+      uStack_f0 = 0;

+      local_118 = 0;

+      uStack_110 = 0;

+      local_128[0] = 0.0;

+      local_128[1] = 0.0;

+      local_128[2] = 0.0;

+      local_128[3] = 0.0;

+      (**(code **)(*(longlong *)param_4 + 0xe8))(param_4,local_1f8,&local_f8,&local_118);

+      if (fVar13 < (float)local_118) {

+        local_158 = (COcclusionContext *)CONCAT44(local_158._4_4_,(float)local_118);

+        fVar13 = (float)local_118;

+      }

+      if (fVar11 < local_118._4_4_) {

+        local_158 = (COcclusionContext *)CONCAT44(local_118._4_4_,(float)local_158);

+        fVar11 = local_118._4_4_;

+      }

+      if ((float)uStack_110 < fVar12) {

+        uStack_150 = CONCAT44(uStack_150._4_4_,(float)uStack_110);

+        fVar12 = (float)uStack_110;

+      }

+      if (uStack_110._4_4_ < fVar10) {

+        uStack_150 = CONCAT44(uStack_110._4_4_,(float)uStack_150);

+        fVar10 = uStack_110._4_4_;

+      }

+      bVar4 = TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded>::IsEmpty

+                        ((TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded> *)

+                         &local_158);

+      if (bVar4) {

+        fVar10 = 0.0;

+        fVar12 = 0.0;

+        fVar11 = 0.0;

+        fVar13 = 0.0;

+        uStack_150 = 0;

+        local_158 = (COcclusionContext *)0x0;

+      }

+      local_130 = local_128[2];

+      local_12c = local_128[3];

+      fVar1 = local_128[0];

+      if (local_128[0] < fVar13) {

+        fVar1 = fVar13;

+      }

+      fVar13 = local_128[1];

+      if (local_128[1] < fVar11) {

+        fVar13 = fVar11;

+      }

+      local_138 = (CCompositionSurfaceInfo *)CONCAT44(fVar13,fVar1);

+      if (fVar12 < local_128[2]) {

+        local_130 = fVar12;

+      }

+      if (fVar10 < local_128[3]) {

+        local_12c = fVar10;

+      }

+      bVar4 = TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded>::IsEmpty

+                        ((TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded> *)

+                         &local_138);

+      if (bVar4) {

+        local_12c = 0.0;

+        local_130 = 0.0;

+        local_138 = (CCompositionSurfaceInfo *)0x0;

+      }

+      else {

+        local_108 = 0;

+        uStack_100 = 0;

+        CMILMatrix::Transform2DBoundsHelper<0>

+                  (this_00,(D2D_RECT_F *)local_128,(D2D_RECT_F *)&local_108);

+        local_148 = (CMILMatrix *)0x0;

+        uStack_140 = 0;

+        CMILMatrix::Transform2DBoundsHelper<0>

+                  (this_00,(D2D_RECT_F *)&local_158,(D2D_RECT_F *)&local_148);

+        pfVar8 = (float *)COverlayContext::GetVirtualModeClip(param_1);

+        if ((float)local_148 < *pfVar8) {

+          local_148 = (CMILMatrix *)CONCAT44(local_148._4_4_,*pfVar8);

+        }

+        if (local_148._4_4_ < pfVar8[1]) {

+          local_148 = (CMILMatrix *)CONCAT44(pfVar8[1],(float)local_148);

+        }

+        if (pfVar8[2] < (float)uStack_140) {

+          uStack_140 = CONCAT44(uStack_140._4_4_,pfVar8[2]);

+        }

+        if (pfVar8[3] < uStack_140._4_4_) {

+          uStack_140 = CONCAT44(pfVar8[3],(float)uStack_140);

+        }

+        bVar4 = TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded>::IsEmpty

+                          ((TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded> *)

+                           &local_148);

+        if (!bVar4) {

+          local_a8 = CONCAT31(local_a8._1_3_,1);

+          local_e8 = 0;

+          uStack_e0 = 0;

+          local_d8 = 0;

+          uStack_d0 = 0;

+          local_c8 = 0;

+          uStack_c0 = 0;

+          local_b8 = 0;

+          uStack_b0 = 0;

+          pCVar7 = COverlayContext::GetMonitorTransform(param_1);

+          local_158 = (COcclusionContext *)0x0;

+          uStack_150 = 0;

+          CMILMatrix::Transform2DBoundsHelper<0>

+                    ((CMILMatrix *)(pCVar7 + 0x78),(D2D_RECT_F *)&local_148,(D2D_RECT_F *)&local_158

+                    );

+          COccluderClipStack::GetCornerRects

+                    ((COccluderClipStack *)(this + 0x98),

+                     (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                      *)&local_158,(CCornerRects *)&local_e8);

+          cVar3 = (**(code **)(*(longlong *)param_4 + 200))(param_4);

+          fVar13 = local_214;

+          if (cVar3 != '\0') {

+            fVar13 = (float)((uint)local_214 | 8);

+          }

+          iVar5 = COverlayContext::CheckAndRecordOverlayCandidate

+                            (param_1,local_208,

+                             (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                              *)&local_138,param_3,param_4,

+                             (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                              *)&local_f8,

+                             (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                              *)&local_108,

+                             (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                              *)&local_148,(CCornerRects *)&local_e8,local_1a8,

+                             (DXGI_MODE_ROTATION)local_210[0],(uint)fVar13,local_218[0]);

+          if (-1 < iVar5) {

+            return iVar5;

+          }

+          uVar14 = 0xfc;

+LAB_1:

+          MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,iVar5,uVar14,(void *)0x0);

+          return iVar5;

+        }

+        uStack_140 = 0;

+        local_148 = (CMILMatrix *)0x0;

+      }

+    }

+    if ((Microsoft_Windows_Dwm_CoreEnableBits._1_1_ & 2) == 0) {

+      return iVar5;

+    }

+    puVar6 = (undefined8 *)

+             (**(code **)(*(longlong *)(param_4 + 0x10) + 0x18))(param_4 + 0x10,&local_208);

+    uVar9 = 3;

+  }

+  else {

+    if ((Microsoft_Windows_Dwm_CoreEnableBits._1_1_ & 2) == 0) {

+      return 0;

+    }

+    puVar6 = (undefined8 *)

+             (**(code **)(*(longlong *)(param_4 + 0x10) + 0x18))(param_4 + 0x10,&local_208);

+    uVar9 = 8;

+  }

+LAB_0:

+  McTemplateU0xq_EventWriteTransfer

+            (*(undefined4 *)puVar6,&EVTDESC_DISPLAYSURFACE_REJECTCANDIDATE,

+             CONCAT44((int)((ulonglong)*puVar6 >> 0x20),*(undefined4 *)puVar6),uVar9);

+  return iVar5;

+}

+
```

## `CKeyframeAnimation::IsOfType`  (modified)

```diff
--- CKeyframeAnimation::IsOfType
+++ CPrimitiveGroup::IsEmptyDrawing
@@ -1,2 +1,2 @@
-Failed to decompile dwmcore.dll - .ProgramDB CKeyframeAnimation::IsOfType : Error: Decompile error: 
-Low-level Error: findByName unimplemented+Failed to decompile dwmcore.dll - .ProgramDB CPrimitiveGroup::IsEmptyDrawing : Error: Decompile error: 
+Marshaling error: Did not see expected closing element
```

## `CCaptureRenderTarget::UpdateTargetDirty`  (modified)

```diff
--- CCaptureRenderTarget::UpdateTargetDirty
+++ CCaptureRenderTarget::UpdateTargetDirty
@@ -1,2 +1,65 @@
-Failed to decompile dwmcore.dll - .ProgramDB CCaptureRenderTarget::UpdateTargetDirty : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* protected: virtual void __cdecl CCaptureRenderTarget::UpdateTargetDirty(class CTreeDirty const &

+   __ptr64,bool) __ptr64 */

+

+void __thiscall

+CCaptureRenderTarget::UpdateTargetDirty(CCaptureRenderTarget *this,CTreeDirty *param_1,bool param_2)

+

+{

+  CMergedRectBase<4> *this_00;

+  longlong lVar1;

+  bool bVar2;

+  bool bVar3;

+  span<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>_const_,_1>

+  *psVar4;

+  

+  CTargetDirtyBase<8>::AddDirtyRegionAndCalcOcclusion((CTargetDirtyBase<8> *)(this + 0x140),param_1)

+  ;

+  if ((this[0xb54] == (CCaptureRenderTarget)0x0) || (bVar3 = true, *(int *)(this + 0xc4) != 1)) {

+    bVar3 = false;

+  }

+  bVar2 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>::

+          __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor> *)

+                              &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DesktopDWMCursor>::GetImpl(void)'

+                               ::__l2::impl);

+  if (bVar2) {

+    UpdateCursorDirty(this,bVar3,param_2);

+  }

+  else if ((bVar3 != false) || (*(int *)(this + 0x150) != 0)) {

+    this_00 = (CMergedRectBase<4> *)(this + 0xaa8);

+    if (*(int *)this_00 != 0) {

+      psVar4 = (span<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>_const_,_1>

+                *)CMergedRectBase<4>::GetRects(this_00);

+      CTargetDirtyBase<8>::AddDirtyRects((CTargetDirtyBase<8> *)(this + 0x140),psVar4);

+      CMergedRectBase<4>::Reset(this_00);

+    }

+    if (bVar3 != false) {

+      AddCursorInvalidRects(this);

+    }

+  }

+  if (param_2) {

+    lVar1 = *(longlong *)(this + 0xc08);

+    if (lVar1 != *(longlong *)(this + 0xc10)) {

+      *(longlong *)(this + 0xc10) = lVar1;

+    }

+    if (*(int *)(this + 0x150) != 0) {

+      if (*(CRegion **)(this + 0x310) != (CRegion *)0x0) {

+        CRegion::GetRectangles

+                  (*(CRegion **)(this + 0x310),

+                   (vector<tagRECT,std::allocator<tagRECT>_> *)(this + 0xc08));

+      }

+      if (*(int *)(this + 0xb0) != 2) {

+        CTargetDirtyBase<8>::SetFullDirty((CTargetDirtyBase<8> *)(this + 0x140));

+      }

+    }

+  }

+  bVar3 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>::

+          __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor> *)

+                              &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DesktopDWMCursor>::GetImpl(void)'

+                               ::__l2::impl);

+  if ((!bVar3) || (param_2)) {

+    this[0xb54] = (CCaptureRenderTarget)0x0;

+  }

+  return;

+}

+
```

## `CPrimitiveGroupRenderStrategy::GetTextureMemoryLayoutData`  (modified)

```diff
--- CPrimitiveGroupRenderStrategy::GetTextureMemoryLayoutData
+++ CPrimitiveGroupRenderStrategy::GetTextureMemoryLayoutData
@@ -1,2 +1,94 @@
-Failed to decompile dwmcore.dll - .ProgramDB CPrimitiveGroupRenderStrategy::GetTextureMemoryLayoutData : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: virtual long __cdecl CPrimitiveGroupRenderStrategy::GetTextureMemoryLayoutData(class

+   CSurfaceBrush const * __ptr64,struct D2D_SIZE_F const & __ptr64,class std::vector<struct

+   CContent::LayoutData,class std::allocator<struct CContent::LayoutData> > & __ptr64)const __ptr64

+    */

+

+long __thiscall

+CPrimitiveGroupRenderStrategy::GetTextureMemoryLayoutData

+          (CPrimitiveGroupRenderStrategy *this,CSurfaceBrush *param_1,D2D_SIZE_F *param_2,

+          vector<CContent::LayoutData,std::allocator<CContent::LayoutData>_> *param_3)

+

+{

+  void *pvVar1;

+  longlong lVar2;

+  longlong lVar3;

+  int iVar4;

+  CResource *pCVar5;

+  Matrix3x2F *pMVar6;

+  int iVar7;

+  ulonglong uVar8;

+  undefined1 auStackY_b8 [32];

+  uint uVar9;

+  void *local_88;

+  longlong lStack_80;

+  longlong local_78;

+  undefined8 local_70;

+  undefined8 uStack_68;

+  undefined8 local_60;

+  undefined8 local_58;

+  undefined8 uStack_50;

+  undefined8 local_48;

+  undefined8 uStack_40;

+  undefined8 local_38;

+  ulonglong local_30;

+  

+  local_30 = __security_cookie ^ (ulonglong)auStackY_b8;

+  if (*(longlong *)param_3 != *(longlong *)(param_3 + 8)) {

+    *(longlong *)(param_3 + 8) = *(longlong *)param_3;

+  }

+  local_78 = 0;

+  local_58 = 0;

+  uStack_50 = 0;

+  local_38 = 0;

+  local_48 = 0;

+  uStack_40 = 0;

+  local_88 = (void *)0x0;

+  lStack_80 = 0;

+  pCVar5 = CSurfaceBrush::GetSurface(param_1);

+  iVar4 = CSurfaceBrush::ComputeLayout(param_1,param_2,(LayoutData *)&local_58,(CShape **)0x0);

+  if (iVar4 < 0) {

+    uVar9 = 0x6f0;

+  }

+  else {

+    iVar4 = (**(code **)(*(longlong *)pCVar5 + 0x120))(pCVar5);

+    if (-1 < iVar4) {

+      uVar8 = 0;

+      if ((lStack_80 - (longlong)local_88 >> 3) * -0x3333333333333333 != 0) {

+        do {

+          iVar7 = (int)uVar8;

+          pMVar6 = (Matrix3x2F *)((longlong)local_88 + uVar8 * 0x28);

+          D2D1::Matrix3x2F::SetProduct((Matrix3x2F *)&local_70,(Matrix3x2F *)&local_58,pMVar6);

+          uVar8 = (ulonglong)(iVar7 + 1);

+          *(undefined8 *)pMVar6 = local_70;

+          *(undefined8 *)(pMVar6 + 8) = uStack_68;

+          *(undefined8 *)(pMVar6 + 0x10) = local_60;

+        } while (uVar8 < (ulonglong)((lStack_80 - (longlong)local_88 >> 3) * -0x3333333333333333));

+      }

+      if (param_3 != (vector<CContent::LayoutData,std::allocator<CContent::LayoutData>_> *)&local_88

+         ) {

+        pvVar1 = *(void **)param_3;

+        *(void **)param_3 = local_88;

+        lVar2 = *(longlong *)(param_3 + 8);

+        *(longlong *)(param_3 + 8) = lStack_80;

+        lVar3 = *(longlong *)(param_3 + 0x10);

+        *(longlong *)(param_3 + 0x10) = local_78;

+        local_88 = pvVar1;

+        lStack_80 = lVar2;

+        local_78 = lVar3;

+      }

+      goto LAB_0;

+    }

+    uVar9 = 0x6f1;

+  }

+  MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,iVar4,uVar9,(void *)0x0);

+LAB_0:

+  if (local_88 != (void *)0x0) {

+    std::_Deallocate<16,0>(local_88,(local_78 - (longlong)local_88 >> 3) << 3);

+  }

+  return iVar4;

+}

+
```

## `CEffectBrush::IsReadyToDraw`  (modified)

```diff
--- CEffectBrush::IsReadyToDraw
+++ CEffectBrush::IsReadyToDraw
@@ -1,2 +1,116 @@
-Failed to decompile dwmcore.dll - .ProgramDB CEffectBrush::IsReadyToDraw : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: virtual bool __cdecl CEffectBrush::IsReadyToDraw(class CDrawingContext * __ptr64,bool *

+   __ptr64)const __ptr64 */

+

+bool __thiscall

+CEffectBrush::IsReadyToDraw(CEffectBrush *this,CDrawingContext *param_1,bool *param_2)

+

+{

+  uint uVar1;

+  code *pcVar2;

+  CSurfaceBrush *this_00;

+  bool bVar3;

+  char cVar4;

+  longlong lVar5;

+  CDrawingContext *pCVar6;

+  CResource *pCVar7;

+  ulonglong uVar8;

+  bool local_res8 [8];

+  IBitmapResource *local_res18 [2];

+  

+  *param_2 = false;

+  if ((*(longlong **)(this + 0x80) == (longlong *)0x0) ||

+     (lVar5 = (**(code **)(**(longlong **)(this + 0x80) + 0x40))(), lVar5 == 0)) {

+    return false;

+  }

+  if ((param_1 != (CDrawingContext *)0x0) && (param_1[0x1f00] != (CDrawingContext)0x0)) {

+    if (param_1[0x1f01] == (CDrawingContext)0x0) {

+      lVar5 = *(longlong *)(param_1 + 0x1f10);

+    }

+    else {

+      lVar5 = *(longlong *)(param_1 + 0xc90);

+    }

+    if (lVar5 != 0) {

+      pCVar6 = param_1 + 0xc90;

+      if (param_1[0x1f01] == (CDrawingContext)0x0) {

+        pCVar6 = param_1 + 0x1f10;

+      }

+      pcVar2 = *(code **)(**(longlong **)pCVar6 + 0xe0);

+      if (pcVar2 == CLayerVisual::GetTreeEffect) {

+        lVar5 = (*(longlong **)pCVar6)[0x56];

+      }

+      else {

+        lVar5 = (*pcVar2)();

+      }

+      if ((lVar5 != 0) && (*(longlong *)(lVar5 + 8) != 0)) {

+        bVar3 = true;

+        goto LAB_0;

+      }

+    }

+  }

+  bVar3 = false;

+LAB_0:

+  uVar1 = *(uint *)(this + 0xa0);

+  uVar8 = 0;

+  do {

+    if (uVar1 <= (uint)uVar8) {

+      return true;

+    }

+    this_00 = *(CSurfaceBrush **)(*(longlong *)(this + 0x88) + uVar8 * 8);

+    if (this_00 == (CSurfaceBrush *)0x0) {

+      if (!bVar3) {

+        return false;

+      }

+    }

+    else {

+      local_res8[0] = false;

+      pcVar2 = *(code **)(*(longlong *)this_00 + 0x138);

+      if (pcVar2 == CSurfaceBrush::IsReadyToDraw) {

+        pcVar2 = *(code **)**(undefined8 **)(this_00 + 0x88);

+        if (pcVar2 == CBitmapRenderStrategy::IsReadyToDraw) {

+          local_res18[0] = (IBitmapResource *)0x0;

+          wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::reset

+                    ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)local_res18);

+          CBitmapRenderStrategy::GetBitmap(this_00,local_res18);

+          cVar4 = CBitmapRenderStrategy::HasRenderingRealization(local_res18[0]);

+          wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::

+          ~com_ptr_t<IBitmapResource,wil::err_returncode_policy>

+                    ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)local_res18);

+        }

+        else if (pcVar2 == CPrimitiveGroupRenderStrategy::IsReadyToDraw) {

+          pCVar7 = CSurfaceBrush::GetSurface(this_00);

+          if (*(code **)(*(longlong *)pCVar7 + 0xd8) == CPrimitiveGroup::IsEmptyDrawing) {

+            CPrimitiveGroup::IsEmptyDrawing((CPrimitiveGroup *)pCVar7);

+          }

+          else {

+            (**(code **)(*(longlong *)pCVar7 + 0xd8))();

+          }

+          cVar4 = '\x01';

+        }

+        else if (pcVar2 == CVisualSurfaceRenderStrategy::IsReadyToDraw) {

+          pCVar7 = CSurfaceBrush::GetSurface(this_00);

+          cVar4 = CVisualSurface::HasSomethingToDraw((CVisualSurface *)pCVar7);

+        }

+        else {

+          cVar4 = (*pcVar2)(*(undefined8 **)(this_00 + 0x88),this_00,param_1,local_res8);

+        }

+      }

+      else if (pcVar2 == CColorBrush::IsReadyToDraw) {

+        cVar4 = CColorBrush::IsReadyToDraw((CColorBrush *)this_00,param_1,local_res8);

+      }

+      else if (pcVar2 == IsReadyToDraw) {

+        cVar4 = IsReadyToDraw((CEffectBrush *)this_00,param_1,local_res8);

+      }

+      else {

+        cVar4 = (*pcVar2)();

+      }

+      if (cVar4 == '\0') {

+        return false;

+      }

+    }

+    uVar8 = (ulonglong)((uint)uVar8 + 1);

+  } while( true );

+}

+
```

## `CCompositionDynamicTexture::SetDirtyRects`  (modified)

```diff
--- CCompositionDynamicTexture::SetDirtyRects
+++ CCompositionDynamicTexture::SetDirtyRects
@@ -1,2 +1,94 @@
-Failed to decompile dwmcore.dll - .ProgramDB CCompositionDynamicTexture::SetDirtyRects : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: long __cdecl CCompositionDynamicTexture::SetDirtyRects(class gsl::span<class

+   TMilRect_<int,struct tagRECT,struct D2D_POINTANDSIZE_L,struct Mil3DRectL,struct

+   RectUniqueness::_CMilRectL_> const ,-1> const & __ptr64) __ptr64 */

+

+long __thiscall

+CCompositionDynamicTexture::SetDirtyRects

+          (CCompositionDynamicTexture *this,

+          span<TMilRect_<int,tagRECT,D2D_POINTANDSIZE_L,Mil3DRectL,RectUniqueness::_CMilRectL_>_const_,_1>

+          *param_1)

+

+{

+  undefined8 uVar1;

+  undefined8 *puVar2;

+  bool bVar3;

+  TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded> *pTVar4;

+  longlong lVar5;

+  vector_facade<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,detail::buffer_impl<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,1,1,detail::liberal_expansion_policy>_>

+  *this_00;

+  undefined8 *puVar6;

+  int *piVar7;

+  int *piVar8;

+  undefined1 auStack_b8 [32];

+  int local_98 [4];

+  D2D_RECT_F local_88 [16];

+  undefined **local_78;

+  undefined8 local_70;

+  undefined8 *local_68;

+  undefined8 *local_60;

+  undefined8 *local_58;

+  undefined8 local_50 [2];

+  undefined8 local_40;

+  ulonglong local_38;

+  

+  local_38 = __security_cookie ^ (ulonglong)auStack_b8;

+  local_70 = 0;

+  local_40 = 0;

+  local_78 = &CRectanglesShape::_vftable_;

+  local_68 = local_50;

+  local_60 = local_50;

+  local_58 = &local_40;

+  Microsoft::WRL::ComPtr<CPathData>::operator=

+            ((ComPtr<CPathData> *)(this + 0x60),(ComPtr<class_CPathData> *)&local_70);

+  puVar2 = local_60;

+  puVar6 = local_68;

+  this_00 = (vector_facade<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,detail::buffer_impl<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,1,1,detail::liberal_expansion_policy>_>

+             *)(this + 0x68);

+  if ((vector_facade<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,detail::buffer_impl<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,1,1,detail::liberal_expansion_policy>_>

+       *)&local_68 != this_00) {

+    detail::

+    vector_facade<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,detail::buffer_impl<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,1,1,detail::liberal_expansion_policy>_>

+    ::clear(this_00);

+    pTVar4 = detail::

+             vector_facade<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,detail::buffer_impl<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,1,1,detail::liberal_expansion_policy>_>

+             ::reserve_region(this_00,0,(longlong)puVar2 - (longlong)puVar6 >> 4);

+    for (; puVar6 != puVar2; puVar6 = puVar6 + 2) {

+      uVar1 = puVar6[1];

+      *(undefined8 *)pTVar4 = *puVar6;

+      *(undefined8 *)(pTVar4 + 8) = uVar1;

+      pTVar4 = pTVar4 + 0x10;

+    }

+  }

+  *(undefined8 *)(this + 0x90) = local_40;

+  CRectanglesShape::~CRectanglesShape((CRectanglesShape *)&local_78);

+  piVar7 = *(int **)(param_1 + 8);

+  piVar8 = piVar7 + *(longlong *)param_1 * 4;

+  for (; piVar7 != piVar8; piVar7 = piVar7 + 4) {

+    local_98[0] = *piVar7;

+    local_98[1] = piVar7[1];

+    local_98[2] = piVar7[2];

+    local_98[3] = piVar7[3];

+    if ((*piVar7 <= (int)*(undefined8 *)(piVar7 + 2)) &&

+       (piVar7[1] <= (int)((ulonglong)*(undefined8 *)(piVar7 + 2) >> 0x20))) {

+      lVar5 = 0;

+      do {

+        *(float *)(local_88 + lVar5) = (float)*(int *)((longlong)local_98 + lVar5);

+        lVar5 = lVar5 + 4;

+      } while (lVar5 < 0x10);

+      CRectanglesShape::AddRect((CRectanglesShape *)(this + 0x58),local_88);

+    }

+  }

+  bVar3 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2>::__private_IsEnabled

+                    ((FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2> *)

+                     &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DCompChromiumK2>::GetImpl(void)'

+                      ::__l2::impl);

+  if (bVar3) {

+    this[0x98] = (CCompositionDynamicTexture)(*(longlong *)param_1 == 0);

+  }

+  CResource::NotifyOnChanged

+            ((CResource *)this,-(uint)(*(longlong *)param_1 != 0) & 0x10,(IUnknown *)this);

+  return 0;

+}

+
```

## `Microsoft::WRL::ComPtr<CDrawListCache>::InternalRelease`  (modified)

```diff
--- Microsoft::WRL::ComPtr<CDrawListCache>::InternalRelease
+++ CMILMatrix::Multiply
@@ -1,2 +1,2 @@
-Failed to decompile dwmcore.dll - .ProgramDB Microsoft::WRL::ComPtr<CDrawListCache>::InternalRelease : Error: Decompile error: 
+Failed to decompile dwmcore.dll - .ProgramDB CMILMatrix::Multiply : Error: Decompile error: 
 Marshaling error: Did not see expected closing element
```

## `CLegacySwapChain::CheckMultiplaneOverlaySupport`  (modified)

```diff
--- CLegacySwapChain::CheckMultiplaneOverlaySupport
+++ CLegacySwapChain::CheckMultiplaneOverlaySupport
@@ -1,110 +1,121 @@
 

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

 /* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

    guard_dispatch_icall */

+/* public: virtual bool __cdecl CLegacySwapChain::CheckMultiplaneOverlaySupport(struct

+   DWM_CHECK_MULTIPLANE_OVERLAY_SUPPORT_PLANE_INFO const * __ptr64,unsigned int,bool * __ptr64)const

+   __ptr64 */

 

 bool __thiscall

-CVisualTree::CheckMultiplaneOverlaySupport

+CLegacySwapChain::CheckMultiplaneOverlaySupport

           (CLegacySwapChain *this,DWM_CHECK_MULTIPLANE_OVERLAY_SUPPORT_PLANE_INFO *param_1,

           uint param_2,bool *param_3)

 

 {

-  undefined1 uVar1;

-  BOOL BVar2;

-  long lVar3;

-  char *in_RAX;

-  char *pcVar4;

-  code *pcVar5;

-  code *extraout_RAX;

-  FailureInfo *unaff_RBX;

-  int unaff_EBP;

-  undefined4 unaff_ESI;

-  char cVar6;

-  char *unaff_RDI;

-  undefined8 unaff_R12;

-  LPCWSTR unaff_R14;

-  bool bVar7;

-  undefined8 in_XMM0_Qa;

-  undefined8 in_XMM0_Qb;

-  char *in_stack_000000e0;

+  ulonglong uVar1;

+  void *pvVar2;

+  bool bVar3;

+  int iVar4;

+  undefined8 *puVar5;

+  ulonglong uVar6;

+  undefined1 auStackY_1c8 [32];

+  bool local_198 [4];

+  int local_194;

+  int local_190;

+  void *local_188;

+  undefined8 uStack_180;

+  longlong local_178;

+  DWM_CHECK_MULTIPLANE_OVERLAY_SUPPORT_PLANE_INFO local_170 [152];

+  undefined8 local_d8;

+  undefined8 uStack_d0;

+  undefined8 local_c8;

+  undefined8 uStack_c0;

+  undefined8 local_b8;

+  undefined8 uStack_b0;

+  undefined8 local_a8;

+  undefined8 uStack_a0;

+  undefined8 local_98;

+  undefined8 uStack_90;

+  undefined8 local_88;

+  undefined8 uStack_80;

+  undefined8 local_78;

+  undefined8 uStack_70;

+  undefined8 uStack_68;

+  undefined8 uStack_60;

+  undefined8 uStack_58;

+  undefined8 uStack_50;

+  ulonglong local_48;

   

-  *in_RAX = *in_RAX + (char)in_RAX;

-  *(undefined4 *)(unaff_RBX + 0x44) = unaff_ESI;

-  *(undefined8 *)(unaff_RBX + 0x30) = unaff_R12;

-  *(char **)(unaff_RBX + 0x48) = unaff_RDI;

-  *(undefined8 *)(unaff_RBX + 0x68) = in_XMM0_Qa;

-  *(undefined8 *)(unaff_RBX + 0x70) = in_XMM0_Qb;

-  *(undefined8 *)(unaff_RBX + 0x78) = 0;

-  *(undefined8 *)(unaff_RBX + 0x50) = in_XMM0_Qa;

-  *(undefined8 *)(unaff_RBX + 0x58) = in_XMM0_Qb;

-  *(undefined8 *)(unaff_RBX + 0x60) = 0;

-  pcVar4 = unaff_RDI;

-  if (wil::details::g_pfnGetModuleName != (_func_char_ptr *)0x0) {

-    pcVar4 = (*wil::details::g_pfnGetModuleName)();

-  }

-  *(char **)(unaff_RBX + 0x80) = pcVar4;

-  if (wil::details::g_pfnNotifyFailure != (_func_void_FailureInfo_ptr *)0x0) {

-    (*wil::details::g_pfnNotifyFailure)(unaff_RBX);

-  }

-  if (wil::details::g_pfnGetContextAndNotifyFailure !=

-      (_func_void_FailureInfo_ptr_char_ptr___uint64 *)0x0) {

-    (*wil::details::g_pfnGetContextAndNotifyFailure)(unaff_RBX,in_stack_000000e0,0x400);

-  }

-  if (wil::details::g_pfnLoggingCallback != (_func_void_FailureInfo_ptr *)0x0) {

-    (*wil::details::g_pfnLoggingCallback)(unaff_RBX);

-  }

-  if ((wil::details::g_pfnOriginateCallback != (_func_void_FailureInfo_ptr *)0x0) &&

-     (((byte)unaff_RBX[4] & 2) == 0)) {

-    (*wil::details::g_pfnOriginateCallback)(unaff_RBX);

-  }

-  if ((int)unaff_RDI <= *(int *)(unaff_RBX + 8)) {

-    if (unaff_EBP != 3) {

-                    /* WARNING: Subroutine does not return */

-      wil::details::in1diag3::_FailFastImmediate_Unexpected();

+  local_48 = __security_cookie ^ (ulonglong)auStackY_1c8;

+  *param_3 = false;

+  uVar1 = (ulonglong)param_2;

+  if ((*(longlong *)(this + 0x108) != 0) && (0 < *(int *)(this + 0x40))) {

+    local_198[0] = false;

+    bVar3 = CD3DDevice::CheckMPOCache(*(CD3DDevice **)(this + 0x28),param_1,param_2,local_198);

+    if (bVar3) {

+      return local_198[0];

     }

-    *(undefined4 *)(unaff_RBX + 8) = 0x8000ffff;

-    lVar3 = wil::details::HrToNtStatus(-0x7fff0001);

-    *(long *)(unaff_RBX + 0xc) = lVar3;

-  }

-  cVar6 = (char)unaff_RDI;

-  if (wil::g_fIsDebuggerPresent == (bool)cVar6) {

-    if (wil::g_pfnIsDebuggerPresent == (_func_bool *)0x0) {

-      BVar2 = IsDebuggerPresent();

-      bVar7 = BVar2 == 0;

+    local_178 = 0;

+    local_188 = (void *)0x0;

+    uStack_180 = 0;

+    std::

+    vector<DXGI_CHECK_MULTIPLANEOVERLAYSUPPORT_PLANE_INFO,std::allocator<DXGI_CHECK_MULTIPLANEOVERLAYSUPPORT_PLANE_INFO>_>

+    ::reserve((vector<DXGI_CHECK_MULTIPLANEOVERLAYSUPPORT_PLANE_INFO,std::allocator<DXGI_CHECK_MULTIPLANEOVERLAYSUPPORT_PLANE_INFO>_>

+               *)&local_188,uVar1);

+    uVar6 = uVar1;

+    if (param_2 != 0) {

+      do {

+        puVar5 = (undefined8 *)DXGIPlaneFromDwmPlane(local_170);

+        local_d8 = *puVar5;

+        uStack_d0 = puVar5[1];

+        local_c8 = puVar5[2];

+        uStack_c0 = puVar5[3];

+        local_b8 = puVar5[4];

+        uStack_b0 = puVar5[5];

+        local_a8 = puVar5[6];

+        uStack_a0 = puVar5[7];

+        local_98 = puVar5[8];

+        uStack_90 = puVar5[9];

+        local_88 = puVar5[10];

+        uStack_80 = puVar5[0xb];

+        local_78 = puVar5[0xc];

+        uStack_70 = puVar5[0xd];

+        uStack_68 = puVar5[0xe];

+        uStack_60 = puVar5[0xf];

+        uStack_58 = puVar5[0x10];

+        uStack_50 = puVar5[0x11];

+        std::

+        vector<DXGI_CHECK_MULTIPLANEOVERLAYSUPPORT_PLANE_INFO,std::allocator<DXGI_CHECK_MULTIPLANEOVERLAYSUPPORT_PLANE_INFO>_>

+        ::emplace_back<DXGI_CHECK_MULTIPLANEOVERLAYSUPPORT_PLANE_INFO>

+                  ((vector<DXGI_CHECK_MULTIPLANEOVERLAYSUPPORT_PLANE_INFO,std::allocator<DXGI_CHECK_MULTIPLANEOVERLAYSUPPORT_PLANE_INFO>_>

+                    *)&local_188,(DXGI_CHECK_MULTIPLANEOVERLAYSUPPORT_PLANE_INFO *)&local_d8);

+        uVar6 = uVar6 - 1;

+      } while (uVar6 != 0);

     }

-    else {

-      bVar7 = (*wil::g_pfnIsDebuggerPresent)();

-      bVar7 = !bVar7;

+    pvVar2 = local_188;

+    local_194 = 0;

+    local_190 = 0;

+    iVar4 = (**(code **)(**(longlong **)(this + 0x108) + 0xb0))

+                      (*(longlong **)(this + 0x108),uVar1,local_188,&local_194);

+    if (-1 < iVar4) {

+      bVar3 = local_194 == 1;

+      if (local_190 == 0) {

+        CD3DDevice::AddCheckMPOCache(*(CD3DDevice **)(this + 0x28),param_1,param_2,bVar3);

+      }

+      else {

+        *param_3 = true;

+      }

+      if (pvVar2 == (void *)0x0) {

+        return bVar3;

+      }

+      std::_Deallocate<16,0>(pvVar2,(local_178 - (longlong)pvVar2 >> 4) << 4);

+      return bVar3;

     }

-    if (!bVar7) goto LAB_0;

-  }

-  else {

-LAB_0:

-    if (((byte)unaff_RBX[4] & 2) == 0) {

-      if ((g_pfnResultLoggingCallback != (code *)0x0) &&

-         (wil::details::g_resultMessageCallbackSet == (bool)cVar6)) {

-        (*g_pfnResultLoggingCallback)();

-        uVar1 = FUN_1802f16f8();

-        return (bool)uVar1;

-      }

-      if (*unaff_R14 == (WCHAR)unaff_RDI) {

-        wil::GetFailureLogString((ushort *)unaff_R14,0x800,unaff_RBX);

-      }

-      OutputDebugStringW(unaff_R14);

-      pcVar5 = extraout_RAX;

-      goto LAB_1;

+    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,iVar4,0x1da,(void *)0x0);

+    if (pvVar2 != (void *)0x0) {

+      std::_Deallocate<16,0>(pvVar2,(local_178 - (longlong)pvVar2 >> 4) << 4);

     }

   }

-  pcVar5 = g_pfnResultLoggingCallback;

-  if ((g_pfnResultLoggingCallback != (code *)0x0) &&

-     (wil::details::g_resultMessageCallbackSet == (bool)cVar6)) {

-    pcVar5 = (code *)(*g_pfnResultLoggingCallback)();

-  }

-LAB_1:

-  uVar1 = SUB81(pcVar5,0);

-  if (((((byte)unaff_RBX[4] & 4) != 0) || (wil::g_fBreakOnFailure != (bool)cVar6)) &&

-     (uVar1 = 0, wil::details::g_pfnDebugBreak != (_func_void *)0x0)) {

-    uVar1 = (*wil::details::g_pfnDebugBreak)();

-  }

-  return (bool)uVar1;

+  return false;

 }
```

## `CBitmapRenderStrategy::GetBitmap`  (modified)

```diff
--- CBitmapRenderStrategy::GetBitmap
+++ CBitmapRenderStrategy::GetBitmap
@@ -1,2 +1,35 @@
-Failed to decompile dwmcore.dll - .ProgramDB CBitmapRenderStrategy::GetBitmap : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: static void __cdecl CBitmapRenderStrategy::GetBitmap(class CSurfaceBrush const *

+   __ptr64,class IBitmapResource * __ptr64 * __ptr64) */

+

+void __cdecl CBitmapRenderStrategy::GetBitmap(CSurfaceBrush *param_1,IBitmapResource **param_2)

+

+{

+  bool bVar1;

+  CResource *this;

+  

+  this = CSurfaceBrush::GetSurface(param_1);

+  if ((code *)**(undefined8 **)this ==

+      CMILCOMBaseWeakRefSource<CResourceDeleter>::InternalQueryInterface) {

+    if (param_2 != (IBitmapResource **)0x0) {

+      bVar1 = operator==((_GUID *)&_GUID_b35f2031_4b76_4d4e_b98c_6771dfcc753c,

+                         (_GUID *)&_GUID_73f2a332_aba0_4b29_88bc_6ee79b3941bc);

+      if (!bVar1) {

+        CMILCOMBaseT<IUnknownWeakRefSource,IUnknownWeakRefSource,CResourceDeleter>::

+        InternalQueryInterface

+                  ((CMILCOMBaseT<IUnknownWeakRefSource,IUnknownWeakRefSource,CResourceDeleter> *)

+                   this,(_GUID *)&_GUID_b35f2031_4b76_4d4e_b98c_6771dfcc753c,param_2);

+        return;

+      }

+      *param_2 = (IBitmapResource *)this;

+      CMILRefCountImpl::AddReference((CMILRefCountImpl *)(this + 8));

+    }

+  }

+  else {

+    (*(code *)**(undefined8 **)this)(this,&_GUID_b35f2031_4b76_4d4e_b98c_6771dfcc753c,param_2);

+  }

+  return;

+}

+
```

## `CSwapchainRenderStrategy::GetLayoutParameters`  (modified)

```diff
--- CSwapchainRenderStrategy::GetLayoutParameters
+++ CSwapchainRenderStrategy::GetLayoutParameters
@@ -1,2 +1,138 @@
-Failed to decompile dwmcore.dll - .ProgramDB CSwapchainRenderStrategy::GetLayoutParameters : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: virtual long __cdecl CSwapchainRenderStrategy::GetLayoutParameters(class CSurfaceBrush

+   const * __ptr64,struct D2D_SIZE_F const & __ptr64,struct D2D_SIZE_F * __ptr64,struct D2D_RECT_F *

+   __ptr64,struct D2D_MATRIX_3X2_F * __ptr64)const __ptr64 */

+

+long __thiscall

+CSwapchainRenderStrategy::GetLayoutParameters

+          (CSwapchainRenderStrategy *this,CSurfaceBrush *param_1,D2D_SIZE_F *param_2,

+          D2D_SIZE_F *param_3,D2D_RECT_F *param_4,D2D_MATRIX_3X2_F *param_5)

+

+{

+  undefined8 uVar1;

+  code *pcVar2;

+  char cVar3;

+  bool bVar4;

+  int iVar5;

+  CResource *this_00;

+  float *pfVar6;

+  float fVar7;

+  float fVar8;

+  float fVar9;

+  float fVar10;

+  undefined1 auStackY_118 [32];

+  uint uVar11;

+  IBitmapRealization *local_e8 [2];

+  undefined4 local_d8;

+  undefined4 local_d4;

+  undefined4 local_c8;

+  undefined4 local_c4;

+  undefined4 local_a8;

+  undefined4 local_a4;

+  undefined4 local_98;

+  float local_88 [5];

+  undefined4 uStack_74;

+  undefined8 local_70;

+  undefined8 uStack_68;

+  float local_60 [10];

+  ulonglong local_38;

+  

+  local_38 = __security_cookie ^ (ulonglong)auStackY_118;

+  local_98 = 0;

+  local_88[0] = 0.0;

+  local_88[1] = 0.0;

+  local_88[2] = 0.0;

+  local_88[3] = 0.0;

+  local_70 = 0;

+  uStack_68 = 0;

+  local_60[0] = 0.0;

+  local_60[1] = 0.0;

+  local_60[2] = 0.0;

+  local_60[3] = 0.0;

+  this_00 = CSurfaceBrush::GetSurface(param_1);

+  local_e8[0] = (IBitmapRealization *)0x0;

+  pcVar2 = *(code **)(*(longlong *)(this_00 + 0x48) + 0x40);

+  if (pcVar2 == CCompositionSurfaceBitmap::GetCurrentRenderingRealization) {

+    iVar5 = CCompositionSurfaceBitmap::GetCurrentRenderingRealization

+                      ((CCompositionSurfaceBitmap *)(this_00 + 0x48),local_e8);

+  }

+  else {

+    iVar5 = (*pcVar2)();

+  }

+  if (iVar5 < 0) {

+    uVar11 = 0x513;

+  }

+  else {

+    cVar3 = (**(code **)(*(longlong *)local_e8[0] + 0x28))(local_e8[0],&local_d8,&local_70);

+    bVar4 = CCompositionSurfaceBitmap::GetScaledLetterboxingMargins

+                      ((CCompositionSurfaceBitmap *)this_00,

+                       (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                        *)local_60);

+    if (bVar4) {

+      CMILMatrix::PrependTranslate((CMILMatrix *)&local_d8,local_60[0],local_60[1],0.0);

+      cVar3 = '\x01';

+LAB_0:

+      CMILMatrix::Transform2DBoundsHelper<0>

+                ((CMILMatrix *)&local_d8,(D2D_RECT_F *)&local_70,(D2D_RECT_F *)local_88);

+      fVar7 = local_88[2];

+      fVar8 = local_88[3];

+      fVar9 = local_88[0];

+      fVar10 = local_88[1];

+    }

+    else {

+      if (cVar3 != '\0') goto LAB_0;

+      fVar7 = (float)uStack_68;

+      fVar8 = uStack_68._4_4_;

+      fVar9 = (float)local_70;

+      fVar10 = local_70._4_4_;

+    }

+    if ((fVar7 - fVar9 != 0.0) && (fVar8 - fVar10 != 0.0)) {

+      *(float *)param_3 = fVar7 - fVar9;

+      *(float *)(param_3 + 4) = fVar8 - fVar10;

+      *(undefined8 *)param_4 = local_70;

+      *(undefined8 *)(param_4 + 8) = uStack_68;

+      if (cVar3 == '\0') {

+        pfVar6 = local_60 + 4;

+        local_60[8] = 0.0;

+        local_60[9] = 0.0;

+        local_60[4] = 1.0;

+        local_60[5] = 0.0;

+        local_60[6] = 0.0;

+        local_60[7] = 1.0;

+      }

+      else {

+        pfVar6 = local_88;

+        local_88[1] = (float)local_d4;

+        local_88[0] = (float)local_d8;

+        local_88[3] = (float)local_c4;

+        local_88[2] = (float)local_c8;

+        local_88[4] = (float)local_a8;

+        uStack_74 = local_a4;

+      }

+      fVar7 = pfVar6[1];

+      fVar8 = pfVar6[2];

+      fVar9 = pfVar6[3];

+      uVar1 = *(undefined8 *)(pfVar6 + 4);

+      *(float *)param_5 = *pfVar6;

+      *(float *)(param_5 + 4) = fVar7;

+      *(float *)(param_5 + 8) = fVar8;

+      *(float *)(param_5 + 0xc) = fVar9;

+      *(undefined8 *)(param_5 + 0x10) = uVar1;

+      goto LAB_1;

+    }

+    iVar5 = -0x7767fff9;

+    uVar11 = 0x52f;

+  }

+  MilInstrumentationCheckHR_MaybeFailFast

+            (0x14,(long *)&`public:_virtual_long___cdecl_CSwapchainRenderStrategy::GetLayoutParameters(CSurfaceBrush_const*___ptr64,D2D_SIZE_F_const&___ptr64,D2D_SIZE_F*___ptr64,D2D_RECT_F*___ptr64,D2D_MATRIX_3X2_F*___ptr64)const___ptr64'

+                           ::__l2::MILINSTRUMENTATIONHRESULTLIST,2,iVar5,uVar11,(void *)0x0);

+LAB_1:

+  if (local_e8[0] != (IBitmapRealization *)0x0) {

+    (**(code **)(*(longlong *)local_e8[0] + 0x10))();

+  }

+  return iVar5;

+}

+
```

## `CCompositionMagnifierBrush::GetBackdropSourceRect`  (modified)

```diff
--- CCompositionMagnifierBrush::GetBackdropSourceRect
+++ CCompositionMagnifierBrush::GetLayeredBrushParameters
@@ -1,142 +1,725 @@
 

+/* WARNING: Function: __chkstk replaced with injection: alloca_probe */

 /* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

    guard_dispatch_icall */

-/* public: class TMilRect_<float,struct D2D_RECT_F,struct D3D_RECT_F,struct

-   D2D_POINTANDSIZE_F,struct RectUniqueness::NotNeeded> __cdecl

-   CCompositionMagnifierBrush::GetBackdropSourceRect(class CVisualTree const * __ptr64,class

-   TMilRect_<float,struct D2D_RECT_F,struct D3D_RECT_F,struct D2D_POINTANDSIZE_F,struct

-   RectUniqueness::NotNeeded> const & __ptr64)const __ptr64 */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* private: long __cdecl CCompositionMagnifierBrush::GetLayeredBrushParameters(class

+   CBrushDrawListGenerator * __ptr64)const __ptr64 */

 

-CVisualTree * __thiscall

-CCompositionMagnifierBrush::GetBackdropSourceRect

-          (CCompositionMagnifierBrush *this,CVisualTree *param_1,

-          TMilRect_<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_D2D_POINTANDSIZE_F,struct_RectUniqueness::NotNeeded>

-          *param_2)

+long __thiscall

+CCompositionMagnifierBrush::GetLayeredBrushParameters

+          (CCompositionMagnifierBrush *this,CBrushDrawListGenerator *param_1)

 

 {

-  int *piVar1;

-  float fVar2;

+  CDrawingContext *this_00;

+  float fVar1;

+  CExcludeVisualReference *pCVar2;

   float fVar3;

-  float fVar4;

-  float fVar5;

-  longlong lVar6;

-  float fVar7;

-  float fVar8;

-  int *piVar9;

-  char cVar10;

-  bool bVar11;

-  CVisualTree *this_00;

-  CVisual *pCVar12;

-  undefined8 uVar13;

-  undefined1 *puVar14;

-  int *piVar15;

-  uint uVar16;

-  CVisualTree *pCVar17;

-  float *in_R9;

-  float fVar18;

-  float fVar19;

-  undefined4 uVar20;

-  undefined4 uVar21;

-  float local_res8;

-  float fStackX_c;

-  undefined1 auStack_108 [32];

-  undefined8 local_e8;

-  uint local_e0;

-  longlong local_d8;

-  uint local_d0;

-  undefined4 uStack_cc;

+  bool bVar4;

+  long lVar5;

+  int iVar6;

+  long lVar7;

+  CVisual *pCVar8;

+  longlong lVar9;

+  CBackdropVisualImage *pCVar10;

+  CVisualTree *this_01;

+  CVisual *pCVar11;

+  TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded> *pTVar12;

+  CExcludeVisualReference *this_02;

+  CExcludeVisualReference *pCVar13;

+  void *unaff_retaddr;

+  undefined1 auStackY_14c8 [32];

+  undefined8 local_1498;

+  undefined8 local_1490;

+  undefined2 local_1488;

+  undefined1 local_1486;

+  CVisualTree *local_1478;

+  longlong local_1470;

+  char *local_1468;

+  undefined8 local_1460;

+  undefined1 local_1458;

+  longlong local_1450;

+  undefined4 local_1448;

+  undefined1 local_1444;

+  undefined8 local_1438;

+  undefined8 uStack_1430;

+  undefined4 local_1428;

+  undefined4 uStack_1424;

+  undefined4 uStack_1420;

+  undefined4 uStack_141c;

+  undefined4 uStack_1418;

+  undefined4 uStack_1414;

+  undefined8 uStack_1410;

+  undefined8 uStack_1408;

+  undefined4 local_1400;

+  undefined4 local_13fc;

+  undefined4 uStack_13f8;

+  undefined8 uStack_13f4;

+  undefined4 local_13ec;

+  undefined8 local_13e8;

+  undefined8 uStack_13e0;

+  undefined4 local_13d8;

+  CBrushDrawListGenerator *local_13c8;

+  longlong *local_13c0;

+  undefined8 local_13b8;

+  undefined1 local_13b0;

+  CDrawListBitmap local_13a8 [16];

+  undefined1 local_1398;

+  undefined8 local_1388;

+  undefined8 uStack_1380;

+  undefined8 local_1378;

+  undefined8 uStack_1370;

+  undefined8 local_1368;

+  undefined8 uStack_1360;

+  undefined8 local_1358;

+  undefined8 uStack_1350;

+  undefined4 local_1348;

+  undefined8 local_1338;

+  undefined8 uStack_1330;

+  undefined4 local_1328;

+  undefined4 uStack_1324;

+  undefined8 uStack_1320;

+  undefined8 local_1318;

+  undefined8 uStack_1310;

+  undefined8 local_1308;

+  undefined8 uStack_1300;

+  undefined4 local_12f8;

+  undefined4 local_12dc;

+  undefined1 local_12d8;

+  undefined8 local_12c8;

+  undefined8 uStack_12c0;

+  undefined8 local_12b8;

+  undefined8 uStack_12b0;

+  undefined8 local_12a8;

+  undefined8 uStack_12a0;

+  undefined8 local_1298;

+  undefined8 uStack_1290;

+  undefined4 local_1288;

+  undefined8 local_1278;

+  undefined8 uStack_1270;

+  undefined4 local_1268;

+  undefined4 uStack_1264;

+  CBrushDrawListGenerator local_1248 [80];

+  CDrawListEntryBuilder local_11f8 [4496];

+  ulonglong local_68;

   

-  fVar2 = in_R9[2];

-  fVar3 = *in_R9;

-  fVar4 = in_R9[3];

-  fVar5 = in_R9[1];

-  fVar18 = (fVar2 - fVar3) / *(float *)(this + 0x68);

-  fVar19 = (fVar4 - fVar5) / *(float *)(this + 0x68);

-  _local_res8 = CONCAT44(fVar19,fVar18);

-  puVar14 = (undefined1 *)register0x00000020;

-  if (this[200] == (CCompositionMagnifierBrush)0x0) {

-    if (this[0xcc] != (CCompositionMagnifierBrush)0x0) {

-      CComposition::GetCursorVisuals(*(CComposition **)(this + 0x18));

-      this_00 = CVisualTree::GetRootVisualTree((CVisualTree *)param_2);

-      piVar9 = (int *)CONCAT44(uStack_cc,local_d0);

-      if (piVar9 != piVar9 + local_d8 * 0xc) {

-        uVar20 = (undefined4)local_d8;

-        uVar21 = (undefined4)((ulonglong)local_d8 >> 0x20);

-        piVar15 = piVar9 + 8;

-        do {

-          pCVar12 = CExcludeVisualReference::GetVisualNoRef

-                              ((CExcludeVisualReference *)(piVar15 + -8));

-          local_e0 = local_e0 & 0xffffff00;

-          cVar10 = (**(code **)(*(longlong *)pCVar12 + 0x40))(pCVar12,0x30);

-          if (cVar10 == '\0') {

-            if (((*(uint *)(pCVar12 + 0x60) & 0x100) != 0) &&

-               (bVar11 = CVisualTree::_IsInTree(this_00,pCVar12,0), bVar11)) {

-              if (pCVar12 == *(CVisual **)(this_00 + 0x48)) {

-                pCVar17 = this_00 + 0x50;

-              }

-              else {

-                pCVar17 = (CVisualTree *)(pCVar12 + 0x98);

-              }

-              fVar7 = *(float *)pCVar17;

-              fVar8 = *(float *)(pCVar17 + 4);

-              local_e8 = *(undefined8 *)pCVar17;

-              uVar16 = 1;

-              local_e0 = CONCAT31(local_e0._1_3_,1);

-              bVar11 = wil::details::

-                       FeatureImpl<__WilFeatureTraits_Feature_CompositionMagnifier_Iter2>::

-                       __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_CompositionMagnifier_Iter2>

-                                            *)&`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_CompositionMagnifier_Iter2>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_CompositionMagnifier_Iter2>::GetImpl(void)'

-                                               ::__l2::impl);

-              puVar14 = auStack_108;

-              if (((bVar11) &&

-                  (bVar11 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>::

-                            __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>

-                                                 *)&

-                                                  `private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DesktopDWMCursor>::GetImpl(void)'

-                                                  ::__l2::impl), puVar14 = auStack_108, !bVar11)) &&

-                 (puVar14 = auStack_108, (char)piVar15[2] != '\0')) {

-                local_e8 = CONCAT44((float)piVar15[1] + fVar8,(float)*piVar15 + fVar7);

-                goto LAB_0;

-              }

-              goto LAB_1;

+  local_68 = __security_cookie ^ (ulonglong)auStackY_14c8;

+  this_00 = *(CDrawingContext **)param_1;

+  local_1498 = *(CExcludeVisualReference **)(param_1 + 0x2c);

+  local_1450 = 0;

+  local_13c8 = param_1;

+  pCVar8 = CDrawingContext::GetCurrentVisual(this_00);

+  wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>::reset

+            ((com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy> *)&local_1450);

+  lVar9 = (**(code **)(*(longlong *)(this_00 + 0x18) + 0x10))(this_00 + 0x18);

+  local_1460 = (CExcludeVisualReference *)CONCAT44(local_1460._4_4_,0x24);

+  local_1468 = "DWM Magnifier Brush Resample Surface";

+  pTVar12 = (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded> *)

+            &local_1468;

+  lVar5 = CDrawingContext::PushOffScreenRenderingLayer

+                    (this_00,pTVar12,&local_1498,*(undefined4 *)(lVar9 + 8));

+  pCVar2 = local_1498;

+  if (lVar5 < 0) {

+    wil::details::in1diag3::Return_Hr

+              (unaff_retaddr,0xe7,

+               "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp",lVar5);

+  }

+  else {

+    fVar3 = local_1498._4_4_;

+    fVar1 = (float)local_1498;

+    if (this[0x6c] != (CCompositionMagnifierBrush)0x0) {

+      local_1448 = *(undefined4 *)(this + 0x68);

+      local_1444 = 1;

+      local_1478 = (CVisualTree *)0x3f8000003f800000;

+      local_1468 = (char *)0x0;

+      iVar6 = PixelAlign((float)local_1498,1);

+      local_1460 = (CExcludeVisualReference *)CONCAT44(local_1460._4_4_,iVar6);

+      iVar6 = PixelAlign(fVar3,1);

+      local_1460 = (CExcludeVisualReference *)CONCAT44(iVar6,(undefined4)local_1460);

+      pTVar12 = (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                 *)pCVar8;

+      lVar5 = CDrawingContext::PushResampleLayer

+                        (this_00,pCVar8,2,(D2D_POINTANDSIZE_L *)&local_1468,

+                         (D2D_SIZE_F *)&local_1478,(optional<float> *)&local_1448);

+      if (lVar5 < 0) {

+        wil::details::in1diag3::Return_Hr

+                  (unaff_retaddr,0x104,

+                   "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp",

+                   lVar5);

+        lVar7 = CDrawingContext::PopLayer(this_00);

+        if (lVar7 < 0) {

+                    /* WARNING: Subroutine does not return */

+          wil::details::in1diag3::FailFast_Hr

+                    (unaff_retaddr,0xea,

+                     "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp",

+                     lVar7);

+        }

+        goto LAB_0;

+      }

+    }

+    if (this[0x6d] != (CCompositionMagnifierBrush)0x0) {

+      local_1438 = *(undefined8 *)(this + 0x70);

+      uStack_1430 = *(undefined8 *)(this + 0x78);

+      local_1428 = 0;

+      uStack_1414 = 0;

+      local_1400 = 0;

+      local_13ec = 0;

+      local_13d8 = 0x3f800000;

+      uStack_1424 = (undefined4)*(undefined8 *)(this + 0x80);

+      uStack_1420 = (undefined4)((ulonglong)*(undefined8 *)(this + 0x80) >> 0x20);

+      uStack_141c = (undefined4)*(undefined8 *)(this + 0x88);

+      uStack_1418 = (undefined4)((ulonglong)*(undefined8 *)(this + 0x88) >> 0x20);

+      uStack_1410 = *(undefined8 *)(this + 0x90);

+      uStack_1408 = *(undefined8 *)(this + 0x98);

+      uStack_13f4 = *(undefined8 *)(this + 0xa8);

+      local_13fc = (undefined4)*(undefined8 *)(this + 0xa0);

+      uStack_13f8 = (undefined4)((ulonglong)*(undefined8 *)(this + 0xa0) >> 0x20);

+      local_13e8 = *(undefined8 *)(this + 0xb0);

+      uStack_13e0 = *(undefined8 *)(this + 0xb8);

+      lVar5 = CDrawingContext::PushValueColorTransformLayer

+                        (this_00,pTVar12,(MilColorTransform *)&local_1438);

+      if (lVar5 < 0) {

+        wil::details::in1diag3::Return_Hr

+                  (unaff_retaddr,0x11b,

+                   "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp",

+                   lVar5);

+        if ((this[0x6c] != (CCompositionMagnifierBrush)0x0) &&

+           (lVar7 = CDrawingContext::PopLayer(this_00), lVar7 < 0)) {

+                    /* WARNING: Subroutine does not return */

+          wil::details::in1diag3::FailFast_Hr

+                    (unaff_retaddr,0x10a,

+                     "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp",

+                     lVar7);

+        }

+        lVar7 = CDrawingContext::PopLayer(this_00);

+        if (lVar7 < 0) {

+                    /* WARNING: Subroutine does not return */

+          wil::details::in1diag3::FailFast_Hr

+                    (unaff_retaddr,0xea,

+                     "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp",

+                     lVar7);

+        }

+        goto LAB_0;

+      }

+    }

+    local_1468 = (char *)&local_1490;

+    local_1490 = 0;

+    local_1460 = (CExcludeVisualReference *)0x0;

+    local_1458 = 1;

+    lVar5 = CBrush::CreateLayoutGeometryDrawListBrush

+                      ((CBrush *)this,this_00,(D2D_SIZE_F *)&local_1498,

+                       (CDrawListBrush **)&local_1460);

+    wil::details::out_param_t<std::unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>_>

+    ::~out_param_t<std::unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>_>

+              ((out_param_t<std::unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>_> *

+               )&local_1468);

+    if (lVar5 < 0) {

+      wil::details::in1diag3::Return_Hr

+                (unaff_retaddr,0x129,

+                 "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp",lVar5

+                );

+      std::unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>::

+      ~unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>

+                ((unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_> *)&local_1490);

+      if ((this[0x6d] != (CCompositionMagnifierBrush)0x0) &&

+         (lVar7 = CDrawingContext::PopLayer(this_00), lVar7 < 0)) {

+                    /* WARNING: Subroutine does not return */

+        wil::details::in1diag3::FailFast_Hr

+                  (unaff_retaddr,0x121,

+                   "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp",

+                   lVar7);

+      }

+      if ((this[0x6c] != (CCompositionMagnifierBrush)0x0) &&

+         (lVar7 = CDrawingContext::PopLayer(this_00), lVar7 < 0)) {

+                    /* WARNING: Subroutine does not return */

+        wil::details::in1diag3::FailFast_Hr

+                  (unaff_retaddr,0x10a,

+                   "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp",

+                   lVar7);

+      }

+      lVar7 = CDrawingContext::PopLayer(this_00);

+      if (lVar7 < 0) {

+                    /* WARNING: Subroutine does not return */

+        wil::details::in1diag3::FailFast_Hr

+                  (unaff_retaddr,0xea,

+                   "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp",

+                   lVar7);

+      }

+    }

+    else {

+      CBrushDrawListGenerator::CBrushDrawListGenerator(local_1248,this_00,(D2D_SIZE_F *)&local_1498)

+      ;

+      lVar5 = GetBVIBrushParameters(this,local_1248);

+      if (lVar5 < 0) {

+        wil::details::in1diag3::Return_Hr

+                  (unaff_retaddr,0x12f,

+                   "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp",

+                   lVar5);

+        CBrushDrawListGenerator::~CBrushDrawListGenerator(local_1248);

+        std::unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>::

+        ~unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>

+                  ((unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_> *)&local_1490);

+        if ((this[0x6d] != (CCompositionMagnifierBrush)0x0) &&

+           (lVar7 = CDrawingContext::PopLayer(this_00), lVar7 < 0)) {

+                    /* WARNING: Subroutine does not return */

+          wil::details::in1diag3::FailFast_Hr

+                    (unaff_retaddr,0x121,

+                     "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp",

+                     lVar7);

+        }

+        if ((this[0x6c] != (CCompositionMagnifierBrush)0x0) &&

+           (lVar7 = CDrawingContext::PopLayer(this_00), lVar7 < 0)) {

+                    /* WARNING: Subroutine does not return */

+          wil::details::in1diag3::FailFast_Hr

+                    (unaff_retaddr,0x10a,

+                     "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp",

+                     lVar7);

+        }

+        lVar7 = CDrawingContext::PopLayer(this_00);

+        if (lVar7 < 0) {

+                    /* WARNING: Subroutine does not return */

+          wil::details::in1diag3::FailFast_Hr

+                    (unaff_retaddr,0xea,

+                     "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp",

+                     lVar7);

+        }

+      }

+      else {

+        local_1338 = local_1490;

+        uStack_1330 = 0;

+        local_1328 = 0;

+        local_12dc = 0x101;

+        local_12d8 = 0;

+        CDrawListEntryBuilder::CDrawListEntryBuilder(local_11f8);

+        lVar5 = CBrushDrawListGenerator::GenerateDrawList

+                          (local_1248,(GenerateDrawListProperties *)&local_1338,local_11f8);

+        if (lVar5 < 0) {

+          wil::details::in1diag3::Return_Hr

+                    (unaff_retaddr,0x136,

+                     "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp",

+                     lVar5);

+          CDrawListEntryBuilder::~CDrawListEntryBuilder(local_11f8);

+          CBrushDrawListGenerator::~CBrushDrawListGenerator(local_1248);

+          std::unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>::

+          ~unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>

+                    ((unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_> *)&local_1490)

+          ;

+          if ((this[0x6d] != (CCompositionMagnifierBrush)0x0) &&

+             (lVar7 = CDrawingContext::PopLayer(this_00), lVar7 < 0)) {

+                    /* WARNING: Subroutine does not return */

+            wil::details::in1diag3::FailFast_Hr

+                      (unaff_retaddr,0x121,

+                       "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                       ,lVar7);

+          }

+          if ((this[0x6c] != (CCompositionMagnifierBrush)0x0) &&

+             (lVar7 = CDrawingContext::PopLayer(this_00), lVar7 < 0)) {

+                    /* WARNING: Subroutine does not return */

+            wil::details::in1diag3::FailFast_Hr

+                      (unaff_retaddr,0x10a,

+                       "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                       ,lVar7);

+          }

+          lVar7 = CDrawingContext::PopLayer(this_00);

+          if (lVar7 < 0) {

+                    /* WARNING: Subroutine does not return */

+            wil::details::in1diag3::FailFast_Hr

+                      (unaff_retaddr,0xea,

+                       "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                       ,lVar7);

+          }

+        }

+        else {

+          local_1498 = (CExcludeVisualReference *)0x0;

+          lVar5 = CDrawListCache::InternalCreate(true,(CDrawListCache **)&local_1498);

+          if (lVar5 < 0) {

+            wil::details::in1diag3::Return_Hr

+                      (unaff_retaddr,0x139,

+                       "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                       ,lVar5);

+            wil::com_ptr_t<CDrawListCache,wil::err_returncode_policy>::

+            ~com_ptr_t<CDrawListCache,wil::err_returncode_policy>

+                      ((com_ptr_t<CDrawListCache,wil::err_returncode_policy> *)&local_1498);

+            CDrawListEntryBuilder::~CDrawListEntryBuilder(local_11f8);

+            CBrushDrawListGenerator::~CBrushDrawListGenerator(local_1248);

+            std::unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>::

+            ~unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>

+                      ((unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_> *)

+                       &local_1490);

+            if ((this[0x6d] != (CCompositionMagnifierBrush)0x0) &&

+               (lVar7 = CDrawingContext::PopLayer(this_00), lVar7 < 0)) {

+                    /* WARNING: Subroutine does not return */

+              wil::details::in1diag3::FailFast_Hr

+                        (unaff_retaddr,0x121,

+                         "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                         ,lVar7);

+            }

+            if ((this[0x6c] != (CCompositionMagnifierBrush)0x0) &&

+               (lVar7 = CDrawingContext::PopLayer(this_00), lVar7 < 0)) {

+                    /* WARNING: Subroutine does not return */

+              wil::details::in1diag3::FailFast_Hr

+                        (unaff_retaddr,0x10a,

+                         "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                         ,lVar7);

+            }

+            lVar7 = CDrawingContext::PopLayer(this_00);

+            if (lVar7 < 0) {

+                    /* WARNING: Subroutine does not return */

+              wil::details::in1diag3::FailFast_Hr

+                        (unaff_retaddr,0xea,

+                         "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                         ,lVar7);

             }

           }

           else {

-            lVar6 = *(longlong *)(pCVar12 + 0x2c8);

-            uVar16 = local_d0 >> 8;

-            local_d0 = local_d0 & 0xffffff00;

-            if (lVar6 != 0) {

-              uVar21 = *(undefined4 *)(lVar6 + 0xe0);

-              uVar20 = *(undefined4 *)(lVar6 + 0xdc);

-              local_d0 = CONCAT31((int3)uVar16,1);

+            CDrawListCache::Update((CDrawListCache *)local_1498,this_00,local_11f8);

+            local_12c8 = 0x3f800000;

+            uStack_12c0 = 0;

+            local_12b8 = 0x3f80000000000000;

+            uStack_12b0 = 0;

+            local_12a8 = 0;

+            uStack_12a0 = 0x3f800000;

+            local_1298 = 0;

+            uStack_1290 = 0x3f80000000000000;

+            local_1288 = 0x29aa;

+            lVar5 = CDrawListCache::Render

+                              ((CDrawListCache *)local_1498,this_00,(CMILMatrix *)&local_12c8,1.0,5)

+            ;

+            if (lVar5 < 0) {

+              wil::details::in1diag3::Return_Hr

+                        (unaff_retaddr,0x141,

+                         "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                         ,lVar5);

+              wil::com_ptr_t<CDrawListCache,wil::err_returncode_policy>::

+              ~com_ptr_t<CDrawListCache,wil::err_returncode_policy>

+                        ((com_ptr_t<CDrawListCache,wil::err_returncode_policy> *)&local_1498);

+              CDrawListEntryBuilder::~CDrawListEntryBuilder(local_11f8);

+              CBrushDrawListGenerator::~CBrushDrawListGenerator(local_1248);

+              std::unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>::

+              ~unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>

+                        ((unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_> *)

+                         &local_1490);

+              if ((this[0x6d] != (CCompositionMagnifierBrush)0x0) &&

+                 (lVar7 = CDrawingContext::PopLayer(this_00), lVar7 < 0)) {

+                    /* WARNING: Subroutine does not return */

+                wil::details::in1diag3::FailFast_Hr

+                          (unaff_retaddr,0x121,

+                           "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                           ,lVar7);

+              }

+              if ((this[0x6c] != (CCompositionMagnifierBrush)0x0) &&

+                 (lVar7 = CDrawingContext::PopLayer(this_00), lVar7 < 0)) {

+                    /* WARNING: Subroutine does not return */

+                wil::details::in1diag3::FailFast_Hr

+                          (unaff_retaddr,0x10a,

+                           "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                           ,lVar7);

+              }

+              lVar7 = CDrawingContext::PopLayer(this_00);

+              if (lVar7 < 0) {

+                    /* WARNING: Subroutine does not return */

+                wil::details::in1diag3::FailFast_Hr

+                          (unaff_retaddr,0xea,

+                           "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                           ,lVar7);

+              }

             }

-            local_e0 = local_d0;

-            local_e8 = CONCAT44(uVar21,uVar20);

-            uVar16 = local_d0;

-LAB_0:

-            puVar14 = auStack_108;

-            if ((char)uVar16 != '\0') goto LAB_1;

+            else {

+              if (this[0xcd] != (CCompositionMagnifierBrush)0x0) {

+                local_1388 = 0x3f800000;

+                uStack_1380 = 0;

+                local_1378 = 0x3f80000000000000;

+                uStack_1370 = 0;

+                local_1368 = 0;

+                uStack_1360 = 0x3f800000;

+                local_1358 = 0;

+                uStack_1350 = 0x3f80000000000000;

+                local_1348 = 0x29aa;

+                pCVar10 = CVisual::GetBackdropVisualImage

+                                    (pCVar8,*(CVisualTreePath **)(this_00 + 0x1f20));

+                CMILMatrix::Translate

+                          ((CMILMatrix *)&local_1388,

+                           -*(float *)(pCVar10 + 0x60) - *(float *)(pCVar10 + 0x828),

+                           -*(float *)(pCVar10 + 100) - *(float *)(pCVar10 + 0x82c));

+                local_1278 = 6;

+                uStack_1270 = CONCAT44(uStack_1270._4_4_,1);

+                if (this[0x6c] == (CCompositionMagnifierBrush)0x0) {

+                  CMILMatrix::Scale((CMILMatrix *)&local_1388,*(float *)(this + 0x68),

+                                    *(float *)(this + 0x68),0.0);

+                  local_1278 = CONCAT44(1,(undefined4)local_1278);

+                }

+                lVar5 = CDrawingContext::PushRenderOptionsInternal

+                                  (this_00,(CVisual *)0x0,(MilRenderOptions *)&local_1278,true);

+                if (lVar5 < 0) {

+                  wil::details::in1diag3::Return_Hr

+                            (unaff_retaddr,0x15d,

+                             "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                             ,lVar5);

+                  wil::com_ptr_t<CDrawListCache,wil::err_returncode_policy>::

+                  ~com_ptr_t<CDrawListCache,wil::err_returncode_policy>

+                            ((com_ptr_t<CDrawListCache,wil::err_returncode_policy> *)&local_1498);

+                  CDrawListEntryBuilder::~CDrawListEntryBuilder(local_11f8);

+                  CBrushDrawListGenerator::~CBrushDrawListGenerator(local_1248);

+                  std::unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>::

+                  ~unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>

+                            ((unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_> *)

+                             &local_1490);

+                  if ((this[0x6d] != (CCompositionMagnifierBrush)0x0) &&

+                     (lVar7 = CDrawingContext::PopLayer(this_00), lVar7 < 0)) {

+                    /* WARNING: Subroutine does not return */

+                    wil::details::in1diag3::FailFast_Hr

+                              (unaff_retaddr,0x121,

+                               "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                               ,lVar7);

+                  }

+                  if ((this[0x6c] != (CCompositionMagnifierBrush)0x0) &&

+                     (lVar7 = CDrawingContext::PopLayer(this_00), lVar7 < 0)) {

+                    /* WARNING: Subroutine does not return */

+                    wil::details::in1diag3::FailFast_Hr

+                              (unaff_retaddr,0x10a,

+                               "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                               ,lVar7);

+                  }

+                  lVar7 = CDrawingContext::PopLayer(this_00);

+                  if (lVar7 < 0) {

+                    /* WARNING: Subroutine does not return */

+                    wil::details::in1diag3::FailFast_Hr

+                              (unaff_retaddr,0xea,

+                               "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                               ,lVar7);

+                  }

+                  goto LAB_0;

+                }

+                CComposition::GetCursorVisuals(*(CComposition **)(this + 0x18));

+                this_01 = CVisualTree::GetRootVisualTree(*(CVisualTree **)(this_00 + 0x1f08));

+                pCVar13 = local_1460 + (longlong)local_1468 * 0x30;

+                for (this_02 = local_1460; this_02 != pCVar13; this_02 = this_02 + 0x30) {

+                  pCVar8 = CExcludeVisualReference::GetVisualNoRef(this_02);

+                  bVar4 = CVisualTree::_IsInTree(this_01,pCVar8,0);

+                  if (bVar4) {

+                    local_1478 = *(CVisualTree **)(this_02 + 0x18);

+                    local_12f8 = 0;

+                    lVar5 = CVisual::GetWorldTransform

+                                      (pCVar8,this_01,3,(CMILMatrix *)&local_1338,(bool *)0x0,

+                                       (CMILMatrix *)0x0);

+                    if (lVar5 < 0) {

+                      wil::details::in1diag3::Return_Hr

+                                (unaff_retaddr,0x173,

+                                 "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                                 ,lVar5);

+                      CDrawingContext::PopRenderOptionsInternal(this_00,true);

+                      wil::com_ptr_t<CDrawListCache,wil::err_returncode_policy>::

+                      ~com_ptr_t<CDrawListCache,wil::err_returncode_policy>

+                                ((com_ptr_t<CDrawListCache,wil::err_returncode_policy> *)&local_1498

+                                );

+                      CDrawListEntryBuilder::~CDrawListEntryBuilder(local_11f8);

+                      CBrushDrawListGenerator::~CBrushDrawListGenerator(local_1248);

+                      std::unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>::

+                      ~unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>

+                                ((unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_> *)

+                                 &local_1490);

+                      if ((this[0x6d] != (CCompositionMagnifierBrush)0x0) &&

+                         (lVar7 = CDrawingContext::PopLayer(this_00), lVar7 < 0)) {

+                    /* WARNING: Subroutine does not return */

+                        wil::details::in1diag3::FailFast_Hr

+                                  (unaff_retaddr,0x121,

+                                   "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                                   ,lVar7);

+                      }

+                      if ((this[0x6c] != (CCompositionMagnifierBrush)0x0) &&

+                         (lVar7 = CDrawingContext::PopLayer(this_00), lVar7 < 0)) {

+                    /* WARNING: Subroutine does not return */

+                        wil::details::in1diag3::FailFast_Hr

+                                  (unaff_retaddr,0x10a,

+                                   "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                                   ,lVar7);

+                      }

+                      lVar7 = CDrawingContext::PopLayer(this_00);

+                      if (lVar7 < 0) {

+                    /* WARNING: Subroutine does not return */

+                        wil::details::in1diag3::FailFast_Hr

+                                  (unaff_retaddr,0xea,

+                                   "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                                   ,lVar7);

+                      }

+                      goto LAB_0;

+                    }

+                    local_1438 = local_1338;

+                    uStack_1430 = uStack_1330;

+                    local_1428 = local_1328;

+                    uStack_1424 = uStack_1324;

+                    uStack_1420 = (undefined4)uStack_1320;

+                    uStack_141c = (undefined4)((ulonglong)uStack_1320 >> 0x20);

+                    uStack_1418 = (undefined4)local_1318;

+                    uStack_1414 = (undefined4)((ulonglong)local_1318 >> 0x20);

+                    uStack_1410 = uStack_1310;

+                    uStack_1408 = local_1308;

+                    local_1400 = (undefined4)uStack_1300;

+                    local_13fc = (undefined4)((ulonglong)uStack_1300 >> 0x20);

+                    uStack_13f8 = local_12f8;

+                    CMILMatrix::Multiply((CMILMatrix *)&local_1438,(CMILMatrix *)&local_1388);

+                    pCVar11 = (CVisual *)(local_1478 + 0x50);

+                    if (pCVar8 != *(CVisual **)(local_1478 + 0x48)) {

+                      pCVar11 = pCVar8 + 0x98;

+                    }

+                    local_1278 = *(undefined8 *)pCVar11;

+                    uStack_1270 = *(undefined8 *)(pCVar11 + 8);

+                    local_1268 = *(undefined4 *)(pCVar11 + 0x10);

+                    uStack_1264 = *(undefined4 *)(pCVar11 + 0x14);

+                    lVar5 = CDrawingContext::DrawSubVisualTree

+                                      (this_00,local_1478,

+                                       (TMil3DRect<float,TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,D3D_RECT_F,MilPointAndSizeF,RectUniqueness::NotNeeded>

+                                        *)&local_1278,(CMILMatrix *)&local_1438);

+                    if (lVar5 < 0) {

+                      wil::details::in1diag3::Return_Hr

+                                (unaff_retaddr,0x17b,

+                                 "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                                 ,lVar5);

+                      CDrawingContext::PopRenderOptionsInternal(this_00,true);

+                      wil::com_ptr_t<CDrawListCache,wil::err_returncode_policy>::

+                      ~com_ptr_t<CDrawListCache,wil::err_returncode_policy>

+                                ((com_ptr_t<CDrawListCache,wil::err_returncode_policy> *)&local_1498

+                                );

+                      CDrawListEntryBuilder::~CDrawListEntryBuilder(local_11f8);

+                      CBrushDrawListGenerator::~CBrushDrawListGenerator(local_1248);

+                      std::unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>::

+                      ~unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>

+                                ((unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_> *)

+                                 &local_1490);

+                      if ((this[0x6d] != (CCompositionMagnifierBrush)0x0) &&

+                         (lVar7 = CDrawingContext::PopLayer(this_00), lVar7 < 0)) {

+                    /* WARNING: Subroutine does not return */

+                        wil::details::in1diag3::FailFast_Hr

+                                  (unaff_retaddr,0x121,

+                                   "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                                   ,lVar7);

+                      }

+                      if ((this[0x6c] != (CCompositionMagnifierBrush)0x0) &&

+                         (lVar7 = CDrawingContext::PopLayer(this_00), lVar7 < 0)) {

+                    /* WARNING: Subroutine does not return */

+                        wil::details::in1diag3::FailFast_Hr

+                                  (unaff_retaddr,0x10a,

+                                   "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                                   ,lVar7);

+                      }

+                      lVar7 = CDrawingContext::PopLayer(this_00);

+                      if (lVar7 < 0) {

+                    /* WARNING: Subroutine does not return */

+                        wil::details::in1diag3::FailFast_Hr

+                                  (unaff_retaddr,0xea,

+                                   "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                                   ,lVar7);

+                      }

+                      goto LAB_0;

+                    }

+                  }

+                }

+                CDrawingContext::PopRenderOptionsInternal(this_00,true);

+                param_1 = local_13c8;

+              }

+              wil::com_ptr_t<CDrawListCache,wil::err_returncode_policy>::

+              ~com_ptr_t<CDrawListCache,wil::err_returncode_policy>

+                        ((com_ptr_t<CDrawListCache,wil::err_returncode_policy> *)&local_1498);

+              CDrawListEntryBuilder::~CDrawListEntryBuilder(local_11f8);

+              CBrushDrawListGenerator::~CBrushDrawListGenerator(local_1248);

+              std::unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>::

+              ~unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>

+                        ((unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_> *)

+                         &local_1490);

+              if ((this[0x6d] != (CCompositionMagnifierBrush)0x0) &&

+                 (lVar5 = CDrawingContext::PopLayer(this_00), lVar5 < 0)) {

+                    /* WARNING: Subroutine does not return */

+                wil::details::in1diag3::FailFast_Hr

+                          (unaff_retaddr,0x121,

+                           "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                           ,lVar5);

+              }

+              if ((this[0x6c] != (CCompositionMagnifierBrush)0x0) &&

+                 (lVar5 = CDrawingContext::PopLayer(this_00), lVar5 < 0)) {

+                    /* WARNING: Subroutine does not return */

+                wil::details::in1diag3::FailFast_Hr

+                          (unaff_retaddr,0x10a,

+                           "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                           ,lVar5);

+              }

+              lVar5 = CDrawingContext::PopLayer(this_00);

+              if (lVar5 < 0) {

+                    /* WARNING: Subroutine does not return */

+                wil::details::in1diag3::FailFast_Hr

+                          (unaff_retaddr,0xea,

+                           "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                           ,lVar5);

+              }

+              local_1470 = 0;

+              CDrawListBitmap::CDrawListBitmap

+                        (local_13a8,

+                         (IBitmapRealization *)(-(ulonglong)(local_1450 != 0) & local_1450 + 8U));

+              local_13c0 = &local_1470;

+              local_1468 = (char *)0x0;

+              local_1460 = pCVar2;

+              local_1398 = 1;

+              local_13b8 = 0;

+              local_13b0 = 1;

+              local_1488 = 0x100;

+              local_1486 = 1;

+              lVar5 = CSurfaceDrawListBrush::CreateWithContentRect

+                                (local_13a8,&local_1488,&local_1468,&local_13b8);

+              wil::details::

+              out_param_t<std::unique_ptr<CSurfaceDrawListBrush,std::default_delete<CSurfaceDrawListBrush>_>_>

+              ::

+              ~out_param_t<std::unique_ptr<CSurfaceDrawListBrush,std::default_delete<CSurfaceDrawListBrush>_>_>

+                        ((out_param_t<std::unique_ptr<CSurfaceDrawListBrush,std::default_delete<CSurfaceDrawListBrush>_>_>

+                          *)&local_13c0);

+              if (-1 < lVar5) {

+                *(undefined8 *)(local_1470 + 0x78) = 0;

+                *(float *)(local_1470 + 0x80) = fVar1;

+                *(float *)(local_1470 + 0x84) = fVar3;

+                CBrushDrawListGenerator::Reset(param_1);

+                local_1478 = (CVisualTree *)local_1470;

+                local_1470 = 0;

+                CBrushDrawListGenerator::AttachInput

+                          (param_1,0,

+                           (unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_> *)

+                           &local_1478);

+                std::unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>::

+                ~unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>

+                          ((unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_> *)

+                           &local_1478);

+                CDrawListBitmap::~CDrawListBitmap(local_13a8);

+                std::unique_ptr<CSurfaceDrawListBrush,std::default_delete<CSurfaceDrawListBrush>_>::

+                ~unique_ptr<CSurfaceDrawListBrush,std::default_delete<CSurfaceDrawListBrush>_>

+                          ((unique_ptr<CSurfaceDrawListBrush,std::default_delete<CSurfaceDrawListBrush>_>

+                            *)&local_1470);

+                wil::

+                com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+                ::

+                ~com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+                          ((com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+                            *)&local_1450);

+                return 0;

+              }

+              wil::details::in1diag3::Return_Hr

+                        (unaff_retaddr,400,

+                         "onecoreuap\\windows\\dwm\\dwmcore\\resources\\compositionmagnifierbrush.cpp"

+                         ,lVar5);

+              CDrawListBitmap::~CDrawListBitmap(local_13a8);

+              std::unique_ptr<CSurfaceDrawListBrush,std::default_delete<CSurfaceDrawListBrush>_>::

+              ~unique_ptr<CSurfaceDrawListBrush,std::default_delete<CSurfaceDrawListBrush>_>

+                        ((unique_ptr<CSurfaceDrawListBrush,std::default_delete<CSurfaceDrawListBrush>_>

+                          *)&local_1470);

+            }

           }

-          piVar1 = piVar15 + 4;

-          piVar15 = piVar15 + 0xc;

-        } while (piVar1 != piVar9 + local_d8 * 0xc);

+        }

       }

     }

-    local_res8 = ((fVar2 - fVar3) - fVar18) * 0.5 + *in_R9;

-    fStackX_c = ((fVar4 - fVar5) - fVar19) * 0.5 + in_R9[1];

   }

-  else {

-LAB_1:

-    uVar13 = ClampMagnificationRectToClientBounds

-                       ((CVisualTree *)param_2,(D2D_POINT_2F *)(puVar14 + 0x20),

-                        (D2D_SIZE_F *)&local_res8);

-    local_res8 = (float)uVar13;

-    fStackX_c = (float)((ulonglong)uVar13 >> 0x20);

-  }

-  *(float *)param_1 = local_res8;

-  *(float *)(param_1 + 4) = fStackX_c;

-  *(float *)(param_1 + 8) = local_res8 + fVar18;

-  *(float *)(param_1 + 0xc) = fStackX_c + fVar19;

-  return param_1;

+LAB_0:

+  wil::

+  com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+  ::

+  ~com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+            ((com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+              *)&local_1450);

+  return lVar5;

 }
```

## `CBlurredWallpaperBackdropBrush::IsOfType`  (modified)

```diff
--- CBlurredWallpaperBackdropBrush::IsOfType
+++ CBlurredWallpaperBackdropBrush::IsOfType
@@ -1,2 +1,15 @@
-Failed to decompile dwmcore.dll - .ProgramDB CBlurredWallpaperBackdropBrush::IsOfType : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: virtual bool __cdecl CBlurredWallpaperBackdropBrush::IsOfType(enum

+   MIL_RESOURCE_TYPE)const __ptr64 */

+

+bool __thiscall

+CBlurredWallpaperBackdropBrush::IsOfType

+          (CBlurredWallpaperBackdropBrush *this,MIL_RESOURCE_TYPE param_1)

+

+{

+  if ((param_1 < 0x2e) && ((0x200000028000U >> ((ulonglong)param_1 & 0x3f) & 1) != 0)) {

+    return true;

+  }

+  return false;

+}

+
```

## `CVisual::GetColorSpace`  (modified)

```diff
--- CVisual::GetColorSpace
+++ CVisual::GetColorSpace
@@ -1,2 +1,19 @@
-Failed to decompile dwmcore.dll - .ProgramDB CVisual::GetColorSpace : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: enum DXGI_COLOR_SPACE_TYPE __cdecl CVisual::GetColorSpace(void)const __ptr64 */

+

+DXGI_COLOR_SPACE_TYPE __thiscall CVisual::GetColorSpace(CVisual *this)

+

+{

+  DXGI_COLOR_SPACE_TYPE DVar1;

+  DataInfo *pDVar2;

+  

+  if ((*(uint *)(*(AllocatedStorage **)(this + 0xe0) + 4) & 0x4000000) == 0) {

+    DVar1 = 4;

+  }

+  else {

+    pDVar2 = CSparseStorage::AllocatedStorage::FindSlot(*(AllocatedStorage **)(this + 0xe0),6);

+    DVar1 = *(DXGI_COLOR_SPACE_TYPE *)(pDVar2 + 4);

+  }

+  return DVar1;

+}

+
```

## `CSurfaceBrush::ComputeLayout`  (modified)

```diff
--- CSurfaceBrush::ComputeLayout
+++ CSurfaceBrush::ComputeLayout
@@ -1,2 +1,409 @@
-Failed to decompile dwmcore.dll - .ProgramDB CSurfaceBrush::ComputeLayout : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: long __cdecl CSurfaceBrush::ComputeLayout(struct D2D_SIZE_F const & __ptr64,struct

+   CContent::LayoutData * __ptr64,class CShape * __ptr64 * __ptr64)const __ptr64 */

+

+long __thiscall

+CSurfaceBrush::ComputeLayout

+          (CSurfaceBrush *this,D2D_SIZE_F *param_1,LayoutData *param_2,CShape **param_3)

+

+{

+  int iVar1;

+  CSwapchainRenderStrategy *this_00;

+  code *pcVar2;

+  CComponentTransform2D *this_01;

+  CMILCOMBaseWeakRefSource<CResourceDeleter> *this_02;

+  CMILRefCountBaseT<ID2D1GeometrySink,CMilObjectDeleter> *this_03;

+  CRectanglesShape *pCVar3;

+  bool bVar4;

+  char cVar5;

+  long lVar6;

+  int iVar7;

+  CResource *this_04;

+  D2D_VECTOR_2F *pDVar8;

+  longlong lVar9;

+  HANDLE hHeap;

+  CMILMatrix *pCVar10;

+  CRectanglesShape *lpMem;

+  float fVar11;

+  float fVar12;

+  float fVar13;

+  float fVar14;

+  float fVar15;

+  float fVar16;

+  float fVar17;

+  float fVar18;

+  float fVar19;

+  undefined1 auStackY_268 [32];

+  uint uVar20;

+  undefined8 local_228;

+  undefined8 uStack_220;

+  undefined8 local_218;

+  CRectanglesShape *local_210;

+  undefined8 local_208;

+  float local_200;

+  float local_1f8;

+  float local_1f4;

+  undefined8 local_1f0;

+  float local_1e8;

+  float local_1e4;

+  undefined8 local_1e0;

+  undefined8 local_1d8;

+  undefined8 uStack_1d0;

+  float local_1c8;

+  float local_1c4;

+  undefined4 local_1c0;

+  undefined8 local_1bc;

+  undefined8 local_1a8;

+  undefined8 uStack_1a0;

+  float local_198;

+  float fStack_194;

+  undefined8 local_190;

+  undefined8 uStack_188;

+  float local_180 [6];

+  undefined **local_168;

+  undefined8 local_160;

+  undefined8 *local_158;

+  undefined8 *local_150;

+  undefined8 *local_148;

+  undefined8 local_140;

+  undefined8 uStack_138;

+  undefined8 local_130;

+  undefined **local_128;

+  undefined8 local_120;

+  undefined4 *local_118;

+  undefined8 *local_110;

+  undefined8 *local_108;

+  undefined4 local_100;

+  undefined4 uStack_fc;

+  float fStack_f8;

+  float fStack_f4;

+  undefined8 local_f0;

+  ulonglong local_e8;

+  

+  local_e8 = __security_cookie ^ (ulonglong)auStackY_268;

+  if (((*(float *)param_1 <= 0.0) || (*(float *)(param_1 + 4) <= 0.0)) ||

+     (*(longlong *)(this + 0x80) == 0)) {

+    MilInstrumentationCheckHR_MaybeFailFast

+              (0x14,(long *)&`public:_virtual_long___cdecl_CSwapchainRenderStrategy::GetLayoutParameters(CSurfaceBrush_const*___ptr64,D2D_SIZE_F_const&___ptr64,D2D_SIZE_F*___ptr64,D2D_RECT_F*___ptr64,D2D_MATRIX_3X2_F*___ptr64)const___ptr64'

+                             ::__l2::MILINSTRUMENTATIONHRESULTLIST,2,-0x7767fff9,700,(void *)0x0);

+    return -0x7767fff9;

+  }

+  this_00 = *(CSwapchainRenderStrategy **)(this + 0x88);

+  iVar7 = 0;

+  local_208 = 0;

+  local_180[4] = 0.0;

+  local_180[5] = 0.0;

+  local_190 = 0;

+  uStack_188 = 0;

+  local_210 = (CRectanglesShape *)0x0;

+  local_180[0] = 0.0;

+  local_180[1] = 0.0;

+  local_180[2] = 0.0;

+  local_180[3] = 0.0;

+  pcVar2 = *(code **)(*(longlong *)this_00 + 0x48);

+  if (pcVar2 == CVisualSurfaceRenderStrategy::GetLayoutParameters) {

+    this_04 = GetSurface(this);

+    pDVar8 = CVisualSurface::GetSourceSize((CVisualSurface *)this_04);

+    local_208 = *(undefined8 *)pDVar8;

+    local_180[4] = 0.0;

+    local_180[5] = 0.0;

+    local_190 = 0;

+    local_180[0] = 1.0;

+    local_180[1] = 0.0;

+    local_180[2] = 0.0;

+    local_180[3] = 1.0;

+    uStack_188 = CONCAT44(*(float *)(pDVar8 + 4) + 0.0,*(float *)pDVar8 + 0.0);

+    fVar12 = *(float *)pDVar8;

+    fVar13 = *(float *)(pDVar8 + 4);

+    fVar11 = 0.0;

+    fVar17 = 0.0;

+  }

+  else {

+    if (pcVar2 == CSwapchainRenderStrategy::GetLayoutParameters) {

+      iVar7 = CSwapchainRenderStrategy::GetLayoutParameters

+                        (this_00,this,param_1,(D2D_SIZE_F *)&local_208,(D2D_RECT_F *)&local_190,

+                         (D2D_MATRIX_3X2_F *)local_180);

+    }

+    else {

+      iVar7 = (*pcVar2)(this_00,this);

+    }

+    if (iVar7 < 0) {

+      MilInstrumentationCheckHR_MaybeFailFast

+                (0x14,(long *)&`public:_virtual_long___cdecl_CSwapchainRenderStrategy::GetLayoutParameters(CSurfaceBrush_const*___ptr64,D2D_SIZE_F_const&___ptr64,D2D_SIZE_F*___ptr64,D2D_RECT_F*___ptr64,D2D_MATRIX_3X2_F*___ptr64)const___ptr64'

+                               ::__l2::MILINSTRUMENTATIONHRESULTLIST,2,iVar7,0x2cd,(void *)0x0);

+      std::unique_ptr<CShape,std::default_delete<CShape>_>::

+      ~unique_ptr<CShape,std::default_delete<CShape>_>

+                ((unique_ptr<CShape,std::default_delete<CShape>_> *)&local_210);

+      return iVar7;

+    }

+    fVar12 = (float)local_208;

+    fVar13 = local_208._4_4_;

+    fVar11 = local_180[5];

+    fVar17 = local_180[4];

+  }

+  iVar1 = *(int *)(this + 0x78);

+  if (iVar1 == 1) {

+    uStack_1a0._0_4_ = *(float *)param_1;

+    uStack_1a0._4_4_ = *(float *)(param_1 + 4);

+    local_1a8._0_4_ = 0.0;

+    local_200 = 0.0;

+  }

+  else {

+    uStack_1a0._0_4_ = fVar12;

+    uStack_1a0._4_4_ = fVar13;

+    if ((iVar1 != 0) &&

+       ((iVar1 == 2 || (uStack_1a0._0_4_ = 0.0, uStack_1a0._4_4_ = 0.0, iVar1 == 3)))) {

+      fVar16 = *(float *)param_1;

+      fVar19 = *(float *)(param_1 + 4);

+      if ((fVar12 != fVar16) ||

+         (uStack_1a0._0_4_ = fVar12, uStack_1a0._4_4_ = fVar13, fVar13 != fVar19)) {

+        uStack_1a0._4_4_ = fVar16 / (fVar12 / fVar13);

+        uStack_1a0._0_4_ = fVar16;

+        if (fVar19 <= uStack_1a0._4_4_ != (iVar1 == 3)) {

+          uStack_1a0._0_4_ = (fVar12 / fVar13) * fVar19;

+          uStack_1a0._4_4_ = fVar19;

+        }

+      }

+    }

+    local_1a8._0_4_ = (*(float *)param_1 - (float)uStack_1a0) * *(float *)(this + 0x70);

+    local_200 = (*(float *)(param_1 + 4) - uStack_1a0._4_4_) * *(float *)(this + 0x74);

+    uStack_1a0._0_4_ = (float)local_1a8 + (float)uStack_1a0;

+    uStack_1a0._4_4_ = local_200 + uStack_1a0._4_4_;

+  }

+  this_01 = *(CComponentTransform2D **)(this + 0x90);

+  fVar12 = ((float)uStack_1a0 - (float)local_1a8) / fVar12;

+  fVar13 = (uStack_1a0._4_4_ - local_200) / fVar13;

+  fVar18 = local_180[0] * fVar12 + local_180[1] * 0.0;

+  fVar16 = local_180[1] * fVar13 + local_180[0] * 0.0;

+  fVar19 = local_180[2] * fVar12 + local_180[3] * 0.0;

+  fVar15 = local_180[3] * fVar13 + local_180[2] * 0.0;

+  fVar14 = fVar11 * fVar13 + fVar17 * 0.0 + local_200;

+  fVar13 = fVar17 * fVar12 + fVar11 * 0.0 + (float)local_1a8;

+  local_218 = CONCAT44(fVar14,fVar13);

+  fVar12 = fVar18;

+  local_1a8._4_4_ = local_200;

+  if (this_01 != (CComponentTransform2D *)0x0) {

+    local_228._0_4_ = fVar18;

+    local_228._4_4_ = fVar16;

+    uStack_220._0_4_ = fVar19;

+    uStack_220._4_4_ = fVar15;

+    if (*(code **)(*(longlong *)this_01 + 0xd0) == CComponentTransform2D::GetRealization) {

+      CComponentTransform2D::GetRealization(this_01,param_1,(D2D_MATRIX_3X2_F *)&local_1a8);

+    }

+    else {

+      (**(code **)(*(longlong *)this_01 + 0xd0))();

+    }

+    fVar12 = (float)uStack_1a0 * fVar16 + (float)local_1a8 * fVar18;

+    fVar11 = local_1a8._4_4_ * fVar19;

+    fVar17 = fVar13 * local_1a8._4_4_;

+    fVar16 = uStack_1a0._4_4_ * fVar16 + local_1a8._4_4_ * fVar18;

+    fVar19 = (float)uStack_1a0 * fVar15 + (float)local_1a8 * fVar19;

+    fVar15 = fVar11 + uStack_1a0._4_4_ * fVar15;

+    fVar13 = fVar13 * (float)local_1a8 + fVar14 * (float)uStack_1a0 + local_198;

+    fVar14 = fVar17 + fVar14 * uStack_1a0._4_4_ + fStack_194;

+    local_218 = CONCAT44(fVar14,fVar13);

+  }

+  if (((*(float *)(this + 0x98) == 1.0) && (*(float *)(this + 0x9c) == 0.0)) &&

+     ((*(float *)(this + 0xa0) == 0.0 &&

+      (((*(float *)(this + 0xa4) == 1.0 && (*(float *)(this + 0xa8) == 0.0)) &&

+       (*(float *)(this + 0xac) == 0.0)))))) {

+    bVar4 = true;

+  }

+  else {

+    bVar4 = false;

+  }

+  local_228._0_4_ = fVar12;

+  local_228._4_4_ = fVar16;

+  uStack_220._0_4_ = fVar19;

+  uStack_220._4_4_ = fVar15;

+  if (!bVar4) {

+    D2D1::Matrix3x2F::SetProduct

+              ((Matrix3x2F *)&local_1a8,(Matrix3x2F *)&local_228,(Matrix3x2F *)(this + 0x98));

+    local_218 = CONCAT44(fStack_194,local_198);

+    fVar12 = (float)local_1a8;

+    fVar16 = local_1a8._4_4_;

+    fVar19 = (float)uStack_1a0;

+    fVar15 = uStack_1a0._4_4_;

+    fVar13 = local_198;

+    fVar14 = fStack_194;

+  }

+  pCVar3 = local_210;

+  if (param_3 == (CShape **)0x0) {

+    *(float *)param_2 = fVar12;

+    *(float *)(param_2 + 4) = fVar16;

+    *(float *)(param_2 + 8) = fVar19;

+    *(float *)(param_2 + 0xc) = fVar15;

+    *(ulonglong *)(param_2 + 0x10) = CONCAT44(fVar14,fVar13);

+    *(undefined4 *)(param_2 + 0x18) = (undefined4)local_190;

+    *(undefined4 *)(param_2 + 0x1c) = local_190._4_4_;

+    *(undefined4 *)(param_2 + 0x20) = (undefined4)uStack_188;

+    *(undefined4 *)(param_2 + 0x24) = uStack_188._4_4_;

+    if (local_210 == (CRectanglesShape *)0x0) {

+      return iVar7;

+    }

+    if ((code *)**(undefined8 **)local_210 == CRectanglesShape::_scalar_deleting_destructor_) {

+      *(undefined ***)local_210 = &CRectanglesShape::_vftable_;

+      lVar9 = *(longlong *)(local_210 + 0x18) - *(longlong *)(local_210 + 0x10) >> 4;

+      if (lVar9 != 0) {

+        *(longlong *)(local_210 + 0x18) = *(longlong *)(local_210 + 0x18) + lVar9 * -0x10;

+      }

+      this_02 = *(CMILCOMBaseWeakRefSource<CResourceDeleter> **)(local_210 + 0x38);

+      if (this_02 != (CMILCOMBaseWeakRefSource<CResourceDeleter> *)0x0) {

+        if (*(code **)(*(longlong *)this_02 + 0x10) ==

+            CMILCOMBaseWeakRefSource<CResourceDeleter>::InternalRelease) {

+          CMILCOMBaseWeakRefSource<CResourceDeleter>::InternalRelease(this_02);

+        }

+        else {

+          (**(code **)(*(longlong *)this_02 + 0x10))();

+        }

+        *(undefined8 *)(pCVar3 + 0x38) = 0;

+      }

+      lVar9 = *(longlong *)(pCVar3 + 0x18) - *(longlong *)(pCVar3 + 0x10) >> 4;

+      if (lVar9 != 0) {

+        *(longlong *)(pCVar3 + 0x18) = *(longlong *)(pCVar3 + 0x18) + lVar9 * -0x10;

+      }

+      lpMem = *(CRectanglesShape **)(pCVar3 + 0x10);

+      *(undefined8 *)(pCVar3 + 0x10) = 0;

+      if (lpMem == pCVar3 + 0x28) {

+        lpMem = (CRectanglesShape *)0x0;

+      }

+      if (lpMem != (CRectanglesShape *)0x0) {

+        hHeap = GetProcessHeap();

+        HeapFree(hHeap,0,lpMem);

+      }

+      this_03 = *(CMILRefCountBaseT<ID2D1GeometrySink,CMilObjectDeleter> **)(pCVar3 + 8);

+      if (this_03 != (CMILRefCountBaseT<ID2D1GeometrySink,CMilObjectDeleter> *)0x0) {

+        *(undefined8 *)(pCVar3 + 8) = 0;

+        if (*(code **)(*(longlong *)this_03 + 0x10) ==

+            CMILCOMBaseT<ID2D1GeometrySink,ID2D1GeometrySink,CMilObjectDeleter>::Release) {

+          CMILRefCountBaseT<ID2D1GeometrySink,CMilObjectDeleter>::InternalRelease(this_03);

+        }

+        else {

+          (**(code **)(*(longlong *)this_03 + 0x10))();

+        }

+      }

+      CThreadLocalObjectCache<CRectanglesShape,CRectanglesShape>::Free(pCVar3);

+      return iVar7;

+    }

+    (*(code *)**(undefined8 **)local_210)(local_210,1);

+    return iVar7;

+  }

+  fStack_f8 = *(float *)param_1 + 0.0;

+  local_128 = &CRectanglesShape::_vftable_;

+  fStack_f4 = *(float *)(param_1 + 4) + 0.0;

+  local_168 = &CRectanglesShape::_vftable_;

+  local_118 = &local_100;

+  local_158 = &local_140;

+  local_148 = &local_130;

+  local_108 = &local_f0;

+  local_150 = &local_130;

+  local_110 = &local_f0;

+  local_228 = &local_210;

+  pCVar10 = (CMILMatrix *)0x0;

+  local_100 = 0;

+  uStack_fc = 0;

+  local_120 = 0;

+  local_f0 = 0;

+  local_1a8 = local_190;

+  uStack_1a0 = uStack_188;

+  local_160 = 0;

+  local_140 = local_190;

+  uStack_138 = uStack_188;

+  local_130 = 0;

+  local_1f0 = 0;

+  local_1e0 = 0;

+  local_1d8 = 0;

+  uStack_1d0 = 0x3f800000;

+  local_1c0 = 0;

+  local_1bc = 0x28083f800000;

+  uStack_220 = (CRectanglesShape *)0x0;

+  local_218 = CONCAT71(local_218._1_7_,1);

+  local_1f8 = fVar12;

+  local_1f4 = fVar16;

+  local_1e8 = fVar19;

+  local_1e4 = fVar15;

+  local_1c8 = fVar13;

+  local_1c4 = fVar14;

+  lVar6 = CShape::TryOptimizedCombinePaths

+                    ((CShape *)&local_128,(CMILMatrix *)0x0,(CShape *)&local_168,

+                     (CMILMatrix *)&local_1f8,1,(CShape **)&uStack_220);

+  if (lVar6 < 0) {

+    uVar20 = 0x1c8;

+  }

+  else {

+    if ((uStack_220 != (CRectanglesShape *)0x0) ||

+       (lVar6 = CShape::D2DCombine((CShape *)&local_128,pCVar10,(CShape *)&local_168,

+                                   (CMILMatrix *)&local_1f8,1,(CShape **)&uStack_220), -1 < lVar6))

+    goto LAB_0;

+    uVar20 = 0x1d3;

+  }

+  MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar6,uVar20,(void *)0x0);

+LAB_0:

+  if ((char)local_218 != '\0') {

+    pCVar3 = *local_228;

+    *local_228 = uStack_220;

+    if (pCVar3 != (CRectanglesShape *)0x0) {

+      if ((code *)**(undefined8 **)pCVar3 == CRectanglesShape::_scalar_deleting_destructor_) {

+        CRectanglesShape::~CRectanglesShape(pCVar3);

+        CThreadLocalObjectCache<CRectanglesShape,CRectanglesShape>::Free(pCVar3);

+      }

+      else {

+        (*(code *)**(undefined8 **)pCVar3)(pCVar3,1);

+      }

+    }

+  }

+  if (lVar6 < 0) {

+    MilInstrumentationCheckHR_MaybeFailFast

+              (0x14,(long *)&`public:_virtual_long___cdecl_CSwapchainRenderStrategy::GetLayoutParameters(CSurfaceBrush_const*___ptr64,D2D_SIZE_F_const&___ptr64,D2D_SIZE_F*___ptr64,D2D_RECT_F*___ptr64,D2D_MATRIX_3X2_F*___ptr64)const___ptr64'

+                             ::__l2::MILINSTRUMENTATIONHRESULTLIST,2,lVar6,0x301,(void *)0x0);

+    CRectanglesShape::~CRectanglesShape((CRectanglesShape *)&local_168);

+    CRectanglesShape::~CRectanglesShape((CRectanglesShape *)&local_128);

+    std::unique_ptr<CShape,std::default_delete<CShape>_>::

+    ~unique_ptr<CShape,std::default_delete<CShape>_>

+              ((unique_ptr<CShape,std::default_delete<CShape>_> *)&local_210);

+  }

+  else {

+    if (*(code **)(*(longlong *)local_210 + 0x10) == CRectanglesShape::IsEmpty) {

+      cVar5 = CRectanglesShape::IsEmpty(local_210);

+    }

+    else {

+      cVar5 = (**(code **)(*(longlong *)local_210 + 0x10))();

+    }

+    if (cVar5 == '\0') {

+      CRectanglesShape::~CRectanglesShape((CRectanglesShape *)&local_168);

+      CRectanglesShape::~CRectanglesShape((CRectanglesShape *)&local_128);

+      *(float *)param_2 = fVar12;

+      *(float *)(param_2 + 4) = fVar16;

+      *(float *)(param_2 + 8) = fVar19;

+      *(float *)(param_2 + 0xc) = fVar15;

+      *(undefined8 *)(param_2 + 0x18) = local_190;

+      *(undefined8 *)(param_2 + 0x20) = uStack_188;

+      *(ulonglong *)(param_2 + 0x10) = CONCAT44(fVar14,fVar13);

+      *param_3 = (CShape *)local_210;

+    }

+    else {

+      lVar6 = -0x7767fff9;

+      MilInstrumentationCheckHR_MaybeFailFast

+                (0x14,(long *)&`public:_virtual_long___cdecl_CSwapchainRenderStrategy::GetLayoutParameters(CSurfaceBrush_const*___ptr64,D2D_SIZE_F_const&___ptr64,D2D_SIZE_F*___ptr64,D2D_RECT_F*___ptr64,D2D_MATRIX_3X2_F*___ptr64)const___ptr64'

+                               ::__l2::MILINSTRUMENTATIONHRESULTLIST,2,-0x7767fff9,0x306,(void *)0x0

+                );

+      CRectanglesShape::~CRectanglesShape((CRectanglesShape *)&local_168);

+      CRectanglesShape::~CRectanglesShape((CRectanglesShape *)&local_128);

+      pCVar3 = local_210;

+      if (local_210 != (CRectanglesShape *)0x0) {

+        if ((code *)**(undefined8 **)local_210 == CRectanglesShape::_scalar_deleting_destructor_) {

+          CRectanglesShape::~CRectanglesShape(local_210);

+          CThreadLocalObjectCache<CRectanglesShape,CRectanglesShape>::Free(pCVar3);

+        }

+        else {

+          (*(code *)**(undefined8 **)local_210)(local_210,1);

+        }

+      }

+    }

+  }

+  return lVar6;

+}

+
```

## `CCompositionSurfaceBitmap::CalcImageTransform`  (modified)

```diff
--- CCompositionSurfaceBitmap::CalcImageTransform
+++ CCompositionSurfaceBitmap::CalcImageTransform
@@ -1,609 +1,260 @@
 

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

 /* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

    guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Removing unreachable block (ram,0x00018005ed7b) */

+/* public: bool __cdecl CCompositionSurfaceBitmap::CalcImageTransform(struct D2D_SIZE_F const &

+   __ptr64,class CMILMatrix * __ptr64,class TMilRect_<float,struct D2D_RECT_F,struct

+   D3D_RECT_F,struct D2D_POINTANDSIZE_F,struct RectUniqueness::NotNeeded> * __ptr64)const __ptr64 */

 

 bool __thiscall

-ShrinkableArray<CBatchCommand*___ptr64,UniqueLifetime<CBatchCommand*___ptr64>_>::CalcImageTransform

+CCompositionSurfaceBitmap::CalcImageTransform

           (CCompositionSurfaceBitmap *this,D2D_SIZE_F *param_1,CMILMatrix *param_2,

           TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

           *param_3)

 

 {

-  CWatermarkStack<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,8,2,8>

-  *this_00;

-  float *pfVar1;

-  undefined1 uVar2;

-  uint uVar3;

-  code *pcVar4;

-  CRectanglesShape *this_01;

-  CMILCOMBaseWeakRefSource<CResourceDeleter> *this_02;

-  CMILRefCountBaseT<ID2D1GeometrySink,CMilObjectDeleter> *this_03;

-  undefined1 auVar5 [16];

-  undefined8 uVar6;

-  byte bVar7;

-  bool bVar8;

-  int iVar9;

-  int iVar10;

-  int iVar11;

-  uint uVar12;

-  ulonglong uVar13;

-  longlong in_RAX;

-  char *pcVar14;

-  longlong lVar15;

-  LPVOID lpTlsValue;

-  HANDLE pvVar16;

-  void *_Dst;

-  CThreadContext *this_04;

-  undefined8 *puVar18;

-  ulonglong uVar19;

-  CRoundedRectangleShape *lpMem;

-  undefined8 *unaff_RBP;

-  CRoundedRectangleShape *unaff_RSI;

-  longlong *plVar20;

-  CMILMatrix *pCVar21;

-  D2D_POINT_2F *pDVar22;

-  uint uVar23;

-  undefined8 unaff_R12;

-  char unaff_R13B;

-  int iVar24;

-  CRoundedRectangleShape *unaff_R14;

-  long unaff_R15D;

-  float fVar25;

-  float fVar26;

-  float fVar27;

-  float fVar28;

-  float fVar29;

-  float fVar30;

-  float fVar31;

-  float fVar32;

-  float unaff_XMM10_Da;

-  uint unaff_XMM14_Da;

-  char cStackX_20;

-  undefined7 uVar17;

+  float fVar1;

+  undefined8 uVar2;

+  undefined8 uVar3;

+  char cVar4;

+  char cVar5;

+  bool bVar6;

+  CGlobalCompositionSurfaceInfo *pCVar7;

+  code *pcVar8;

+  longlong *plVar9;

+  float fVar10;

+  float fVar11;

+  float fVar12;

+  float fVar13;

+  float fVar14;

+  float fVar15;

+  undefined1 auStackY_138 [32];

+  int local_f8;

+  undefined8 local_f0;

+  undefined8 uStack_e8;

+  ulonglong local_d8 [6];

+  undefined8 local_a8;

+  undefined8 uStack_a0;

+  undefined4 local_98;

+  float local_88 [4];

+  float local_78 [4];

+  ulonglong local_68;

   

-  uVar23 = (uint)param_3;

-  uVar12 = (uint)param_2;

-  *(char *)(in_RAX + -0x75) = *(char *)(in_RAX + -0x75) + (char)this;

-  bVar7 = bRam80858b4c50458b48;

-  uVar17 = (undefined7)((ulonglong)in_RAX >> 8);

-  pcVar14 = (char *)CONCAT71(uVar17,bRam80858b4c50458b48);

-  *pcVar14 = *pcVar14 + bRam80858b4c50458b48;

-  pcVar14[-0x75] = pcVar14[-0x75] + (char)this;

-  uVar13 = CONCAT71(uVar17,bVar7 | (byte)((ulonglong)this >> 8));

-  iVar9 = (int)uVar13;

-  plVar20 = (longlong *)(uVar13 & 0xffffffff);

-  if (iVar9 < 0) {

-    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,iVar9,0x187,(void *)0x0);

-    goto LAB_0;

-  }

-  lVar15 = *(longlong *)unaff_R14;

-  unaff_RBP[10] = 0;

-  unaff_RBP[0xb] = 0;

-  pcVar4 = *(code **)(lVar15 + 0x30);

-  if (pcVar4 == CRectanglesShape::GetTightBounds) {

-    puVar18 = *(undefined8 **)(unaff_R14 + 0x10);

-    uVar13 = *(longlong *)(unaff_R14 + 0x18) - (longlong)puVar18 >> 4;

-    if (uVar13 == 0) goto LAB_1;

-    uVar6 = puVar18[1];

-    uVar19 = 1;

-    unaff_RBP[10] = *puVar18;

-    unaff_RBP[0xb] = uVar6;

-    if (1 < uVar13) {

-      lVar15 = 0x10;

-      do {

-        TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded>::UnionUnsafe

-                  ((TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded> *)

-                   (unaff_RBP + 10),

-                   (TMilRect<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_RectUniqueness::NotNeeded>

-                    *)((longlong)puVar18 + lVar15));

-        uVar23 = (uint)param_3;

-        uVar12 = (uint)param_2;

-        puVar18 = *(undefined8 **)(unaff_R14 + 0x10);

-        lVar15 = lVar15 + 0x10;

-        uVar19 = uVar19 + 1;

-      } while (uVar19 < (ulonglong)(*(longlong *)(unaff_R14 + 0x18) - (longlong)puVar18 >> 4));

-    }

-    bVar8 = CMILMatrix::IsIdentity<0>((CMILMatrix *)(unaff_RBP + -10));

-    if (bVar8) goto LAB_1;

-    bVar8 = CMILMatrix::IsTranslateIgnoreZ<1>((CMILMatrix *)(unaff_RBP + -10));

-    if (bVar8) {

-      unaff_XMM10_Da = *(float *)(unaff_RBP + 10) + *(float *)(unaff_RBP + -4);

-      fVar31 = *(float *)((longlong)unaff_RBP + 0x54) + *(float *)((longlong)unaff_RBP + -0x1c);

-      fVar32 = *(float *)(unaff_RBP + 0xb) + *(float *)(unaff_RBP + -4);

-      fVar26 = *(float *)((longlong)unaff_RBP + 0x5c) + *(float *)((longlong)unaff_RBP + -0x1c);

-      *(float *)(unaff_RBP + 10) = unaff_XMM10_Da;

-      *(float *)((longlong)unaff_RBP + 0x54) = fVar31;

-      *(float *)(unaff_RBP + 0xb) = fVar32;

-      *(float *)((longlong)unaff_RBP + 0x5c) = fVar26;

+  local_68 = __security_cookie ^ (ulonglong)auStackY_138;

+  pCVar7 = *(CGlobalCompositionSurfaceInfo **)(this + 0x60);

+  if (pCVar7 == (CGlobalCompositionSurfaceInfo *)0x0) {

+LAB_0:

+    *(undefined8 *)param_2 = 0x3f800000;

+    *(undefined8 *)(param_2 + 8) = 0;

+    *(undefined4 *)(param_2 + 0x10) = 0;

+    *(undefined8 *)(param_2 + 0x14) = 0x3f800000;

+    *(undefined8 *)(param_2 + 0x1c) = 0;

+    *(undefined4 *)(param_2 + 0x24) = 0;

+    *(undefined8 *)(param_2 + 0x28) = 0x3f800000;

+    *(undefined8 *)(param_2 + 0x30) = 0;

+    *(undefined4 *)(param_2 + 0x38) = 0;

+    *(undefined4 *)(param_2 + 0x3c) = 0x3f800000;

+    param_2[0x40] = (CMILMatrix)0xaa;

+    param_2[0x41] = (CMILMatrix)((byte)param_2[0x41] & 0xe9 | 0x29);

+    *(undefined8 *)(param_3 + 8) = 0;

+    *(undefined8 *)param_3 = 0;

+    return false;

+  }

+  if (*(code **)(*(longlong *)pCVar7 + 0x30) ==

+      CGlobalCompositionSurfaceInfo::GetRenderingRealization) {

+    if (*(longlong *)(pCVar7 + 0xd0) == 0) {

+      CGlobalCompositionSurfaceInfo::ForceUpdateRenderingRealization(pCVar7);

+    }

+    plVar9 = (longlong *)(*(longlong *)(pCVar7 + 0xd0) + 8);

+    if (*(longlong *)(pCVar7 + 0xd0) == 0) {

+      plVar9 = (longlong *)0x0;

+    }

+  }

+  else {

+    plVar9 = (longlong *)(**(code **)(*(longlong *)pCVar7 + 0x30))(pCVar7);

+  }

+  if (plVar9 == (longlong *)0x0) goto LAB_0;

+  pCVar7 = *(CGlobalCompositionSurfaceInfo **)(this + 0x60);

+  if (pCVar7 == (CGlobalCompositionSurfaceInfo *)0x0) {

+LAB_1:

+    local_f8 = 1;

+  }

+  else {

+    pcVar8 = *(code **)(*(longlong *)pCVar7 + 0x1c8);

+    if (pcVar8 == CGlobalCompositionSurfaceInfo::GetSizePreference) {

+      pCVar7 = (CGlobalCompositionSurfaceInfo *)

+               CGlobalCompositionSurfaceInfo::GetSwapChainRealization(pCVar7);

+      if (pCVar7 == (CGlobalCompositionSurfaceInfo *)0x0) goto LAB_1;

+      pcVar8 = *(code **)(*(longlong *)pCVar7 + 0x68);

+    }

+    local_f8 = (*pcVar8)(pCVar7);

+  }

+  cVar4 = (**(code **)(*plVar9 + 0x28))(plVar9,param_2,param_3);

+  pCVar7 = *(CGlobalCompositionSurfaceInfo **)(this + 0x60);

+  fVar15 = 0.0;

+  local_88[0] = 0.0;

+  local_88[1] = 0.0;

+  local_88[2] = 0.0;

+  local_88[3] = 0.0;

+  if (pCVar7 == (CGlobalCompositionSurfaceInfo *)0x0) {

+LAB_2:

+    cVar5 = '\0';

+    goto LAB_3;

+  }

+  pcVar8 = *(code **)(*(longlong *)pCVar7 + 0x1e0);

+  if (pcVar8 == CGlobalCompositionSurfaceInfo::GetScaledLetterboxingMargins) {

+    pCVar7 = (CGlobalCompositionSurfaceInfo *)

+             CGlobalCompositionSurfaceInfo::GetSwapChainRealization(pCVar7);

+    if (pCVar7 == (CGlobalCompositionSurfaceInfo *)0x0) goto LAB_2;

+    pcVar8 = *(code **)(*(longlong *)pCVar7 + 0x100);

+    if (pcVar8 != CDxHandleBitmapRealization::GetScaledLetterboxingMargins) goto LAB_4;

+    cVar5 = CBitmapRealization::GetScaledLetterboxingMargins

+                      ((CBitmapRealization *)(pCVar7 + -0x148),

+                       (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                        *)local_88);

+  }

+  else if (pcVar8 == CDxHandleBitmapRealization::GetScaledLetterboxingMargins) {

+    cVar5 = CDxHandleBitmapRealization::GetScaledLetterboxingMargins

+                      ((CDxHandleBitmapRealization *)pCVar7,

+                       (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                        *)local_88);

+  }

+  else {

+LAB_4:

+    if (pcVar8 == CDxHandleYUVBitmapRealization::GetScaledLetterboxingMargins) {

+      cVar5 = CDxHandleYUVBitmapRealization::GetScaledLetterboxingMargins

+                        ((CDxHandleYUVBitmapRealization *)pCVar7,

+                         (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                          *)local_88);

     }

     else {

-      bVar8 = CMILMatrix::IsTranslateAndScaleIgnoreZ<1>((CMILMatrix *)(unaff_RBP + -10));

-      if (!bVar8) {

-        pDVar22 = (D2D_POINT_2F *)(unaff_RBP + 0x10);

-        CMILMatrix::Transform2DRectToPerspective

-                  ((CMILMatrix *)(unaff_RBP + -10),(D2D_RECT_F *)(unaff_RBP + 10),pDVar22);

-        uVar12 = (uint)pDVar22;

-        unaff_RBP[0xc] = 4;

-        unaff_RBP[0xd] = unaff_RBP + 0x10;

-        TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded>::

-        SetToBoundsOfUnorderedPointSet<D2D_POINT_2F>

-                  ((TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded> *)

-                   (unaff_RBP + 10),unaff_RBP + 0xc);

-        goto LAB_1;

-      }

-      fVar25 = *(float *)(unaff_RBP + -10);

-      fVar28 = *(float *)((longlong)unaff_RBP + -0x3c);

-      unaff_XMM10_Da = fVar25 * *(float *)(unaff_RBP + 10) + *(float *)(unaff_RBP + -4);

-      fVar31 = fVar28 * *(float *)((longlong)unaff_RBP + 0x54) +

-               *(float *)((longlong)unaff_RBP + -0x1c);

-      fVar32 = fVar25 * *(float *)(unaff_RBP + 0xb) + *(float *)(unaff_RBP + -4);

-      fVar30 = fVar28 * *(float *)((longlong)unaff_RBP + 0x5c) +

-               *(float *)((longlong)unaff_RBP + -0x1c);

-      *(float *)(unaff_RBP + 10) = unaff_XMM10_Da;

-      *(float *)((longlong)unaff_RBP + 0x54) = fVar31;

-      *(float *)(unaff_RBP + 0xb) = fVar32;

-      *(float *)((longlong)unaff_RBP + 0x5c) = fVar30;

-      fVar26 = fVar30;

-      if ((fVar25 <= 0.0) || (fVar28 <= 0.0)) {

-        fVar25 = fVar32;

-        if (fVar32 < unaff_XMM10_Da) {

-          *(float *)(unaff_RBP + 10) = fVar32;

-          *(float *)(unaff_RBP + 0xb) = unaff_XMM10_Da;

-          fVar25 = unaff_XMM10_Da;

-          unaff_XMM10_Da = fVar32;

-        }

-        fVar32 = fVar25;

-        if (fVar30 < fVar31) {

-          *(float *)((longlong)unaff_RBP + 0x54) = fVar30;

-          *(float *)((longlong)unaff_RBP + 0x5c) = fVar31;

-          fVar26 = fVar31;

-          fVar31 = fVar30;

-        }

-      }

-    }

-  }

-  else {

-    pCVar21 = (CMILMatrix *)(unaff_RBP + -10);

-    if (pcVar4 == CRoundedRectangleShape::GetTightBounds) {

-      iVar9 = CRoundedRectangleShape::GetTightBounds

-                        (unaff_R14,

-                         (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

-                          *)(unaff_RBP + 10),pCVar21);

-      uVar12 = (uint)pCVar21;

-    }

-    else if (pcVar4 == CRegionShape::GetTightBounds) {

-      iVar9 = CRegionShape::GetTightBounds

-                        ((CRegionShape *)unaff_R14,

-                         (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

-                          *)(unaff_RBP + 10),pCVar21);

-      uVar12 = (uint)pCVar21;

-    }

-    else {

-      iVar9 = (*pcVar4)();

-      uVar12 = (uint)pCVar21;

-    }

-    if (iVar9 < 0) {

-      if (iVar9 != -0x7767fff6) {

-                    /* WARNING: Subroutine does not return */

-        ModuleFailFastForHRESULT(iVar9,unaff_RBP[0x33]);

-      }

-      *(float *)(unaff_RBP + 10) = unaff_XMM10_Da;

-      fVar32 = 0.0;

-      *(undefined4 *)((longlong)unaff_RBP + 0x5c) = 0;

-      fVar31 = 0.0;

-      *(undefined4 *)(unaff_RBP + 0xb) = 0;

-      *(undefined4 *)((longlong)unaff_RBP + 0x54) = 0;

-      fVar26 = 0.0;

-      goto LAB_2;

-    }

-LAB_1:

-    unaff_XMM10_Da = *(float *)(unaff_RBP + 10);

-    fVar31 = *(float *)((longlong)unaff_RBP + 0x54);

-    fVar32 = *(float *)(unaff_RBP + 0xb);

-    fVar26 = *(float *)((longlong)unaff_RBP + 0x5c);

-  }

-LAB_2:

-  if (cStackX_20 == '\0') {

-    if ((float)((uint)unaff_XMM10_Da & unaff_XMM14_Da) < 8388608.0) {

-      fVar25 = floorf(unaff_XMM10_Da);

-      unaff_XMM10_Da = (float)(int)fVar25;

-    }

-    *(float *)(unaff_RBP + 10) = unaff_XMM10_Da;

-    if ((float)((uint)fVar31 & unaff_XMM14_Da) < 8388608.0) {

-      fVar31 = floorf(fVar31);

-      fVar31 = (float)(int)fVar31;

-    }

-    *(float *)((longlong)unaff_RBP + 0x54) = fVar31;

-    if ((float)((uint)fVar32 & unaff_XMM14_Da) < 8388608.0) {

-      fVar32 = ceilf(fVar32);

-      fVar32 = (float)(int)fVar32;

-    }

-    *(float *)(unaff_RBP + 0xb) = fVar32;

-    if ((float)((uint)fVar26 & unaff_XMM14_Da) < 8388608.0) {

-      fVar26 = ceilf(fVar26);

-      fVar26 = (float)(int)fVar26;

-    }

-    *(float *)((longlong)unaff_RBP + 0x5c) = fVar26;

-  }

-  if ((plVar20[1] == *plVar20) || (*(longlong *)(plVar20[1] + -0xa8) == 0)) {

-    iVar9 = *(int *)(unaff_RBP + 0x38);

-    if (iVar9 == 1) {

-      iVar24 = 0x7fffffff;

-      fVar25 = unaff_XMM10_Da - 0.5;

-      iVar11 = 0x7fffffff;

-      if (fVar25 < -2.1474836e+09) {

-        iVar10 = -0x80000000;

+      cVar5 = (*pcVar8)();

+    }

+  }

+  if (cVar5 == '\0') goto LAB_3;

+  if ((8.138021e-05 <= ABS(local_88[0])) || (8.138021e-05 <= ABS(local_88[1]))) {

+    *(float *)(param_2 + 0x30) =

+         local_88[1] * *(float *)(param_2 + 0x10) + local_88[0] * *(float *)param_2 +

+         *(float *)(param_2 + 0x20) * 0.0 + *(float *)(param_2 + 0x30);

+    *(float *)(param_2 + 0x34) =

+         local_88[0] * *(float *)(param_2 + 4) + local_88[1] * *(float *)(param_2 + 0x14) +

+         *(float *)(param_2 + 0x24) * 0.0 + *(float *)(param_2 + 0x34);

+    *(float *)(param_2 + 0x38) =

+         local_88[0] * *(float *)(param_2 + 8) + local_88[1] * *(float *)(param_2 + 0x18) +

+         *(float *)(param_2 + 0x28) * 0.0 + *(float *)(param_2 + 0x38);

+    cVar4 = (char)((char)param_2[0x41] << 2) >> 6;

+    if (cVar4 < '\x01') {

+      if (cVar4 < '\0') {

+        fVar10 = *(float *)(param_2 + 0x2c);

       }

       else {

-        iVar10 = iVar11;

-        if (fVar25 < 2.1474836e+09) {

-          fVar25 = ceilf(fVar25);

-          iVar10 = (int)fVar25;

-        }

+        if (8.138021e-05 <=

+            ABS((ABS(*(float *)(param_2 + 0x1c)) * 61440.0 +

+                 ABS(*(float *)(param_2 + 0xc)) * 61440.0 + ABS(*(float *)(param_2 + 0x3c))) - 1.0))

+        goto LAB_5;

+        fVar10 = *(float *)(param_2 + 0x2c);

+        param_2[0x41] = (CMILMatrix)((byte)param_2[0x41] | 0x30);

       }

-      fVar31 = fVar31 - 0.5;

-      *(float *)(unaff_RBP + 0xc) = (float)iVar10;

-      if (fVar31 < -2.1474836e+09) {

-        iVar10 = -0x80000000;

+      if (ABS(ABS(fVar10) * 61440.0 - 0.0) < 8.138021e-05) {

+        param_2[0x40] = (CMILMatrix)((byte)param_2[0x40] & 0xfc);

+        goto LAB_6;

       }

-      else {

-        iVar10 = iVar11;

-        if (fVar31 < 2.1474836e+09) {

-          fVar31 = ceilf(fVar31);

-          iVar10 = (int)fVar31;

-        }

-      }

-      fVar32 = fVar32 - 0.5;

-      *(float *)((longlong)unaff_RBP + 100) = (float)iVar10;

-      if (fVar32 < -2.1474836e+09) {

-        iVar11 = -0x80000000;

-      }

-      else if (fVar32 < 2.1474836e+09) {

-        fVar31 = ceilf(fVar32);

-        iVar11 = (int)fVar31;

-      }

-      fVar26 = fVar26 - 0.5;

-      *(float *)(unaff_RBP + 0xd) = (float)iVar11;

-      if (fVar26 < -2.1474836e+09) {

-        iVar24 = -0x80000000;

-      }

-      else if (fVar26 < 2.1474836e+09) {

-        fVar31 = ceilf(fVar26);

-        iVar24 = (int)fVar31;

-      }

-      *(float *)((longlong)unaff_RBP + 0x6c) = (float)iVar24;

+    }

+LAB_5:

+    cVar4 = '\x01';

+    *(undefined4 *)(param_2 + 0x40) = 0;

+    *(float *)(param_2 + 0x3c) =

+         local_88[0] * *(float *)(param_2 + 0xc) + local_88[1] * *(float *)(param_2 + 0x1c) +

+         *(float *)(param_2 + 0x2c) * 0.0 + *(float *)(param_2 + 0x3c);

+  }

+  else {

+LAB_6:

+    cVar4 = '\x01';

+  }

+LAB_3:

+  bVar6 = UseLayoutSizeForBounds(this,param_1);

+  if (!bVar6) {

+    return (bool)cVar4;

+  }

+  if (local_f8 == 1) {

+    return (bool)cVar4;

+  }

+  local_78[0] = 0.0;

+  local_78[1] = 0.0;

+  local_78[2] = 0.0;

+  local_78[3] = 0.0;

+  uVar2 = *(undefined8 *)param_3;

+  uVar3 = *(undefined8 *)(param_3 + 8);

+  local_f0._0_4_ = (float)uVar2;

+  local_f0._4_4_ = (float)((ulonglong)uVar2 >> 0x20);

+  uStack_e8._0_4_ = (float)uVar3;

+  uStack_e8._4_4_ = (float)((ulonglong)uVar3 >> 0x20);

+  fVar10 = local_f0._4_4_;

+  fVar11 = (float)local_f0;

+  fVar12 = uStack_e8._4_4_;

+  fVar13 = (float)uStack_e8;

+  if (cVar5 != '\0') {

+    fVar11 = (float)local_f0 - local_88[0];

+    fVar10 = local_f0._4_4_ - local_88[1];

+    fVar13 = (float)uStack_e8 + local_88[2];

+    fVar12 = uStack_e8._4_4_ + local_88[3];

+    local_f0 = CONCAT44(fVar10,fVar11);

+    uStack_e8 = CONCAT44(fVar12,fVar13);

+    uVar2 = local_f0;

+    uVar3 = uStack_e8;

+  }

+  uStack_e8 = uVar3;

+  local_f0 = uVar2;

+  if (cVar4 != '\0') {

+    CMILMatrix::Transform2DBoundsHelper<0>(param_2,(D2D_RECT_F *)&local_f0,(D2D_RECT_F *)local_78);

+    fVar10 = local_78[1];

+    fVar11 = local_78[0];

+    fVar12 = local_78[3];

+    fVar13 = local_78[2];

+  }

+  if (fVar13 <= fVar11) {

+    return (bool)cVar4;

+  }

+  if (fVar12 <= fVar10) {

+    return (bool)cVar4;

+  }

+  fVar1 = *(float *)param_1;

+  fVar12 = fVar12 - fVar10;

+  fVar13 = fVar13 - fVar11;

+  if ((ABS(fVar1 - fVar13) <= 0.00390625) && (ABS(*(float *)(param_1 + 4) - fVar12) <= 0.00390625))

+  {

+    return (bool)cVar4;

+  }

+  local_d8[2] = 0x3f80000000000000;

+  local_d8[3] = 0;

+  local_d8[0] = 0x3f800000;

+  local_d8[1] = 0;

+  local_a8 = 0;

+  uStack_a0 = 0x3f80000000000000;

+  local_d8[4] = 0;

+  local_d8[5] = 0x3f800000;

+  fVar10 = *(float *)(param_1 + 4);

+  local_98 = 0x29aa;

+  fVar11 = fVar1 / fVar13;

+  if (local_f8 == 0) {

+    CMILMatrix::SetScale((CMILMatrix *)local_d8,fVar11,fVar10 / fVar12,1.0,0.0,0.0,0.0);

+  }

+  else {

+    fVar14 = 0.0;

+    if (fVar10 < fVar11 * fVar12) {

+      fVar11 = fVar10 / fVar12;

+      fVar15 = (fVar1 - fVar11 * fVar13) * 0.5;

     }

     else {

-      *(float *)(unaff_RBP + 0xc) = unaff_XMM10_Da;

-      *(float *)((longlong)unaff_RBP + 100) = fVar31;

-      *(float *)(unaff_RBP + 0xd) = fVar32;

-      *(float *)((longlong)unaff_RBP + 0x6c) = fVar26;

-    }

-    if (*(uint *)(plVar20 + 300) != *(uint *)((longlong)plVar20 + 0x964)) {

-LAB_3:

-      uVar6 = unaff_RBP[0xd];

-      puVar18 = (undefined8 *)(plVar20[299] + (ulonglong)*(uint *)(plVar20 + 300) * 0x10);

-      *puVar18 = unaff_RBP[0xc];

-      puVar18[1] = uVar6;

-      *(int *)(plVar20 + 300) = (int)plVar20[300] + 1;

-      uVar12 = *(uint *)((longlong)plVar20 + 0x96c);

-      if (*(uint *)((longlong)plVar20 + 0x96c) <= *(uint *)(plVar20 + 300)) {

-        uVar12 = *(uint *)(plVar20 + 300);

-      }

-      *(uint *)((longlong)plVar20 + 0x96c) = uVar12;

-LAB_4:

-      *(longlong *)(plVar20[1] + -0xa8) = *(longlong *)(plVar20[1] + -0xa8) + 1;

-      detail::

-      vector_facade<CScopedClipStack::CpuClipStackState,detail::buffer_impl<CScopedClipStack::CpuClipStackState,10,1,detail::liberal_expansion_policy>_>

-      ::emplace_back<>((vector_facade<CScopedClipStack::CpuClipStackState,detail::buffer_impl<CScopedClipStack::CpuClipStackState,10,1,detail::liberal_expansion_policy>_>

-                        *)(plVar20 + 0xf3));

-      *(longlong *)(plVar20[1] + -0xb0) = *(longlong *)(plVar20[1] + -0xb0) + 1;

-      lVar15 = plVar20[0xf4];

-      if ((*(char *)(lVar15 + -0x20) != '\0') &&

-         (this_01 = *(CRectanglesShape **)(lVar15 + -0x28), this_01 != (CRectanglesShape *)0x0)) {

-        pcVar4 = (code *)**(undefined8 **)this_01;

-        if (pcVar4 == CRectanglesShape::_scalar_deleting_destructor_) {

-          CRectanglesShape::~CRectanglesShape(this_01);

-          CThreadLocalObjectCache<CRectanglesShape,CRectanglesShape>::Free(this_01);

-        }

-        else if (pcVar4 == CRoundedRectangleShape::_scalar_deleting_destructor_) {

-          CRoundedRectangleShape::~CRoundedRectangleShape((CRoundedRectangleShape *)this_01);

-          CThreadLocalObjectCache<CRoundedRectangleShape,CRoundedRectangleShape>::Free(this_01);

-        }

-        else if (pcVar4 == CPolygonShape::_scalar_deleting_destructor_) {

-          CPolygonShape::_scalar_deleting_destructor_((CPolygonShape *)this_01,1);

-        }

-        else {

-          (*pcVar4)();

-        }

-      }

-      uVar2 = *(undefined1 *)(unaff_RBP + 0x39);

-      *(CRoundedRectangleShape **)(lVar15 + -0x28) = unaff_RSI;

-      *(undefined1 *)(lVar15 + -0x20) = 1;

-      *(undefined1 *)(lVar15 + -4) = uVar2;

-      pcVar14 = (char *)*unaff_RBP;

-      *(undefined8 *)(lVar15 + -0x18) = unaff_R12;

-      *(undefined8 *)(lVar15 + -0x10) = 0;

-      *(int *)(lVar15 + -8) = iVar9;

-      *pcVar14 = cStackX_20;

-      return false;

-    }

-    uVar13 = (ulonglong)*(uint *)((longlong)plVar20 + 0x964) * 2;

-    if (uVar13 < 0x100000000) {

-      uVar19 = uVar13 & 0xffffffff;

-      if ((uint)uVar13 < 9) {

-        uVar19 = 8;

-      }

-      uVar13 = (ulonglong)*(uint *)(plVar20 + 300) << 4;

-      if (0xffffffff < uVar13) {

-        uVar12 = 0x65;

-        goto LAB_5;

-      }

-      if (((int)uVar19 == 0) ||

-         (auVar5._8_8_ = 0, auVar5._0_8_ = uVar19,

-         SUB168((ZEXT816(0) << 0x40 | ZEXT816(0xffffffffffffffff)) / auVar5,0) < 0x11)) {

-        unaff_R15D = -0x7ff8ffa9;

-      }

-      else {

-        _Dst = _Alloc_DefaultHeap__SAPEAX_K_Z(uVar19 << 4);

-        unaff_RBP[0x10] = _Dst;

-        if (_Dst != (void *)0x0) {

-          memcpy(_Dst,(void *)plVar20[299],uVar13 & 0xffffffff);

-          ___V_YAXPEAX_Z((void *)plVar20[299]);

-          plVar20[299] = unaff_RBP[0x10];

-          *(int *)((longlong)plVar20 + 0x964) = (int)uVar19;

-          goto LAB_3;

-        }

-        unaff_R15D = -0x7ff8fff2;

-      }

-      uVar12 = 0x68;

-    }

-    else {

-      uVar12 = 0x62;

-LAB_5:

-      unaff_R15D = -0x7ff8fdea;

-    }

-    wil::details::in1diag3::Return_Hr

-              ((void *)unaff_RBP[0x33],uVar12,

-               "onecoreuap\\windows\\DWM\\dwmcore\\common\\WatermarkStack.inl",unaff_R15D);

-    wil::details::in1diag3::Return_Hr

-              ((void *)unaff_RBP[0x33],0x83,

-               "onecoreuap\\windows\\DWM\\dwmcore\\common\\WatermarkStack.inl",unaff_R15D);

-    uVar12 = 0x201;

-  }

-  else {

-    iVar9 = *(int *)(unaff_RBP + 0x38);

-    this_00 = (CWatermarkStack<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,8,2,8>

-               *)(plVar20 + 299);

-    if (iVar9 == 1) {

-      iVar24 = 0x7fffffff;

-      fVar25 = unaff_XMM10_Da - 0.5;

-      iVar11 = 0x7fffffff;

-      if (fVar25 < -2.1474836e+09) {

-        iVar10 = -0x80000000;

-      }

-      else {

-        iVar10 = iVar11;

-        if (fVar25 < 2.1474836e+09) {

-          fVar25 = ceilf(fVar25);

-          iVar10 = (int)fVar25;

-        }

-      }

-      fVar31 = fVar31 - 0.5;

-      unaff_XMM10_Da = (float)iVar10;

-      if (fVar31 < -2.1474836e+09) {

-        iVar10 = -0x80000000;

-      }

-      else {

-        iVar10 = iVar11;

-        if (fVar31 < 2.1474836e+09) {

-          fVar31 = ceilf(fVar31);

-          iVar10 = (int)fVar31;

-        }

-      }

-      fVar32 = fVar32 - 0.5;

-      fVar31 = (float)iVar10;

-      if (fVar32 < -2.1474836e+09) {

-        iVar11 = -0x80000000;

-      }

-      else if (fVar32 < 2.1474836e+09) {

-        fVar32 = ceilf(fVar32);

-        iVar11 = (int)fVar32;

-      }

-      fVar26 = fVar26 - 0.5;

-      fVar32 = (float)iVar11;

-      if (fVar26 < -2.1474836e+09) {

-        iVar24 = -0x80000000;

-      }

-      else if (fVar26 < 2.1474836e+09) {

-        fVar26 = ceilf(fVar26);

-        iVar24 = (int)fVar26;

-      }

-      fVar26 = (float)iVar24;

-    }

-    uVar3 = *(uint *)(plVar20 + 300);

-    unaff_RBP[0x10] = 0;

-    unaff_RBP[0x11] = 0;

-    if (uVar3 == 0) {

-      fVar25 = -3.4028235e+38;

-      fVar28 = -3.4028235e+38;

-      fVar30 = 3.4028235e+38;

-      fVar29 = 3.4028235e+38;

-    }

-    else {

-      pfVar1 = (float *)(*(longlong *)this_00 + (ulonglong)(uVar3 - 1) * 0x10);

-      fVar25 = *pfVar1;

-      fVar28 = pfVar1[1];

-      fVar30 = pfVar1[2];

-      fVar29 = pfVar1[3];

-    }

-    *(float *)(unaff_RBP + 0x10) = fVar25;

-    *(float *)((longlong)unaff_RBP + 0x84) = fVar28;

-    *(float *)(unaff_RBP + 0x11) = fVar30;

-    *(float *)((longlong)unaff_RBP + 0x8c) = fVar29;

-    if (fVar25 < unaff_XMM10_Da) {

-      *(float *)(unaff_RBP + 0x10) = unaff_XMM10_Da;

-      *(float *)((longlong)unaff_RBP + 0x84) = fVar28;

-      *(float *)(unaff_RBP + 0x11) = fVar30;

-      *(float *)((longlong)unaff_RBP + 0x8c) = fVar29;

-      fVar25 = unaff_XMM10_Da;

-    }

-    fVar27 = fVar25;

-    if (fVar28 < fVar31) {

-      fVar27 = *(float *)(unaff_RBP + 0x10);

-      fVar30 = *(float *)(unaff_RBP + 0x11);

-      fVar29 = *(float *)((longlong)unaff_RBP + 0x8c);

-      *(float *)(unaff_RBP + 0x10) = fVar27;

-      *(float *)((longlong)unaff_RBP + 0x84) = fVar31;

-      *(float *)(unaff_RBP + 0x11) = fVar30;

-      *(float *)((longlong)unaff_RBP + 0x8c) = fVar29;

-      fVar28 = fVar31;

-    }

-    fVar31 = fVar28;

-    if (fVar32 < fVar30) {

-      fVar27 = *(float *)(unaff_RBP + 0x10);

-      fVar31 = *(float *)((longlong)unaff_RBP + 0x84);

-      fVar29 = *(float *)((longlong)unaff_RBP + 0x8c);

-      *(float *)(unaff_RBP + 0x10) = fVar27;

-      *(float *)((longlong)unaff_RBP + 0x84) = fVar31;

-      *(float *)(unaff_RBP + 0x11) = fVar32;

-      *(float *)((longlong)unaff_RBP + 0x8c) = fVar29;

-      fVar30 = fVar32;

-    }

-    fVar32 = fVar30;

-    if (fVar26 < fVar29) {

-      fVar27 = *(float *)(unaff_RBP + 0x10);

-      fVar31 = *(float *)((longlong)unaff_RBP + 0x84);

-      fVar32 = *(float *)(unaff_RBP + 0x11);

-      *(float *)(unaff_RBP + 0x10) = fVar27;

-      *(float *)((longlong)unaff_RBP + 0x84) = fVar31;

-      *(float *)(unaff_RBP + 0x11) = fVar32;

-      *(float *)((longlong)unaff_RBP + 0x8c) = fVar26;

-      fVar29 = fVar26;

-    }

-    if ((fVar30 <= fVar25) || (fVar29 <= fVar28)) {

-      unaff_RBP[0x11] = 0;

-      unaff_RBP[0x10] = 0;

-      fVar27 = *(float *)(unaff_RBP + 0x10);

-      fVar31 = *(float *)((longlong)unaff_RBP + 0x84);

-      fVar32 = *(float *)(unaff_RBP + 0x11);

-      fVar29 = *(float *)((longlong)unaff_RBP + 0x8c);

-    }

-    if ((uVar3 != *(uint *)((longlong)plVar20 + 0x964)) ||

-       (unaff_R15D = CWatermarkStack<TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,8,2,8>

-                     ::Grow(this_00,(ulonglong)uVar3,uVar12,uVar23,(void **)this_00),

-       -1 < unaff_R15D)) {

-      pfVar1 = (float *)(*(longlong *)this_00 + (ulonglong)*(uint *)(plVar20 + 300) * 0x10);

-      *pfVar1 = fVar27;

-      pfVar1[1] = fVar31;

-      pfVar1[2] = fVar32;

-      pfVar1[3] = fVar29;

-      *(int *)(plVar20 + 300) = (int)plVar20[300] + 1;

-      uVar12 = *(uint *)((longlong)plVar20 + 0x96c);

-      if (*(uint *)((longlong)plVar20 + 0x96c) <= *(uint *)(plVar20 + 300)) {

-        uVar12 = *(uint *)(plVar20 + 300);

-      }

-      *(uint *)((longlong)plVar20 + 0x96c) = uVar12;

-      goto LAB_4;

-    }

-    wil::details::in1diag3::Return_Hr

-              ((void *)unaff_RBP[0x33],0x83,

-               "onecoreuap\\windows\\DWM\\dwmcore\\common\\WatermarkStack.inl",unaff_R15D);

-    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,unaff_R15D,0x31,(void *)0x0);

-    uVar12 = 0x205;

-  }

-  MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,unaff_R15D,uVar12,(void *)0x0);

-  MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,unaff_R15D,0x1a9,(void *)0x0);

-  bVar8 = unaff_R13B != '\0';

-  unaff_R13B = *(char *)(unaff_RBP + -0xe);

-  if (bVar8) {

-    detail::

-    vector_facade<CCpuClipAntialiasSinkContext::SinkEntry,detail::buffer_impl<CCpuClipAntialiasSinkContext::SinkEntry,2,1,detail::liberal_expansion_policy>_>

-    ::pop_back((vector_facade<CCpuClipAntialiasSinkContext::SinkEntry,detail::buffer_impl<CCpuClipAntialiasSinkContext::SinkEntry,2,1,detail::liberal_expansion_policy>_>

-                *)(*(longlong *)(plVar20[1] + -0x10) + 0x10));

-  }

-LAB_0:

-  detail::

-  vector_facade<CScopedClipStack::CpuClipStackState,detail::buffer_impl<CScopedClipStack::CpuClipStackState,10,1,detail::liberal_expansion_policy>_>

-  ::pop_back((vector_facade<CScopedClipStack::CpuClipStackState,detail::buffer_impl<CScopedClipStack::CpuClipStackState,10,1,detail::liberal_expansion_policy>_>

-              *)(plVar20 + 0xf3));

-  if ((unaff_R13B != '\0') && (unaff_RSI != (CRoundedRectangleShape *)0x0)) {

-    pcVar4 = (code *)**(undefined8 **)unaff_RSI;

-    if (pcVar4 == CRectanglesShape::_scalar_deleting_destructor_) {

-      *(undefined ***)unaff_RSI = &CRectanglesShape::_vftable_;

-      lVar15 = *(longlong *)(unaff_RSI + 0x18) - *(longlong *)(unaff_RSI + 0x10) >> 4;

-      if (lVar15 != 0) {

-        *(longlong *)(unaff_RSI + 0x18) = *(longlong *)(unaff_RSI + 0x18) + lVar15 * -0x10;

-      }

-      this_02 = *(CMILCOMBaseWeakRefSource<CResourceDeleter> **)(unaff_RSI + 0x38);

-      if (this_02 != (CMILCOMBaseWeakRefSource<CResourceDeleter> *)0x0) {

-        if (*(code **)(*(longlong *)this_02 + 0x10) ==

-            CMILCOMBaseWeakRefSource<CResourceDeleter>::InternalRelease) {

-          CMILCOMBaseWeakRefSource<CResourceDeleter>::InternalRelease(this_02);

-        }

-        else {

-          (**(code **)(*(longlong *)this_02 + 0x10))();

-        }

-        *(undefined8 *)(unaff_RSI + 0x38) = 0;

-      }

-      lpMem = *(CRoundedRectangleShape **)(unaff_RSI + 0x10);

-      lVar15 = *(longlong *)(unaff_RSI + 0x18) - (longlong)lpMem >> 4;

-      if (lVar15 != 0) {

-        *(longlong *)(unaff_RSI + 0x18) = *(longlong *)(unaff_RSI + 0x18) + lVar15 * -0x10;

-      }

-      *(undefined8 *)(unaff_RSI + 0x10) = 0;

-      if (lpMem == unaff_RSI + 0x28) {

-        lpMem = (CRoundedRectangleShape *)0x0;

-      }

-      if (lpMem != (CRoundedRectangleShape *)0x0) {

-        pvVar16 = GetProcessHeap();

-        HeapFree(pvVar16,0,lpMem);

-      }

-      this_03 = *(CMILRefCountBaseT<ID2D1GeometrySink,CMilObjectDeleter> **)(unaff_RSI + 8);

-      if (this_03 != (CMILRefCountBaseT<ID2D1GeometrySink,CMilObjectDeleter> *)0x0) {

-        *(undefined8 *)(unaff_RSI + 8) = 0;

-        if (*(code **)(*(longlong *)this_03 + 0x10) ==

-            CMILCOMBaseT<ID2D1GeometrySink,ID2D1GeometrySink,CMilObjectDeleter>::Release) {

-          CMILRefCountBaseT<ID2D1GeometrySink,CMilObjectDeleter>::InternalRelease(this_03);

-        }

-        else {

-          (**(code **)(*(longlong *)this_03 + 0x10))();

-        }

-      }

-      lpTlsValue = TlsGetValue(CThreadContext::s_dwTlsIndex);

-      if (lpTlsValue == (LPVOID)0x0) {

-        this_04 = _Alloc_DefaultHeap__SAPEAX_K_Z(0x1c0);

-        if ((this_04 == (CThreadContext *)0x0) ||

-           (lpTlsValue = (LPVOID)CThreadContext::CThreadContext(this_04), lpTlsValue == (LPVOID)0x0)

-           ) {

-          MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,-0x7ff8fff2,0x28,(void *)0x0);

-                    /* WARNING: Subroutine does not return */

-          ModuleFailFastForHRESULT(0x8007000e,unaff_RBP[0x33]);

-        }

-        TlsSetValue(CThreadContext::s_dwTlsIndex,lpTlsValue);

-      }

-      if (*(uint *)((longlong)lpTlsValue + 0x34) < *(uint *)((longlong)lpTlsValue + 0x30)) {

-        *(undefined8 *)unaff_RSI = *(undefined8 *)((longlong)lpTlsValue + 0x38);

-        *(int *)((longlong)lpTlsValue + 0x34) = *(int *)((longlong)lpTlsValue + 0x34) + 1;

-        *(CRoundedRectangleShape **)((longlong)lpTlsValue + 0x38) = unaff_RSI;

-      }

-      else {

-        pvVar16 = GetProcessHeap();

-        HeapFree(pvVar16,0,unaff_RSI);

-      }

-    }

-    else if (pcVar4 == CRoundedRectangleShape::_scalar_deleting_destructor_) {

-      CRoundedRectangleShape::~CRoundedRectangleShape(unaff_RSI);

-      CThreadLocalObjectCache<CRoundedRectangleShape,CRoundedRectangleShape>::Free(unaff_RSI);

-    }

-    else if (pcVar4 == CPolygonShape::_scalar_deleting_destructor_) {

-      CPolygonShape::_scalar_deleting_destructor_((CPolygonShape *)unaff_RSI,1);

-    }

-    else {

-      (*pcVar4)();

-    }

-  }

-  return (bool)(char)unaff_R15D;

+      fVar14 = (fVar10 - fVar11 * fVar12) * 0.5;

+    }

+    local_98 = 0x2988;

+    local_d8[0] = (ulonglong)(uint)fVar11;

+    local_d8[2] = (ulonglong)(uint)fVar11 << 0x20;

+    local_a8 = CONCAT44(fVar14,fVar15);

+  }

+  CMILMatrix::Multiply(param_2,(CMILMatrix *)local_d8);

+  return true;

 }
```

## `std::unordered_map<unsigned_int,CFlipAwayFence,std::hash<unsigned_int>,std::equal_to<unsigned_int>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>_>::unordered_map<unsigned_int,CFlipAwayFence,std::hash<unsigned_int>,std::equal_to<unsigned_int>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>_>`  (modified)

```diff
--- std::unordered_map<unsigned_int,CFlipAwayFence,std::hash<unsigned_int>,std::equal_to<unsigned_int>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>_>::unordered_map<unsigned_int,CFlipAwayFence,std::hash<unsigned_int>,std::equal_to<unsigned_int>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>_>
+++ std::unordered_map<unsigned_int,CFlipAwayFence,std::hash<unsigned_int>,std::equal_to<unsigned_int>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>_>::unordered_map<unsigned_int,CFlipAwayFence,std::hash<unsigned_int>,std::equal_to<unsigned_int>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>_>
@@ -1,2 +1,40 @@
-Failed to decompile dwmcore.dll - .ProgramDB std::unordered_map<unsigned_int,CFlipAwayFence,std::hash<unsigned_int>,std::equal_to<unsigned_int>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>_>::unordered_map<unsigned_int,CFlipAwayFence,std::hash<unsigned_int>,std::equal_to<unsigned_int>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>_> : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: __cdecl std::unordered_map<unsigned int,class CFlipAwayFence,struct std::hash<unsigned

+   int>,struct std::equal_to<unsigned int>,class std::allocator<struct std::pair<unsigned int const

+   ,class CFlipAwayFence> > >::unordered_map<unsigned int,class CFlipAwayFence,struct

+   std::hash<unsigned int>,struct std::equal_to<unsigned int>,class std::allocator<struct

+   std::pair<unsigned int const ,class CFlipAwayFence> > >(void) __ptr64 */

+

+unordered_map<unsigned_int,CFlipAwayFence,std::hash<unsigned_int>,std::equal_to<unsigned_int>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>_>

+* __thiscall

+std::

+unordered_map<unsigned_int,CFlipAwayFence,std::hash<unsigned_int>,std::equal_to<unsigned_int>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>_>

+::

+unordered_map<unsigned_int,CFlipAwayFence,std::hash<unsigned_int>,std::equal_to<unsigned_int>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>_>

+          (unordered_map<unsigned_int,CFlipAwayFence,std::hash<unsigned_int>,std::equal_to<unsigned_int>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>_>

+           *this)

+

+{

+  __uint64 _Var1;

+  void *pvVar2;

+  

+  *(undefined4 *)this = 0;

+  *(undefined8 *)(this + 8) = 0;

+  *(undefined8 *)(this + 0x10) = 0;

+  _Var1 = _Get_size_of_n<48>(1);

+  pvVar2 = _Allocate<16,std::_Default_allocate_traits,0>(_Var1);

+  *(void **)pvVar2 = pvVar2;

+  *(void **)((longlong)pvVar2 + 8) = pvVar2;

+  *(void **)(this + 8) = pvVar2;

+  *(undefined8 *)(this + 0x18) = 0;

+  *(undefined8 *)(this + 0x20) = 0;

+  *(undefined8 *)(this + 0x28) = 0;

+  *(undefined8 *)(this + 0x30) = 7;

+  *(undefined8 *)(this + 0x38) = 8;

+  *(undefined4 *)this = 0x3f800000;

+  _Hash_vec<std::allocator<std::_List_unchecked_iterator<std::_List_val<std::_List_simple_types<std::pair<unsigned_int_const_,CFlipAwayFence>_>_>_>_>_>

+  ::_Assign_grow((_Hash_vec<std::allocator<std::_List_unchecked_iterator<std::_List_val<std::_List_simple_types<std::pair<unsigned_int_const_,CFlipAwayFence>_>_>_>_>_>

+                  *)(this + 0x18),0x10,*(undefined8 *)(this + 8));

+  return this;

+}

+
```

## `CSwapchainRenderStrategy::HasRevealBorder`  (modified)

```diff
--- CSwapchainRenderStrategy::HasRevealBorder
+++ CSwapchainRenderStrategy::HasRevealBorder
@@ -1,2 +1,39 @@
-Failed to decompile dwmcore.dll - .ProgramDB CSwapchainRenderStrategy::HasRevealBorder : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: virtual bool __cdecl CSwapchainRenderStrategy::HasRevealBorder(class CSurfaceBrush const

+   * __ptr64,struct _D3DCOLORVALUE * __ptr64)const __ptr64 */

+

+bool __thiscall

+CSwapchainRenderStrategy::HasRevealBorder

+          (CSwapchainRenderStrategy *this,CSurfaceBrush *param_1,_D3DCOLORVALUE *param_2)

+

+{

+  bool bVar1;

+  SizePreference SVar2;

+  CResource *this_00;

+  undefined8 local_18;

+  undefined4 uStack_10;

+  float fStack_c;

+  

+  if (*(int *)(param_1 + 0x78) != 1) {

+    this_00 = CSurfaceBrush::GetSurface(param_1);

+    bVar1 = CCompositionSurfaceBitmap::HasSwapChainAttributes((CCompositionSurfaceBitmap *)this_00);

+    if (bVar1) {

+      SVar2 = CCompositionSurfaceBitmap::GetSizePreference((CCompositionSurfaceBitmap *)this_00);

+      bVar1 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2>::

+              __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2> *)

+                                  &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DCompChromiumK2>::GetImpl(void)'

+                                   ::__l2::impl);

+      if ((((!bVar1) || (SVar2 != 3)) && (SVar2 != 0)) &&

+         (CCompositionSurfaceBitmap::GetBorderColor((CCompositionSurfaceBitmap *)this_00),

+         1.1920929e-06 <= ABS(fStack_c))) {

+        if (param_2 != (_D3DCOLORVALUE *)0x0) {

+          *(undefined8 *)param_2 = local_18;

+          *(ulonglong *)(param_2 + 8) = CONCAT44(fStack_c,uStack_10);

+        }

+        return true;

+      }

+    }

+  }

+  return false;

+}

+
```

## `CCursorState::MonitorData::operator=`  (modified)

```diff
--- CCursorState::MonitorData::operator=
+++ CCursorState::MonitorData::operator=
@@ -1,2 +1,47 @@
-Failed to decompile dwmcore.dll - .ProgramDB CCursorState::MonitorData::operator= : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: class CCursorState::MonitorData & __ptr64 __cdecl

+   CCursorState::MonitorData::operator=(class CCursorState::MonitorData && __ptr64) __ptr64 */

+

+MonitorData * __thiscall

+CCursorState::MonitorData::operator=(MonitorData *this,MonitorData *param_1)

+

+{

+  undefined8 uVar1;

+  

+  *(undefined8 *)this = *(undefined8 *)param_1;

+  *(undefined4 *)(this + 8) = *(undefined4 *)(param_1 + 8);

+  uVar1 = *(undefined8 *)(param_1 + 0x14);

+  *(undefined8 *)(this + 0xc) = *(undefined8 *)(param_1 + 0xc);

+  *(undefined8 *)(this + 0x14) = uVar1;

+  uVar1 = *(undefined8 *)(param_1 + 0x24);

+  *(undefined8 *)(this + 0x1c) = *(undefined8 *)(param_1 + 0x1c);

+  *(undefined8 *)(this + 0x24) = uVar1;

+  uVar1 = *(undefined8 *)(param_1 + 0x34);

+  *(undefined8 *)(this + 0x2c) = *(undefined8 *)(param_1 + 0x2c);

+  *(undefined8 *)(this + 0x34) = uVar1;

+  uVar1 = *(undefined8 *)(param_1 + 0x44);

+  *(undefined8 *)(this + 0x3c) = *(undefined8 *)(param_1 + 0x3c);

+  *(undefined8 *)(this + 0x44) = uVar1;

+  *(undefined4 *)(this + 0x4c) = *(undefined4 *)(param_1 + 0x4c);

+  uVar1 = *(undefined8 *)(param_1 + 0x58);

+  *(undefined8 *)(this + 0x50) = *(undefined8 *)(param_1 + 0x50);

+  *(undefined8 *)(this + 0x58) = uVar1;

+  uVar1 = *(undefined8 *)(param_1 + 0x68);

+  *(undefined8 *)(this + 0x60) = *(undefined8 *)(param_1 + 0x60);

+  *(undefined8 *)(this + 0x68) = uVar1;

+  std::shared_ptr<CCursorState::ShapeData>::operator=

+            ((shared_ptr<CCursorState::ShapeData> *)(this + 0x70),

+             (shared_ptr<class_CCursorState::ShapeData> *)(param_1 + 0x70));

+  *(undefined4 *)(this + 0x80) = *(undefined4 *)(param_1 + 0x80);

+  *(undefined8 *)(this + 0x84) = *(undefined8 *)(param_1 + 0x84);

+  *(undefined4 *)(this + 0x8c) = *(undefined4 *)(param_1 + 0x8c);

+  *(undefined4 *)(this + 0x90) = *(undefined4 *)(param_1 + 0x90);

+  *(undefined4 *)(this + 0x94) = *(undefined4 *)(param_1 + 0x94);

+  *(undefined4 *)(this + 0x98) = *(undefined4 *)(param_1 + 0x98);

+  this[0x9c] = param_1[0x9c];

+  this[0x9d] = param_1[0x9d];

+  this[0x9e] = param_1[0x9e];

+  this[0x9f] = param_1[0x9f];

+  return this;

+}

+
```

## `CCompositionSurfaceBitmap::GetBounds`  (modified)

```diff
--- CCompositionSurfaceBitmap::GetBounds
+++ CCompositionSurfaceBitmap::GetBounds
@@ -1,89 +1,118 @@
 

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

 /* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

    guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: virtual long __cdecl CCompositionSurfaceBitmap::GetBounds(struct D2D_SIZE_F const &

+   __ptr64,class TMilRect_<float,struct D2D_RECT_F,struct D3D_RECT_F,struct

+   D2D_POINTANDSIZE_F,struct RectUniqueness::NotNeeded> * __ptr64)const __ptr64 */

 

 long __thiscall

-ShrinkableArray<CBatchCommand*___ptr64,UniqueLifetime<CBatchCommand*___ptr64>_>::GetBounds

+CCompositionSurfaceBitmap::GetBounds

           (CCompositionSurfaceBitmap *this,D2D_SIZE_F *param_1,

           TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

           *param_2)

 

 {

-  undefined4 uVar1;

-  undefined1 uVar2;

-  longlong lVar3;

-  CRectanglesShape *this_00;

-  code *pcVar4;

-  undefined1 *puVar5;

-  uint uVar6;

-  uint *in_RAX;

-  longlong lVar7;

-  undefined8 *unaff_RBP;

-  undefined8 unaff_RSI;

-  undefined1 *unaff_RDI;

-  undefined8 unaff_R12;

-  undefined4 unaff_R13D;

-  undefined1 unaff_R15B;

+  CGlobalCompositionSurfaceInfo *pCVar1;

+  bool bVar2;

+  char cVar3;

+  char cVar4;

+  ISwapChainRealization *this_00;

+  code *pcVar5;

+  longlong *plVar6;

+  undefined1 auStack_b8 [32];

+  CMILMatrix local_98 [64];

+  undefined4 local_58;

+  float local_48 [4];

+  undefined8 local_38;

+  undefined8 uStack_30;

+  ulonglong local_28;

   

-  uVar2 = in((short)param_1);

-  *unaff_RDI = uVar2;

-  uVar6 = (uint)in_RAX;

-  *in_RAX = *in_RAX | uVar6;

-  LOCK();

-  uVar1 = *(undefined4 *)((longlong)in_RAX + 9);

-  *(int *)((longlong)in_RAX + 9) = (int)&stack0x00000000;

-  lVar7 = CONCAT44((int)((ulonglong)&stack0x00000000 >> 0x20),uVar1);

-  UNLOCK();

-  *(char *)in_RAX = (char)*in_RAX + (char)in_RAX;

-  if (uVar6 <= *(uint *)(unaff_RDI + 0x961)) {

-    uVar6 = *(uint *)(unaff_RDI + 0x961);

+  local_28 = __security_cookie ^ (ulonglong)auStack_b8;

+  pCVar1 = *(CGlobalCompositionSurfaceInfo **)(this + 0x60);

+  if (pCVar1 == (CGlobalCompositionSurfaceInfo *)0x0) {

+LAB_0:

+    *(undefined8 *)(param_2 + 8) = 0;

+    *(undefined8 *)param_2 = 0;

+    return 0;

   }

-  *(uint *)(unaff_RDI + 0x96d) = uVar6;

-  *(longlong *)(*(longlong *)(unaff_RDI + 9) + -0xa8) =

-       *(longlong *)(*(longlong *)(unaff_RDI + 9) + -0xa8) + 1;

-  *(undefined8 *)(lVar7 + -8) = 0x18007c6f5;

-  detail::

-  vector_facade<CScopedClipStack::CpuClipStackState,detail::buffer_impl<CScopedClipStack::CpuClipStackState,10,1,detail::liberal_expansion_policy>_>

-  ::emplace_back<>((vector_facade<CScopedClipStack::CpuClipStackState,detail::buffer_impl<CScopedClipStack::CpuClipStackState,10,1,detail::liberal_expansion_policy>_>

-                    *)(unaff_RDI + 0x799));

-  *(longlong *)(*(longlong *)(unaff_RDI + 9) + -0xb0) =

-       *(longlong *)(*(longlong *)(unaff_RDI + 9) + -0xb0) + 1;

-  lVar3 = *(longlong *)(unaff_RDI + 0x7a1);

-  if ((*(char *)(lVar3 + -0x20) != '\0') &&

-     (this_00 = *(CRectanglesShape **)(lVar3 + -0x28), this_00 != (CRectanglesShape *)0x0)) {

-    pcVar4 = (code *)**(undefined8 **)this_00;

-    if (pcVar4 == CRectanglesShape::_scalar_deleting_destructor_) {

-      *(undefined8 *)(lVar7 + -8) = 0x18007c734;

-      CRectanglesShape::~CRectanglesShape(this_00);

-      *(undefined8 *)(lVar7 + -8) = 0x18007c73c;

-      CThreadLocalObjectCache<CRectanglesShape,CRectanglesShape>::Free(this_00);

+  if (*(code **)(*(longlong *)pCVar1 + 0x30) ==

+      CGlobalCompositionSurfaceInfo::GetRenderingRealization) {

+    if (*(longlong *)(pCVar1 + 0xd0) == 0) {

+      CGlobalCompositionSurfaceInfo::ForceUpdateRenderingRealization(pCVar1);

     }

-    else if (pcVar4 == CRoundedRectangleShape::_scalar_deleting_destructor_) {

-      *(undefined8 *)(lVar7 + -8) = 0x18007cc6f;

-      CRoundedRectangleShape::~CRoundedRectangleShape((CRoundedRectangleShape *)this_00);

-      *(undefined8 *)(lVar7 + -8) = 0x18007cc77;

-      CThreadLocalObjectCache<CRoundedRectangleShape,CRoundedRectangleShape>::Free(this_00);

+    plVar6 = (longlong *)(*(longlong *)(pCVar1 + 0xd0) + 8);

+    if (*(longlong *)(pCVar1 + 0xd0) == 0) {

+      plVar6 = (longlong *)0x0;

     }

-    else if (pcVar4 == CPolygonShape::_scalar_deleting_destructor_) {

-      *(undefined8 *)(lVar7 + -8) = 0x18007d9f3;

-      CPolygonShape::_scalar_deleting_destructor_((CPolygonShape *)this_00,1);

+  }

+  else {

+    plVar6 = (longlong *)(**(code **)(*(longlong *)pCVar1 + 0x30))(pCVar1);

+  }

+  if (plVar6 == (longlong *)0x0) goto LAB_0;

+  bVar2 = UseLayoutSizeForBounds(this,param_1);

+  if (bVar2) {

+    *(undefined8 *)param_2 = 0;

+    *(undefined4 *)(param_2 + 8) = *(undefined4 *)param_1;

+    *(undefined4 *)(param_2 + 0xc) = *(undefined4 *)(param_1 + 4);

+    return 0;

+  }

+  local_58 = 0;

+  local_38 = 0;

+  uStack_30 = 0;

+  cVar3 = (**(code **)(*plVar6 + 0x28))(plVar6,local_98,&local_38);

+  pCVar1 = *(CGlobalCompositionSurfaceInfo **)(this + 0x60);

+  local_48[0] = 0.0;

+  local_48[1] = 0.0;

+  local_48[2] = 0.0;

+  local_48[3] = 0.0;

+  if (pCVar1 == (CGlobalCompositionSurfaceInfo *)0x0) goto LAB_1;

+  pcVar5 = *(code **)(*(longlong *)pCVar1 + 0x1e0);

+  if (pcVar5 == CGlobalCompositionSurfaceInfo::GetScaledLetterboxingMargins) {

+    this_00 = CGlobalCompositionSurfaceInfo::GetSwapChainRealization(pCVar1);

+    if (this_00 == (ISwapChainRealization *)0x0) goto LAB_1;

+    pcVar5 = *(code **)(*(longlong *)this_00 + 0x100);

+    if (pcVar5 == CDxHandleBitmapRealization::GetScaledLetterboxingMargins) {

+      cVar4 = CBitmapRealization::GetScaledLetterboxingMargins

+                        ((CBitmapRealization *)(this_00 + -0x148),

+                         (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                          *)local_48);

     }

     else {

-      *(undefined8 *)(lVar7 + -8) = 0x18007da8f;

-      (*pcVar4)();

+      if (pcVar5 != CDxHandleYUVBitmapRealization::GetScaledLetterboxingMargins) goto LAB_2;

+      cVar4 = CDxHandleYUVBitmapRealization::GetScaledLetterboxingMargins

+                        ((CDxHandleYUVBitmapRealization *)this_00,

+                         (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                          *)local_48);

     }

   }

-  uVar2 = *(undefined1 *)(unaff_RBP + 0x39);

-  *(undefined8 *)(lVar3 + -0x28) = unaff_RSI;

-  *(undefined1 *)(lVar3 + -0x20) = 1;

-  *(undefined1 *)(lVar3 + -4) = uVar2;

-  puVar5 = (undefined1 *)*unaff_RBP;

-  *(undefined8 *)(lVar3 + -0x18) = unaff_R12;

-  *(undefined8 *)(lVar3 + -0x10) = 0;

-  *(undefined4 *)(lVar3 + -8) = unaff_R13D;

-  *puVar5 = unaff_R15B;

-  *(undefined8 *)(lVar7 + -8) = 0x18007c777;

+  else if (pcVar5 == CDxHandleBitmapRealization::GetScaledLetterboxingMargins) {

+    cVar4 = CDxHandleBitmapRealization::GetScaledLetterboxingMargins

+                      ((CDxHandleBitmapRealization *)pCVar1,

+                       (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                        *)local_48);

+  }

+  else if (pcVar5 == CDxHandleYUVBitmapRealization::GetScaledLetterboxingMargins) {

+    cVar4 = CDxHandleYUVBitmapRealization::GetScaledLetterboxingMargins

+                      ((CDxHandleYUVBitmapRealization *)pCVar1,

+                       (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                        *)local_48);

+  }

+  else {

+LAB_2:

+    cVar4 = (*pcVar5)();

+  }

+  if (cVar4 != '\0') {

+    uStack_30 = CONCAT44(uStack_30._4_4_ + local_48[3] + local_48[1],

+                         (float)uStack_30 + local_48[2] + local_48[0]);

+  }

+LAB_1:

+  if (cVar3 == '\0') {

+    *(undefined8 *)param_2 = local_38;

+    *(undefined8 *)(param_2 + 8) = uStack_30;

+    return 0;

+  }

+  CMILMatrix::Transform2DBoundsHelper<0>(local_98,(D2D_RECT_F *)&local_38,(D2D_RECT_F *)param_2);

   return 0;

 }
```

## `CCaptureRenderTarget::RenderCursors`  (modified)

```diff
--- CCaptureRenderTarget::RenderCursors
+++ CCaptureRenderTarget::RenderCursors
@@ -1,2 +1,125 @@
-Failed to decompile dwmcore.dll - .ProgramDB CCaptureRenderTarget::RenderCursors : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* protected: long __cdecl CCaptureRenderTarget::RenderCursors(class CDrawingContext * __ptr64)

+   __ptr64 */

+

+long __thiscall

+CCaptureRenderTarget::RenderCursors(CCaptureRenderTarget *this,CDrawingContext *param_1)

+

+{

+  CVisualTree *this_00;

+  CVisual *pCVar1;

+  CComposition *pCVar2;

+  CVisual *pCVar3;

+  bool bVar4;

+  long lVar5;

+  CVisualTree *pCVar6;

+  CVisualTree *pCVar7;

+  uint uVar8;

+  ulonglong uVar9;

+  CVisual *this_01;

+  void *unaff_retaddr;

+  CDrawingContext *local_res10;

+  undefined1 local_res18 [8];

+  undefined1 local_res20 [8];

+  CVisualTree *local_128;

+  CVisual *local_120;

+  undefined8 local_118;

+  undefined8 uStack_110;

+  undefined8 uStack_108;

+  undefined4 uStack_100;

+  undefined8 uStack_fc;

+  undefined4 local_f4;

+  undefined8 local_f0;

+  CCaptureRenderTarget *local_e8;

+  CVisualTree **local_e0;

+  undefined1 *local_d8;

+  CVisual **local_d0;

+  undefined1 *local_c8;

+  CDrawingContext **local_c0;

+  undefined8 *local_b8;

+  undefined1 *local_b0;

+  undefined1 local_a8 [56];

+  undefined8 local_70;

+  undefined1 local_68 [64];

+  undefined4 local_28;

+  

+  local_res10 = param_1;

+  bVar4 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>::

+          __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor> *)

+                              &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DesktopDWMCursor>::GetImpl(void)'

+                               ::__l2::impl);

+  if (bVar4) {

+    local_118._0_4_ = 6;

+    uStack_110._4_4_ = 0;

+    uStack_108._0_4_ = 0;

+    local_118._4_4_ = 0;

+    uStack_108._4_4_ = 0;

+    uStack_100 = 0;

+    uStack_fc = 0;

+    local_f4 = 0;

+    uStack_110._0_4_ = 1;

+    lVar5 = COffScreenRenderTarget::RenderCursors

+                      ((COffScreenRenderTarget *)this,local_res10,(MilRenderOptions *)&local_118,

+                       (_D3DCOLORVALUE *)(this + 0x8c));

+  }

+  else {

+    local_118 = local_res20;

+    uStack_110 = &local_res10;

+    uStack_108 = local_res18;

+    local_res20[0] = 0;

+    local_res18[0] = 0;

+    uStack_100 = CONCAT31(uStack_100._1_3_,1);

+    if (*(int *)(this + 0xc4) == 1) {

+      this_00 = *(CVisualTree **)(this + 0x70);

+      pCVar6 = CVisualTree::GetRootVisualTree(this_00);

+      local_120 = *(CVisual **)(this_00 + 0x48);

+      local_128 = pCVar6;

+      pCVar3 = local_120;

+      if (pCVar6 == this_00) {

+        pCVar1 = *(CVisual **)(this + 0xb68);

+        for (this_01 = pCVar1; this_01 != (CVisual *)0x0; this_01 = *(CVisual **)(this_01 + 0x58)) {

+          pCVar7 = CVisual::GetVisualTreeNoRef(this_01);

+          if (pCVar7 != (CVisualTree *)0x0) {

+            pCVar6 = pCVar7;

+            local_128 = pCVar7;

+          }

+          pCVar3 = pCVar1;

+        }

+      }

+      local_120 = pCVar3;

+      if ((pCVar6 != this_00) && (uVar9 = 0, *(int *)(this + 0xa40) != 0)) {

+        do {

+          pCVar2 = *(CComposition **)(this + 0x18);

+          local_f0 = *(undefined8 *)(*(longlong *)(this + 0xa28) + uVar9 * 8);

+          local_e0 = &local_128;

+          local_28 = 0;

+          local_d8 = local_res18;

+          local_d0 = &local_120;

+          local_c8 = local_68;

+          local_c0 = &local_res10;

+          local_b8 = &local_f0;

+          local_b0 = local_res20;

+          local_e8 = this;

+          local_70 = std::

+                     _Global_new<std::_Func_impl_no_alloc<<lambda_a1d645c788d657455050b12db52c7919>,long,CVisual_*,CVisualTree_*>,<lambda_a1d645c788d657455050b12db52c7919>_>

+                               (&local_e8);

+          lVar5 = CComposition::ForEachCursorVisual(pCVar2,local_a8);

+          if (lVar5 < 0) {

+            wil::details::in1diag3::Return_Hr

+                      (unaff_retaddr,0x226,

+                       "onecoreuap\\windows\\dwm\\dwmcore\\engine\\capturerendertarget.cpp",lVar5);

+            goto LAB_0;

+          }

+          uVar8 = (int)uVar9 + 1;

+          uVar9 = (ulonglong)uVar8;

+        } while (uVar8 < *(uint *)(this + 0xa40));

+      }

+    }

+    lVar5 = 0;

+LAB_0:

+    gsl::final_action<<lambda_a963e2fac1282037e8b8d37b07854811>_>::

+    ~final_action<<lambda_a963e2fac1282037e8b8d37b07854811>_>(&local_118);

+  }

+  return lVar5;

+}

+
```

## `CSurfaceBrush::HasCompositionSurface`  (modified)

```diff
--- CSurfaceBrush::HasCompositionSurface
+++ CSurfaceBrush::HasCompositionSurface
@@ -1,2 +1,23 @@
-Failed to decompile dwmcore.dll - .ProgramDB CSurfaceBrush::HasCompositionSurface : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: virtual bool __cdecl CSurfaceBrush::HasCompositionSurface(void)const __ptr64 */

+

+bool __thiscall CSurfaceBrush::HasCompositionSurface(CSurfaceBrush *this)

+

+{

+  char cVar1;

+  CResource *pCVar2;

+  bool bVar3;

+  

+  pCVar2 = GetSurface(this);

+  bVar3 = false;

+  if (pCVar2 != (CResource *)0x0) {

+    cVar1 = (**(code **)(*(longlong *)pCVar2 + 0x40))(pCVar2,0x29);

+    if (cVar1 != '\0') {

+      bVar3 = true;

+    }

+  }

+  return bVar3;

+}

+
```

## `CCompositionDynamicTextureGeneratedT<CCompositionDynamicTexture,CContent>::SetTexture`  (modified)

```diff
--- CCompositionDynamicTextureGeneratedT<CCompositionDynamicTexture,CContent>::SetTexture
+++ CCompositionDynamicTextureGeneratedT<CCompositionDynamicTexture,CContent>::SetTexture
@@ -1,2 +1,27 @@
-Failed to decompile dwmcore.dll - .ProgramDB CCompositionDynamicTextureGeneratedT<CCompositionDynamicTexture,CContent>::SetTexture : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: long __cdecl CCompositionDynamicTextureGeneratedT<class CCompositionDynamicTexture,class

+   CContent>::SetTexture(class CCompositionSurfaceBitmap * __ptr64) __ptr64 */

+

+long __thiscall

+CCompositionDynamicTextureGeneratedT<CCompositionDynamicTexture,CContent>::SetTexture

+          (CCompositionDynamicTextureGeneratedT<CCompositionDynamicTexture,CContent> *this,

+          CCompositionSurfaceBitmap *param_1)

+

+{

+  long lVar1;

+  

+  lVar1 = 0;

+  if (param_1 != *(CCompositionSurfaceBitmap **)(this + 0x48)) {

+    lVar1 = CResource::RegisterNotifier((CResource *)this,(CResource *)param_1);

+    if (lVar1 < 0) {

+      MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar1,0x3d8,(void *)0x0);

+    }

+    else {

+      CResource::UnRegisterNotifierInternal((CResource *)this,*(CResource **)(this + 0x48));

+      *(CCompositionSurfaceBitmap **)(this + 0x48) = param_1;

+      CCompositionDynamicTexture::OnTextureChanged((CCompositionDynamicTexture *)this);

+    }

+  }

+  return lVar1;

+}

+
```

## `detail::vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>::reserve_region`  (modified)

```diff
--- detail::vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>::reserve_region
+++ detail::vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>::reserve_region
@@ -1,2 +1,79 @@
-Failed to decompile dwmcore.dll - .ProgramDB detail::vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>::reserve_region : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* protected: class CD3DDevice::CDelayUnpin * __ptr64 __cdecl detail::vector_facade<class

+   CD3DDevice::CDelayUnpin,class detail::buffer_impl<class CD3DDevice::CDelayUnpin,7,1,class

+   detail::liberal_expansion_policy> >::reserve_region(unsigned __int64,unsigned __int64) __ptr64 */

+

+CDelayUnpin * __thiscall

+detail::

+vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>

+::reserve_region(vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>

+                 *this,__uint64 param_1,__uint64 param_2)

+

+{

+  CDelayUnpin *pCVar1;

+  ulonglong uVar2;

+  ulonglong uVar3;

+  CDelayUnpin *pCVar4;

+  ulonglong uVar5;

+  CDelayUnpin *pCVar6;

+  CDelayUnpin *local_88;

+  ulonglong uStack_80;

+  ulonglong local_78;

+  CDelayUnpin *local_68;

+  undefined8 uStack_60;

+  undefined8 local_58;

+  undefined1 local_50 [16];

+  undefined8 local_40;

+  

+  buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>::ensure_extra_capacity

+            ((buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy> *)this,1);

+  pCVar1 = *(CDelayUnpin **)this;

+  pCVar6 = *(CDelayUnpin **)(this + 8);

+  local_58 = 0;

+  uVar3 = (longlong)pCVar6 - (longlong)pCVar1 >> 6;

+  uStack_60 = 1;

+  local_40 = 0;

+  uVar5 = uVar3 - param_1;

+  local_68 = pCVar1 + uVar3 * 0x40;

+  if (local_68 == (CDelayUnpin *)0x0) {

+LAB_0:

+                    /* WARNING: Subroutine does not return */

+    _invalid_parameter_noinfo_noreturn();

+  }

+  local_40 = 1;

+  uVar2 = uVar5;

+  if (1 < uVar5) {

+    uVar2 = 1;

+  }

+  uStack_80 = 1;

+  pCVar4 = pCVar6 + uVar2 * -0x40;

+  local_78 = 1;

+  local_88 = local_68;

+  if (pCVar6 != pCVar4) {

+    uVar2 = 1;

+    do {

+      pCVar6 = pCVar6 + -0x40;

+      if (((local_88 == (CDelayUnpin *)0x0) || (uVar2 == 0)) ||

+         (uVar2 = uVar2 - 1, uStack_80 <= uVar2)) goto LAB_0;

+      CD3DDevice::CDelayUnpin::CDelayUnpin(local_88 + uVar2 * 0x40,pCVar6);

+    } while (pCVar6 != pCVar4);

+  }

+  if (1 < uVar5) {

+    if ((uVar3 != 0) && ((pCVar1 == (CDelayUnpin *)0x0 || (((longlong)uVar3 < 0 && (uVar3 != 0))))))

+    goto LAB_0;

+    local_88 = pCVar1;

+    uStack_80 = uVar3;

+    local_78 = uVar3;

+    std::

+    move_backward<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_>

+              (local_50,pCVar1 + param_1 * 0x40,pCVar1 + uVar3 * 0x40 + -0x40,&local_88);

+  }

+  pCVar6 = pCVar1 + (param_1 + 1) * 0x40;

+  if (local_68 < pCVar1 + (param_1 + 1) * 0x40) {

+    pCVar6 = local_68;

+  }

+  destruct_range<CD3DDevice::CDelayUnpin>(pCVar1 + param_1 * 0x40,pCVar6);

+  *(longlong *)(this + 8) = *(longlong *)(this + 8) + 0x40;

+  return pCVar1 + param_1 * 0x40;

+}

+
```

## `wil::details::in1diag3::Log_Hr`  (modified)

```diff
--- wil::details::in1diag3::Log_Hr
+++ detail::vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>::clear
@@ -1,13 +1,21 @@
 

-/* long __cdecl wil::details::in1diag3::Log_Hr(void * __ptr64,unsigned int,char const *

-   __ptr64,long) */

+/* public: void __cdecl detail::vector_facade<class CD3DDevice::CDelayUnpin,class

+   detail::buffer_impl<class CD3DDevice::CDelayUnpin,7,1,class detail::liberal_expansion_policy>

+   >::clear(void) __ptr64 */

 

-long __cdecl wil::details::in1diag3::Log_Hr(void *param_1,uint param_2,char *param_3,long param_4)

+void __thiscall

+detail::

+vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>

+::clear(vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>

+        *this)

 

 {

-  void *unaff_retaddr;

+  __uint64 _Var1;

   

-  ReportFailure_Hr<2>(param_1,param_2,param_3,(char *)0x0,(char *)0x0,unaff_retaddr,param_4);

-  return param_4;

+  _Var1 = *(longlong *)(this + 8) - *(longlong *)this >> 6;

+  if (_Var1 != 0) {

+    clear_region(this,0,_Var1);

+  }

+  return;

 }
```

## `CSwapchainRenderStrategy::GetCompositionSurfaceInfo`  (modified)

```diff
--- CSwapchainRenderStrategy::GetCompositionSurfaceInfo
+++ CSwapchainRenderStrategy::GetCompositionSurfaceInfo
@@ -1,2 +1,16 @@
-Failed to decompile dwmcore.dll - .ProgramDB CSwapchainRenderStrategy::GetCompositionSurfaceInfo : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: virtual class CCompositionSurfaceInfo * __ptr64 __cdecl

+   CSwapchainRenderStrategy::GetCompositionSurfaceInfo(class CSurfaceBrush const * __ptr64)const

+   __ptr64 */

+

+CCompositionSurfaceInfo * __thiscall

+CSwapchainRenderStrategy::GetCompositionSurfaceInfo

+          (CSwapchainRenderStrategy *this,CSurfaceBrush *param_1)

+

+{

+  CResource *pCVar1;

+  

+  pCVar1 = CSurfaceBrush::GetSurface(param_1);

+  return *(CCompositionSurfaceInfo **)(pCVar1 + 0x60);

+}

+
```

## `CNineGridBrush::GetBrushParameters`  (modified)

```diff
--- CNineGridBrush::GetBrushParameters
+++ CNineGridBrush::GetBrushParameters
@@ -1,2 +1,320 @@
-Failed to decompile dwmcore.dll - .ProgramDB CNineGridBrush::GetBrushParameters : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* WARNING: Removing unreachable block (ram,0x0001800c455e) */

+/* public: virtual long __cdecl CNineGridBrush::GetBrushParameters(class CBrushDrawListGenerator *

+   __ptr64)const __ptr64 */

+

+long __thiscall

+CNineGridBrush::GetBrushParameters(CNineGridBrush *this,CBrushDrawListGenerator *param_1)

+

+{

+  float fVar1;

+  CNineGridBrush CVar2;

+  code *pcVar3;

+  CSurfaceDrawListBrush *this_00;

+  CDrawListBrush *pCVar4;

+  CNineGridDrawListBrush *pCVar5;

+  char cVar6;

+  bool bVar7;

+  int iVar8;

+  CObjectCache *pCVar9;

+  CNineGridDrawListBrush *pCVar10;

+  Matrix3x2F *this_01;

+  default_delete<CNineGridDrawListBrush> *this_02;

+  CSurfaceBrush *this_03;

+  undefined4 uVar11;

+  unique_ptr<CSharedCircularQueueProducer,std::default_delete<CSharedCircularQueueProducer>_>

+  *this_04;

+  CBrushDrawListGenerator *in_R8;

+  longlong lVar12;

+  float fVar13;

+  float fVar14;

+  float fVar15;

+  float fVar16;

+  float fVar17;

+  float fVar18;

+  float fVar19;

+  float fVar20;

+  undefined1 auStackY_178 [32];

+  uint uVar21;

+  CDrawListBrush *local_148;

+  CNineGridDrawListBrush *local_140;

+  CDrawListBrush **local_138;

+  CGeometryOnlyDrawListBrush *pCStack_130;

+  char local_128;

+  undefined8 local_118;

+  CNineGridDrawListBrush *local_110 [4];

+  undefined4 local_f0;

+  undefined4 local_ec;

+  undefined4 local_e8;

+  undefined4 local_e4;

+  undefined4 local_e0;

+  undefined4 uStack_dc;

+  undefined4 uStack_d8;

+  undefined4 uStack_d4;

+  ulonglong local_c8;

+  

+  local_c8 = __security_cookie ^ (ulonglong)auStackY_178;

+  this_04 = (unique_ptr<CSharedCircularQueueProducer,std::default_delete<CSharedCircularQueueProducer>_>

+             *)local_110;

+  local_118 = *(undefined8 *)param_1;

+  fVar17 = *(float *)(this + 0x74) * *(float *)(this + 0x70);

+  lVar12 = 4;

+  local_140 = (CNineGridDrawListBrush *)0x0;

+  fVar18 = *(float *)(this + 0x7c) * *(float *)(this + 0x78);

+  fVar19 = *(float *)(this + 0x84) * *(float *)(this + 0x80);

+  fVar20 = *(float *)(this + 0x8c) * *(float *)(this + 0x88);

+  do {

+    lVar12 = lVar12 + -1;

+    std::unique_ptr<CSharedCircularQueueProducer,std::default_delete<CSharedCircularQueueProducer>_>

+    ::

+    unique_ptr<CSharedCircularQueueProducer,std::default_delete<CSharedCircularQueueProducer>_><std::default_delete<CSharedCircularQueueProducer>,0>

+              (this_04);

+    this_04 = this_04 + 8;

+  } while (lVar12 != 0);

+  local_ec = *(undefined4 *)(param_1 + 0x2c);

+  local_e8 = *(undefined4 *)(param_1 + 0x30);

+  local_f0 = 0;

+  local_e4 = 0;

+  local_e0 = 0x3f800000;

+  uStack_dc = 0x3f800000;

+  uStack_d8 = 0x3f800000;

+  uStack_d4 = 0x3f800000;

+  if (this[0xa9] == (CNineGridBrush)0x0) {

+    pcVar3 = *(code **)(*(longlong *)*(CSurfaceBrush **)(this + 0x68) + 0x40);

+    if (pcVar3 == CSurfaceBrush::IsOfType) {

+      cVar6 = CSurfaceBrush::IsOfType(*(CSurfaceBrush **)(this + 0x68),0xa7);

+    }

+    else {

+      cVar6 = (*pcVar3)();

+    }

+    if (((cVar6 == '\0') ||

+        (*(CComponentTransform2D **)(*(longlong *)(this + 0x68) + 0x90) ==

+         (CComponentTransform2D *)0x0)) ||

+       (bVar7 = CComponentTransform2D::IsIdentity

+                          (*(CComponentTransform2D **)(*(longlong *)(this + 0x68) + 0x90)), bVar7))

+    goto LAB_0;

+    iVar8 = -0x7ff8f81c;

+    if ((Microsoft_Windows_Dwm_CoreEnableBits._2_1_ & 0x20) != 0) {

+      McTemplateU0t_EventWriteTransfer

+                (&Microsoft_Windows_Dwm_Core_Provider_Context,

+                 &EVTDESC_NINEGRIDBRUSH_DRAW_ERROR_INVALID_INPUT,0x800707e4);

+    }

+    uVar21 = 0x275;

+LAB_1:

+    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)&DAT_2,2,iVar8,uVar21,(void *)0x0);

+  }

+  else {

+LAB_0:

+    this_03 = *(CSurfaceBrush **)(this + 0x68);

+    pcVar3 = *(code **)(*(longlong *)this_03 + 0x150);

+    if (pcVar3 == CSurfaceBrush::GetBrushParameters) {

+      iVar8 = CSurfaceBrush::GetBrushParameters(this_03,(CBrushDrawListGenerator *)&local_118);

+    }

+    else if (pcVar3 == CBitmapRenderStrategy::GetBrushParameters) {

+      iVar8 = CBitmapRenderStrategy::GetBrushParameters

+                        ((CBitmapRenderStrategy *)this_03,(CSurfaceBrush *)&local_118,in_R8);

+    }

+    else {

+      iVar8 = (*pcVar3)();

+    }

+    pCVar10 = local_110[0];

+    if (iVar8 < 0) {

+      uVar21 = 0x27a;

+      goto LAB_1;

+    }

+    local_110[0] = (CNineGridDrawListBrush *)0x0;

+    local_140 = pCVar10;

+    bVar7 = true;

+    fVar13 = fVar17;

+    fVar14 = fVar18;

+    fVar15 = fVar19;

+    fVar16 = fVar20;

+    if (pCVar10 != (CNineGridDrawListBrush *)0x0) {

+      if (pCVar10[0x34] == (CNineGridDrawListBrush)0x0) {

+        if (this[0xa8] == (CNineGridBrush)0x0) goto LAB_3;

+        pCStack_130 = *(CGeometryOnlyDrawListBrush **)(param_1 + 0x2c);

+        local_138 = (CDrawListBrush **)0x0;

+        pCVar10[0x34] = (CNineGridDrawListBrush)0x1;

+        *(undefined4 *)(pCVar10 + 0x30) = 0x3030303;

+        *(undefined8 *)(pCVar10 + 0x20) = 0;

+        *(CGeometryOnlyDrawListBrush **)(pCVar10 + 0x28) = pCStack_130;

+      }

+      else {

+        fVar13 = *(float *)(this + 0x70);

+        fVar14 = *(float *)(this + 0x78);

+        fVar15 = *(float *)(this + 0x80);

+        fVar16 = *(float *)(this + 0x88);

+      }

+LAB_4:

+      local_148 = (CDrawListBrush *)CONCAT44(local_148._4_4_,local_e4);

+      pCVar10 = local_140;

+      uVar11 = local_e4;

+      if (!bVar7) {

+LAB_5:

+        iVar8 = 0;

+        this_01 = (Matrix3x2F *)(this + 0x90);

+        bVar7 = D2D1::Matrix3x2F::IsIdentity(this_01);

+        if (!bVar7) {

+          fVar17 = *(float *)(this_01 + 8);

+          fVar18 = *(float *)this_01;

+          fVar19 = *(float *)(this_01 + 0xc);

+          fVar20 = *(float *)(this_01 + 4);

+          fVar13 = *(float *)(pCVar10 + 8);

+          fVar14 = *(float *)(pCVar10 + 0x10);

+          fVar15 = *(float *)(pCVar10 + 0x18);

+          fVar16 = *(float *)(this_01 + 0x10);

+          fVar1 = *(float *)(this_01 + 0x14);

+          *(float *)(pCVar10 + 8) = *(float *)(pCVar10 + 0xc) * fVar17 + fVar13 * fVar18;

+          *(float *)(pCVar10 + 0xc) = fVar13 * fVar20 + *(float *)(pCVar10 + 0xc) * fVar19;

+          *(float *)(pCVar10 + 0x10) = fVar14 * fVar18 + *(float *)(pCVar10 + 0x14) * fVar17;

+          *(float *)(pCVar10 + 0x14) = fVar14 * fVar20 + *(float *)(pCVar10 + 0x14) * fVar19;

+          *(float *)(pCVar10 + 0x18) =

+               fVar15 * fVar18 + *(float *)(pCVar10 + 0x1c) * fVar17 + fVar16;

+          *(float *)(pCVar10 + 0x1c) = fVar15 * fVar20 + *(float *)(pCVar10 + 0x1c) * fVar19 + fVar1

+          ;

+        }

+        this_00 = *(CSurfaceDrawListBrush **)(param_1 + 8);

+        local_140 = (CNineGridDrawListBrush *)0x0;

+        *(CNineGridDrawListBrush **)(param_1 + 8) = pCVar10;

+        if (this_00 != (CSurfaceDrawListBrush *)0x0) {

+          pcVar3 = (code *)**(undefined8 **)this_00;

+          if (pcVar3 == CMultiPrimitiveDrawListBrush::_vector_deleting_destructor_) {

+            CMultiPrimitiveDrawListBrush::_vector_deleting_destructor_

+                      ((CMultiPrimitiveDrawListBrush *)this_00,1);

+          }

+          else if (pcVar3 == CSurfaceDrawListBrush::_vector_deleting_destructor_) {

+            CSurfaceDrawListBrush::_vector_deleting_destructor_(this_00,1);

+          }

+          else if (pcVar3 == CDrawListPrimitive0::_scalar_deleting_destructor_) {

+            CDrawListPrimitive0::_scalar_deleting_destructor_((CDrawListPrimitive0 *)this_00,1);

+          }

+          else {

+            (*pcVar3)();

+          }

+        }

+        *(undefined4 *)(param_1 + 0x34) = uVar11;

+        uVar11 = 1;

+        if (1 < *(uint *)(param_1 + 0x28)) {

+          uVar11 = *(undefined4 *)(param_1 + 0x28);

+        }

+        *(undefined4 *)(param_1 + 0x28) = uVar11;

+        goto LAB_6;

+      }

+LAB_7:

+      pCVar5 = local_140;

+      CVar2 = this[0xa8];

+      pCVar9 = CThreadContext::GetObjectCache((CNineGridDrawListBrush *)this_03);

+      pCVar10 = (CNineGridDrawListBrush *)0x0;

+      if (*(int *)(pCVar9 + 4) != 0) {

+        pCVar10 = *(CNineGridDrawListBrush **)(pCVar9 + 8);

+        *(undefined8 *)(pCVar9 + 8) = *(undefined8 *)pCVar10;

+        *(int *)(pCVar9 + 4) = *(int *)(pCVar9 + 4) + -1;

+      }

+      if ((pCVar10 == (CNineGridDrawListBrush *)0x0) &&

+         (pCVar10 = _Alloc_DefaultHeap__SAPEAX_K_Z(0x240), pCVar10 == (CNineGridDrawListBrush *)0x0)

+         ) {

+        iVar8 = -0x7ff8fff2;

+        MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,-0x7ff8fff2,0x27,(void *)0x0);

+      }

+      else {

+        *(undefined8 *)(pCVar10 + 8) = 0x3f800000;

+        *(undefined4 *)(pCVar10 + 0x10) = 0;

+        *(undefined8 *)(pCVar10 + 0x14) = 0x3f800000;

+        *(undefined4 *)(pCVar10 + 0x1c) = 0;

+        *(undefined ***)pCVar10 = &CNineGridDrawListBrush::_vftable_;

+        pCVar10[0x34] = (CNineGridDrawListBrush)0x0;

+        pCVar10[0x40] = (CNineGridDrawListBrush)0x0;

+        *(CNineGridDrawListBrush **)(pCVar10 + 0x48) = pCVar5;

+        *(CNineGridDrawListBrush **)(pCVar10 + 0x70) = pCVar10 + 0x88;

+        *(CNineGridDrawListBrush **)(pCVar10 + 0x78) = pCVar10 + 0x88;

+        *(CNineGridDrawListBrush **)(pCVar10 + 0x80) = pCVar10 + 0x128;

+        *(CNineGridDrawListBrush **)(pCVar10 + 0x128) = pCVar10 + 0x140;

+        *(CNineGridDrawListBrush **)(pCVar10 + 0x130) = pCVar10 + 0x140;

+        *(CNineGridDrawListBrush **)(pCVar10 + 0x138) = pCVar10 + 0x1e0;

+        *(float *)(pCVar10 + 0x50) = fVar13;

+        *(float *)(pCVar10 + 0x54) = fVar14;

+        *(float *)(pCVar10 + 0x58) = fVar15;

+        *(float *)(pCVar10 + 0x5c) = fVar16;

+        *(CNineGridDrawListBrush **)(pCVar10 + 0x1e0) = pCVar10 + 0x1f8;

+        *(CNineGridDrawListBrush **)(pCVar10 + 0x1e8) = pCVar10 + 0x1f8;

+        *(CNineGridDrawListBrush **)(pCVar10 + 0x1f0) = pCVar10 + 0x228;

+        *(float *)(pCVar10 + 0x60) = fVar17;

+        *(float *)(pCVar10 + 100) = fVar18;

+        *(float *)(pCVar10 + 0x68) = fVar19;

+        *(float *)(pCVar10 + 0x6c) = fVar20;

+        *(CNineGridBrush *)(pCVar10 + 0x238) = CVar2;

+        pCVar10[0x239] = (CNineGridDrawListBrush)0x0;

+        local_140 = (CNineGridDrawListBrush *)0x0;

+        iVar8 = CNineGridDrawListBrush::Initialize(pCVar10);

+        if (-1 < iVar8) {

+          uVar11 = local_148._0_4_;

+          goto LAB_5;

+        }

+        this_02 = (default_delete<CNineGridDrawListBrush> *)0x14;

+        MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,iVar8,0x29,(void *)0x0);

+        std::default_delete<CNineGridDrawListBrush>::operator()(this_02,pCVar10);

+      }

+      uVar21 = 699;

+      goto LAB_1;

+    }

+    *(ulonglong *)(param_1 + 0x38) = CONCAT44(uStack_dc,local_e0);

+    *(ulonglong *)(param_1 + 0x40) = CONCAT44(uStack_d4,uStack_d8);

+    if (this[0xa8] == (CNineGridBrush)0x0) {

+LAB_3:

+      fVar13 = local_148._0_4_;

+      fVar14 = local_148._0_4_;

+      fVar15 = local_148._0_4_;

+      fVar16 = local_148._0_4_;

+      bVar7 = false;

+      goto LAB_4;

+    }

+    local_128 = '\x01';

+    local_138 = &local_148;

+    local_148 = (CDrawListBrush *)0x0;

+    pCStack_130 = (CGeometryOnlyDrawListBrush *)0x0;

+    iVar8 = CGeometryOnlyDrawListBrush::Create(&pCStack_130);

+    if (local_128 != '\0') {

+      pCVar4 = *local_138;

+      *local_138 = (CDrawListBrush *)pCStack_130;

+      if (pCVar4 != (CDrawListBrush *)0x0) {

+        CThreadLocalObjectCache<CGeometryOnlyDrawListBrush,CGeometryOnlyDrawListBrush>::Free(pCVar4)

+        ;

+      }

+    }

+    pCVar4 = local_148;

+    if (-1 < iVar8) {

+      pCStack_130 = *(CGeometryOnlyDrawListBrush **)(param_1 + 0x2c);

+      local_138 = (CDrawListBrush **)0x0;

+      local_148[0x34] = (CDrawListBrush)0x1;

+      *(undefined4 *)(local_148 + 0x30) = 0x3030303;

+      *(undefined8 *)(local_148 + 0x20) = 0;

+      *(CGeometryOnlyDrawListBrush **)(local_148 + 0x28) = pCStack_130;

+      local_148 = (CDrawListBrush *)0x0;

+      std::unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>::reset

+                ((unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_> *)&local_140,

+                 pCVar4);

+      this_03 = (CSurfaceBrush *)local_148;

+      if (local_148 == (CDrawListBrush *)0x0) goto LAB_4;

+      CThreadLocalObjectCache<CGeometryOnlyDrawListBrush,CGeometryOnlyDrawListBrush>::Free

+                (local_148);

+      local_148 = (CDrawListBrush *)CONCAT44(local_148._4_4_,local_e4);

+      goto LAB_7;

+    }

+    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)&DAT_2,2,iVar8,0x28b,(void *)0x0);

+    if (local_148 != (CDrawListBrush *)0x0) {

+      CThreadLocalObjectCache<CGeometryOnlyDrawListBrush,CGeometryOnlyDrawListBrush>::Free

+                (local_148);

+    }

+  }

+  CBrushDrawListGenerator::Reset(param_1);

+LAB_6:

+  CBrushDrawListGenerator::~CBrushDrawListGenerator((CBrushDrawListGenerator *)&local_118);

+  std::unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>::

+  ~unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>

+            ((unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_> *)&local_140);

+  return iVar8;

+}

+
```

## `COcclusionContext::CollectCursor`  (modified)

```diff
--- COcclusionContext::CollectCursor
+++ COcclusionContext::CollectCursor
@@ -1,2 +1,42 @@
-Failed to decompile dwmcore.dll - .ProgramDB COcclusionContext::CollectCursor : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: void __cdecl COcclusionContext::CollectCursor(class CCursorVisual * __ptr64) __ptr64 */

+

+void __thiscall COcclusionContext::CollectCursor(COcclusionContext *this,CCursorVisual *param_1)

+

+{

+  undefined8 *puVar1;

+  long lVar2;

+  StackBackfaceVisibilityEntry *pSVar3;

+  undefined8 *puVar4;

+  bool bVar5;

+  CMILMatrix local_58 [64];

+  undefined4 local_18;

+  

+  if (this[0x5f6] != (COcclusionContext)0x0) {

+    if ((((*(int *)(this + 0x688) == 0) && (*(int *)(this + 0x68c) == 0)) &&

+        (this[0x5f7] == (COcclusionContext)0x0)) &&

+       (pSVar3 = CWatermarkStack<CDrawingContext::StackBackfaceVisibilityEntry,64,2,10>::

+                 GetTopByReference((CWatermarkStack<CDrawingContext::StackBackfaceVisibilityEntry,64,2,10>

+                                    *)(this + 0x80)), pSVar3 == (StackBackfaceVisibilityEntry *)0x0)

+       ) {

+      bVar5 = true;

+    }

+    else {

+      bVar5 = false;

+    }

+    local_18 = 0;

+    lVar2 = CVisual::GetWorldTransform

+                      ((CVisual *)param_1,*(CVisualTree **)(this + 8),2,local_58,(bool *)0x0,

+                       (CMILMatrix *)0x0);

+    if (-1 < lVar2) {

+      puVar1 = *(undefined8 **)(this + 0x6e8);

+      for (puVar4 = *(undefined8 **)(this + 0x6e0); puVar4 != puVar1; puVar4 = puVar4 + 1) {

+        COverlayContext::SetHardwareCursor((COverlayContext *)*puVar4,param_1,local_58,bVar5);

+      }

+    }

+    this[0x5f6] = (COcclusionContext)0x0;

+    return;

+  }

+  return;

+}

+
```

## `CComposition::Partition_SetCursor`  (modified)

```diff
--- CComposition::Partition_SetCursor
+++ CComposition::Partition_SetCursor
@@ -1,2 +1,51 @@
-Failed to decompile dwmcore.dll - .ProgramDB CComposition::Partition_SetCursor : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* protected: long __cdecl CComposition::Partition_SetCursor(class CChannelContext * __ptr64,class

+   CResourceTable * __ptr64,struct tagMILCMD_PARTITION_SETCURSOR const * __ptr64) __ptr64 */

+

+long __thiscall

+CComposition::Partition_SetCursor

+          (CComposition *this,CChannelContext *param_1,CResourceTable *param_2,

+          tagMILCMD_PARTITION_SETCURSOR *param_3)

+

+{

+  bool bVar1;

+  long lVar2;

+  CResource *pCVar3;

+  uint uVar4;

+  

+  pCVar3 = CResourceTable::GetResource(param_2,*(uint *)(param_3 + 4),0xb4);

+  if (pCVar3 == (CResource *)0x0) {

+                    /* WARNING: Subroutine does not return */

+    FailFastOnMalformedPacket(0xfdfdf761,(void *)0x0);

+  }

+  if (param_3[8] == (tagMILCMD_PARTITION_SETCURSOR)0x0) {

+    RemoveCursorVisual(this,(CVisual *)pCVar3);

+  }

+  else {

+    bVar1 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_CompositionMagnifier_Iter2>::

+            __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_CompositionMagnifier_Iter2>

+                                 *)&`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_CompositionMagnifier_Iter2>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_CompositionMagnifier_Iter2>::GetImpl(void)'

+                                    ::__l2::impl);

+    if ((!bVar1) ||

+       (bVar1 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>::

+                __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor> *)

+                                    &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DesktopDWMCursor>::GetImpl(void)'

+                                     ::__l2::impl), bVar1)) {

+      lVar2 = AddCursorVisual(this);

+      if (-1 < lVar2) {

+        return 0;

+      }

+      uVar4 = 0x4a5;

+    }

+    else {

+      lVar2 = AddCursorVisual(this);

+      if (-1 < lVar2) {

+        return 0;

+      }

+      uVar4 = 0x4a1;

+    }

+    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar2,uVar4,(void *)0x0);

+  }

+  return 0;

+}

+
```

## `CBackdropVisualImage::CBackdropVisualImage`  (modified)

```diff
--- CBackdropVisualImage::CBackdropVisualImage
+++ CBackdropVisualImage::CBackdropVisualImage
@@ -1,28 +1,46 @@
 

-/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

-   guard_dispatch_icall */

+/* private: __cdecl CBackdropVisualImage::CBackdropVisualImage(class CComposition * __ptr64,class

+   CVisual const * __ptr64,class CVisualTreePath const & __ptr64,bool) __ptr64 */

 

-undefined8 __thiscall

-gsl::span<AnimationHelper::AnimatedProperty_const*___ptr64_const,-1>::

-storage_type<gsl::details::extent_type<-1>_>::CBackdropVisualImage

+CBackdropVisualImage * __thiscall

+CBackdropVisualImage::CBackdropVisualImage

           (CBackdropVisualImage *this,CComposition *param_1,CVisual *param_2,

           CVisualTreePath *param_3,bool param_4)

 

 {

-  longlong lVar1;

-  undefined4 uVar2;

-  undefined4 uVar3;

-  undefined4 uVar4;

-  

-  uVar2 = *(undefined4 *)(param_1 + 4);

-  uVar3 = *(undefined4 *)(param_1 + 8);

-  uVar4 = *(undefined4 *)(param_1 + 0xc);

-  lVar1 = *(longlong *)param_3;

-  *(undefined4 *)this = *(undefined4 *)param_1;

-  *(undefined4 *)(this + 4) = uVar2;

-  *(undefined4 *)(this + 8) = uVar3;

-  *(undefined4 *)(this + 0xc) = uVar4;

-  (**(code **)(lVar1 + 0x50))(param_3,3);

-  return 0;

+  CCachedVisualImage::CCachedVisualImage((CCachedVisualImage *)this,param_1,false);

+  *(CVisual **)(this + 0x7e8) = param_2;

+  *(undefined ***)this = &_vftable__for__CResource__;

+  *(undefined ***)(this + 0x48) = &CCachedVisualImage::_vftable__for__IBitmapResource__;

+  *(undefined ***)(this + 0x50) = &CCachedVisualImage::_vftable__for__IBitmapRealization__;

+  *(undefined ***)(this + 0x58) = &CCachedVisualImage::_vftable__for__IDeviceResourceNotify__;

+  detail::

+  vector_facade<CVisualTreePath::VisualTreePathUnit,detail::buffer_impl<CVisualTreePath::VisualTreePathUnit,2,1,detail::liberal_expansion_policy>_>

+  ::

+  vector_facade<CVisualTreePath::VisualTreePathUnit,detail::buffer_impl<CVisualTreePath::VisualTreePathUnit,2,1,detail::liberal_expansion_policy>_>

+            ((vector_facade<CVisualTreePath::VisualTreePathUnit,detail::buffer_impl<CVisualTreePath::VisualTreePathUnit,2,1,detail::liberal_expansion_policy>_>

+              *)(this + 0x7f0),

+             (vector_facade<struct_CVisualTreePath::VisualTreePathUnit,class_detail::buffer_impl<struct_CVisualTreePath::VisualTreePathUnit,2,1,class_detail::liberal_expansion_policy>_>

+              *)param_3);

+  *(undefined8 *)(this + 0x828) = 0;

+  *(undefined8 *)(this + 0x830) = 0;

+  *(undefined4 *)(this + 0x838) = 0x3f800000;

+  *(undefined4 *)(this + 0x83c) = 0x3f800000;

+  *(undefined4 *)(this + 0x840) = 0x3f800000;

+  *(undefined4 *)(this + 0x844) = 0x3f800000;

+  *(undefined8 *)(this + 0x848) = 2;

+  *(undefined4 *)(this + 0x850) = 0x800;

+  *(undefined8 *)(this + 0x85c) = 0;

+  *(undefined8 *)(this + 0x86c) = 0;

+  *(undefined8 *)(this + 0x878) = 0;

+  *(undefined8 *)(this + 0x880) = 0;

+  *(undefined8 *)(this + 0x888) = 0;

+  *(undefined8 *)(this + 0x854) = 0x3f800000;

+  *(undefined8 *)(this + 0x864) = 0x3f800000;

+  *(undefined4 *)(this + 0x874) = 0x3f800000;

+  *(undefined8 *)(this + 0x890) = 0;

+  *(undefined2 *)(this + 0x898) = 0;

+  this[0x89a] = (CBackdropVisualImage)param_4;

+  return this;

 }
```

## `CCursorState::UpdateHardwareCursor`  (modified)

```diff
--- CCursorState::UpdateHardwareCursor
+++ CCursorState::UpdateHardwareCursor
@@ -1,2 +1,62 @@
-Failed to decompile dwmcore.dll - .ProgramDB CCursorState::UpdateHardwareCursor : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* private: enum CursorVisibility __cdecl CCursorState::UpdateHardwareCursor(class

+   CCursorState::MonitorData * __ptr64,bool,bool) __ptr64 */

+

+CursorVisibility __thiscall

+CCursorState::UpdateHardwareCursor

+          (CCursorState *this,MonitorData *param_1,bool param_2,bool param_3)

+

+{

+  bool bVar1;

+  MonitorData *this_00;

+  MonitorData MVar2;

+  undefined8 local_res8;

+  int local_28 [4];

+  undefined8 local_18;

+  undefined8 uStack_10;

+  

+  local_28[0] = 0;

+  local_28[1] = 0;

+  local_28[2] = 0;

+  local_28[3] = 0;

+  local_18 = 0;

+  uStack_10 = 0;

+  MVar2 = (MonitorData)(~*(byte *)(*(longlong *)(this + 0x50) + 0x6a) & 1);

+  param_1[0x9c] = MVar2;

+  this_00 = (MonitorData *)this;

+  if ((MVar2 != (MonitorData)0x0) && (*(longlong *)(this + 0xb8) != 0)) {

+    local_res8 = *(undefined8 *)(this + 0x38);

+    if ((!param_2) || ((this[0x58] != (CCursorState)0x0 || (*(longlong *)(param_1 + 0x70) == 0)))) {

+      local_res8 = *(undefined8 *)(this + 0xdc);

+    }

+    this_00 = param_1;

+    bVar1 = MonitorData::CalcShapeRects

+                      (param_1,(D2D_POINT_2F *)&local_res8,

+                       (TMilRect_<int,tagRECT,D2D_POINTANDSIZE_L,Mil3DRectL,RectUniqueness::_CMilRectL_>

+                        *)local_28,

+                       (TMilRect_<int,tagRECT,D2D_POINTANDSIZE_L,Mil3DRectL,RectUniqueness::_CMilRectL_>

+                        *)&local_18);

+    if (bVar1) {

+      if (param_2) {

+        if ((((!param_3) && (*(int *)(param_1 + 0x98) == 1)) &&

+            (*(int *)(param_1 + 0x8c) == local_28[0])) && (*(int *)(param_1 + 0x90) == local_28[1]))

+        goto LAB_0;

+        bVar1 = SetHardwareShapeAndPosition

+                          (this,param_1,

+                           (TMilRect_<int,tagRECT,D2D_POINTANDSIZE_L,Mil3DRectL,RectUniqueness::_CMilRectL_>

+                            *)local_28,

+                           (TMilRect_<int,tagRECT,D2D_POINTANDSIZE_L,Mil3DRectL,RectUniqueness::_CMilRectL_>

+                            *)&local_18,0,param_3);

+        this_00 = (MonitorData *)this;

+        if (bVar1) goto LAB_0;

+      }

+      ForceSoftwareShape((CCursorState *)this_00,param_1);

+      goto LAB_0;

+    }

+  }

+  HideHardwareShape((CCursorState *)this_00,param_1);

+  *(undefined4 *)(param_1 + 0x98) = 0;

+LAB_0:

+  return *(CursorVisibility *)(param_1 + 0x98);

+}

+
```

## `CIndirectSwapchainRenderTarget::CIndirectSwapchainRenderTarget`  (modified)

```diff
--- CIndirectSwapchainRenderTarget::CIndirectSwapchainRenderTarget
+++ CIndirectSwapchainRenderTarget::CIndirectSwapchainRenderTarget
@@ -1,2 +1,41 @@
-Failed to decompile dwmcore.dll - .ProgramDB CIndirectSwapchainRenderTarget::CIndirectSwapchainRenderTarget : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* private: __cdecl CIndirectSwapchainRenderTarget::CIndirectSwapchainRenderTarget(class

+   CComposition * __ptr64) __ptr64 */

+

+CIndirectSwapchainRenderTarget * __thiscall

+CIndirectSwapchainRenderTarget::CIndirectSwapchainRenderTarget

+          (CIndirectSwapchainRenderTarget *this,CComposition *param_1)

+

+{

+  __uint64 _Var1;

+  void *pvVar2;

+  char *local_18;

+  undefined4 local_10;

+  

+  local_10 = 0x25;

+  local_18 = "DWM Rendertarget (indirect swapchain)";

+  COffScreenRenderTarget::COffScreenRenderTarget

+            ((COffScreenRenderTarget *)this,param_1,(CResourceTag *)&local_18,0);

+  *(undefined ***)this = &_vftable__for__CNotificationResource__;

+  *(undefined ***)(this + 0x50) = &CVisualCapture::_vftable__for__IPixelFormat__;

+  *(undefined ***)(this + 0x58) = &COffScreenRenderTarget::_vftable__for__IVisualTreeClient__;

+  *(undefined ***)(this + 0x60) = &_vftable__for__IRenderTarget__;

+  *(undefined ***)(this + 0xa88) = &_vftable__for__IOcclusionChangeTarget__;

+  *(undefined ***)(this + 0xa90) = &_vftable__for__IDeviceResourceNotify__;

+  *(undefined8 *)(this + 0xa98) = 0;

+  *(undefined8 *)(this + 0xaa0) = 0;

+  _Var1 = std::_Get_size_of_n<48>(1);

+  pvVar2 = std::_Allocate<16,std::_Default_allocate_traits,0>(_Var1);

+  *(void **)pvVar2 = pvVar2;

+  *(void **)((longlong)pvVar2 + 8) = pvVar2;

+  *(void **)((longlong)pvVar2 + 0x10) = pvVar2;

+  *(undefined2 *)((longlong)pvVar2 + 0x18) = 0x101;

+  *(void **)(this + 0xa98) = pvVar2;

+  *(undefined8 *)(this + 0xaa8) = 0;

+  *(undefined8 *)(this + 0xab0) = 0;

+  *(undefined4 *)(this + 0xab8) = 0;

+  *(undefined4 *)(this + 0xabc) = 0;

+  *(undefined4 *)(this + 0xac0) = 0;

+  return this;

+}

+
```

## `CMagnifierRenderTarget::RenderTargetDirty`  (modified)

```diff
--- CMagnifierRenderTarget::RenderTargetDirty
+++ CMagnifierRenderTarget::RenderTargetDirty
@@ -1,2 +1,52 @@
-Failed to decompile dwmcore.dll - .ProgramDB CMagnifierRenderTarget::RenderTargetDirty : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* protected: virtual long __cdecl CMagnifierRenderTarget::RenderTargetDirty(class CDrawingContext *

+   __ptr64,bool * __ptr64) __ptr64 */

+

+long __thiscall

+CMagnifierRenderTarget::RenderTargetDirty

+          (CMagnifierRenderTarget *this,CDrawingContext *param_1,bool *param_2)

+

+{

+  bool bVar1;

+  long lVar2;

+  uint uVar3;

+  undefined4 local_38;

+  undefined8 local_34;

+  undefined8 uStack_2c;

+  undefined8 local_24;

+  undefined8 uStack_1c;

+  undefined4 local_14;

+  

+  lVar2 = COffScreenRenderTarget::RenderTargetDirty((COffScreenRenderTarget *)this,param_1,param_2);

+  if (lVar2 < 0) {

+    uVar3 = 0x228;

+  }

+  else {

+    bVar1 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>::

+            __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor> *)

+                                &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DesktopDWMCursor>::GetImpl(void)'

+                                 ::__l2::impl);

+    if (!bVar1) {

+      return lVar2;

+    }

+    if (*param_2 == false) {

+      return lVar2;

+    }

+    local_38 = 2;

+    uStack_2c = 0;

+    local_34 = 1;

+    local_14 = 0;

+    local_24 = 0;

+    uStack_1c = 0;

+    lVar2 = COffScreenRenderTarget::RenderCursors

+                      ((COffScreenRenderTarget *)this,param_1,(MilRenderOptions *)&local_38,

+                       (_D3DCOLORVALUE *)0x0);

+    if (-1 < lVar2) {

+      return lVar2;

+    }

+    uVar3 = 0x231;

+  }

+  MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar2,uVar3,(void *)0x0);

+  return lVar2;

+}

+
```

## `CKeyframeAnimation::SetOutputType`  (modified)

```diff
--- CKeyframeAnimation::SetOutputType
+++ CKeyframeAnimation::SetOutputType
@@ -1,121 +1,48 @@
 

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

-/* WARNING: Removing unreachable block (ram,0x00018001e0cd) */

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* protected: virtual long __cdecl CKeyframeAnimation::SetOutputType(enum

+   DCOMPOSITION_EXPRESSION_TYPE) __ptr64 */

 

 long __thiscall

-KeyframeSequence::Keyframe::SetOutputType

-          (CKeyframeAnimation *this,DCOMPOSITION_EXPRESSION_TYPE param_1)

+CKeyframeAnimation::SetOutputType(CKeyframeAnimation *this,DCOMPOSITION_EXPRESSION_TYPE param_1)

 

 {

-  CBaseExpression CVar1;

-  byte bVar2;

-  uint uVar3;

-  longlong lVar4;

-  bool bVar5;

-  bool bVar6;

-  CBaseExpression CVar7;

-  long lVar8;

-  byte bVar9;

-  int unaff_EBP;

-  CBaseExpression *unaff_RSI;

-  CExpressionValue *unaff_RDI;

-  long lVar10;

-  int unaff_R13D;

-  CExpressionValueStack *unaff_R14;

-  byte *unaff_R15;

-  float unaff_XMM6_Da;

-  float unaff_XMM9_Da;

+  DCOMPOSITION_EXPRESSION_TYPE DVar1;

+  longlong *plVar2;

+  bool bVar3;

+  long lVar4;

   

-  unaff_RDI[0x48000004] = SUB81((ulonglong)this >> 8,0);

-  Microsoft::WRL::ComPtr<CPathData>::InternalRelease

-            ((ComPtr<CPathData> *)(ulonglong)(unaff_EBP - 0x70));

-  uVar3 = *(uint *)(unaff_R14 + 8);

-  *(uint *)(unaff_R14 + 8) = uVar3 + 1;

-  CExpressionValue::CopyFrom

-            ((CExpressionValue *)((ulonglong)uVar3 * 0x50 + *(longlong *)(unaff_R14 + 0x10)),

-             unaff_RDI);

-  if (((byte)(*(KeyframeSequence **)(unaff_RSI + 0x160))[0x8c] & 1) != 0) {

-    Stop(*(KeyframeSequence **)(unaff_RSI + 0x160));

-  }

-  lVar10 = 0;

-  CVar1 = unaff_RSI[0x218];

-  *(undefined4 *)(unaff_RSI + 0x1bc) = 0;

-  unaff_RSI[0x218] = (CBaseExpression)((byte)CVar1 & 0x7f);

-  unaff_RSI[0x219] = (CBaseExpression)((byte)unaff_RSI[0x219] & 0xf8);

-  if ((((byte)CVar1 & 0x20) == 0) &&

-     (lVar8 = CBaseExpression::NotifyAnimationStopped(unaff_RSI), lVar8 < 0)) {

-    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar8,0x742,(void *)0x0);

-  }

-  CVar1 = unaff_RSI[0x218];

-  CVar7 = (CBaseExpression)((byte)CVar1 & 0xfe);

-  unaff_RSI[0x218] = CVar7;

-  if (((byte)CVar1 & 0x20) == 0) {

-    *(undefined8 *)(unaff_RSI + 0x204) = 0;

+  if ((param_1 - 0xb < 0x3d) &&

+     ((0x1c000200010000c1U >> ((ulonglong)(param_1 - 0xb) & 0x3f) & 1) != 0)) {

+    bVar3 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_2041296187>::__private_IsEnabled

+                      ((FeatureImpl<__WilFeatureTraits_Feature_2041296187> *)

+                       &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_2041296187>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_2041296187>::GetImpl(void)'

+                        ::__l2::impl);

+    if (bVar3) {

+      DVar1 = *(DCOMPOSITION_EXPRESSION_TYPE *)(this + 0xa0);

+      *(DCOMPOSITION_EXPRESSION_TYPE *)(this + 0xa0) = param_1;

+      if (param_1 != DVar1) {

+        std::unique_ptr<unsigned_char_[0],std::default_delete<unsigned_char_[0]>_>::

+        reset<unsigned_char*___ptr64,0>

+                  ((unique_ptr<unsigned_char_[0],std::default_delete<unsigned_char_[0]>_> *)

+                   (this + 0x150),(uchar *)0x0);

+        plVar2 = *(longlong **)(this + 0x158);

+        *(undefined8 *)(this + 0x158) = 0;

+        if (plVar2 != (longlong *)0x0) {

+          (**(code **)(*plVar2 + 0x10))();

+        }

+      }

+    }

+    else {

+      *(DCOMPOSITION_EXPRESSION_TYPE *)(this + 0xa0) = param_1;

+    }

+    lVar4 = 0;

   }

   else {

-    CVar1 = unaff_RSI[0x219];

-    if (((byte)CVar1 & 1) == 0) {

-      *(undefined4 *)(unaff_RSI + 0x1f0) = 0;

-      if ((*(int *)(unaff_RSI + 0x210) == 0) || (*(int *)(unaff_RSI + 0x210) == 2)) {

-        bVar9 = (byte)CVar1 >> 3;

-      }

-      else {

-        bVar9 = 0;

-      }

-      if ((*(int *)(unaff_RSI + 500) == 0) && (*(float *)(unaff_RSI + 0x1fc) != unaff_XMM6_Da)) {

-        unaff_XMM6_Da = *(float *)(unaff_RSI + 0x1fc);

-      }

-      bVar2 = *(byte *)(*(longlong *)(unaff_RSI + 0x160) + 0x8c);

-      *(byte *)(*(longlong *)(unaff_RSI + 0x160) + 0x8c) = (bVar9 << 3 ^ bVar2) & 8 ^ bVar2;

-      bVar5 = unaff_XMM9_Da != *(float *)(unaff_RSI + 0x1e0);

-      bVar6 = *(float *)(unaff_RSI + 0x1e0) <= unaff_XMM9_Da;

-      lVar4 = *(longlong *)(unaff_RSI + 0x160);

-      bVar9 = 0x10;

-      if (!bVar6 || !bVar5) {

-        bVar9 = 0;

-      }

-      *(bool *)(lVar4 + 0x60) = bVar6 && bVar5;

-      *(byte *)(lVar4 + 0x8c) = bVar9 | *(byte *)(lVar4 + 0x8c) & 0xef;

-      *(undefined4 *)(*(longlong *)(unaff_RSI + 0x160) + 0x84) = 0;

-      *(float *)(*(longlong *)(unaff_RSI + 0x160) + 0x88) = unaff_XMM6_Da;

-      Play(*(KeyframeSequence **)(unaff_RSI + 0x160));

-      CVar1 = unaff_RSI[0x218];

-      unaff_RSI[0x219] = (CBaseExpression)((byte)unaff_RSI[0x219] & 0xfd | 1);

-      *(undefined4 *)(unaff_RSI + 0x1f8) = *(undefined4 *)(unaff_RSI + 500);

-      unaff_RSI[0x218] = (CBaseExpression)((byte)CVar1 | 0x80);

-      if (((byte)CVar1 & 0x20) == 0) {

-        if (*(int *)(unaff_RSI + 0xe4) != 4) {

-          *(undefined4 *)(unaff_RSI + 0xe4) = 4;

-        }

-        if ((*(int *)(unaff_RSI + 0x1b8) <= *(int *)(unaff_RSI + 0x1bc)) &&

-           (lVar8 = CKeyframeAnimation::SampleExpressionsAndStartingValue

-                              ((CKeyframeAnimation *)unaff_RSI,unaff_R14), lVar8 < 0)) {

-          MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar8,0x753,(void *)0x0);

-        }

-      }

-      unaff_RSI[0x219] = (CBaseExpression)((byte)unaff_RSI[0x219] | 4);

-    }

-    else if ((-1 < (char)CVar7) && (((byte)CVar1 & 2) == 0)) {

-      unaff_RSI[0x218] = (CBaseExpression)((byte)CVar7 | 0x80);

-      Play(*(KeyframeSequence **)(unaff_RSI + 0x160));

-    }

-    if ((((byte)unaff_RSI[0x219] & 1) != 0) && ((char)unaff_RSI[0x218] < '\0')) {

-      unaff_RSI[0x218] = (CBaseExpression)((byte)unaff_RSI[0x218] & 0x7f);

-      *(byte *)(*(longlong *)(unaff_RSI + 0x160) + 0x8c) =

-           *(byte *)(*(longlong *)(unaff_RSI + 0x160) + 0x8c) & 0xfd;

-    }

+    lVar4 = -0x7767fbfd;

+    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,-0x7767fbfd,0xa2,(void *)0x0);

   }

-  if (*(int *)(unaff_R14 + 8) != unaff_R13D + 1) {

-    if (*(int *)(unaff_R14 + 8) == unaff_R13D) {

-      lVar10 = 1;

-    }

-    else {

-      lVar10 = -0x7fff0001;

-      MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,-0x7fff0001,0x6b4,(void *)0x0);

-    }

-  }

-  *unaff_R15 = (byte)unaff_RSI[0x218] & 1;

-  unaff_RSI[0x218] = (CBaseExpression)((byte)unaff_RSI[0x218] & 0x99);

-  return lVar10;

+  return lVar4;

 }
```

## `CSwapchainRenderStrategy::HasRevealBorder`  (modified)

```diff
--- CSwapchainRenderStrategy::HasRevealBorder
+++ CSwapchainRenderStrategy::Draw
@@ -1,39 +1,148 @@
 

-/* public: virtual bool __cdecl CSwapchainRenderStrategy::HasRevealBorder(class CSurfaceBrush const

-   * __ptr64,struct _D3DCOLORVALUE * __ptr64)const __ptr64 */

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: virtual long __cdecl CSwapchainRenderStrategy::Draw(class CSurfaceBrush * __ptr64,class

+   CDrawingContext * __ptr64,struct D2D_SIZE_F const & __ptr64,class CDrawListCache * __ptr64)const

+   __ptr64 */

 

-bool __thiscall

-CSwapchainRenderStrategy::HasRevealBorder

-          (CSwapchainRenderStrategy *this,CSurfaceBrush *param_1,_D3DCOLORVALUE *param_2)

+long __thiscall

+CSwapchainRenderStrategy::Draw

+          (CSwapchainRenderStrategy *this,CSurfaceBrush *param_1,CDrawingContext *param_2,

+          D2D_SIZE_F *param_3,CDrawListCache *param_4)

 

 {

   bool bVar1;

-  SizePreference SVar2;

+  bool bVar2;

+  bool bVar3;

+  bool bVar4;

+  long lVar5;

+  long lVar6;

   CResource *this_00;

-  undefined8 local_18;

-  undefined4 uStack_10;

-  float fStack_c;

+  undefined1 auStackY_f8 [32];

+  uint uVar7;

+  CDrawListCache *local_c0;

+  undefined8 local_b8;

+  undefined8 uStack_b0;

+  undefined8 local_a8;

+  undefined8 uStack_a0;

+  undefined8 local_98;

+  undefined8 uStack_90;

+  undefined8 local_88;

+  CDrawListCache **local_80;

+  CShape *pCStack_78;

+  undefined1 local_70;

+  undefined8 local_68;

+  undefined8 uStack_60;

+  undefined8 local_58;

+  undefined8 uStack_50;

+  ulonglong local_48;

   

-  if (*(int *)(param_1 + 0x78) != 1) {

-    this_00 = CSurfaceBrush::GetSurface(param_1);

-    bVar1 = CCompositionSurfaceBitmap::HasSwapChainAttributes((CCompositionSurfaceBitmap *)this_00);

-    if (bVar1) {

-      SVar2 = CCompositionSurfaceBitmap::GetSizePreference((CCompositionSurfaceBitmap *)this_00);

-      bVar1 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2>::

-              __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2> *)

-                                  &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DCompChromiumK2>::GetImpl(void)'

-                                   ::__l2::impl);

-      if ((((!bVar1) || (SVar2 != 3)) && (SVar2 != 0)) &&

-         (CCompositionSurfaceBitmap::GetBorderColor((CCompositionSurfaceBitmap *)this_00),

-         1.1920929e-06 <= ABS(fStack_c))) {

-        if (param_2 != (_D3DCOLORVALUE *)0x0) {

-          *(undefined8 *)param_2 = local_18;

-          *(ulonglong *)(param_2 + 8) = CONCAT44(fStack_c,uStack_10);

+  local_48 = __security_cookie ^ (ulonglong)auStackY_f8;

+  local_c0 = param_4;

+  lVar5 = 0;

+  bVar1 = false;

+  this_00 = CSurfaceBrush::GetSurface(param_1);

+  local_68 = 0;

+  uStack_60 = 0;

+  bVar2 = HasRevealBorder(this,param_1,(_D3DCOLORVALUE *)&local_68);

+  local_58 = 0;

+  uStack_50 = 0;

+  bVar3 = CCompositionSurfaceBitmap::GetLetterboxingMargins

+                    ((CCompositionSurfaceBitmap *)this_00,(D2D_RECT_F *)&local_58);

+  local_b8 = 0;

+  uStack_b0 = 0;

+  bVar4 = CDrawingContext::DrawAsOverlay

+                    (param_2,(IBitmapResource *)

+                             (-(ulonglong)(this_00 != (CResource *)0x0) &

+                             (ulonglong)(this_00 + 0x48)),

+                     (TMilRect_<int,tagRECT,D2D_POINTANDSIZE_L,Mil3DRectL,RectUniqueness::_CMilRectL_>

+                      *)&local_b8);

+  if (bVar4) {

+    bVar4 = TMilRect<int,tagRECT,D2D_POINTANDSIZE_L,RectUniqueness::_CMilRectL_>::IsEmpty

+                      ((TMilRect<int,tagRECT,D2D_POINTANDSIZE_L,RectUniqueness::_CMilRectL_> *)

+                       &local_b8);

+    if (!bVar4) {

+      lVar5 = CDrawingContext::PushOverlayClip

+                        (param_2,(IBitmapResource *)

+                                 (-(ulonglong)(this_00 != (CResource *)0x0) &

+                                 (ulonglong)(this_00 + 0x48)),

+                         (TMilRect_<int,tagRECT,D2D_POINTANDSIZE_L,Mil3DRectL,RectUniqueness::_CMilRectL_>

+                          *)&local_b8);

+      if (lVar5 < 0) {

+        MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar5,0x559,(void *)0x0);

+        return lVar5;

+      }

+      bVar1 = true;

+      goto LAB_0;

+    }

+LAB_1:

+    if (bVar2) {

+      pCStack_78 = (CShape *)0x0;

+      local_70 = 1;

+      local_c0 = (CDrawListCache *)0x0;

+      local_88 = 0;

+      local_80 = &local_c0;

+      local_a8 = 0;

+      uStack_a0 = 0;

+      local_98 = 0;

+      uStack_90 = 0;

+      lVar6 = CSurfaceBrush::ComputeLayout(param_1,param_3,(LayoutData *)&local_a8,&pCStack_78);

+      wil::details::out_param_t<std::unique_ptr<CShape,std::default_delete<CShape>_>_>::

+      ~out_param_t<std::unique_ptr<CShape,std::default_delete<CShape>_>_>

+                ((out_param_t<std::unique_ptr<CShape,std::default_delete<CShape>_>_> *)&local_80);

+      if (-1 < lVar6) {

+        local_80 = (CDrawListCache **)0x0;

+        pCStack_78 = (CShape *)0x0;

+        lVar5 = (**(code **)(*(longlong *)local_c0 + 0x30))();

+        if (lVar5 < 0) {

+          uVar7 = 0x577;

         }

-        return true;

+        else {

+          local_b8 = 0;

+          uStack_b0 = CONCAT44(*(float *)(param_3 + 4) + 0.0,*(float *)param_3 + 0.0);

+          lVar5 = CCompositionSurfaceBitmap::DrawContentBorders

+                            (param_2,(TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                                      *)&local_b8,

+                             (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                              *)&local_80,(_D3DCOLORVALUE *)&local_68);

+          if (-1 < lVar5) goto LAB_2;

+          uVar7 = 0x583;

+        }

+        MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar5,uVar7,(void *)0x0);

+        std::unique_ptr<CShape,std::default_delete<CShape>_>::

+        ~unique_ptr<CShape,std::default_delete<CShape>_>

+                  ((unique_ptr<CShape,std::default_delete<CShape>_> *)&local_c0);

+        goto LAB_3;

       }

+LAB_2:

+      std::unique_ptr<CShape,std::default_delete<CShape>_>::

+      ~unique_ptr<CShape,std::default_delete<CShape>_>

+                ((unique_ptr<CShape,std::default_delete<CShape>_> *)&local_c0);

     }

+    if ((!bVar3) ||

+       (lVar5 = CCompositionSurfaceBitmap::DrawLetterboxingMargins

+                          ((CCompositionSurfaceBitmap *)this_00,param_2,param_3), -1 < lVar5))

+    goto LAB_3;

+    uVar7 = 0x589;

   }

-  return false;

+  else {

+LAB_0:

+    lVar5 = CBrush::Draw((CBrush *)param_1,param_2,param_3,local_c0);

+    if (-1 < lVar5) {

+      if (bVar1) {

+        CDrawingContext::PopGpuClipRectInternal(param_2,false);

+        bVar1 = false;

+      }

+      goto LAB_1;

+    }

+    uVar7 = 0x55f;

+  }

+  MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar5,uVar7,(void *)0x0);

+LAB_3:

+  if (bVar1) {

+    CDrawingContext::PopGpuClipRectInternal(param_2,false);

+  }

+  return lVar5;

 }
```

## `CBitmapRenderStrategy::IsOpaque`  (modified)

```diff
--- CBitmapRenderStrategy::IsOpaque
+++ CBitmapRenderStrategy::IsOpaque
@@ -1,2 +1,41 @@
-Failed to decompile dwmcore.dll - .ProgramDB CBitmapRenderStrategy::IsOpaque : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: virtual bool __cdecl CBitmapRenderStrategy::IsOpaque(class CSurfaceBrush const *

+   __ptr64)const __ptr64 */

+

+bool __thiscall CBitmapRenderStrategy::IsOpaque(CBitmapRenderStrategy *this,CSurfaceBrush *param_1)

+

+{

+  undefined1 uVar1;

+  CResource *this_00;

+  CCompositionSurfaceBitmap *local_res18;

+  undefined8 local_res20;

+  

+  local_res18 = (CCompositionSurfaceBitmap *)0x0;

+  local_res20 = 0;

+  this_00 = CSurfaceBrush::GetSurface(param_1);

+  if ((code *)**(undefined8 **)this_00 ==

+      CMILCOMBaseWeakRefSource<CResourceDeleter>::InternalQueryInterface) {

+    CMILCOMBaseWeakRefSource<CResourceDeleter>::InternalQueryInterface

+              ((CMILCOMBaseWeakRefSource<CResourceDeleter> *)this_00,

+               (_GUID *)&_GUID_b35f2031_4b76_4d4e_b98c_6771dfcc753c,&local_res18);

+  }

+  else {

+    (*(code *)**(undefined8 **)this_00)();

+  }

+  wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::

+  ~com_ptr_t<IBitmapResource,wil::err_returncode_policy>

+            ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res20);

+  if (*(code **)(*(longlong *)local_res18 + 0x20) == CCompositionSurfaceBitmap::IsOpaque) {

+    uVar1 = CCompositionSurfaceBitmap::IsOpaque(local_res18);

+  }

+  else {

+    uVar1 = (**(code **)(*(longlong *)local_res18 + 0x20))();

+  }

+  wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::

+  ~com_ptr_t<IBitmapResource,wil::err_returncode_policy>

+            ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res18);

+  return (bool)uVar1;

+}

+
```

## `CGlobalComposition::RegisterCursorVisual`  (modified)

```diff
--- CGlobalComposition::RegisterCursorVisual
+++ CGlobalComposition::RegisterCursorVisual
@@ -1,2 +1,32 @@
-Failed to decompile dwmcore.dll - .ProgramDB CGlobalComposition::RegisterCursorVisual : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: void __cdecl CGlobalComposition::RegisterCursorVisual(class CCursorVisual * __ptr64)

+   __ptr64 */

+

+void __thiscall

+CGlobalComposition::RegisterCursorVisual(CGlobalComposition *this,CCursorVisual *param_1)

+

+{

+  __uint64 *p_Var1;

+  CCursorVisual *local_res10 [3];

+  uint local_20;

+  undefined1 local_18 [8];

+  uint local_10;

+  

+  p_Var1 = *(__uint64 **)(this + 0x19b0);

+  local_res10[0] = param_1;

+  if (p_Var1 == *(__uint64 **)(this + 0x19b8)) {

+    std::vector<unsigned___int64,std::allocator<unsigned___int64>_>::

+    _Emplace_reallocate<unsigned___int64_const&___ptr64>

+              ((vector<unsigned___int64,std::allocator<unsigned___int64>_> *)(this + 0x19a8),p_Var1,

+               (__uint64 *)local_res10);

+  }

+  else {

+    *p_Var1 = (__uint64)param_1;

+    *(longlong *)(this + 0x19b0) = *(longlong *)(this + 0x19b0) + 8;

+  }

+  local_20 = local_20 & 0xffffff00;

+  local_10 = local_20;

+  CComposition::AddCursorVisual((CComposition *)this,local_res10[0],local_18);

+  return;

+}

+
```

## `wil::details::WilApiImpl_RecordFeatureUsage`  (modified)

```diff
--- wil::details::WilApiImpl_RecordFeatureUsage
+++ wil::details::WilApiImpl_RecordFeatureUsage
@@ -1,2 +1,31 @@
-Failed to decompile dwmcore.dll - .ProgramDB wil::details::WilApiImpl_RecordFeatureUsage : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* void __cdecl wil::details::WilApiImpl_RecordFeatureUsage(unsigned int,unsigned int,unsigned

+   int,char const * __ptr64) */

+

+void __cdecl

+wil::details::WilApiImpl_RecordFeatureUsage(uint param_1,uint param_2,uint param_3,char *param_4)

+

+{

+  undefined4 in_register_0000000c;

+  wil_details_ServiceReportingKind wVar1;

+  

+  wVar1 = param_2 & 0x7fffffff;

+  if (((param_1 == 0) && (param_3 == 0)) && (wVar1 == 0)) {

+    FeatureStateManager::FlushUsage((FeatureStateManager *)&g_featureStateManager);

+    return;

+  }

+  if (wVar1 >> 0x1e != 0) {

+    FeatureStateManager::QueueBackgroundSRUMUsageReporting

+              ((FeatureStateManager *)&g_featureStateManager,param_1,(ushort)wVar1,param_3);

+    return;

+  }

+  if ((param_3 == 0) && (wVar1 != 0xfe)) {

+    wil_RtlStagingConfig_RecordFeatureUsage

+              (CONCAT44(in_register_0000000c,param_1),wVar1,param_2 >> 0x1f);

+    return;

+  }

+  FeatureStateManager::RecordFeatureUsage

+            ((FeatureStateManager *)&g_featureStateManager,param_1,wVar1,(ulonglong)param_3);

+  return;

+}

+
```

## `CVisual::HasNonEmptyContent`  (modified)

```diff
--- CVisual::HasNonEmptyContent
+++ CVisual::HasNonEmptyContent
@@ -1,2 +1,190 @@
-Failed to decompile dwmcore.dll - .ProgramDB CVisual::HasNonEmptyContent : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: virtual bool __cdecl CVisual::HasNonEmptyContent(void)const __ptr64 */

+

+bool __thiscall CVisual::HasNonEmptyContent(CVisual *this)

+

+{

+  uint uVar1;

+  uint *puVar2;

+  CEffectBrush *this_00;

+  bool bVar3;

+  char cVar4;

+  char cVar5;

+  CResource *pCVar6;

+  uint *puVar7;

+  code *pcVar8;

+  CSurfaceBrush *this_01;

+  uint uVar9;

+  longlong *plVar11;

+  bool local_res8 [8];

+  bool local_res10 [8];

+  char local_res18 [8];

+  IBitmapResource *local_res20;

+  IBitmapResource *local_48 [3];

+  longlong *plVar10;

+  

+  this_01 = *(CSurfaceBrush **)(this + 0x100);

+  plVar11 = (longlong *)0x0;

+  if (this_01 == (CSurfaceBrush *)0x0) goto LAB_0;

+  pcVar8 = *(code **)(*(longlong *)this_01 + 0xd8);

+  if (pcVar8 == CBrush::IsEmptyDrawing) {

+    pcVar8 = *(code **)(*(longlong *)this_01 + 0x138);

+    local_res8[0] = false;

+    if (pcVar8 == CSurfaceBrush::IsReadyToDraw) {

+      pcVar8 = *(code **)**(undefined8 **)(this_01 + 0x88);

+      if (pcVar8 == CBitmapRenderStrategy::IsReadyToDraw) {

+        local_res20 = (IBitmapResource *)0x0;

+        wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::reset

+                  ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res20);

+        CBitmapRenderStrategy::GetBitmap(this_01,&local_res20);

+        cVar5 = CBitmapRenderStrategy::HasRenderingRealization(local_res20);

+        wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::

+        ~com_ptr_t<IBitmapResource,wil::err_returncode_policy>

+                  ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res20);

+      }

+      else if (pcVar8 == CPrimitiveGroupRenderStrategy::IsReadyToDraw) {

+LAB_1:

+        pCVar6 = CSurfaceBrush::GetSurface(this_01);

+        if (*(code **)(*(longlong *)pCVar6 + 0xd8) == CPrimitiveGroup::IsEmptyDrawing) {

+          local_res8[0] = CPrimitiveGroup::IsEmptyDrawing((CPrimitiveGroup *)pCVar6);

+        }

+        else {

+          local_res8[0] = (bool)(**(code **)(*(longlong *)pCVar6 + 0xd8))();

+        }

+        cVar5 = '\x01';

+      }

+      else if (pcVar8 == CVisualSurfaceRenderStrategy::IsReadyToDraw) {

+        pCVar6 = CSurfaceBrush::GetSurface(this_01);

+        cVar5 = CVisualSurface::HasSomethingToDraw((CVisualSurface *)pCVar6);

+      }

+      else {

+        cVar5 = (*pcVar8)(*(undefined8 **)(this_01 + 0x88),this_01,0,local_res8);

+      }

+      goto LAB_2;

+    }

+    if (pcVar8 == CMaskBrush::IsReadyToDraw) {

+      this_00 = *(CEffectBrush **)(this_01 + 0x78);

+      cVar5 = '\0';

+      local_res10[0] = false;

+      local_res18[0] = '\0';

+      if (this_00 != (CEffectBrush *)0x0) {

+        pcVar8 = *(code **)(*(longlong *)this_00 + 0x138);

+        if (pcVar8 == CGradientBrush::IsReadyToDraw) {

+          local_res10[0] =

+               std::vector<CColorGradientStop*___ptr64,std::allocator<CColorGradientStop*___ptr64>_>

+               ::empty((vector<CColorGradientStop*___ptr64,std::allocator<CColorGradientStop*___ptr64>_>

+                        *)(this_00 + 0xa8));

+          bVar3 = std::

+                  vector<CColorGradientStop*___ptr64,std::allocator<CColorGradientStop*___ptr64>_>::

+                  empty((vector<CColorGradientStop*___ptr64,std::allocator<CColorGradientStop*___ptr64>_>

+                         *)(this_00 + 0xa8));

+          cVar4 = !bVar3;

+LAB_3:

+          if (cVar4 != '\0') {

+LAB_4:

+            plVar10 = *(longlong **)(this_01 + 0x70);

+            if ((plVar10 == (longlong *)0x0) ||

+               (cVar4 = (**(code **)(*plVar10 + 0x138))(plVar10,0,local_res18), cVar4 != '\0')) {

+              cVar5 = '\x01';

+            }

+          }

+        }

+        else {

+          if (pcVar8 != CColorBrush::IsReadyToDraw) {

+            if (pcVar8 == CEffectBrush::IsReadyToDraw) {

+              cVar4 = CEffectBrush::IsReadyToDraw(this_00,(CDrawingContext *)0x0,local_res10);

+            }

+            else {

+              cVar4 = (*pcVar8)();

+            }

+            goto LAB_3;

+          }

+          local_res10[0] = IsCloseRealZero(*(float *)(this_00 + 0x74),1.1920929e-06);

+          if (!NAN(*(float *)(this_00 + 0x74))) goto LAB_4;

+        }

+        if ((local_res10[0] != false) || (local_res18[0] != '\0')) {

+          local_res8[0] = true;

+          goto LAB_2;

+        }

+      }

+      local_res8[0] = false;

+    }

+    else if (pcVar8 == CNineGridBrush::IsReadyToDraw) {

+      this_01 = *(CSurfaceBrush **)(this_01 + 0x68);

+      if (this_01 == (CSurfaceBrush *)0x0) goto LAB_0;

+      pcVar8 = *(code **)(*(longlong *)this_01 + 0x138);

+      if (pcVar8 == CSurfaceBrush::IsReadyToDraw) {

+        pcVar8 = *(code **)**(undefined8 **)(this_01 + 0x88);

+        if (pcVar8 == CBitmapRenderStrategy::IsReadyToDraw) {

+          local_48[0] = (IBitmapResource *)0x0;

+          wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::reset

+                    ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)local_48);

+          CBitmapRenderStrategy::GetBitmap(this_01,local_48);

+          cVar5 = CBitmapRenderStrategy::HasRenderingRealization(local_48[0]);

+          wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::

+          ~com_ptr_t<IBitmapResource,wil::err_returncode_policy>

+                    ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)local_48);

+        }

+        else {

+          if (pcVar8 == CPrimitiveGroupRenderStrategy::IsReadyToDraw) goto LAB_1;

+          if (pcVar8 == CVisualSurfaceRenderStrategy::IsReadyToDraw) {

+            pCVar6 = CSurfaceBrush::GetSurface(this_01);

+            cVar5 = CVisualSurface::HasSomethingToDraw((CVisualSurface *)pCVar6);

+          }

+          else {

+            cVar5 = (*pcVar8)(*(undefined8 **)(this_01 + 0x88),this_01,0,local_res8);

+          }

+        }

+      }

+      else {

+        if (pcVar8 != CColorBrush::IsReadyToDraw) goto LAB_5;

+        cVar5 = CColorBrush::IsReadyToDraw((CColorBrush *)this_01,(CDrawingContext *)0x0,local_res8)

+        ;

+      }

+    }

+    else {

+LAB_5:

+      cVar5 = (*pcVar8)(this_01,0,local_res8);

+    }

+LAB_2:

+    if (cVar5 == '\0') goto LAB_0;

+  }

+  else if (pcVar8 == CColorBrush::IsEmptyDrawing) {

+    local_res8[0] = IsCloseRealZero(*(float *)(this_01 + 0x74),1.1920929e-06);

+  }

+  else {

+    local_res8[0] = (bool)(*pcVar8)(this_01);

+  }

+  if (local_res8[0] == false) {

+    return true;

+  }

+LAB_0:

+  puVar2 = *(uint **)(this + 0xe8);

+  if ((*puVar2 & 0x40000) != 0) {

+    uVar1 = puVar2[1];

+    puVar7 = puVar2 + 2;

+    uVar9 = 0;

+    plVar10 = plVar11;

+    if (uVar1 != 0) {

+      do {

+        uVar9 = (uint)plVar10;

+        if ((char)*puVar7 == '\x0e') break;

+        uVar9 = uVar9 + 1;

+        plVar10 = (longlong *)(ulonglong)uVar9;

+        puVar7 = (uint *)((longlong)puVar7 + 1);

+      } while (uVar9 < uVar1);

+    }

+    if (uVar9 < uVar1) {

+      plVar11 = (longlong *)

+                (((ulonglong)uVar9 * 8 - (ulonglong)((uint)((ulonglong)uVar1 + 0xf) & 7)) +

+                 (ulonglong)uVar1 + 0xf + (longlong)puVar2);

+    }

+    if (*(longlong *)*plVar11 != ((longlong *)*plVar11)[1]) {

+      return true;

+    }

+  }

+  return false;

+}

+
```

## `CSurfaceBrush::HasRenderingIntermediate`  (modified)

```diff
--- CSurfaceBrush::HasRenderingIntermediate
+++ CSurfaceBrush::HasRenderingIntermediate
@@ -1,2 +1,24 @@
-Failed to decompile dwmcore.dll - .ProgramDB CSurfaceBrush::HasRenderingIntermediate : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: virtual bool __cdecl CSurfaceBrush::HasRenderingIntermediate(void)const __ptr64 */

+

+bool __thiscall CSurfaceBrush::HasRenderingIntermediate(CSurfaceBrush *this)

+

+{

+  char cVar1;

+  CResource *pCVar2;

+  bool bVar3;

+  

+  pCVar2 = GetSurface(this);

+  bVar3 = false;

+  if (pCVar2 != (CResource *)0x0) {

+    cVar1 = (**(code **)(*(longlong *)pCVar2 + 0x40))(pCVar2,0xba);

+    bVar3 = false;

+    if (cVar1 != '\0') {

+      bVar3 = true;

+    }

+  }

+  return bVar3;

+}

+
```

## `CBrush::IsEmptyDrawing`  (modified)

```diff
--- CBrush::IsEmptyDrawing
+++ CBrush::IsEmptyDrawing
@@ -1,2 +1,148 @@
-Failed to decompile dwmcore.dll - .ProgramDB CBrush::IsEmptyDrawing : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: virtual bool __cdecl CBrush::IsEmptyDrawing(void)const __ptr64 */

+

+bool __thiscall CBrush::IsEmptyDrawing(CBrush *this)

+

+{

+  CEffectBrush *this_00;

+  longlong *plVar1;

+  bool bVar2;

+  char cVar3;

+  char cVar4;

+  CResource *pCVar5;

+  code *pcVar6;

+  bool local_res8 [8];

+  IBitmapResource *local_res10;

+  char local_res18 [8];

+  

+  local_res8[0] = false;

+  pcVar6 = *(code **)(*(longlong *)this + 0x138);

+  if (pcVar6 == CSurfaceBrush::IsReadyToDraw) {

+    pcVar6 = *(code **)**(undefined8 **)(this + 0x88);

+    if (pcVar6 == CBitmapRenderStrategy::IsReadyToDraw) {

+      local_res10 = (IBitmapResource *)0x0;

+      wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::reset

+                ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res10);

+      CBitmapRenderStrategy::GetBitmap((CSurfaceBrush *)this,&local_res10);

+      cVar4 = CBitmapRenderStrategy::HasRenderingRealization(local_res10);

+      wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::

+      ~com_ptr_t<IBitmapResource,wil::err_returncode_policy>

+                ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res10);

+      goto LAB_0;

+    }

+    if (pcVar6 != CPrimitiveGroupRenderStrategy::IsReadyToDraw) {

+      if (pcVar6 == CVisualSurfaceRenderStrategy::IsReadyToDraw) {

+        pCVar5 = CSurfaceBrush::GetSurface((CSurfaceBrush *)this);

+        cVar4 = CVisualSurface::HasSomethingToDraw((CVisualSurface *)pCVar5);

+      }

+      else {

+        cVar4 = (*pcVar6)(*(undefined8 **)(this + 0x88),this,0,local_res8);

+      }

+      goto LAB_0;

+    }

+LAB_1:

+    pCVar5 = CSurfaceBrush::GetSurface((CSurfaceBrush *)this);

+    if (*(code **)(*(longlong *)pCVar5 + 0xd8) == CPrimitiveGroup::IsEmptyDrawing) {

+      local_res8[0] = CPrimitiveGroup::IsEmptyDrawing((CPrimitiveGroup *)pCVar5);

+    }

+    else {

+      local_res8[0] = (bool)(**(code **)(*(longlong *)pCVar5 + 0xd8))();

+    }

+    cVar4 = '\x01';

+    goto LAB_0;

+  }

+  if (pcVar6 != CMaskBrush::IsReadyToDraw) {

+    if (pcVar6 == CNineGridBrush::IsReadyToDraw) {

+      this = *(CBrush **)(this + 0x68);

+      if (this == (CBrush *)0x0) {

+        return true;

+      }

+      pcVar6 = *(code **)(*(longlong *)this + 0x138);

+      if (pcVar6 == CSurfaceBrush::IsReadyToDraw) {

+        pcVar6 = *(code **)**(undefined8 **)(this + 0x88);

+        if (pcVar6 == CBitmapRenderStrategy::IsReadyToDraw) {

+          local_res10 = (IBitmapResource *)0x0;

+          wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::reset

+                    ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res10);

+          CBitmapRenderStrategy::GetBitmap((CSurfaceBrush *)this,&local_res10);

+          cVar4 = CBitmapRenderStrategy::HasRenderingRealization(local_res10);

+          wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::

+          ~com_ptr_t<IBitmapResource,wil::err_returncode_policy>

+                    ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res10);

+          goto LAB_0;

+        }

+        if (pcVar6 != CPrimitiveGroupRenderStrategy::IsReadyToDraw) {

+          if (pcVar6 == CVisualSurfaceRenderStrategy::IsReadyToDraw) {

+            pCVar5 = CSurfaceBrush::GetSurface((CSurfaceBrush *)this);

+            cVar4 = CVisualSurface::HasSomethingToDraw((CVisualSurface *)pCVar5);

+          }

+          else {

+            cVar4 = (*pcVar6)(*(undefined8 **)(this + 0x88),this,0,local_res8);

+          }

+          goto LAB_0;

+        }

+        goto LAB_1;

+      }

+      if (pcVar6 == CColorBrush::IsReadyToDraw) {

+        cVar4 = CColorBrush::IsReadyToDraw((CColorBrush *)this,(CDrawingContext *)0x0,local_res8);

+        goto LAB_0;

+      }

+    }

+    cVar4 = (*pcVar6)(this,0,local_res8);

+    goto LAB_0;

+  }

+  this_00 = *(CEffectBrush **)(this + 0x78);

+  cVar4 = '\0';

+  local_res10 = (IBitmapResource *)((ulonglong)local_res10 & 0xffffffffffffff00);

+  local_res18[0] = '\0';

+  if (this_00 != (CEffectBrush *)0x0) {

+    pcVar6 = *(code **)(*(longlong *)this_00 + 0x138);

+    if (pcVar6 == CGradientBrush::IsReadyToDraw) {

+      bVar2 = std::vector<CColorGradientStop*___ptr64,std::allocator<CColorGradientStop*___ptr64>_>

+              ::empty((vector<CColorGradientStop*___ptr64,std::allocator<CColorGradientStop*___ptr64>_>

+                       *)(this_00 + 0xa8));

+      local_res10 = (IBitmapResource *)CONCAT71(local_res10._1_7_,bVar2);

+      bVar2 = std::vector<CColorGradientStop*___ptr64,std::allocator<CColorGradientStop*___ptr64>_>

+              ::empty((vector<CColorGradientStop*___ptr64,std::allocator<CColorGradientStop*___ptr64>_>

+                       *)(this_00 + 0xa8));

+      cVar3 = !bVar2;

+LAB_2:

+      if (cVar3 != '\0') {

+LAB_3:

+        plVar1 = *(longlong **)(this + 0x70);

+        if ((plVar1 == (longlong *)0x0) ||

+           (cVar3 = (**(code **)(*plVar1 + 0x138))(plVar1,0,local_res18), cVar3 != '\0')) {

+          cVar4 = '\x01';

+        }

+      }

+    }

+    else {

+      if (pcVar6 != CColorBrush::IsReadyToDraw) {

+        if (pcVar6 == CEffectBrush::IsReadyToDraw) {

+          cVar3 = CEffectBrush::IsReadyToDraw(this_00,(CDrawingContext *)0x0,(bool *)&local_res10);

+        }

+        else {

+          cVar3 = (*pcVar6)();

+        }

+        goto LAB_2;

+      }

+      bVar2 = IsCloseRealZero(*(float *)(this_00 + 0x74),1.1920929e-06);

+      local_res10 = (IBitmapResource *)CONCAT71(local_res10._1_7_,bVar2);

+      if (!NAN(*(float *)(this_00 + 0x74))) goto LAB_3;

+    }

+    if ((local_res10._0_1_ != (com_ptr_t<IBitmapResource,wil::err_returncode_policy>)0x0) ||

+       (local_res18[0] != '\0')) {

+      local_res8[0] = true;

+      goto LAB_0;

+    }

+  }

+  local_res8[0] = false;

+LAB_0:

+  if ((cVar4 != '\0') && (local_res8[0] == false)) {

+    return false;

+  }

+  return true;

+}

+
```

## `CD3DDevice::NotifyNoSequencePresent`  (modified)

```diff
--- CD3DDevice::NotifyNoSequencePresent
+++ CD3DDevice::NotifyNoSequencePresent
@@ -1,2 +1,30 @@
-Failed to decompile dwmcore.dll - .ProgramDB CD3DDevice::NotifyNoSequencePresent : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: void __cdecl CD3DDevice::NotifyNoSequencePresent(struct _LUID,unsigned int) __ptr64 */

+

+void __thiscall CD3DDevice::NotifyNoSequencePresent(CD3DDevice *this,_LUID param_1,uint param_2)

+

+{

+  longlong lVar1;

+  DWORD *pDVar2;

+  longlong lVar3;

+  

+  lVar3 = *(longlong *)(this + 0x4c0);

+  lVar1 = *(longlong *)(this + 0x4c8);

+  do {

+    if (lVar3 == lVar1) {

+      return;

+    }

+    for (pDVar2 = *(DWORD **)(lVar3 + 8); pDVar2 != *(DWORD **)(lVar3 + 0x10); pDVar2 = pDVar2 + 4)

+    {

+      if (((*pDVar2 == param_1.LowPart) && (pDVar2[1] == param_1.HighPart)) &&

+         (pDVar2[2] == param_2)) {

+        if (pDVar2[3] != 0xffffffff) {

+          pDVar2[3] = pDVar2[3] + 1;

+        }

+        break;

+      }

+    }

+    lVar3 = lVar3 + 0x40;

+  } while( true );

+}

+
```

## `CPrimitiveGroupRenderStrategy::IsReadyToDraw`  (modified)

```diff
--- CPrimitiveGroupRenderStrategy::IsReadyToDraw
+++ CPrimitiveGroupRenderStrategy::IsReadyToDraw
@@ -1,2 +1,26 @@
-Failed to decompile dwmcore.dll - .ProgramDB CPrimitiveGroupRenderStrategy::IsReadyToDraw : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: virtual bool __cdecl CPrimitiveGroupRenderStrategy::IsReadyToDraw(class CSurfaceBrush

+   const * __ptr64,class CDrawingContext * __ptr64,bool * __ptr64)const __ptr64 */

+

+bool __thiscall

+CPrimitiveGroupRenderStrategy::IsReadyToDraw

+          (CPrimitiveGroupRenderStrategy *this,CSurfaceBrush *param_1,CDrawingContext *param_2,

+          bool *param_3)

+

+{

+  undefined1 uVar1;

+  CResource *this_00;

+  

+  this_00 = CSurfaceBrush::GetSurface(param_1);

+  if (*(code **)(*(longlong *)this_00 + 0xd8) == CPrimitiveGroup::IsEmptyDrawing) {

+    uVar1 = CPrimitiveGroup::IsEmptyDrawing((CPrimitiveGroup *)this_00);

+  }

+  else {

+    uVar1 = (**(code **)(*(longlong *)this_00 + 0xd8))();

+  }

+  *param_3 = (bool)uVar1;

+  return true;

+}

+
```

## `std::_Hash<std::_Umap_traits<unsigned_int,CFlipAwayFence,std::_Uhash_compare<unsigned_int,std::hash<unsigned_int>,std::equal_to<unsigned_int>_>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>,0>_>::emplace<std::piecewise_construct_t_const&___ptr64,std::tuple<unsigned_int&___ptr64>,std::tuple<wil::com_ptr_t<ID3D11Fence,wil::err_returncode_policy>&&___ptr64,wil::unique_any_t<wil::details::unique_storage<wil::details::handle_null_resource_policy<int_(__cdecl*)(void*___ptr64),&int___cdecl_CloseHandle(void*___ptr64)>_>_>&&___ptr64>_>`  (modified)

```diff
--- std::_Hash<std::_Umap_traits<unsigned_int,CFlipAwayFence,std::_Uhash_compare<unsigned_int,std::hash<unsigned_int>,std::equal_to<unsigned_int>_>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>,0>_>::emplace<std::piecewise_construct_t_const&___ptr64,std::tuple<unsigned_int&___ptr64>,std::tuple<wil::com_ptr_t<ID3D11Fence,wil::err_returncode_policy>&&___ptr64,wil::unique_any_t<wil::details::unique_storage<wil::details::handle_null_resource_policy<int_(__cdecl*)(void*___ptr64),&int___cdecl_CloseHandle(void*___ptr64)>_>_>&&___ptr64>_>
+++ std::_Hash<std::_Umap_traits<unsigned_int,CFlipAwayFence,std::_Uhash_compare<unsigned_int,std::hash<unsigned_int>,std::equal_to<unsigned_int>_>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>,0>_>::emplace<std::piecewise_construct_t_const&___ptr64,std::tuple<unsigned_int&___ptr64>,std::tuple<wil::com_ptr_t<ID3D11Fence,wil::err_returncode_policy>&&___ptr64,wil::unique_any_t<wil::details::unique_storage<wil::details::handle_null_resource_policy<int_(__cdecl*)(void*___ptr64),&int___cdecl_CloseHandle(void*___ptr64)>_>_>&&___ptr64>_>
@@ -1,2 +1,127 @@
-Failed to decompile dwmcore.dll - .ProgramDB std::_Hash<std::_Umap_traits<unsigned_int,CFlipAwayFence,std::_Uhash_compare<unsigned_int,std::hash<unsigned_int>,std::equal_to<unsigned_int>_>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>,0>_>::emplace<std::piecewise_construct_t_const&___ptr64,std::tuple<unsigned_int&___ptr64>,std::tuple<wil::com_ptr_t<ID3D11Fence,wil::err_returncode_policy>&&___ptr64,wil::unique_any_t<wil::details::unique_storage<wil::details::handle_null_resource_policy<int_(__cdecl*)(void*___ptr64),&int___cdecl_CloseHandle(void*___ptr64)>_>_>&&___ptr64>_> : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: struct std::pair<class std::_List_iterator<class std::_List_val<struct

+   std::_List_simple_types<struct std::pair<unsigned int const ,class CFlipAwayFence> > > >,bool>

+   __cdecl std::_Hash<class std::_Umap_traits<unsigned int,class CFlipAwayFence,class

+   std::_Uhash_compare<unsigned int,struct std::hash<unsigned int>,struct std::equal_to<unsigned

+   int> >,class std::allocator<struct std::pair<unsigned int const ,class CFlipAwayFence> >,0>

+   >::emplace<struct std::piecewise_construct_t const & __ptr64,class std::tuple<unsigned int &

+   __ptr64>,class std::tuple<class wil::com_ptr_t<struct ID3D11Fence,struct

+   wil::err_returncode_policy> && __ptr64,class wil::unique_any_t<class

+   wil::details::unique_storage<struct wil::details::handle_null_resource_policy<int (__cdecl*)(void

+   * __ptr64),&int __cdecl CloseHandle(void * __ptr64)> > > && __ptr64> >(struct

+   std::piecewise_construct_t const & __ptr64,class std::tuple<unsigned int & __ptr64> &&

+   __ptr64,class std::tuple<class wil::com_ptr_t<struct ID3D11Fence,struct

+   wil::err_returncode_policy> && __ptr64,class wil::unique_any_t<class

+   wil::details::unique_storage<struct wil::details::handle_null_resource_policy<int (__cdecl*)(void

+   * __ptr64),&int __cdecl CloseHandle(void * __ptr64)> > > && __ptr64> && __ptr64) __ptr64 */

+

+piecewise_construct_t * __thiscall

+std::

+_Hash<std::_Umap_traits<unsigned_int,CFlipAwayFence,std::_Uhash_compare<unsigned_int,std::hash<unsigned_int>,std::equal_to<unsigned_int>_>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>,0>_>

+::

+emplace<std::piecewise_construct_t_const&___ptr64,std::tuple<unsigned_int&___ptr64>,std::tuple<wil::com_ptr_t<ID3D11Fence,wil::err_returncode_policy>&&___ptr64,wil::unique_any_t<wil::details::unique_storage<wil::details::handle_null_resource_policy<int_(__cdecl*)(void*___ptr64),&int___cdecl_CloseHandle(void*___ptr64)>_>_>&&___ptr64>_>

+          (_Hash<std::_Umap_traits<unsigned_int,CFlipAwayFence,std::_Uhash_compare<unsigned_int,std::hash<unsigned_int>,std::equal_to<unsigned_int>_>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>,0>_>

+           *this,piecewise_construct_t *param_1,tuple<unsigned_int&___ptr64> *param_2,

+          tuple<wil::com_ptr_t<ID3D11Fence,wil::err_returncode_policy>&&___ptr64,wil::unique_any_t<wil::details::unique_storage<wil::details::handle_null_resource_policy<int_(__cdecl*)(void*___ptr64),&int___cdecl_CloseHandle(void*___ptr64)>_>_>&&___ptr64>

+          *param_3)

+

+{

+  uint *puVar1;

+  uint uVar2;

+  longlong *plVar3;

+  longlong lVar4;

+  undefined8 *puVar5;

+  longlong lVar6;

+  code *pcVar7;

+  __uint64 _Var8;

+  longlong *plVar9;

+  piecewise_construct_t *ppVar10;

+  longlong *plVar11;

+  ulonglong uVar12;

+  __uint64 _Var13;

+  float fVar14;

+  undefined8 *in_stack_00000028;

+  _Hash<std::_Umap_traits<unsigned_int,CFlipAwayFence,std::_Uhash_compare<unsigned_int,std::hash<unsigned_int>,std::equal_to<unsigned_int>_>,std::allocator<std::pair<unsigned_int_const_,CFlipAwayFence>_>,0>_>

+  *local_38;

+  longlong *local_30;

+  longlong local_28;

+  longlong lStack_20;

+  

+  local_38 = this + 8;

+  _Var8 = _Get_size_of_n<48>(1);

+  plVar9 = _Allocate<16,std::_Default_allocate_traits,0>(_Var8);

+  puVar1 = (uint *)(plVar9 + 2);

+  plVar11 = (longlong *)in_stack_00000028[1];

+  plVar3 = (longlong *)*in_stack_00000028;

+  uVar2 = **(uint **)param_3;

+  CFlipAwayFence::s_nextUniqueId = CFlipAwayFence::s_nextUniqueId + 1;

+  *puVar1 = uVar2;

+  plVar9[3] = CFlipAwayFence::s_nextUniqueId;

+  lVar4 = *plVar11;

+  *plVar11 = 0;

+  plVar9[4] = lVar4;

+  plVar9[5] = *plVar3;

+  *plVar3 = 0;

+  local_30 = plVar9;

+  _Var8 = _Uhash_compare<unsigned_int,std::hash<unsigned_int>,std::equal_to<unsigned_int>_>::

+          operator()<unsigned_int>

+                    ((_Uhash_compare<unsigned_int,std::hash<unsigned_int>,std::equal_to<unsigned_int>_>

+                      *)(ulonglong)uVar2,puVar1);

+  _Hash<std::_Umap_traits<unsigned_int,CDDisplayFlipAwayFence,std::_Uhash_compare<unsigned_int,std::hash<unsigned_int>,std::equal_to<unsigned_int>_>,std::allocator<std::pair<unsigned_int_const_,CDDisplayFlipAwayFence>_>,0>_>

+  ::_Find_last<unsigned_int>

+            ((_Hash<std::_Umap_traits<unsigned_int,CDDisplayFlipAwayFence,std::_Uhash_compare<unsigned_int,std::hash<unsigned_int>,std::equal_to<unsigned_int>_>,std::allocator<std::pair<unsigned_int_const_,CDDisplayFlipAwayFence>_>,0>_>

+              *)this,(uint *)&local_28,(__uint64)puVar1);

+  if (lStack_20 != 0) {

+    *(longlong *)param_1 = lStack_20;

+    param_1[8] = (piecewise_construct_t)0x0;

+    goto LAB_0;

+  }

+  if (*(longlong *)(this + 0x10) == 0x555555555555555) {

+    std::_Xlength_error("unordered_map/set too long");

+    pcVar7 = (code *)swi(3);

+    ppVar10 = (piecewise_construct_t *)(*pcVar7)();

+    return ppVar10;

+  }

+  _Var13 = *(longlong *)(this + 0x10) + 1;

+  fVar14 = (float)_Var13 / (float)*(ulonglong *)(this + 0x38);

+  if (*(float *)this <= fVar14 && fVar14 != *(float *)this) {

+    _Var13 = _Desired_grow_bucket_count(this,_Var13);

+    _Forced_rehash(this,_Var13);

+    plVar11 = (longlong *)

+              _Hash<std::_Umap_traits<unsigned_int,CDDisplayFlipAwayFence,std::_Uhash_compare<unsigned_int,std::hash<unsigned_int>,std::equal_to<unsigned_int>_>,std::allocator<std::pair<unsigned_int_const_,CDDisplayFlipAwayFence>_>,0>_>

+              ::_Find_last<unsigned_int>

+                        ((_Hash<std::_Umap_traits<unsigned_int,CDDisplayFlipAwayFence,std::_Uhash_compare<unsigned_int,std::hash<unsigned_int>,std::equal_to<unsigned_int>_>,std::allocator<std::pair<unsigned_int_const_,CDDisplayFlipAwayFence>_>,0>_>

+                          *)this,(uint *)&local_28,(__uint64)puVar1);

+    local_28 = *plVar11;

+    lStack_20 = plVar11[1];

+  }

+  local_30 = (longlong *)0x0;

+  puVar5 = *(undefined8 **)(local_28 + 8);

+  *(longlong *)(this + 0x10) = *(longlong *)(this + 0x10) + 1;

+  *plVar9 = local_28;

+  plVar9[1] = (longlong)puVar5;

+  *puVar5 = plVar9;

+  *(longlong **)(local_28 + 8) = plVar9;

+  lVar4 = *(longlong *)(this + 0x18);

+  uVar12 = *(ulonglong *)(this + 0x30) & _Var8;

+  lVar6 = *(longlong *)(lVar4 + uVar12 * 0x10);

+  if (lVar6 == *(longlong *)(this + 8)) {

+    *(longlong **)(lVar4 + uVar12 * 0x10) = plVar9;

+LAB_1:

+    *(longlong **)(lVar4 + 8 + uVar12 * 0x10) = plVar9;

+  }

+  else if (lVar6 == local_28) {

+    *(longlong **)(lVar4 + uVar12 * 0x10) = plVar9;

+  }

+  else if (*(undefined8 **)(lVar4 + 8 + uVar12 * 0x10) == puVar5) goto LAB_1;

+  *(longlong **)param_1 = plVar9;

+  param_1[8] = (piecewise_construct_t)0x1;

+LAB_0:

+  _List_node_emplace_op2<std::allocator<std::_List_node<std::pair<unsigned_int_const_,CFlipAwayFence>,void*___ptr64>_>_>

+  ::

+  ~_List_node_emplace_op2<std::allocator<std::_List_node<std::pair<unsigned_int_const_,CFlipAwayFence>,void*___ptr64>_>_>

+            ((_List_node_emplace_op2<std::allocator<std::_List_node<std::pair<unsigned_int_const_,CFlipAwayFence>,void*___ptr64>_>_>

+              *)&local_38);

+  return param_1;

+}

+
```

## `COverlayContext::COverlayContext`  (modified)

```diff
--- COverlayContext::COverlayContext
+++ COverlayContext::COverlayContext
@@ -1,2 +1,72 @@
-Failed to decompile dwmcore.dll - .ProgramDB COverlayContext::COverlayContext : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: __cdecl COverlayContext::COverlayContext(class IOverlayMonitorTarget * __ptr64,bool)

+   __ptr64 */

+

+COverlayContext * __thiscall

+COverlayContext::COverlayContext(COverlayContext *this,IOverlayMonitorTarget *param_1,bool param_2)

+

+{

+  *(IOverlayMonitorTarget **)this = param_1;

+  *(undefined4 *)(this + 8) = 0;

+  *(undefined8 *)(this + 0x28) = 0;

+  *(undefined8 *)(this + 0x30) = 0;

+  *(undefined8 *)(this + 0x38) = 0;

+  *(undefined8 *)(this + 0x40) = 0;

+  *(undefined8 *)(this + 0x48) = 0;

+  *(undefined4 *)(this + 0x50) = 0;

+  *(COverlayContext **)(this + 0x58) = this + 0x70;

+  *(COverlayContext **)(this + 0x60) = this + 0x70;

+  *(COverlayContext **)(this + 0x68) = this + 0x18f0;

+  *(COverlayContext **)(this + 0x18f0) = this + 0x1908;

+  *(COverlayContext **)(this + 0x18f8) = this + 0x1908;

+  *(COverlayContext **)(this + 0x1900) = this + 0x3188;

+  *(undefined8 *)(this + 0x4b6c) = 0;

+  *(undefined8 *)(this + 0x4b74) = 0;

+  *(undefined8 *)(this + 0x4b7c) = 0;

+  *(undefined8 *)(this + 0x4b84) = 0;

+  *(undefined8 *)(this + 0x4b8c) = 0;

+  *(undefined8 *)(this + 0x4b94) = 0;

+  *(undefined8 *)(this + 0x4b9c) = 0;

+  *(undefined8 *)(this + 0x4ba4) = 0;

+  *(undefined4 *)(this + 0x4bac) = 0;

+  *(COverlayContext **)(this + 0x3188) = this + 0x31a0;

+  *(COverlayContext **)(this + 0x3190) = this + 0x31a0;

+  *(COverlayContext **)(this + 0x3198) = this + 0x4a20;

+  *(undefined8 *)(this + 0x4bb8) = 0;

+  *(undefined8 *)(this + 0x4bc0) = 0;

+  *(undefined8 *)(this + 0x4bd0) = 0;

+  *(undefined8 *)(this + 0x4be8) = 0;

+  *(undefined8 *)(this + 0x4bf0) = 0;

+  *(undefined8 *)(this + 0x4b18) = 0;

+  *(undefined8 *)(this + 0x4bc8) = 0;

+  *(undefined8 *)(this + 0x4bd8) = 0;

+  *(undefined8 *)(this + 0x4be0) = 0;

+  *(undefined8 *)(this + 0x4b10) = 0;

+  *(undefined8 *)(this + 0x4bf8) = 0;

+  *(undefined8 *)(this + 0x4c00) = 0;

+  *(undefined8 *)(this + 0x4c08) = 0;

+  *(undefined8 *)(this + 0x4c10) = 0;

+  *(undefined8 *)(this + 0x4c18) = 0;

+  *(undefined4 *)(this + 0x4c20) = 0x1000000;

+  *(undefined2 *)(this + 0x4c24) = 0;

+  *(undefined4 *)(this + 0x7638) = 0xffffffff;

+  *(undefined8 *)(this + 0x4c28) = 0;

+  *(undefined4 *)(this + 0x4c30) = 0;

+  *(undefined8 *)(this + 0x4c38) = 0;

+  *(undefined8 *)(this + 0x4c40) = 0;

+  *(undefined8 *)(this + 0x4c48) = 0;

+  *(undefined8 *)(this + 0x4c50) = 0;

+  *(undefined8 *)(this + 0x4c58) = 0;

+  *(undefined8 *)(this + 0x4c60) = 0;

+  *(undefined2 *)(this + 0x4c68) = 0;

+  *(undefined2 *)(this + 0x4c6b) = 0;

+  *(undefined4 *)(this + 0x4c6e) = 0x100;

+  this[0x4c7b] = (COverlayContext)param_2;

+  *(undefined8 *)(this + 0x4c7c) = 0;

+  *(undefined4 *)(this + 0x4c84) = 0;

+  this[0x4c88] = (COverlayContext)0x0;

+  *(undefined8 *)(this + 0x4c8c) = 0;

+  *(undefined4 *)(this + 0x4c94) = 0;

+  return this;

+}

+
```

## `CCachedVisualImage::CCachedVisualImage`  (modified)

```diff
--- CCachedVisualImage::CCachedVisualImage
+++ CCachedVisualImage::CCachedVisualImage
@@ -1,2 +1,33 @@
-Failed to decompile dwmcore.dll - .ProgramDB CCachedVisualImage::CCachedVisualImage : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* protected: __cdecl CCachedVisualImage::CCachedVisualImage(class CComposition * __ptr64,bool)

+   __ptr64 */

+

+CCachedVisualImage * __thiscall

+CCachedVisualImage::CCachedVisualImage(CCachedVisualImage *this,CComposition *param_1,bool param_2)

+

+{

+  undefined4 uVar1;

+  

+  uVar1 = 0;

+  *(undefined4 *)(this + 8) = 0;

+  *(undefined8 *)(this + 0x10) = 0;

+  *(CComposition **)(this + 0x18) = param_1;

+  *(undefined8 *)(this + 0x20) = 0;

+  *(undefined8 *)(this + 0x30) = 0;

+  *(undefined4 *)(this + 0x28) = 0;

+  *(undefined ***)this = &_vftable__for__CResource__;

+  *(undefined ***)(this + 0x48) = &_vftable__for__IBitmapResource__;

+  *(undefined ***)(this + 0x50) = &_vftable__for__IBitmapRealization__;

+  *(undefined ***)(this + 0x58) = &_vftable__for__IDeviceResourceNotify__;

+  *(undefined8 *)(this + 0xb0) = 0;

+  *(undefined8 *)(this + 0xb8) = 0;

+  *(undefined8 *)(this + 0xc0) = 0;

+  *(undefined8 *)(this + 200) = 0;

+  COcclusionContext::COcclusionContext((COcclusionContext *)(this + 0xd0));

+  *(undefined8 *)(this + 0x7d8) = 0;

+  *(undefined4 *)(this + 0x7e0) = uVar1;

+  this[0x7e4] = (CCachedVisualImage)param_2;

+  *(undefined4 *)(this + 0xa8) = 2;

+  return this;

+}

+
```

## `CSceneResourceManager::GetSpectreTexture`  (modified)

```diff
--- CSceneResourceManager::GetSpectreTexture
+++ CSceneResourceManager::GetSpectreTexture
@@ -1,2 +1,158 @@
-Failed to decompile dwmcore.dll - .ProgramDB CSceneResourceManager::GetSpectreTexture : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: long __cdecl CSceneResourceManager::GetSpectreTexture(class CResource * __ptr64,struct

+   ISpectreTexture * __ptr64 * __ptr64) __ptr64 */

+

+long __thiscall

+CSceneResourceManager::GetSpectreTexture

+          (CSceneResourceManager *this,CResource *param_1,ISpectreTexture **param_2)

+

+{

+  uint uVar1;

+  code *pcVar2;

+  char cVar3;

+  long lVar4;

+  undefined4 *puVar5;

+  ISpectreRenderer *pIVar6;

+  undefined8 uVar7;

+  undefined8 uVar8;

+  __uint64 _Var9;

+  undefined8 *puVar10;

+  CResource *this_00;

+  longlong *plVar11;

+  _Tree<std::_Tmap_traits<unsigned___int64,CCursorState*___ptr64,std::less<unsigned___int64>,std::allocator<std::pair<unsigned___int64_const_,CCursorState*___ptr64>_>,0>_>

+  *this_01;

+  CCachedVisualImage *local_res20;

+  longlong *local_78;

+  ISpectreTexture *local_70;

+  undefined8 local_68;

+  undefined8 uStack_60;

+  undefined4 local_58;

+  undefined4 uStack_54;

+  undefined4 uStack_50;

+  undefined4 uStack_4c;

+  undefined8 local_48;

+  undefined4 local_40;

+  undefined4 uStack_3c;

+  _Tree_node<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>,void*___ptr64> *local_30;

+  

+  lVar4 = 0;

+  cVar3 = (**(code **)(*(longlong *)param_1 + 0x40))(param_1);

+  if (cVar3 == '\0') {

+    cVar3 = (**(code **)(*(longlong *)param_1 + 0x40))(param_1,0x25);

+    if (cVar3 != '\0') {

+      lVar4 = 0;

+      *param_2 = *(ISpectreTexture **)(param_1 + 0x98);

+    }

+  }

+  else {

+    local_res20 = (CCachedVisualImage *)0x0;

+    uVar1 = *(uint *)(*(longlong *)(this + 0x20) + 0x3c0);

+    local_68 = *(_Tree<std::_Tmap_traits<unsigned___int64,CCursorState*___ptr64,std::less<unsigned___int64>,std::allocator<std::pair<unsigned___int64_const_,CCursorState*___ptr64>_>,0>_>

+                 **)(param_1 + (ulonglong)(-(uint)(param_1[0xcc] != (CResource)0x0) & 8) + 0xb8);

+    wil::com_ptr_t<IMessageConversation,wil::err_returncode_policy>::reset

+              ((com_ptr_t<IMessageConversation,wil::err_returncode_policy> *)&local_res20);

+    this_00 = param_1;

+    lVar4 = CVisualSurface::GetCVIForRealizationSize

+                      ((CVisualSurface *)param_1,uVar1,(D2D_VECTOR_2F *)&local_68,

+                       (D2D_VECTOR_2F *)&local_68,&local_res20);

+    if (lVar4 < 0) {

+      MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar4,0xfa,(void *)0x0);

+    }

+    else {

+      CDisplayManager::GetPrimaryAdapterLuid((CDisplayManager *)this_00);

+      uStack_50 = 0xffffffff;

+      uStack_4c = 0;

+      local_48 = 0;

+      if (**(longlong **)(g_pComposition + 0x290) != 0) {

+        plVar11 = (longlong *)(**(longlong **)(g_pComposition + 0x290) + 8);

+        puVar5 = (undefined4 *)(**(code **)(*plVar11 + 0x18))(plVar11,&local_40);

+        local_58 = *puVar5;

+        uStack_54 = puVar5[1];

+        uStack_50 = puVar5[2];

+        uStack_4c = puVar5[3];

+        local_48 = *(undefined8 *)(puVar5 + 4);

+      }

+      local_78 = (longlong *)0x0;

+      lVar4 = (**(code **)(*(longlong *)(local_res20 + 0x50) + 0x68))();

+      if (lVar4 < 0) {

+        MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar4,0x108,(void *)0x0);

+      }

+      else {

+        pIVar6 = GetSpectreRenderer(this);

+        local_70 = (ISpectreTexture *)0x0;

+        pcVar2 = *(code **)(*(longlong *)pIVar6 + 0x58);

+        uVar7 = (**(code **)(*local_78 + 0x80))();

+        uVar8 = (**(code **)(*local_78 + 0x78))();

+        lVar4 = (*pcVar2)(pIVar6,uVar8,uVar7,&local_70);

+        if (lVar4 < 0) {

+          MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar4,0x10f,(void *)0x0);

+        }

+        else {

+          this_01 = (_Tree<std::_Tmap_traits<unsigned___int64,CCursorState*___ptr64,std::less<unsigned___int64>,std::allocator<std::pair<unsigned___int64_const_,CCursorState*___ptr64>_>,0>_>

+                     *)(this + 0x40);

+          std::

+          _Tree<std::_Tmap_traits<unsigned___int64,CCursorState*___ptr64,std::less<unsigned___int64>,std::allocator<std::pair<unsigned___int64_const_,CCursorState*___ptr64>_>,0>_>

+          ::_Find_lower_bound<unsigned___int64>(this_01,(__uint64 *)&local_40);

+          if ((local_30[0x19] !=

+               (_Tree_node<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>,void*___ptr64>

+                )0x0) || (param_1 < *(CResource **)(local_30 + 0x20))) {

+            if (*(longlong *)(this + 0x48) == 0x555555555555555) {

+                    /* WARNING: Subroutine does not return */

+              std::_Throw_tree_length_error();

+            }

+            uVar7 = *(undefined8 *)this_01;

+            local_68 = this_01;

+            _Var9 = std::_Get_size_of_n<48>(1);

+            puVar10 = std::_Allocate<16,std::_Default_allocate_traits,0>(_Var9);

+            uStack_60 = 0;

+            puVar10[4] = param_1;

+            puVar10[5] = 0;

+            *puVar10 = uVar7;

+            puVar10[1] = uVar7;

+            puVar10[2] = uVar7;

+            *(undefined2 *)(puVar10 + 3) = 0;

+            std::

+            _Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_>

+            ::

+            ~_Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_>

+                      ((_Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_>

+                        *)&local_68);

+            local_68 = (_Tree<std::_Tmap_traits<unsigned___int64,CCursorState*___ptr64,std::less<unsigned___int64>,std::allocator<std::pair<unsigned___int64_const_,CCursorState*___ptr64>_>,0>_>

+                        *)CONCAT44(uStack_3c,local_40);

+            local_30 = std::

+                       _Tree_val<std::_Tree_simple_types<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>_>_>

+                       ::_Insert_node((_Tree_val<std::_Tree_simple_types<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>_>_>

+                                       *)this_01,&local_68,puVar10);

+          }

+          wil::com_ptr_t<CSystemMemoryBitmap,wil::err_returncode_policy>::operator=

+                    ((com_ptr_t<CSystemMemoryBitmap,wil::err_returncode_policy> *)(local_30 + 0x28),

+                     (com_ptr_t<class_CSystemMemoryBitmap,struct_wil::err_returncode_policy> *)

+                     &local_70);

+          *param_2 = local_70;

+        }

+        wil::

+        com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+        ::

+        ~com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+                  ((com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+                    *)&local_70);

+      }

+      wil::

+      com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+      ::

+      ~com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+                ((com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+                  *)&local_78);

+    }

+    wil::

+    com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+    ::

+    ~com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+              ((com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+                *)&local_res20);

+  }

+  return lVar4;

+}

+
```

## `std::_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData,CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>_>,0>_>::_Emplace_hint<D2D_VECTOR_2F_const&___ptr64,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData&___ptr64>`  (modified)

```diff
--- std::_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData,CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>_>,0>_>::_Emplace_hint<D2D_VECTOR_2F_const&___ptr64,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData&___ptr64>
+++ std::_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData,CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>_>,0>_>::_Emplace_hint<D2D_VECTOR_2F_const&___ptr64,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData&___ptr64>
@@ -1,2 +1,67 @@
-Failed to decompile dwmcore.dll - .ProgramDB std::_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData,CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>_>,0>_>::_Emplace_hint<D2D_VECTOR_2F_const&___ptr64,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData&___ptr64> : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* protected: struct std::_Tree_node<struct std::pair<struct D2D_VECTOR_2F const ,struct

+   CConvexPolygonEdgeMap<struct CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void * __ptr64> *

+   __ptr64 __cdecl std::_Tree<class std::_Tmap_traits<struct D2D_VECTOR_2F const ,struct

+   CConvexPolygonEdgeMap<struct CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData,struct

+   CConvexPolygonEdgeMap<struct CCpuClipAntialiasSink::SinkRoutingInfo>::CompareEdgeDirection,class

+   std::allocator<struct std::pair<struct D2D_VECTOR_2F const ,struct CConvexPolygonEdgeMap<struct

+   CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData> >,0> >::_Emplace_hint<struct D2D_VECTOR_2F

+   const & __ptr64,struct CConvexPolygonEdgeMap<struct

+   CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData & __ptr64>(struct std::_Tree_node<struct

+   std::pair<struct D2D_VECTOR_2F const ,struct CConvexPolygonEdgeMap<struct

+   CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void * __ptr64> * __ptr64 const,struct

+   D2D_VECTOR_2F const & __ptr64,struct CConvexPolygonEdgeMap<struct

+   CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData & __ptr64) __ptr64 */

+

+_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+* __thiscall

+std::

+_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData,CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>_>,0>_>

+::

+_Emplace_hint<D2D_VECTOR_2F_const&___ptr64,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData&___ptr64>

+          (_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData,CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>_>,0>_>

+           *this,_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+                 *param_1,D2D_VECTOR_2F *param_2,EdgeData *param_3)

+

+{

+  undefined8 uVar1;

+  undefined8 *puVar2;

+  undefined8 *puVar3;

+  _Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+  *p_Var4;

+  _Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+  *local_48;

+  undefined8 uStack_40;

+  undefined8 local_38;

+  

+  uVar1 = *(undefined8 *)this;

+  puVar2 = _Allocate<16,std::_Default_allocate_traits,0>(0x30);

+  *(undefined8 *)((longlong)puVar2 + 0x1c) = *(undefined8 *)param_2;

+  *(undefined8 *)((longlong)puVar2 + 0x24) = *(undefined8 *)param_3;

+  *(undefined4 *)((longlong)puVar2 + 0x2c) = *(undefined4 *)(param_3 + 8);

+  *puVar2 = uVar1;

+  puVar2[1] = uVar1;

+  puVar2[2] = uVar1;

+  *(undefined2 *)(puVar2 + 3) = 0;

+  puVar3 = (undefined8 *)

+           _Find_hint<D2D_VECTOR_2F>

+                     (this,(_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+                            *)&local_48,(D2D_VECTOR_2F *)param_1);

+  local_38 = puVar3[2];

+  p_Var4 = (_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+            *)*puVar3;

+  uVar1 = puVar3[1];

+  if ((char)local_38 == '\0') {

+    _Check_grow_by_1(this);

+    local_48 = p_Var4;

+    uStack_40 = uVar1;

+    p_Var4 = _Tree_val<std::_Tree_simple_types<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>_>_>

+             ::_Insert_node((_Tree_val<std::_Tree_simple_types<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>_>_>

+                             *)this,&local_48,puVar2);

+  }

+  else if (puVar2 != (undefined8 *)0x0) {

+    _Deallocate<16,0>(puVar2,0x30);

+  }

+  return p_Var4;

+}

+
```

## `CBitmapRenderStrategy::IsReadyToDraw`  (modified)

```diff
--- CBitmapRenderStrategy::IsReadyToDraw
+++ CBitmapRenderStrategy::IsReadyToDraw
@@ -1,2 +1,149 @@
-Failed to decompile dwmcore.dll - .ProgramDB CBitmapRenderStrategy::IsReadyToDraw : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: virtual bool __cdecl CBitmapRenderStrategy::IsReadyToDraw(class CSurfaceBrush const *

+   __ptr64,class CDrawingContext * __ptr64,bool * __ptr64)const __ptr64 */

+

+bool __thiscall

+CBitmapRenderStrategy::IsReadyToDraw

+          (CBitmapRenderStrategy *this,CSurfaceBrush *param_1,CDrawingContext *param_2,bool *param_3

+          )

+

+{

+  CGlobalCompositionSurfaceInfo *this_00;

+  code *pcVar1;

+  longlong lVar2;

+  bool bVar3;

+  bool bVar4;

+  ulong uVar5;

+  CResource *pCVar6;

+  longlong *plVar7;

+  void *unaff_retaddr;

+  CResource *local_res20;

+  uint uVar8;

+  longlong local_18;

+  longlong *local_10;

+  

+  *param_3 = false;

+  local_res20 = (CResource *)0x0;

+  pCVar6 = CSurfaceBrush::GetSurface(param_1);

+  if ((code *)**(undefined8 **)pCVar6 ==

+      CMILCOMBaseWeakRefSource<CResourceDeleter>::InternalQueryInterface) {

+    bVar3 = operator==((_GUID *)&_GUID_b35f2031_4b76_4d4e_b98c_6771dfcc753c,

+                       (_GUID *)&_GUID_73f2a332_aba0_4b29_88bc_6ee79b3941bc);

+    if (bVar3) {

+      local_res20 = pCVar6;

+      CMILRefCountImpl::AddReference((CMILRefCountImpl *)(pCVar6 + 8));

+    }

+    else {

+      CMILCOMBaseT<IUnknownWeakRefSource,IUnknownWeakRefSource,CResourceDeleter>::

+      InternalQueryInterface

+                ((CMILCOMBaseT<IUnknownWeakRefSource,IUnknownWeakRefSource,CResourceDeleter> *)

+                 pCVar6,(_GUID *)&_GUID_b35f2031_4b76_4d4e_b98c_6771dfcc753c,&local_res20);

+    }

+  }

+  else {

+    (*(code *)**(undefined8 **)pCVar6)(pCVar6);

+  }

+  pCVar6 = local_res20;

+  local_10 = (longlong *)0x0;

+  if (*(code **)(*(longlong *)local_res20 + 0x40) ==

+      CCompositionSurfaceBitmap::GetCurrentRenderingRealization) {

+    bVar3 = wil::operator!=<CWeakReference<CVisual>,wil::err_returncode_policy>(local_res20 + 0x18);

+    if (bVar3) {

+      this_00 = *(CGlobalCompositionSurfaceInfo **)(pCVar6 + 0x18);

+      if (*(code **)(*(longlong *)this_00 + 0x30) ==

+          CGlobalCompositionSurfaceInfo::GetRenderingRealization) {

+        if (*(longlong *)(this_00 + 0xd0) == 0) {

+          CGlobalCompositionSurfaceInfo::ForceUpdateRenderingRealization(this_00);

+        }

+        local_10 = (longlong *)(*(longlong *)(this_00 + 0xd0) + 8);

+        if (*(longlong *)(this_00 + 0xd0) == 0) {

+          local_10 = (longlong *)0x0;

+        }

+      }

+      else {

+        local_10 = (longlong *)(**(code **)(*(longlong *)this_00 + 0x30))(this_00);

+      }

+      if (local_10 != (longlong *)0x0) {

+        if (*(code **)(*local_10 + 8) == CMILRefCountImpl::AddReference) {

+          LOCK();

+          lVar2 = *local_10;

+          *(int *)local_10 = (int)*local_10 + 1;

+          UNLOCK();

+          plVar7 = (longlong *)0x0;

+          if ((int)*local_10 == 0 || SCARRY4((int)lVar2,1) != (int)*local_10 < 0) {

+            wil::details::in1diag3::Log_Hr

+                      (unaff_retaddr,0x18,

+                       "onecoreuap\\windows\\dwm\\common\\shared\\refcountbase.cpp",-0x7ff8fd64);

+            plVar7 = (longlong *)0x0;

+          }

+        }

+        else {

+          (**(code **)(*local_10 + 8))(local_10);

+          plVar7 = (longlong *)0x0;

+        }

+        goto LAB_0;

+      }

+      plVar7 = (longlong *)0x8898008b;

+      uVar8 = 0xc0;

+    }

+    else {

+      plVar7 = (longlong *)0x88982f04;

+      uVar8 = 0xc5;

+    }

+    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,(long)plVar7,uVar8,(void *)0x0);

+  }

+  else {

+    uVar8 = (**(code **)(*(longlong *)local_res20 + 0x40))(local_res20,&local_10);

+    plVar7 = (longlong *)(ulonglong)uVar8;

+  }

+LAB_0:

+  bVar3 = (bool)((byte)((ulonglong)plVar7 >> 0x1f) ^ 1);

+  if (local_10 != (longlong *)0x0) {

+    (**(code **)(*local_10 + 0x10))();

+  }

+  pCVar6 = local_res20;

+  if (local_res20 != (CResource *)0x0) {

+    pcVar1 = *(code **)(*(longlong *)local_res20 + 0x10);

+    if (pcVar1 == CMILRefCountBaseT<IBitmapResource,CMilObjectDeleter>::InternalRelease) {

+      uVar5 = CMILRefCountImpl::RemoveReference((CMILRefCountImpl *)(local_res20 + 8));

+      if (uVar5 == 0) {

+        CMILRefCountImpl::AddReference((CMILRefCountImpl *)(pCVar6 + 8));

+        (**(code **)(*(longlong *)pCVar6 + 0x50))(pCVar6);

+        uVar5 = CMILRefCountImpl::RemoveReference((CMILRefCountImpl *)(pCVar6 + 8));

+        if (uVar5 == 0) {

+          CMILRefCountImpl::RemoveReference((CMILRefCountImpl *)(pCVar6 + 8));

+          CMilObjectDeleter::Delete<IBitmapResource>

+                    ((CMILRefCountBaseT<IBitmapResource,CMilObjectDeleter> *)pCVar6);

+          return bVar3;

+        }

+      }

+    }

+    else {

+      if (pcVar1 == CMILCOMBaseWeakRefSource<CResourceDeleter>::InternalRelease) {

+        wil::com_ptr_t<CMILCOMWeakRef,wil::err_returncode_policy>::

+        com_ptr_t<CMILCOMWeakRef,wil::err_returncode_policy>

+                  ((com_ptr_t<CMILCOMWeakRef,wil::err_returncode_policy> *)&local_18,

+                   *(CMILCOMWeakRef **)(local_res20 + 0x10));

+        bVar4 = wil::operator!=<CWeakReference<CVisual>,wil::err_returncode_policy>(&local_18,0);

+        if (bVar4) {

+          EnterCriticalSection((LPCRITICAL_SECTION)(local_18 + 0x10));

+        }

+        CMILRefCountBaseT<IUnknownWeakRefSource,CResourceDeleter>::InternalRelease

+                  ((CMILRefCountBaseT<IUnknownWeakRefSource,CResourceDeleter> *)pCVar6);

+        bVar4 = wil::operator!=<CWeakReference<CVisual>,wil::err_returncode_policy>(&local_18,0);

+        if (bVar4) {

+          LeaveCriticalSection((LPCRITICAL_SECTION)(local_18 + 0x10));

+        }

+        wil::com_ptr_t<CMILCOMWeakRef,wil::err_returncode_policy>::

+        ~com_ptr_t<CMILCOMWeakRef,wil::err_returncode_policy>

+                  ((com_ptr_t<CMILCOMWeakRef,wil::err_returncode_policy> *)&local_18);

+        return bVar3;

+      }

+      (*pcVar1)(local_res20);

+    }

+  }

+  return bVar3;

+}

+
```

## `detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>::ensure_extra_capacity`  (modified)

```diff
--- detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>::ensure_extra_capacity
+++ detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>::ensure_extra_capacity
@@ -1,70 +1,83 @@
 

-/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

-   guard_dispatch_icall */

-/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: void __cdecl detail::buffer_impl<class CD3DDevice::CDelayUnpin,7,1,class

+   detail::liberal_expansion_policy>::ensure_extra_capacity(unsigned __int64) __ptr64 */

 

 void __thiscall

-CThreadContext::ensure_extra_capacity

+detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>::

+ensure_extra_capacity

           (buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy> *this,

           __uint64 param_1)

 

 {

-  uint uVar1;

-  int iVar2;

-  undefined *puVar3;

-  uint uVar4;

-  longlong unaff_RBP;

-  longlong unaff_RDI;

+  code *pcVar1;

+  undefined1 auVar2 [16];

+  __uint64 _Var3;

+  __uint64 _Var4;

+  void *pvVar5;

+  liberal_expansion_policy *this_00;

+  buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy> *pbVar6;

+  longlong lVar7;

+  ulonglong uVar8;

+  undefined8 local_res8;

+  undefined8 local_58;

+  undefined8 uStack_50;

+  undefined8 local_48;

+  undefined4 local_38;

+  undefined4 uStack_34;

+  undefined4 uStack_30;

+  int iStack_2c;

+  undefined8 local_28;

   

-  if (*(longlong **)(unaff_RBP + 0x3f) != (longlong *)0x0) {

-    (**(code **)(**(longlong **)(unaff_RBP + 0x3f) + 0x18))();

-  }

-  *(undefined8 *)(unaff_RBP + -0x39) = 0;

-  *(undefined8 *)(unaff_RBP + -0x59) = 0;

-  *(code **)(unaff_RBP + -0x41) = CComposition::s_PowerNotification;

-  *(undefined1 *)(unaff_RBP + -0x51) = 1;

-  *(longlong *)(unaff_RBP + -0x61) = unaff_RDI + 0x1948;

-  uVar1 = PowerSettingRegisterNotification

-                    (&GUID_LOW_POWER_EPOCH,2,unaff_RBP + -0x41,unaff_RBP + -0x59);

-  if (0 < (int)uVar1) {

-    uVar1 = uVar1 & 0xffff | 0x80070000;

-  }

-  if (*(char *)(unaff_RBP + -0x51) != '\0') {

-    wil::details::

-    unique_storage<wil::details::resource_policy<void*___ptr64,unsigned_long_(__cdecl*)(void*___ptr64),&unsigned_long___cdecl_PowerSettingUnregisterNotification(void*___ptr64),wistd::integral_constant<unsigned___int64,0>,void*___ptr64,void*___ptr64,0,std::nullptr_t>_>

-    ::reset(*(unique_storage<wil::details::resource_policy<void*___ptr64,unsigned_long_(__cdecl*)(void*___ptr64),&unsigned_long___cdecl_PowerSettingUnregisterNotification(void*___ptr64),wistd::integral_constant<unsigned___int64,0>,void*___ptr64,void*___ptr64,0,std::nullptr_t>_>

-              **)(unaff_RBP + -0x61),*(void **)(unaff_RBP + -0x59));

-  }

-  if ((int)uVar1 < 0) {

-    uVar4 = 0xb12;

-  }

-  else {

-    *(undefined8 *)(unaff_RBP + -0x59) = 0;

-    *(longlong *)(unaff_RBP + -0x61) = unaff_RDI + 0x1950;

-    *(undefined1 *)(unaff_RBP + -0x51) = 1;

-    iVar2 = GetSystemMetrics(0x1800);

-    puVar3 = &GUID_SESSION_DISPLAY_STATUS;

-    if (iVar2 == 0) {

-      puVar3 = &GUID_CONSOLE_DISPLAY_STATE;

-    }

-    uVar1 = PowerSettingRegisterNotification(puVar3,2,unaff_RBP + -0x41,unaff_RBP + -0x59);

-    if (0 < (int)uVar1) {

-      uVar1 = uVar1 & 0xffff | 0x80070000;

-    }

-    wil::details::

-    out_param_t<wil::unique_any_t<wil::details::unique_storage<wil::details::resource_policy<void*___ptr64,unsigned_long_(__cdecl*)(void*___ptr64),&unsigned_long___cdecl_PowerSettingUnregisterNotification(void*___ptr64),wistd::integral_constant<unsigned___int64,0>,void*___ptr64,void*___ptr64,0,std::nullptr_t>_>_>_>

-    ::

-    ~out_param_t<wil::unique_any_t<wil::details::unique_storage<wil::details::resource_policy<void*___ptr64,unsigned_long_(__cdecl*)(void*___ptr64),&unsigned_long___cdecl_PowerSettingUnregisterNotification(void*___ptr64),wistd::integral_constant<unsigned___int64,0>,void*___ptr64,void*___ptr64,0,std::nullptr_t>_>_>_>

-              ((out_param_t<wil::unique_any_t<wil::details::unique_storage<wil::details::resource_policy<void*___ptr64,unsigned_long_(__cdecl*)(void*___ptr64),&unsigned_long___cdecl_PowerSettingUnregisterNotification(void*___ptr64),wistd::integral_constant<unsigned___int64,0>,void*___ptr64,void*___ptr64,0,std::nullptr_t>_>_>_>

-                *)(unaff_RBP + -0x61));

-    if (-1 < (int)uVar1) {

+  if ((ulonglong)(*(longlong *)(this + 0x10) - *(longlong *)(this + 8) >> 6) < param_1) {

+    lVar7 = *(longlong *)(this + 8) - *(longlong *)this;

+    uVar8 = lVar7 >> 6;

+    if (uVar8 + param_1 < uVar8) {

+      std::_Xoverflow_error("overflow");

+      pcVar1 = (code *)swi(3);

+      (*pcVar1)();

       return;

     }

-    uVar4 = 0xb19;

+    this_00 = (liberal_expansion_policy *)(*(longlong *)(this + 0x10) - *(longlong *)this >> 6);

+    _Var3 = liberal_expansion_policy::expand(this_00,(__uint64)this_00,uVar8 + param_1);

+    auVar2._8_8_ = 0;

+    auVar2._0_8_ = _Var3;

+    _Var4 = SUB168(ZEXT816(0x40) * auVar2,0);

+    if (SUB168(ZEXT816(0x40) * auVar2,8) != 0) {

+      _Var4 = 0xffffffffffffffff;

+    }

+    pvVar5 = operator_new__(_Var4);

+    local_58._0_4_ = SUB84(pvVar5,0);

+    local_58._4_4_ = (undefined4)((ulonglong)pvVar5 >> 0x20);

+    uStack_50._0_4_ = (undefined4)uVar8;

+    uStack_50._4_4_ = (int)(lVar7 >> 0x26);

+    local_48 = 0;

+    local_38 = (undefined4)local_58;

+    uStack_34 = local_58._4_4_;

+    uStack_30 = (undefined4)uStack_50;

+    iStack_2c = uStack_50._4_4_;

+    local_28 = 0;

+    local_58 = pvVar5;

+    uStack_50 = uVar8;

+    std::

+    uninitialized_move<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_>

+              (&local_58,*(undefined8 *)this,*(undefined8 *)(this + 8),&local_38);

+    destruct_range<CD3DDevice::CDelayUnpin>(*(CDelayUnpin **)this,*(CDelayUnpin **)(this + 8));

+    pbVar6 = *(buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy> **)this;

+    local_res8 = 0;

+    *(void **)this = pvVar5;

+    if (pbVar6 == this + 0x18) {

+      pbVar6 = (buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy> *)0x0;

+    }

+    ___V_YAXPEAX_Z(pbVar6);

+    *(ulonglong *)(this + 8) = uVar8 * 0x40 + *(longlong *)this;

+    *(__uint64 *)(this + 0x10) = _Var3 * 0x40 + *(longlong *)this;

+    std::

+    unique_ptr<struct_detail::aligned_storage_for<wil::com_ptr_t<CVisualTree,wil::err_returncode_policy>_>_[0],std::default_delete<struct_detail::aligned_storage_for<wil::com_ptr_t<CVisualTree,wil::err_returncode_policy>_>_[0]>_>

+    ::

+    ~unique_ptr<struct_detail::aligned_storage_for<wil::com_ptr_t<CVisualTree,wil::err_returncode_policy>_>_[0],std::default_delete<struct_detail::aligned_storage_for<wil::com_ptr_t<CVisualTree,wil::err_returncode_policy>_>_[0]>_>

+              ((unique_ptr<struct_detail::aligned_storage_for<wil::com_ptr_t<CVisualTree,wil::err_returncode_policy>_>_[0],std::default_delete<struct_detail::aligned_storage_for<wil::com_ptr_t<CVisualTree,wil::err_returncode_policy>_>_[0]>_>

+                *)&local_res8);

   }

-  wil::details::in1diag3::Return_Hr

-            (*(void **)(unaff_RBP + 0x5f),uVar4,

-             "onecoreuap\\windows\\dwm\\dwmcore\\engine\\composition.cpp",uVar1);

   return;

 }
```

## `std::_Tree<std::_Tmap_traits<_LUID,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>,CDDisplayManager::LUIDComparator,std::allocator<std::pair<_LUID_const_,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>_>_>,0>_>::_Emplace<_LUID_const&___ptr64,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>&___ptr64>`  (modified)

```diff
--- std::_Tree<std::_Tmap_traits<_LUID,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>,CDDisplayManager::LUIDComparator,std::allocator<std::pair<_LUID_const_,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>_>_>,0>_>::_Emplace<_LUID_const&___ptr64,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>&___ptr64>
+++ std::_Tree<std::_Tmap_traits<_LUID,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>,CDDisplayManager::LUIDComparator,std::allocator<std::pair<_LUID_const_,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>_>_>,0>_>::_Emplace<_LUID_const&___ptr64,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>&___ptr64>
@@ -1,2 +1,90 @@
-Failed to decompile dwmcore.dll - .ProgramDB std::_Tree<std::_Tmap_traits<_LUID,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>,CDDisplayManager::LUIDComparator,std::allocator<std::pair<_LUID_const_,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>_>_>,0>_>::_Emplace<_LUID_const&___ptr64,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>&___ptr64> : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* protected: struct std::pair<struct std::_Tree_node<struct std::pair<struct _LUID const ,class

+   wil::com_ptr_t<struct Windows::Devices::Display::Core::IDisplayDevice,struct

+   wil::err_returncode_policy> >,void * __ptr64> * __ptr64,bool> __cdecl std::_Tree<class

+   std::_Tmap_traits<struct _LUID,class wil::com_ptr_t<struct

+   Windows::Devices::Display::Core::IDisplayDevice,struct wil::err_returncode_policy>,struct

+   CDDisplayManager::LUIDComparator,class std::allocator<struct std::pair<struct _LUID const ,class

+   wil::com_ptr_t<struct Windows::Devices::Display::Core::IDisplayDevice,struct

+   wil::err_returncode_policy> > >,0> >::_Emplace<struct _LUID const & __ptr64,class

+   wil::com_ptr_t<struct Windows::Devices::Display::Core::IDisplayDevice,struct

+   wil::err_returncode_policy> & __ptr64>(struct _LUID const & __ptr64,class wil::com_ptr_t<struct

+   Windows::Devices::Display::Core::IDisplayDevice,struct wil::err_returncode_policy> & __ptr64)

+   __ptr64 */

+

+_LUID * __thiscall

+std::

+_Tree<std::_Tmap_traits<_LUID,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>,CDDisplayManager::LUIDComparator,std::allocator<std::pair<_LUID_const_,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>_>_>,0>_>

+::

+_Emplace<_LUID_const&___ptr64,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>&___ptr64>

+          (_Tree<std::_Tmap_traits<_LUID,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>,CDDisplayManager::LUIDComparator,std::allocator<std::pair<_LUID_const_,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>_>_>,0>_>

+           *this,_LUID *param_1,

+          com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>

+          *param_2)

+

+{

+  undefined8 uVar1;

+  _Tree<std::_Tmap_traits<_LUID,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>,CDDisplayManager::LUIDComparator,std::allocator<std::pair<_LUID_const_,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>_>_>,0>_>

+  *p_Var2;

+  undefined8 uVar3;

+  undefined8 *puVar4;

+  __uint64 _Var5;

+  _LUID _Var6;

+  com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy> *pcVar7;

+  com_ptr_t<struct_Windows::Devices::Display::Core::IDisplayDevice,struct_wil::err_returncode_policy>

+  *in_R9;

+  _Tree<std::_Tmap_traits<_LUID,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>,CDDisplayManager::LUIDComparator,std::allocator<std::pair<_LUID_const_,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>_>_>,0>_>

+  *local_48;

+  undefined8 uStack_40;

+  _LUID local_38;

+  

+  pcVar7 = param_2;

+  puVar4 = (undefined8 *)

+           _Tree<std::_Tmap_traits<unsigned___int64,CCursorState*___ptr64,std::less<unsigned___int64>,std::allocator<std::pair<unsigned___int64_const_,CCursorState*___ptr64>_>,0>_>

+           ::_Find_lower_bound<unsigned___int64>

+                     ((_Tree<std::_Tmap_traits<unsigned___int64,CCursorState*___ptr64,std::less<unsigned___int64>,std::allocator<std::pair<unsigned___int64_const_,CCursorState*___ptr64>_>,0>_>

+                       *)this,(__uint64 *)&local_48);

+  local_38 = *(_LUID *)(puVar4 + 2);

+  p_Var2 = (_Tree<std::_Tmap_traits<_LUID,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>,CDDisplayManager::LUIDComparator,std::allocator<std::pair<_LUID_const_,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>_>_>,0>_>

+            *)*puVar4;

+  uVar3 = puVar4[1];

+  if ((*(char *)((longlong)local_38 + 0x19) == '\0') &&

+     (*(ulonglong *)((longlong)local_38 + 0x20) <= *(ulonglong *)pcVar7)) {

+    *param_1 = local_38;

+    *(undefined1 *)&param_1[1].LowPart = 0;

+  }

+  else {

+    if (*(longlong *)(this + 8) == 0x555555555555555) {

+                    /* WARNING: Subroutine does not return */

+      _Throw_tree_length_error();

+    }

+    uVar1 = *(undefined8 *)this;

+    local_48 = this;

+    _Var5 = _Get_size_of_n<48>(1);

+    puVar4 = _Allocate<16,std::_Default_allocate_traits,0>(_Var5);

+    puVar4[4] = *(undefined8 *)param_2;

+    wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>::

+    com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>

+              ((com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>

+                *)(puVar4 + 5),in_R9);

+    uStack_40 = 0;

+    *puVar4 = uVar1;

+    puVar4[1] = uVar1;

+    puVar4[2] = uVar1;

+    *(undefined2 *)(puVar4 + 3) = 0;

+    _Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_>

+    ::

+    ~_Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_>

+              ((_Tree_temp_node<std::allocator<std::_Tree_node<std::pair<IDXGIResource*___ptr64_const,wil::com_ptr_t<IRenderTargetBitmap,wil::err_returncode_policy>_>,void*___ptr64>_>_>

+                *)&local_48);

+    local_48 = p_Var2;

+    uStack_40 = uVar3;

+    _Var6 = (_LUID)_Tree_val<std::_Tree_simple_types<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>_>_>

+                   ::_Insert_node((_Tree_val<std::_Tree_simple_types<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>_>_>

+                                   *)this,&local_48,puVar4);

+    *param_1 = _Var6;

+    *(undefined1 *)&param_1[1].LowPart = 1;

+  }

+  return param_1;

+}

+
```

## `std::move<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_>`  (modified)

```diff
--- std::move<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_>
+++ std::move<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_>
@@ -1,2 +1,35 @@
-Failed to decompile dwmcore.dll - .ProgramDB std::move<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_> : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* class stdext::checked_array_iterator<class CD3DDevice::CDelayUnpin * __ptr64> __cdecl

+   std::move<class std::move_iterator<class CD3DDevice::CDelayUnpin * __ptr64>,class

+   stdext::checked_array_iterator<class CD3DDevice::CDelayUnpin * __ptr64> >(class

+   std::move_iterator<class CD3DDevice::CDelayUnpin * __ptr64>,class std::move_iterator<class

+   CD3DDevice::CDelayUnpin * __ptr64>,class stdext::checked_array_iterator<class

+   CD3DDevice::CDelayUnpin * __ptr64>) */

+

+undefined8 * __cdecl

+std::

+move<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_>

+          (undefined8 *param_1,CDelayUnpin *param_2,CDelayUnpin *param_3,

+          checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64> *param_4)

+

+{

+  undefined8 uVar1;

+  undefined8 uVar2;

+  CDelayUnpin *this;

+  

+  this = (CDelayUnpin *)

+         _Get_unwrapped_n<stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>&___ptr64,__int64>

+                   (param_4,(longlong)param_3 - (longlong)param_2 >> 6);

+  for (; param_2 != param_3; param_2 = param_2 + 0x40) {

+    CD3DDevice::CDelayUnpin::operator=(this,param_2);

+    this = this + 0x40;

+  }

+  *(longlong *)(param_4 + 0x10) = (longlong)this - *(longlong *)param_4 >> 6;

+  uVar2 = *(undefined8 *)(param_4 + 8);

+  uVar1 = *(undefined8 *)(param_4 + 0x10);

+  *param_1 = *(undefined8 *)param_4;

+  param_1[1] = uVar2;

+  param_1[2] = uVar1;

+  return param_1;

+}

+
```

## `CPrimitiveGroupRenderStrategy::GetBrushParameters`  (modified)

```diff
--- CPrimitiveGroupRenderStrategy::GetBrushParameters
+++ CPrimitiveGroupRenderStrategy::GetBrushParameters
@@ -1,2 +1,87 @@
-Failed to decompile dwmcore.dll - .ProgramDB CPrimitiveGroupRenderStrategy::GetBrushParameters : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Restarted to delay deadcode elimination for space: stack */

+/* public: virtual long __cdecl CPrimitiveGroupRenderStrategy::GetBrushParameters(class

+   CSurfaceBrush const * __ptr64,class CBrushDrawListGenerator * __ptr64)const __ptr64 */

+

+long __thiscall

+CPrimitiveGroupRenderStrategy::GetBrushParameters

+          (CPrimitiveGroupRenderStrategy *this,CSurfaceBrush *param_1,

+          CBrushDrawListGenerator *param_2)

+

+{

+  CPrimitiveGroupDrawListBrush *pCVar1;

+  long lVar2;

+  Enum EVar3;

+  CResource *this_00;

+  undefined8 local_res18;

+  CPrimitiveGroupDrawListBrush *local_res20;

+  uint uVar4;

+  undefined8 local_40;

+  undefined8 uStack_38;

+  undefined8 local_30;

+  undefined8 uStack_28;

+  undefined8 local_20;

+  

+  CBrushDrawListGenerator::Reset(param_2);

+  this_00 = CSurfaceBrush::GetSurface(param_1);

+  local_res20 = (CPrimitiveGroupDrawListBrush *)0x0;

+  local_20 = 0;

+  local_40 = 0;

+  uStack_38 = 0;

+  local_30 = 0;

+  uStack_28 = 0;

+  lVar2 = CSurfaceBrush::ComputeLayout

+                    (param_1,(D2D_SIZE_F *)(param_2 + 0x2c),(LayoutData *)&local_40,(CShape **)0x0);

+  if (lVar2 < 0) {

+    uVar4 = 0x70f;

+  }

+  else {

+    lVar2 = CPrimitiveGroup::EnsureDrawListGenerator((CPrimitiveGroup *)this_00);

+    if (lVar2 < 0) {

+      MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar2,0x1ee,(void *)0x0);

+      uVar4 = 0x711;

+    }

+    else {

+      EVar3 = InterpolationMode::FromD2D1InterpolationMode

+                        (*(D2D1_INTERPOLATION_MODE *)(param_1 + 0x7c));

+      local_res18._0_3_ = CONCAT21(0x101,(char)EVar3);

+      lVar2 = CPrimitiveGroupDrawListBrush::Create(*(undefined8 *)(this_00 + 0x80));

+      pCVar1 = local_res20;

+      local_res20 = (CPrimitiveGroupDrawListBrush *)0x0;

+      if (pCVar1 != (CPrimitiveGroupDrawListBrush *)0x0) {

+        CPrimitiveGroupDrawListBrush::_scalar_deleting_destructor_(pCVar1,1);

+      }

+      pCVar1 = local_res20;

+      if (-1 < lVar2) {

+        *(undefined8 *)(local_res20 + 8) = local_40;

+        *(undefined8 *)(local_res20 + 0x10) = uStack_38;

+        *(undefined8 *)(local_res20 + 0x18) = local_30;

+        local_res20[0x34] = (CPrimitiveGroupDrawListBrush)0x1;

+        *(undefined8 *)(local_res20 + 0x20) = uStack_28;

+        *(undefined8 *)(local_res20 + 0x28) = local_20;

+        *(undefined4 *)(local_res20 + 0x30) = 0x3030303;

+        if (param_1[200] != (CSurfaceBrush)0x0) {

+          *(undefined8 *)(local_res20 + 0x38) = uStack_28;

+          local_res20[0x40] = (CPrimitiveGroupDrawListBrush)0x1;

+        }

+        local_res20 = (CPrimitiveGroupDrawListBrush *)0x0;

+        local_res18 = pCVar1;

+        CBrushDrawListGenerator::AttachInput

+                  (param_2,0,

+                   (unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_> *)&local_res18);

+        std::unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>::

+        ~unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_>

+                  ((unique_ptr<CDrawListBrush,std::default_delete<CDrawListBrush>_> *)&local_res18);

+        goto LAB_0;

+      }

+      uVar4 = 0x714;

+    }

+  }

+  MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar2,uVar4,(void *)0x0);

+LAB_0:

+  if (local_res20 != (CPrimitiveGroupDrawListBrush *)0x0) {

+    CPrimitiveGroupDrawListBrush::_scalar_deleting_destructor_(local_res20,1);

+  }

+  return lVar2;

+}

+
```

## `CD3DDevice::CDelayUnpin::ReadyToUnpin`  (modified)

```diff
--- CD3DDevice::CDelayUnpin::ReadyToUnpin
+++ CD3DDevice::CDelayUnpin::ReadyToUnpin
@@ -1,2 +1,76 @@
-Failed to decompile dwmcore.dll - .ProgramDB CD3DDevice::CDelayUnpin::ReadyToUnpin : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: bool __cdecl CD3DDevice::CDelayUnpin::ReadyToUnpin(struct _LUID,unsigned int,unsigned

+   int) __ptr64 */

+

+bool __thiscall

+CD3DDevice::CDelayUnpin::ReadyToUnpin(CDelayUnpin *this,_LUID param_1,uint param_2,uint param_3)

+

+{

+  vector_facade<CD3DDevice::CDelayUnpin::UnpinTarget,detail::buffer_impl<CD3DDevice::CDelayUnpin::UnpinTarget,2,1,detail::liberal_expansion_policy>_>

+  *this_00;

+  int iVar1;

+  undefined4 uVar2;

+  undefined8 uVar3;

+  undefined8 *puVar4;

+  DWORD *pDVar5;

+  undefined8 uVar6;

+  undefined4 uVar7;

+  longlong *local_res8;

+  _LUID local_res10;

+  undefined1 local_48 [16];

+  

+  this_00 = (vector_facade<CD3DDevice::CDelayUnpin::UnpinTarget,detail::buffer_impl<CD3DDevice::CDelayUnpin::UnpinTarget,2,1,detail::liberal_expansion_policy>_>

+             *)(this + 8);

+  pDVar5 = *(DWORD **)this_00;

+  do {

+    if (pDVar5 == *(DWORD **)(this + 0x10)) {

+LAB_0:

+      return *(longlong *)(this + 0x10) == *(longlong *)this_00;

+    }

+    if (((*pDVar5 == param_1.LowPart) && (pDVar5[1] == param_1.HighPart)) && (pDVar5[2] == param_2))

+    {

+      uVar3 = 0;

+      local_res10 = param_1;

+      if ((param_3 < pDVar5[3]) && (param_3 != 0)) {

+        uVar7 = 0;

+      }

+      else {

+        uVar7 = 1;

+        detail::

+        vector_facade<CD3DDevice::CDelayUnpin::UnpinTarget,detail::buffer_impl<CD3DDevice::CDelayUnpin::UnpinTarget,2,1,detail::liberal_expansion_policy>_>

+        ::clear_region(this_00,(longlong)pDVar5 - *(longlong *)this_00 >> 4,1);

+      }

+      if (((byte)Microsoft_Windows_Dwm_CompositorEnableBits & 2) != 0) {

+        local_res8 = (longlong *)0x0;

+        uVar2 = 0xffffffff;

+        iVar1 = (**(code **)**(undefined8 **)this)

+                          (*(undefined8 **)this,&_GUID_178d0f24_35be_4a99_bb8d_0ce831b03f8c,

+                           &local_res8);

+        if (-1 < iVar1) {

+          uVar2 = (**(code **)(*local_res8 + 0x58))();

+          uVar3 = (**(code **)(*local_res8 + 0x108))();

+        }

+        if (((byte)Microsoft_Windows_Dwm_CompositorEnableBits & 2) != 0) {

+          puVar4 = (undefined8 *)

+                   (**(code **)(**(longlong **)this + 0x18))(*(longlong **)this,local_48);

+          uVar6 = CONCAT44((int)((ulonglong)*puVar4 >> 0x20),*(undefined4 *)puVar4);

+          McTemplateU0txqqxqx_EventWriteTransfer

+                    (*(undefined4 *)puVar4,uVar6,uVar7,

+                     (longlong)local_res10.HighPart << 0x20 | (ulonglong)param_1 & 0xffffffff,

+                     param_2,param_3,uVar6,uVar2,uVar3);

+        }

+        wil::

+        com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+        ::

+        ~com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+                  ((com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+                    *)&local_res8);

+      }

+      goto LAB_0;

+    }

+    pDVar5 = pDVar5 + 4;

+  } while( true );

+}

+
```

## `COcclusionContext::COcclusionContext`  (modified)

```diff
--- COcclusionContext::COcclusionContext
+++ COcclusionContext::COcclusionContext
@@ -1,2 +1,90 @@
-Failed to decompile dwmcore.dll - .ProgramDB COcclusionContext::COcclusionContext : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: __cdecl COcclusionContext::COcclusionContext(void) __ptr64 */

+

+COcclusionContext * __thiscall COcclusionContext::COcclusionContext(COcclusionContext *this)

+

+{

+  uint uVar1;

+  int iVar2;

+  undefined8 uVar3;

+  

+  uVar3 = 0;

+  *(undefined ***)this = &_vftable_;

+  *(undefined8 *)(this + 8) = 0;

+  *(undefined8 *)(this + 0x10) = 0;

+  *(undefined8 *)(this + 0x18) = 0;

+  *(undefined8 *)(this + 0x28) = 0;

+  *(undefined8 *)(this + 0x20) = 0;

+  *(undefined8 *)(this + 0x30) = 0;

+  *(undefined8 *)(this + 0x60) = 0;

+  *(undefined8 *)(this + 0x58) = 0;

+  *(undefined8 *)(this + 0x68) = 0;

+  *(undefined4 *)(this + 0x54) = 0;

+  *(undefined4 *)(this + 0x3c) = 0;

+  *(undefined8 *)(this + 0x40) = 0;

+  *(undefined8 *)(this + 0x48) = 0;

+  *(undefined4 *)(this + 0x60) = 0;

+  *(undefined8 *)(this + 0x88) = 0;

+  *(undefined8 *)(this + 0x80) = 0;

+  *(undefined8 *)(this + 0x90) = 0;

+  COccluderClipStack::COccluderClipStack((COccluderClipStack *)(this + 0x98));

+  *(undefined8 *)(this + 200) = uVar3;

+  *(COcclusionContext **)(this + 0xd0) = this + 0xf0;

+  *(COcclusionContext **)(this + 0xd8) = this + 0xf0;

+  iVar2 = (int)uVar3;

+  *(uint *)(this + 0xe0) = iVar2 + 4U;

+  *(ulonglong *)(this + 0xe4) = (ulonglong)(iVar2 + 4U);

+  *(COcclusionContext **)(this + 0x130) = this + 0x150;

+  *(COcclusionContext **)(this + 0x138) = this + 0x150;

+  *(uint *)(this + 0x140) = iVar2 + 3U;

+  *(ulonglong *)(this + 0x144) = (ulonglong)(iVar2 + 3U);

+  *(undefined8 *)(this + 0x1a8) = uVar3;

+  *(COcclusionContext **)(this + 0x1b0) = this + 0x1b8;

+  *(int *)(this + 0x1b8) = iVar2;

+  *(COcclusionContext **)(this + 0x1f8) = this + 0x200;

+  *(int *)(this + 0x200) = iVar2;

+  *(COcclusionContext **)(this + 0x240) = this + 0x260;

+  *(COcclusionContext **)(this + 0x248) = this + 0x260;

+  *(uint *)(this + 0x250) = iVar2 + 10U;

+  *(ulonglong *)(this + 0x254) = (ulonglong)(iVar2 + 10U);

+  *(COcclusionContext **)(this + 0x440) = this + 0x458;

+  *(COcclusionContext **)(this + 0x448) = this + 0x458;

+  *(COcclusionContext **)(this + 0x450) = this + 0x4f8;

+  detail::

+  vector_facade<COcclusionContext::CTempOcclusionRect,detail::buffer_impl<COcclusionContext::CTempOcclusionRect,10,1,detail::liberal_expansion_policy>_>

+  ::

+  vector_facade<COcclusionContext::CTempOcclusionRect,detail::buffer_impl<COcclusionContext::CTempOcclusionRect,10,1,detail::liberal_expansion_policy>_>

+            ((vector_facade<COcclusionContext::CTempOcclusionRect,detail::buffer_impl<COcclusionContext::CTempOcclusionRect,10,1,detail::liberal_expansion_policy>_>

+              *)(this + 0x4f8));

+  do {

+    LOCK();

+    uVar1 = s_occlusionId + 1;

+    UNLOCK();

+    iVar2 = s_occlusionId + 1;

+    s_occlusionId = uVar1;

+  } while (iVar2 == 0);

+  *(int *)(this + 0x5d8) = iVar2;

+  *(undefined8 *)(this + 0x5e0) = uVar3;

+  *(undefined8 *)(this + 0x5e8) = uVar3;

+  *(undefined4 *)(this + 0x5f0) = 0x7fffffff;

+  *(undefined4 *)(this + 0x5f4) = 0x100;

+  this[0x5f8] = SUB81(uVar3,0);

+  *(int *)(this + 0x63c) = (int)uVar3;

+  *(undefined8 *)(this + 0x680) = uVar3;

+  *(undefined8 *)(this + 0x688) = uVar3;

+  *(int *)(this + 0x690) = (int)uVar3;

+  *(undefined8 *)(this + 0x6a0) = uVar3;

+  *(undefined8 *)(this + 0x698) = uVar3;

+  *(undefined8 *)(this + 0x6a8) = uVar3;

+  *(undefined8 *)(this + 0x6b8) = uVar3;

+  *(undefined8 *)(this + 0x6b0) = uVar3;

+  *(undefined8 *)(this + 0x6c0) = uVar3;

+  *(undefined8 *)(this + 0x6d0) = uVar3;

+  *(undefined8 *)(this + 0x6c8) = uVar3;

+  *(undefined8 *)(this + 0x6d8) = uVar3;

+  *(COcclusionContext **)(this + 0x6e0) = this + 0x6f8;

+  *(COcclusionContext **)(this + 0x6e8) = this + 0x6f8;

+  *(COcclusionContext **)(this + 0x6f0) = this + 0x708;

+  return this;

+}

+
```

## `COverlayContext::ApplyConfiguration`  (modified)

```diff
--- COverlayContext::ApplyConfiguration
+++ COverlayContext::ApplyConfiguration
@@ -1,2 +1,597 @@
-Failed to decompile dwmcore.dll - .ProgramDB COverlayContext::ApplyConfiguration : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: void __cdecl COverlayContext::ApplyConfiguration(bool,class std::vector<class CVisual

+   const * __ptr64,class std::allocator<class CVisual const * __ptr64> > * __ptr64) __ptr64 */

+

+void __thiscall

+COverlayContext::ApplyConfiguration

+          (COverlayContext *this,bool param_1,

+          vector<CVisual_const*___ptr64,std::allocator<CVisual_const*___ptr64>_> *param_2)

+

+{

+  undefined8 *_Src;

+  CDirectFlipInfo *pCVar1;

+  CursorVisualData *pCVar2;

+  longlong *plVar3;

+  char cVar4;

+  bool bVar5;

+  bool bVar6;

+  int iVar7;

+  uint uVar8;

+  long lVar9;

+  CursorVisibility CVar10;

+  CursorVisualData **ppCVar11;

+  HANDLE hHeap;

+  undefined8 *puVar12;

+  ulonglong uVar13;

+  CursorVisualData **_Dst;

+  longlong *plVar14;

+  longlong lVar15;

+  int *piVar16;

+  ulonglong uVar17;

+  size_t sVar18;

+  undefined8 uVar19;

+  ulonglong uVar20;

+  uint uVar21;

+  longlong lVar22;

+  undefined8 extraout_XMM0_Qa;

+  undefined8 extraout_XMM0_Qa_00;

+  undefined8 unaff_retaddr;

+  undefined1 auStack_128 [32];

+  undefined1 *local_108;

+  ulonglong local_100;

+  char local_e8;

+  char local_e7;

+  char local_e6;

+  int local_e4;

+  CursorVisualData **local_e0;

+  ulonglong local_d8;

+  longlong local_d0;

+  ulonglong local_c8;

+  vector<CVisual_const*___ptr64,std::allocator<CVisual_const*___ptr64>_> *local_c0;

+  undefined1 local_b8 [24];

+  undefined1 local_a0 [24];

+  float local_88;

+  float local_84;

+  float local_80;

+  float local_7c;

+  undefined1 local_70 [16];

+  ulonglong *local_60;

+  undefined8 local_58;

+  ulonglong *local_50;

+  undefined8 local_48;

+  ulonglong local_40;

+  

+  local_40 = __security_cookie ^ (ulonglong)auStack_128;

+  local_e8 = '\0';

+  local_e6 = '\0';

+  local_e7 = param_1;

+  local_c0 = param_2;

+  if ((this[0x4a90] != (COverlayContext)0x0) &&

+     ((this[0x4b08] == (COverlayContext)0x0 || (this[0x4b09] != this[0x4a91])))) {

+    (**(code **)(*(longlong *)(*(longlong *)this + 8) + 0x30))();

+    lVar15 = (**(code **)(**(longlong **)this + 0x100))();

+    if (*(char *)(lVar15 + 0x100) != '\0') {

+      *(undefined1 *)(lVar15 + 0x101) = 1;

+    }

+  }

+  uVar13 = (**(code **)(*(longlong *)(*(longlong *)this + 8) + 0x20))();

+  lVar15 = *(longlong *)(this + 0x3188);

+  local_d0 = *(longlong *)(this + 0x3190);

+  piVar16 = (int *)(lVar15 + 0x100);

+  local_e4 = 1;

+  local_c8 = uVar13;

+  for (; lVar15 != local_d0; lVar15 = lVar15 + 0x188) {

+    if ((piVar16[-3] < piVar16[-1]) && (piVar16[-2] < *piVar16)) {

+      (**(code **)(**(longlong **)(piVar16 + -0x3c) + 0xd8))();

+    }

+    if ((piVar16[5] != 0) &&

+       (iVar7 = (**(code **)(**(longlong **)(piVar16 + -0x3c) + 0x140))(), piVar16[5] != iVar7)) {

+      local_88 = (float)piVar16[1];

+      local_84 = (float)piVar16[2];

+      local_80 = (float)piVar16[3];

+      local_7c = (float)piVar16[4];

+      (**(code **)(**(longlong **)this + 0x128))(*(longlong **)this,&local_88);

+      piVar16[5] = iVar7;

+      *(undefined8 *)(piVar16 + 1) = *(undefined8 *)(piVar16 + -3);

+      *(undefined8 *)(piVar16 + 3) = *(undefined8 *)(piVar16 + -1);

+    }

+    local_108 = (undefined1 *)CONCAT44(local_108._4_4_,piVar16[-0x25]);

+    local_100 = uVar13;

+    (**(code **)(**(longlong **)(piVar16 + -0x3c) + 0xe0))();

+    if ((*(char *)((longlong)piVar16 + 0x6f) == '\0') &&

+       ((cVar4 = (**(code **)(**(longlong **)(piVar16 + -0x3c) + 0x160))(), cVar4 == '\0' ||

+        (cVar4 = (**(code **)(**(longlong **)(piVar16 + -0x3c) + 0x168))(), cVar4 != '\0')))) {

+      puVar12 = *(undefined8 **)(param_2 + 8);

+      if (puVar12 == *(undefined8 **)(param_2 + 0x10)) {

+        lVar22 = (longlong)puVar12 - *(longlong *)param_2 >> 3;

+        if (lVar22 == 0x1fffffffffffffff) goto LAB_0;

+        local_d8 = lVar22 + 1;

+        uVar13 = (longlong)*(undefined8 **)(param_2 + 0x10) - *(longlong *)param_2 >> 3;

+        if (0x1fffffffffffffff - (uVar13 >> 1) < uVar13) {

+          uVar20 = 0x1fffffffffffffff;

+        }

+        else {

+          uVar13 = (uVar13 >> 1) + uVar13;

+          uVar20 = local_d8;

+          if (local_d8 <= uVar13) {

+            uVar20 = uVar13;

+          }

+          if (0x1fffffffffffffff < uVar20) goto LAB_1;

+        }

+        ppCVar11 = std::_Allocate<16,std::_Default_allocate_traits,0>(uVar20 * 8);

+        ppCVar11[lVar22] = *(CursorVisualData **)(piVar16 + -0x3e);

+        _Src = *(undefined8 **)param_2;

+        local_e0 = ppCVar11;

+        if (puVar12 == *(undefined8 **)(param_2 + 8)) {

+          sVar18 = (longlong)*(undefined8 **)(param_2 + 8) - (longlong)_Src;

+          puVar12 = _Src;

+        }

+        else {

+          memmove(ppCVar11,_Src,(longlong)puVar12 - (longlong)_Src);

+          sVar18 = *(longlong *)(param_2 + 8) - (longlong)puVar12;

+          ppCVar11 = local_e0 + lVar22 + 1;

+        }

+        memmove(ppCVar11,puVar12,sVar18);

+        std::

+        vector<CursorVisualData_const*___ptr64,std::allocator<CursorVisualData_const*___ptr64>_>::

+        _Change_array((vector<CursorVisualData_const*___ptr64,std::allocator<CursorVisualData_const*___ptr64>_>

+                       *)param_2,local_e0,local_d8,uVar20);

+        uVar13 = local_c8;

+      }

+      else {

+        *puVar12 = *(undefined8 *)(piVar16 + -0x3e);

+        *(longlong *)(param_2 + 8) = *(longlong *)(param_2 + 8) + 8;

+      }

+    }

+    piVar16 = piVar16 + 0x62;

+  }

+  uVar13 = 0;

+  if (*(int *)(this + 0x4be8) < 1) {

+    bVar6 = false;

+  }

+  else {

+    lVar15 = *(longlong *)(this + 0x4c28);

+    bVar6 = true;

+    bVar5 = true;

+    local_e8 = '\x01';

+    if ((((lVar15 == 0) || (*(longlong *)(lVar15 + 8) != *(longlong *)(this + 0x4bc0))) ||

+        (*(longlong *)(lVar15 + 0x10) != *(longlong *)(this + 0x4bc8))) ||

+       ((*(longlong *)(lVar15 + 0x18) != *(longlong *)(this + 0x4bd0) ||

+        ((*(int *)(lVar15 + 0x34) == 1) != (*(int *)(this + 0x4bec) == 1))))) {

+      cVar4 = (**(code **)(**(longlong **)(this + 0x4bc8) + 0x88))();

+      if (cVar4 == '\0') {

+        bVar5 = false;

+        goto LAB_2;

+      }

+    }

+    else {

+      local_e6 = '\x01';

+LAB_2:

+      if (((*(longlong *)(this + 0x3190) == *(longlong *)(this + 0x3188)) &&

+          (*(int *)(this + 0x4b10) == 0)) &&

+         (cVar4 = (**(code **)(**(longlong **)(this + 0x4bc8) + 0xb0))(), cVar4 == '\0')) {

+        local_e0 = (CursorVisualData **)0x0;

+        puVar12 = (undefined8 *)(**(code **)(**(longlong **)(this + 0x4bc8) + 0x30))();

+        if (puVar12 != (undefined8 *)0x0) {

+          if (local_e0 != (CursorVisualData **)0x0) {

+            (**(code **)(*local_e0 + 0x10))();

+          }

+          (**(code **)*puVar12)(puVar12,&_GUID_302508ed_c63d_40f8_af07_af5881d2df95,&local_e0);

+        }

+        if ((local_e0 == (CursorVisualData **)0x0) ||

+           (cVar4 = (**(code **)(*local_e0 + 0x18))(), cVar4 == '\0')) {

+          if (*(int *)(this + 0x4bec) < 3) {

+LAB_3:

+            if (!bVar5) goto LAB_4;

+          }

+          else if ((!bVar5) ||

+                  (cVar4 = (**(code **)(**(longlong **)(*(longlong *)(this + 0x4c28) + 0x10) + 0x160

+                                       ))(), cVar4 != '\0')) {

+            if (this[0x4c72] != (COverlayContext)0x0) {

+              bVar6 = false;

+              local_e8 = '\0';

+              if ((Microsoft_Windows_Dwm_CoreEnableBits._1_1_ & 2) != 0) {

+                uVar19 = 2;

+                goto LAB_5;

+              }

+              goto LAB_4;

+            }

+            goto LAB_3;

+          }

+          bVar5 = CDirectFlipInfo::RenderingRealizationChanged(*(CDirectFlipInfo **)(this + 0x4c28))

+          ;

+          if (((!bVar5) && (2 < *(int *)(this + 0x4bec))) && (*(int *)(this + 0x4bec) != 4)) {

+            bVar6 = false;

+            local_e8 = '\0';

+            if ((Microsoft_Windows_Dwm_CoreEnableBits._1_1_ & 2) != 0) {

+              uVar19 = 1;

+              goto LAB_5;

+            }

+          }

+        }

+        else {

+          bVar6 = false;

+          local_e8 = '\0';

+          if ((Microsoft_Windows_Dwm_CoreEnableBits._1_1_ & 2) != 0) {

+            uVar19 = 0;

+LAB_5:

+            local_e8 = '\0';

+            bVar6 = false;

+            uVar20 = *(ulonglong *)(*(longlong *)(this + 0x4bc8) + 0x28);

+            McTemplateU0xq_EventWriteTransfer

+                      (uVar20,&EVTDESC_ADVANCED_DIRECTFLIP_CANCEL,

+                       (longlong)(int)(uVar20 >> 0x20) << 0x20 | uVar20 & 0xffffffff,uVar19);

+          }

+        }

+LAB_4:

+        if (local_e0 != (CursorVisualData **)0x0) {

+          (**(code **)(*local_e0 + 0x10))();

+        }

+        goto LAB_6;

+      }

+    }

+    bVar6 = false;

+    local_e8 = '\0';

+  }

+LAB_6:

+  lVar15 = *(longlong *)(this + 0x4c28);

+  if ((lVar15 != 0) &&

+     ((*(int *)(lVar15 + 0x30) != 3 || ((local_e7 == '\0' && ((!bVar6 || (local_e6 == '\0')))))))) {

+    if (*(int *)(lVar15 + 0x34) != 1) {

+      (**(code **)(**(longlong **)(lVar15 + 0x10) + 0x1e8))(*(longlong **)(lVar15 + 0x10),1,0);

+    }

+    pCVar1 = *(CDirectFlipInfo **)(this + 0x4c28);

+    if (pCVar1 != (CDirectFlipInfo *)0x0) {

+      CDirectFlipInfo::Reset(pCVar1);

+      plVar14 = *(longlong **)(pCVar1 + 0x28);

+      if (plVar14 != (longlong *)0x0) {

+        LOCK();

+        plVar3 = plVar14 + 1;

+        lVar15 = *plVar3;

+        *(int *)plVar3 = (int)*plVar3 + -1;

+        UNLOCK();

+        if ((int)lVar15 == 1) {

+          (**(code **)*plVar14)(plVar14);

+          LOCK();

+          piVar16 = (int *)((longlong)plVar14 + 0xc);

+          iVar7 = *piVar16;

+          *piVar16 = *piVar16 + -1;

+          UNLOCK();

+          if (iVar7 == 1) {

+            (**(code **)(*plVar14 + 8))(plVar14);

+          }

+        }

+      }

+      if (*(longlong **)(pCVar1 + 0x10) != (longlong *)0x0) {

+        (**(code **)(**(longlong **)(pCVar1 + 0x10) + 0x10))();

+      }

+      operator_delete__(pCVar1,0x70);

+    }

+    *(undefined8 *)(this + 0x4c28) = 0;

+    if ((Microsoft_Windows_Dwm_CoreEnableBits._1_1_ & 2) != 0) {

+      lVar15 = (**(code **)(*(longlong *)(*(longlong *)this + 8) + 0x18))

+                         ((longlong *)(*(longlong *)this + 8),local_b8);

+      McTemplateU0xq_EventWriteTransfer

+                (extraout_XMM0_Qa,&EVTDESC_ETWGUID_DIRECTFLIP_TRANSITIONEVENT,

+                 *(undefined4 *)(lVar15 + 8),0);

+    }

+    (**(code **)(*(longlong *)(*(longlong *)this + 8) + 0x30))();

+  }

+  if ((*(longlong *)(this + 0x4c28) == 0) && (local_e8 != '\0')) {

+    hHeap = GetProcessHeap();

+    puVar12 = HeapAlloc(hHeap,0,0x70);

+    if (puVar12 == (undefined8 *)0x0) {

+                    /* WARNING: Subroutine does not return */

+      ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+    }

+    *puVar12 = *(undefined8 *)(this + 0x4bb8);

+    puVar12[1] = *(undefined8 *)(this + 0x4bc0);

+    plVar14 = *(longlong **)(this + 0x4bc8);

+    puVar12[2] = plVar14;

+    if (plVar14 != (longlong *)0x0) {

+      (**(code **)(*plVar14 + 8))();

+    }

+    uVar19 = (**(code **)(**(longlong **)(this + 0x4bc8) + 0x40))();

+    puVar12[4] = 0;

+    puVar12[5] = 0;

+    puVar12[3] = uVar19;

+    *(undefined4 *)(puVar12 + 6) = 1;

+    *(undefined4 *)((longlong)puVar12 + 0x34) = *(undefined4 *)(this + 0x4bec);

+    puVar12[7] = 0;

+    puVar12[8] = 0;

+    puVar12[9] = 0;

+    puVar12[10] = 0;

+    puVar12[0xb] = 0;

+    puVar12[0xc] = 0;

+    *(undefined4 *)(puVar12 + 0xd) = 0x1000000;

+    *(undefined2 *)((longlong)puVar12 + 0x6c) = 0;

+    plVar14 = (longlong *)puVar12[5];

+    puVar12[4] = 0;

+    puVar12[5] = 0;

+    if (plVar14 != (longlong *)0x0) {

+      LOCK();

+      plVar3 = plVar14 + 1;

+      lVar15 = *plVar3;

+      *(int *)plVar3 = (int)*plVar3 + -1;

+      UNLOCK();

+      if ((int)lVar15 == 1) {

+        (**(code **)*plVar14)(plVar14);

+        LOCK();

+        piVar16 = (int *)((longlong)plVar14 + 0xc);

+        iVar7 = *piVar16;

+        *piVar16 = *piVar16 + -1;

+        UNLOCK();

+        if (iVar7 == 1) {

+          (**(code **)(*plVar14 + 8))(plVar14);

+        }

+      }

+    }

+    *(undefined4 *)(puVar12 + 6) = 2;

+    *(undefined8 **)(this + 0x4c28) = puVar12;

+    local_d0 = 0;

+    std::unique_ptr<CDirectFlipInfo,std::default_delete<CDirectFlipInfo>_>::

+    ~unique_ptr<CDirectFlipInfo,std::default_delete<CDirectFlipInfo>_>

+              ((unique_ptr<CDirectFlipInfo,std::default_delete<CDirectFlipInfo>_> *)&local_d0);

+    if (2 < *(int *)(*(longlong *)(this + 0x4c28) + 0x34)) {

+      (**(code **)(*(longlong *)(*(longlong *)this + 8) + 0x30))();

+    }

+    (**(code **)(**(longlong **)(*(longlong *)(this + 0x4c28) + 0x10) + 0x1e8))

+              (*(longlong **)(*(longlong *)(this + 0x4c28) + 0x10),1,1);

+    if ((Microsoft_Windows_Dwm_CoreEnableBits._1_1_ & 2) != 0) {

+      lVar15 = (**(code **)(*(longlong *)(*(longlong *)this + 8) + 0x18))

+                         ((longlong *)(*(longlong *)this + 8),local_a0);

+      local_d8 = CONCAT44(local_d8._4_4_,1);

+      local_58 = 8;

+      local_48 = 4;

+      local_c8 = (ulonglong)*(uint *)(lVar15 + 8);

+      local_60 = &local_c8;

+      local_50 = &local_d8;

+      local_108 = local_70;

+      McGenEventWrite_EventWriteTransfer

+                (&Microsoft_Windows_Dwm_Core_Provider_Context,

+                 &EVTDESC_ETWGUID_DIRECTFLIP_TRANSITIONEVENT);

+    }

+  }

+  lVar15 = *(longlong *)(this + 0x4c28);

+  if (lVar15 == 0) {

+    plVar14 = *(longlong **)(this + 0x3188);

+    local_d0 = (*(longlong *)(this + 0x3190) - (longlong)plVar14 >> 3) * 0x7d6343eb1a1f58d1;

+    uVar8 = (uint)local_d0;

+    uVar20 = uVar13;

+    uVar17 = uVar13;

+    if ((this[0x4a90] == (COverlayContext)0x0) && (uVar8 == 1)) {

+      if ((*(char *)((longlong)plVar14 + 0x16c) == '\0') &&

+         ((((CCommonRegistryData::m_dwOverlayTestMode == 5 || (*(uint *)(*plVar14 + 0x28) < 2)) &&

+           ((int)plVar14[0x2d] == 2)) &&

+          ((*(int *)((longlong)plVar14 + 0xec) <= *(int *)((longlong)plVar14 + 0xe4) ||

+           ((int)plVar14[0x1e] <= (int)plVar14[0x1d])))))) {

+        local_e4 = 0;

+      }

+    }

+    else if (uVar8 == 0) goto LAB_7;

+    do {

+      iVar7 = (**(code **)(**(longlong **)(*(longlong *)(this + 0x3188) + 0x10 + uVar13) + 0x170))()

+      ;

+      bVar5 = false;

+      local_d8 = CONCAT44(local_d8._4_4_,iVar7);

+      lVar15 = *(longlong *)(this + 0x3188) + uVar13;

+      bVar6 = *(bool *)(lVar15 + 0x16d);

+      if ((*(int *)(lVar15 + 0x178) != local_e4 + (int)uVar20) ||

+         ((*(char *)(lVar15 + 0x16f) != '\0' && ((iVar7 < 3 || (*(char *)(lVar15 + 0x170) == '\0')))

+          ))) {

+        bVar5 = true;

+      }

+      if ((((bVar6 == false) || (bVar5)) || (iVar7 == -1)) ||

+         (((this[0x4c75] == (COverlayContext)0x0 ||

+           (cVar4 = (**(code **)(**(longlong **)(*(longlong *)(this + 0x3188) + 0x10 + uVar13) +

+                                0x78))(), cVar4 == '\0')) ||

+          (CCommonRegistryData::m_fDisableIndependentFlip != 0)))) {

+        EnsureIndependentFlipState

+                  (this,(OverlayPlaneInfo *)(*(longlong *)(this + 0x3188) + uVar17),false);

+        if (!bVar5) goto LAB_8;

+LAB_9:

+        *(undefined1 *)(*(longlong *)(this + 0x3188) + 0x172 + uVar13) = 1;

+      }

+      else {

+        EnsureIndependentFlipState

+                  (this,(OverlayPlaneInfo *)(*(longlong *)(this + 0x3188) + uVar17),bVar6);

+        if ((int)local_d8 < 3) {

+LAB_8:

+          lVar15 = *(longlong *)(this + 0x3188);

+          iVar7 = (**(code **)(**(longlong **)(lVar15 + 0x10 + uVar13) + 0x140))();

+          if (*(int *)(lVar15 + 0x180 + uVar13) != iVar7) goto LAB_9;

+        }

+      }

+      uVar21 = (int)uVar20 + 1;

+      uVar13 = uVar13 + 0x188;

+      param_2 = local_c0;

+      uVar20 = (ulonglong)uVar21;

+      uVar17 = uVar17 + 0x188;

+    } while (uVar21 < uVar8);

+  }

+  else {

+    if (local_e8 != '\0') {

+      iVar7 = *(int *)(this + 0x4bec);

+      *(int *)(lVar15 + 0x34) = iVar7;

+      if (iVar7 < 3) {

+        plVar14 = *(longlong **)(lVar15 + 0x28);

+        *(undefined8 *)(lVar15 + 0x28) = 0;

+        *(undefined8 *)(lVar15 + 0x20) = 0;

+      }

+      else {

+        if (*(longlong *)(this + 0x4be0) != 0) {

+          LOCK();

+          piVar16 = (int *)(*(longlong *)(this + 0x4be0) + 8);

+          *piVar16 = *piVar16 + 1;

+          UNLOCK();

+        }

+        uVar19 = *(undefined8 *)(this + 0x4be0);

+        plVar14 = *(longlong **)(lVar15 + 0x28);

+        *(undefined8 *)(lVar15 + 0x20) = *(undefined8 *)(this + 0x4bd8);

+        *(undefined8 *)(lVar15 + 0x28) = uVar19;

+      }

+      if (plVar14 != (longlong *)0x0) {

+        LOCK();

+        plVar3 = plVar14 + 1;

+        lVar15 = *plVar3;

+        *(int *)plVar3 = (int)*plVar3 + -1;

+        UNLOCK();

+        if ((int)lVar15 == 1) {

+          (**(code **)*plVar14)(plVar14);

+          LOCK();

+          piVar16 = (int *)((longlong)plVar14 + 0xc);

+          iVar7 = *piVar16;

+          *piVar16 = *piVar16 + -1;

+          UNLOCK();

+          if (iVar7 == 1) {

+            (**(code **)(*plVar14 + 8))(plVar14);

+          }

+        }

+      }

+    }

+    if ((2 < *(int *)(*(longlong *)(this + 0x4c28) + 0x34)) && (local_e7 == '\0')) {

+      (**(code **)(*(longlong *)(*(longlong *)this + 8) + 0x30))();

+    }

+    lVar9 = CDirectFlipInfo::Activate(*(CDirectFlipInfo **)(this + 0x4c28));

+    pCVar1 = *(CDirectFlipInfo **)(this + 0x4c28);

+    if (lVar9 < 0) {

+      if (pCVar1 != (CDirectFlipInfo *)0x0) {

+        if (*(int *)(pCVar1 + 0x34) != 1) {

+          (**(code **)(**(longlong **)(pCVar1 + 0x10) + 0x1e8))(*(longlong **)(pCVar1 + 0x10),1,0);

+        }

+        pCVar1 = *(CDirectFlipInfo **)(this + 0x4c28);

+        if (pCVar1 != (CDirectFlipInfo *)0x0) {

+          CDirectFlipInfo::Reset(pCVar1);

+          plVar14 = *(longlong **)(pCVar1 + 0x28);

+          if (plVar14 != (longlong *)0x0) {

+            LOCK();

+            plVar3 = plVar14 + 1;

+            lVar15 = *plVar3;

+            *(int *)plVar3 = (int)*plVar3 + -1;

+            UNLOCK();

+            if ((int)lVar15 == 1) {

+              (**(code **)*plVar14)(plVar14);

+              LOCK();

+              piVar16 = (int *)((longlong)plVar14 + 0xc);

+              iVar7 = *piVar16;

+              *piVar16 = *piVar16 + -1;

+              UNLOCK();

+              if (iVar7 == 1) {

+                (**(code **)(*plVar14 + 8))(plVar14);

+              }

+            }

+          }

+          if (*(longlong **)(pCVar1 + 0x10) != (longlong *)0x0) {

+            (**(code **)(**(longlong **)(pCVar1 + 0x10) + 0x10))();

+          }

+          operator_delete__(pCVar1,0x70);

+        }

+        *(undefined8 *)(this + 0x4c28) = 0;

+        if ((Microsoft_Windows_Dwm_CoreEnableBits._1_1_ & 2) != 0) {

+          lVar15 = (**(code **)(*(longlong *)(*(longlong *)this + 8) + 0x18))

+                             ((longlong *)(*(longlong *)this + 8),&local_88);

+          McTemplateU0xq_EventWriteTransfer

+                    (extraout_XMM0_Qa_00,&EVTDESC_ETWGUID_DIRECTFLIP_TRANSITIONEVENT,

+                     *(undefined4 *)(lVar15 + 8),0);

+        }

+        (**(code **)(*(longlong *)(*(longlong *)this + 8) + 0x30))();

+      }

+    }

+    else {

+      bVar6 = CDirectFlipInfo::RenderingRealizationChanged(pCVar1);

+      if ((bVar6) &&

+         (pCVar1 = *(CDirectFlipInfo **)(this + 0x4c28), pCVar1 != (CDirectFlipInfo *)0x0)) {

+        if (*(int *)(pCVar1 + 0x34) == 4) {

+          CDirectFlipInfo::RenderingRealizationChanged(pCVar1);

+        }

+        else if (*(int *)(pCVar1 + 0x34) == 1) {

+          (**(code **)(*(longlong *)(*(longlong *)this + 8) + 0x30))();

+        }

+      }

+    }

+  }

+LAB_7:

+  CDirectFlipInfo::Reset((CDirectFlipInfo *)(this + 0x4bb8));

+  bVar6 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>::

+          __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor> *)

+                              &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DesktopDWMCursor>::GetImpl(void)'

+                               ::__l2::impl);

+  if ((bVar6) && (*(longlong *)(this + 0x4b18) != 0)) {

+    if (((this[0x4c77] != (COverlayContext)0x0) &&

+        (((this[0x4c6f] == (COverlayContext)0x0 &&

+          (lVar15 = *(longlong *)(*(longlong *)(this + 0x4b18) + 0x2c8), lVar15 != 0)) &&

+         (*(longlong *)(lVar15 + 0xb8) != 0)))) && (*(char *)(lVar15 + 0x59) != '\0')) {

+      if ((*(longlong *)(this + 0x3190) - *(longlong *)(this + 0x3188) >> 3) * 0x7d6343eb1a1f58d1 ==

+          0) {

+        bVar6 = true;

+      }

+      else {

+        bVar6 = *(int *)(*(longlong *)(this + 0x3188) + 0x178) == 0;

+      }

+      UpdateHardwareCursor(this,bVar6);

+    }

+    CVar10 = GetCursorVisibility(this);

+    if (((CVar10 != 2) &&

+        ((*(float *)(this + 0x4b78) < *(float *)(this + 0x4b70) ||

+          *(float *)(this + 0x4b78) == *(float *)(this + 0x4b70) ||

+         (*(float *)(this + 0x4b7c) < *(float *)(this + 0x4b74) ||

+          *(float *)(this + 0x4b7c) == *(float *)(this + 0x4b74))))) &&

+       (pCVar2 = *(CursorVisualData **)(this + 0x4b18), pCVar2[0x2f1] == (CursorVisualData)0x0)) {

+      plVar14 = *(longlong **)(param_2 + 8);

+      if (plVar14 == *(longlong **)(param_2 + 0x10)) {

+        lVar15 = (longlong)plVar14 - *(longlong *)param_2 >> 3;

+        if (lVar15 == 0x1fffffffffffffff) {

+LAB_0:

+                    /* WARNING: Subroutine does not return */

+          std::

+          vector<CursorVisualData_const*___ptr64,std::allocator<CursorVisualData_const*___ptr64>_>::

+          _Xlength();

+        }

+        uVar13 = lVar15 + 1;

+        uVar20 = (longlong)*(longlong **)(param_2 + 0x10) - *(longlong *)param_2 >> 3;

+        if (0x1fffffffffffffff - (uVar20 >> 1) < uVar20) {

+          uVar17 = 0x1fffffffffffffff;

+        }

+        else {

+          uVar20 = (uVar20 >> 1) + uVar20;

+          uVar17 = uVar13;

+          if (uVar13 <= uVar20) {

+            uVar17 = uVar20;

+          }

+          if (0x1fffffffffffffff < uVar17) {

+LAB_1:

+                    /* WARNING: Subroutine does not return */

+            std::_Throw_bad_array_new_length();

+          }

+        }

+        ppCVar11 = std::_Allocate<16,std::_Default_allocate_traits,0>(uVar17 * 8);

+        ppCVar11[lVar15] = pCVar2;

+        plVar3 = *(longlong **)param_2;

+        if (plVar14 == *(longlong **)(param_2 + 8)) {

+          sVar18 = (longlong)*(longlong **)(param_2 + 8) - (longlong)plVar3;

+          _Dst = ppCVar11;

+          plVar14 = plVar3;

+        }

+        else {

+          memmove(ppCVar11,plVar3,(longlong)plVar14 - (longlong)plVar3);

+          sVar18 = *(longlong *)(param_2 + 8) - (longlong)plVar14;

+          _Dst = ppCVar11 + lVar15 + 1;

+        }

+        memmove(_Dst,plVar14,sVar18);

+        std::

+        vector<CursorVisualData_const*___ptr64,std::allocator<CursorVisualData_const*___ptr64>_>::

+        _Change_array((vector<CursorVisualData_const*___ptr64,std::allocator<CursorVisualData_const*___ptr64>_>

+                       *)param_2,ppCVar11,uVar13,uVar17);

+      }

+      else {

+        *plVar14 = (longlong)pCVar2;

+        *(longlong *)(param_2 + 8) = *(longlong *)(param_2 + 8) + 8;

+      }

+    }

+  }

+  return;

+}

+
```

## `CColorBrush::GetProperty`  (modified)

```diff
--- CColorBrush::GetProperty
+++ CColorBrush::GetProperty
@@ -1,2 +1,106 @@
-Failed to decompile dwmcore.dll - .ProgramDB CColorBrush::GetProperty : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: virtual long __cdecl CColorBrush::GetProperty(unsigned int,class CExpressionValue *

+   __ptr64) __ptr64 */

+

+long __thiscall CColorBrush::GetProperty(CColorBrush *this,uint param_1,CExpressionValue *param_2)

+

+{

+  undefined8 *puVar1;

+  int *piVar2;

+  longlong lVar3;

+  undefined8 uVar4;

+  undefined4 in_register_00000014;

+  AnimatedProperty **ppAVar5;

+  undefined8 unaff_retaddr;

+  longlong local_18;

+  undefined8 *local_10;

+  

+  ppAVar5 = (AnimatedProperty **)CONCAT44(in_register_00000014,param_1);

+  gsl::span<AnimationHelper::AnimatedProperty_const*___ptr64_const,-1>::

+  span<AnimationHelper::AnimatedProperty_const*___ptr64_const,_1><5,0>

+            ((span<AnimationHelper::AnimatedProperty_const*___ptr64_const,_1> *)&local_18,ppAVar5);

+  puVar1 = local_10 + local_18;

+  do {

+    if (local_10 == puVar1) {

+LAB_0:

+      MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,-0x7ff8ffa9,0x29,(void *)0x0);

+      return -0x7ff8ffa9;

+    }

+    piVar2 = (int *)*local_10;

+    if ((int)ppAVar5 == *piVar2) {

+      if (piVar2 != (int *)0x0) {

+        lVar3 = *(longlong *)(piVar2 + 2);

+        if (piVar2[1] != 0x23) {

+          switch(piVar2[1]) {

+          case 0x11:

+            *param_2 = (CExpressionValue)this[lVar3];

+            *(undefined4 *)(param_2 + 0x48) = 0x11;

+            return 0;

+          case 0x12:

+            *(undefined4 *)param_2 = *(undefined4 *)(this + lVar3);

+            *(undefined4 *)(param_2 + 0x48) = 0x12;

+            return 0;

+          default:

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x80070057,unaff_retaddr);

+          case 0x2a:

+            *(undefined4 *)(param_2 + 0x48) = 0x2a;

+            *(undefined4 *)param_2 = *(undefined4 *)(this + lVar3);

+            return 0;

+          case 0x34:

+            *(undefined4 *)(param_2 + 0x48) = 0x34;

+            *(undefined8 *)param_2 = *(undefined8 *)(this + lVar3);

+            *(undefined4 *)(param_2 + 8) = *(undefined4 *)(this + lVar3 + 8);

+            return 0;

+          case 0x45:

+            *(undefined4 *)(param_2 + 0x48) = 0x45;

+            uVar4 = *(undefined8 *)(this + lVar3 + 8);

+            *(undefined8 *)param_2 = *(undefined8 *)(this + lVar3);

+            *(undefined8 *)(param_2 + 8) = uVar4;

+            return 0;

+          case 0x46:

+            *(undefined4 *)(param_2 + 0x48) = 0x46;

+            uVar4 = *(undefined8 *)(this + lVar3 + 8);

+            *(undefined8 *)param_2 = *(undefined8 *)(this + lVar3);

+            *(undefined8 *)(param_2 + 8) = uVar4;

+            return 0;

+          case 0x47:

+            *(undefined4 *)(param_2 + 0x48) = 0x47;

+            uVar4 = *(undefined8 *)(this + lVar3 + 8);

+            *(undefined8 *)param_2 = *(undefined8 *)(this + lVar3);

+            *(undefined8 *)(param_2 + 8) = uVar4;

+            return 0;

+          case 0x68:

+            *(undefined4 *)(param_2 + 0x48) = 0x68;

+            uVar4 = *(undefined8 *)(this + lVar3 + 8);

+            *(undefined8 *)param_2 = *(undefined8 *)(this + lVar3);

+            *(undefined8 *)(param_2 + 8) = uVar4;

+            *(undefined8 *)(param_2 + 0x10) = *(undefined8 *)(this + lVar3 + 0x10);

+            return 0;

+          case 0x109:

+            *(undefined4 *)(param_2 + 0x48) = 0x109;

+            uVar4 = *(undefined8 *)(this + lVar3 + 8);

+            *(undefined8 *)param_2 = *(undefined8 *)(this + lVar3);

+            *(undefined8 *)(param_2 + 8) = uVar4;

+            uVar4 = *(undefined8 *)(this + lVar3 + 0x10 + 8);

+            *(undefined8 *)(param_2 + 0x10) = *(undefined8 *)(this + lVar3 + 0x10);

+            *(undefined8 *)(param_2 + 0x18) = uVar4;

+            uVar4 = *(undefined8 *)(this + lVar3 + 0x20 + 8);

+            *(undefined8 *)(param_2 + 0x20) = *(undefined8 *)(this + lVar3 + 0x20);

+            *(undefined8 *)(param_2 + 0x28) = uVar4;

+            uVar4 = *(undefined8 *)(this + lVar3 + 0x30 + 8);

+            *(undefined8 *)(param_2 + 0x30) = *(undefined8 *)(this + lVar3 + 0x30);

+            *(undefined8 *)(param_2 + 0x38) = uVar4;

+            return 0;

+          }

+        }

+        *(undefined4 *)(param_2 + 0x48) = 0x23;

+        *(undefined8 *)param_2 = *(undefined8 *)(this + lVar3);

+        return 0;

+      }

+      goto LAB_0;

+    }

+    local_10 = local_10 + 1;

+  } while( true );

+}

+
```

## `CComposition::GetCursorVisuals`  (modified)

```diff
--- CComposition::GetCursorVisuals
+++ CComposition::GetCursorVisuals
@@ -1,2 +1,45 @@
-Failed to decompile dwmcore.dll - .ProgramDB CComposition::GetCursorVisuals : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: class gsl::span<struct CursorVisualData const ,-1> const __cdecl

+   CComposition::GetCursorVisuals(void) __ptr64 */

+

+void __thiscall CComposition::GetCursorVisuals(CComposition *this)

+

+{

+  CExcludeVisualReference *pCVar1;

+  longlong lVar2;

+  CVisual *pCVar3;

+  longlong *plVar4;

+  longlong *in_RDX;

+  CExcludeVisualReference *this_00;

+  extent_type<_1> local_res8 [8];

+  __uint64 local_28 [2];

+  

+  this_00 = *(CExcludeVisualReference **)(this + 0x1828);

+  while (pCVar1 = *(CExcludeVisualReference **)(this + 0x1820), this_00 != pCVar1) {

+    this_00 = this_00 + -0x30;

+    pCVar3 = CExcludeVisualReference::GetVisualNoRef(this_00);

+    if (pCVar3 == (CVisual *)0x0) {

+      std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::erase

+                ((vector<CursorVisualData,std::allocator<CursorVisualData>_> *)(this + 0x1820),

+                 local_res8,this_00);

+    }

+  }

+  gsl::details::extent_type<-1>::extent_type<_1>

+            ((extent_type<_1> *)local_28,

+             (*(longlong *)(this + 0x1828) - (longlong)pCVar1 >> 4) * -0x5555555555555555);

+  if ((local_28[0] != 0xffffffffffffffff) &&

+     ((pCVar1 != (CExcludeVisualReference *)0x0 || (local_28[0] == 0)))) {

+    plVar4 = (longlong *)gsl::details::extent_type<-1>::extent_type<_1>(local_res8,local_28[0]);

+    lVar2 = *plVar4;

+    *in_RDX = lVar2;

+    in_RDX[1] = (longlong)pCVar1;

+    if ((lVar2 != -1) && ((pCVar1 != (CExcludeVisualReference *)0x0 || (lVar2 == 0)))) {

+      return;

+    }

+                    /* WARNING: Subroutine does not return */

+    gsl::details::terminate();

+  }

+                    /* WARNING: Subroutine does not return */

+  gsl::details::terminate();

+}

+
```

## `std::_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>::_Copy_nodes<0>`  (modified)

```diff
--- std::_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>::_Copy_nodes<0>
+++ std::_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>::_Copy_nodes<0>
@@ -1,21 +1,66 @@
+

+/* protected: struct std::_Tree_node<struct std::pair<struct D2D_VECTOR_2F const ,struct

+   CConvexPolygonEdgeMap<unsigned int>::EdgeData>,void * __ptr64> * __ptr64 __cdecl std::_Tree<class

+   std::_Tmap_traits<struct D2D_VECTOR_2F const ,struct CConvexPolygonEdgeMap<unsigned

+   int>::EdgeData,struct CConvexPolygonEdgeMap<unsigned int>::CompareEdgeDirection,class

+   std::allocator<struct std::pair<struct D2D_VECTOR_2F const ,struct CConvexPolygonEdgeMap<unsigned

+   int>::EdgeData> >,0> >::_Copy_nodes<0>(struct std::_Tree_node<struct std::pair<struct

+   D2D_VECTOR_2F const ,struct CConvexPolygonEdgeMap<unsigned int>::EdgeData>,void * __ptr64> *

+   __ptr64,struct std::_Tree_node<struct std::pair<struct D2D_VECTOR_2F const ,struct

+   CConvexPolygonEdgeMap<unsigned int>::EdgeData>,void * __ptr64> * __ptr64) __ptr64 */

 

 _Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

 * __thiscall

-CWatermarkStack<float,2,2,10>::_Copy_nodes<0>

-          (_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>

-           *this,_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

-                 *param_1,

-          _Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

-          *param_2)

+std::

+_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>

+::_Copy_nodes<0>(_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>

+                 *this,_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+                       *param_1,

+                _Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+                *param_2)

 

 {

-  code *pcVar1;

+  undefined8 uVar1;

+  _Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+  *p_Var2;

   _Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

-  *p_Var2;

+  *p_Var3;

+  _Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+  *p_Var4;

   

-  pcVar1 = (code *)swi(3);

-  p_Var2 = (_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

-            *)(*pcVar1)();

-  return p_Var2;

+  p_Var4 = *(_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+             **)this;

+  if (param_1[0x19] ==

+      (_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+       )0x0) {

+    p_Var2 = _Allocate<16,std::_Default_allocate_traits,0>(0x30);

+    uVar1 = *(undefined8 *)(param_1 + 0x24);

+    *(undefined8 *)(p_Var2 + 0x1c) = *(undefined8 *)(param_1 + 0x1c);

+    *(undefined8 *)(p_Var2 + 0x24) = uVar1;

+    *(undefined4 *)(p_Var2 + 0x2c) = *(undefined4 *)(param_1 + 0x2c);

+    *(_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+      **)p_Var2 = p_Var4;

+    *(_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+      **)(p_Var2 + 0x10) = p_Var4;

+    *(undefined2 *)(p_Var2 + 0x18) = 0;

+    *(_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+      **)(p_Var2 + 8) = param_2;

+    p_Var2[0x18] = param_1[0x18];

+    if (p_Var4[0x19] !=

+        (_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+         )0x0) {

+      p_Var4 = (_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+                *)p_Var2;

+    }

+    p_Var3 = _Copy_nodes<0>(this,*(_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+                                   **)param_1,p_Var2);

+    *(_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+      **)p_Var2 = p_Var3;

+    p_Var3 = _Copy_nodes<0>(this,*(_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+                                   **)(param_1 + 0x10),p_Var2);

+    *(_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+      **)(p_Var2 + 0x10) = p_Var3;

+  }

+  return p_Var4;

 }
```

## `CDDisplaySwapChain::CheckMultiplaneOverlaySupport`  (modified)

```diff
--- CDDisplaySwapChain::CheckMultiplaneOverlaySupport
+++ CDDisplaySwapChain::CheckMultiplaneOverlaySupport
@@ -1,2 +1,208 @@
-Failed to decompile dwmcore.dll - .ProgramDB CDDisplaySwapChain::CheckMultiplaneOverlaySupport : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: virtual bool __cdecl CDDisplaySwapChain::CheckMultiplaneOverlaySupport(struct

+   DWM_CHECK_MULTIPLANE_OVERLAY_SUPPORT_PLANE_INFO const * __ptr64,unsigned int,bool * __ptr64)const

+   __ptr64 */

+

+bool __thiscall

+CDDisplaySwapChain::CheckMultiplaneOverlaySupport

+          (CDDisplaySwapChain *this,DWM_CHECK_MULTIPLANE_OVERLAY_SUPPORT_PLANE_INFO *param_1,

+          uint param_2,bool *param_3)

+

+{

+  code *pcVar1;

+  CDDisplaySwapChain *pCVar2;

+  bool bVar3;

+  long lVar4;

+  undefined1 uVar5;

+  DWM_CHECK_MULTIPLANE_OVERLAY_SUPPORT_PLANE_INFO *pDVar6;

+  DWM_CHECK_MULTIPLANE_OVERLAY_SUPPORT_PLANE_INFO *pDVar7;

+  undefined1 auStackY_188 [32];

+  uint uVar8;

+  bool local_118;

+  char local_117;

+  undefined4 local_114;

+  int local_110;

+  uint local_10c;

+  int local_108;

+  longlong *local_100;

+  CDDisplaySwapChain *local_f8 [2];

+  int local_e8;

+  int local_e4;

+  int local_e0;

+  int local_dc;

+  int local_d8;

+  int local_d4;

+  int local_d0;

+  int local_cc;

+  int local_c8;

+  int local_c4;

+  int local_c0;

+  int local_bc;

+  int local_b8;

+  int local_b4;

+  int local_b0;

+  int local_ac;

+  int local_a8;

+  int local_a4;

+  int local_a0;

+  int local_9c;

+  longlong local_98;

+  code *local_90;

+  undefined8 uStack_88;

+  DWM_CHECK_MULTIPLANE_OVERLAY_SUPPORT_PLANE_INFO *local_80;

+  CDDisplaySwapChain *local_78;

+  bool *local_70;

+  undefined8 local_68;

+  undefined8 local_60;

+  undefined8 uStack_58;

+  ulonglong local_50;

+  

+  local_50 = __security_cookie ^ (ulonglong)auStackY_188;

+  *param_3 = false;

+  local_100 = (longlong *)0x0;

+  local_118 = false;

+  local_68 = 0;

+  local_f8[0] = (CDDisplaySwapChain *)0x0;

+  local_80 = param_1;

+  local_78 = this;

+  local_70 = param_3;

+  lVar4 = (**(code **)(**(longlong **)(this + 0x170) + 0x30))();

+  if (lVar4 < 0) {

+    uVar8 = 0x150;

+  }

+  else {

+    bVar3 = CD3DDevice::CheckMPOCache(*(CD3DDevice **)(this + 0x28),param_1,param_2,&local_118);

+    uVar5 = local_118;

+    if (bVar3) goto LAB_0;

+    local_10c = 0;

+    if (param_2 != 0) {

+      pDVar7 = param_1 + 0x34;

+      do {

+        local_114 = 0;

+        local_98 = (**(code **)(**(longlong **)(pDVar7 + -0x2c) + 0x30))

+                             (*(longlong **)(pDVar7 + -0x2c),&local_114);

+        uVar5 = 0;

+        if (local_98 == 0) goto LAB_0;

+        if ((*(int *)(pDVar7 + -0x34) == 0) && (((byte)pDVar7[-0x1c] & 4) != 0)) {

+          pDVar6 = pDVar7 + -0x18;

+          local_110 = 2;

+          local_60 = *(undefined8 *)pDVar6;

+          uStack_58 = *(undefined8 *)(pDVar7 + -0x10);

+        }

+        else {

+          local_60 = *(undefined8 *)(pDVar7 + 8);

+          uStack_58 = *(undefined8 *)(pDVar7 + 0x10);

+          local_110 = 1;

+          pDVar6 = pDVar7 + -8;

+          local_90 = *(code **)pDVar6;

+          uStack_88 = *(undefined8 *)pDVar7;

+          TMilRect<int,tagRECT,D2D_POINTANDSIZE_L,RectUniqueness::_CMilRectL_>::IntersectUnsafe

+                    ((TMilRect<int,tagRECT,D2D_POINTANDSIZE_L,RectUniqueness::_CMilRectL_> *)

+                     &local_60,

+                     (TMilRect<int,struct_tagRECT,struct_D2D_POINTANDSIZE_L,struct_RectUniqueness::_CMilRectL_>

+                      *)&local_90);

+        }

+        local_90 = *(code **)(*(longlong *)local_f8[0] + 0x30);

+        GetDisplayRotationFromDxgiRotation(local_f8[0],*(DXGI_MODE_ROTATION *)(pDVar7 + 0x18));

+        local_d8 = *(int *)pDVar6;

+        local_d4 = *(int *)(pDVar6 + 4);

+        local_c8 = *(int *)(pDVar7 + -0x18);

+        local_c4 = *(int *)(pDVar7 + -0x14);

+        local_e0 = (int)uStack_58 - (int)local_60;

+        local_e8 = (int)local_60;

+        local_dc = uStack_58._4_4_ - local_60._4_4_;

+        local_e4 = local_60._4_4_;

+        local_d0 = *(int *)(pDVar6 + 8) - local_d8;

+        local_cc = *(int *)(pDVar6 + 0xc) - local_d4;

+        local_c0 = *(int *)(pDVar7 + -0x10) - local_c8;

+        local_bc = *(int *)(pDVar7 + -0xc) - local_c4;

+        lVar4 = (*local_90)();

+        if (lVar4 < 0) {

+          uVar8 = 0x187;

+          goto LAB_1;

+        }

+        if (local_110 == 2) {

+          local_b8 = *(int *)(pDVar7 + -8);

+          local_b4 = *(int *)(pDVar7 + -4);

+          local_a8 = *(int *)(pDVar7 + -0x18);

+          local_a4 = *(int *)(pDVar7 + -0x14);

+          local_b0 = *(int *)pDVar7 - local_b8;

+          local_ac = *(int *)(pDVar7 + 4) - local_b4;

+          local_a0 = *(int *)(pDVar7 + -0x10) - local_a8;

+          local_9c = *(int *)(pDVar7 + -0xc) - local_a4;

+          lVar4 = (**(code **)(*(longlong *)local_f8[0] + 0x38))

+                            (local_f8[0],*(undefined8 *)(pDVar7 + 0x54),0,&local_a8);

+          if (lVar4 < 0) {

+            uVar8 = 0x194;

+            goto LAB_1;

+          }

+        }

+        local_10c = local_10c + 1;

+        pDVar7 = pDVar7 + 0x90;

+        param_1 = local_80;

+        param_3 = local_70;

+        this = local_78;

+      } while (local_10c < param_2);

+    }

+    pCVar2 = local_f8[0];

+    pcVar1 = *(code **)(*(longlong *)local_f8[0] + 0x40);

+    if (local_100 != (longlong *)0x0) {

+      (**(code **)(*local_100 + 0x10))();

+    }

+    lVar4 = (*pcVar1)(pCVar2);

+    if (lVar4 < 0) {

+      uVar8 = 0x199;

+    }

+    else {

+      local_117 = '\0';

+      lVar4 = (**(code **)(*local_100 + 0x40))();

+      if (lVar4 < 0) {

+        uVar8 = 0x19d;

+      }

+      else {

+        local_108 = 0;

+        *param_3 = local_117 != '\0';

+        lVar4 = (**(code **)(*local_100 + 0x30))();

+        if (-1 < lVar4) {

+          if (local_108 == 1) {

+            local_118 = true;

+          }

+          uVar5 = local_118;

+          if (*param_3 == false) {

+            CD3DDevice::AddCheckMPOCache(*(CD3DDevice **)(this + 0x28),param_1,param_2,local_118);

+            uVar5 = local_118;

+          }

+          goto LAB_0;

+        }

+        uVar8 = 0x1a2;

+      }

+    }

+  }

+LAB_1:

+  MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar4,uVar8,(void *)0x0);

+  uVar5 = local_118;

+LAB_0:

+  wil::

+  com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+  ::

+  ~com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+            ((com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+              *)&local_100);

+  wil::

+  com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+  ::

+  ~com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+            ((com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+              *)&local_68);

+  wil::

+  com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+  ::

+  ~com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+            ((com_ptr_t<Windows::Devices::Display::Core::IScanoutFactoryLockResultExtended,wil::err_returncode_policy>

+              *)local_f8);

+  return (bool)uVar5;

+}

+
```

## `CursorVisualData::CursorVisualData`  (modified)

```diff
--- CursorVisualData::CursorVisualData
+++ CursorVisualData::CursorVisualData
@@ -1,49 +1,28 @@
 

-void __thiscall

-std::default_delete<CSuperWetInkManager>::CursorVisualData

-          (CursorVisualData *this,CursorVisualData *param_1)

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: __cdecl CursorVisualData::CursorVisualData(struct CursorVisualData && __ptr64) __ptr64 */

+

+CursorVisualData * __thiscall

+CursorVisualData::CursorVisualData(CursorVisualData *this,CursorVisualData *param_1)

 

 {

-  bool bVar1;

-  bool bVar2;

-  uint in_EAX;

-  ReportingKind RVar3;

-  ReportingKind RVar4;

-  ReportingKind *unaff_RBX;

-  uint in_R8D;

-  uint in_R9D;

+  longlong *plVar1;

+  undefined8 uVar2;

   

-  RVar4 = -(uint)((in_EAX & 0x40) != 0) & 0x800 | -(uint)((in_R8D & 0x80) != 0) & 0x400 |

-          (in_R9D & 3) << 7;

-  if ((in_R9D & 0xffffff3f) != 0) {

-    RVar3 = 0;

-    if ((in_R9D & 0xffffff3f) == 2) {

-      RVar3 = 0x40;

-    }

-    RVar4 = RVar4 | RVar3;

+  *(undefined ***)this = &CExcludeVisualReference::_vftable_;

+  plVar1 = *(longlong **)(param_1 + 8);

+  *(longlong **)(this + 8) = plVar1;

+  if (plVar1 != (longlong *)0x0) {

+    (**(code **)(*plVar1 + 8))();

   }

-  *unaff_RBX = RVar4;

-  bVar2 = false;

-  RVar3 = 1;

-  if ((RVar4 & 0xc00) == 0xc00) {

-    bVar1 = true;

-  }

-  else {

-    bVar1 = false;

-    if ((RVar4 & 0x40) == 0) goto LAB_0;

-  }

-  bVar2 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_Standalone_Future>::

-          __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_Standalone_Future> *)

-                              &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_Standalone_Future>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_Standalone_Future>::GetImpl(void)'

-                               ::__l2::impl,RVar4);

-  if ((bVar1) && (!bVar2)) {

-    *unaff_RBX = *unaff_RBX & 0xfffffbff;

-  }

-LAB_0:

-  if (((*unaff_RBX & 0x40) == 0) || (bVar2 == false)) {

-    RVar3 = 0;

-  }

-  *unaff_RBX = *unaff_RBX & 0xfffffffe | RVar3;

-  return;

+  *(undefined4 *)(this + 0x10) = *(undefined4 *)(param_1 + 0x10);

+  this[0x14] = param_1[0x14];

+  uVar2 = *(undefined8 *)(param_1 + 0x18);

+  *(undefined8 *)(param_1 + 0x18) = 0;

+  *(undefined8 *)(this + 0x18) = uVar2;

+  *(undefined8 *)(this + 0x20) = *(undefined8 *)(param_1 + 0x20);

+  *(undefined4 *)(this + 0x28) = *(undefined4 *)(param_1 + 0x28);

+  return this;

 }
```

## `std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::~vector<CursorVisualData,std::allocator<CursorVisualData>_>`  (modified)

```diff
--- std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::~vector<CursorVisualData,std::allocator<CursorVisualData>_>
+++ std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::~vector<CursorVisualData,std::allocator<CursorVisualData>_>
@@ -1,2 +1,24 @@
-Failed to decompile dwmcore.dll - .ProgramDB std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::~vector<CursorVisualData,std::allocator<CursorVisualData>_> : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: __cdecl std::vector<struct CursorVisualData,class std::allocator<struct CursorVisualData>

+   >::~vector<struct CursorVisualData,class std::allocator<struct CursorVisualData> >(void) __ptr64

+    */

+

+void __thiscall

+std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::

+~vector<CursorVisualData,std::allocator<CursorVisualData>_>

+          (vector<CursorVisualData,std::allocator<CursorVisualData>_> *this)

+

+{

+  allocator<CursorVisualData> *in_R8;

+  

+  if (*(CursorVisualData **)this != (CursorVisualData *)0x0) {

+    _Destroy_range<std::allocator<CursorVisualData>_>

+              (*(CursorVisualData **)this,*(CursorVisualData **)(this + 8),in_R8);

+    _Deallocate<16,0>(*(void **)this,(*(longlong *)(this + 0x10) - *(longlong *)this >> 4) << 4);

+    *(undefined8 *)this = 0;

+    *(undefined8 *)(this + 8) = 0;

+    *(undefined8 *)(this + 0x10) = 0;

+  }

+  return;

+}

+
```

## `COffScreenRenderTarget::ShouldRenderCursor`  (modified)

```diff
--- COffScreenRenderTarget::ShouldRenderCursor
+++ wil::details::FeatureImpl<__WilFeatureTraits_Feature_Capture_ETWRenderReporting>::GetCurrentFeatureEnabledState
@@ -1,28 +1,54 @@
 

-/* protected: virtual bool __cdecl COffScreenRenderTarget::ShouldRenderCursor(class CVisual const *

-   __ptr64)const __ptr64 */

+/* private: union wil_details_FeatureStateCache __cdecl wil::details::FeatureImpl<struct

+   __WilFeatureTraits_Feature_Capture_ETWRenderReporting>::GetCurrentFeatureEnabledState(int *

+   __ptr64) __ptr64 */

 

-bool __thiscall

-COffScreenRenderTarget::ShouldRenderCursor(COffScreenRenderTarget *this,CVisual *param_1)

+int * __thiscall

+wil::details::FeatureImpl<__WilFeatureTraits_Feature_Capture_ETWRenderReporting>::

+GetCurrentFeatureEnabledState

+          (FeatureImpl<__WilFeatureTraits_Feature_Capture_ETWRenderReporting> *this,int *param_1)

 

 {

   bool bVar1;

-  CDesktopTree *pCVar2;

-  CDesktopTree *pCVar3;

-  bool bVar4;

+  FEATURE_ENABLED_STATE FVar2;

+  uint uVar3;

+  uint uVar4;

+  uint uVar5;

+  uint uVar6;

+  int *in_R8;

+  FEATURE_ENABLED_STATE FVar7;

   

-  pCVar2 = CVisual::GetDesktopTree(*(CVisual **)(*(longlong *)(this + 0x70) + 0x48));

-  bVar4 = false;

-  if (pCVar2 != (CDesktopTree *)0x0) {

-    pCVar3 = CVisual::GetDesktopTree(param_1);

-    bVar4 = false;

-    if (pCVar3 == pCVar2) {

-      bVar1 = CVisualTree::_IsInTree(*(CVisualTree **)(this + 0x70),param_1,0);

-      if (!bVar1) {

-        bVar4 = true;

-      }

+  FVar2 = WilApi_GetFeatureEnabledState(0x3a64931,3,in_R8);

+  param_1[0] = 0;

+  param_1[1] = 0;

+  FVar7 = FVar2 & 0xffffff3f;

+  uVar4 = -(uint)((FVar2 & 0x40) != 0) & 0x800 | -(uint)((FVar2 & 0x80) != 0) & 0x400;

+  uVar5 = uVar4 | (FVar2 & 3) << 7;

+  *param_1 = uVar5;

+  if (FVar7 == 0) {

+    uVar3 = 0x40;

+  }

+  else {

+    uVar3 = 0;

+    if (FVar7 == 2) {

+      uVar3 = 0x40;

     }

   }

-  return bVar4;

+  uVar5 = uVar5 | uVar3;

+  *param_1 = uVar5;

+  bVar1 = false;

+  uVar6 = 1;

+  if ((uVar4 == 0xc00) || (uVar3 != 0)) {

+    FeatureImpl<__WilFeatureTraits_Feature_TestUex12>::ReportUsage

+              ((FeatureImpl<__WilFeatureTraits_Feature_TestUex12> *)

+               &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_TestUex12>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_TestUex12>::GetImpl(void)'

+                ::__l2::impl,SUB41(uVar5,0),0xc00,(ulonglong)FVar7);

+    bVar1 = true;

+  }

+  if (((*param_1 & 0x40U) == 0) || (!bVar1)) {

+    uVar6 = 0;

+  }

+  *param_1 = *param_1 & 0xfffffffeU | uVar6;

+  return param_1;

 }
```

## `std::move_backward<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_>`  (modified)

```diff
--- std::move_backward<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_>
+++ std::move_backward<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_>
@@ -1,2 +1,36 @@
-Failed to decompile dwmcore.dll - .ProgramDB std::move_backward<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_> : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* class stdext::checked_array_iterator<class CD3DDevice::CDelayUnpin * __ptr64> __cdecl

+   std::move_backward<class std::move_iterator<class CD3DDevice::CDelayUnpin * __ptr64>,class

+   stdext::checked_array_iterator<class CD3DDevice::CDelayUnpin * __ptr64> >(class

+   std::move_iterator<class CD3DDevice::CDelayUnpin * __ptr64>,class std::move_iterator<class

+   CD3DDevice::CDelayUnpin * __ptr64>,class stdext::checked_array_iterator<class

+   CD3DDevice::CDelayUnpin * __ptr64>) */

+

+undefined8 * __cdecl

+std::

+move_backward<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_>

+          (undefined8 *param_1,CDelayUnpin *param_2,CDelayUnpin *param_3,

+          checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64> *param_4)

+

+{

+  undefined8 uVar1;

+  undefined8 uVar2;

+  CDelayUnpin *this;

+  

+  this = (CDelayUnpin *)

+         _Get_unwrapped_n<stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>&___ptr64,__int64>

+                   (param_4,-((longlong)param_3 - (longlong)param_2 >> 6));

+  while (param_2 != param_3) {

+    this = this + -0x40;

+    param_3 = param_3 + -0x40;

+    CD3DDevice::CDelayUnpin::operator=(this,param_3);

+  }

+  *(longlong *)(param_4 + 0x10) = (longlong)this - *(longlong *)param_4 >> 6;

+  uVar2 = *(undefined8 *)(param_4 + 8);

+  uVar1 = *(undefined8 *)(param_4 + 0x10);

+  *param_1 = *(undefined8 *)param_4;

+  param_1[1] = uVar2;

+  param_1[2] = uVar1;

+  return param_1;

+}

+
```

## `CD3DDevice::CDelayUnpin::operator=`  (modified)

```diff
--- CD3DDevice::CDelayUnpin::operator=
+++ CD3DDevice::CDelayUnpin::operator=
@@ -1,2 +1,30 @@
-Failed to decompile dwmcore.dll - .ProgramDB CD3DDevice::CDelayUnpin::operator= : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: class CD3DDevice::CDelayUnpin & __ptr64 __cdecl CD3DDevice::CDelayUnpin::operator=(class

+   CD3DDevice::CDelayUnpin && __ptr64) __ptr64 */

+

+CDelayUnpin * __thiscall CD3DDevice::CDelayUnpin::operator=(CDelayUnpin *this,CDelayUnpin *param_1)

+

+{

+  undefined8 uVar1;

+  longlong *plVar2;

+  

+  if (this != param_1) {

+    uVar1 = *(undefined8 *)param_1;

+    *(undefined8 *)param_1 = 0;

+    plVar2 = *(longlong **)this;

+    *(undefined8 *)this = uVar1;

+    if (plVar2 != (longlong *)0x0) {

+      (**(code **)(*plVar2 + 0x10))();

+    }

+    detail::

+    vector_facade<CD3DDevice::CDelayUnpin::UnpinTarget,detail::buffer_impl<CD3DDevice::CDelayUnpin::UnpinTarget,2,1,detail::liberal_expansion_policy>_>

+    ::operator=((vector_facade<CD3DDevice::CDelayUnpin::UnpinTarget,detail::buffer_impl<CD3DDevice::CDelayUnpin::UnpinTarget,2,1,detail::liberal_expansion_policy>_>

+                 *)(this + 8),

+                (vector_facade<class_CD3DDevice::CDelayUnpin::UnpinTarget,class_detail::buffer_impl<class_CD3DDevice::CDelayUnpin::UnpinTarget,2,1,class_detail::liberal_expansion_policy>_>

+                 *)(param_1 + 8));

+  }

+  return this;

+}

+
```

## `CVisualSurfaceRenderStrategy::GetLayoutParameters`  (modified)

```diff
--- CVisualSurfaceRenderStrategy::GetLayoutParameters
+++ CVisualSurfaceRenderStrategy::GetLayoutParameters
@@ -1,2 +1,31 @@
-Failed to decompile dwmcore.dll - .ProgramDB CVisualSurfaceRenderStrategy::GetLayoutParameters : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: virtual long __cdecl CVisualSurfaceRenderStrategy::GetLayoutParameters(class

+   CSurfaceBrush const * __ptr64,struct D2D_SIZE_F const & __ptr64,struct D2D_SIZE_F *

+   __ptr64,struct D2D_RECT_F * __ptr64,struct D2D_MATRIX_3X2_F * __ptr64)const __ptr64 */

+

+long __thiscall

+CVisualSurfaceRenderStrategy::GetLayoutParameters

+          (CVisualSurfaceRenderStrategy *this,CSurfaceBrush *param_1,D2D_SIZE_F *param_2,

+          D2D_SIZE_F *param_3,D2D_RECT_F *param_4,D2D_MATRIX_3X2_F *param_5)

+

+{

+  float fVar1;

+  float fVar2;

+  CResource *pCVar3;

+  ulonglong uVar4;

+  

+  pCVar3 = CSurfaceBrush::GetSurface(param_1);

+  uVar4 = (ulonglong)(-(uint)(pCVar3[0xcc] != (CResource)0x0) & 8);

+  fVar1 = *(float *)(pCVar3 + uVar4 + 0xb8);

+  fVar2 = *(float *)(pCVar3 + uVar4 + 0xbc);

+  *(ulonglong *)param_3 = CONCAT44(fVar2,fVar1);

+  *(undefined8 *)param_4 = 0;

+  *(float *)(param_4 + 8) = fVar1 + 0.0;

+  *(float *)(param_4 + 0xc) = fVar2 + 0.0;

+  *(undefined8 *)param_5 = 0x3f800000;

+  *(undefined4 *)(param_5 + 8) = 0;

+  *(undefined8 *)(param_5 + 0xc) = 0x3f800000;

+  *(undefined4 *)(param_5 + 0x14) = 0;

+  return 0;

+}

+
```

## `std::_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData,CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>_>,0>_>::_Copy_nodes<0>`  (modified)

```diff
--- std::_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData,CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>_>,0>_>::_Copy_nodes<0>
+++ std::_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData,CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>_>,0>_>::_Copy_nodes<0>
@@ -1,2 +1,68 @@
-Failed to decompile dwmcore.dll - .ProgramDB std::_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData,CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>_>,0>_>::_Copy_nodes<0> : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* protected: struct std::_Tree_node<struct std::pair<struct D2D_VECTOR_2F const ,struct

+   CConvexPolygonEdgeMap<struct CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void * __ptr64> *

+   __ptr64 __cdecl std::_Tree<class std::_Tmap_traits<struct D2D_VECTOR_2F const ,struct

+   CConvexPolygonEdgeMap<struct CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData,struct

+   CConvexPolygonEdgeMap<struct CCpuClipAntialiasSink::SinkRoutingInfo>::CompareEdgeDirection,class

+   std::allocator<struct std::pair<struct D2D_VECTOR_2F const ,struct CConvexPolygonEdgeMap<struct

+   CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData> >,0> >::_Copy_nodes<0>(struct

+   std::_Tree_node<struct std::pair<struct D2D_VECTOR_2F const ,struct CConvexPolygonEdgeMap<struct

+   CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void * __ptr64> * __ptr64,struct

+   std::_Tree_node<struct std::pair<struct D2D_VECTOR_2F const ,struct CConvexPolygonEdgeMap<struct

+   CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void * __ptr64> * __ptr64) __ptr64 */

+

+_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+* __thiscall

+std::

+_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData,CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>_>,0>_>

+::_Copy_nodes<0>(_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData,CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>_>,0>_>

+                 *this,_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+                       *param_1,

+                _Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+                *param_2)

+

+{

+  undefined8 uVar1;

+  _Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+  *p_Var2;

+  _Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+  *p_Var3;

+  _Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+  *p_Var4;

+  

+  p_Var4 = *(_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+             **)this;

+  if (param_1[0x19] ==

+      (_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+       )0x0) {

+    p_Var2 = _Allocate<16,std::_Default_allocate_traits,0>(0x30);

+    uVar1 = *(undefined8 *)(param_1 + 0x24);

+    *(undefined8 *)(p_Var2 + 0x1c) = *(undefined8 *)(param_1 + 0x1c);

+    *(undefined8 *)(p_Var2 + 0x24) = uVar1;

+    *(undefined4 *)(p_Var2 + 0x2c) = *(undefined4 *)(param_1 + 0x2c);

+    *(_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+      **)p_Var2 = p_Var4;

+    *(_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+      **)(p_Var2 + 0x10) = p_Var4;

+    *(undefined2 *)(p_Var2 + 0x18) = 0;

+    *(_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+      **)(p_Var2 + 8) = param_2;

+    p_Var2[0x18] = param_1[0x18];

+    if (p_Var4[0x19] !=

+        (_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+         )0x0) {

+      p_Var4 = p_Var2;

+    }

+    p_Var3 = _Copy_nodes<0>(this,*(_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+                                   **)param_1,p_Var2);

+    *(_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+      **)p_Var2 = p_Var3;

+    p_Var3 = _Copy_nodes<0>(this,*(_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<struct_CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+                                   **)(param_1 + 0x10),p_Var2);

+    *(_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+      **)(p_Var2 + 0x10) = p_Var3;

+  }

+  return (_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<CCpuClipAntialiasSink::SinkRoutingInfo>::EdgeData>,void*___ptr64>

+          *)p_Var4;

+}

+
```

## `HANDLE_TABLE::ValidEntry`  (modified)

```diff
--- HANDLE_TABLE::ValidEntry
+++ D2D1::Matrix3x2F::SetProduct
@@ -1,2 +1,2 @@
-Failed to decompile dwmcore.dll - .ProgramDB HANDLE_TABLE::ValidEntry : Error: Decompile error: 
+Failed to decompile dwmcore.dll - .ProgramDB D2D1::Matrix3x2F::SetProduct : Error: Decompile error: 
 Marshaling error: Did not see expected closing element
```

## `std::_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>::_Emplace_hint<D2D_VECTOR_2F_const&___ptr64,CConvexPolygonEdgeMap<unsigned_int>::EdgeData&___ptr64>`  (modified)

```diff
--- std::_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>::_Emplace_hint<D2D_VECTOR_2F_const&___ptr64,CConvexPolygonEdgeMap<unsigned_int>::EdgeData&___ptr64>
+++ std::_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>::_Emplace_hint<D2D_VECTOR_2F_const&___ptr64,CConvexPolygonEdgeMap<unsigned_int>::EdgeData&___ptr64>
@@ -1,21 +1,71 @@
+

+/* protected: struct std::_Tree_node<struct std::pair<struct D2D_VECTOR_2F const ,struct

+   CConvexPolygonEdgeMap<unsigned int>::EdgeData>,void * __ptr64> * __ptr64 __cdecl std::_Tree<class

+   std::_Tmap_traits<struct D2D_VECTOR_2F const ,struct CConvexPolygonEdgeMap<unsigned

+   int>::EdgeData,struct CConvexPolygonEdgeMap<unsigned int>::CompareEdgeDirection,class

+   std::allocator<struct std::pair<struct D2D_VECTOR_2F const ,struct CConvexPolygonEdgeMap<unsigned

+   int>::EdgeData> >,0> >::_Emplace_hint<struct D2D_VECTOR_2F const & __ptr64,struct

+   CConvexPolygonEdgeMap<unsigned int>::EdgeData & __ptr64>(struct std::_Tree_node<struct

+   std::pair<struct D2D_VECTOR_2F const ,struct CConvexPolygonEdgeMap<unsigned int>::EdgeData>,void

+   * __ptr64> * __ptr64 const,struct D2D_VECTOR_2F const & __ptr64,struct

+   CConvexPolygonEdgeMap<unsigned int>::EdgeData & __ptr64) __ptr64 */

 

 _Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

 * __thiscall

-CWatermarkStack<float,2,2,10>::

-_Emplace_hint<D2D_VECTOR_2F_const&___ptr64,CConvexPolygonEdgeMap<unsigned_int>::EdgeData&___ptr64>

+std::

+_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>

+::_Emplace_hint<D2D_VECTOR_2F_const&___ptr64,CConvexPolygonEdgeMap<unsigned_int>::EdgeData&___ptr64>

           (_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>

            *this,_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

                  *param_1,D2D_VECTOR_2F *param_2,EdgeData *param_3)

 

 {

-  ulonglong unaff_RBX;

-  uint in_stack_00000020;

-  void *in_stack_00000028;

+  undefined8 uVar1;

+  undefined8 *puVar2;

+  undefined8 *puVar3;

+  _Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+  *p_Var4;

+  _Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>

+  *local_58;

+  undefined8 uStack_50;

+  _Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+  local_48 [16];

+  undefined8 local_38;

   

-  MilInstrumentationCheckHR_MaybeFailFast

-            ((ulong)this,(long *)param_1,(uint)param_2,(long)param_3,in_stack_00000020,

-             in_stack_00000028);

-  return (_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

-          *)(unaff_RBX & 0xffffffff);

+  uVar1 = *(undefined8 *)this;

+  local_58 = this;

+  puVar2 = _Allocate<16,std::_Default_allocate_traits,0>(0x30);

+  *(undefined8 *)((longlong)puVar2 + 0x1c) = *(undefined8 *)param_2;

+  *(undefined8 *)((longlong)puVar2 + 0x24) = *(undefined8 *)param_3;

+  *(undefined4 *)((longlong)puVar2 + 0x2c) = *(undefined4 *)(param_3 + 8);

+  *puVar2 = uVar1;

+  puVar2[1] = uVar1;

+  puVar2[2] = uVar1;

+  *(undefined2 *)(puVar2 + 3) = 0;

+  puVar3 = (undefined8 *)_Find_hint<D2D_VECTOR_2F>(this,local_48,(D2D_VECTOR_2F *)param_1);

+  local_38 = puVar3[2];

+  p_Var4 = (_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+            *)*puVar3;

+  uVar1 = puVar3[1];

+  if ((char)local_38 == '\0') {

+    _Check_grow_by_1(this);

+    uStack_50 = 0;

+    _Alloc_construct_ptr<std::allocator<std::_Tree_node<std::pair<_LUID_const_,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>_>,void*___ptr64>_>_>

+    ::

+    ~_Alloc_construct_ptr<std::allocator<std::_Tree_node<std::pair<_LUID_const_,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>_>,void*___ptr64>_>_>

+              ((_Alloc_construct_ptr<std::allocator<std::_Tree_node<std::pair<_LUID_const_,wil::com_ptr_t<Windows::Devices::Display::Core::IDisplayDevice,wil::err_returncode_policy>_>,void*___ptr64>_>_>

+                *)&local_58);

+    local_58 = (_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>

+                *)p_Var4;

+    uStack_50 = uVar1;

+    p_Var4 = (_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+              *)_Tree_val<std::_Tree_simple_types<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>_>_>

+                ::_Insert_node((_Tree_val<std::_Tree_simple_types<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>_>_>

+                                *)this,&local_58,puVar2);

+  }

+  else if (puVar2 != (undefined8 *)0x0) {

+    _Deallocate<16,0>(puVar2,0x30);

+  }

+  return p_Var4;

 }
```

## `CD3DDevice::ProcessDelayUnpinForTarget`  (modified)

```diff
--- CD3DDevice::ProcessDelayUnpinForTarget
+++ CD3DDevice::ProcessDelayUnpinForTarget
@@ -1,2 +1,110 @@
-Failed to decompile dwmcore.dll - .ProgramDB CD3DDevice::ProcessDelayUnpinForTarget : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: void __cdecl CD3DDevice::ProcessDelayUnpinForTarget(struct _LUID,unsigned int,unsigned

+   int) __ptr64 */

+

+void __thiscall

+CD3DDevice::ProcessDelayUnpinForTarget(CD3DDevice *this,_LUID param_1,uint param_2,uint param_3)

+

+{

+  longlong lVar1;

+  longlong lVar2;

+  bool bVar3;

+  int iVar4;

+  undefined8 *puVar5;

+  undefined1 *puVar6;

+  CDelayUnpin *this_00;

+  void *unaff_retaddr;

+  IDXGIResource *local_res8;

+  undefined1 local_68 [8];

+  undefined1 local_60 [8];

+  undefined8 *local_58;

+  undefined8 *puStack_50;

+  undefined8 local_48;

+  longlong local_40;

+  longlong lStack_38;

+  undefined8 local_30;

+  

+  local_30 = 0;

+  local_48 = 0;

+  this_00 = *(CDelayUnpin **)(this + 0x4c0);

+  local_40 = 0;

+  lStack_38 = 0;

+  local_58 = (undefined8 *)0x0;

+  puStack_50 = (undefined8 *)0x0;

+  do {

+    while( true ) {

+      lVar2 = lStack_38;

+      lVar1 = local_40;

+      if (this_00 == *(CDelayUnpin **)(this + 0x4c8)) {

+        puVar5 = local_58;

+        if (local_40 != lStack_38) {

+          if (((byte)Microsoft_Windows_Dwm_CompositorEnableBits & 2) != 0) {

+            McTemplateU0t_EventWriteTransfer

+                      (&Microsoft_Windows_Dwm_Compositor_Context,&UnPinning_Start,

+                       lStack_38 - local_40 >> 3);

+          }

+          iVar4 = (**(code **)(**(longlong **)(this + 0x220) + 0x20))

+                            (*(longlong **)(this + 0x220),lVar1,lVar2 - lVar1 >> 3 & 0xffffffff);

+          if (((byte)Microsoft_Windows_Dwm_CompositorEnableBits & 2) != 0) {

+            McTemplateU0t_EventWriteTransfer

+                      (&Microsoft_Windows_Dwm_Compositor_Context,&UnPinning_Stop,iVar4);

+          }

+          puVar5 = local_58;

+          if (iVar4 < 0) {

+            wil::details::in1diag3::_Log_Hr

+                      (unaff_retaddr,0x48a,

+                       "onecoreuap\\windows\\dwm\\dwmcore\\hw\\global\\globald3ddevice.cpp",iVar4);

+            puVar5 = local_58;

+          }

+        }

+        for (; puVar5 != puStack_50; puVar5 = puVar5 + 1) {

+          (**(code **)(*(longlong *)*puVar5 + 0x48))();

+        }

+        std::

+        vector<wil::com_ptr_t<CWeakReference<CGdiSpriteBitmap>,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<CWeakReference<CGdiSpriteBitmap>,wil::err_returncode_policy>_>_>

+        ::_Tidy((vector<wil::com_ptr_t<CWeakReference<CGdiSpriteBitmap>,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<CWeakReference<CGdiSpriteBitmap>,wil::err_returncode_policy>_>_>

+                 *)&local_58);

+        std::

+        vector<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>_>_>

+        ::_Tidy((vector<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>_>_>

+                 *)&local_40);

+        return;

+      }

+      bVar3 = CDelayUnpin::ReadyToUnpin(this_00,param_1,param_2,param_3);

+      if (!bVar3) break;

+      local_res8 = (IDXGIResource *)

+                   (**(code **)(**(longlong **)this_00 + 0x28))(*(longlong **)this_00,0);

+      if (local_res8 != (IDXGIResource *)0x0) {

+        std::

+        vector<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>_>_>

+        ::emplace_back<IDXGIResource*___ptr64&___ptr64>

+                  ((vector<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>_>_>

+                    *)&local_40,&local_res8);

+      }

+      std::

+      vector<wil::com_ptr_t<IOverlayPlaneResource,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<IOverlayPlaneResource,wil::err_returncode_policy>_>_>

+      ::emplace_back<wil::com_ptr_t<IOverlayPlaneResource,wil::err_returncode_policy>_>

+                ((vector<wil::com_ptr_t<IOverlayPlaneResource,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<IOverlayPlaneResource,wil::err_returncode_policy>_>_>

+                  *)&local_58,(com_ptr_t<IOverlayPlaneResource,wil::err_returncode_policy> *)this_00

+                );

+      puVar6 = local_68;

+LAB_0:

+      local_res8 = (IDXGIResource *)this_00;

+      puVar5 = (undefined8 *)

+               detail::

+               vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>

+               ::erase((vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>

+                        *)(this + 0x4c0),puVar6,&local_res8);

+      this_00 = (CDelayUnpin *)*puVar5;

+    }

+    if ((*(longlong *)(this_00 + 0x10) - *(longlong *)(this_00 + 8) == 0x10) &&

+       (*(int *)(*(longlong *)(this_00 + 8) + 0xc) == -1)) {

+      puVar6 = local_60;

+      goto LAB_0;

+    }

+    this_00 = this_00 + 0x40;

+  } while( true );

+}

+
```

## `CEdgeFlagsMap::Copy`  (modified)

```diff
--- CEdgeFlagsMap::Copy
+++ CEdgeFlagsMap::Copy
@@ -1,2 +1,85 @@
-Failed to decompile dwmcore.dll - .ProgramDB CEdgeFlagsMap::Copy : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: void __cdecl CEdgeFlagsMap::Copy(class CEdgeFlagsMap const & __ptr64,struct

+   D2D_MATRIX_3X2_F const * __ptr64) __ptr64 */

+

+void __thiscall

+CEdgeFlagsMap::Copy(CEdgeFlagsMap *this,CEdgeFlagsMap *param_1,D2D_MATRIX_3X2_F *param_2)

+

+{

+  __uint64 _Var1;

+  void *pvVar2;

+  CEdgeFlagsMap *this_00;

+  CEdgeFlagsMap *pCVar3;

+  undefined1 auStackY_88 [32];

+  undefined4 local_58;

+  undefined4 local_54;

+  undefined4 local_50;

+  undefined4 local_4c;

+  undefined4 local_48;

+  undefined4 local_44;

+  undefined4 local_40;

+  undefined4 local_3c;

+  undefined4 local_38;

+  undefined8 local_30;

+  undefined8 uStack_28;

+  ulonglong local_20;

+  

+  local_20 = __security_cookie ^ (ulonglong)auStackY_88;

+  std::

+  _Variant_base<std::monostate,CEdgeFlagsMap::CRectangleMapStrategy,CEdgeFlagsMap::CPolygonMapStrategy>

+  ::_Reset((_Variant_base<std::monostate,CEdgeFlagsMap::CRectangleMapStrategy,CEdgeFlagsMap::CPolygonMapStrategy>

+            *)this);

+  this_00 = this;

+  std::

+  variant<std::monostate,CEdgeFlagsMap::CRectangleMapStrategy,CEdgeFlagsMap::CPolygonMapStrategy>::

+  _Emplace_valueless<0>

+            ((variant<std::monostate,CEdgeFlagsMap::CRectangleMapStrategy,CEdgeFlagsMap::CPolygonMapStrategy>

+              *)this);

+  if ((param_1 == (CEdgeFlagsMap *)0x0) || (pCVar3 = param_1, param_1[0x18] != (CEdgeFlagsMap)0x1))

+  {

+    pCVar3 = (CEdgeFlagsMap *)0x0;

+  }

+  if (pCVar3 == (CEdgeFlagsMap *)0x0) {

+    if ((param_1 != (CEdgeFlagsMap *)0x0) && (param_1[0x18] == (CEdgeFlagsMap)0x2)) {

+      std::

+      _Variant_base<std::monostate,CEdgeFlagsMap::CRectangleMapStrategy,CEdgeFlagsMap::CPolygonMapStrategy>

+      ::_Reset((_Variant_base<std::monostate,CEdgeFlagsMap::CRectangleMapStrategy,CEdgeFlagsMap::CPolygonMapStrategy>

+                *)this_00);

+      *(undefined8 *)this = 0;

+      *(undefined8 *)(this + 8) = 0;

+      _Var1 = std::_Get_size_of_n<48>(1);

+      pvVar2 = std::_Allocate<16,std::_Default_allocate_traits,0>(_Var1);

+      *(void **)pvVar2 = pvVar2;

+      *(void **)((longlong)pvVar2 + 8) = pvVar2;

+      *(void **)((longlong)pvVar2 + 0x10) = pvVar2;

+      *(undefined2 *)((longlong)pvVar2 + 0x18) = 0x101;

+      *(void **)this = pvVar2;

+      this[0x18] = (CEdgeFlagsMap)0x2;

+      CConvexPolygonEdgeMap<unsigned_int>::Copy

+                ((CConvexPolygonEdgeMap<unsigned_int> *)this,

+                 (CConvexPolygonEdgeMap<unsigned_int> *)param_1,param_2);

+    }

+  }

+  else {

+    if (param_2 != (D2D_MATRIX_3X2_F *)0x0) {

+      local_58 = *(undefined4 *)param_2;

+      local_54 = *(undefined4 *)(param_2 + 4);

+      local_50 = 0;

+      local_44 = 0;

+      local_48 = *(undefined4 *)(param_2 + 0xc);

+      local_4c = *(undefined4 *)(param_2 + 8);

+      local_40 = *(undefined4 *)(param_2 + 0x10);

+      local_3c = *(undefined4 *)(param_2 + 0x14);

+      local_38 = 0x3f800000;

+    }

+    local_30 = *(undefined8 *)pCVar3;

+    uStack_28 = *(undefined8 *)(pCVar3 + 8);

+    AddEdgeFlags(this_00,(D2D_RECT_F *)&local_30,*(D2D1_EDGE_FLAGS *)(pCVar3 + 0x10),

+                 (Matrix3x3 *)

+                 (-(ulonglong)(param_2 != (D2D_MATRIX_3X2_F *)0x0) & (ulonglong)&local_58),

+                 8.138021e-05);

+  }

+  return;

+}

+
```

## `CColorBrush::SetProperty`  (modified)

```diff
--- CColorBrush::SetProperty
+++ CColorBrush::SetProperty
@@ -1,2 +1,64 @@
-Failed to decompile dwmcore.dll - .ProgramDB CColorBrush::SetProperty : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: virtual long __cdecl CColorBrush::SetProperty(unsigned int,enum

+   DCOMPOSITION_EXPRESSION_TYPE,void const * __ptr64) __ptr64 */

+

+long __thiscall

+CColorBrush::SetProperty

+          (CColorBrush *this,uint param_1,DCOMPOSITION_EXPRESSION_TYPE param_2,void *param_3)

+

+{

+  undefined8 *puVar1;

+  AnimatedProperty *pAVar2;

+  code *pcVar3;

+  int iVar4;

+  undefined4 in_register_00000014;

+  uint uVar5;

+  longlong local_18;

+  undefined8 *local_10;

+  

+  gsl::span<AnimationHelper::AnimatedProperty_const*___ptr64_const,-1>::

+  span<AnimationHelper::AnimatedProperty_const*___ptr64_const,_1><5,0>

+            ((span<AnimationHelper::AnimatedProperty_const*___ptr64_const,_1> *)&local_18,

+             (AnimatedProperty **)CONCAT44(in_register_00000014,param_1));

+  puVar1 = local_10 + local_18;

+  do {

+    if (local_10 == puVar1) {

+LAB_0:

+      iVar4 = -0x7ff8ffa9;

+      uVar5 = 0x43;

+LAB_1:

+      MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,iVar4,uVar5,(void *)0x0);

+      return iVar4;

+    }

+    pAVar2 = (AnimatedProperty *)*local_10;

+    if ((param_1 == *(uint *)pAVar2) &&

+       ((param_2 == *(DCOMPOSITION_EXPRESSION_TYPE *)(pAVar2 + 4) || (param_2 == 0)))) {

+      if (pAVar2 != (AnimatedProperty *)0x0) {

+        pcVar3 = *(code **)(pAVar2 + 0x18);

+        if (pcVar3 == CGeometry::SetTrimInvalidatingAnimatedProperty) {

+          iVar4 = CGeometry::SetTrimInvalidatingAnimatedProperty((CGeometry *)this,pAVar2,param_3);

+        }

+        else if (pcVar3 == CComponentTransform2D::SetRotationAngle) {

+          iVar4 = CComponentTransform2D::SetRotationAngle

+                            ((CComponentTransform2D *)this,pAVar2,param_3);

+        }

+        else if (pcVar3 == CBrush::SetAnimatedProperty) {

+          iVar4 = CBrush::SetAnimatedProperty((CBrush *)this,pAVar2,param_3);

+        }

+        else {

+          iVar4 = (*pcVar3)();

+        }

+        if (-1 < iVar4) {

+          return iVar4;

+        }

+        uVar5 = 0x3f;

+        goto LAB_1;

+      }

+      goto LAB_0;

+    }

+    local_10 = local_10 + 1;

+  } while( true );

+}

+
```

## `COverlayContext::BeginOverlayCandidateCollection`  (modified)

```diff
--- COverlayContext::BeginOverlayCandidateCollection
+++ COverlayContext::BeginOverlayCandidateCollection
@@ -1,2 +1,139 @@
-Failed to decompile dwmcore.dll - .ProgramDB COverlayContext::BeginOverlayCandidateCollection : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: bool __cdecl COverlayContext::BeginOverlayCandidateCollection(class CRegion const *

+   __ptr64,class CRegion * __ptr64) __ptr64 */

+

+bool __thiscall

+COverlayContext::BeginOverlayCandidateCollection

+          (COverlayContext *this,CRegion *param_1,CRegion *param_2)

+

+{

+  OverlayPlaneInfo *pOVar1;

+  CRegion *this_00;

+  bool bVar2;

+  char cVar3;

+  char cVar4;

+  COverlayContext CVar5;

+  CMonitorTransform *pCVar6;

+  longlong lVar7;

+  tagRECT *ptVar8;

+  OverlayPlaneInfo *pOVar9;

+  undefined4 uVar10;

+  bool bVar11;

+  undefined1 auStack_f8 [32];

+  CMonitorTransform *local_d8;

+  undefined4 local_d0;

+  CMonitorTransform *local_c8;

+  D2D_RECT_F local_c0 [16];

+  CRegion *local_b0 [3];

+  CRgnData *local_98 [10];

+  ulonglong local_48;

+  

+  local_48 = __security_cookie ^ (ulonglong)auStack_f8;

+  bVar11 = false;

+  uVar10 = 0;

+  local_b0[0] = param_2;

+  detail::

+  vector_facade<COverlayContext::OverlayPlaneInfo,detail::buffer_impl<COverlayContext::OverlayPlaneInfo,16,1,detail::liberal_expansion_policy>_>

+  ::clear((vector_facade<COverlayContext::OverlayPlaneInfo,detail::buffer_impl<COverlayContext::OverlayPlaneInfo,16,1,detail::liberal_expansion_policy>_>

+           *)(this + 0x58));

+  *(undefined8 *)(this + 0x4b98) = 0;

+  *(undefined8 *)(this + 0x4b90) = 0;

+  *(undefined8 *)(this + 0x4ba8) = 0;

+  *(undefined8 *)(this + 0x4ba0) = 0;

+  *(undefined2 *)(this + 0x4bb0) = 0;

+  bVar2 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>::

+          __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor> *)

+                              &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DesktopDWMCursor>::GetImpl(void)'

+                               ::__l2::impl);

+  if (bVar2) {

+    this[0x4c7a] = (COverlayContext)0x0;

+  }

+  *(undefined2 *)(this + 0x4c78) = 0;

+  *(undefined8 *)(this + 0x4c58) = 0;

+  *(undefined8 *)(this + 0x4c50) = 0;

+  pCVar6 = GetMonitorTransform(this);

+  bVar2 = CMILMatrix::Is2DAxisAlignedPreserving((CMILMatrix *)(pCVar6 + 0x34));

+  if (!bVar2) goto LAB_0;

+  lVar7 = (**(code **)(**(longlong **)this + 0x118))();

+  if (lVar7 == 0) goto LAB_0;

+  uVar10 = 1;

+  local_d0 = 1;

+  local_d8 = (CMonitorTransform *)GetCurrentFrameId();

+  local_c8 = *(CMonitorTransform **)(this + 0x4c38);

+  cVar3 = (**(code **)(**(longlong **)this + 0x30))();

+  if (cVar3 == '\0') {

+    cVar4 = (**(code **)(**(longlong **)this + 0x120))(*(longlong **)this,param_2);

+    bVar11 = cVar4 != '\0';

+    if (local_c8 == local_d8) goto LAB_1;

+    CVar5 = (COverlayContext)0x0;

+  }

+  else {

+LAB_1:

+    CVar5 = (COverlayContext)0x1;

+  }

+  this[0x4c78] = CVar5;

+  if ((!bVar11) && (param_1 != (CRegion *)0x0)) {

+    ptVar8 = (tagRECT *)PixelAlign(local_c0);

+    FastRegion::CRegion::CRegion((CRegion *)local_98,ptVar8);

+    if ((*(int *)*(CRgnData **)param_1 != 0) && (*(int *)local_98[0] != 0)) {

+      bVar2 = FastRegion::Internal::CRgnData::Intersects(*(CRgnData **)param_1,local_98[0]);

+      if (bVar2) {

+        bVar11 = true;

+      }

+    }

+    FastRegion::CRegion::FreeMemory((CRegion *)local_98);

+  }

+  if (cVar3 == '\0') {

+    bVar2 = TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded>::IsEmpty

+                      ((TMilRect<float,D2D_RECT_F,D3D_RECT_F,RectUniqueness::NotNeeded> *)

+                       (this + 0x4b80));

+    if (bVar2) {

+      bVar2 = false;

+      if ((!bVar11) && (local_c8 != local_d8)) {

+        bVar11 = HasRevokablePlanes(this);

+        if (!bVar11) goto LAB_0;

+      }

+    }

+    else {

+      bVar2 = true;

+    }

+    this_00 = local_b0[0];

+    this[0x4c79] = (COverlayContext)0x1;

+    if (*(longlong *)(this + 0x4c28) == 0) {

+      local_d8 = pCVar6 + 0x78;

+      pOVar1 = *(OverlayPlaneInfo **)(this + 0x3190);

+      for (pOVar9 = *(OverlayPlaneInfo **)(this + 0x3188); pOVar9 != pOVar1; pOVar9 = pOVar9 + 0x188

+          ) {

+        OverlayPlaneInfo::GetLocalClipRect(pOVar9,(CMILMatrix *)local_b0);

+        ptVar8 = (tagRECT *)PixelAlign(local_c0);

+        CRegion::AddRectangle((CRegion *)this_00,ptVar8);

+      }

+      pOVar1 = *(OverlayPlaneInfo **)(this + 0x18f8);

+      for (pOVar9 = *(OverlayPlaneInfo **)(this + 0x18f0); uVar10 = local_d0, pOVar9 != pOVar1;

+          pOVar9 = pOVar9 + 0x188) {

+        OverlayPlaneInfo::GetLocalClipRect(pOVar9,(CMILMatrix *)local_b0);

+        ptVar8 = (tagRECT *)PixelAlign(local_c0);

+        CRegion::AddRectangle((CRegion *)this_00,ptVar8);

+      }

+      if (bVar2) {

+        ptVar8 = (tagRECT *)PixelAlign(local_c0);

+        CRegion::AddRectangle((CRegion *)this_00,ptVar8);

+        *(undefined8 *)(this + 0x4b88) = 0;

+        *(undefined8 *)(this + 0x4b80) = 0;

+      }

+    }

+    else {

+      ptVar8 = (tagRECT *)PixelAlign(local_c0);

+      CRegion::AddRectangle((CRegion *)param_2,ptVar8);

+    }

+  }

+LAB_0:

+  if ((Microsoft_Windows_Dwm_CoreEnableBits._1_1_ & 2) != 0) {

+    McTemplateU0dd_EventWriteTransfer();

+  }

+  return (bool)(char)uVar10;

+}

+
```

## `CBitmapRenderStrategy::GetBitmap`  (modified)

```diff
--- CBitmapRenderStrategy::GetBitmap
+++ PixelAlign
@@ -1,35 +1,98 @@
 

-/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

-   guard_dispatch_icall */

-/* public: static void __cdecl CBitmapRenderStrategy::GetBitmap(class CSurfaceBrush const *

-   __ptr64,class IBitmapResource * __ptr64 * __ptr64) */

+/* class TMilRect_<int,struct tagRECT,struct D2D_POINTANDSIZE_L,struct Mil3DRectL,struct

+   RectUniqueness::_CMilRectL_> __cdecl PixelAlign(struct D2D_RECT_F const & __ptr64) */

 

-void __cdecl CBitmapRenderStrategy::GetBitmap(CSurfaceBrush *param_1,IBitmapResource **param_2)

+D2D_RECT_F * __cdecl PixelAlign(D2D_RECT_F *param_1)

 

 {

-  bool bVar1;

-  CResource *this;

+  int iVar1;

+  float *in_RDX;

+  int iVar2;

+  float fVar3;

   

-  this = CSurfaceBrush::GetSurface(param_1);

-  if ((code *)**(undefined8 **)this ==

-      CMILCOMBaseWeakRefSource<CResourceDeleter>::InternalQueryInterface) {

-    if (param_2 != (IBitmapResource **)0x0) {

-      bVar1 = operator==((_GUID *)&_GUID_b35f2031_4b76_4d4e_b98c_6771dfcc753c,

-                         (_GUID *)&_GUID_73f2a332_aba0_4b29_88bc_6ee79b3941bc);

-      if (!bVar1) {

-        CMILCOMBaseT<IUnknownWeakRefSource,IUnknownWeakRefSource,CResourceDeleter>::

-        InternalQueryInterface

-                  ((CMILCOMBaseT<IUnknownWeakRefSource,IUnknownWeakRefSource,CResourceDeleter> *)

-                   this,(_GUID *)&_GUID_b35f2031_4b76_4d4e_b98c_6771dfcc753c,param_2);

-        return;

+  fVar3 = *in_RDX;

+  iVar2 = 0x7fffffff;

+  if ((uint)ABS(fVar3) < 0x497ffff1) {

+    iVar1 = ((int)(fVar3 + 6291456.0) << 10) >> 0xb;

+  }

+  else {

+    iVar1 = (int)ROUND(fVar3) + (uint)((float)(int)ROUND(fVar3) - fVar3 <= -0.5);

+  }

+  if (0.00390625 < ABS(fVar3 - (float)iVar1)) {

+    if (fVar3 < -2.1474836e+09) {

+      iVar1 = -0x80000000;

+    }

+    else {

+      iVar1 = 0x7fffffff;

+      if (fVar3 < 2.1474836e+09) {

+        fVar3 = floorf(fVar3);

+        iVar1 = (int)fVar3;

       }

-      *param_2 = (IBitmapResource *)this;

-      CMILRefCountImpl::AddReference((CMILRefCountImpl *)(this + 8));

+    }

+  }

+  fVar3 = in_RDX[1];

+  *(int *)param_1 = iVar1;

+  if ((uint)ABS(fVar3) < 0x497ffff1) {

+    iVar1 = ((int)(fVar3 + 6291456.0) << 10) >> 0xb;

+  }

+  else {

+    iVar1 = (int)ROUND(fVar3) + (uint)((float)(int)ROUND(fVar3) - fVar3 <= -0.5);

+  }

+  if (0.00390625 < ABS(fVar3 - (float)iVar1)) {

+    if (fVar3 < -2.1474836e+09) {

+      iVar1 = -0x80000000;

+    }

+    else {

+      iVar1 = 0x7fffffff;

+      if (fVar3 < 2.1474836e+09) {

+        fVar3 = floorf(fVar3);

+        iVar1 = (int)fVar3;

+      }

+    }

+  }

+  fVar3 = in_RDX[2];

+  *(int *)(param_1 + 4) = iVar1;

+  if ((uint)ABS(fVar3) < 0x497ffff1) {

+    iVar1 = ((int)(fVar3 + 6291456.0) << 10) >> 0xb;

+  }

+  else {

+    iVar1 = (int)ROUND(fVar3) + (uint)((float)(int)ROUND(fVar3) - fVar3 <= -0.5);

+  }

+  if (0.00390625 < ABS(fVar3 - (float)iVar1)) {

+    if (fVar3 < -2.1474836e+09) {

+      iVar1 = -0x80000000;

+    }

+    else {

+      iVar1 = 0x7fffffff;

+      if (fVar3 < 2.1474836e+09) {

+        fVar3 = ceilf(fVar3);

+        iVar1 = (int)fVar3;

+      }

+    }

+  }

+  fVar3 = in_RDX[3];

+  *(int *)(param_1 + 8) = iVar1;

+  if ((uint)ABS(fVar3) < 0x497ffff1) {

+    iVar1 = ((int)(fVar3 + 6291456.0) << 10) >> 0xb;

+  }

+  else {

+    iVar1 = (int)ROUND(fVar3) + (uint)((float)(int)ROUND(fVar3) - fVar3 <= -0.5);

+  }

+  if (0.00390625 < ABS(fVar3 - (float)iVar1)) {

+    if (fVar3 < -2.1474836e+09) {

+      *(undefined4 *)(param_1 + 0xc) = 0x80000000;

+    }

+    else {

+      if (fVar3 < 2.1474836e+09) {

+        fVar3 = ceilf(fVar3);

+        iVar2 = (int)fVar3;

+      }

+      *(int *)(param_1 + 0xc) = iVar2;

     }

   }

   else {

-    (*(code *)**(undefined8 **)this)(this,&_GUID_b35f2031_4b76_4d4e_b98c_6771dfcc753c,param_2);

+    *(int *)(param_1 + 0xc) = iVar1;

   }

-  return;

+  return param_1;

 }
```

## `CD3DDevice::ImmediateUnpinResources`  (modified)

```diff
--- CD3DDevice::ImmediateUnpinResources
+++ CD3DDevice::ImmediateUnpinResources
@@ -1,2 +1,94 @@
-Failed to decompile dwmcore.dll - .ProgramDB CD3DDevice::ImmediateUnpinResources : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: void __cdecl CD3DDevice::ImmediateUnpinResources(class gsl::span<class

+   ISwapChainRealization * __ptr64,-1>) __ptr64 */

+

+void __thiscall CD3DDevice::ImmediateUnpinResources(CD3DDevice *this,longlong *param_2)

+

+{

+  longlong *plVar1;

+  longlong *plVar2;

+  longlong lVar3;

+  longlong lVar4;

+  char cVar5;

+  int iVar6;

+  IDXGIResource *pIVar7;

+  longlong *plVar8;

+  longlong *plVar9;

+  void *unaff_retaddr;

+  IDXGIResource *local_res18;

+  undefined1 local_res20 [8];

+  longlong local_58;

+  longlong lStack_50;

+  undefined8 local_48;

+  

+  plVar8 = (longlong *)param_2[1];

+  local_48 = 0;

+  local_58 = 0;

+  lStack_50 = 0;

+  plVar2 = plVar8 + *param_2;

+  if (plVar8 != plVar2) {

+    plVar9 = plVar8;

+    do {

+      lVar3 = *plVar9;

+      plVar1 = (longlong *)(lVar3 + 0x10);

+      cVar5 = (**(code **)(*plVar1 + 0x38))(plVar1);

+      if (cVar5 != '\0') {

+        for (pIVar7 = *(IDXGIResource **)(this + 0x4c0); pIVar7 != *(IDXGIResource **)(this + 0x4c8)

+            ; pIVar7 = pIVar7 + 0x40) {

+          if (*(ulonglong *)pIVar7 == (-(ulonglong)(lVar3 != 0) & (ulonglong)plVar1)) {

+            local_res18 = pIVar7;

+            detail::

+            vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>

+            ::erase((vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>

+                     *)(this + 0x4c0),local_res20,&local_res18);

+            break;

+          }

+        }

+        local_res18 = (IDXGIResource *)(**(code **)(*plVar1 + 0x28))(plVar1);

+        if (local_res18 != (IDXGIResource *)0x0) {

+          std::

+          vector<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>_>_>

+          ::emplace_back<IDXGIResource*___ptr64&___ptr64>

+                    ((vector<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>_>_>

+                      *)&local_58,&local_res18);

+        }

+      }

+      plVar9 = plVar9 + 1;

+    } while (plVar9 != plVar2);

+  }

+  lVar4 = lStack_50;

+  lVar3 = local_58;

+  if (local_58 != lStack_50) {

+    if (((byte)Microsoft_Windows_Dwm_CompositorEnableBits & 2) != 0) {

+      McTemplateU0t_EventWriteTransfer

+                (&Microsoft_Windows_Dwm_Compositor_Context,&UnPinning_Start,

+                 lStack_50 - local_58 >> 3);

+    }

+    iVar6 = (**(code **)(**(longlong **)(this + 0x220) + 0x20))

+                      (*(longlong **)(this + 0x220),lVar3,lVar4 - lVar3 >> 3 & 0xffffffff);

+    if (((byte)Microsoft_Windows_Dwm_CompositorEnableBits & 2) != 0) {

+      McTemplateU0t_EventWriteTransfer

+                (&Microsoft_Windows_Dwm_Compositor_Context,&UnPinning_Stop,iVar6);

+    }

+    if (iVar6 < 0) {

+      wil::details::in1diag3::_Log_Hr

+                (unaff_retaddr,0x421,

+                 "onecoreuap\\windows\\dwm\\dwmcore\\hw\\global\\globald3ddevice.cpp",iVar6);

+    }

+  }

+  for (; plVar8 != plVar2; plVar8 = plVar8 + 1) {

+    lVar3 = *plVar8;

+    cVar5 = (**(code **)(*(longlong *)(lVar3 + 0x10) + 0x38))(lVar3 + 0x10);

+    if (cVar5 != '\0') {

+      (**(code **)(*(longlong *)(lVar3 + 0x10) + 0x48))(lVar3 + 0x10);

+    }

+  }

+  std::

+  vector<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>_>_>

+  ::_Tidy((vector<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>,std::allocator<wil::com_ptr_t<IDXGIResource,wil::err_returncode_policy>_>_>

+           *)&local_58);

+  return;

+}

+
```

## `CResourceFactory::Create`  (modified)

```diff
--- CResourceFactory::Create
+++ CResourceFactory::Create
@@ -1,2 +1,2090 @@
-Failed to decompile dwmcore.dll - .ProgramDB CResourceFactory::Create : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: static long __cdecl CResourceFactory::Create(class CComposition * __ptr64,class

+   CChannelContext * __ptr64,enum MIL_RESOURCE_TYPE,class CResource * __ptr64 * __ptr64) */

+

+long __cdecl

+CResourceFactory::Create

+          (CComposition *param_1,CChannelContext *param_2,MIL_RESOURCE_TYPE param_3,

+          CResource **param_4)

+

+{

+  CFilterEffect *this;

+  CAnimationTrigger *this_00;

+  CFilterEffect *pCVar1;

+  undefined **ppuVar2;

+  CAnimationController *this_01;

+  CAnimation *this_02;

+  CCaptureRenderTarget *this_03;

+  CCachedVisualImage *this_04;

+  CBitmapResource *this_05;

+  CCompositionAmbientLight *this_06;

+  CComponentTransform3D *this_07;

+  CCombinedGeometry *this_08;

+  CColorMatrixEffect *this_09;

+  CCompositionDistantLight *this_10;

+  CConditionalExpression *this_11;

+  CCompositionSpotLight *this_12;

+  CCompositionPointLight *this_13;

+  CDropShadow *this_14;

+  CDesktopTree *this_15;

+  CDelegatedInkCanvas *this_16;

+  CDDisplayRenderTarget *this_17;

+  CCursorVisual *this_18;

+  CHolographicDisplay *this_19;

+  CGeometryGroup *this_20;

+  CGeometry2DGroup *this_21;

+  CGenericInk *this_22;

+  CGdiSpriteBitmap *this_23;

+  CHolographicExclusiveMode *this_24;

+  CIndirectSwapchainRenderTarget *this_25;

+  undefined8 *puVar3;

+  CHolographicViewer *this_26;

+  CHolographicInteropTexture *this_27;

+  CHolographicInteropTarget *this_28;

+  CHolographicExclusiveView *this_29;

+  CLegacyStereoRenderTarget *this_30;

+  CLegacyRenderTarget *this_31;

+  CKeyframeAnimation *this_32;

+  CInteractionTrackerBindingManager *this_33;

+  CInteractionTracker *this_34;

+  CInteraction *this_35;

+  CManipulationTransform *this_36;

+  CManipulation *this_37;

+  CMagnifierRenderTarget *this_38;

+  CLinearTransferEffect *this_39;

+  CLinearGradientBrush *this_40;

+  CProjectedShadow *this_41;

+  CPrimitiveGroup *this_42;

+  CNineGridBrush *this_43;

+  CNaturalAnimation *this_44;

+  CMeshGeometry2D *this_45;

+  CProjectedShadowCaster *this_46;

+  CRegionGeometry *this_47;

+  CRadialGradientBrush *this_48;

+  CProjectedShadowScene *this_49;

+  CRemoteAppRenderTarget *this_50;

+  CRenderData *this_51;

+  CRemoteRenderTarget *this_52;

+  CSceneMesh *this_53;

+  CShadowEffect *this_54;

+  CSceneVisual *this_55;

+  CSceneSurfaceMaterialInput *this_56;

+  CSceneNode *this_57;

+  CSceneMetallicRoughnessMaterial *this_58;

+  CSceneMeshRendererComponent *this_59;

+  CSpriteVectorShape *this_60;

+  CSurfaceBrush *this_61;

+  CVirtualMonitorCaptureRenderTarget *this_62;

+  CViewBox *this_63;

+  CTurbulenceEffect *this_64;

+  CTransformGroup *this_65;

+  CTransform3DGroup *this_66;

+  CTableTransferEffect *this_67;

+  CSynchronousSuperWetInk *this_68;

+  CVisual *this_69;

+  CWindowNode *this_70;

+  CVisualSurface *this_71;

+  CVisualCapture *this_72;

+  CTransform *pCVar4;

+  CTransform3D *pCVar5;

+  long lVar6;

+  undefined8 unaff_retaddr;

+  uint uVar7;

+  

+  pCVar1 = (CFilterEffect *)0x0;

+  if (param_3 < 0x61) {

+    if (param_3 == 0x60) {

+      this = DefaultHeap::AllocClear(0x48);

+      if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+        ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+      }

+      *(undefined4 *)(this + 8) = 0;

+      *(longlong *)(this + 0x10) = 0;

+      *(CComposition **)(this + 0x18) = param_1;

+      *(longlong *)(this + 0x20) = 0;

+      *(longlong *)(this + 0x30) = 0;

+      *(undefined4 *)(this + 0x28) = 0;

+      ppuVar2 = &CLegacyVisualCaptureRenderTarget::_vftable_;

+LAB_0:

+      *(undefined ***)this = ppuVar2;

+      goto LAB_1;

+    }

+    if (param_3 < 0x2f) {

+      if (param_3 == 0x2e) {

+        this = DefaultHeap::AllocClear(0x78);

+        if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        *(undefined4 *)(this + 8) = 0;

+        *(longlong *)(this + 0x20) = 0;

+        *(longlong *)(this + 0x10) = 0;

+        *(CComposition **)(this + 0x18) = param_1;

+        *(longlong *)(this + 0x30) = 0;

+        *(undefined4 *)(this + 0x28) = 0;

+        ppuVar2 = &CCrossContainerGuestReadWriteSharedSection::_vftable_;

+        *(longlong *)(this + 0x58) = 0;

+        *(longlong *)(this + 0x60) = 0;

+        goto LAB_0;

+      }

+      if (param_3 < 0x18) {

+        if (param_3 == 0x17) {

+          this = CResource::operator_new(0x60);

+          if (this != (CFilterEffect *)0x0) {

+            *(undefined4 *)(this + 8) = 0;

+            *(longlong *)(this + 0x20) = 0;

+            *(longlong *)(this + 0x10) = 0;

+            *(CComposition **)(this + 0x18) = param_1;

+            *(longlong *)(this + 0x30) = 0;

+            *(undefined4 *)(this + 0x28) = 0;

+            *(undefined ***)this = &CColorGradientStop::_vftable_;

+            *(longlong *)(this + 0x48) = 0;

+            *(longlong *)(this + 0x50) = 0;

+            *(undefined4 *)(this + 0x58) = 0;

+            goto LAB_1;

+          }

+        }

+        else if (param_3 < 0xd) {

+          if (param_3 == 0xc) {

+            this = CResource::operator_new(0x48);

+            if (this != (CFilterEffect *)0x0) {

+              *(undefined4 *)(this + 8) = 0;

+              *(longlong *)(this + 0x10) = 0;

+              *(CComposition **)(this + 0x18) = param_1;

+              *(longlong *)(this + 0x20) = 0;

+              *(longlong *)(this + 0x30) = 0;

+              *(undefined4 *)(this + 0x28) = 0;

+              ppuVar2 = &CBatchDeferral::_vftable_;

+              goto LAB_0;

+            }

+          }

+          else {

+            if (param_3 == 1) {

+              this = DefaultHeap::AllocClear(0xf8);

+              if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              CFilterEffect::CFilterEffect(this,param_1);

+              *(undefined8 *)(this + 0xb0) = 0;

+              *(undefined8 *)(this + 0xb8) = 0x3f800000;

+              *(undefined8 *)(this + 0xc4) = 0x3f800000;

+              *(undefined4 *)(this + 0xd0) = 0x3f800000;

+              *(undefined ***)this = &CAffineTransform2DEffect::_vftable_;

+              *(undefined4 *)(this + 0xc0) = 0;

+              *(undefined4 *)(this + 0xcc) = 0;

+              goto LAB_1;

+            }

+            if (param_3 == 2) {

+              this_02 = DefaultHeap::AllocClear(0x130);

+              if (this_02 == (CAnimation *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              pCVar1 = (CFilterEffect *)CAnimation::CAnimation(this_02,param_1);

+            }

+            else if (param_3 == 3) {

+              this_01 = DefaultHeap::AllocClear(0x80);

+              if (this_01 == (CAnimationController *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              pCVar1 = (CFilterEffect *)CAnimationController::CAnimationController(this_01,param_1);

+            }

+            else {

+              if (param_3 == 4) {

+                this = DefaultHeap::AllocClear(0x58);

+                if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                  ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+                }

+                *(undefined4 *)(this + 8) = 0;

+                *(longlong *)(this + 0x10) = 0;

+                *(CComposition **)(this + 0x18) = param_1;

+                *(longlong *)(this + 0x20) = 0;

+                *(longlong *)(this + 0x30) = 0;

+                *(undefined4 *)(this + 0x28) = 0;

+                ppuVar2 = &CAnimationGlobalConfiguration::_vftable_;

+                goto LAB_0;

+              }

+              if (param_3 != 5) {

+                if (param_3 == 6) {

+                  this = DefaultHeap::AllocClear(200);

+                  if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                    ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+                  }

+                  CFilterEffect::CFilterEffect(this,param_1);

+                  *(undefined8 *)(this + 0xb0) = 0x3f800000;

+                  *(undefined ***)this = &CArithmeticCompositeEffect::_vftable_;

+                  *(undefined8 *)(this + 0xb8) = 0;

+                  *(undefined4 *)(this + 0xc0) = 0;

+                  goto LAB_1;

+                }

+                if (param_3 == 7) {

+                  this = DefaultHeap::AllocClear(0x80);

+                  if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                    ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+                  }

+                  *(undefined4 *)(this + 8) = 0;

+                  *(longlong *)(this + 0x20) = 0;

+                  *(longlong *)(this + 0x10) = 0;

+                  *(CComposition **)(this + 0x18) = param_1;

+                  *(longlong *)(this + 0x30) = 0;

+                  *(undefined4 *)(this + 0x28) = 0;

+                  *(undefined ***)this = &CAtlasedRectsGroup::_vftable_;

+                  *(longlong *)(this + 0x50) = 0;

+                  *(longlong *)(this + 0x58) = 0;

+                  *(longlong *)(this + 0x60) = 0;

+                  *(longlong *)(this + 0x68) = 0;

+                  *(longlong *)(this + 0x70) = 0;

+                  this[0x78] = (CFilterEffect)0x1;

+                  goto LAB_1;

+                }

+                if (param_3 == 8) {

+                  this = DefaultHeap::AllocClear(0x98);

+                  if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                    ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+                  }

+                  *(undefined4 *)(this + 8) = 0;

+                  *(longlong *)(this + 0x20) = 0;

+                  *(longlong *)(this + 0x10) = 0;

+                  *(CComposition **)(this + 0x18) = param_1;

+                  *(longlong *)(this + 0x30) = 0;

+                  *(undefined4 *)(this + 0x28) = 0;

+                  *(undefined ***)this = &CAtlasedRectsMesh::_vftable_;

+                  *(longlong *)(this + 0x50) = 0;

+                  *(longlong *)(this + 0x58) = 0;

+                  *(longlong *)(this + 0x60) = 0;

+                  *(longlong *)(this + 0x68) = 0;

+                  *(longlong *)(this + 0x70) = 0;

+                  *(longlong *)(this + 0x78) = 0;

+                  *(longlong *)(this + 0x80) = 0;

+                  *(longlong *)(this + 0x88) = 0;

+                  this[0x90] = (CFilterEffect)0x1;

+                  goto LAB_1;

+                }

+                if (param_3 != 9) goto LAB_2;

+                this = DefaultHeap::AllocClear(0x68);

+                if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                  ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+                }

+                *(undefined4 *)(this + 8) = 0;

+                *(longlong *)(this + 0x20) = 0;

+                *(longlong *)(this + 0x10) = 0;

+                *(CComposition **)(this + 0x18) = param_1;

+                *(longlong *)(this + 0x30) = 0;

+                *(undefined4 *)(this + 0x28) = 0;

+                *(undefined ***)this = &CBackdropBrush::_vftable__for__CContent__;

+                goto LAB_3;

+              }

+              this_00 = DefaultHeap::AllocClear(200);

+              if (this_00 == (CAnimationTrigger *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              pCVar1 = (CFilterEffect *)CAnimationTrigger::CAnimationTrigger(this_00,param_1);

+            }

+          }

+        }

+        else if (param_3 == 0xd) {

+          this_05 = CResource::operator_new(0x70);

+          if (this_05 != (CBitmapResource *)0x0) {

+            pCVar1 = (CFilterEffect *)

+                     CBitmapResource::CBitmapResource(this_05,param_1,(IBitmapRealization *)0x0);

+          }

+        }

+        else {

+          if (param_3 == 0xe) {

+            this = DefaultHeap::AllocClear(0xb8);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            CFilterEffect::CFilterEffect(this,param_1);

+            ppuVar2 = &CBlendEffect::_vftable_;

+LAB_4:

+            *(undefined ***)this = ppuVar2;

+            *(undefined4 *)(this + 0xb0) = 0;

+            goto LAB_1;

+          }

+          if (param_3 == 0xf) {

+            this = DefaultHeap::AllocClear(0x68);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            *(undefined4 *)(this + 8) = 0;

+            *(longlong *)(this + 0x20) = 0;

+            *(longlong *)(this + 0x10) = 0;

+            *(CComposition **)(this + 0x18) = param_1;

+            *(longlong *)(this + 0x30) = 0;

+            *(undefined4 *)(this + 0x28) = 0;

+            *(undefined ***)this = &CBlurredWallpaperBackdropBrush::_vftable__for__CContent__;

+LAB_3:

+            ppuVar2 = &CColorBrush::_vftable__for__IBrushChangeNotification__;

+            this[0x60] = (CFilterEffect)0x0;

+            *(longlong *)(this + 0x58) = 0;

+            *(longlong *)(this + 0x50) = 0;

+LAB_5:

+            *(undefined ***)(this + 0x48) = ppuVar2;

+            goto LAB_1;

+          }

+          if (param_3 == 0x10) {

+            this = DefaultHeap::AllocClear(0xc0);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            CFilterEffect::CFilterEffect(this,param_1);

+            *(undefined4 *)(this + 0xbc) = 0;

+            *(undefined4 *)(this + 0xb0) = 0x3f800000;

+            *(undefined8 *)(this + 0xb4) = 0x3f800000;

+            *(undefined ***)this = &CBrightnessEffect::_vftable_;

+            goto LAB_1;

+          }

+          if (param_3 == 0x12) {

+            this_04 = CCachedVisualImage::operator_new(0x60);

+            if (this_04 != (CCachedVisualImage *)0x0) {

+              pCVar1 = (CFilterEffect *)

+                       CCachedVisualImage::CCachedVisualImage(this_04,param_1,false);

+            }

+          }

+          else {

+            if (param_3 == 0x13) {

+              this = DefaultHeap::AllocClear(0xb0);

+              if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              *(undefined4 *)(this + 8) = 0;

+              *(longlong *)(this + 0x20) = 0;

+              *(longlong *)(this + 0x10) = 0;

+              *(CComposition **)(this + 0x18) = param_1;

+              *(longlong *)(this + 0x30) = 0;

+              *(undefined4 *)(this + 0x28) = 0;

+              *(undefined ***)this = &CCaptureController::_vftable_;

+              this[0x48] = (CFilterEffect)0x1;

+              this[0x54] = (CFilterEffect)0x1;

+              *(undefined4 *)(this + 0x58) = 0x40000000;

+              this[100] = (CFilterEffect)0x0;

+              *(longlong *)(this + 0x80) = 0;

+              *(longlong *)(this + 0x88) = 0;

+              *(longlong *)(this + 0x90) = 0;

+              *(longlong *)(this + 0xa0) = 0;

+              goto LAB_6;

+            }

+            if (param_3 == 0x14) {

+              this_03 = DefaultHeap::AllocClear(0xc48);

+              if (this_03 == (CCaptureRenderTarget *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              pCVar1 = (CFilterEffect *)CCaptureRenderTarget::CCaptureRenderTarget(this_03,param_1);

+            }

+            else {

+              if (param_3 == 0x15) {

+                this = DefaultHeap::AllocClear(0x80);

+                if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                  ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+                }

+                *(undefined4 *)(this + 8) = 0;

+                *(longlong *)(this + 0x20) = 0;

+                *(longlong *)(this + 0x10) = 0;

+                *(CComposition **)(this + 0x18) = param_1;

+                *(longlong *)(this + 0x30) = 0;

+                *(undefined4 *)(this + 0x28) = 0;

+                *(undefined ***)this = &CClipBrush::_vftable__for__CContent__;

+                *(undefined ***)(this + 0x48) =

+                     &CColorBrush::_vftable__for__IBrushChangeNotification__;

+                *(longlong *)(this + 0x50) = 0;

+                *(longlong *)(this + 0x58) = 0;

+                this[0x60] = (CFilterEffect)0x0;

+                *(longlong *)(this + 0x68) = 0;

+                *(longlong *)(this + 0x70) = 0;

+                *(longlong *)(this + 0x78) = 0;

+                goto LAB_1;

+              }

+              if (param_3 != 0x16) goto LAB_2;

+              this = CColorBrush::operator_new(0x60);

+              if (this != (CFilterEffect *)0x0) {

+                *(undefined4 *)(this + 8) = 0;

+                *(longlong *)(this + 0x20) = 0;

+                *(longlong *)(this + 0x10) = 0;

+                *(CComposition **)(this + 0x18) = param_1;

+                *(longlong *)(this + 0x30) = 0;

+                *(undefined4 *)(this + 0x28) = 0;

+                *(undefined ***)this = &CColorBrush::_vftable__for__CContent__;

+                goto LAB_3;

+              }

+            }

+          }

+        }

+      }

+      else if (param_3 < 0x22) {

+        if (param_3 == 0x21) {

+          this_10 = DefaultHeap::AllocClear(0x128);

+          if (this_10 == (CCompositionDistantLight *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)

+                   CCompositionDistantLight::CCompositionDistantLight(this_10,param_1);

+        }

+        else if (param_3 == 0x18) {

+          this_09 = DefaultHeap::AllocClear(0x108);

+          if (this_09 == (CColorMatrixEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CColorMatrixEffect::CColorMatrixEffect(this_09,param_1);

+        }

+        else if (param_3 == 0x19) {

+          this = CResource::operator_new(0x58);

+          if (this != (CFilterEffect *)0x0) {

+            *(undefined4 *)(this + 8) = 0;

+            *(longlong *)(this + 0x10) = 0;

+            *(CComposition **)(this + 0x18) = param_1;

+            *(longlong *)(this + 0x20) = 0;

+            *(longlong *)(this + 0x30) = 0;

+            *(undefined4 *)(this + 0x28) = 0;

+            ppuVar2 = &CColorResource::_vftable_;

+            *(longlong *)(this + 0x48) = 0;

+            *(longlong *)(this + 0x50) = 0;

+            goto LAB_0;

+          }

+        }

+        else if (param_3 == 0x1a) {

+          this = CResource::operator_new(0xb0);

+          if (this != (CFilterEffect *)0x0) {

+            *(undefined4 *)(this + 8) = 0;

+            *(longlong *)(this + 0x10) = 0;

+            *(CComposition **)(this + 0x18) = param_1;

+            *(longlong *)(this + 0x20) = 0;

+            *(longlong *)(this + 0x30) = 0;

+            *(undefined4 *)(this + 0x28) = 0;

+            memset(this + 0x48,0,100);

+            ppuVar2 = &CColorTransformResource::_vftable_;

+            goto LAB_0;

+          }

+        }

+        else if (param_3 == 0x1b) {

+          this_08 = DefaultHeap::AllocClear(0xb8);

+          if (this_08 == (CCombinedGeometry *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CCombinedGeometry::CCombinedGeometry(this_08,param_1,param_2);

+        }

+        else {

+          if (param_3 == 0x1c) {

+            this = DefaultHeap::AllocClear(0x58);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            *(undefined4 *)(this + 8) = 0;

+            *(longlong *)(this + 0x10) = 0;

+            *(CComposition **)(this + 0x18) = param_1;

+            *(longlong *)(this + 0x20) = 0;

+            *(longlong *)(this + 0x30) = 0;

+            *(undefined4 *)(this + 0x28) = 0;

+            ppuVar2 = &CCompiledEffectTemplate::_vftable_;

+            goto LAB_7;

+          }

+          if (param_3 == 0x1d) {

+            this = DefaultHeap::AllocClear(0xe0);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            *(undefined4 *)(this + 8) = 0;

+            *(longlong *)(this + 0x20) = 0;

+            *(longlong *)(this + 0x10) = 0;

+            *(CComposition **)(this + 0x18) = param_1;

+            *(longlong *)(this + 0x30) = 0;

+            *(undefined4 *)(this + 0x28) = 0;

+            *(undefined4 *)(this + 0x90) = 0;

+            *(uint *)(this + 0x28) = *(uint *)(this + 0x28) | 1;

+            *(undefined ***)this = &CComponentTransform2D::_vftable_;

+            *(undefined4 *)(this + 0xb8) = 0x3f800000;

+            *(undefined4 *)(this + 0xbc) = 0x3f800000;

+            this[0x9c] = (CFilterEffect)0x0;

+            *(undefined8 *)(this + 0xc4) = 0x3f800000;

+            *(undefined8 *)(this + 0xcc) = 0x3f80000000000000;

+            *(undefined8 *)(this + 0xd4) = 0;

+            goto LAB_1;

+          }

+          if (param_3 == 0x1e) {

+            this_07 = DefaultHeap::AllocClear(0x130);

+            if (this_07 == (CComponentTransform3D *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            pCVar1 = (CFilterEffect *)CComponentTransform3D::CComponentTransform3D(this_07,param_1);

+          }

+          else {

+            if (param_3 == 0x1f) {

+              this = DefaultHeap::AllocClear(0xb8);

+              if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              CFilterEffect::CFilterEffect(this,param_1);

+              ppuVar2 = &CCompositeEffect::_vftable_;

+              goto LAB_4;

+            }

+            if (param_3 != 0x20) goto LAB_2;

+            this_06 = DefaultHeap::AllocClear(0x118);

+            if (this_06 == (CCompositionAmbientLight *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            pCVar1 = (CFilterEffect *)

+                     CCompositionAmbientLight::CCompositionAmbientLight(this_06,param_1);

+          }

+        }

+      }

+      else {

+        if (param_3 == 0x22) {

+          this = DefaultHeap::AllocClear(0xa0);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          *(undefined4 *)(this + 8) = 0;

+          *(longlong *)(this + 0x20) = 0;

+          *(longlong *)(this + 0x10) = 0;

+          *(CComposition **)(this + 0x18) = param_1;

+          *(longlong *)(this + 0x30) = 0;

+          *(undefined4 *)(this + 0x28) = 0;

+          *(undefined ***)this =

+               &CCompositionDynamicTexture::

+                _vftable__for__CCompositionDynamicTextureGeneratedT<CCompositionDynamicTexture,CContent>__

+          ;

+          *(undefined ***)(this + 0x50) =

+               &CCompositionDynamicTexture::_vftable__for__IDirtyRectSource__;

+          *(undefined ***)(this + 0x58) = &CRectanglesShape::_vftable_;

+          *(CFilterEffect **)(this + 0x68) = this + 0x80;

+          *(CFilterEffect **)(this + 0x70) = this + 0x80;

+          *(CFilterEffect **)(this + 0x78) = this + 0x90;

+          *(longlong *)(this + 0x60) = 0;

+          *(longlong *)(this + 0x90) = 0;

+          this[0x98] = (CFilterEffect)0x1;

+          goto LAB_1;

+        }

+        if (param_3 == 0x24) {

+          this = DefaultHeap::AllocClear(0xd0);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          *(undefined4 *)(this + 8) = 0;

+          *(longlong *)(this + 0x20) = 0;

+          *(longlong *)(this + 0x10) = 0;

+          *(CComposition **)(this + 0x18) = param_1;

+          *(longlong *)(this + 0x30) = 0;

+          *(undefined4 *)(this + 0x28) = 0;

+          *(longlong *)(this + 0x50) = 0;

+          *(undefined ***)this = &CCompositionMagnifierBrush::_vftable__for__CContent__;

+          *(undefined ***)(this + 0x48) =

+               &CCompositionMagnifierBrush::_vftable__for__IBrushChangeNotification__;

+          *(longlong *)(this + 0x58) = 0;

+          this[0x60] = (CFilterEffect)0x0;

+          *(undefined4 *)(this + 0x68) = 0x3f800000;

+          *(undefined2 *)(this + 0x6c) = 0;

+          memset(this + 0x70,0,0x50);

+          this[200] = (CFilterEffect)0x0;

+          *(undefined2 *)(this + 0xcc) = 0;

+          this[0xce] = (CFilterEffect)0x0;

+          goto LAB_1;

+        }

+        if (param_3 == 0x25) {

+          this = DefaultHeap::AllocClear(0xb0);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          *(undefined4 *)(this + 8) = 0;

+          *(longlong *)(this + 0x20) = 0;

+          *(longlong *)(this + 0x10) = 0;

+          *(CComposition **)(this + 0x18) = param_1;

+          *(longlong *)(this + 0x30) = 0;

+          *(undefined4 *)(this + 0x28) = 0;

+          *(undefined ***)this =

+               &CCompositionMipmapSurface::_vftable__for__CPropertyChangeResource__;

+          *(undefined ***)(this + 0x50) =

+               &CCompositionMipmapSurface::_vftable__for__IDeviceResourceNotify__;

+          *(undefined ***)(this + 0x58) =

+               &CCompositionMipmapSurface::_vftable__for__ISceneNotificationListener__;

+          *(longlong *)(this + 0x60) = 0;

+          *(longlong *)(this + 0x68) = 0;

+          *(longlong *)(this + 0x70) = 0;

+LAB_6:

+          *(longlong *)(this + 0x98) = 0;

+          *(longlong *)(this + 0xa8) = 0;

+          goto LAB_1;

+        }

+        if (param_3 == 0x26) {

+          this_13 = DefaultHeap::AllocClear(0x140);

+          if (this_13 == (CCompositionPointLight *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CCompositionPointLight::CCompositionPointLight(this_13,param_1);

+        }

+        else if (param_3 == 0x28) {

+          this_12 = DefaultHeap::AllocClear(0x198);

+          if (this_12 == (CCompositionSpotLight *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CCompositionSpotLight::CCompositionSpotLight(this_12,param_1);

+        }

+        else if (param_3 == 0x29) {

+          this = CCompositionSurfaceBitmap::operator_new(0x60);

+          if (this != (CFilterEffect *)0x0) {

+            *(undefined4 *)(this + 8) = 0;

+            *(longlong *)(this + 0x20) = 0;

+            *(longlong *)(this + 0x10) = 0;

+            *(CComposition **)(this + 0x18) = param_1;

+            *(longlong *)(this + 0x30) = 0;

+            *(undefined4 *)(this + 0x28) = 0;

+            *(undefined ***)this = &CCompositionSurfaceBitmap::_vftable__for__CContent__;

+            *(undefined ***)(this + 0x48) =

+                 &CCompositionSurfaceBitmap::_vftable__for__IBitmapResource__;

+            *(undefined ***)(this + 0x50) =

+                 &CCompositionSurfaceBitmap::_vftable__for__ICompositionSurfaceInfoListener__;

+            *(undefined ***)(this + 0x58) =

+                 &CCompositionSurfaceBitmap::_vftable__for__IDirtyRectSource__;

+            goto LAB_8;

+          }

+        }

+        else {

+          if (param_3 != 0x2b) {

+            if (param_3 == 0x2c) {

+              this = DefaultHeap::AllocClear(0x80);

+              if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              *(undefined4 *)(this + 8) = 0;

+              *(longlong *)(this + 0x20) = 0;

+              *(longlong *)(this + 0x10) = 0;

+              *(CComposition **)(this + 0x18) = param_1;

+              *(longlong *)(this + 0x30) = 0;

+              *(undefined4 *)(this + 0x28) = 0;

+              *(undefined ***)this = &CContainerVectorShape::_vftable_;

+              this[0x60] = (CFilterEffect)0x1;

+              *(longlong *)(this + 0x68) = 0;

+              *(longlong *)(this + 0x70) = 0;

+              goto LAB_9;

+            }

+            goto LAB_2;

+          }

+          this_11 = DefaultHeap::AllocClear(0x170);

+          if (this_11 == (CConditionalExpression *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CConditionalExpression::CConditionalExpression(this_11,param_1);

+        }

+      }

+    }

+    else if (param_3 < 0x4c) {

+      if (param_3 == 0x4b) {

+        this_24 = DefaultHeap::AllocClear(0x70);

+        if (this_24 == (CHolographicExclusiveMode *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        pCVar1 = (CFilterEffect *)

+                 CHolographicExclusiveMode::CHolographicExclusiveMode(this_24,param_1);

+      }

+      else if (param_3 < 0x3b) {

+        if (param_3 == 0x3a) {

+          this = DefaultHeap::AllocClear(0x180);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          CBaseExpression::CBaseExpression((CBaseExpression *)this,param_1);

+          *(undefined ***)this = &CExpression::_vftable_;

+          *(undefined8 *)(this + 0x148) = 0;

+          *(undefined8 *)(this + 0x150) = 0;

+          *(undefined8 *)(this + 0x158) = 0;

+          *(undefined8 *)(this + 0x160) = 0;

+          goto LAB_1;

+        }

+        if (param_3 == 0x30) {

+          this_18 = DefaultHeap::AllocClear(0x2f8);

+          if (this_18 == (CCursorVisual *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CCursorVisual::CCursorVisual(this_18,param_1);

+        }

+        else {

+          if (param_3 == 0x31) {

+            this = DefaultHeap::AllocClear(0x60);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            *(undefined4 *)(this + 8) = 0;

+            *(longlong *)(this + 0x10) = 0;

+            *(CComposition **)(this + 0x18) = param_1;

+            *(longlong *)(this + 0x20) = 0;

+            *(longlong *)(this + 0x30) = 0;

+            *(undefined4 *)(this + 0x28) = 0;

+            ppuVar2 = &CDataSourceReader::_vftable_;

+            goto LAB_0;

+          }

+          if (param_3 == 0x32) {

+            this_17 = DefaultHeap::AllocClear(0x82c0);

+            if (this_17 == (CDDisplayRenderTarget *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            pCVar1 = (CFilterEffect *)CDDisplayRenderTarget::CDDisplayRenderTarget(this_17,param_1);

+          }

+          else if (param_3 == 0x33) {

+            this_16 = CContent::operator_new(200);

+            if (this_16 != (CDelegatedInkCanvas *)0x0) {

+              pCVar1 = (CFilterEffect *)CDelegatedInkCanvas::CDelegatedInkCanvas(this_16,param_1);

+            }

+          }

+          else if (param_3 == 0x34) {

+            this_15 = CDesktopTree::operator_new(0x60);

+            if (this_15 != (CDesktopTree *)0x0) {

+              pCVar1 = (CFilterEffect *)CDesktopTree::CDesktopTree(this_15,param_1);

+            }

+          }

+          else {

+            if (param_3 != 0x35) {

+              if (param_3 == 0x37) {

+                this = DefaultHeap::AllocClear(0xc0);

+                if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                  ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+                }

+                *(undefined4 *)(this + 8) = 0;

+                *(longlong *)(this + 0x20) = 0;

+                *(longlong *)(this + 0x10) = 0;

+                *(CComposition **)(this + 0x18) = param_1;

+                *(longlong *)(this + 0x30) = 0;

+                *(undefined4 *)(this + 0x28) = 0;

+                *(undefined ***)this = &CEffectBrush::_vftable__for__CContent__;

+                *(undefined ***)(this + 0x48) =

+                     &CColorBrush::_vftable__for__IBrushChangeNotification__;

+                *(undefined ***)(this + 0x68) = &CEffectBrush::_vftable_;

+                *(CFilterEffect **)(this + 0x88) = this + 0xa8;

+                *(CFilterEffect **)(this + 0x90) = this + 0xa8;

+                *(longlong *)(this + 0x50) = 0;

+                *(longlong *)(this + 0x58) = 0;

+                *(longlong *)(this + 0x78) = 0;

+                *(longlong *)(this + 0x80) = 0;

+                *(undefined4 *)(this + 0x98) = 2;

+                *(undefined8 *)(this + 0x9c) = 2;

+                this[0xb8] = (CFilterEffect)0x0;

+                this[0x60] = (CFilterEffect)0x1;

+                goto LAB_1;

+              }

+              if (param_3 == 0x38) {

+                this = DefaultHeap::AllocClear(0x60);

+                if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                  ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+                }

+                *(undefined4 *)(this + 8) = 0;

+                *(longlong *)(this + 0x20) = 0;

+                *(longlong *)(this + 0x10) = 0;

+                *(CComposition **)(this + 0x18) = param_1;

+                *(longlong *)(this + 0x30) = 0;

+                *(undefined4 *)(this + 0x28) = 0;

+                ppuVar2 = &CEffectGroup::_vftable_;

+                *(undefined4 *)(this + 0x50) = 0x3f800000;

+              }

+              else {

+                if (param_3 != 0x39) goto LAB_2;

+                this = DefaultHeap::AllocClear(0x98);

+                if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                  ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+                }

+                *(undefined4 *)(this + 8) = 0;

+                *(longlong *)(this + 0x20) = 0;

+                *(longlong *)(this + 0x10) = 0;

+                *(CComposition **)(this + 0x18) = param_1;

+                *(longlong *)(this + 0x30) = 0;

+                *(undefined4 *)(this + 0x28) = 0;

+                ppuVar2 = &CEllipseGeometry::_vftable_;

+                *(longlong *)(this + 0x58) = 0;

+                this[0x60] = (CFilterEffect)0x0;

+                *(longlong *)(this + 0x68) = 0;

+                this[0x70] = (CFilterEffect)0x0;

+                *(uint *)(this + 0x28) = *(uint *)(this + 0x28) | 1;

+                *(undefined4 *)(this + 0x7c) = 0x3f800000;

+              }

+              goto LAB_0;

+            }

+            this_14 = DefaultHeap::AllocClear(0x110);

+            if (this_14 == (CDropShadow *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            pCVar1 = (CFilterEffect *)CDropShadow::CDropShadow(this_14,param_1);

+          }

+        }

+      }

+      else if (param_3 == 0x3c) {

+        this = CResource::operator_new(0x50);

+        if (this != (CFilterEffect *)0x0) {

+          *(undefined4 *)(this + 8) = 0;

+          *(longlong *)(this + 0x20) = 0;

+          *(longlong *)(this + 0x10) = 0;

+          *(CComposition **)(this + 0x18) = param_1;

+          *(longlong *)(this + 0x30) = 0;

+          *(undefined4 *)(this + 0x28) = 0;

+          ppuVar2 = &CFloatResource::_vftable_;

+          *(undefined4 *)(this + 0x48) = 0;

+          goto LAB_0;

+        }

+      }

+      else {

+        if (param_3 == 0x3d) {

+          this = DefaultHeap::AllocClear(0xc0);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          CFilterEffect::CFilterEffect(this,param_1);

+          *(undefined8 *)(this + 0xb0) = 0;

+          *(undefined ***)this = &CFloodEffect::_vftable_;

+          *(undefined4 *)(this + 0xb8) = 0;

+          *(undefined4 *)(this + 0xbc) = 0x3f800000;

+          goto LAB_1;

+        }

+        if (param_3 == 0x3e) {

+          this = DefaultHeap::AllocClear(0xc0);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          CFilterEffect::CFilterEffect(this,param_1);

+          ppuVar2 = &CGaussianBlurEffect::_vftable_;

+          *(undefined8 *)(this + 0xb0) = 0x40400000;

+LAB_10:

+          *(undefined ***)this = ppuVar2;

+          *(undefined4 *)(this + 0xb8) = 0;

+          goto LAB_1;

+        }

+        if (param_3 == 0x3f) {

+          this_23 = DefaultHeap::AllocClear(0x1e0);

+          if (this_23 == (CGdiSpriteBitmap *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CGdiSpriteBitmap::CGdiSpriteBitmap(this_23,param_1);

+        }

+        else if (param_3 == 0x40) {

+          this_22 = DefaultHeap::AllocClear(0x158);

+          if (this_22 == (CGenericInk *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CGenericInk::CGenericInk(this_22,param_1);

+        }

+        else if (param_3 == 0x43) {

+          this_21 = DefaultHeap::AllocClear(0xa8);

+          if (this_21 == (CGeometry2DGroup *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CGeometry2DGroup::CGeometry2DGroup(this_21,param_1,param_2);

+        }

+        else if (param_3 == 0x44) {

+          this_20 = DefaultHeap::AllocClear(0xb8);

+          if (this_20 == (CGeometryGroup *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CGeometryGroup::CGeometryGroup(this_20,param_1,param_2);

+        }

+        else {

+          if (param_3 == 0x49) {

+            this = DefaultHeap::AllocClear(0x80);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            *(undefined4 *)(this + 8) = 0;

+            *(longlong *)(this + 0x20) = 0;

+            *(longlong *)(this + 0x10) = 0;

+            *(CComposition **)(this + 0x18) = param_1;

+            *(longlong *)(this + 0x30) = 0;

+            *(undefined4 *)(this + 0x28) = 0;

+            *(undefined ***)this = &CHolographicComposition::_vftable__for__CNotificationResource__;

+            *(undefined ***)(this + 0x50) =

+                 &CHolographicComposition::_vftable__for__IHolographicComposition__;

+            *(CComposition **)(this + 0x58) = param_1;

+            *(longlong *)(this + 0x60) = *(longlong *)(param_1 + 0x2c0);

+            goto LAB_1;

+          }

+          if (param_3 != 0x4a) goto LAB_2;

+          this_19 = DefaultHeap::AllocClear(0x90);

+          if (this_19 == (CHolographicDisplay *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CHolographicDisplay::CHolographicDisplay(this_19,param_1);

+        }

+      }

+    }

+    else if (param_3 < 0x57) {

+      if (param_3 == 0x56) {

+        this = CContent::operator_new(0xd8);

+        if (this != (CFilterEffect *)0x0) {

+          *(undefined4 *)(this + 8) = 0;

+          *(longlong *)(this + 0x20) = 0;

+          *(longlong *)(this + 0x10) = 0;

+          *(CComposition **)(this + 0x18) = param_1;

+          *(longlong *)(this + 0x30) = 0;

+          *(undefined4 *)(this + 0x28) = 0;

+          *(undefined ***)this = &CInk::_vftable_;

+          *(undefined ***)(this + 0x48) = &CDeviceResourceTable<CD2DInk,CInk>::_vftable_;

+          *(CFilterEffect **)(this + 0x58) = this + 0x70;

+          *(CFilterEffect **)(this + 0x60) = this + 0x70;

+          *(CFilterEffect **)(this + 0x68) = this + 0x80;

+          *(CFilterEffect **)(this + 0x50) = this;

+          *(longlong *)(this + 0x90) = 0;

+          *(longlong *)(this + 0x98) = 0;

+          *(longlong *)(this + 0xa0) = 0;

+          *(undefined4 *)(this + 0xa8) = 0;

+          goto LAB_1;

+        }

+      }

+      else if (param_3 == 0x4c) {

+        this_29 = DefaultHeap::AllocClear(0x1a8);

+        if (this_29 == (CHolographicExclusiveView *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        pCVar1 = (CFilterEffect *)

+                 CHolographicExclusiveView::CHolographicExclusiveView(this_29,param_1);

+      }

+      else if (param_3 == 0x4d) {

+        this_28 = CHolographicInteropTarget::operator_new(0x60);

+        if (this_28 != (CHolographicInteropTarget *)0x0) {

+          pCVar1 = (CFilterEffect *)

+                   CHolographicInteropTarget::CHolographicInteropTarget(this_28,param_1);

+        }

+      }

+      else if (param_3 == 0x4e) {

+        this_27 = DefaultHeap::AllocClear(0x8f0);

+        if (this_27 == (CHolographicInteropTexture *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        pCVar1 = (CFilterEffect *)

+                 CHolographicInteropTexture::CHolographicInteropTexture(this_27,param_1);

+      }

+      else if (param_3 == 0x4f) {

+        this_26 = DefaultHeap::AllocClear(200);

+        if (this_26 == (CHolographicViewer *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        pCVar1 = (CFilterEffect *)CHolographicViewer::CHolographicViewer(this_26,param_1);

+      }

+      else if (param_3 == 0x50) {

+        puVar3 = DefaultHeap::AllocClear(0x60);

+        if (puVar3 == (undefined8 *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        *(undefined4 *)(puVar3 + 2) = 0;

+        puVar3[3] = 0;

+        puVar3[4] = param_1;

+        puVar3[5] = 0;

+        puVar3[7] = 0;

+        *(undefined4 *)(puVar3 + 6) = 0;

+        *puVar3 = &CHoverPointerSource::_vftable__for__IHoverPointerSourceResource__;

+        *(undefined ***)(puVar3 + 1) = &CHoverPointerSource::_vftable__for__CResource__;

+        puVar3[10] = 0;

+        puVar3[0xb] = 0;

+        pCVar1 = (CFilterEffect *)(puVar3 + 1);

+      }

+      else {

+        if (param_3 == 0x51) {

+          this = DefaultHeap::AllocClear(0xb8);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          CFilterEffect::CFilterEffect(this,param_1);

+          ppuVar2 = &CHueRotationEffect::_vftable_;

+          goto LAB_4;

+        }

+        if (param_3 == 0x52) {

+          this = DefaultHeap::AllocClear(0x108);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          *(undefined4 *)(this + 8) = 0;

+          *(longlong *)(this + 0x20) = 0;

+          *(longlong *)(this + 0x10) = 0;

+          *(CComposition **)(this + 0x18) = param_1;

+          *(longlong *)(this + 0x30) = 0;

+          *(undefined4 *)(this + 0x28) = 0;

+          *(uint *)(this + 0x28) = *(uint *)(this + 0x28) | 1;

+          *(undefined ***)this = &CImageLegacyMilBrush::_vftable_;

+          *(undefined4 *)(this + 200) = 0x3f800000;

+          *(undefined4 *)(this + 0xcc) = 0x3f800000;

+          *(undefined4 *)(this + 0xd0) = 0x3f800000;

+          *(undefined8 *)(this + 0xd4) = 0x3f800000;

+          *(undefined8 *)(this + 0xdc) = 0;

+          *(undefined4 *)(this + 0xe4) = 0;

+          this[0xe8] = (CFilterEffect)0x0;

+          *(undefined8 *)(this + 0xf4) = 0;

+          *(undefined8 *)(this + 0xfc) = 0;

+          goto LAB_1;

+        }

+        if (param_3 != 0x54) {

+          if (param_3 == 0x55) {

+            this = DefaultHeap::AllocClear(0x158);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            CBaseExpression::CBaseExpression((CBaseExpression *)this,param_1);

+            *(undefined8 *)(this + 0x140) = 0;

+            *(undefined ***)this = &CInjectionAnimation::_vftable_;

+            *(undefined8 *)(this + 0x14c) = 0;

+            goto LAB_1;

+          }

+          goto LAB_2;

+        }

+        this_25 = DefaultHeap::AllocClear(0xaf0);

+        if (this_25 == (CIndirectSwapchainRenderTarget *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        pCVar1 = (CFilterEffect *)

+                 CIndirectSwapchainRenderTarget::CIndirectSwapchainRenderTarget(this_25,param_1);

+      }

+    }

+    else if (param_3 == 0x57) {

+      this_35 = DefaultHeap::AllocClear(0x6c8);

+      if (this_35 == (CInteraction *)0x0) {

+                    /* WARNING: Subroutine does not return */

+        ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+      }

+      pCVar1 = (CFilterEffect *)CInteraction::CInteraction(this_35,param_1);

+    }

+    else if (param_3 == 0x58) {

+      this_34 = DefaultHeap::AllocClear(0x288);

+      if (this_34 == (CInteractionTracker *)0x0) {

+                    /* WARNING: Subroutine does not return */

+        ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+      }

+      pCVar1 = (CFilterEffect *)CInteractionTracker::CInteractionTracker(this_34,param_1);

+    }

+    else if (param_3 == 0x59) {

+      this_33 = DefaultHeap::AllocClear(0x90);

+      if (this_33 == (CInteractionTrackerBindingManager *)0x0) {

+                    /* WARNING: Subroutine does not return */

+        ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+      }

+      pCVar1 = (CFilterEffect *)

+               CInteractionTrackerBindingManager::CInteractionTrackerBindingManager(this_33,param_1)

+      ;

+    }

+    else if (param_3 == 0x5a) {

+      this_32 = DefaultHeap::AllocClear(0x220);

+      if (this_32 == (CKeyframeAnimation *)0x0) {

+                    /* WARNING: Subroutine does not return */

+        ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+      }

+      pCVar1 = (CFilterEffect *)CKeyframeAnimation::CKeyframeAnimation(this_32,param_1);

+    }

+    else {

+      if (param_3 == 0x5b) {

+        this = DefaultHeap::AllocClear(0x2c8);

+        if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        CVisual::CVisual((CVisual *)this,param_1);

+        *(undefined ***)this = &CLayerVisual::_vftable_;

+        *(undefined8 *)(this + 0x2b8) = 0;

+        goto LAB_1;

+      }

+      if (param_3 == 0x5c) {

+        this = DefaultHeap::AllocClear(0x70);

+        if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        *(undefined4 *)(this + 8) = 0;

+        *(longlong *)(this + 0x20) = 0;

+        *(longlong *)(this + 0x10) = 0;

+        *(CComposition **)(this + 0x18) = param_1;

+        *(longlong *)(this + 0x30) = 0;

+        *(undefined4 *)(this + 0x28) = 0;

+        *(undefined ***)this = &CLegacyAnimationTrigger::_vftable_;

+        *(longlong *)(this + 0x48) = 0;

+        *(longlong *)(this + 0x50) = 0;

+        *(longlong *)(this + 0x58) = 0;

+        *(undefined4 *)(this + 0x60) = 0;

+        goto LAB_1;

+      }

+      if (param_3 == 0x5e) {

+        this_31 = DefaultHeap::AllocClear(0x82b8);

+        if (this_31 == (CLegacyRenderTarget *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        pCVar1 = (CFilterEffect *)CLegacyRenderTarget::CLegacyRenderTarget(this_31,param_1);

+      }

+      else {

+        if (param_3 != 0x5f) {

+LAB_2:

+          lVar6 = -0x7767fbfd;

+          uVar7 = 0x288;

+          goto LAB_11;

+        }

+        this_30 = DefaultHeap::AllocClear(0x82c8);

+        if (this_30 == (CLegacyStereoRenderTarget *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        pCVar1 = (CFilterEffect *)

+                 CLegacyStereoRenderTarget::CLegacyStereoRenderTarget(this_30,param_1);

+      }

+    }

+  }

+  else if (param_3 < 0x90) {

+    if (param_3 == 0x8f) {

+      this_53 = DefaultHeap::AllocClear(0xb8);

+      if (this_53 == (CSceneMesh *)0x0) {

+                    /* WARNING: Subroutine does not return */

+        ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+      }

+      pCVar1 = (CFilterEffect *)CSceneMesh::CSceneMesh(this_53,param_1);

+    }

+    else if (param_3 < 0x77) {

+      if (param_3 == 0x76) {

+        this_46 = DefaultHeap::AllocClear(0x90);

+        if (this_46 == (CProjectedShadowCaster *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        pCVar1 = (CFilterEffect *)CProjectedShadowCaster::CProjectedShadowCaster(this_46,param_1);

+      }

+      else if (param_3 < 0x6c) {

+        if (param_3 == 0x6b) {

+          this = DefaultHeap::AllocClear(0xb8);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          CTransform::CTransform((CTransform *)this,param_1);

+          *(undefined4 *)(this + 0xa0) = 0x3f800000;

+          *(undefined4 *)(this + 0xac) = 0x3f800000;

+          *(undefined ***)this = &CMatrixTransform::_vftable_;

+          goto LAB_1;

+        }

+        if (param_3 == 0x61) {

+          this_40 = DefaultHeap::AllocClear(0x100);

+          if (this_40 == (CLinearGradientBrush *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CLinearGradientBrush::CLinearGradientBrush(this_40,param_1);

+        }

+        else {

+          if (param_3 == 0x62) {

+            this = DefaultHeap::AllocClear(0xd8);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            *(undefined4 *)(this + 8) = 0;

+            *(longlong *)(this + 0x20) = 0;

+            *(longlong *)(this + 0x10) = 0;

+            *(CComposition **)(this + 0x18) = param_1;

+            *(longlong *)(this + 0x30) = 0;

+            *(undefined4 *)(this + 0x28) = 0;

+            *(uint *)(this + 0x28) = *(uint *)(this + 0x28) | 1;

+            *(undefined ***)this = &CLinearGradientLegacyMilBrush::_vftable_;

+            *(longlong *)(this + 0x78) = 0;

+            *(longlong *)(this + 0x80) = 0;

+            *(longlong *)(this + 0x88) = 0;

+            *(longlong *)(this + 0xa0) = 0;

+            *(longlong *)(this + 0xa8) = 0;

+            *(longlong *)(this + 0xb8) = 0;

+            *(longlong *)(this + 0xc0) = 0;

+            *(longlong *)(this + 200) = 0;

+            goto LAB_1;

+          }

+          if (param_3 == 99) {

+            this_39 = DefaultHeap::AllocClear(0xe0);

+            if (this_39 == (CLinearTransferEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            pCVar1 = (CFilterEffect *)CLinearTransferEffect::CLinearTransferEffect(this_39,param_1);

+          }

+          else {

+            if (param_3 == 100) {

+              this = DefaultHeap::AllocClear(0x98);

+              if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              CGeometry::CGeometry((CGeometry *)this,param_1);

+              ppuVar2 = &CLineGeometry::_vftable_;

+              goto LAB_12;

+            }

+            if (param_3 == 0x66) {

+              this_38 = DefaultHeap::AllocClear(0xb90);

+              if (this_38 == (CMagnifierRenderTarget *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              pCVar1 = (CFilterEffect *)

+                       CMagnifierRenderTarget::CMagnifierRenderTarget(this_38,param_1);

+            }

+            else if (param_3 == 0x67) {

+              this_37 = DefaultHeap::AllocClear(0x2e0);

+              if (this_37 == (CManipulation *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              pCVar1 = (CFilterEffect *)CManipulation::CManipulation(this_37,param_1);

+            }

+            else if (param_3 == 0x68) {

+              this_36 = DefaultHeap::AllocClear(0x118);

+              if (this_36 == (CManipulationTransform *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              pCVar1 = (CFilterEffect *)

+                       CManipulationTransform::CManipulationTransform(this_36,param_1);

+            }

+            else {

+              if (param_3 == 0x69) {

+                this = DefaultHeap::AllocClear(0x80);

+                if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                  ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+                }

+                *(undefined4 *)(this + 8) = 0;

+                *(longlong *)(this + 0x20) = 0;

+                *(longlong *)(this + 0x10) = 0;

+                *(CComposition **)(this + 0x18) = param_1;

+                *(longlong *)(this + 0x30) = 0;

+                *(undefined4 *)(this + 0x28) = 0;

+                *(undefined ***)this = &CMaskBrush::_vftable__for__CContent__;

+                *(undefined ***)(this + 0x48) =

+                     &CColorBrush::_vftable__for__IBrushChangeNotification__;

+                *(undefined ***)(this + 0x68) = &CMaskBrush::_vftable_;

+                *(longlong *)(this + 0x50) = 0;

+                *(longlong *)(this + 0x58) = 0;

+                this[0x60] = (CFilterEffect)0x0;

+                goto LAB_1;

+              }

+              if (param_3 != 0x6a) goto LAB_2;

+              this = CResource::operator_new(0x60);

+              if (this != (CFilterEffect *)0x0) {

+                *(undefined4 *)(this + 8) = 0;

+                *(longlong *)(this + 0x10) = 0;

+                *(CComposition **)(this + 0x18) = param_1;

+                *(longlong *)(this + 0x20) = 0;

+                *(longlong *)(this + 0x30) = 0;

+                *(undefined4 *)(this + 0x28) = 0;

+                *(longlong *)(this + 0x48) = 0;

+                *(longlong *)(this + 0x50) = 0;

+                *(longlong *)(this + 0x58) = 0;

+                ppuVar2 = &CMatrixResource::_vftable_;

+                goto LAB_0;

+              }

+            }

+          }

+        }

+      }

+      else {

+        if (param_3 == 0x6c) {

+          this = DefaultHeap::AllocClear(0xe0);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          CTransform3D::CTransform3D((CTransform3D *)this,param_1,false);

+          *(undefined4 *)(this + 0xa0) = 0x3f800000;

+          *(undefined4 *)(this + 0xb4) = 0x3f800000;

+          *(undefined4 *)(this + 200) = 0x3f800000;

+          *(undefined4 *)(this + 0xdc) = 0x3f800000;

+          *(undefined ***)this = &CMatrixTransform3D::_vftable_;

+          goto LAB_1;

+        }

+        if (param_3 == 0x6d) {

+          this_45 = DefaultHeap::AllocClear(0xc0);

+          if (this_45 == (CMeshGeometry2D *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CMeshGeometry2D::CMeshGeometry2D(this_45,param_1);

+        }

+        else if (param_3 == 0x6e) {

+          this_44 = DefaultHeap::AllocClear(0x240);

+          if (this_44 == (CNaturalAnimation *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CNaturalAnimation::CNaturalAnimation(this_44,param_1);

+        }

+        else if (param_3 == 0x6f) {

+          this_43 = DefaultHeap::AllocClear(0xb0);

+          if (this_43 == (CNineGridBrush *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CNineGridBrush::CNineGridBrush(this_43,param_1,false);

+        }

+        else {

+          if (param_3 == 0x71) {

+            this = DefaultHeap::AllocClear(0x90);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            CGeometry::CGeometry((CGeometry *)this,param_1);

+            *(undefined ***)this = &CPathGeometry::_vftable_;

+            *(undefined8 *)(this + 0x88) = 0;

+            goto LAB_1;

+          }

+          if (param_3 == 0x72) {

+            this = CResource::operator_new(0x50);

+            if (this != (CFilterEffect *)0x0) {

+              *(undefined4 *)(this + 8) = 0;

+              *(longlong *)(this + 0x10) = 0;

+              *(CComposition **)(this + 0x18) = param_1;

+              *(longlong *)(this + 0x20) = 0;

+              *(longlong *)(this + 0x30) = 0;

+              *(undefined4 *)(this + 0x28) = 0;

+              *(longlong *)(this + 0x48) = 0;

+              ppuVar2 = &CPointResource::_vftable_;

+              goto LAB_0;

+            }

+          }

+          else {

+            if (param_3 == 0x73) {

+              this = DefaultHeap::AllocClear(0x58);

+              if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              *(undefined4 *)(this + 8) = 0;

+              *(longlong *)(this + 0x10) = 0;

+              *(CComposition **)(this + 0x18) = param_1;

+              *(longlong *)(this + 0x20) = 0;

+              *(longlong *)(this + 0x30) = 0;

+              *(undefined4 *)(this + 0x28) = 0;

+              ppuVar2 = &CPrimitiveColor::_vftable_;

+              goto LAB_0;

+            }

+            if (param_3 == 0x74) {

+              this_42 = DefaultHeap::AllocClear(0x250);

+              if (this_42 == (CPrimitiveGroup *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              pCVar1 = (CFilterEffect *)CPrimitiveGroup::CPrimitiveGroup(this_42,param_1);

+            }

+            else {

+              if (param_3 != 0x75) goto LAB_2;

+              this_41 = CProjectedShadow::operator_new(0x60);

+              if (this_41 != (CProjectedShadow *)0x0) {

+                pCVar1 = (CFilterEffect *)CProjectedShadow::CProjectedShadow(this_41,param_1);

+              }

+            }

+          }

+        }

+      }

+    }

+    else if (param_3 < 0x82) {

+      if (param_3 == 0x81) {

+        this_50 = DefaultHeap::AllocClear(0xa20);

+        if (this_50 == (CRemoteAppRenderTarget *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        pCVar1 = (CFilterEffect *)CRemoteAppRenderTarget::CRemoteAppRenderTarget(this_50,param_1);

+      }

+      else {

+        if (param_3 == 0x77) {

+          this = DefaultHeap::AllocClear(0x80);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          *(undefined4 *)(this + 8) = 0;

+          *(longlong *)(this + 0x20) = 0;

+          *(longlong *)(this + 0x10) = 0;

+          *(CComposition **)(this + 0x18) = param_1;

+          *(longlong *)(this + 0x30) = 0;

+          *(undefined4 *)(this + 0x28) = 0;

+          *(undefined ***)this = &CProjectedShadowReceiver::_vftable_;

+          *(longlong *)(this + 0x60) = 0;

+LAB_9:

+          *(longlong *)(this + 0x58) = 0;

+          *(longlong *)(this + 0x50) = 0;

+          *(longlong *)(this + 0x78) = 0;

+          goto LAB_1;

+        }

+        if (param_3 == 0x78) {

+          this_49 = DefaultHeap::AllocClear(0x90);

+          if (this_49 == (CProjectedShadowScene *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CProjectedShadowScene::CProjectedShadowScene(this_49,param_1);

+        }

+        else {

+          if (param_3 == 0x7a) {

+            this = DefaultHeap::AllocClear(0xa0);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            *(undefined4 *)(this + 8) = 0;

+            *(longlong *)(this + 0x20) = 0;

+            *(longlong *)(this + 0x10) = 0;

+            *(CComposition **)(this + 0x18) = param_1;

+            *(longlong *)(this + 0x30) = 0;

+            *(undefined4 *)(this + 0x28) = 0;

+            *(undefined ***)this = &CPropertySet::_vftable_;

+            *(longlong *)(this + 0x58) = 0;

+            *(longlong *)(this + 0x60) = 0;

+            *(longlong *)(this + 0x68) = 0;

+            *(undefined4 *)(this + 0x70) = 0;

+            *(longlong *)(this + 0x78) = 0;

+            *(longlong *)(this + 0x80) = 0;

+            *(longlong *)(this + 0x88) = 0;

+            *(undefined4 *)(this + 0x90) = 0;

+            goto LAB_1;

+          }

+          if (param_3 == 0x7b) {

+            this = DefaultHeap::AllocClear(0x98);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            CGeometry::CGeometry((CGeometry *)this,param_1);

+            ppuVar2 = &CProxyGeometry::_vftable_;

+            goto LAB_12;

+          }

+          if (param_3 == 0x7c) {

+            this_48 = DefaultHeap::AllocClear(0x110);

+            if (this_48 == (CRadialGradientBrush *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            pCVar1 = (CFilterEffect *)CRadialGradientBrush::CRadialGradientBrush(this_48,param_1);

+            goto LAB_13;

+          }

+          if (param_3 == 0x7d) {

+            this = DefaultHeap::AllocClear(200);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            CGeometry::CGeometry((CGeometry *)this,param_1);

+            ppuVar2 = &CRectangleGeometry::_vftable_;

+            goto LAB_10;

+          }

+          if (param_3 == 0x7e) {

+            this = CResource::operator_new(0x58);

+            if (this != (CFilterEffect *)0x0) {

+              *(undefined4 *)(this + 8) = 0;

+              *(longlong *)(this + 0x10) = 0;

+              *(CComposition **)(this + 0x18) = param_1;

+              *(longlong *)(this + 0x20) = 0;

+              *(longlong *)(this + 0x30) = 0;

+              *(undefined4 *)(this + 0x28) = 0;

+              ppuVar2 = &CRectResource::_vftable_;

+              *(longlong *)(this + 0x48) = 0;

+              *(longlong *)(this + 0x50) = 0;

+              goto LAB_0;

+            }

+          }

+          else {

+            if (param_3 == 0x7f) {

+              this = DefaultHeap::AllocClear(0x2a8);

+              if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              CVisual::CVisual((CVisual *)this,param_1);

+              ppuVar2 = &CRedirectVisual::_vftable_;

+              goto LAB_0;

+            }

+            if (param_3 != 0x80) goto LAB_2;

+            this_47 = DefaultHeap::AllocClear(0xa8);

+            if (this_47 == (CRegionGeometry *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            pCVar1 = (CFilterEffect *)CRegionGeometry::CRegionGeometry(this_47,param_1);

+          }

+        }

+      }

+    }

+    else if (param_3 == 0x82) {

+      this_52 = DefaultHeap::AllocClear(0xa50);

+      if (this_52 == (CRemoteRenderTarget *)0x0) {

+                    /* WARNING: Subroutine does not return */

+        ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+      }

+      pCVar1 = (CFilterEffect *)CRemoteRenderTarget::CRemoteRenderTarget(this_52,param_1);

+    }

+    else {

+      if (param_3 != 0x83) {

+        if (param_3 == 0x86) {

+          this = DefaultHeap::AllocClear(0xb0);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          CTransform::CTransform((CTransform *)this,param_1);

+          ppuVar2 = &CRotateTransform::_vftable_;

+          goto LAB_12;

+        }

+        if (param_3 == 0x87) {

+          this = DefaultHeap::AllocClear(0xc0);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar5 = (CTransform3D *)this;

+          CTransform3D::CTransform3D((CTransform3D *)this,param_1,false);

+          ppuVar2 = &CRotateTransform3D::_vftable_;

+          *(undefined4 *)(pCVar5 + 0xac) = 0x3f800000;

+        }

+        else {

+          if (param_3 == 0x88) {

+            this = DefaultHeap::AllocClear(0xb8);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            CFilterEffect::CFilterEffect(this,param_1);

+            *(undefined4 *)(this + 0xb0) = 0x3f000000;

+            *(undefined ***)this = &CSaturationEffect::_vftable_;

+            goto LAB_1;

+          }

+          if (param_3 == 0x89) {

+            this = DefaultHeap::AllocClear(0x80);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            CBaseAnimation::CBaseAnimation((CBaseAnimation *)this,param_1);

+            *(undefined ***)this = &CScalar::_vftable__for__CResource__;

+            ppuVar2 = &CScalar::_vftable__for__IAnimationResource__;

+            goto LAB_5;

+          }

+          if (param_3 == 0x8a) {

+            this = DefaultHeap::AllocClear(0xb0);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            pCVar4 = (CTransform *)this;

+            CTransform::CTransform((CTransform *)this,param_1);

+            *(undefined4 *)(pCVar4 + 0xa0) = 0x3f800000;

+            *(undefined4 *)(pCVar4 + 0xa4) = 0x3f800000;

+            ppuVar2 = &CScaleTransform::_vftable_;

+          }

+          else {

+            if (param_3 != 0x8b) goto LAB_2;

+            this = DefaultHeap::AllocClear(0xb8);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            pCVar5 = (CTransform3D *)this;

+            CTransform3D::CTransform3D((CTransform3D *)this,param_1,false);

+            *(undefined4 *)(pCVar5 + 0xa0) = 0x3f800000;

+            *(undefined4 *)(pCVar5 + 0xa4) = 0x3f800000;

+            *(undefined4 *)(pCVar5 + 0xa8) = 0x3f800000;

+            ppuVar2 = &CScaleTransform3D::_vftable_;

+          }

+        }

+        goto LAB_0;

+      }

+      this_51 = CContent::operator_new(0x130);

+      if (this_51 != (CRenderData *)0x0) {

+        pCVar1 = (CFilterEffect *)CRenderData::CRenderData(this_51,param_1);

+      }

+    }

+  }

+  else if (param_3 < 0xa8) {

+    if (param_3 == 0xa7) {

+      this_61 = DefaultHeap::AllocClear(0xd0);

+      if (this_61 == (CSurfaceBrush *)0x0) {

+                    /* WARNING: Subroutine does not return */

+        ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+      }

+      pCVar1 = (CFilterEffect *)CSurfaceBrush::CSurfaceBrush(this_61,param_1);

+    }

+    else if (param_3 < 0x9d) {

+      if (param_3 == 0x9c) {

+        this = DefaultHeap::AllocClear(0x68);

+        if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        *(undefined4 *)(this + 8) = 0;

+        *(longlong *)(this + 0x20) = 0;

+        *(longlong *)(this + 0x10) = 0;

+        *(CComposition **)(this + 0x18) = param_1;

+        *(longlong *)(this + 0x30) = 0;

+        *(undefined4 *)(this + 0x28) = 0;

+        *(undefined ***)this = &CSharedSectionBase::_vftable_;

+        *(longlong *)(this + 0x58) = 0;

+LAB_8:

+        *(longlong *)(this + 0x60) = 0;

+        goto LAB_1;

+      }

+      if (param_3 == 0x90) {

+        this_59 = DefaultHeap::AllocClear(0x80);

+        if (this_59 == (CSceneMeshRendererComponent *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        pCVar1 = (CFilterEffect *)

+                 CSceneMeshRendererComponent::CSceneMeshRendererComponent(this_59,param_1);

+      }

+      else if (param_3 == 0x91) {

+        this_58 = DefaultHeap::AllocClear(0xc0);

+        if (this_58 == (CSceneMetallicRoughnessMaterial *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        pCVar1 = (CFilterEffect *)

+                 CSceneMetallicRoughnessMaterial::CSceneMetallicRoughnessMaterial(this_58,param_1);

+      }

+      else {

+        if (param_3 == 0x92) {

+          this = DefaultHeap::AllocClear(0x50);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          *(undefined4 *)(this + 8) = 0;

+          *(longlong *)(this + 0x10) = 0;

+          *(CComposition **)(this + 0x18) = param_1;

+          *(longlong *)(this + 0x20) = 0;

+          *(longlong *)(this + 0x30) = 0;

+          *(undefined4 *)(this + 0x28) = 0;

+          ppuVar2 = &CSceneModelTransform::_vftable_;

+          goto LAB_0;

+        }

+        if (param_3 == 0x93) {

+          this_57 = CSceneNode::operator_new(0x60);

+          if (this_57 != (CSceneNode *)0x0) {

+            pCVar1 = (CFilterEffect *)CSceneNode::CSceneNode(this_57,param_1);

+          }

+        }

+        else if (param_3 == 0x97) {

+          this_56 = DefaultHeap::AllocClear(0x80);

+          if (this_56 == (CSceneSurfaceMaterialInput *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)

+                   CSceneSurfaceMaterialInput::CSceneSurfaceMaterialInput(this_56,param_1);

+        }

+        else if (param_3 == 0x98) {

+          this_55 = DefaultHeap::AllocClear(0x2b8);

+          if (this_55 == (CSceneVisual *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CSceneVisual::CSceneVisual(this_55,param_1);

+        }

+        else {

+          if (param_3 != 0x99) {

+            if (param_3 == 0x9a) {

+              this = DefaultHeap::AllocClear(0x2a8);

+              if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              CVisual::CVisual((CVisual *)this,param_1);

+              ppuVar2 = &CShapeVisual::_vftable_;

+            }

+            else {

+              if (param_3 != 0x9b) goto LAB_2;

+              this = DefaultHeap::AllocClear(0x68);

+              if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              *(undefined4 *)(this + 8) = 0;

+              *(longlong *)(this + 0x20) = 0;

+              *(longlong *)(this + 0x10) = 0;

+              *(CComposition **)(this + 0x18) = param_1;

+              *(longlong *)(this + 0x30) = 0;

+              *(undefined4 *)(this + 0x28) = 0;

+              ppuVar2 = &CSharedSection::_vftable_;

+              *(longlong *)(this + 0x58) = 0;

+              *(longlong *)(this + 0x60) = 0;

+            }

+            goto LAB_0;

+          }

+          this_54 = DefaultHeap::AllocClear(200);

+          if (this_54 == (CShadowEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          pCVar1 = (CFilterEffect *)CShadowEffect::CShadowEffect(this_54,param_1);

+        }

+      }

+    }

+    else {

+      if (param_3 == 0x9d) {

+        this = DefaultHeap::AllocClear(0x58);

+        if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        *(undefined4 *)(this + 8) = 0;

+        *(longlong *)(this + 0x20) = 0;

+        *(longlong *)(this + 0x10) = 0;

+        *(CComposition **)(this + 0x18) = param_1;

+        *(longlong *)(this + 0x30) = 0;

+        *(undefined4 *)(this + 0x28) = 0;

+        *(undefined ***)this = &CSharedSectionWrapper::_vftable_;

+        *(longlong *)(this + 0x48) = 0;

+        goto LAB_1;

+      }

+      if (param_3 == 0x9e) {

+        this = CResource::operator_new(0x50);

+        if (this != (CFilterEffect *)0x0) {

+          *(undefined4 *)(this + 8) = 0;

+          *(longlong *)(this + 0x10) = 0;

+          *(CComposition **)(this + 0x18) = param_1;

+          *(longlong *)(this + 0x20) = 0;

+          *(longlong *)(this + 0x30) = 0;

+          *(undefined4 *)(this + 0x28) = 0;

+          *(longlong *)(this + 0x48) = 0;

+          ppuVar2 = &CSizeResource::_vftable_;

+          goto LAB_0;

+        }

+      }

+      else {

+        if (param_3 == 0x9f) {

+          this = DefaultHeap::AllocClear(0xb0);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          CTransform::CTransform((CTransform *)this,param_1);

+          ppuVar2 = &CSkewTransform::_vftable_;

+          goto LAB_12;

+        }

+        if (param_3 != 0xa0) {

+          if (param_3 == 0xa1) {

+            this = CResource::operator_new(0x48);

+            if (this == (CFilterEffect *)0x0) goto LAB_13;

+            *(undefined4 *)(this + 8) = 0;

+            *(longlong *)(this + 0x10) = 0;

+            *(CComposition **)(this + 0x18) = param_1;

+            *(longlong *)(this + 0x20) = 0;

+            *(longlong *)(this + 0x30) = 0;

+            *(undefined4 *)(this + 0x28) = 0;

+            ppuVar2 = &CSoftwareCursorScope::_vftable_;

+          }

+          else if (param_3 == 0xa2) {

+            this = DefaultHeap::AllocClear(0x78);

+            if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+              ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+            }

+            *(undefined4 *)(this + 8) = 0;

+            *(longlong *)(this + 0x20) = 0;

+            *(longlong *)(this + 0x10) = 0;

+            *(CComposition **)(this + 0x18) = param_1;

+            *(longlong *)(this + 0x30) = 0;

+            *(undefined4 *)(this + 0x28) = 0;

+            ppuVar2 = &CSolidColorLegacyMilBrush::_vftable_;

+            *(uint *)(this + 0x28) = *(uint *)(this + 0x28) | 1;

+          }

+          else {

+            if (param_3 == 0xa3) {

+              this_60 = DefaultHeap::AllocClear(0xd8);

+              if (this_60 == (CSpriteVectorShape *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              pCVar1 = (CFilterEffect *)CSpriteVectorShape::CSpriteVectorShape(this_60,param_1);

+              goto LAB_13;

+            }

+            if (param_3 == 0xa4) {

+              this = DefaultHeap::AllocClear(0x2a8);

+              if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              CVisual::CVisual((CVisual *)this,param_1);

+              ppuVar2 = &CSpriteVisual::_vftable_;

+            }

+            else {

+              if (param_3 != 0xa5) goto LAB_2;

+              this = KeyframeInterpolation::operator_new(0x2b0);

+              if (this == (CFilterEffect *)0x0) goto LAB_13;

+              CVisual::CVisual((CVisual *)this,param_1);

+              ppuVar2 = &CSuperWetInkVisual::_vftable_;

+            }

+          }

+          goto LAB_0;

+        }

+        this = CContent::operator_new(0x60);

+        if (this != (CFilterEffect *)0x0) {

+          *(undefined4 *)(this + 8) = 0;

+          *(longlong *)(this + 0x20) = 0;

+          *(longlong *)(this + 0x10) = 0;

+          *(CComposition **)(this + 0x18) = param_1;

+          *(longlong *)(this + 0x30) = 0;

+          *(undefined4 *)(this + 0x28) = 0;

+          *(undefined ***)this = &CSnapshot::_vftable_;

+          *(longlong *)(this + 0x48) = 0;

+          *(longlong *)(this + 0x50) = 0;

+          *(undefined2 *)(this + 0x58) = 0;

+          goto LAB_1;

+        }

+      }

+    }

+  }

+  else if (param_3 < 0xb5) {

+    if (param_3 == 0xb4) {

+      this_69 = KeyframeInterpolation::operator_new(0x2a8);

+      if (this_69 != (CVisual *)0x0) {

+        pCVar1 = (CFilterEffect *)CVisual::CVisual(this_69,param_1);

+      }

+    }

+    else if (param_3 == 0xa8) {

+      this_68 = CContent::operator_new(0x120);

+      if (this_68 != (CSynchronousSuperWetInk *)0x0) {

+        pCVar1 = (CFilterEffect *)CSynchronousSuperWetInk::CSynchronousSuperWetInk(this_68,param_1);

+      }

+    }

+    else if (param_3 == 0xa9) {

+      this_67 = DefaultHeap::AllocClear(0x158);

+      if (this_67 == (CTableTransferEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+        ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+      }

+      pCVar1 = (CFilterEffect *)CTableTransferEffect::CTableTransferEffect(this_67,param_1);

+    }

+    else if (param_3 == 0xac) {

+      this_66 = DefaultHeap::AllocClear(0xd8);

+      if (this_66 == (CTransform3DGroup *)0x0) {

+                    /* WARNING: Subroutine does not return */

+        ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+      }

+      pCVar1 = (CFilterEffect *)CTransform3DGroup::CTransform3DGroup(this_66,param_1,param_2);

+    }

+    else {

+      if (param_3 != 0xad) {

+        if (param_3 == 0xae) {

+          this = DefaultHeap::AllocClear(0xa8);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          CTransform::CTransform((CTransform *)this,param_1);

+          ppuVar2 = &CTranslateTransform::_vftable_;

+        }

+        else {

+          if (param_3 != 0xaf) {

+            if (param_3 == 0xb0) {

+              this_64 = DefaultHeap::AllocClear(0xd8);

+              if (this_64 == (CTurbulenceEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              pCVar1 = (CFilterEffect *)CTurbulenceEffect::CTurbulenceEffect(this_64,param_1);

+            }

+            else if (param_3 == 0xb2) {

+              this_63 = DefaultHeap::AllocClear(0x100);

+              if (this_63 == (CViewBox *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              pCVar1 = (CFilterEffect *)CViewBox::CViewBox(this_63,param_1);

+            }

+            else {

+              if (param_3 != 0xb3) goto LAB_2;

+              this_62 = DefaultHeap::AllocClear(0xc78);

+              if (this_62 == (CVirtualMonitorCaptureRenderTarget *)0x0) {

+                    /* WARNING: Subroutine does not return */

+                ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+              }

+              pCVar1 = (CFilterEffect *)

+                       CVirtualMonitorCaptureRenderTarget::CVirtualMonitorCaptureRenderTarget

+                                 (this_62,param_1);

+            }

+            goto LAB_13;

+          }

+          this = DefaultHeap::AllocClear(0xb0);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          CTransform3D::CTransform3D((CTransform3D *)this,param_1,false);

+          ppuVar2 = &CTranslateTransform3D::_vftable_;

+        }

+LAB_12:

+        *(undefined ***)this = ppuVar2;

+        goto LAB_1;

+      }

+      this_65 = DefaultHeap::AllocClear(0xd8);

+      if (this_65 == (CTransformGroup *)0x0) {

+                    /* WARNING: Subroutine does not return */

+        ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+      }

+      pCVar1 = (CFilterEffect *)CTransformGroup::CTransformGroup(this_65,param_1,param_2);

+    }

+  }

+  else {

+    if (param_3 == 0xb5) {

+      this = DefaultHeap::AllocClear(0x68);

+      if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+        ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+      }

+      *(undefined4 *)(this + 8) = 0;

+      *(longlong *)(this + 0x20) = 0;

+      *(longlong *)(this + 0x10) = 0;

+      *(CComposition **)(this + 0x18) = param_1;

+      *(longlong *)(this + 0x30) = 0;

+      *(undefined4 *)(this + 0x28) = 0;

+      *(undefined ***)this =

+           &CVisualBitmap::_vftable__for__CVisualBitmapGeneratedT<CVisualBitmap,CContent>__;

+      *(undefined ***)(this + 0x50) = &CVisualBitmap::_vftable__for__IBitmapResource__;

+      goto LAB_1;

+    }

+    if (param_3 == 0xb6) {

+      this_72 = DefaultHeap::AllocClear(0xac0);

+      if (this_72 == (CVisualCapture *)0x0) {

+                    /* WARNING: Subroutine does not return */

+        ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+      }

+      pCVar1 = (CFilterEffect *)CVisualCapture::CVisualCapture(this_72,param_1);

+    }

+    else if (param_3 == 0xb7) {

+      this = CResource::operator_new(0x60);

+      if (this != (CFilterEffect *)0x0) {

+        *(undefined4 *)(this + 8) = 0;

+        *(longlong *)(this + 0x20) = 0;

+        *(longlong *)(this + 0x10) = 0;

+        *(CComposition **)(this + 0x18) = param_1;

+        *(longlong *)(this + 0x30) = 0;

+        *(undefined4 *)(this + 0x28) = 0;

+        *(undefined ***)this = &CVisualGroup::_vftable_;

+        *(longlong *)(this + 0x48) = 0;

+        *(longlong *)(this + 0x50) = 0;

+        *(longlong *)(this + 0x58) = 0;

+        goto LAB_1;

+      }

+    }

+    else {

+      if (param_3 == 0xb9) {

+        this = DefaultHeap::AllocClear(0x58);

+        if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        *(undefined4 *)(this + 8) = 0;

+        *(longlong *)(this + 0x10) = 0;

+        *(CComposition **)(this + 0x18) = param_1;

+        *(longlong *)(this + 0x20) = 0;

+        *(longlong *)(this + 0x30) = 0;

+        *(undefined4 *)(this + 0x28) = 0;

+        ppuVar2 = &CVisualReferenceController::_vftable_;

+LAB_7:

+        *(undefined ***)this = ppuVar2;

+        *(longlong *)(this + 0x50) = 0;

+        goto LAB_1;

+      }

+      if (param_3 == 0xba) {

+        this_71 = CResource::operator_new(0xd0);

+        if (this_71 != (CVisualSurface *)0x0) {

+          pCVar1 = (CFilterEffect *)CVisualSurface::CVisualSurface(this_71,param_1);

+        }

+      }

+      else {

+        if (param_3 == 0xbb) {

+          this = DefaultHeap::AllocClear(0x68);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          CBrush::CBrush((CBrush *)this,param_1);

+          *(undefined ***)this = &CWindowBackdropBrush::_vftable__for__CContent__;

+          ppuVar2 = &CColorBrush::_vftable__for__IBrushChangeNotification__;

+          goto LAB_5;

+        }

+        if (param_3 != 0xbc) {

+          if (param_3 != 0xbd) goto LAB_2;

+          this = DefaultHeap::AllocClear(0x68);

+          if (this == (CFilterEffect *)0x0) {

+                    /* WARNING: Subroutine does not return */

+            ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+          }

+          *(undefined4 *)(this + 8) = 0;

+          *(longlong *)(this + 0x10) = 0;

+          *(CComposition **)(this + 0x18) = param_1;

+          *(longlong *)(this + 0x20) = 0;

+          *(longlong *)(this + 0x30) = 0;

+          *(undefined4 *)(this + 0x28) = 0;

+          ppuVar2 = &CYCbCrSurface::_vftable_;

+          goto LAB_0;

+        }

+        this_70 = DefaultHeap::AllocClear(0x388);

+        if (this_70 == (CWindowNode *)0x0) {

+                    /* WARNING: Subroutine does not return */

+          ModuleFailFastForHRESULT(0x8007000e,unaff_retaddr);

+        }

+        pCVar1 = (CFilterEffect *)CWindowNode::CWindowNode(this_70,param_1);

+      }

+    }

+  }

+LAB_13:

+  this = pCVar1;

+  if (this == (CFilterEffect *)0x0) {

+    lVar6 = -0x7ff8fff2;

+    uVar7 = 0x28b;

+LAB_11:

+    MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar6,uVar7,(void *)0x0);

+    return lVar6;

+  }

+LAB_1:

+  (**(code **)(*(longlong *)this + 8))(this);

+  *param_4 = (CResource *)this;

+  return 0;

+}

+
```

## `Microsoft::BamoImpl::BufferingMessageCallHost::BufferingMessageCallHost`  (modified)

```diff
--- Microsoft::BamoImpl::BufferingMessageCallHost::BufferingMessageCallHost
+++ Microsoft::BamoImpl::BufferingMessageCallHost::BufferingMessageCallHost
@@ -1,2 +1,46 @@
-Failed to decompile dwmcore.dll - .ProgramDB Microsoft::BamoImpl::BufferingMessageCallHost::BufferingMessageCallHost : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: __cdecl Microsoft::BamoImpl::BufferingMessageCallHost::BufferingMessageCallHost(struct

+   IMessageCallSendHost * __ptr64) __ptr64 */

+

+BufferingMessageCallHost * __thiscall

+Microsoft::BamoImpl::BufferingMessageCallHost::BufferingMessageCallHost

+          (BufferingMessageCallHost *this,IMessageCallSendHost *param_1)

+

+{

+  longlong *plVar1;

+  __uint64 _Var2;

+  void *pvVar3;

+  

+  *(undefined ***)this = &_vftable__for__Microsoft__BamoImpl__BamoImplObject__;

+  *(undefined4 *)(this + 8) = 1;

+  *(undefined ***)(this + 0x10) = &_vftable__for__IMessageCallSendHost__;

+  *(undefined8 *)(this + 0x18) = 0;

+  *(undefined8 *)(this + 0x20) = 0;

+  *(undefined8 *)(this + 0x28) = 0;

+  _Var2 = std::_Get_size_of_n<48>(1);

+  pvVar3 = std::_Allocate<16,std::_Default_allocate_traits,0>(_Var2);

+  *(void **)pvVar3 = pvVar3;

+  *(void **)((longlong)pvVar3 + 8) = pvVar3;

+  *(void **)((longlong)pvVar3 + 0x10) = pvVar3;

+  *(undefined2 *)((longlong)pvVar3 + 0x18) = 0x101;

+  *(void **)(this + 0x20) = pvVar3;

+  *(undefined8 *)(this + 0x30) = 0;

+  *(undefined8 *)(this + 0x38) = 0;

+  *(undefined8 *)(this + 0x40) = 0;

+  this[0x48] = (BufferingMessageCallHost)0x0;

+  *(undefined8 *)(this + 0x50) = 0;

+  *(undefined8 *)(this + 0x58) = 0;

+  *(undefined8 *)(this + 0x60) = 0;

+  plVar1 = *(longlong **)(this + 0x18);

+  *(IMessageCallSendHost **)(this + 0x18) = param_1;

+  if (param_1 != (IMessageCallSendHost *)0x0) {

+    (**(code **)(*(longlong *)param_1 + 8))(param_1);

+  }

+  if (plVar1 != (longlong *)0x0) {

+    (**(code **)(*plVar1 + 0x10))(plVar1);

+  }

+  return this;

+}

+
```

## `CSwapchainRenderStrategy::GetDirtyRegion`  (modified)

```diff
--- CSwapchainRenderStrategy::GetDirtyRegion
+++ CSwapchainRenderStrategy::GetDirtyRegion
@@ -1,2 +1,51 @@
-Failed to decompile dwmcore.dll - .ProgramDB CSwapchainRenderStrategy::GetDirtyRegion : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: virtual bool __cdecl CSwapchainRenderStrategy::GetDirtyRegion(class CSurfaceBrush const *

+   __ptr64,struct D2D_SIZE_F const & __ptr64,class CRectanglesShape * __ptr64)const __ptr64 */

+

+bool __thiscall

+CSwapchainRenderStrategy::GetDirtyRegion

+          (CSwapchainRenderStrategy *this,CSurfaceBrush *param_1,D2D_SIZE_F *param_2,

+          CRectanglesShape *param_3)

+

+{

+  bool bVar1;

+  CResource *this_00;

+  CMILMatrix *pCVar2;

+  undefined1 auStack_b8 [32];

+  CMILMatrix local_98 [64];

+  uint local_58;

+  undefined8 local_48;

+  undefined8 uStack_40;

+  ulonglong local_38;

+  

+  local_38 = __security_cookie ^ (ulonglong)auStack_b8;

+  this_00 = CSurfaceBrush::GetSurface(param_1);

+  bVar1 = CBitmapRenderStrategy::HasRenderingRealization

+                    ((IBitmapResource *)

+                     (-(ulonglong)(this_00 != (CResource *)0x0) & (ulonglong)(this_00 + 0x48)));

+  pCVar2 = (CMILMatrix *)0x0;

+  if (bVar1) {

+    local_58 = 0;

+    local_48 = 0;

+    uStack_40 = 0;

+    bVar1 = CCompositionSurfaceBitmap::CalcImageTransform

+                      ((CCompositionSurfaceBitmap *)this_00,param_2,local_98,

+                       (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                        *)&local_48);

+    if (bVar1) {

+      bVar1 = Windows::Foundation::Numerics::invert((float4x4 *)local_98,(float4x4 *)local_98);

+      local_58 = local_58 & 0xffffc003;

+      if (!bVar1) goto LAB_0;

+      pCVar2 = local_98;

+    }

+    bVar1 = CSurfaceBrush::CSurfaceRenderStrategy::GetDirtyRegionFromSurface

+                      (param_1,pCVar2,param_2,param_3);

+  }

+  else {

+LAB_0:

+    bVar1 = false;

+  }

+  return bVar1;

+}

+
```

## `CNineGridBrush::IsReadyToDraw`  (modified)

```diff
--- CNineGridBrush::IsReadyToDraw
+++ CNineGridBrush::IsReadyToDraw
@@ -1,2 +1,69 @@
-Failed to decompile dwmcore.dll - .ProgramDB CNineGridBrush::IsReadyToDraw : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: virtual bool __cdecl CNineGridBrush::IsReadyToDraw(class CDrawingContext * __ptr64,bool *

+   __ptr64)const __ptr64 */

+

+bool __thiscall

+CNineGridBrush::IsReadyToDraw(CNineGridBrush *this,CDrawingContext *param_1,bool *param_2)

+

+{

+  CSurfaceBrush *this_00;

+  code *pcVar1;

+  char cVar2;

+  undefined1 uVar3;

+  CResource *pCVar4;

+  bool bVar5;

+  IBitmapResource *local_res8;

+  

+  *param_2 = false;

+  this_00 = *(CSurfaceBrush **)(this + 0x68);

+  if (this_00 == (CSurfaceBrush *)0x0) {

+    bVar5 = false;

+  }

+  else {

+    pcVar1 = *(code **)(*(longlong *)this_00 + 0x138);

+    if (pcVar1 == CSurfaceBrush::IsReadyToDraw) {

+      pcVar1 = *(code **)**(undefined8 **)(this_00 + 0x88);

+      if (pcVar1 == CBitmapRenderStrategy::IsReadyToDraw) {

+        local_res8 = (IBitmapResource *)0x0;

+        wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::reset

+                  ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res8);

+        CBitmapRenderStrategy::GetBitmap(this_00,&local_res8);

+        cVar2 = CBitmapRenderStrategy::HasRenderingRealization(local_res8);

+        wil::com_ptr_t<IBitmapResource,wil::err_returncode_policy>::

+        ~com_ptr_t<IBitmapResource,wil::err_returncode_policy>

+                  ((com_ptr_t<IBitmapResource,wil::err_returncode_policy> *)&local_res8);

+      }

+      else {

+        if (pcVar1 == CPrimitiveGroupRenderStrategy::IsReadyToDraw) {

+          pCVar4 = CSurfaceBrush::GetSurface(this_00);

+          if (*(code **)(*(longlong *)pCVar4 + 0xd8) == CPrimitiveGroup::IsEmptyDrawing) {

+            uVar3 = CPrimitiveGroup::IsEmptyDrawing((CPrimitiveGroup *)pCVar4);

+          }

+          else {

+            uVar3 = (**(code **)(*(longlong *)pCVar4 + 0xd8))();

+          }

+          *param_2 = (bool)uVar3;

+          return true;

+        }

+        if (pcVar1 == CVisualSurfaceRenderStrategy::IsReadyToDraw) {

+          pCVar4 = CSurfaceBrush::GetSurface(this_00);

+          cVar2 = CVisualSurface::HasSomethingToDraw((CVisualSurface *)pCVar4);

+        }

+        else {

+          cVar2 = (*pcVar1)(*(undefined8 **)(this_00 + 0x88),this_00,param_1,param_2);

+        }

+      }

+    }

+    else if (pcVar1 == CColorBrush::IsReadyToDraw) {

+      cVar2 = CColorBrush::IsReadyToDraw((CColorBrush *)this_00,param_1,param_2);

+    }

+    else {

+      cVar2 = (*pcVar1)();

+    }

+    bVar5 = cVar2 != '\0';

+  }

+  return bVar5;

+}

+
```

## `CCursorState::InputThread_UpdateHardwareCursor`  (modified)

```diff
--- CCursorState::InputThread_UpdateHardwareCursor
+++ CCursorState::InputThread_UpdateHardwareCursor
@@ -1,2 +1,47 @@
-Failed to decompile dwmcore.dll - .ProgramDB CCursorState::InputThread_UpdateHardwareCursor : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* private: bool __cdecl CCursorState::InputThread_UpdateHardwareCursor(class

+   CCursorState::MonitorData * __ptr64,enum _HWCURSOR_UPDATE_TYPE) __ptr64 */

+

+bool __thiscall

+CCursorState::InputThread_UpdateHardwareCursor

+          (CCursorState *this,MonitorData *param_1,_HWCURSOR_UPDATE_TYPE param_2)

+

+{

+  bool bVar1;

+  MonitorData *this_00;

+  undefined8 local_28;

+  undefined8 uStack_20;

+  undefined8 local_18;

+  undefined8 uStack_10;

+  

+  if (*(int *)(param_1 + 0x98) == 2) {

+    bVar1 = false;

+  }

+  else {

+    local_18 = 0;

+    uStack_10 = 0;

+    local_28 = 0;

+    uStack_20 = 0;

+    this_00 = (MonitorData *)this;

+    if ((param_1[0x9c] != (MonitorData)0x0) &&

+       (this_00 = param_1,

+       bVar1 = MonitorData::CalcShapeRects

+                         (param_1,(D2D_POINT_2F *)(this + 0x38),

+                          (TMilRect_<int,tagRECT,D2D_POINTANDSIZE_L,Mil3DRectL,RectUniqueness::_CMilRectL_>

+                           *)&local_18,

+                          (TMilRect_<int,tagRECT,D2D_POINTANDSIZE_L,Mil3DRectL,RectUniqueness::_CMilRectL_>

+                           *)&local_28), bVar1)) {

+      bVar1 = SetHardwareShapeAndPosition

+                        (this,param_1,

+                         (TMilRect_<int,tagRECT,D2D_POINTANDSIZE_L,Mil3DRectL,RectUniqueness::_CMilRectL_>

+                          *)&local_18,

+                         (TMilRect_<int,tagRECT,D2D_POINTANDSIZE_L,Mil3DRectL,RectUniqueness::_CMilRectL_>

+                          *)&local_28,param_2,false);

+      return bVar1;

+    }

+    HideHardwareShape((CCursorState *)this_00,param_1);

+    bVar1 = true;

+  }

+  return bVar1;

+}

+
```

## `CVisual::GetClipForHitTest`  (modified)

```diff
--- CVisual::GetClipForHitTest
+++ CResource::DetachFromChannel
@@ -1,13 +1,13 @@
 

-/* public: virtual class CGeometry * __ptr64 __cdecl CVisual::GetClipForHitTest(void)const __ptr64

-    */

+/* public: virtual void __cdecl CResource::DetachFromChannel(class CChannelContext * __ptr64,bool)

+   __ptr64 */

 

-CGeometry * __thiscall CVisual::GetClipForHitTest(CVisual *this)

+void __thiscall CResource::DetachFromChannel(CResource *this,CChannelContext *param_1,bool param_2)

 

 {

-  if (-1 < (char)this[0x69]) {

-    return *(CGeometry **)(this + 0xf8);

+  if (param_1 == *(CChannelContext **)(this + 0x38)) {

+    *(undefined8 *)(this + 0x38) = 0;

   }

-  return (CGeometry *)0x0;

+  return;

 }
```

## `detail::vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>::reserve_region`  (modified)

```diff
--- detail::vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>::reserve_region
+++ detail::vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>::erase_unchecked
@@ -1,79 +1,2 @@
-

-/* protected: class CD3DDevice::CDelayUnpin * __ptr64 __cdecl detail::vector_facade<class

-   CD3DDevice::CDelayUnpin,class detail::buffer_impl<class CD3DDevice::CDelayUnpin,7,1,class

-   detail::liberal_expansion_policy> >::reserve_region(unsigned __int64,unsigned __int64) __ptr64 */

-

-CDelayUnpin * __thiscall

-detail::

-vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>

-::reserve_region(vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>

-                 *this,__uint64 param_1,__uint64 param_2)

-

-{

-  CDelayUnpin *pCVar1;

-  ulonglong uVar2;

-  ulonglong uVar3;

-  CDelayUnpin *pCVar4;

-  ulonglong uVar5;

-  CDelayUnpin *pCVar6;

-  CDelayUnpin *local_88;

-  ulonglong uStack_80;

-  ulonglong local_78;

-  CDelayUnpin *local_68;

-  undefined8 uStack_60;

-  undefined8 local_58;

-  undefined1 local_50 [16];

-  undefined8 local_40;

-  

-  buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>::ensure_extra_capacity

-            ((buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy> *)this,1);

-  pCVar1 = *(CDelayUnpin **)this;

-  pCVar6 = *(CDelayUnpin **)(this + 8);

-  local_58 = 0;

-  uVar3 = (longlong)pCVar6 - (longlong)pCVar1 >> 6;

-  uStack_60 = 1;

-  local_40 = 0;

-  uVar5 = uVar3 - param_1;

-  local_68 = pCVar1 + uVar3 * 0x40;

-  if (local_68 == (CDelayUnpin *)0x0) {

-LAB_0:

-                    /* WARNING: Subroutine does not return */

-    _invalid_parameter_noinfo_noreturn();

-  }

-  local_40 = 1;

-  uVar2 = uVar5;

-  if (1 < uVar5) {

-    uVar2 = 1;

-  }

-  uStack_80 = 1;

-  pCVar4 = pCVar6 + uVar2 * -0x40;

-  local_78 = 1;

-  local_88 = local_68;

-  if (pCVar6 != pCVar4) {

-    uVar2 = 1;

-    do {

-      pCVar6 = pCVar6 + -0x40;

-      if (((local_88 == (CDelayUnpin *)0x0) || (uVar2 == 0)) ||

-         (uVar2 = uVar2 - 1, uStack_80 <= uVar2)) goto LAB_0;

-      CD3DDevice::CDelayUnpin::CDelayUnpin(local_88 + uVar2 * 0x40,pCVar6);

-    } while (pCVar6 != pCVar4);

-  }

-  if (1 < uVar5) {

-    if ((uVar3 != 0) && ((pCVar1 == (CDelayUnpin *)0x0 || (((longlong)uVar3 < 0 && (uVar3 != 0))))))

-    goto LAB_0;

-    local_88 = pCVar1;

-    uStack_80 = uVar3;

-    local_78 = uVar3;

-    std::

-    move_backward<std::move_iterator<CD3DDevice::CDelayUnpin*___ptr64>,stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>_>

-              (local_50,pCVar1 + param_1 * 0x40,pCVar1 + uVar3 * 0x40 + -0x40,&local_88);

-  }

-  pCVar6 = pCVar1 + (param_1 + 1) * 0x40;

-  if (local_68 < pCVar1 + (param_1 + 1) * 0x40) {

-    pCVar6 = local_68;

-  }

-  destruct_range<CD3DDevice::CDelayUnpin>(pCVar1 + param_1 * 0x40,pCVar6);

-  *(longlong *)(this + 8) = *(longlong *)(this + 8) + 0x40;

-  return pCVar1 + param_1 * 0x40;

-}

-

+Failed to decompile dwmcore.dll - .ProgramDB detail::vector_facade<CD3DDevice::CDelayUnpin,detail::buffer_impl<CD3DDevice::CDelayUnpin,7,1,detail::liberal_expansion_policy>_>::erase_unchecked : Error: Decompile error: 
+Marshaling error: Did not see expected closing element
```

## `CCompositionDynamicTexture::GetDirtyRegion`  (modified)

```diff
--- CCompositionDynamicTexture::GetDirtyRegion
+++ CCompositionDynamicTexture::SetDirtyRects
@@ -1,2 +1,2 @@
-Failed to decompile dwmcore.dll - .ProgramDB CCompositionDynamicTexture::GetDirtyRegion : Error: Decompile error: 
+Failed to decompile dwmcore.dll - .ProgramDB CCompositionDynamicTexture::SetDirtyRects : Error: Decompile error: 
 Marshaling error: Did not see expected closing element
```

## `CChannel::PartitionSetCursor`  (modified)

```diff
--- CChannel::PartitionSetCursor
+++ CChannel::PartitionSetCursor
@@ -1,2 +1,29 @@
-Failed to decompile dwmcore.dll - .ProgramDB CChannel::PartitionSetCursor : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: virtual long __cdecl CChannel::PartitionSetCursor(unsigned int,bool,bool,int,int) __ptr64

+    */

+

+long __thiscall

+CChannel::PartitionSetCursor

+          (CChannel *this,uint param_1,bool param_2,bool param_3,int param_4,int param_5)

+

+{

+  long lVar1;

+  CChannelLock local_38 [8];

+  longlong *local_30;

+  undefined4 local_28;

+  undefined8 local_24;

+  int iStack_1c;

+  int iStack_18;

+  

+  CChannelLock::CChannelLock(local_38,this);

+  CheckHandle(this,param_1,0xb4);

+  local_28 = 0x114;

+  _iStack_1c = CONCAT44(param_5,param_4);

+  local_24 = (ulonglong)CONCAT15(param_3,CONCAT14(param_2,param_1));

+  lVar1 = SendCommand(this,&local_28,0x14);

+  (**(code **)(*local_30 + 0x50))();

+  return lVar1;

+}

+
```

## `CCursorState::MonitorData::MonitorData`  (modified)

```diff
--- CCursorState::MonitorData::MonitorData
+++ CCursorState::MonitorData::MonitorData
@@ -1,2 +1,50 @@
-Failed to decompile dwmcore.dll - .ProgramDB CCursorState::MonitorData::MonitorData : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: __cdecl CCursorState::MonitorData::MonitorData(class CCursorState::MonitorData &&

+   __ptr64) __ptr64 */

+

+MonitorData * __thiscall

+CCursorState::MonitorData::MonitorData(MonitorData *this,MonitorData *param_1)

+

+{

+  undefined8 uVar1;

+  

+  *(undefined8 *)this = *(undefined8 *)param_1;

+  *(undefined4 *)(this + 8) = *(undefined4 *)(param_1 + 8);

+  uVar1 = *(undefined8 *)(param_1 + 0x14);

+  *(undefined8 *)(this + 0xc) = *(undefined8 *)(param_1 + 0xc);

+  *(undefined8 *)(this + 0x14) = uVar1;

+  uVar1 = *(undefined8 *)(param_1 + 0x24);

+  *(undefined8 *)(this + 0x1c) = *(undefined8 *)(param_1 + 0x1c);

+  *(undefined8 *)(this + 0x24) = uVar1;

+  uVar1 = *(undefined8 *)(param_1 + 0x34);

+  *(undefined8 *)(this + 0x2c) = *(undefined8 *)(param_1 + 0x2c);

+  *(undefined8 *)(this + 0x34) = uVar1;

+  uVar1 = *(undefined8 *)(param_1 + 0x44);

+  *(undefined8 *)(this + 0x3c) = *(undefined8 *)(param_1 + 0x3c);

+  *(undefined8 *)(this + 0x44) = uVar1;

+  *(undefined4 *)(this + 0x4c) = *(undefined4 *)(param_1 + 0x4c);

+  uVar1 = *(undefined8 *)(param_1 + 0x58);

+  *(undefined8 *)(this + 0x50) = *(undefined8 *)(param_1 + 0x50);

+  *(undefined8 *)(this + 0x58) = uVar1;

+  uVar1 = *(undefined8 *)(param_1 + 0x68);

+  *(undefined8 *)(this + 0x60) = *(undefined8 *)(param_1 + 0x60);

+  *(undefined8 *)(this + 0x68) = uVar1;

+  *(undefined8 *)(this + 0x70) = 0;

+  *(undefined8 *)(this + 0x78) = 0;

+  *(undefined8 *)(this + 0x70) = *(undefined8 *)(param_1 + 0x70);

+  *(undefined8 *)(this + 0x78) = *(undefined8 *)(param_1 + 0x78);

+  *(undefined8 *)(param_1 + 0x70) = 0;

+  *(undefined8 *)(param_1 + 0x78) = 0;

+  *(undefined4 *)(this + 0x80) = *(undefined4 *)(param_1 + 0x80);

+  *(undefined8 *)(this + 0x84) = *(undefined8 *)(param_1 + 0x84);

+  *(undefined4 *)(this + 0x8c) = *(undefined4 *)(param_1 + 0x8c);

+  *(undefined4 *)(this + 0x90) = *(undefined4 *)(param_1 + 0x90);

+  *(undefined4 *)(this + 0x94) = *(undefined4 *)(param_1 + 0x94);

+  *(undefined4 *)(this + 0x98) = *(undefined4 *)(param_1 + 0x98);

+  this[0x9c] = param_1[0x9c];

+  this[0x9d] = param_1[0x9d];

+  this[0x9e] = param_1[0x9e];

+  this[0x9f] = param_1[0x9f];

+  return this;

+}

+
```

## `CCaptureRenderTarget::ComputeCursorRenderTransform`  (modified)

```diff
--- CCaptureRenderTarget::ComputeCursorRenderTransform
+++ CComposition::ForEachCursorVisual
@@ -1,25 +1,2 @@
-

-/* protected: virtual bool __cdecl CCaptureRenderTarget::ComputeCursorRenderTransform(class CVisual

-   const * __ptr64,class CMILMatrix * __ptr64)const __ptr64 */

-

-bool __thiscall

-CCaptureRenderTarget::ComputeCursorRenderTransform

-          (CCaptureRenderTarget *this,CVisual *param_1,CMILMatrix *param_2)

-

-{

-  bool bVar1;

-  bool bVar2;

-  CDesktopTree *local_res20;

-  CVisual *local_18 [2];

-  

-  local_res20 = (CDesktopTree *)0x0;

-  local_18[0] = (CVisual *)0x0;

-  bVar1 = GetCursorCaptureContext(this,&local_res20,local_18);

-  bVar2 = false;

-  if (bVar1) {

-    bVar2 = ComputeCursorTransform(this,param_1,local_18[0],(CVisualTree *)local_res20,true,param_2)

-    ;

-  }

-  return bVar2;

-}

-

+Failed to decompile dwmcore.dll - .ProgramDB CComposition::ForEachCursorVisual : Error: Decompile error: 
+Marshaling error: Did not see expected closing element
```

## `CComposition::AddCursorVisual`  (modified)

```diff
--- CComposition::AddCursorVisual
+++ CComposition::AddCursorVisual
@@ -1,2 +1,94 @@
-Failed to decompile dwmcore.dll - .ProgramDB CComposition::AddCursorVisual : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: long __cdecl CComposition::AddCursorVisual(class CVisual * __ptr64,class

+   std::optional<struct tagPOINT>) __ptr64 */

+

+long __thiscall

+CComposition::AddCursorVisual(CComposition *this,CVisual *param_1,undefined8 *param_3)

+

+{

+  vector<CursorVisualData,std::allocator<CursorVisualData>_> *this_00;

+  undefined4 uVar1;

+  CursorVisualData *this_01;

+  undefined8 *puVar2;

+  CExcludeVisualReference *pCVar3;

+  bool bVar4;

+  CVisual *pCVar5;

+  CExcludeVisualReference *pCVar6;

+  undefined8 *puVar7;

+  undefined1 local_res8 [8];

+  CExcludeVisualReference local_48 [24];

+  undefined8 local_30;

+  undefined8 local_28;

+  uint local_20;

+  

+  bVar4 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_CompositionMagnifier_Iter2>::

+          __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_CompositionMagnifier_Iter2> *)

+                              &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_CompositionMagnifier_Iter2>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_CompositionMagnifier_Iter2>::GetImpl(void)'

+                               ::__l2::impl);

+  if ((!bVar4) ||

+     (bVar4 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>::

+              __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor> *)

+                                  &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DesktopDWMCursor>::GetImpl(void)'

+                                   ::__l2::impl), bVar4)) {

+    bVar4 = false;

+  }

+  else {

+    bVar4 = true;

+  }

+  pCVar6 = *(CExcludeVisualReference **)(this + 0x1828);

+  this_00 = (vector<CursorVisualData,std::allocator<CursorVisualData>_> *)(this + 0x1820);

+  do {

+    while( true ) {

+      if (pCVar6 == *(CExcludeVisualReference **)this_00) {

+        pCVar6 = (CExcludeVisualReference *)0x0;

+        goto LAB_0;

+      }

+      pCVar6 = pCVar6 + -0x30;

+      pCVar5 = CExcludeVisualReference::GetVisualNoRef(pCVar6);

+      if (pCVar5 != (CVisual *)0x0) break;

+      std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::erase

+                (this_00,local_res8,pCVar6);

+    }

+  } while (pCVar5 != param_1);

+LAB_0:

+  if (pCVar6 == (CExcludeVisualReference *)0x0) {

+    CExcludeVisualReference::CExcludeVisualReference(local_48,param_1);

+    local_30 = 0;

+    local_20 = local_20 & 0xffffff00;

+    if (bVar4) {

+      local_28 = *param_3;

+      local_20 = *(uint *)(param_3 + 1);

+    }

+    if (*(longlong *)(this + 0x1838) != *(longlong *)(this + 0x1840)) {

+      CursorVisualData::EnsureVisualTree((CursorVisualData *)local_48);

+    }

+    this_01 = *(CursorVisualData **)(this + 0x1828);

+    if (this_01 == *(CursorVisualData **)(this + 0x1830)) {

+      std::vector<CursorVisualData,std::allocator<CursorVisualData>_>::

+      _Emplace_reallocate<CursorVisualData>(this_00,this_01,(CursorVisualData *)local_48);

+    }

+    else {

+      CursorVisualData::CursorVisualData(this_01,(CursorVisualData *)local_48);

+      *(longlong *)(this + 0x1828) = *(longlong *)(this + 0x1828) + 0x30;

+    }

+    puVar2 = *(undefined8 **)(this + 0x1840);

+    for (puVar7 = *(undefined8 **)(this + 0x1838); puVar7 != puVar2; puVar7 = puVar7 + 1) {

+      CResource::RegisterNotifier((CResource *)*puVar7,(CResource *)param_1);

+    }

+    CursorVisualData::~CursorVisualData((CursorVisualData *)local_48);

+  }

+  else if (bVar4) {

+    pCVar3 = *(CExcludeVisualReference **)(this + 0x1828);

+    for (pCVar6 = *(CExcludeVisualReference **)this_00; pCVar6 != pCVar3; pCVar6 = pCVar6 + 0x30) {

+      pCVar5 = CExcludeVisualReference::GetVisualNoRef(pCVar6);

+      if (pCVar5 == param_1) {

+        uVar1 = *(undefined4 *)(param_3 + 1);

+        *(undefined8 *)(pCVar6 + 0x20) = *param_3;

+        *(undefined4 *)(pCVar6 + 0x28) = uVar1;

+        return 0;

+      }

+    }

+  }

+  return 0;

+}

+
```

## `CMatrixTransform3D::IsOfType`  (modified)

```diff
--- CMatrixTransform3D::IsOfType
+++ CMatrixTransform3D::IsOfType
@@ -1,2 +1,14 @@
-Failed to decompile dwmcore.dll - .ProgramDB CMatrixTransform3D::IsOfType : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: virtual bool __cdecl CMatrixTransform3D::IsOfType(enum MIL_RESOURCE_TYPE)const __ptr64 */

+

+bool __thiscall CMatrixTransform3D::IsOfType(CMatrixTransform3D *this,MIL_RESOURCE_TYPE param_1)

+

+{

+  if (((0x3f < param_1 - 0x6c) ||

+      ((0x8000000000002011U >> ((ulonglong)(param_1 - 0x6c) & 0x3f) & 1) == 0)) && (param_1 != 0x36)

+     ) {

+    return false;

+  }

+  return true;

+}

+
```

## `std::_Get_unwrapped_n<stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>&___ptr64,__int64>`  (modified)

```diff
--- std::_Get_unwrapped_n<stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>&___ptr64,__int64>
+++ std::_Get_unwrapped_n<stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>&___ptr64,__int64>
@@ -1,2 +1,26 @@
-Failed to decompile dwmcore.dll - .ProgramDB std::_Get_unwrapped_n<stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>&___ptr64,__int64> : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* UNKNOWN __cdecl std::_Get_unwrapped_n<class stdext::checked_array_iterator<class

+   CD3DDevice::CDelayUnpin * __ptr64> & __ptr64,__int64>(class stdext::checked_array_iterator<class

+   CD3DDevice::CDelayUnpin * __ptr64> & __ptr64,__int64) */

+

+longlong __cdecl

+std::

+_Get_unwrapped_n<stdext::checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64>&___ptr64,__int64>

+          (checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64> *param_1,__int64 param_2)

+

+{

+  checked_array_iterator<CD3DDevice::CDelayUnpin*___ptr64> *pcVar1;

+  

+  pcVar1 = param_1 + 0x10;

+  if (param_2 < 0) {

+    if (*(ulonglong *)pcVar1 < (ulonglong)-param_2) {

+LAB_0:

+                    /* WARNING: Subroutine does not return */

+      _invalid_parameter_noinfo_noreturn();

+    }

+  }

+  else if ((0 < param_2) && (*(longlong *)(param_1 + 8) - *(ulonglong *)pcVar1 < (ulonglong)param_2)

+          ) goto LAB_0;

+  return *(ulonglong *)pcVar1 * 0x40 + *(longlong *)param_1;

+}

+
```

## `std::_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>::_Emplace_hint<D2D_VECTOR_2F,CConvexPolygonEdgeMap<unsigned_int>::EdgeData&___ptr64>`  (modified)

```diff
--- std::_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>::_Emplace_hint<D2D_VECTOR_2F,CConvexPolygonEdgeMap<unsigned_int>::EdgeData&___ptr64>
+++ std::_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>::_Emplace_hint<D2D_VECTOR_2F,CConvexPolygonEdgeMap<unsigned_int>::EdgeData&___ptr64>
@@ -1,28 +1,63 @@
+

+/* protected: struct std::_Tree_node<struct std::pair<struct D2D_VECTOR_2F const ,struct

+   CConvexPolygonEdgeMap<unsigned int>::EdgeData>,void * __ptr64> * __ptr64 __cdecl std::_Tree<class

+   std::_Tmap_traits<struct D2D_VECTOR_2F const ,struct CConvexPolygonEdgeMap<unsigned

+   int>::EdgeData,struct CConvexPolygonEdgeMap<unsigned int>::CompareEdgeDirection,class

+   std::allocator<struct std::pair<struct D2D_VECTOR_2F const ,struct CConvexPolygonEdgeMap<unsigned

+   int>::EdgeData> >,0> >::_Emplace_hint<struct D2D_VECTOR_2F,struct CConvexPolygonEdgeMap<unsigned

+   int>::EdgeData & __ptr64>(struct std::_Tree_node<struct std::pair<struct D2D_VECTOR_2F const

+   ,struct CConvexPolygonEdgeMap<unsigned int>::EdgeData>,void * __ptr64> * __ptr64 const,struct

+   D2D_VECTOR_2F && __ptr64,struct CConvexPolygonEdgeMap<unsigned int>::EdgeData & __ptr64) __ptr64

+    */

 

 _Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

 * __thiscall

-CWatermarkStack<float,2,2,10>::

-_Emplace_hint<D2D_VECTOR_2F,CConvexPolygonEdgeMap<unsigned_int>::EdgeData&___ptr64>

+std::

+_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>

+::_Emplace_hint<D2D_VECTOR_2F,CConvexPolygonEdgeMap<unsigned_int>::EdgeData&___ptr64>

           (_Tree<std::_Tmap_traits<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData,CConvexPolygonEdgeMap<unsigned_int>::CompareEdgeDirection,std::allocator<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>_>,0>_>

            *this,_Tree_node<struct_std::pair<struct_D2D_VECTOR_2F_const_,struct_CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

                  *param_1,D2D_VECTOR_2F *param_2,EdgeData *param_3)

 

 {

-  byte *pbVar1;

-  char cVar2;

-  undefined8 in_RAX;

-  char *pcVar3;

-  longlong unaff_RBX;

-  char *unaff_RSI;

+  undefined8 uVar1;

+  undefined8 *puVar2;

+  undefined8 *puVar3;

+  _Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+  *p_Var4;

+  _Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+  *local_48;

+  undefined8 uStack_40;

+  undefined8 local_38;

   

-  pbVar1 = (byte *)(unaff_RBX + -0x80 + (longlong)this * 4);

-  *pbVar1 = *pbVar1 & (byte)in_RAX;

-  cVar2 = *unaff_RSI;

-  pcVar3 = (char *)CONCAT71((int7)((ulonglong)in_RAX >> 8),cVar2);

-  *pcVar3 = *pcVar3 + cVar2;

-  pcVar3 = (char *)((longlong)this * 5 + 7);

-  *pcVar3 = *pcVar3 + cVar2;

-  return *(_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

-           **)(unaff_RBX + 0x28);

+  uVar1 = *(undefined8 *)this;

+  puVar2 = _Allocate<16,std::_Default_allocate_traits,0>(0x30);

+  *(undefined8 *)((longlong)puVar2 + 0x1c) = *(undefined8 *)param_2;

+  *(undefined8 *)((longlong)puVar2 + 0x24) = *(undefined8 *)param_3;

+  *(undefined4 *)((longlong)puVar2 + 0x2c) = *(undefined4 *)(param_3 + 8);

+  *puVar2 = uVar1;

+  puVar2[1] = uVar1;

+  puVar2[2] = uVar1;

+  *(undefined2 *)(puVar2 + 3) = 0;

+  puVar3 = (undefined8 *)

+           _Find_hint<D2D_VECTOR_2F>

+                     (this,(_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+                            *)&local_48,(D2D_VECTOR_2F *)param_1);

+  local_38 = puVar3[2];

+  p_Var4 = (_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+            *)*puVar3;

+  uStack_40 = puVar3[1];

+  if ((char)local_38 == '\0') {

+    _Check_grow_by_1(this);

+    local_48 = p_Var4;

+    p_Var4 = (_Tree_node<std::pair<D2D_VECTOR_2F_const_,CConvexPolygonEdgeMap<unsigned_int>::EdgeData>,void*___ptr64>

+              *)_Tree_val<std::_Tree_simple_types<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>_>_>

+                ::_Insert_node((_Tree_val<std::_Tree_simple_types<std::pair<SceneMaterialInputType::Enum_const_,unsigned_int>_>_>

+                                *)this,&local_48,puVar2);

+  }

+  else if (puVar2 != (undefined8 *)0x0) {

+    _Deallocate<16,0>(puVar2,0x30);

+  }

+  return p_Var4;

 }
```

## `CBitmapRenderStrategy::GetTextureMemoryLayoutData`  (modified)

```diff
--- CBitmapRenderStrategy::GetTextureMemoryLayoutData
+++ CBitmapRenderStrategy::GetTextureMemoryLayoutData
@@ -1,2 +1,92 @@
-Failed to decompile dwmcore.dll - .ProgramDB CBitmapRenderStrategy::GetTextureMemoryLayoutData : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+/* public: virtual long __cdecl CBitmapRenderStrategy::GetTextureMemoryLayoutData(class

+   CSurfaceBrush const * __ptr64,struct D2D_SIZE_F const & __ptr64,class std::vector<struct

+   CContent::LayoutData,class std::allocator<struct CContent::LayoutData> > & __ptr64)const __ptr64

+    */

+

+long __thiscall

+CBitmapRenderStrategy::GetTextureMemoryLayoutData

+          (CBitmapRenderStrategy *this,CSurfaceBrush *param_1,D2D_SIZE_F *param_2,

+          vector<CContent::LayoutData,std::allocator<CContent::LayoutData>_> *param_3)

+

+{

+  LayoutData *pLVar1;

+  char cVar2;

+  long lVar3;

+  CResource *pCVar4;

+  undefined1 auStackY_b8 [32];

+  undefined4 local_88;

+  undefined4 uStack_84;

+  undefined4 uStack_80;

+  undefined4 uStack_7c;

+  undefined8 local_78;

+  undefined8 local_70;

+  undefined8 uStack_68;

+  undefined8 local_60;

+  undefined8 uStack_58;

+  undefined8 local_50;

+  undefined8 local_48;

+  undefined8 uStack_40;

+  float local_38;

+  float local_34;

+  ulonglong local_30;

+  

+  local_30 = __security_cookie ^ (ulonglong)auStackY_b8;

+  lVar3 = 0;

+  if (*(longlong *)param_3 != *(longlong *)(param_3 + 8)) {

+    *(longlong *)(param_3 + 8) = *(longlong *)param_3;

+  }

+  pCVar4 = CSurfaceBrush::GetSurface(param_1);

+  cVar2 = (**(code **)(*(longlong *)pCVar4 + 0x40))(pCVar4,0x29);

+  if (cVar2 != '\0') {

+    local_50 = 0;

+    local_70 = 0;

+    uStack_68 = 0;

+    local_60 = 0;

+    uStack_58 = 0;

+    lVar3 = CSurfaceBrush::ComputeLayout(param_1,param_2,(LayoutData *)&local_70,(CShape **)0x0);

+    if (lVar3 < 0) {

+      MilInstrumentationCheckHR_MaybeFailFast(0x14,(long *)0x0,0,lVar3,0x43d,(void *)0x0);

+    }

+    else {

+      if ((0.0 < (float)uStack_58) || (0.0 < uStack_58._4_4_)) {

+        local_38 = (float)uStack_58;

+        local_34 = uStack_58._4_4_;

+        local_48 = 0x3f800000;

+        uStack_40 = 0x3f80000000000000;

+        D2D1::Matrix3x2F::SetProduct

+                  ((Matrix3x2F *)&local_88,(Matrix3x2F *)&local_48,(Matrix3x2F *)&local_70);

+        local_70 = CONCAT44(uStack_84,local_88);

+        uStack_68 = CONCAT44(uStack_7c,uStack_80);

+        local_60 = local_78;

+      }

+      else {

+        local_88 = (undefined4)local_70;

+        uStack_84 = local_70._4_4_;

+        uStack_80 = (undefined4)uStack_68;

+        uStack_7c = uStack_68._4_4_;

+      }

+      pLVar1 = *(LayoutData **)(param_3 + 8);

+      if (pLVar1 == *(LayoutData **)(param_3 + 0x10)) {

+        std::vector<CContent::LayoutData,std::allocator<CContent::LayoutData>_>::

+        _Emplace_reallocate<CContent::LayoutData_const&___ptr64>

+                  (param_3,pLVar1,(LayoutData *)&local_70);

+      }

+      else {

+        *(undefined4 *)pLVar1 = local_88;

+        *(undefined4 *)(pLVar1 + 4) = uStack_84;

+        *(undefined4 *)(pLVar1 + 8) = uStack_80;

+        *(undefined4 *)(pLVar1 + 0xc) = uStack_7c;

+        *(undefined8 *)(pLVar1 + 0x10) = local_60;

+        *(undefined8 *)(pLVar1 + 0x18) = uStack_58;

+        *(undefined8 *)(pLVar1 + 0x20) = local_50;

+        *(longlong *)(param_3 + 8) = *(longlong *)(param_3 + 8) + 0x28;

+      }

+    }

+  }

+  return lVar3;

+}

+
```

## `CTextVisualGeneratedT<CTextVisual,CVisual>::IsOfType`  (modified)

```diff
--- CTextVisualGeneratedT<CTextVisual,CVisual>::IsOfType
+++ COverlayContext::DelayCursorUpdateForMPO
@@ -1,2 +1,19 @@
-Failed to decompile dwmcore.dll - .ProgramDB CTextVisualGeneratedT<CTextVisual,CVisual>::IsOfType : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* private: bool __cdecl COverlayContext::DelayCursorUpdateForMPO(void)const __ptr64 */

+

+bool __thiscall COverlayContext::DelayCursorUpdateForMPO(COverlayContext *this)

+

+{

+  bool bVar1;

+  undefined1 uVar2;

+  

+  uVar2 = 0;

+  if ((this[0x4c77] != (COverlayContext)0x0) && (this[0x4c6f] == (COverlayContext)0x0)) {

+    bVar1 = CCursorVisual::IsMaskInvert(*(CCursorVisual **)(this + 0x4b18));

+    if (bVar1) {

+      uVar2 = 1;

+    }

+  }

+  return (bool)uVar2;

+}

+
```

## `<lambda_038d12cb786c59c95af184389708e22a>::operator()`  (modified)

```diff
--- <lambda_038d12cb786c59c95af184389708e22a>::operator()
+++ <lambda_a1d645c788d657455050b12db52c7919>::operator()
@@ -1,7 +1,134 @@
 

-void CloseHandle::operator()(void)

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

+

+long <lambda_a1d645c788d657455050b12db52c7919>::operator()

+               (undefined8 *param_1,CVisual *param_2,CVisualTree *param_3)

 

 {

-  return;

+  CCaptureRenderTarget *this;

+  undefined8 *puVar1;

+  char *pcVar2;

+  CDrawingContext *this_00;

+  undefined8 *puVar3;

+  bool bVar4;

+  long lVar5;

+  longlong lVar6;

+  CVisual *pCVar7;

+  CMILMatrix *this_01;

+  uint uVar8;

+  TMil3DRect<float,TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,D3D_RECT_F,MilPointAndSizeF,RectUniqueness::NotNeeded>

+  *pTVar9;

+  void *unaff_retaddr;

+  undefined1 auStackY_f8 [32];

+  undefined8 local_b8;

+  undefined8 uStack_b0;

+  undefined4 local_a8;

+  undefined4 local_a4;

+  undefined8 local_98;

+  undefined8 uStack_90;

+  undefined8 local_88;

+  undefined4 local_58;

+  ulonglong local_48;

+  

+  local_48 = __security_cookie ^ (ulonglong)auStackY_f8;

+  this = (CCaptureRenderTarget *)*param_1;

+  bVar4 = CVisualTree::_IsInTree(*(CVisualTree **)(this + 0x70),param_2,0);

+  if (!bVar4) {

+    puVar1 = (undefined8 *)param_1[1];

+    bVar4 = CVisualTree::_IsInTree((CVisualTree *)*puVar1,param_2,0);

+    if (!bVar4) {

+      return 0;

+    }

+    pcVar2 = (char *)param_1[2];

+    if ((*pcVar2 == '\0') &&

+       (bVar4 = CCaptureRenderTarget::ComputeCursorTransform

+                          (this,param_2,*(CVisual **)param_1[3],(CVisualTree *)*puVar1,true,

+                           (CMILMatrix *)param_1[4]), bVar4)) {

+      this_00 = *(CDrawingContext **)param_1[5];

+      lVar6 = (**(code **)(**(longlong **)param_1[6] + 0x90))();

+      lVar5 = CDrawingContext::BeginFrame

+                        (this_00,(IDeviceTarget *)(lVar6 + 0x10U & -(ulonglong)(lVar6 != 0)),

+                         (CMILMatrix *)param_1[4],(_D3DCOLORVALUE *)(this + 0x8c),4,

+                         (COverlayContext *)0x0);

+      if (lVar5 < 0) {

+        uVar8 = 0x1e1;

+        goto LAB_0;

+      }

+      puVar3 = (undefined8 *)param_1[5];

+      *pcVar2 = '\x01';

+      local_98 = 6;

+      uStack_90 = CONCAT44(uStack_90._4_4_,1);

+      lVar5 = CDrawingContext::PushRenderOptionsInternal

+                        ((CDrawingContext *)*puVar3,(CVisual *)0x0,(MilRenderOptions *)&local_98,

+                         true);

+      if (lVar5 < 0) {

+        uVar8 = 0x1eb;

+        goto LAB_0;

+      }

+      *(undefined1 *)param_1[7] = 1;

+    }

+    bVar4 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_Capture_CursorDirtyRegions>::

+            __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_Capture_CursorDirtyRegions>

+                                 *)&`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_Capture_CursorDirtyRegions>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_Capture_CursorDirtyRegions>::GetImpl(void)'

+                                    ::__l2::impl);

+    if (bVar4) {

+      pTVar9 = (TMil3DRect<float,TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,D3D_RECT_F,MilPointAndSizeF,RectUniqueness::NotNeeded>

+                *)(param_2 + 0xb0);

+      lVar5 = CDrawingContext::DrawVisualTree

+                        (*(CDrawingContext **)param_1[5],param_3,pTVar9,(COcclusionContext *)0x0,0,

+                         false,param_2);

+      if (lVar5 < 0) {

+        uVar8 = 0x1f9;

+LAB_0:

+        wil::details::in1diag3::Return_Hr

+                  (unaff_retaddr,uVar8,

+                   "onecoreuap\\windows\\dwm\\dwmcore\\engine\\capturerendertarget.cpp",lVar5);

+        return lVar5;

+      }

+      local_58 = 0;

+      bVar4 = CCaptureRenderTarget::ComputeCursorTransform

+                        (this,param_2,*(CVisual **)param_1[3],(CVisualTree *)*puVar1,false,

+                         (CMILMatrix *)&local_98);

+      if (!bVar4) {

+        return 0;

+      }

+      this_01 = (CMILMatrix *)&local_98;

+    }

+    else {

+      pCVar7 = (CVisual *)(param_3 + 0x50);

+      if (param_2 != *(CVisual **)(param_3 + 0x48)) {

+        pCVar7 = param_2 + 0x98;

+      }

+      local_98 = *(undefined8 *)pCVar7;

+      uStack_90 = *(undefined8 *)(pCVar7 + 8);

+      local_88 = *(undefined8 *)(pCVar7 + 0x10);

+      lVar5 = CDrawingContext::DrawVisualTree

+                        (*(CDrawingContext **)param_1[5],param_3,

+                         (TMil3DRect<float,TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,D3D_RECT_F,MilPointAndSizeF,RectUniqueness::NotNeeded>

+                          *)&local_98,(COcclusionContext *)0x0,0,false,param_2);

+      if (lVar5 < 0) {

+        uVar8 = 0x215;

+        goto LAB_0;

+      }

+      this_01 = (CMILMatrix *)param_1[4];

+      pTVar9 = (TMil3DRect<float,TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>,D3D_RECT_F,MilPointAndSizeF,RectUniqueness::NotNeeded>

+                *)&local_98;

+    }

+    local_a8 = 0;

+    local_a4 = 0;

+    local_b8 = 0;

+    uStack_b0 = 0;

+    CMILMatrix::Transform3DBoundsHelper<0>

+              (this_01,pTVar9,

+               (TMil3DRect<float,class_TMilRect_<float,struct_D2D_RECT_F,struct_D3D_RECT_F,struct_D2D_POINTANDSIZE_F,struct_RectUniqueness::NotNeeded>,struct_D3D_RECT_F,struct_MilPointAndSizeF,struct_RectUniqueness::NotNeeded>

+                *)&local_b8);

+    CMergedRectBase<4>::Add

+              ((CMergedRectBase<4> *)(this + 0xaa8),

+               (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                *)&local_b8);

+  }

+  return 0;

 }
```

## `CResource::NotifyOnChanged`  (modified)

```diff
--- CResource::NotifyOnChanged
+++ CMagnifierRenderTarget::NotifyOnChanged
@@ -1,2 +1,22 @@
-Failed to decompile dwmcore.dll - .ProgramDB CResource::NotifyOnChanged : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* public: virtual void __cdecl CMagnifierRenderTarget::NotifyOnChanged(enum

+   NotificationEventArgs::Flags,struct IUnknown * __ptr64) __ptr64 */

+

+void __thiscall

+CMagnifierRenderTarget::NotifyOnChanged

+          (CMagnifierRenderTarget *this,Flags param_1,IUnknown *param_2)

+

+{

+  bool bVar1;

+  

+  bVar1 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>::

+          __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor> *)

+                              &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DesktopDWMCursor>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DesktopDWMCursor>::GetImpl(void)'

+                               ::__l2::impl);

+  if (((bVar1) && (param_2 != (IUnknown *)0x0)) && (*(int *)(this + 0xc4) == 1)) {

+    CTargetDirtyBase<8>::SetFullDirty((CTargetDirtyBase<8> *)(this + 0x140));

+  }

+  CResource::NotifyOnChanged((CResource *)this,param_1,param_2);

+  return;

+}

+
```

## `std::_Allocate<16,std::_Default_allocate_traits,0>`  (modified)

```diff
--- std::_Allocate<16,std::_Default_allocate_traits,0>
+++ std::_Get_size_of_n<48>
@@ -1,2 +1,13 @@
-Failed to decompile dwmcore.dll - .ProgramDB std::_Allocate<16,std::_Default_allocate_traits,0> : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* unsigned __int64 __cdecl std::_Get_size_of_n<48>(unsigned __int64) */

+

+__uint64 __cdecl std::_Get_size_of_n<48>(__uint64 param_1)

+

+{

+  if (0x555555555555555 < param_1) {

+                    /* WARNING: Subroutine does not return */

+    _Throw_bad_array_new_length();

+  }

+  return param_1 * 0x30;

+}

+
```

## `std::_Get_size_of_n<32>`  (modified)

```diff
--- std::_Get_size_of_n<32>
+++ std::_Get_size_of_n<48>
@@ -1,2 +1,13 @@
-Failed to decompile dwmcore.dll - .ProgramDB std::_Get_size_of_n<32> : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* unsigned __int64 __cdecl std::_Get_size_of_n<48>(unsigned __int64) */

+

+__uint64 __cdecl std::_Get_size_of_n<48>(__uint64 param_1)

+

+{

+  if (0x555555555555555 < param_1) {

+                    /* WARNING: Subroutine does not return */

+    _Throw_bad_array_new_length();

+  }

+  return param_1 * 0x30;

+}

+
```

## `CCaptureRenderTarget::ComputeCursorInvalidRects`  (modified)

```diff
--- CCaptureRenderTarget::ComputeCursorInvalidRects
+++ <lambda_0cd4278d08ea9acd6146e48707a92b5b>::operator()
@@ -1,35 +1,98 @@
 

-/* protected: void __cdecl CCaptureRenderTarget::ComputeCursorInvalidRects(class CMergedRect *

-   __ptr64)const __ptr64 */

+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

 

-void __thiscall

-CCaptureRenderTarget::ComputeCursorInvalidRects(CCaptureRenderTarget *this,CMergedRect *param_1)

+undefined8

+<lambda_0cd4278d08ea9acd6146e48707a92b5b>::operator()(undefined8 *param_1,CVisual *param_2)

 

 {

-  bool bVar1;

-  CMergedRect *local_res10;

-  CDesktopTree *local_res18;

-  CVisual *local_res20;

-  undefined **local_48;

-  CCaptureRenderTarget *local_40;

-  CDesktopTree **ppCStack_38;

-  CVisual **local_30;

-  CMergedRect **ppCStack_28;

-  undefined ***local_10;

+  CCaptureRenderTarget *this;

+  longlong *plVar1;

+  char *pcVar2;

+  byte bVar3;

+  bool bVar4;

+  byte bVar5;

+  D2D_RECT_F *pDVar6;

+  undefined1 auStackY_c8 [32];

+  CMILMatrix local_98 [64];

+  undefined4 local_58;

+  undefined8 local_48;

+  undefined8 uStack_40;

+  ulonglong local_38;

   

-  local_res18 = (CDesktopTree *)0x0;

-  local_res20 = (CVisual *)0x0;

-  local_res10 = param_1;

-  bVar1 = GetCursorCaptureContext(this,&local_res18,&local_res20);

-  if (bVar1) {

-    ppCStack_38 = &local_res18;

-    local_30 = &local_res20;

-    ppCStack_28 = &local_res10;

-    local_48 = &PTR__Copy_180306d00;

-    local_10 = &local_48;

-    local_40 = this;

-    CComposition::ForEachCursorVisual(*(CComposition **)(this + 0x18),&local_48);

+  local_38 = __security_cookie ^ (ulonglong)auStackY_c8;

+  this = (CCaptureRenderTarget *)*param_1;

+  if ((this[0xa20] == (CCaptureRenderTarget)0x0) &&

+     (bVar4 = CVisualTree::_IsInTree(*(CVisualTree **)(this + 0x70),param_2,0), !bVar4)) {

+    plVar1 = (longlong *)param_1[1];

+    bVar4 = CVisualTree::_IsInTree((CVisualTree *)*plVar1,param_2,0);

+    if (bVar4) {

+      bVar4 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_Capture_CursorDirtyRegions>::

+              __private_IsEnabled((FeatureImpl<__WilFeatureTraits_Feature_Capture_CursorDirtyRegions>

+                                   *)&`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_Capture_CursorDirtyRegions>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_Capture_CursorDirtyRegions>::GetImpl(void)'

+                                      ::__l2::impl);

+      if (bVar4) {

+        pDVar6 = (D2D_RECT_F *)(param_2 + 0xb0);

+        bVar4 = *(float *)(param_2 + 0xc4) < *(float *)(param_2 + 0xc0) ||

+                *(float *)(param_2 + 0xc4) == *(float *)(param_2 + 0xc0);

+        bVar3 = bVar4 + 1;

+        if (*(float *)pDVar6 <= *(float *)(param_2 + 0xb8) &&

+            *(float *)(param_2 + 0xb8) != *(float *)pDVar6) {

+          bVar3 = bVar4;

+        }

+        bVar5 = bVar3 + 1;

+        if (*(float *)(param_2 + 0xb4) <= *(float *)(param_2 + 0xbc) &&

+            *(float *)(param_2 + 0xbc) != *(float *)(param_2 + 0xb4)) {

+          bVar5 = bVar3;

+        }

+        if (bVar5 < 2) {

+          local_58 = 0;

+          bVar4 = CCaptureRenderTarget::ComputeCursorTransform

+                            (this,param_2,*(CVisual **)param_1[2],(CVisualTree *)*plVar1,false,

+                             local_98);

+          if (bVar4) {

+            local_48 = 0;

+            uStack_40 = 0;

+            CMILMatrix::Transform2DBoundsHelper<0>(local_98,pDVar6,(D2D_RECT_F *)&local_48);

+            CTargetDirtyBase<8>::AddDirtyRect

+                      ((CTargetDirtyBase<8> *)(this + 0x140),

+                       (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                        *)&local_48);

+            CMergedRectBase<4>::Add

+                      ((CMergedRectBase<4> *)(this + 0xaa8),

+                       (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                        *)&local_48);

+          }

+          else {

+            CTargetDirtyBase<8>::SetFullDirty((CTargetDirtyBase<8> *)(this + 0x140));

+          }

+        }

+      }

+      else {

+        pcVar2 = (char *)param_1[3];

+        local_58 = 0;

+        if (*pcVar2 == '\0') {

+          bVar4 = CCaptureRenderTarget::ComputeCursorTransform

+                            (this,param_2,*(CVisual **)param_1[2],(CVisualTree *)*plVar1,true,

+                             local_98);

+          if (!bVar4) {

+            CTargetDirtyBase<8>::SetFullDirty((CTargetDirtyBase<8> *)(this + 0x140));

+          }

+          *pcVar2 = '\x01';

+        }

+        pDVar6 = (D2D_RECT_F *)(*plVar1 + 0x50);

+        if (param_2 != *(CVisual **)(*plVar1 + 0x48)) {

+          pDVar6 = (D2D_RECT_F *)(param_2 + 0x98);

+        }

+        local_48 = 0;

+        uStack_40 = 0;

+        CMILMatrix::Transform2DBoundsHelper<0>(local_98,pDVar6,(D2D_RECT_F *)&local_48);

+        CTargetDirtyBase<8>::AddDirtyRect

+                  ((CTargetDirtyBase<8> *)(this + 0x140),

+                   (TMilRect_<float,D2D_RECT_F,D3D_RECT_F,D2D_POINTANDSIZE_F,RectUniqueness::NotNeeded>

+                    *)&local_48);

+      }

+    }

   }

-  return;

+  return 0;

 }
```

## `CCaptureRenderTarget::ComputeCursorInvalidRects`  (modified)

```diff
--- CCaptureRenderTarget::ComputeCursorInvalidRects
+++ <lambda_038d12cb786c59c95af184389708e22a>::operator()
@@ -1,35 +1,7 @@
 

-/* protected: void __cdecl CCaptureRenderTarget::ComputeCursorInvalidRects(class CMergedRect *

-   __ptr64)const __ptr64 */

-

-void __thiscall

-CCaptureRenderTarget::ComputeCursorInvalidRects(CCaptureRenderTarget *this,CMergedRect *param_1)

+void CloseHandle::operator()(void)

 

 {

-  bool bVar1;

-  CMergedRect *local_res10;

-  CDesktopTree *local_res18;

-  CVisual *local_res20;

-  undefined **local_48;

-  CCaptureRenderTarget *local_40;

-  CDesktopTree **ppCStack_38;

-  CVisual **local_30;

-  CMergedRect **ppCStack_28;

-  undefined ***local_10;

-  

-  local_res18 = (CDesktopTree *)0x0;

-  local_res20 = (CVisual *)0x0;

-  local_res10 = param_1;

-  bVar1 = GetCursorCaptureContext(this,&local_res18,&local_res20);

-  if (bVar1) {

-    ppCStack_38 = &local_res18;

-    local_30 = &local_res20;

-    ppCStack_28 = &local_res10;

-    local_48 = &PTR__Copy_180306d00;

-    local_10 = &local_48;

-    local_40 = this;

-    CComposition::ForEachCursorVisual(*(CComposition **)(this + 0x18),&local_48);

-  }

   return;

 }
```

## `CPrimitiveGroup::IsEmptyDrawing`  (modified)

```diff
--- CPrimitiveGroup::IsEmptyDrawing
+++ CSurfaceBrush::GetSurface
@@ -1,2 +1,23 @@
-Failed to decompile dwmcore.dll - .ProgramDB CPrimitiveGroup::IsEmptyDrawing : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* WARNING: Function: _guard_dispatch_icall$thunk$10345483385596137414 replaced with injection:

+   guard_dispatch_icall */

+/* public: class CResource * __ptr64 __cdecl CSurfaceBrush::GetSurface(void)const __ptr64 */

+

+CResource * __thiscall CSurfaceBrush::GetSurface(CSurfaceBrush *this)

+

+{

+  longlong *plVar1;

+  bool bVar2;

+  char cVar3;

+  

+  bVar2 = wil::details::FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2>::__private_IsEnabled

+                    ((FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2> *)

+                     &`private:_static_class_wil::details::FeatureImpl<__WilFeatureTraits_Feature_DCompChromiumK2>&___ptr64___cdecl_wil::Feature<__WilFeatureTraits_Feature_DCompChromiumK2>::GetImpl(void)'

+                      ::__l2::impl);

+  if (((bVar2) && (plVar1 = *(longlong **)(this + 0x80), plVar1 != (longlong *)0x0)) &&

+     (cVar3 = (**(code **)(*plVar1 + 0x40))(plVar1,0x22), cVar3 != '\0')) {

+    return *(CResource **)(*(longlong *)(this + 0x80) + 0x48);

+  }

+  return *(CResource **)(this + 0x80);

+}

+
```

## `CTextVisual::CTextVisual`  (modified)

```diff
--- CTextVisual::CTextVisual
+++ CTableTransferEffect::CTableTransferEffect
@@ -1,2 +1,24 @@
-Failed to decompile dwmcore.dll - .ProgramDB CTextVisual::CTextVisual : Error: Decompile error: 
-Marshaling error: Did not see expected closing element+

+/* protected: __cdecl CTableTransferEffect::CTableTransferEffect(class CComposition * __ptr64)

+   __ptr64 */

+

+CTableTransferEffect * __thiscall

+CTableTransferEffect::CTableTransferEffect(CTableTransferEffect *this,CComposition *param_1)

+

+{

+  CTableTransferEffect *this_00;

+  longlong lVar1;

+  

+  CFilterEffect::CFilterEffect((CFilterEffect *)this,param_1);

+  lVar1 = 4;

+  *(undefined ***)this = &_vftable_;

+  this_00 = this + 0xb8;

+  _vector_constructor_iterator_(this_00,0x28,4,DynArrayIA<float,2,0>::DynArrayIA<float,2,0>);

+  do {

+    DynArray<float,0>::AddMultipleAndSet((DynArray<float,0> *)this_00,(float *)&DAT_0,2);

+    this_00 = this_00 + 0x28;

+    lVar1 = lVar1 + -1;

+  } while (lVar1 != 0);

+  return this;

+}

+
```
