# CVE-2026-119873 — netbios.sys patch diff

`netbios.sys` 10.0.26100.9818 -> 10.0.26100.9974 (ghidriff).

## `NbListenCompletion`  (modified)

```diff
--- NbListenCompletion
+++ NbListenCompletion
@@ -1,17 +1,155 @@
-

-/* WARNING: Control flow encountered bad instruction data */

 

 undefined8 NbListenCompletion(undefined8 param_1,longlong param_2,byte *param_3)

 

 {

-  uint in_EAX;

-  undefined4 in_register_00000004;

-  char *unaff_RBX;

+  int *piVar1;

+  longlong lVar2;

+  longlong lVar3;

+  longlong lVar4;

+  undefined1 uVar5;

+  char cVar6;

+  longlong *plVar7;

+  ulonglong uVar8;

+  undefined8 uVar9;

   

-  *(uint *)CONCAT44(in_register_00000004,in_EAX) =

-       *(uint *)CONCAT44(in_register_00000004,in_EAX) | in_EAX;

-  *unaff_RBX = *unaff_RBX + (char)param_1;

-                    /* WARNING: Bad instruction - Truncating control flow here */

-  halt_baddata();

+  piVar1 = (int *)(param_2 + 0x30);

+  uVar9 = 0;

+  lVar2 = *(longlong *)(*(longlong *)(*(longlong *)(param_2 + 0xb8) + 0x30) + 0x20);

+  lVar3 = *(longlong *)(param_3 + 0xa0);

+  if (*piVar1 < 0) {

+    if (lVar3 == 0) {

+      ExFreePoolWithTag(*(undefined8 *)(param_3 + 0xd0),0);

+      param_3[0xd0] = 0;

+      param_3[0xd1] = 0;

+      param_3[0xd2] = 0;

+      param_3[0xd3] = 0;

+      param_3[0xd4] = 0;

+      param_3[0xd5] = 0;

+      param_3[0xd6] = 0;

+      param_3[0xd7] = 0;

+    }

+    else {

+      ExFreePoolWithTag();

+      param_3[0xa0] = 0;

+      param_3[0xa1] = 0;

+      param_3[0xa2] = 0;

+      param_3[0xa3] = 0;

+      param_3[0xa4] = 0;

+      param_3[0xa5] = 0;

+      param_3[0xa6] = 0;

+      param_3[0xa7] = 0;

+    }

+  }

+  else if (lVar3 == 0) {

+    memmove(param_3 + 0x12,(void *)(*(longlong *)(param_3 + 0xd0) + 10),0x10);

+    ExFreePoolWithTag(*(undefined8 *)(param_3 + 0xd0),0);

+    param_3[0xd0] = 0;

+    param_3[0xd1] = 0;

+    param_3[0xd2] = 0;

+    param_3[0xd3] = 0;

+    param_3[0xd4] = 0;

+    param_3[0xd5] = 0;

+    param_3[0xd6] = 0;

+    param_3[0xd7] = 0;

+  }

+  else {

+    ExFreePoolWithTag(lVar3,0);

+    param_3[0xa0] = 0;

+    param_3[0xa1] = 0;

+    param_3[0xa2] = 0;

+    param_3[0xa3] = 0;

+    param_3[0xa4] = 0;

+    param_3[0xa5] = 0;

+    param_3[0xa6] = 0;

+    param_3[0xa7] = 0;

+  }

+  lVar3 = lVar2 + 0x70;

+  uVar5 = KeAcquireSpinLockRaiseToDpc(lVar3);

+  plVar7 = (longlong *)FindCb(lVar2,param_3,'\0');

+  if (plVar7 != (longlong *)0x0) {

+    lVar2 = *plVar7;

+    if (*(char *)(lVar2 + 0x69) != '\x04') {

+      if ((*(char *)(lVar2 + 0x69) != '\x06') && (-1 < *piVar1)) {

+        uVar9 = *(undefined8 *)(lVar2 + 0x20);

+        *(undefined2 *)(param_3 + 0x10) = *(undefined2 *)(param_2 + 0x38);

+        memmove((void *)(lVar2 + 0x50),param_3 + 0x12,0x10);

+        lVar4 = *(longlong *)(param_2 + 0xb8);

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

+        *(code **)(lVar4 + -0x10) = NbCallCompletion;

+        *(byte **)(lVar4 + -8) = param_3;

+        *(undefined1 *)(lVar4 + -0x45) = 0xe0;

+        lVar4 = *(longlong *)(param_2 + 0xb8);

+        *(undefined2 *)(lVar4 + -0x48) = 0x50f;

+        *(undefined8 *)(lVar4 + -0x20) = *(undefined8 *)(lVar2 + 0x20);

+        *(undefined8 *)(lVar4 + -0x18) = *(undefined8 *)(lVar2 + 0x18);

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

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

+        uVar8 = Feature_2216061241__private_IsEnabledDeviceUsageNoInline();

+        if (((int)uVar8 == 0) || (cVar6 = ExAcquireRundownProtection(lVar2 + 0x90), cVar6 != '\0'))

+        {

+          KeReleaseSpinLock(lVar3,uVar5);

+          IofCallDriver(uVar9,param_2);

+          uVar8 = Feature_2216061241__private_IsEnabledDeviceUsageNoInline();

+          if ((int)uVar8 != 0) {

+            ExReleaseRundownProtection(lVar2 + 0x90);

+          }

+          return 0xc0000016;

+        }

+        uVar8 = Feature_3778698554__private_IsEnabledDeviceUsageNoInline();

+        if ((int)uVar8 != 0) {

+          *(undefined1 *)(*plVar7 + 0x69) = 6;

+        }

+        KeReleaseSpinLock(lVar3,uVar5);

+        if (param_3[1] == 0xff) {

+          param_3[1] = 10;

+        }

+        uVar9 = 0x80010001;

+        *piVar1 = -0x7ffeffff;

+        goto LAB_0;

+      }

+      uVar8 = Feature_3778698554__private_IsEnabledDeviceUsageNoInline();

+      if ((int)uVar8 == 0) {

+        KeReleaseSpinLock(lVar3,uVar5);

+        if (*(char *)(*plVar7 + 0x69) == '\x06') {

+          if (param_3[1] == 0xff) goto LAB_1;

+        }

+        else {

+          *(undefined1 *)(*plVar7 + 0x69) = 6;

+          if (param_3[1] == 0xff) goto LAB_2;

+        }

+      }

+      else {

+        cVar6 = *(char *)(*plVar7 + 0x69);

+        *(undefined1 *)(*plVar7 + 0x69) = 6;

+        KeReleaseSpinLock();

+        if (param_3[1] == 0xff) {

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

+LAB_1:

+            param_3[1] = 0xb;

+          }

+          else {

+LAB_2:

+            uVar8 = NbMakeNbError(*(int *)(param_2 + 0x30));

+            param_3[1] = (byte)uVar8;

+          }

+        }

+      }

+      uVar9 = 0x80010001;

+      *(undefined4 *)(param_2 + 0x30) = 0x80010001;

+      goto LAB_0;

+    }

+  }

+  KeReleaseSpinLock(lVar3,uVar5);

+  if (param_3[1] == 0xff) {

+    param_3[1] = 0x17;

+  }

+  *(undefined4 *)(param_2 + 0x30) = 0;

+LAB_0:

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

+  cVar6 = IoIs32bitProcess(param_2);

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

+    NbCompleteIrp32(param_2);

+  }

+  return uVar9;

 }
```

## `FindCallCb`  (modified)

```diff
--- FindCallCb
+++ wil_details_IsEnabledFallback
@@ -1,25 +1,22 @@
 

-longlong FindCallCb(longlong param_1,longlong param_2,byte param_3)

+uint wil_details_IsEnabledFallback(ulonglong param_1,int param_2,undefined8 *param_3)

 

 {

-  longlong lVar1;

-  int iVar2;

-  longlong lVar3;

-  longlong *plVar4;

+  uint uVar1;

+  ulonglong local_res8;

   

-  if ((((param_1 != 0) && ((uint)param_3 <= *(uint *)(param_1 + 0xe0))) &&

-      (lVar1 = *(longlong *)(*(longlong *)(param_1 + 0xe8) + (ulonglong)param_3 * 8), lVar1 != 0))

-     && (*(int *)(lVar1 + 4) == 2)) {

-    plVar4 = (longlong *)(lVar1 + 0x10);

-    iVar2 = 1;

-    for (lVar3 = 1; lVar3 < 0xff; lVar3 = lVar3 + 1) {

-      if ((*plVar4 != 0) && (*(longlong *)(*plVar4 + 0x70) == param_2)) {

-        return lVar1 + ((longlong)iVar2 + 1) * 8;

-      }

-      iVar2 = iVar2 + 1;

-      plVar4 = plVar4 + 1;

-    }

+  uVar1 = (uint)param_1;

+  local_res8 = param_1 & 0xffffffff;

+  if ((param_1 & 2) == 0) {

+    local_res8 = wil_details_FeatureStateCache_ReevaluateCachedFeatureEnabledState

+                           ((uint *)*param_3,param_1,(longlong)param_3);

+    uVar1 = (uint)local_res8;

   }

-  return 0;

+  if ((param_2 != 0) &&

+     (wil_details_FeatureReporting_ReportUsageToService((longlong)param_3,local_res8,param_2),

+     param_2 - 3U < 2)) {

+    wil_details_FeatureStateCache_TryEnableDeviceUsageFastPath((uint)local_res8,param_2,param_3);

+  }

+  return uVar1 & 1;

 }
```

## `NbCancel`  (modified)

```diff
--- NbCancel
+++ NbCancel
@@ -1,11 +1,449 @@
+

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

 

 undefined8 NbCancel(longlong param_1,longlong param_2,longlong param_3,uint param_4)

 

 {

-  char *in_RAX;

+  longlong lVar1;

+  undefined1 uVar2;

+  longlong lVar3;

+  longlong lVar4;

+  code *pcVar5;

+  char cVar6;

+  char cVar7;

+  uint *puVar8;

+  longlong *plVar9;

+  ulonglong uVar10;

+  uint uVar11;

+  longlong *plVar12;

+  longlong lVar13;

+  undefined8 *puVar14;

+  undefined8 uVar15;

+  undefined7 uVar17;

+  byte *pbVar16;

+  byte bVar18;

+  undefined1 *puVar19;

+  undefined1 *puVar20;

+  undefined1 *puVar21;

+  undefined8 uStack_220;

+  undefined1 auStack_218 [32];

+  undefined4 local_1f8;

+  undefined4 local_1f0;

+  undefined1 local_1e8 [4];

+  undefined4 local_1e4;

+  char local_1e0;

+  undefined8 *local_1d8;

+  longlong local_1d0;

+  byte *local_1c0;

+  longlong local_1b8;

+  undefined4 local_1a8;

+  uint uStack_1a4;

+  uint uStack_1a0;

+  uint uStack_19c;

+  undefined8 local_198;

+  undefined8 uStack_190;

+  undefined8 local_188;

+  undefined8 uStack_180;

+  undefined8 local_178;

+  undefined8 uStack_170;

+  undefined8 local_168;

+  undefined8 uStack_160;

+  uint local_158;

+  uint uStack_154;

+  uint uStack_150;

+  uint uStack_14c;

+  byte local_148 [256];

+  ulonglong local_48;

   

-  *in_RAX = *in_RAX + (char)in_RAX;

-  in_RAX[-1] = in_RAX[-1] + (char)param_1;

-  return 0x103;

+  puVar19 = auStack_218;

+  puVar20 = auStack_218;

+  puVar21 = auStack_218;

+  local_48 = __security_cookie ^ (ulonglong)auStack_218;

+  lVar3 = *(longlong *)(*(longlong *)(param_3 + 0x30) + 0x20);

+  local_1d0 = lVar3;

+  local_1b8 = param_1;

+  memset(&local_1a8,0,0x60);

+  puVar8 = (uint *)0x0;

+  uVar15 = 0;

+  memset(local_148,0,0xf8);

+  KeEnterCriticalRegion();

+  lVar13 = lVar3 + 8;

+  uVar15 = CONCAT71((int7)((ulonglong)uVar15 >> 8),1);

+  ExAcquireResourceExclusiveLite(lVar13,uVar15);

+  lVar1 = lVar3 + 0x70;

+  local_1e8[0] = KeAcquireSpinLockRaiseToDpc(lVar1);

+  local_1e4 = 1;

+  if (*(uint *)(lVar3 + 0xe0) < (uint)*(byte *)(param_1 + 0x40)) {

+    uVar17 = (undefined7)((ulonglong)uVar15 >> 8);

+  }

+  else {

+    lVar4 = *(longlong *)(*(longlong *)(lVar3 + 0xe8) + (ulonglong)*(byte *)(param_1 + 0x40) * 8);

+    if ((lVar4 != 0) && (*(int *)(lVar4 + 4) == 2)) {

+      lVar4 = *(longlong *)(param_2 + 8);

+      if (lVar4 != 0) {

+        if ((*(byte *)(lVar4 + 10) & 5) == 0) {

+          local_1f0 = 0x40000010;

+          local_1f8 = 0;

+          puVar8 = (uint *)MmMapLockedPagesSpecifyCache(lVar4,0,1,0);

+        }

+        else {

+          puVar8 = *(uint **)(lVar4 + 0x18);

+        }

+      }

+      if ((*(longlong *)(param_2 + 8) == 0) || (puVar8 == (uint *)0x0)) {

+        KeReleaseSpinLock(lVar3 + 0x70,local_1e8[0]);

+        ExReleaseResourceLite(lVar3 + 8);

+        KeLeaveCriticalRegion();

+        puVar21 = auStack_218;

+        if (*(char *)(param_1 + 1) == -1) {

+          *(undefined1 *)(param_1 + 1) = 0x24;

+          puVar21 = auStack_218;

+        }

+        goto LAB_0;

+      }

+      cVar6 = IoIs32bitProcess(param_2);

+      local_1e0 = cVar6;

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

+        if (param_4 < 0x40) {

+          KeReleaseSpinLock(lVar1,local_1e8[0]);

+          ExReleaseResourceLite(lVar13);

+          KeLeaveCriticalRegion();

+          puVar21 = auStack_218;

+          if (*(char *)(param_1 + 1) == -1) {

+            *(undefined1 *)(param_1 + 1) = 1;

+            puVar21 = auStack_218;

+          }

+          goto LAB_0;

+        }

+        NbThunkNcb((undefined1 *)puVar8,local_148);

+        pbVar16 = local_148;

+        uVar11 = (uint)local_148[0];

+      }

+      else {

+        if (param_4 < 0x60) {

+          KeReleaseSpinLock(lVar1,local_1e8[0]);

+          ExReleaseResourceLite(lVar13);

+          KeLeaveCriticalRegion();

+          puVar21 = auStack_218;

+          if (*(char *)(param_1 + 1) == -1) {

+            *(undefined1 *)(param_1 + 1) = 1;

+            puVar21 = auStack_218;

+          }

+          goto LAB_0;

+        }

+        uVar11 = *puVar8;

+        local_1a8 = uVar11;

+        uStack_1a4 = puVar8[1];

+        uStack_1a0 = puVar8[2];

+        uStack_19c = puVar8[3];

+        local_198 = *(undefined8 *)(puVar8 + 4);

+        uStack_190 = *(undefined8 *)(puVar8 + 6);

+        local_188 = *(undefined8 *)(puVar8 + 8);

+        uStack_180 = *(undefined8 *)(puVar8 + 10);

+        local_178 = *(undefined8 *)(puVar8 + 0xc);

+        uStack_170 = *(undefined8 *)(puVar8 + 0xe);

+        local_168 = *(undefined8 *)(puVar8 + 0x10);

+        uStack_160 = *(undefined8 *)(puVar8 + 0x12);

+        local_158 = puVar8[0x14];

+        uStack_154 = puVar8[0x15];

+        uStack_150 = puVar8[0x16];

+        uStack_14c = puVar8[0x17];

+        pbVar16 = (byte *)&local_1a8;

+      }

+      local_1c0 = pbVar16;

+      if (pbVar16[0x40] != *(byte *)(param_1 + 0x40)) {

+        puVar21 = auStack_218;

+        if (*(char *)(param_1 + 1) == -1) {

+          *(undefined1 *)(param_1 + 1) = 0x23;

+          puVar21 = auStack_218;

+        }

+        goto LAB_1;

+      }

+      uVar11 = uVar11 & 0x7f;

+      if (uVar11 < 0x22) {

+        if (uVar11 == 0x21) {

+          puVar21 = auStack_218;

+          if ((pbVar16[0x41] == 0xff) &&

+             (plVar9 = FindAbUsingNum(lVar3,pbVar16,pbVar16[3]), puVar21 = auStack_218,

+             plVar9 != (longlong *)0x0)) {

+            lVar13 = *plVar9;

+            for (plVar9 = *(longlong **)(lVar13 + 0x58); puVar21 = puVar20,

+                plVar9 != (longlong *)(lVar13 + 0x58); plVar9 = (longlong *)*plVar9) {

+              if (plVar9[3] == *(longlong *)(param_1 + 8)) {

+                lVar13 = *plVar9;

+                plVar12 = (longlong *)plVar9[1];

+                if ((*(longlong **)(lVar13 + 8) == plVar9) && ((longlong *)*plVar12 == plVar9))

+                goto LAB_2;

+                lVar13 = 3;

+                pcVar5 = (code *)swi(0x29);

+                (*pcVar5)();

+                puVar20 = puVar20 + 8;

+              }

+            }

+          }

+        }

+        else if ((uVar11 == 0x10) || (uVar11 == 0x11)) {

+LAB_3:

+          puVar21 = auStack_218;

+          if (pbVar16[0x41] == 0xff) {

+            KeReleaseSpinLock(lVar3 + 0x70,CONCAT71((int7)((ulonglong)pbVar16 >> 8),local_1e8[0]));

+            local_1e4 = 0;

+            cVar7 = ExGetPreviousMode();

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

+              ProbeForRead(*(undefined8 *)(param_1 + 8),0x60,4);

+            }

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

+              bVar18 = *(byte *)(*(longlong *)(param_1 + 8) + 0x30);

+            }

+            else {

+              bVar18 = *(byte *)(*(longlong *)(param_1 + 8) + 0x40);

+            }

+            local_1e8[0] = KeAcquireSpinLockRaiseToDpc(lVar3 + 0x70);

+            local_1e4 = 1;

+            plVar9 = (longlong *)FindCallCb(lVar3,*(longlong *)(param_1 + 8),bVar18);

+            uVar10 = Feature_3778698554__private_IsEnabledDeviceUsageNoInline();

+            if ((int)uVar10 == 0) {

+              puVar21 = auStack_218;

+              if (plVar9 != (longlong *)0x0) {

+                puVar14 = *(undefined8 **)(*plVar9 + 0x78);

+                puVar21 = auStack_218;

+                if ((*(char *)((longlong)puVar14 + 0x41) == -1) &&

+                   (puVar21 = auStack_218, (byte)(*(char *)(*plVar9 + 0x69) - 1U) < 2))

+                goto LAB_4;

+              }

+            }

+            else {

+              puVar21 = auStack_218;

+              if ((plVar9 != (longlong *)0x0) &&

+                 (((puVar21 = auStack_218, (byte)(*(char *)(*plVar9 + 0x69) - 1U) < 2 &&

+                   (lVar13 = *(longlong *)(*plVar9 + 0x78), puVar21 = auStack_218, lVar13 != 0)) &&

+                  (puVar21 = auStack_218, *(char *)(lVar13 + 0x41) == -1)))) {

+                if (*(char *)(lVar13 + 1) == -1) {

+                  *(undefined1 *)(lVar13 + 1) = 0xb;

+                }

+                goto LAB_5;

+              }

+            }

+          }

+        }

+        else if (uVar11 == 0x12) {

+          puVar21 = auStack_218;

+          if (pbVar16[0x41] == 0xff) {

+            plVar9 = (longlong *)FindCb(lVar3,pbVar16,'\0');

+            if ((plVar9 == (longlong *)0x0) || (*(char *)(*plVar9 + 0x69) != '\x04')) {

+LAB_6:

+              puVar21 = auStack_218;

+              if (*(char *)(param_1 + 1) == -1) {

+                *(undefined1 *)(param_1 + 1) = 0x26;

+                puVar21 = auStack_218;

+              }

+              goto LAB_1;

+            }

+            *(undefined1 *)(*plVar9 + 0x69) = 3;

+            lVar13 = *(longlong *)(*plVar9 + 0x80);

+            *(undefined8 *)(*plVar9 + 0x80) = 0;

+            if (lVar13 != 0) {

+              if (*(char *)(lVar13 + 1) == -1) {

+                *(undefined1 *)(lVar13 + 1) = 0xb;

+              }

+              *(undefined8 *)(*(longlong *)(lVar13 + 0x58) + 0x38) = 0x41;

+              *(undefined4 *)(*(longlong *)(lVar13 + 0x58) + 0x30) = 0;

+              IofCompleteRequest(*(undefined8 *)(lVar13 + 0x58),2);

+            }

+LAB_7:

+            puVar21 = auStack_218;

+            if (*(char *)(param_1 + 1) == -1) {

+              *(undefined1 *)(param_1 + 1) = 0;

+              puVar21 = auStack_218;

+            }

+            goto LAB_1;

+          }

+        }

+        else {

+          if ((uVar11 != 0x14) && (uVar11 != 0x15)) {

+            if (uVar11 == 0x16) {

+              puVar21 = auStack_218;

+              if ((pbVar16[0x41] == 0xff) &&

+                 (plVar9 = FindAbUsingNum(lVar3,pbVar16,pbVar16[3]), puVar21 = auStack_218,

+                 plVar9 != (longlong *)0x0)) {

+                plVar12 = (longlong *)(*plVar9 + 0x48);

+                for (plVar9 = (longlong *)*plVar12; puVar21 = puVar19, plVar9 != plVar12;

+                    plVar9 = (longlong *)*plVar9) {

+                  if (plVar9[3] == *(longlong *)(param_1 + 8)) {

+                    lVar13 = *plVar9;

+                    plVar12 = (longlong *)plVar9[1];

+                    if ((*(longlong **)(lVar13 + 8) == plVar9) && ((longlong *)*plVar12 == plVar9))

+                    {

+                      *plVar12 = lVar13;

+                      *(longlong **)(lVar13 + 8) = plVar12;

+                      *(undefined4 *)(puVar19 + 0x34) = 0;

+                      *(undefined8 *)(puVar19 + -8) = 0x140005120;

+                      KeReleaseSpinLock(lVar1,puVar19[0x30]);

+                      lVar13 = plVar9[2];

+                      *(undefined8 *)(puVar19 + -8) = 0x140005134;

+                      IoAcquireCancelSpinLock(lVar13 + 0x45);

+                      *(undefined1 *)(lVar13 + 0x44) = 0;

+                      LOCK();

+                      *(undefined8 *)(lVar13 + 0x68) = 0;

+                      UNLOCK();

+                      uVar2 = *(undefined1 *)(lVar13 + 0x45);

+                      *(undefined8 *)(puVar19 + -8) = 0x140005152;

+                      IoReleaseCancelSpinLock(uVar2);

+                      if (*(char *)((longlong)plVar9 + -0x47) == -1) {

+                        *(undefined1 *)((longlong)plVar9 + -0x47) = 0xb;

+                      }

+                      *(undefined4 *)(lVar13 + 0x30) = 0;

+                      *(undefined8 *)(lVar13 + 0x38) = 0x41;

+                      *(undefined8 *)(puVar19 + -8) = 0x14000517a;

+                      IofCompleteRequest(lVar13,2);

+                      if (*(char *)(param_1 + 1) != -1) goto LAB_1;

+                      *(undefined1 *)(param_1 + 1) = 0;

+                      break;

+                    }

+                    plVar12 = (longlong *)0x3;

+                    pcVar5 = (code *)swi(0x29);

+                    (*pcVar5)();

+                    puVar19 = puVar19 + 8;

+                  }

+                }

+              }

+              goto LAB_8;

+            }

+            if (uVar11 != 0x17) goto LAB_6;

+          }

+LAB_9:

+          puVar21 = auStack_218;

+          if ((pbVar16[0x41] == 0xff) &&

+             (plVar9 = (longlong *)FindCb(lVar3,pbVar16,'\0'), puVar21 = auStack_218,

+             plVar9 != (longlong *)0x0)) {

+            local_1d8 = (undefined8 *)0x0;

+            lVar13 = *plVar9;

+            if ((*pbVar16 & 0x7f) == 0x15) {

+              for (puVar14 = *(undefined8 **)(lVar13 + 0x30);

+                  (local_1d8 = (undefined8 *)0x0, puVar14 != (undefined8 *)(lVar13 + 0x30) &&

+                  (local_1d8 = puVar14 + -9, puVar14[3] != *(longlong *)(param_1 + 8)));

+                  puVar14 = (undefined8 *)*puVar14) {

+                local_1d8 = (undefined8 *)0x0;

+              }

+            }

+            else {

+              for (puVar14 = *(undefined8 **)(lVar13 + 0x40);

+                  (local_1d8 = (undefined8 *)0x0, puVar14 != (undefined8 *)(lVar13 + 0x40) &&

+                  (local_1d8 = puVar14 + -9, puVar14[3] != *(longlong *)(param_1 + 8)));

+                  puVar14 = (undefined8 *)*puVar14) {

+                local_1d8 = (undefined8 *)0x0;

+              }

+            }

+            puVar14 = local_1d8;

+            puVar21 = auStack_218;

+            if (local_1d8 != (undefined8 *)0x0) {

+LAB_4:

+              if (*(char *)((longlong)puVar14 + 1) == -1) {

+                *(undefined1 *)((longlong)puVar14 + 1) = 0xb;

+              }

+LAB_5:

+              local_1e4 = 0;

+              *(undefined1 *)(*plVar9 + 0x2c) = 1;

+              KeReleaseSpinLock(lVar3 + 0x70);

+              CleanupCb(plVar9,0);

+              goto LAB_7;

+            }

+          }

+        }

+      }

+      else if (uVar11 == 0x23) {

+        puVar21 = auStack_218;

+        if ((pbVar16[0x41] == 0xff) &&

+           (plVar9 = FindAbUsingNum(lVar3,pbVar16,0xff), puVar21 = auStack_218,

+           plVar9 != (longlong *)0x0)) {

+          lVar13 = *plVar9;

+          puVar21 = auStack_218;

+          for (plVar9 = *(longlong **)(lVar13 + 0x68); plVar9 != (longlong *)(lVar13 + 0x68);

+              plVar9 = (longlong *)*plVar9) {

+            if (plVar9[3] == *(longlong *)(param_1 + 8)) {

+              lVar13 = *plVar9;

+              plVar12 = (longlong *)plVar9[1];

+              if ((*(longlong **)(lVar13 + 8) == plVar9) && ((longlong *)*plVar12 == plVar9))

+              goto LAB_2;

+              lVar13 = 3;

+              pcVar5 = (code *)swi(0x29);

+              (*pcVar5)();

+              puVar21 = puVar21 + 8;

+            }

+          }

+        }

+      }

+      else if (uVar11 != 0x33) {

+        if ((uVar11 == 0x71) || (uVar11 == 0x72)) goto LAB_9;

+        if (uVar11 != 0x73) {

+          if (uVar11 != 0x74) goto LAB_6;

+          goto LAB_3;

+        }

+        puVar21 = auStack_218;

+        if (pbVar16[0x41] == 0xff) {

+          CancelLanAlert(lVar3,param_1);

+          puVar21 = auStack_218;

+          goto LAB_1;

+        }

+      }

+LAB_8:

+      if (*(char *)(param_1 + 1) == -1) {

+        *(undefined1 *)(param_1 + 1) = 0x24;

+      }

+      goto LAB_1;

+    }

+    uVar17 = (undefined7)((ulonglong)lVar4 >> 8);

+  }

+  KeReleaseSpinLock(lVar1,CONCAT71(uVar17,local_1e8[0]));

+  ExReleaseResourceLite(lVar13);

+  KeLeaveCriticalRegion();

+  puVar21 = auStack_218;

+  if (*(char *)(param_1 + 1) == -1) {

+    *(undefined1 *)(param_1 + 1) = 0x23;

+    puVar21 = auStack_218;

+  }

+  goto LAB_0;

+LAB_2:

+  *plVar12 = lVar13;

+  *(longlong **)(lVar13 + 8) = plVar12;

+  *(undefined4 *)(puVar21 + 0x34) = 0;

+  *(undefined8 *)(puVar21 + -8) = 0x1400054f5;

+  KeReleaseSpinLock(lVar3 + 0x70,puVar21[0x30]);

+  lVar13 = plVar9[2];

+  *(undefined8 *)(puVar21 + -8) = 0x140005509;

+  IoAcquireCancelSpinLock(lVar13 + 0x45);

+  *(undefined1 *)(lVar13 + 0x44) = 0;

+  LOCK();

+  *(undefined8 *)(lVar13 + 0x68) = 0;

+  UNLOCK();

+  uVar2 = *(undefined1 *)(lVar13 + 0x45);

+  *(undefined8 *)(puVar21 + -8) = 0x140005523;

+  IoReleaseCancelSpinLock(uVar2);

+  if (*(char *)((longlong)plVar9 + -0x47) == -1) {

+    *(undefined1 *)((longlong)plVar9 + -0x47) = 0xb;

+  }

+  *(undefined4 *)(lVar13 + 0x30) = 0;

+  *(undefined8 *)(lVar13 + 0x38) = 0x41;

+  *(undefined8 *)(puVar21 + -8) = 0x14000554c;

+  IofCompleteRequest(lVar13,2);

+  if (*(char *)(param_1 + 1) == -1) {

+    *(undefined1 *)(param_1 + 1) = 0;

+    goto LAB_8;

+  }

+LAB_1:

+  if (*(int *)(puVar21 + 0x34) == 1) {

+    *(undefined8 *)(puVar21 + -8) = 0x140005592;

+    KeReleaseSpinLock(lVar3 + 0x70,puVar21[0x30]);

+  }

+  *(undefined8 *)(puVar21 + -8) = 0x1400055a2;

+  ExReleaseResourceLite(lVar3 + 8);

+  *(undefined8 *)(puVar21 + -8) = 0x1400055ae;

+  KeLeaveCriticalRegion();

+  if (*(char *)(param_1 + 1) == -1) {

+    *(undefined1 *)(param_1 + 1) = 0;

+  }

+LAB_0:

+  *(undefined8 *)(puVar21 + -8) = 0x1400056ac;

+  return 0;

 }
```
