
npfs.nostrip.sys:     file format pei-i386

Disassembly of section .text:

00011000 <___crt_xc_end__>:

static PNPFS_PIPE
NpfsFindPipe(PNPFS_DEVICE_EXTENSION DeviceExt,
	     PUNICODE_STRING PipeName)
{
   11000:	55                   	push   %ebp
   11001:	89 e5                	mov    %esp,%ebp
   11003:	57                   	push   %edi
   11004:	56                   	push   %esi
   11005:	53                   	push   %ebx
   11006:	83 ec 0c             	sub    $0xc,%esp
   11009:	89 c7                	mov    %eax,%edi
  PLIST_ENTRY CurrentEntry;
  PNPFS_PIPE Pipe;

  CurrentEntry = DeviceExt->PipeListHead.Flink;
   1100b:	8b 18                	mov    (%eax),%ebx
   1100d:	89 55 f0             	mov    %edx,0xfffffff0(%ebp)
   11010:	eb 17                	jmp    11029 <___crt_xc_end__+0x29>
  while (CurrentEntry != &DeviceExt->PipeListHead)
    {
      Pipe = CONTAINING_RECORD(CurrentEntry, NPFS_PIPE, PipeListEntry);
   11012:	8d 73 f8             	lea    0xfffffff8(%ebx),%esi
      if (RtlCompareUnicodeString(PipeName,
   11015:	50                   	push   %eax
   11016:	6a 01                	push   $0x1
   11018:	56                   	push   %esi
   11019:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   1101c:	51                   	push   %ecx
   1101d:	e8 1e 18 00 00       	call   12840 <_RtlCompareUnicodeString@12>
   11022:	5a                   	pop    %edx
   11023:	85 c0                	test   %eax,%eax
   11025:	74 10                	je     11037 <___crt_xc_end__+0x37>
				  &Pipe->PipeName,
				  TRUE) == 0)
	{
	  DPRINT("<%wZ> = <%wZ>\n", PipeName, &Pipe->PipeName);
	  return Pipe;
	}

       CurrentEntry = CurrentEntry->Flink;
   11027:	8b 1b                	mov    (%ebx),%ebx
   11029:	39 fb                	cmp    %edi,%ebx
   1102b:	75 e5                	jne    11012 <___crt_xc_end__+0x12>
     }

  return NULL;
}
   1102d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11030:	31 c0                	xor    %eax,%eax
   11032:	5b                   	pop    %ebx
   11033:	5e                   	pop    %esi
   11034:	5f                   	pop    %edi
   11035:	5d                   	pop    %ebp
   11036:	c3                   	ret    
   11037:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1103a:	89 f0                	mov    %esi,%eax
   1103c:	5b                   	pop    %ebx
   1103d:	5e                   	pop    %esi
   1103e:	5f                   	pop    %edi
   1103f:	5d                   	pop    %ebp
   11040:	c3                   	ret    
   11041:	eb 0d                	jmp    11050 <_NpfsCreate@8>
   11043:	90                   	nop    
   11044:	90                   	nop    
   11045:	90                   	nop    
   11046:	90                   	nop    
   11047:	90                   	nop    
   11048:	90                   	nop    
   11049:	90                   	nop    
   1104a:	90                   	nop    
   1104b:	90                   	nop    
   1104c:	90                   	nop    
   1104d:	90                   	nop    
   1104e:	90                   	nop    
   1104f:	90                   	nop    

00011050 <_NpfsCreate@8>:


static PNPFS_FCB
NpfsFindListeningServerInstance(PNPFS_PIPE Pipe)
{
  PLIST_ENTRY CurrentEntry;
  PNPFS_WAITER_ENTRY Waiter;

  CurrentEntry = Pipe->WaiterListHead.Flink;
  while (CurrentEntry != &Pipe->WaiterListHead)
    {
      Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry);
      if (Waiter->Fcb->PipeState == FILE_PIPE_LISTENING_STATE &&
          !Waiter->Irp->Cancel)
	{
	  DPRINT("Server found! Fcb %p\n", Waiter->Fcb);

          if (IoSetCancelRoutine(Waiter->Irp, NULL) != NULL)
            {
              return Waiter->Fcb;
            }
	}

      CurrentEntry = CurrentEntry->Flink;
    }

  return NULL;
}


static VOID
NpfsSignalAndRemoveListeningServerInstance(PNPFS_PIPE Pipe,
					   PNPFS_FCB Fcb)
{
  PLIST_ENTRY CurrentEntry;
  PNPFS_WAITER_ENTRY Waiter;

  CurrentEntry = Pipe->WaiterListHead.Flink;
  while (CurrentEntry != &Pipe->WaiterListHead)
    {
      Waiter = CONTAINING_RECORD(CurrentEntry, NPFS_WAITER_ENTRY, Entry);
      if (Waiter->Fcb == Fcb)
	{
	  DPRINT("Server found! Fcb %p\n", Waiter->Fcb);

	  Waiter->Irp->IoStatus.Status = FILE_PIPE_CONNECTED_STATE;
	  Waiter->Irp->IoStatus.Information = 0;
	  IoCompleteRequest(Waiter->Irp, IO_NO_INCREMENT);

	  RemoveEntryList(&Waiter->Entry);
	  ExFreePool(Waiter);
	  return;
	}
      CurrentEntry = CurrentEntry->Flink;
    }
}


NTSTATUS STDCALL
NpfsCreate(PDEVICE_OBJECT DeviceObject,
	   PIRP Irp)
{
   11050:	55                   	push   %ebp
   11051:	89 e5                	mov    %esp,%ebp
   11053:	57                   	push   %edi
   11054:	56                   	push   %esi
   11055:	53                   	push   %ebx
   11056:	83 ec 28             	sub    $0x28,%esp
  PIO_STACK_LOCATION IoStack;
  PFILE_OBJECT FileObject;
  PNPFS_PIPE Pipe;
  PNPFS_FCB ClientFcb;
  PNPFS_FCB ServerFcb = NULL;
   11059:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
  PNPFS_DEVICE_EXTENSION DeviceExt;
  BOOLEAN SpecialAccess;

  DPRINT("NpfsCreate(DeviceObject %p Irp %p)\n", DeviceObject, Irp);

  DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
   11060:	8b 45 08             	mov    0x8(%ebp),%eax
  IoStack = IoGetCurrentIrpStackLocation(Irp);
   11063:	8b 55 0c             	mov    0xc(%ebp),%edx
   11066:	8b 58 28             	mov    0x28(%eax),%ebx
   11069:	8b 42 60             	mov    0x60(%edx),%eax
  FileObject = IoStack->FileObject;
   1106c:	8b 50 18             	mov    0x18(%eax),%edx
  DPRINT("FileObject %p\n", FileObject);
  DPRINT("FileName %wZ\n", &FileObject->FileName);

  Irp->IoStatus.Information = 0;

  SpecialAccess = ((IoStack->Parameters.Create.ShareAccess & 3) == 3);
  if (SpecialAccess)
    {
      DPRINT("NpfsCreate() open client end for special use!\n");
    }

  /*
   * Step 1. Find the pipe we're trying to open.
   */
  KeLockMutex(&DeviceExt->PipeListLock);
   1106f:	8d 73 08             	lea    0x8(%ebx),%esi
   11072:	89 55 f0             	mov    %edx,0xfffffff0(%ebp)
   11075:	8b 55 0c             	mov    0xc(%ebp),%edx
   11078:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)
   1107f:	66 8b 40 0e          	mov    0xe(%eax),%ax
   11083:	6a 00                	push   $0x0
   11085:	83 e0 03             	and    $0x3,%eax
   11088:	6a 00                	push   $0x0
   1108a:	83 f8 03             	cmp    $0x3,%eax
   1108d:	6a 00                	push   $0x0
   1108f:	0f 94 c0             	sete   %al
   11092:	6a 06                	push   $0x6
   11094:	89 c7                	mov    %eax,%edi
   11096:	56                   	push   %esi
   11097:	e8 b4 17 00 00       	call   12850 <_KeWaitForSingleObject@20>
  Pipe = NpfsFindPipe(DeviceExt,
   1109c:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   1109f:	83 c4 0c             	add    $0xc,%esp
   110a2:	83 c2 30             	add    $0x30,%edx
   110a5:	89 d8                	mov    %ebx,%eax
   110a7:	e8 54 ff ff ff       	call   11000 <___crt_xc_end__>
		      &FileObject->FileName);
  if (Pipe == NULL)
   110ac:	85 c0                	test   %eax,%eax
   110ae:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   110b1:	0f 84 89 02 00 00    	je     11340 <_NpfsCreate@8+0x2f0>
    {
      /* Not found, bail out with error. */
      DPRINT("No pipe found!\n");
      KeUnlockMutex(&DeviceExt->PipeListLock);
      Irp->IoStatus.Status = STATUS_OBJECT_NAME_NOT_FOUND;
      IoCompleteRequest(Irp, IO_NO_INCREMENT);
      return STATUS_OBJECT_NAME_NOT_FOUND;
    }

  KeUnlockMutex(&DeviceExt->PipeListLock);
   110b7:	53                   	push   %ebx
   110b8:	53                   	push   %ebx
   110b9:	6a 00                	push   $0x0
   110bb:	56                   	push   %esi
   110bc:	e8 9f 17 00 00       	call   12860 <_KeReleaseMutex@8>

  /*
   * Acquire the lock for FCB lists. From now on no modifications to the
   * FCB lists are allowed, because it can cause various misconsistencies.
   */
  KeLockMutex(&Pipe->FcbListLock);
   110c1:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   110c4:	83 c0 10             	add    $0x10,%eax
   110c7:	51                   	push   %ecx
   110c8:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   110cb:	6a 00                	push   $0x0
   110cd:	6a 00                	push   $0x0
   110cf:	6a 00                	push   $0x0
   110d1:	6a 06                	push   $0x6
   110d3:	50                   	push   %eax
   110d4:	e8 77 17 00 00       	call   12850 <_KeWaitForSingleObject@20>

  /*
   * Step 2. Create the client FCB.
   */
  ClientFcb = ExAllocatePool(NonPagedPool, sizeof(NPFS_FCB));
   110d9:	c7 04 24 58 00 00 00 	movl   $0x58,(%esp)
   110e0:	6a 00                	push   $0x0
   110e2:	e8 89 17 00 00       	call   12870 <_ExAllocatePool@8>
   110e7:	89 c6                	mov    %eax,%esi
  if (ClientFcb == NULL)
   110e9:	58                   	pop    %eax
   110ea:	85 f6                	test   %esi,%esi
   110ec:	5a                   	pop    %edx
   110ed:	0f 84 73 02 00 00    	je     11366 <_NpfsCreate@8+0x316>
    {
      DPRINT("No memory!\n");
      KeUnlockMutex(&Pipe->FcbListLock);
      Irp->IoStatus.Status = STATUS_NO_MEMORY;
      IoCompleteRequest(Irp, IO_NO_INCREMENT);
      return STATUS_NO_MEMORY;
    }

  ClientFcb->Thread = (struct ETHREAD *)Irp->Tail.Overlay.Thread;
   110f3:	8b 55 0c             	mov    0xc(%ebp),%edx
   110f6:	8b 42 50             	mov    0x50(%edx),%eax
  ClientFcb->Pipe = Pipe;
  ClientFcb->PipeEnd = FILE_PIPE_CLIENT_END;
  ClientFcb->OtherSide = NULL;
  ClientFcb->PipeState = SpecialAccess ? 0 : FILE_PIPE_DISCONNECTED_STATE;

  /* Initialize data list. */
  if (Pipe->OutboundQuota)
   110f9:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   110fc:	89 46 0c             	mov    %eax,0xc(%esi)
   110ff:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11102:	89 46 10             	mov    %eax,0x10(%esi)
   11105:	89 f8                	mov    %edi,%eax
   11107:	83 f0 01             	xor    $0x1,%eax
   1110a:	c7 46 34 00 00 00 00 	movl   $0x0,0x34(%esi)
   11111:	25 ff 00 00 00       	and    $0xff,%eax
   11116:	c7 46 08 00 00 00 00 	movl   $0x0,0x8(%esi)
   1111d:	89 46 38             	mov    %eax,0x38(%esi)
   11120:	8b 42 68             	mov    0x68(%edx),%eax
   11123:	85 c0                	test   %eax,%eax
   11125:	0f 85 65 01 00 00    	jne    11290 <_NpfsCreate@8+0x240>
    {
      ClientFcb->Data = ExAllocatePool(NonPagedPool, Pipe->OutboundQuota);
      if (ClientFcb->Data == NULL)
        {
          DPRINT("No memory!\n");
          ExFreePool(ClientFcb);
          KeUnlockMutex(&Pipe->FcbListLock);
          Irp->IoStatus.Status = STATUS_NO_MEMORY;
          IoCompleteRequest(Irp, IO_NO_INCREMENT);
          return STATUS_NO_MEMORY;
        }
    }
  else
    {
      ClientFcb->Data = NULL;
   1112b:	c7 46 44 00 00 00 00 	movl   $0x0,0x44(%esi)
    }

  ClientFcb->ReadPtr = ClientFcb->Data;
  ClientFcb->WritePtr = ClientFcb->Data;
  ClientFcb->ReadDataAvailable = 0;
  ClientFcb->WriteQuotaAvailable = Pipe->OutboundQuota;
   11132:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   11135:	8b 46 44             	mov    0x44(%esi),%eax
   11138:	c7 46 3c 00 00 00 00 	movl   $0x0,0x3c(%esi)
   1113f:	89 46 48             	mov    %eax,0x48(%esi)
   11142:	89 46 4c             	mov    %eax,0x4c(%esi)
   11145:	8b 42 68             	mov    0x68(%edx),%eax
   11148:	89 46 40             	mov    %eax,0x40(%esi)
  ClientFcb->MaxDataLength = Pipe->OutboundQuota;
  KeInitializeSpinLock(&ClientFcb->DataListLock);
   1114b:	83 ec 0c             	sub    $0xc,%esp
   1114e:	8b 42 68             	mov    0x68(%edx),%eax
   11151:	89 46 50             	mov    %eax,0x50(%esi)
   11154:	8d 46 54             	lea    0x54(%esi),%eax
   11157:	50                   	push   %eax
   11158:	e8 23 17 00 00       	call   12880 <_KeInitializeSpinLock@4>
  KeInitializeEvent(&ClientFcb->ConnectEvent, SynchronizationEvent, FALSE);
   1115d:	58                   	pop    %eax
   1115e:	8d 46 14             	lea    0x14(%esi),%eax
   11161:	5a                   	pop    %edx
   11162:	6a 00                	push   $0x0
   11164:	6a 01                	push   $0x1
   11166:	50                   	push   %eax
   11167:	e8 24 17 00 00       	call   12890 <_KeInitializeEvent@12>
  KeInitializeEvent(&ClientFcb->Event, SynchronizationEvent, FALSE);
   1116c:	8d 46 24             	lea    0x24(%esi),%eax
   1116f:	6a 00                	push   $0x0
   11171:	6a 01                	push   $0x1
   11173:	50                   	push   %eax
   11174:	e8 17 17 00 00       	call   12890 <_KeInitializeEvent@12>

  /*
   * Step 3. Search for listening server FCB.
   */

  if (!SpecialAccess)
   11179:	58                   	pop    %eax
   1117a:	89 f8                	mov    %edi,%eax
   1117c:	84 c0                	test   %al,%al
   1117e:	74 74                	je     111f4 <_NpfsCreate@8+0x1a4>
    {
      /*
       * WARNING: Point of no return! Once we get the server FCB it's
       * possible that we completed a wait request and so we have to
       * complete even this request.
       */

      ServerFcb = NpfsFindListeningServerInstance(Pipe);
      if (ServerFcb == NULL)
        {
          PLIST_ENTRY CurrentEntry;
          PNPFS_FCB Fcb;

          /*
           * If no waiting server FCB was found then try to pick
           * one of the listing server FCB on the pipe.
           */

          CurrentEntry = Pipe->ServerFcbListHead.Flink;
          while (CurrentEntry != &Pipe->ServerFcbListHead)
            {
              Fcb = CONTAINING_RECORD(CurrentEntry, NPFS_FCB, FcbListEntry);
              if (Fcb->PipeState == FILE_PIPE_LISTENING_STATE)
                {
                  ServerFcb = Fcb;
                  break;
                }
              CurrentEntry = CurrentEntry->Flink;
            }

          /*
           * No one is listening to me?! I'm so lonely... :(
           */

          if (ServerFcb == NULL)
            {
              /* Not found, bail out with error for FILE_OPEN requests. */
              DPRINT("No listening server fcb found!\n");
              if (ClientFcb->Data)
                ExFreePool(ClientFcb->Data);
              KeUnlockMutex(&Pipe->FcbListLock);
              Irp->IoStatus.Status = STATUS_PIPE_BUSY;
              IoCompleteRequest(Irp, IO_NO_INCREMENT);
              return STATUS_PIPE_BUSY;
            }
        }
      else
        {
          /* Signal the server thread and remove it from the waiter list */
          /* FIXME: Merge this with the NpfsFindListeningServerInstance routine. */
          NpfsSignalAndRemoveListeningServerInstance(Pipe, ServerFcb);
        }
    }
  else if (IsListEmpty(&Pipe->ServerFcbListHead))
   11180:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11183:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   11186:	83 c0 30             	add    $0x30,%eax
   11189:	39 42 30             	cmp    %eax,0x30(%edx)
   1118c:	0f 84 f3 01 00 00    	je     11385 <_NpfsCreate@8+0x335>
static __inline VOID
InsertTailList(
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
   11192:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11195:	83 c0 38             	add    $0x38,%eax
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
	Entry->Flink = ListHead;
   11198:	89 06                	mov    %eax,(%esi)
   1119a:	8b 50 04             	mov    0x4(%eax),%edx
	Entry->Blink = OldBlink;
   1119d:	89 56 04             	mov    %edx,0x4(%esi)
	OldBlink->Flink = Entry;
	ListHead->Blink = Entry;
   111a0:	89 70 04             	mov    %esi,0x4(%eax)
    {
      DPRINT("No server fcb found!\n");
      KeUnlockMutex(&Pipe->FcbListLock);
      Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
      IoCompleteRequest(Irp, IO_NO_INCREMENT);
      return STATUS_UNSUCCESSFUL;
    }

  /*
   * Step 4. Add the client FCB to a list and connect it if possible.
   */

  /* Add the client FCB to the pipe FCB list. */
  InsertTailList(&Pipe->ClientFcbListHead, &ClientFcb->FcbListEntry);

  /* Connect to listening server side */
  if (ServerFcb)
   111a3:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
	Entry->Flink = ListHead;
	Entry->Blink = OldBlink;
	OldBlink->Flink = Entry;
   111a6:	89 32                	mov    %esi,(%edx)
   111a8:	85 c0                	test   %eax,%eax
   111aa:	74 17                	je     111c3 <_NpfsCreate@8+0x173>
    {
      ClientFcb->OtherSide = ServerFcb;
   111ac:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
      ServerFcb->OtherSide = ClientFcb;
      ClientFcb->PipeState = FILE_PIPE_CONNECTED_STATE;
   111af:	c7 46 38 03 00 00 00 	movl   $0x3,0x38(%esi)
   111b6:	89 56 08             	mov    %edx,0x8(%esi)
      ServerFcb->PipeState = FILE_PIPE_CONNECTED_STATE;
   111b9:	c7 42 38 03 00 00 00 	movl   $0x3,0x38(%edx)
   111c0:	89 72 08             	mov    %esi,0x8(%edx)
    }

  KeUnlockMutex(&Pipe->FcbListLock);
   111c3:	50                   	push   %eax
   111c4:	50                   	push   %eax
   111c5:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   111c8:	6a 00                	push   $0x0
   111ca:	50                   	push   %eax
   111cb:	e8 90 16 00 00       	call   12860 <_KeReleaseMutex@8>

  FileObject->FsContext = ClientFcb;
   111d0:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax

  Irp->IoStatus.Status = STATUS_SUCCESS;
   111d3:	8b 55 0c             	mov    0xc(%ebp),%edx
   111d6:	89 70 0c             	mov    %esi,0xc(%eax)
   111d9:	c7 42 18 00 00 00 00 	movl   $0x0,0x18(%edx)
  IoCompleteRequest(Irp, IO_NO_INCREMENT);
   111e0:	6a 00                	push   $0x0
   111e2:	52                   	push   %edx
   111e3:	e8 b8 16 00 00       	call   128a0 <_IoCompleteRequest@8>

  DPRINT("Success!\n");

  return STATUS_SUCCESS;
   111e8:	31 c0                	xor    %eax,%eax
}
   111ea:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   111ed:	5b                   	pop    %ebx
   111ee:	5e                   	pop    %esi
   111ef:	5f                   	pop    %edi
   111f0:	5d                   	pop    %ebp
   111f1:	c2 08 00             	ret    $0x8
   111f4:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   111f7:	89 d7                	mov    %edx,%edi
   111f9:	8b 5a 40             	mov    0x40(%edx),%ebx
   111fc:	83 c7 40             	add    $0x40,%edi
   111ff:	39 df                	cmp    %ebx,%edi
   11201:	74 0f                	je     11212 <_NpfsCreate@8+0x1c2>
   11203:	8b 43 10             	mov    0x10(%ebx),%eax
   11206:	83 78 38 02          	cmpl   $0x2,0x38(%eax)
   1120a:	74 64                	je     11270 <_NpfsCreate@8+0x220>
   1120c:	8b 1b                	mov    (%ebx),%ebx
   1120e:	39 df                	cmp    %ebx,%edi
   11210:	75 f1                	jne    11203 <_NpfsCreate@8+0x1b3>
   11212:	31 c0                	xor    %eax,%eax
   11214:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   11217:	85 c0                	test   %eax,%eax
   11219:	0f 84 bd 00 00 00    	je     112dc <_NpfsCreate@8+0x28c>
   1121f:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   11222:	8b 5a 40             	mov    0x40(%edx),%ebx
   11225:	eb 02                	jmp    11229 <_NpfsCreate@8+0x1d9>
   11227:	8b 1b                	mov    (%ebx),%ebx
   11229:	39 df                	cmp    %ebx,%edi
   1122b:	0f 84 61 ff ff ff    	je     11192 <_NpfsCreate@8+0x142>
   11231:	39 43 10             	cmp    %eax,0x10(%ebx)
   11234:	75 f1                	jne    11227 <_NpfsCreate@8+0x1d7>
   11236:	8b 43 08             	mov    0x8(%ebx),%eax
   11239:	c7 40 18 03 00 00 00 	movl   $0x3,0x18(%eax)
   11240:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   11247:	52                   	push   %edx
   11248:	52                   	push   %edx
   11249:	6a 00                	push   $0x0
   1124b:	8b 43 08             	mov    0x8(%ebx),%eax
   1124e:	50                   	push   %eax
   1124f:	e8 4c 16 00 00       	call   128a0 <_IoCompleteRequest@8>
   11254:	50                   	push   %eax
{
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
   11255:	8b 13                	mov    (%ebx),%edx
  OldBlink = Entry->Blink;
   11257:	8b 43 04             	mov    0x4(%ebx),%eax
  OldFlink->Blink = OldBlink;
   1125a:	89 42 04             	mov    %eax,0x4(%edx)
  OldBlink->Flink = OldFlink;
   1125d:	89 10                	mov    %edx,(%eax)
   1125f:	53                   	push   %ebx
   11260:	e8 4b 16 00 00       	call   128b0 <_ExFreePool@4>
   11265:	83 c4 0c             	add    $0xc,%esp
   11268:	e9 25 ff ff ff       	jmp    11192 <_NpfsCreate@8+0x142>
   1126d:	8d 76 00             	lea    0x0(%esi),%esi
   11270:	8b 43 08             	mov    0x8(%ebx),%eax
   11273:	80 78 24 00          	cmpb   $0x0,0x24(%eax)
   11277:	75 93                	jne    1120c <_NpfsCreate@8+0x1bc>
   11279:	31 d2                	xor    %edx,%edx
   1127b:	8d 48 38             	lea    0x38(%eax),%ecx
   1127e:	e8 3d 16 00 00       	call   128c0 <@InterlockedExchange@8>
   11283:	85 c0                	test   %eax,%eax
   11285:	74 85                	je     1120c <_NpfsCreate@8+0x1bc>
   11287:	8b 43 10             	mov    0x10(%ebx),%eax
   1128a:	eb 88                	jmp    11214 <_NpfsCreate@8+0x1c4>
   1128c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11290:	51                   	push   %ecx
   11291:	51                   	push   %ecx
   11292:	50                   	push   %eax
   11293:	6a 00                	push   $0x0
   11295:	e8 d6 15 00 00       	call   12870 <_ExAllocatePool@8>
   1129a:	85 c0                	test   %eax,%eax
   1129c:	89 46 44             	mov    %eax,0x44(%esi)
   1129f:	5b                   	pop    %ebx
   112a0:	5a                   	pop    %edx
   112a1:	0f 85 8b fe ff ff    	jne    11132 <_NpfsCreate@8+0xe2>
   112a7:	83 ec 0c             	sub    $0xc,%esp
   112aa:	56                   	push   %esi
   112ab:	e8 00 16 00 00       	call   128b0 <_ExFreePool@4>
   112b0:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   112b3:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   112ba:	51                   	push   %ecx
   112bb:	e8 a0 15 00 00       	call   12860 <_KeReleaseMutex@8>
   112c0:	8b 45 0c             	mov    0xc(%ebp),%eax
   112c3:	c7 40 18 17 00 00 c0 	movl   $0xc0000017,0x18(%eax)
   112ca:	6a 00                	push   $0x0
   112cc:	50                   	push   %eax
   112cd:	e8 ce 15 00 00       	call   128a0 <_IoCompleteRequest@8>
   112d2:	b8 17 00 00 c0       	mov    $0xc0000017,%eax
   112d7:	e9 0e ff ff ff       	jmp    111ea <_NpfsCreate@8+0x19a>
   112dc:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   112df:	8b 42 30             	mov    0x30(%edx),%eax
   112e2:	83 c2 30             	add    $0x30,%edx
   112e5:	eb 08                	jmp    112ef <_NpfsCreate@8+0x29f>
   112e7:	83 78 38 02          	cmpl   $0x2,0x38(%eax)
   112eb:	74 44                	je     11331 <_NpfsCreate@8+0x2e1>
   112ed:	8b 00                	mov    (%eax),%eax
   112ef:	39 c2                	cmp    %eax,%edx
   112f1:	75 f4                	jne    112e7 <_NpfsCreate@8+0x297>
   112f3:	8b 46 44             	mov    0x44(%esi),%eax
   112f6:	85 c0                	test   %eax,%eax
   112f8:	75 29                	jne    11323 <_NpfsCreate@8+0x2d3>
   112fa:	8b 75 e4             	mov    0xffffffe4(%ebp),%esi
   112fd:	57                   	push   %edi
   112fe:	57                   	push   %edi
   112ff:	6a 00                	push   $0x0
   11301:	56                   	push   %esi
   11302:	e8 59 15 00 00       	call   12860 <_KeReleaseMutex@8>
   11307:	8b 45 0c             	mov    0xc(%ebp),%eax
   1130a:	c7 40 18 ae 00 00 c0 	movl   $0xc00000ae,0x18(%eax)
   11311:	6a 00                	push   $0x0
   11313:	50                   	push   %eax
   11314:	e8 87 15 00 00       	call   128a0 <_IoCompleteRequest@8>
   11319:	b8 ae 00 00 c0       	mov    $0xc00000ae,%eax
   1131e:	e9 c7 fe ff ff       	jmp    111ea <_NpfsCreate@8+0x19a>
   11323:	83 ec 0c             	sub    $0xc,%esp
   11326:	50                   	push   %eax
   11327:	e8 84 15 00 00       	call   128b0 <_ExFreePool@4>
   1132c:	83 c4 0c             	add    $0xc,%esp
   1132f:	eb c9                	jmp    112fa <_NpfsCreate@8+0x2aa>
   11331:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   11334:	85 c0                	test   %eax,%eax
   11336:	0f 85 56 fe ff ff    	jne    11192 <_NpfsCreate@8+0x142>
   1133c:	eb b5                	jmp    112f3 <_NpfsCreate@8+0x2a3>
   1133e:	89 f6                	mov    %esi,%esi
   11340:	57                   	push   %edi
   11341:	57                   	push   %edi
   11342:	6a 00                	push   $0x0
   11344:	56                   	push   %esi
   11345:	e8 16 15 00 00       	call   12860 <_KeReleaseMutex@8>
   1134a:	8b 55 0c             	mov    0xc(%ebp),%edx
   1134d:	c7 42 18 34 00 00 c0 	movl   $0xc0000034,0x18(%edx)
   11354:	6a 00                	push   $0x0
   11356:	52                   	push   %edx
   11357:	e8 44 15 00 00       	call   128a0 <_IoCompleteRequest@8>
   1135c:	b8 34 00 00 c0       	mov    $0xc0000034,%eax
   11361:	e9 84 fe ff ff       	jmp    111ea <_NpfsCreate@8+0x19a>
   11366:	8b 5d e4             	mov    0xffffffe4(%ebp),%ebx
   11369:	56                   	push   %esi
   1136a:	56                   	push   %esi
   1136b:	6a 00                	push   $0x0
   1136d:	53                   	push   %ebx
   1136e:	e8 ed 14 00 00       	call   12860 <_KeReleaseMutex@8>
   11373:	8b 55 0c             	mov    0xc(%ebp),%edx
   11376:	c7 42 18 17 00 00 c0 	movl   $0xc0000017,0x18(%edx)
   1137d:	6a 00                	push   $0x0
   1137f:	52                   	push   %edx
   11380:	e9 48 ff ff ff       	jmp    112cd <_NpfsCreate@8+0x27d>
   11385:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   11388:	53                   	push   %ebx
   11389:	53                   	push   %ebx
   1138a:	6a 00                	push   $0x0
   1138c:	51                   	push   %ecx
   1138d:	e8 ce 14 00 00       	call   12860 <_KeReleaseMutex@8>
   11392:	8b 45 0c             	mov    0xc(%ebp),%eax
   11395:	c7 40 18 01 00 00 c0 	movl   $0xc0000001,0x18(%eax)
   1139c:	6a 00                	push   $0x0
   1139e:	50                   	push   %eax
   1139f:	e8 fc 14 00 00       	call   128a0 <_IoCompleteRequest@8>
   113a4:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   113a9:	e9 3c fe ff ff       	jmp    111ea <_NpfsCreate@8+0x19a>
   113ae:	89 f6                	mov    %esi,%esi

000113b0 <_NpfsCreateNamedPipe@8>:


NTSTATUS STDCALL
NpfsCreateNamedPipe(PDEVICE_OBJECT DeviceObject,
		    PIRP Irp)
{
   113b0:	55                   	push   %ebp
   113b1:	89 e5                	mov    %esp,%ebp
   113b3:	57                   	push   %edi
   113b4:	56                   	push   %esi
   113b5:	53                   	push   %ebx
   113b6:	83 ec 24             	sub    $0x24,%esp
   PIO_STACK_LOCATION IoStack;
   PFILE_OBJECT FileObject;
   PNPFS_DEVICE_EXTENSION DeviceExt;
   PNPFS_PIPE Pipe;
   PNPFS_FCB Fcb;
   PNAMED_PIPE_CREATE_PARAMETERS Buffer;
   BOOLEAN NewPipe = FALSE;
   113b9:	c6 45 e7 00          	movb   $0x0,0xffffffe7(%ebp)

   DPRINT("NpfsCreateNamedPipe(DeviceObject %p Irp %p)\n", DeviceObject, Irp);

   DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
   113bd:	8b 45 08             	mov    0x8(%ebp),%eax
   IoStack = IoGetCurrentIrpStackLocation(Irp);
   FileObject = IoStack->FileObject;
   DPRINT("FileObject %p\n", FileObject);
   DPRINT("Pipe name %wZ\n", &FileObject->FileName);

   Buffer = IoStack->Parameters.CreatePipe.Parameters;

   Irp->IoStatus.Information = 0;
   113c0:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   113c3:	8b 58 28             	mov    0x28(%eax),%ebx
   113c6:	8b 45 0c             	mov    0xc(%ebp),%eax
   113c9:	8b 40 60             	mov    0x60(%eax),%eax
   113cc:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   113cf:	8b 50 18             	mov    0x18(%eax),%edx
   113d2:	89 55 ec             	mov    %edx,0xffffffec(%ebp)
   113d5:	8b 70 10             	mov    0x10(%eax),%esi
   113d8:	c7 41 1c 00 00 00 00 	movl   $0x0,0x1c(%ecx)

   Fcb = ExAllocatePool(NonPagedPool, sizeof(NPFS_FCB));
   113df:	6a 58                	push   $0x58
   113e1:	6a 00                	push   $0x0
   113e3:	e8 88 14 00 00       	call   12870 <_ExAllocatePool@8>
   if (Fcb == NULL)
   113e8:	85 c0                	test   %eax,%eax
   113ea:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
   113ed:	59                   	pop    %ecx
   113ee:	5f                   	pop    %edi
   113ef:	0f 84 7b 03 00 00    	je     11770 <_NpfsCreateNamedPipe@8+0x3c0>
     {
	Irp->IoStatus.Status = STATUS_NO_MEMORY;
	IoCompleteRequest(Irp, IO_NO_INCREMENT);
	return STATUS_NO_MEMORY;
     }

   Fcb->Thread = (struct ETHREAD *)Irp->Tail.Overlay.Thread;
   113f5:	8b 55 0c             	mov    0xc(%ebp),%edx
   113f8:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   KeLockMutex(&DeviceExt->PipeListLock);
   113fb:	83 ec 0c             	sub    $0xc,%esp
   113fe:	8b 42 50             	mov    0x50(%edx),%eax
   11401:	89 41 0c             	mov    %eax,0xc(%ecx)
   11404:	8d 43 08             	lea    0x8(%ebx),%eax
   11407:	6a 00                	push   $0x0
   11409:	6a 00                	push   $0x0
   1140b:	6a 00                	push   $0x0
   1140d:	6a 06                	push   $0x6
   1140f:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   11412:	50                   	push   %eax
   11413:	e8 38 14 00 00       	call   12850 <_KeWaitForSingleObject@20>

   /*
    * First search for existing Pipe with the same name.
    */
   Pipe = NpfsFindPipe(DeviceExt,
   11418:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   1141b:	83 c4 0c             	add    $0xc,%esp
   1141e:	83 c2 30             	add    $0x30,%edx
   11421:	89 d8                	mov    %ebx,%eax
   11423:	e8 d8 fb ff ff       	call   11000 <___crt_xc_end__>
   11428:	89 c7                	mov    %eax,%edi
		       &FileObject->FileName);
   if (Pipe != NULL)
   1142a:	85 c0                	test   %eax,%eax
   1142c:	0f 84 50 01 00 00    	je     11582 <_NpfsCreateNamedPipe@8+0x1d2>
     {
       /*
        * Found Pipe with the same name. Check if we are 
        * allowed to use it.
        */
       KeUnlockMutex(&DeviceExt->PipeListLock);
   11432:	50                   	push   %eax
   11433:	50                   	push   %eax
   11434:	6a 00                	push   $0x0
   11436:	8b 5d e0             	mov    0xffffffe0(%ebp),%ebx
   11439:	53                   	push   %ebx
   1143a:	e8 21 14 00 00       	call   12860 <_KeReleaseMutex@8>

       if (Pipe->CurrentInstances >= Pipe->MaximumInstances)
   1143f:	8b 47 5c             	mov    0x5c(%edi),%eax
   11442:	5a                   	pop    %edx
   11443:	39 47 60             	cmp    %eax,0x60(%edi)
   11446:	59                   	pop    %ecx
   11447:	0f 83 f6 02 00 00    	jae    11743 <_NpfsCreateNamedPipe@8+0x393>
         {
           DPRINT("Out of instances.\n");
           ExFreePool(Fcb);
           Irp->IoStatus.Status = STATUS_PIPE_BUSY;
           IoCompleteRequest(Irp, IO_NO_INCREMENT);
           return STATUS_PIPE_BUSY;
         }

       /* FIXME: Check pipe modes also! */
       if (Pipe->MaximumInstances != Buffer->MaximumInstances ||
   1144d:	3b 46 0c             	cmp    0xc(%esi),%eax
   11450:	0f 85 fa 00 00 00    	jne    11550 <_NpfsCreateNamedPipe@8+0x1a0>
   11456:	8b 5f 74             	mov    0x74(%edi),%ebx
   11459:	8b 46 18             	mov    0x18(%esi),%eax
   1145c:	8b 56 1c             	mov    0x1c(%esi),%edx
   1145f:	8b 4f 70             	mov    0x70(%edi),%ecx
   11462:	89 de                	mov    %ebx,%esi
   11464:	31 c8                	xor    %ecx,%eax
   11466:	31 d6                	xor    %edx,%esi
   11468:	09 c6                	or     %eax,%esi
   1146a:	0f 85 e0 00 00 00    	jne    11550 <_NpfsCreateNamedPipe@8+0x1a0>
           Pipe->TimeOut.QuadPart != Buffer->DefaultTimeout.QuadPart)
         {
           DPRINT("Asked for invalid pipe mode.\n");
           ExFreePool(Fcb);
           Irp->IoStatus.Status = STATUS_ACCESS_DENIED;
           IoCompleteRequest(Irp, IO_NO_INCREMENT);
           return STATUS_ACCESS_DENIED;
         }
     }
   else
     {
       NewPipe = TRUE;
       Pipe = ExAllocatePool(NonPagedPool, sizeof(NPFS_PIPE));
       if (Pipe == NULL)
         {
           KeUnlockMutex(&DeviceExt->PipeListLock);
           Irp->IoStatus.Status = STATUS_NO_MEMORY;
           Irp->IoStatus.Information = 0;
           IoCompleteRequest(Irp, IO_NO_INCREMENT);
           return STATUS_NO_MEMORY;
         }

       if (RtlCreateUnicodeString(&Pipe->PipeName, FileObject->FileName.Buffer) == FALSE)
         {
           KeUnlockMutex(&DeviceExt->PipeListLock);
           ExFreePool(Pipe);
           ExFreePool(Fcb);
           Irp->IoStatus.Status = STATUS_NO_MEMORY;
           Irp->IoStatus.Information = 0;
           IoCompleteRequest(Irp, IO_NO_INCREMENT);
           return STATUS_NO_MEMORY;
         }

       InitializeListHead(&Pipe->ServerFcbListHead);
       InitializeListHead(&Pipe->ClientFcbListHead);
       InitializeListHead(&Pipe->WaiterListHead);
       KeInitializeMutex(&Pipe->FcbListLock, 0);

       Pipe->PipeType = Buffer->NamedPipeType;
       Pipe->WriteMode = Buffer->ReadMode;
       Pipe->ReadMode = Buffer->ReadMode;
       Pipe->CompletionMode = Buffer->CompletionMode;
       Pipe->PipeConfiguration = IoStack->Parameters.CreatePipe.Options & 0x3;
       Pipe->MaximumInstances = Buffer->MaximumInstances;
       Pipe->CurrentInstances = 0;
       Pipe->TimeOut = Buffer->DefaultTimeout;
       if (!(IoStack->Parameters.Create.Options & FILE_PIPE_OUTBOUND) || 
           IoStack->Parameters.Create.Options & FILE_PIPE_FULL_DUPLEX)
         {
           if (Buffer->InboundQuota == 0)
             {
               Pipe->InboundQuota = DeviceExt->DefaultQuota;
             }
           else
             {
               Pipe->InboundQuota = PAGE_ROUND_UP(Buffer->InboundQuota);
               if (Pipe->InboundQuota < DeviceExt->MinQuota)
                 {
                   Pipe->InboundQuota = DeviceExt->MinQuota;
                 }
               else if (Pipe->InboundQuota > DeviceExt->MaxQuota)
                 {
                   Pipe->InboundQuota = DeviceExt->MaxQuota;
                 }
             }
         }
       else
         {
           Pipe->InboundQuota = 0;
         }

       if (IoStack->Parameters.Create.Options & (FILE_PIPE_FULL_DUPLEX|FILE_PIPE_OUTBOUND))
         {
           if (Buffer->OutboundQuota == 0)
             {
               Pipe->OutboundQuota = DeviceExt->DefaultQuota;
             }
           else
             {
               Pipe->OutboundQuota = PAGE_ROUND_UP(Buffer->OutboundQuota);
               if (Pipe->OutboundQuota < DeviceExt->MinQuota)
                 {
                   Pipe->OutboundQuota = DeviceExt->MinQuota;
                 }
               else if (Pipe->OutboundQuota > DeviceExt->MaxQuota)
                 {
                   Pipe->OutboundQuota = DeviceExt->MaxQuota;
                 }
             }
         }
       else
         {
           Pipe->OutboundQuota = 0;
         }

       InsertTailList(&DeviceExt->PipeListHead, &Pipe->PipeListEntry);
       KeUnlockMutex(&DeviceExt->PipeListLock);
     }

   if (Pipe->InboundQuota)
   11470:	8b 47 64             	mov    0x64(%edi),%eax
   11473:	85 c0                	test   %eax,%eax
   11475:	0f 85 06 02 00 00    	jne    11681 <_NpfsCreateNamedPipe@8+0x2d1>
     {
       Fcb->Data = ExAllocatePool(NonPagedPool, Pipe->InboundQuota);
       if (Fcb->Data == NULL)
         {
           ExFreePool(Fcb);

           if (NewPipe)
             {
               RtlFreeUnicodeString(&Pipe->PipeName);
               ExFreePool(Pipe);
             }

           Irp->IoStatus.Status = STATUS_NO_MEMORY;
           IoCompleteRequest(Irp, IO_NO_INCREMENT);
           return STATUS_NO_MEMORY;
         }
     }
   else
     {
       Fcb->Data = NULL;
   1147b:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   1147e:	c7 40 44 00 00 00 00 	movl   $0x0,0x44(%eax)
     }

   Fcb->ReadPtr = Fcb->Data;
   11485:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   Fcb->WritePtr = Fcb->Data;
   Fcb->ReadDataAvailable = 0;
   Fcb->WriteQuotaAvailable = Pipe->InboundQuota;
   Fcb->MaxDataLength = Pipe->InboundQuota;
   KeInitializeSpinLock(&Fcb->DataListLock);
   11488:	83 ec 0c             	sub    $0xc,%esp

   Pipe->CurrentInstances++;

   KeLockMutex(&Pipe->FcbListLock);
   1148b:	8d 5f 10             	lea    0x10(%edi),%ebx
   1148e:	8b 42 44             	mov    0x44(%edx),%eax
   11491:	c7 42 3c 00 00 00 00 	movl   $0x0,0x3c(%edx)
   11498:	89 42 48             	mov    %eax,0x48(%edx)
   1149b:	89 42 4c             	mov    %eax,0x4c(%edx)
   1149e:	8b 47 64             	mov    0x64(%edi),%eax
   114a1:	89 42 40             	mov    %eax,0x40(%edx)
   114a4:	8b 47 64             	mov    0x64(%edi),%eax
   114a7:	89 42 50             	mov    %eax,0x50(%edx)
   114aa:	89 d0                	mov    %edx,%eax
   114ac:	83 c0 54             	add    $0x54,%eax
   114af:	50                   	push   %eax
   114b0:	e8 cb 13 00 00       	call   12880 <_KeInitializeSpinLock@4>
   114b5:	8b 4f 60             	mov    0x60(%edi),%ecx
   114b8:	41                   	inc    %ecx
   114b9:	89 4f 60             	mov    %ecx,0x60(%edi)
   114bc:	6a 00                	push   $0x0
   114be:	6a 00                	push   $0x0
   114c0:	6a 00                	push   $0x0
   114c2:	6a 06                	push   $0x6
   114c4:	53                   	push   %ebx
   114c5:	e8 86 13 00 00       	call   12850 <_KeWaitForSingleObject@20>
static __inline VOID
InsertTailList(
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
   114ca:	8d 47 30             	lea    0x30(%edi),%eax
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
	Entry->Flink = ListHead;
   114cd:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   114d0:	8b 50 04             	mov    0x4(%eax),%edx
	Entry->Blink = OldBlink;
   114d3:	89 51 04             	mov    %edx,0x4(%ecx)
   114d6:	89 01                	mov    %eax,(%ecx)
	OldBlink->Flink = Entry;
	ListHead->Blink = Entry;
   114d8:	89 48 04             	mov    %ecx,0x4(%eax)
   114db:	89 0a                	mov    %ecx,(%edx)
   InsertTailList(&Pipe->ServerFcbListHead, &Fcb->FcbListEntry);
   KeUnlockMutex(&Pipe->FcbListLock);
   114dd:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   114e4:	53                   	push   %ebx
   114e5:	e8 76 13 00 00       	call   12860 <_KeReleaseMutex@8>

   Fcb->Pipe = Pipe;
   114ea:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   114ed:	89 78 10             	mov    %edi,0x10(%eax)
   Fcb->PipeEnd = FILE_PIPE_SERVER_END;
   114f0:	c7 40 34 01 00 00 00 	movl   $0x1,0x34(%eax)
   Fcb->PipeState = FILE_PIPE_LISTENING_STATE;
   114f7:	c7 40 38 02 00 00 00 	movl   $0x2,0x38(%eax)
   Fcb->OtherSide = NULL;
   114fe:	c7 40 08 00 00 00 00 	movl   $0x0,0x8(%eax)

   KeInitializeEvent(&Fcb->ConnectEvent,
   11505:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1150c:	83 c0 14             	add    $0x14,%eax
   1150f:	6a 01                	push   $0x1
   11511:	50                   	push   %eax
   11512:	e8 79 13 00 00       	call   12890 <_KeInitializeEvent@12>
		     SynchronizationEvent,
		     FALSE);

   KeInitializeEvent(&Fcb->Event,
   11517:	6a 00                	push   $0x0
   11519:	6a 01                	push   $0x1
   1151b:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   1151e:	83 c0 24             	add    $0x24,%eax
   11521:	50                   	push   %eax
   11522:	e8 69 13 00 00       	call   12890 <_KeInitializeEvent@12>
		     SynchronizationEvent,
		     FALSE);

   FileObject->FsContext = Fcb;
   11527:	8b 55 ec             	mov    0xffffffec(%ebp),%edx

   Irp->IoStatus.Status = STATUS_SUCCESS;
   1152a:	8b 45 0c             	mov    0xc(%ebp),%eax
   1152d:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   11530:	89 4a 0c             	mov    %ecx,0xc(%edx)
   11533:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
   IoCompleteRequest(Irp, IO_NO_INCREMENT);
   1153a:	52                   	push   %edx
   1153b:	6a 00                	push   $0x0
   1153d:	50                   	push   %eax
   1153e:	e8 5d 13 00 00       	call   128a0 <_IoCompleteRequest@8>

   DPRINT("Success!\n");

   return STATUS_SUCCESS;
   11543:	31 c0                	xor    %eax,%eax
}
   11545:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11548:	5b                   	pop    %ebx
   11549:	5e                   	pop    %esi
   1154a:	5f                   	pop    %edi
   1154b:	5d                   	pop    %ebp
   1154c:	c2 08 00             	ret    $0x8
   1154f:	90                   	nop    
   11550:	83 ec 0c             	sub    $0xc,%esp
   11553:	8b 5d e8             	mov    0xffffffe8(%ebp),%ebx
   11556:	53                   	push   %ebx
   11557:	e8 54 13 00 00       	call   128b0 <_ExFreePool@4>
   1155c:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   1155f:	c7 41 18 22 00 00 c0 	movl   $0xc0000022,0x18(%ecx)
   11566:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1156d:	51                   	push   %ecx
   1156e:	e8 2d 13 00 00       	call   128a0 <_IoCompleteRequest@8>
   11573:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11576:	b8 22 00 00 c0       	mov    $0xc0000022,%eax
   1157b:	5b                   	pop    %ebx
   1157c:	5e                   	pop    %esi
   1157d:	5f                   	pop    %edi
   1157e:	5d                   	pop    %ebp
   1157f:	c2 08 00             	ret    $0x8
   11582:	c6 45 e7 01          	movb   $0x1,0xffffffe7(%ebp)
   11586:	51                   	push   %ecx
   11587:	51                   	push   %ecx
   11588:	6a 78                	push   $0x78
   1158a:	6a 00                	push   $0x0
   1158c:	e8 df 12 00 00       	call   12870 <_ExAllocatePool@8>
   11591:	89 c7                	mov    %eax,%edi
   11593:	58                   	pop    %eax
   11594:	85 ff                	test   %edi,%edi
   11596:	5a                   	pop    %edx
   11597:	0f 84 23 02 00 00    	je     117c0 <_NpfsCreateNamedPipe@8+0x410>
   1159d:	50                   	push   %eax
   1159e:	50                   	push   %eax
   1159f:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   115a2:	8b 42 34             	mov    0x34(%edx),%eax
   115a5:	50                   	push   %eax
   115a6:	57                   	push   %edi
   115a7:	e8 24 13 00 00       	call   128d0 <_RtlCreateUnicodeString@8>
   115ac:	5a                   	pop    %edx
   115ad:	84 c0                	test   %al,%al
   115af:	59                   	pop    %ecx
   115b0:	0f 84 d3 01 00 00    	je     11789 <_NpfsCreateNamedPipe@8+0x3d9>
 */
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
   115b6:	8d 47 30             	lea    0x30(%edi),%eax
	ListHead->Flink = ListHead->Blink = ListHead;
   115b9:	89 47 30             	mov    %eax,0x30(%edi)
   115bc:	89 40 04             	mov    %eax,0x4(%eax)
   115bf:	8d 47 38             	lea    0x38(%edi),%eax
   115c2:	89 47 38             	mov    %eax,0x38(%edi)
   115c5:	89 40 04             	mov    %eax,0x4(%eax)
   115c8:	8d 47 40             	lea    0x40(%edi),%eax
   115cb:	89 47 40             	mov    %eax,0x40(%edi)
   115ce:	89 40 04             	mov    %eax,0x4(%eax)
   115d1:	50                   	push   %eax
   115d2:	50                   	push   %eax
   115d3:	8d 47 10             	lea    0x10(%edi),%eax
   115d6:	6a 00                	push   $0x0
   115d8:	50                   	push   %eax
   115d9:	e8 02 13 00 00       	call   128e0 <_KeInitializeMutex@8>
   115de:	8b 06                	mov    (%esi),%eax
   115e0:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
   115e3:	89 47 48             	mov    %eax,0x48(%edi)
   115e6:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   115e9:	8b 46 04             	mov    0x4(%esi),%eax
   115ec:	89 47 50             	mov    %eax,0x50(%edi)
   115ef:	8b 46 04             	mov    0x4(%esi),%eax
   115f2:	89 47 4c             	mov    %eax,0x4c(%edi)
   115f5:	8b 46 08             	mov    0x8(%esi),%eax
   115f8:	89 47 54             	mov    %eax,0x54(%edi)
   115fb:	8b 42 08             	mov    0x8(%edx),%eax
   115fe:	83 e0 03             	and    $0x3,%eax
   11601:	89 47 58             	mov    %eax,0x58(%edi)
   11604:	8b 46 0c             	mov    0xc(%esi),%eax
   11607:	c7 47 60 00 00 00 00 	movl   $0x0,0x60(%edi)
   1160e:	89 47 5c             	mov    %eax,0x5c(%edi)
   11611:	8b 46 18             	mov    0x18(%esi),%eax
   11614:	8b 56 1c             	mov    0x1c(%esi),%edx
   11617:	89 57 74             	mov    %edx,0x74(%edi)
   1161a:	89 47 70             	mov    %eax,0x70(%edi)
   1161d:	8b 41 08             	mov    0x8(%ecx),%eax
   11620:	5a                   	pop    %edx
   11621:	a8 01                	test   $0x1,%al
   11623:	59                   	pop    %ecx
   11624:	74 08                	je     1162e <_NpfsCreateNamedPipe@8+0x27e>
   11626:	a8 02                	test   $0x2,%al
   11628:	0f 84 fc 00 00 00    	je     1172a <_NpfsCreateNamedPipe@8+0x37a>
   1162e:	8b 46 10             	mov    0x10(%esi),%eax
   11631:	85 c0                	test   %eax,%eax
   11633:	0f 85 c2 00 00 00    	jne    116fb <_NpfsCreateNamedPipe@8+0x34b>
   11639:	8b 43 2c             	mov    0x2c(%ebx),%eax
   1163c:	89 47 64             	mov    %eax,0x64(%edi)
   1163f:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11642:	f6 40 08 03          	testb  $0x3,0x8(%eax)
   11646:	0f 84 83 00 00 00    	je     116cf <_NpfsCreateNamedPipe@8+0x31f>
   1164c:	8b 46 14             	mov    0x14(%esi),%eax
   1164f:	85 c0                	test   %eax,%eax
   11651:	0f 84 cb 00 00 00    	je     11722 <_NpfsCreateNamedPipe@8+0x372>
   11657:	89 c2                	mov    %eax,%edx
   11659:	a9 ff 0f 00 00       	test   $0xfff,%eax
   1165e:	74 0b                	je     1166b <_NpfsCreateNamedPipe@8+0x2bb>
   11660:	25 00 f0 ff ff       	and    $0xfffff000,%eax
   11665:	8d 90 00 10 00 00    	lea    0x1000(%eax),%edx
   1166b:	89 57 68             	mov    %edx,0x68(%edi)
   1166e:	8b 43 28             	mov    0x28(%ebx),%eax
   11671:	39 c2                	cmp    %eax,%edx
   11673:	72 07                	jb     1167c <_NpfsCreateNamedPipe@8+0x2cc>
   11675:	8b 43 30             	mov    0x30(%ebx),%eax
   11678:	39 c2                	cmp    %eax,%edx
   1167a:	76 5a                	jbe    116d6 <_NpfsCreateNamedPipe@8+0x326>
   1167c:	89 47 68             	mov    %eax,0x68(%edi)
   1167f:	eb 55                	jmp    116d6 <_NpfsCreateNamedPipe@8+0x326>
   11681:	53                   	push   %ebx
   11682:	53                   	push   %ebx
   11683:	50                   	push   %eax
   11684:	6a 00                	push   $0x0
   11686:	e8 e5 11 00 00       	call   12870 <_ExAllocatePool@8>
   1168b:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   1168e:	85 c0                	test   %eax,%eax
   11690:	89 42 44             	mov    %eax,0x44(%edx)
   11693:	5e                   	pop    %esi
   11694:	59                   	pop    %ecx
   11695:	0f 85 ea fd ff ff    	jne    11485 <_NpfsCreateNamedPipe@8+0xd5>
   1169b:	83 ec 0c             	sub    $0xc,%esp
   1169e:	52                   	push   %edx
   1169f:	e8 0c 12 00 00       	call   128b0 <_ExFreePool@4>
   116a4:	83 c4 0c             	add    $0xc,%esp
   116a7:	80 7d e7 00          	cmpb   $0x0,0xffffffe7(%ebp)
   116ab:	0f 85 3f 01 00 00    	jne    117f0 <_NpfsCreateNamedPipe@8+0x440>
   116b1:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   116b4:	c7 41 18 17 00 00 c0 	movl   $0xc0000017,0x18(%ecx)
   116bb:	53                   	push   %ebx
   116bc:	53                   	push   %ebx
   116bd:	6a 00                	push   $0x0
   116bf:	51                   	push   %ecx
   116c0:	e8 db 11 00 00       	call   128a0 <_IoCompleteRequest@8>
   116c5:	b8 17 00 00 c0       	mov    $0xc0000017,%eax
   116ca:	e9 76 fe ff ff       	jmp    11545 <_NpfsCreateNamedPipe@8+0x195>
   116cf:	c7 47 68 00 00 00 00 	movl   $0x0,0x68(%edi)
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
   116d6:	8b 53 04             	mov    0x4(%ebx),%edx
   116d9:	8d 47 08             	lea    0x8(%edi),%eax
	Entry->Flink = ListHead;
   116dc:	89 5f 08             	mov    %ebx,0x8(%edi)
	Entry->Blink = OldBlink;
   116df:	89 50 04             	mov    %edx,0x4(%eax)
	OldBlink->Flink = Entry;
   116e2:	89 02                	mov    %eax,(%edx)
	ListHead->Blink = Entry;
   116e4:	89 43 04             	mov    %eax,0x4(%ebx)
   116e7:	50                   	push   %eax
   116e8:	50                   	push   %eax
   116e9:	6a 00                	push   $0x0
   116eb:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   116ee:	50                   	push   %eax
   116ef:	e8 6c 11 00 00       	call   12860 <_KeReleaseMutex@8>
   116f4:	5e                   	pop    %esi
   116f5:	58                   	pop    %eax
   116f6:	e9 75 fd ff ff       	jmp    11470 <_NpfsCreateNamedPipe@8+0xc0>
   116fb:	89 c2                	mov    %eax,%edx
   116fd:	a9 ff 0f 00 00       	test   $0xfff,%eax
   11702:	75 32                	jne    11736 <_NpfsCreateNamedPipe@8+0x386>
   11704:	89 57 64             	mov    %edx,0x64(%edi)
   11707:	8b 43 28             	mov    0x28(%ebx),%eax
   1170a:	39 c2                	cmp    %eax,%edx
   1170c:	0f 82 2a ff ff ff    	jb     1163c <_NpfsCreateNamedPipe@8+0x28c>
   11712:	8b 43 30             	mov    0x30(%ebx),%eax
   11715:	39 c2                	cmp    %eax,%edx
   11717:	0f 86 22 ff ff ff    	jbe    1163f <_NpfsCreateNamedPipe@8+0x28f>
   1171d:	e9 1a ff ff ff       	jmp    1163c <_NpfsCreateNamedPipe@8+0x28c>
   11722:	8b 43 2c             	mov    0x2c(%ebx),%eax
   11725:	89 47 68             	mov    %eax,0x68(%edi)
   11728:	eb ac                	jmp    116d6 <_NpfsCreateNamedPipe@8+0x326>
   1172a:	c7 47 64 00 00 00 00 	movl   $0x0,0x64(%edi)
   11731:	e9 09 ff ff ff       	jmp    1163f <_NpfsCreateNamedPipe@8+0x28f>
   11736:	25 00 f0 ff ff       	and    $0xfffff000,%eax
   1173b:	8d 90 00 10 00 00    	lea    0x1000(%eax),%edx
   11741:	eb c1                	jmp    11704 <_NpfsCreateNamedPipe@8+0x354>
   11743:	83 ec 0c             	sub    $0xc,%esp
   11746:	8b 75 e8             	mov    0xffffffe8(%ebp),%esi
   11749:	56                   	push   %esi
   1174a:	e8 61 11 00 00       	call   128b0 <_ExFreePool@4>
   1174f:	8b 55 0c             	mov    0xc(%ebp),%edx
   11752:	c7 42 18 ae 00 00 c0 	movl   $0xc00000ae,0x18(%edx)
   11759:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   11760:	52                   	push   %edx
   11761:	e8 3a 11 00 00       	call   128a0 <_IoCompleteRequest@8>
   11766:	b8 ae 00 00 c0       	mov    $0xc00000ae,%eax
   1176b:	e9 d5 fd ff ff       	jmp    11545 <_NpfsCreateNamedPipe@8+0x195>
   11770:	8b 45 0c             	mov    0xc(%ebp),%eax
   11773:	c7 40 18 17 00 00 c0 	movl   $0xc0000017,0x18(%eax)
   1177a:	52                   	push   %edx
   1177b:	52                   	push   %edx
   1177c:	6a 00                	push   $0x0
   1177e:	50                   	push   %eax
   1177f:	e8 1c 11 00 00       	call   128a0 <_IoCompleteRequest@8>
   11784:	e9 3c ff ff ff       	jmp    116c5 <_NpfsCreateNamedPipe@8+0x315>
   11789:	50                   	push   %eax
   1178a:	50                   	push   %eax
   1178b:	6a 00                	push   $0x0
   1178d:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   11790:	50                   	push   %eax
   11791:	e8 ca 10 00 00       	call   12860 <_KeReleaseMutex@8>
   11796:	50                   	push   %eax
   11797:	57                   	push   %edi
   11798:	e8 13 11 00 00       	call   128b0 <_ExFreePool@4>
   1179d:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   117a0:	50                   	push   %eax
   117a1:	e8 0a 11 00 00       	call   128b0 <_ExFreePool@4>
   117a6:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   117a9:	c7 41 18 17 00 00 c0 	movl   $0xc0000017,0x18(%ecx)
   117b0:	c7 41 1c 00 00 00 00 	movl   $0x0,0x1c(%ecx)
   117b7:	58                   	pop    %eax
   117b8:	6a 00                	push   $0x0
   117ba:	51                   	push   %ecx
   117bb:	e9 00 ff ff ff       	jmp    116c0 <_NpfsCreateNamedPipe@8+0x310>
   117c0:	50                   	push   %eax
   117c1:	50                   	push   %eax
   117c2:	6a 00                	push   $0x0
   117c4:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   117c7:	50                   	push   %eax
   117c8:	e8 93 10 00 00       	call   12860 <_KeReleaseMutex@8>
   117cd:	8b 45 0c             	mov    0xc(%ebp),%eax
   117d0:	c7 40 18 17 00 00 c0 	movl   $0xc0000017,0x18(%eax)
   117d7:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   117de:	6a 00                	push   $0x0
   117e0:	50                   	push   %eax
   117e1:	e8 ba 10 00 00       	call   128a0 <_IoCompleteRequest@8>
   117e6:	b8 17 00 00 c0       	mov    $0xc0000017,%eax
   117eb:	e9 55 fd ff ff       	jmp    11545 <_NpfsCreateNamedPipe@8+0x195>
   117f0:	83 ec 0c             	sub    $0xc,%esp
   117f3:	57                   	push   %edi
   117f4:	e8 f7 10 00 00       	call   128f0 <_RtlFreeUnicodeString@4>
   117f9:	57                   	push   %edi
   117fa:	e8 b1 10 00 00       	call   128b0 <_ExFreePool@4>
   117ff:	83 c4 0c             	add    $0xc,%esp
   11802:	e9 aa fe ff ff       	jmp    116b1 <_NpfsCreateNamedPipe@8+0x301>
   11807:	89 f6                	mov    %esi,%esi
   11809:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011810 <_NpfsClose@8>:


NTSTATUS STDCALL
NpfsClose(PDEVICE_OBJECT DeviceObject,
          PIRP Irp)
{
   11810:	55                   	push   %ebp
   11811:	89 e5                	mov    %esp,%ebp
   11813:	57                   	push   %edi
   11814:	56                   	push   %esi
   11815:	53                   	push   %ebx
   11816:	83 ec 0c             	sub    $0xc,%esp
   PNPFS_DEVICE_EXTENSION DeviceExt;
   PIO_STACK_LOCATION IoStack;
   PFILE_OBJECT FileObject;
   PNPFS_FCB Fcb;
   PNPFS_PIPE Pipe;
   BOOL Server;

   DPRINT("NpfsClose(DeviceObject %p Irp %p)\n", DeviceObject, Irp);

   IoStack = IoGetCurrentIrpStackLocation(Irp);
   11819:	8b 45 0c             	mov    0xc(%ebp),%eax
   1181c:	8b 50 60             	mov    0x60(%eax),%edx
   DeviceExt = (PNPFS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
   1181f:	8b 45 08             	mov    0x8(%ebp),%eax
   FileObject = IoStack->FileObject;
   11822:	8b 7a 18             	mov    0x18(%edx),%edi
   11825:	8b 40 28             	mov    0x28(%eax),%eax
   11828:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   Fcb = FileObject->FsContext;
   1182b:	8b 5f 0c             	mov    0xc(%edi),%ebx

   if (Fcb == NULL)
   1182e:	85 db                	test   %ebx,%ebx
   11830:	74 6c                	je     1189e <_NpfsClose@8+0x8e>
   {
      DPRINT("Success!\n");
      Irp->IoStatus.Status = STATUS_SUCCESS;
      Irp->IoStatus.Information = 0;
      IoCompleteRequest(Irp, IO_NO_INCREMENT);
      return STATUS_SUCCESS;
   }

   DPRINT("Fcb %x\n", Fcb);
   Pipe = Fcb->Pipe;
   11832:	8b 73 10             	mov    0x10(%ebx),%esi

   DPRINT("Closing pipe %wZ\n", &Pipe->PipeName);

   KeLockMutex(&Pipe->FcbListLock);
   11835:	83 ec 0c             	sub    $0xc,%esp
   11838:	8d 46 10             	lea    0x10(%esi),%eax
   1183b:	6a 00                	push   $0x0
   1183d:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   11840:	6a 00                	push   $0x0
   11842:	6a 00                	push   $0x0
   11844:	6a 06                	push   $0x6
   11846:	50                   	push   %eax
   11847:	e8 04 10 00 00       	call   12850 <_KeWaitForSingleObject@20>

   Server = (Fcb->PipeEnd == FILE_PIPE_SERVER_END);
   1184c:	83 c4 0c             	add    $0xc,%esp

   if (Server)
   1184f:	83 7b 34 01          	cmpl   $0x1,0x34(%ebx)
   11853:	74 70                	je     118c5 <_NpfsClose@8+0xb5>
   {
      /* FIXME: Clean up existing connections here ?? */
      DPRINT("Server\n");
      Pipe->CurrentInstances--;
   }
   else
   {
      DPRINT("Client\n");
   }

   if (Fcb->PipeState == FILE_PIPE_CONNECTED_STATE)
   11855:	83 7b 38 03          	cmpl   $0x3,0x38(%ebx)
   11859:	74 77                	je     118d2 <_NpfsClose@8+0xc2>
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
  OldBlink = Entry->Blink;
   1185b:	8b 43 04             	mov    0x4(%ebx),%eax
   1185e:	8b 13                	mov    (%ebx),%edx
   {
      if (Fcb->OtherSide)
      {
         Fcb->OtherSide->PipeState = FILE_PIPE_CLOSING_STATE;
         Fcb->OtherSide->OtherSide = NULL;
         /*
          * Signaling the write event. If is possible that an other
          * thread waits for an empty buffer.
          */
         KeSetEvent(&Fcb->OtherSide->Event, IO_NO_INCREMENT, FALSE);
      }

      Fcb->PipeState = 0;
   }

   FileObject->FsContext = NULL;
   11860:	c7 47 0c 00 00 00 00 	movl   $0x0,0xc(%edi)
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
  OldBlink = Entry->Blink;
  OldFlink->Blink = OldBlink;
   11867:	89 42 04             	mov    %eax,0x4(%edx)
  OldBlink->Flink = OldFlink;
   1186a:	89 10                	mov    %edx,(%eax)

   RemoveEntryList(&Fcb->FcbListEntry);
   if (Fcb->Data)
   1186c:	8b 43 44             	mov    0x44(%ebx),%eax
   1186f:	85 c0                	test   %eax,%eax
   11871:	0f 85 89 00 00 00    	jne    11900 <_NpfsClose@8+0xf0>
      ExFreePool(Fcb->Data);
   ExFreePool(Fcb);
   11877:	83 ec 0c             	sub    $0xc,%esp
   1187a:	53                   	push   %ebx
   1187b:	e8 30 10 00 00       	call   128b0 <_ExFreePool@4>

   KeUnlockMutex(&Pipe->FcbListLock);
   11880:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11883:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1188a:	50                   	push   %eax
   1188b:	e8 d0 0f 00 00       	call   12860 <_KeReleaseMutex@8>

   if (IsListEmpty(&Pipe->ServerFcbListHead) &&
   11890:	8d 46 30             	lea    0x30(%esi),%eax
   11893:	5b                   	pop    %ebx
   11894:	39 46 30             	cmp    %eax,0x30(%esi)
   11897:	5f                   	pop    %edi
   11898:	0f 84 95 00 00 00    	je     11933 <_NpfsClose@8+0x123>
       IsListEmpty(&Pipe->ClientFcbListHead))
   {
      RtlFreeUnicodeString(&Pipe->PipeName);
      KeLockMutex(&DeviceExt->PipeListLock);
      RemoveEntryList(&Pipe->PipeListEntry);
      KeUnlockMutex(&DeviceExt->PipeListLock);
      ExFreePool(Pipe);
   }

   Irp->IoStatus.Status = STATUS_SUCCESS;
   1189e:	8b 45 0c             	mov    0xc(%ebp),%eax
   118a1:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
   Irp->IoStatus.Information = 0;
   118a8:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   IoCompleteRequest(Irp, IO_NO_INCREMENT);
   118af:	52                   	push   %edx
   118b0:	52                   	push   %edx
   118b1:	6a 00                	push   $0x0
   118b3:	50                   	push   %eax
   118b4:	e8 e7 0f 00 00       	call   128a0 <_IoCompleteRequest@8>

   DPRINT("Success!\n");

   return STATUS_SUCCESS;
}
   118b9:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   118bc:	31 c0                	xor    %eax,%eax
   118be:	5b                   	pop    %ebx
   118bf:	5e                   	pop    %esi
   118c0:	5f                   	pop    %edi
   118c1:	5d                   	pop    %ebp
   118c2:	c2 08 00             	ret    $0x8
   118c5:	8b 46 60             	mov    0x60(%esi),%eax
   118c8:	48                   	dec    %eax
   118c9:	89 46 60             	mov    %eax,0x60(%esi)
   118cc:	83 7b 38 03          	cmpl   $0x3,0x38(%ebx)
   118d0:	75 89                	jne    1185b <_NpfsClose@8+0x4b>
   118d2:	8b 43 08             	mov    0x8(%ebx),%eax
   118d5:	85 c0                	test   %eax,%eax
   118d7:	0f 85 a6 00 00 00    	jne    11983 <_NpfsClose@8+0x173>
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
  OldBlink = Entry->Blink;
   118dd:	8b 43 04             	mov    0x4(%ebx),%eax
   118e0:	8b 13                	mov    (%ebx),%edx
   118e2:	c7 47 0c 00 00 00 00 	movl   $0x0,0xc(%edi)
   118e9:	c7 43 38 00 00 00 00 	movl   $0x0,0x38(%ebx)
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
  OldBlink = Entry->Blink;
  OldFlink->Blink = OldBlink;
   118f0:	89 42 04             	mov    %eax,0x4(%edx)
  OldBlink->Flink = OldFlink;
   118f3:	89 10                	mov    %edx,(%eax)
   118f5:	8b 43 44             	mov    0x44(%ebx),%eax
   118f8:	85 c0                	test   %eax,%eax
   118fa:	0f 84 77 ff ff ff    	je     11877 <_NpfsClose@8+0x67>
   11900:	83 ec 0c             	sub    $0xc,%esp
   11903:	50                   	push   %eax
   11904:	e8 a7 0f 00 00       	call   128b0 <_ExFreePool@4>
   11909:	83 c4 0c             	add    $0xc,%esp
   1190c:	83 ec 0c             	sub    $0xc,%esp
   1190f:	53                   	push   %ebx
   11910:	e8 9b 0f 00 00       	call   128b0 <_ExFreePool@4>
   11915:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11918:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1191f:	50                   	push   %eax
   11920:	e8 3b 0f 00 00       	call   12860 <_KeReleaseMutex@8>
   11925:	8d 46 30             	lea    0x30(%esi),%eax
   11928:	5b                   	pop    %ebx
   11929:	39 46 30             	cmp    %eax,0x30(%esi)
   1192c:	5f                   	pop    %edi
   1192d:	0f 85 6b ff ff ff    	jne    1189e <_NpfsClose@8+0x8e>
   11933:	8d 46 38             	lea    0x38(%esi),%eax
   11936:	39 46 38             	cmp    %eax,0x38(%esi)
   11939:	0f 85 5f ff ff ff    	jne    1189e <_NpfsClose@8+0x8e>
   1193f:	83 ec 0c             	sub    $0xc,%esp
   11942:	56                   	push   %esi
   11943:	e8 a8 0f 00 00       	call   128f0 <_RtlFreeUnicodeString@4>
   11948:	8b 5d f0             	mov    0xfffffff0(%ebp),%ebx
   1194b:	83 c3 08             	add    $0x8,%ebx
   1194e:	6a 00                	push   $0x0
   11950:	6a 00                	push   $0x0
   11952:	6a 00                	push   $0x0
   11954:	6a 06                	push   $0x6
   11956:	53                   	push   %ebx
   11957:	e8 f4 0e 00 00       	call   12850 <_KeWaitForSingleObject@20>
{
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
   1195c:	8b 56 08             	mov    0x8(%esi),%edx
  OldBlink = Entry->Blink;
   1195f:	8b 46 0c             	mov    0xc(%esi),%eax
  OldFlink->Blink = OldBlink;
   11962:	89 42 04             	mov    %eax,0x4(%edx)
  OldBlink->Flink = OldFlink;
   11965:	89 10                	mov    %edx,(%eax)
   11967:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   1196e:	53                   	push   %ebx
   1196f:	e8 ec 0e 00 00       	call   12860 <_KeReleaseMutex@8>
   11974:	51                   	push   %ecx
   11975:	56                   	push   %esi
   11976:	e8 35 0f 00 00       	call   128b0 <_ExFreePool@4>
   1197b:	83 c4 0c             	add    $0xc,%esp
   1197e:	e9 1b ff ff ff       	jmp    1189e <_NpfsClose@8+0x8e>
   11983:	c7 40 38 04 00 00 00 	movl   $0x4,0x38(%eax)
   1198a:	c7 40 08 00 00 00 00 	movl   $0x0,0x8(%eax)
   11991:	50                   	push   %eax
   11992:	6a 00                	push   $0x0
   11994:	6a 00                	push   $0x0
   11996:	8b 43 08             	mov    0x8(%ebx),%eax
   11999:	83 c0 24             	add    $0x24,%eax
   1199c:	50                   	push   %eax
   1199d:	e8 5e 0f 00 00       	call   12900 <_KeSetEvent@12>
   119a2:	58                   	pop    %eax
   119a3:	e9 35 ff ff ff       	jmp    118dd <_NpfsClose@8+0xcd>
   119a8:	90                   	nop    
   119a9:	90                   	nop    
   119aa:	90                   	nop    
   119ab:	90                   	nop    
   119ac:	90                   	nop    
   119ad:	90                   	nop    
   119ae:	90                   	nop    
   119af:	90                   	nop    

000119b0 <_NpfsQueryInformation@8>:
   119b0:	55                   	push   %ebp
   119b1:	89 e5                	mov    %esp,%ebp
   119b3:	57                   	push   %edi
   119b4:	56                   	push   %esi
   119b5:	53                   	push   %ebx
   119b6:	83 ec 0c             	sub    $0xc,%esp
   119b9:	8b 45 0c             	mov    0xc(%ebp),%eax
   119bc:	8b 40 60             	mov    0x60(%eax),%eax
   119bf:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   119c2:	89 c1                	mov    %eax,%ecx
   119c4:	8b 50 08             	mov    0x8(%eax),%edx
   119c7:	8b 40 18             	mov    0x18(%eax),%eax
   119ca:	83 fa 18             	cmp    $0x18,%edx
   119cd:	8b 78 0c             	mov    0xc(%eax),%edi
   119d0:	8b 45 0c             	mov    0xc(%ebp),%eax
   119d3:	8b 70 0c             	mov    0xc(%eax),%esi
   119d6:	8b 41 04             	mov    0x4(%ecx),%eax
   119d9:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
   119dc:	0f 84 91 00 00 00    	je     11a73 <_NpfsQueryInformation@8+0xc3>
   119e2:	77 3c                	ja     11a20 <_NpfsQueryInformation@8+0x70>
   119e4:	83 fa 17             	cmp    $0x17,%edx
   119e7:	74 6e                	je     11a57 <_NpfsQueryInformation@8+0xa7>
   119e9:	bb bb 00 00 c0       	mov    $0xc00000bb,%ebx
   119ee:	8b 55 0c             	mov    0xc(%ebp),%edx
   119f1:	85 db                	test   %ebx,%ebx
   119f3:	89 5a 18             	mov    %ebx,0x18(%edx)
   119f6:	78 3c                	js     11a34 <_NpfsQueryInformation@8+0x84>
   119f8:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   119fb:	8b 41 04             	mov    0x4(%ecx),%eax
   119fe:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
   11a01:	29 c8                	sub    %ecx,%eax
   11a03:	89 42 1c             	mov    %eax,0x1c(%edx)
   11a06:	52                   	push   %edx
   11a07:	52                   	push   %edx
   11a08:	6a 00                	push   $0x0
   11a0a:	8b 45 0c             	mov    0xc(%ebp),%eax
   11a0d:	50                   	push   %eax
   11a0e:	e8 8d 0e 00 00       	call   128a0 <_IoCompleteRequest@8>
   11a13:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11a16:	89 d8                	mov    %ebx,%eax
   11a18:	5b                   	pop    %ebx
   11a19:	5e                   	pop    %esi
   11a1a:	5f                   	pop    %edi
   11a1b:	5d                   	pop    %ebp
   11a1c:	c2 08 00             	ret    $0x8
   11a1f:	90                   	nop    
   11a20:	bb 02 00 00 c0       	mov    $0xc0000002,%ebx
   11a25:	83 fa 19             	cmp    $0x19,%edx
   11a28:	75 bf                	jne    119e9 <_NpfsQueryInformation@8+0x39>
   11a2a:	8b 55 0c             	mov    0xc(%ebp),%edx
   11a2d:	85 db                	test   %ebx,%ebx
   11a2f:	89 5a 18             	mov    %ebx,0x18(%edx)
   11a32:	79 c4                	jns    119f8 <_NpfsQueryInformation@8+0x48>
   11a34:	8b 45 0c             	mov    0xc(%ebp),%eax
   11a37:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   11a3e:	52                   	push   %edx
   11a3f:	52                   	push   %edx
   11a40:	6a 00                	push   $0x0
   11a42:	8b 45 0c             	mov    0xc(%ebp),%eax
   11a45:	50                   	push   %eax
   11a46:	e8 55 0e 00 00       	call   128a0 <_IoCompleteRequest@8>
   11a4b:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11a4e:	89 d8                	mov    %ebx,%eax
   11a50:	5b                   	pop    %ebx
   11a51:	5e                   	pop    %esi
   11a52:	5f                   	pop    %edi
   11a53:	5d                   	pop    %ebp
   11a54:	c2 08 00             	ret    $0x8
   11a57:	50                   	push   %eax
   11a58:	50                   	push   %eax
   11a59:	6a 08                	push   $0x8
   11a5b:	56                   	push   %esi
   11a5c:	e8 af 0e 00 00       	call   12910 <_RtlZeroMemory@8>
   11a61:	8b 5d f0             	mov    0xfffffff0(%ebp),%ebx
   11a64:	5e                   	pop    %esi
   11a65:	83 eb 08             	sub    $0x8,%ebx
   11a68:	5f                   	pop    %edi
   11a69:	89 5d f0             	mov    %ebx,0xfffffff0(%ebp)
   11a6c:	31 db                	xor    %ebx,%ebx
   11a6e:	e9 7b ff ff ff       	jmp    119ee <_NpfsQueryInformation@8+0x3e>
   11a73:	8b 5f 10             	mov    0x10(%edi),%ebx
   11a76:	51                   	push   %ecx
   11a77:	51                   	push   %ecx
   11a78:	6a 28                	push   $0x28
   11a7a:	56                   	push   %esi
   11a7b:	e8 90 0e 00 00       	call   12910 <_RtlZeroMemory@8>
   11a80:	58                   	pop    %eax
   11a81:	8b 43 48             	mov    0x48(%ebx),%eax
   11a84:	5a                   	pop    %edx
   11a85:	89 06                	mov    %eax,(%esi)
   11a87:	8b 43 58             	mov    0x58(%ebx),%eax
   11a8a:	89 46 04             	mov    %eax,0x4(%esi)
   11a8d:	8b 43 5c             	mov    0x5c(%ebx),%eax
   11a90:	89 46 08             	mov    %eax,0x8(%esi)
   11a93:	8b 43 60             	mov    0x60(%ebx),%eax
   11a96:	89 46 0c             	mov    %eax,0xc(%esi)
   11a99:	8b 43 64             	mov    0x64(%ebx),%eax
   11a9c:	89 46 10             	mov    %eax,0x10(%esi)
   11a9f:	8b 43 68             	mov    0x68(%ebx),%eax
   11aa2:	89 46 18             	mov    %eax,0x18(%esi)
   11aa5:	8b 47 38             	mov    0x38(%edi),%eax
   11aa8:	89 46 20             	mov    %eax,0x20(%esi)
   11aab:	8b 47 34             	mov    0x34(%edi),%eax
   11aae:	89 46 24             	mov    %eax,0x24(%esi)
   11ab1:	83 7f 34 01          	cmpl   $0x1,0x34(%edi)
   11ab5:	74 23                	je     11ada <_NpfsQueryInformation@8+0x12a>
   11ab7:	8b 57 08             	mov    0x8(%edi),%edx
   11aba:	85 d2                	test   %edx,%edx
   11abc:	74 0c                	je     11aca <_NpfsQueryInformation@8+0x11a>
   11abe:	8b 42 3c             	mov    0x3c(%edx),%eax
   11ac1:	89 46 14             	mov    %eax,0x14(%esi)
   11ac4:	8b 42 40             	mov    0x40(%edx),%eax
   11ac7:	89 46 1c             	mov    %eax,0x1c(%esi)
   11aca:	8b 5d f0             	mov    0xfffffff0(%ebp),%ebx
   11acd:	83 eb 28             	sub    $0x28,%ebx
   11ad0:	89 5d f0             	mov    %ebx,0xfffffff0(%ebp)
   11ad3:	31 db                	xor    %ebx,%ebx
   11ad5:	e9 14 ff ff ff       	jmp    119ee <_NpfsQueryInformation@8+0x3e>
   11ada:	8b 47 3c             	mov    0x3c(%edi),%eax
   11add:	89 46 14             	mov    %eax,0x14(%esi)
   11ae0:	8b 47 40             	mov    0x40(%edi),%eax
   11ae3:	eb e2                	jmp    11ac7 <_NpfsQueryInformation@8+0x117>
   11ae5:	8d 74 26 00          	lea    0x0(%esi),%esi
   11ae9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

00011af0 <_NpfsSetInformation@8>:
   11af0:	55                   	push   %ebp
   11af1:	89 e5                	mov    %esp,%ebp
   11af3:	53                   	push   %ebx
   11af4:	50                   	push   %eax
   11af5:	bb 02 00 00 c0       	mov    $0xc0000002,%ebx
   11afa:	8b 55 0c             	mov    0xc(%ebp),%edx
   11afd:	8b 42 60             	mov    0x60(%edx),%eax
   11b00:	8b 40 08             	mov    0x8(%eax),%eax
   11b03:	83 f8 18             	cmp    $0x18,%eax
   11b06:	74 11                	je     11b19 <_NpfsSetInformation@8+0x29>
   11b08:	76 2c                	jbe    11b36 <_NpfsSetInformation@8+0x46>
   11b0a:	bb 02 00 00 c0       	mov    $0xc0000002,%ebx
   11b0f:	83 f8 19             	cmp    $0x19,%eax
   11b12:	74 05                	je     11b19 <_NpfsSetInformation@8+0x29>
   11b14:	bb bb 00 00 c0       	mov    $0xc00000bb,%ebx
   11b19:	89 5a 18             	mov    %ebx,0x18(%edx)
   11b1c:	c7 42 1c 00 00 00 00 	movl   $0x0,0x1c(%edx)
   11b23:	50                   	push   %eax
   11b24:	50                   	push   %eax
   11b25:	6a 00                	push   $0x0
   11b27:	52                   	push   %edx
   11b28:	e8 73 0d 00 00       	call   128a0 <_IoCompleteRequest@8>
   11b2d:	89 d8                	mov    %ebx,%eax
   11b2f:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
   11b32:	c9                   	leave  
   11b33:	c2 08 00             	ret    $0x8
   11b36:	83 f8 17             	cmp    $0x17,%eax
   11b39:	eb d7                	jmp    11b12 <_NpfsSetInformation@8+0x22>
   11b3b:	90                   	nop    
   11b3c:	90                   	nop    
   11b3d:	90                   	nop    
   11b3e:	90                   	nop    
   11b3f:	90                   	nop    

00011b40 <_NpfsListeningCancelRoutine>:
   11b40:	55                   	push   %ebp
   11b41:	89 e5                	mov    %esp,%ebp
   11b43:	56                   	push   %esi
   11b44:	53                   	push   %ebx
   11b45:	52                   	push   %edx
   11b46:	8b 75 0c             	mov    0xc(%ebp),%esi
   11b49:	6a 1b                	push   $0x1b
   11b4b:	68 00 30 01 00       	push   $0x13000
   11b50:	68 09 30 01 00       	push   $0x13009
   11b55:	e8 e6 0d 00 00       	call   12940 <_DbgPrint>
   11b5a:	c7 04 24 14 30 01 00 	movl   $0x13014,(%esp)
   11b61:	e8 da 0d 00 00       	call   12940 <_DbgPrint>
   11b66:	31 c0                	xor    %eax,%eax
   11b68:	8a 46 25             	mov    0x25(%esi),%al
   11b6b:	89 04 24             	mov    %eax,(%esp)
   11b6e:	e8 ad 0d 00 00       	call   12920 <_IoReleaseCancelSpinLock@4>
   11b73:	8b 5e 40             	mov    0x40(%esi),%ebx
   11b76:	6a 00                	push   $0x0
   11b78:	6a 00                	push   $0x0
   11b7a:	6a 00                	push   $0x0
   11b7c:	6a 06                	push   $0x6
   11b7e:	8b 43 0c             	mov    0xc(%ebx),%eax
   11b81:	83 c0 10             	add    $0x10,%eax
   11b84:	50                   	push   %eax
   11b85:	e8 c6 0c 00 00       	call   12850 <_KeWaitForSingleObject@20>
{
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
   11b8a:	8b 13                	mov    (%ebx),%edx
  OldBlink = Entry->Blink;
   11b8c:	8b 43 04             	mov    0x4(%ebx),%eax
  OldFlink->Blink = OldBlink;
   11b8f:	89 42 04             	mov    %eax,0x4(%edx)
  OldBlink->Flink = OldFlink;
   11b92:	89 10                	mov    %edx,(%eax)
   11b94:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
   11b9b:	8b 43 0c             	mov    0xc(%ebx),%eax
   11b9e:	83 c0 10             	add    $0x10,%eax
   11ba1:	50                   	push   %eax
   11ba2:	e8 b9 0c 00 00       	call   12860 <_KeReleaseMutex@8>
   11ba7:	c7 46 18 20 01 00 c0 	movl   $0xc0000120,0x18(%esi)
   11bae:	c7 46 1c 00 00 00 00 	movl   $0x0,0x1c(%esi)
   11bb5:	6a 00                	push   $0x0
   11bb7:	56                   	push   %esi
   11bb8:	e8 e3 0c 00 00       	call   128a0 <_IoCompleteRequest@8>
   11bbd:	50                   	push   %eax
   11bbe:	53                   	push   %ebx
   11bbf:	e8 ec 0c 00 00       	call   128b0 <_ExFreePool@4>
   11bc4:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   11bc7:	5b                   	pop    %ebx
   11bc8:	5e                   	pop    %esi
   11bc9:	5d                   	pop    %ebp
   11bca:	c3                   	ret    
   11bcb:	90                   	nop    
   11bcc:	8d 74 26 00          	lea    0x0(%esi),%esi

00011bd0 <_NpfsFileSystemControl@8>:
   11bd0:	55                   	push   %ebp
   11bd1:	89 e5                	mov    %esp,%ebp
   11bd3:	57                   	push   %edi
   11bd4:	56                   	push   %esi
   11bd5:	53                   	push   %ebx
   11bd6:	83 ec 0c             	sub    $0xc,%esp
   11bd9:	8b 75 0c             	mov    0xc(%ebp),%esi
   11bdc:	8b 56 60             	mov    0x60(%esi),%edx
   11bdf:	8b 42 18             	mov    0x18(%edx),%eax
   11be2:	8b 78 0c             	mov    0xc(%eax),%edi
   11be5:	8b 42 0c             	mov    0xc(%edx),%eax
   11be8:	3d 24 00 11 00       	cmp    $0x110024,%eax
   11bed:	0f 84 64 01 00 00    	je     11d57 <_NpfsFileSystemControl@8+0x187>
   11bf3:	0f 87 2a 01 00 00    	ja     11d23 <_NpfsFileSystemControl@8+0x153>
   11bf9:	3d 10 00 11 00       	cmp    $0x110010,%eax
   11bfe:	0f 84 53 01 00 00    	je     11d57 <_NpfsFileSystemControl@8+0x187>
   11c04:	0f 87 76 01 00 00    	ja     11d80 <_NpfsFileSystemControl@8+0x1b0>
   11c0a:	3d 04 00 11 00       	cmp    $0x110004,%eax
   11c0f:	0f 84 f5 02 00 00    	je     11f0a <_NpfsFileSystemControl@8+0x33a>
   11c15:	0f 86 29 02 00 00    	jbe    11e44 <_NpfsFileSystemControl@8+0x274>
   11c1b:	3d 08 00 11 00       	cmp    $0x110008,%eax
   11c20:	0f 85 2a 01 00 00    	jne    11d50 <_NpfsFileSystemControl@8+0x180>
   11c26:	8b 57 38             	mov    0x38(%edi),%edx
   11c29:	83 fa 03             	cmp    $0x3,%edx
   11c2c:	0f 84 28 03 00 00    	je     11f5a <_NpfsFileSystemControl@8+0x38a>
   11c32:	b8 b1 00 00 c0       	mov    $0xc00000b1,%eax
   11c37:	83 fa 04             	cmp    $0x4,%edx
   11c3a:	0f 84 dc 00 00 00    	je     11d1c <_NpfsFileSystemControl@8+0x14c>
   11c40:	8b 5f 10             	mov    0x10(%edi),%ebx
   11c43:	83 ec 0c             	sub    $0xc,%esp
   11c46:	8d 43 10             	lea    0x10(%ebx),%eax
   11c49:	6a 00                	push   $0x0
   11c4b:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   11c4e:	6a 00                	push   $0x0
   11c50:	6a 00                	push   $0x0
   11c52:	6a 06                	push   $0x6
   11c54:	50                   	push   %eax
   11c55:	e8 f6 0b 00 00       	call   12850 <_KeWaitForSingleObject@20>
   11c5a:	8b 43 38             	mov    0x38(%ebx),%eax
   11c5d:	83 c4 0c             	add    $0xc,%esp
   11c60:	8d 53 38             	lea    0x38(%ebx),%edx
   11c63:	eb 0d                	jmp    11c72 <_NpfsFileSystemControl@8+0xa2>
   11c65:	8b 58 38             	mov    0x38(%eax),%ebx
   11c68:	85 db                	test   %ebx,%ebx
   11c6a:	0f 84 4b 03 00 00    	je     11fbb <_NpfsFileSystemControl@8+0x3eb>
   11c70:	8b 00                	mov    (%eax),%eax
   11c72:	39 c2                	cmp    %eax,%edx
   11c74:	75 ef                	jne    11c65 <_NpfsFileSystemControl@8+0x95>
   11c76:	c7 47 38 02 00 00 00 	movl   $0x2,0x38(%edi)
   11c7d:	51                   	push   %ecx
   11c7e:	51                   	push   %ecx
   11c7f:	6a 14                	push   $0x14
   11c81:	6a 00                	push   $0x0
   11c83:	e8 e8 0b 00 00       	call   12870 <_ExAllocatePool@8>
   11c88:	c7 45 f0 9a 00 00 c0 	movl   $0xc000009a,0xfffffff0(%ebp)
   11c8f:	5b                   	pop    %ebx
   11c90:	85 c0                	test   %eax,%eax
   11c92:	5a                   	pop    %edx
   11c93:	89 c3                	mov    %eax,%ebx
   11c95:	74 73                	je     11d0a <_NpfsFileSystemControl@8+0x13a>
   11c97:	83 ec 0c             	sub    $0xc,%esp
   11c9a:	89 70 08             	mov    %esi,0x8(%eax)
   11c9d:	89 78 10             	mov    %edi,0x10(%eax)
   11ca0:	8b 47 10             	mov    0x10(%edi),%eax
   11ca3:	89 43 0c             	mov    %eax,0xc(%ebx)
   11ca6:	6a 00                	push   $0x0
   11ca8:	6a 00                	push   $0x0
   11caa:	6a 00                	push   $0x0
   11cac:	6a 06                	push   $0x6
   11cae:	8b 47 10             	mov    0x10(%edi),%eax
   11cb1:	83 c0 10             	add    $0x10,%eax
   11cb4:	50                   	push   %eax
   11cb5:	e8 96 0b 00 00       	call   12850 <_KeWaitForSingleObject@20>
   11cba:	8b 46 60             	mov    0x60(%esi),%eax
   11cbd:	83 c4 0c             	add    $0xc,%esp
   11cc0:	8d 4e 38             	lea    0x38(%esi),%ecx
   11cc3:	80 48 03 01          	orb    $0x1,0x3(%eax)
   11cc7:	89 5e 40             	mov    %ebx,0x40(%esi)
static __inline VOID
InsertTailList(
	IN PLIST_ENTRY  ListHead,
	IN PLIST_ENTRY  Entry)
{
   11cca:	8b 47 10             	mov    0x10(%edi),%eax
   11ccd:	83 c0 40             	add    $0x40,%eax
	PLIST_ENTRY OldBlink;
	OldBlink = ListHead->Blink;
	Entry->Flink = ListHead;
   11cd0:	89 03                	mov    %eax,(%ebx)
   11cd2:	8b 50 04             	mov    0x4(%eax),%edx
	Entry->Blink = OldBlink;
   11cd5:	89 53 04             	mov    %edx,0x4(%ebx)
	OldBlink->Flink = Entry;
	ListHead->Blink = Entry;
   11cd8:	89 58 04             	mov    %ebx,0x4(%eax)
   11cdb:	89 1a                	mov    %ebx,(%edx)
   11cdd:	ba 40 1b 01 00       	mov    $0x11b40,%edx
   11ce2:	e8 d9 0b 00 00       	call   128c0 <@InterlockedExchange@8>
   11ce7:	80 7e 24 00          	cmpb   $0x0,0x24(%esi)
   11ceb:	0f 85 84 02 00 00    	jne    11f75 <_NpfsFileSystemControl@8+0x3a5>
   11cf1:	51                   	push   %ecx
   11cf2:	51                   	push   %ecx
   11cf3:	6a 00                	push   $0x0
   11cf5:	8b 47 10             	mov    0x10(%edi),%eax
   11cf8:	83 c0 10             	add    $0x10,%eax
   11cfb:	50                   	push   %eax
   11cfc:	e8 5f 0b 00 00       	call   12860 <_KeReleaseMutex@8>
   11d01:	c7 45 f0 03 01 00 00 	movl   $0x103,0xfffffff0(%ebp)
   11d08:	58                   	pop    %eax
   11d09:	5a                   	pop    %edx
   11d0a:	50                   	push   %eax
   11d0b:	50                   	push   %eax
   11d0c:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   11d0f:	6a 00                	push   $0x0
   11d11:	50                   	push   %eax
   11d12:	e8 49 0b 00 00       	call   12860 <_KeReleaseMutex@8>
   11d17:	5f                   	pop    %edi
   11d18:	58                   	pop    %eax
   11d19:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
   11d1c:	89 c3                	mov    %eax,%ebx
   11d1e:	e9 10 01 00 00       	jmp    11e33 <_NpfsFileSystemControl@8+0x263>
   11d23:	3d f4 5f 11 00       	cmp    $0x115ff4,%eax
   11d28:	74 2d                	je     11d57 <_NpfsFileSystemControl@8+0x187>
   11d2a:	0f 87 b0 00 00 00    	ja     11de0 <_NpfsFileSystemControl@8+0x210>
   11d30:	3d 2c 00 11 00       	cmp    $0x11002c,%eax
   11d35:	0f 84 73 01 00 00    	je     11eae <_NpfsFileSystemControl@8+0x2de>
   11d3b:	0f 87 d6 00 00 00    	ja     11e17 <_NpfsFileSystemControl@8+0x247>
   11d41:	3d 28 00 11 00       	cmp    $0x110028,%eax
   11d46:	0f 84 17 01 00 00    	je     11e63 <_NpfsFileSystemControl@8+0x293>
   11d4c:	8d 74 26 00          	lea    0x0(%esi),%esi
   11d50:	bb 01 00 00 c0       	mov    $0xc0000001,%ebx
   11d55:	eb 05                	jmp    11d5c <_NpfsFileSystemControl@8+0x18c>
   11d57:	bb 02 00 00 c0       	mov    $0xc0000002,%ebx
   11d5c:	89 5e 18             	mov    %ebx,0x18(%esi)
   11d5f:	c7 46 1c 00 00 00 00 	movl   $0x0,0x1c(%esi)
   11d66:	57                   	push   %edi
   11d67:	57                   	push   %edi
   11d68:	6a 00                	push   $0x0
   11d6a:	56                   	push   %esi
   11d6b:	e8 30 0b 00 00       	call   128a0 <_IoCompleteRequest@8>
   11d70:	59                   	pop    %ecx
   11d71:	5e                   	pop    %esi
   11d72:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   11d75:	89 d8                	mov    %ebx,%eax
   11d77:	5b                   	pop    %ebx
   11d78:	5e                   	pop    %esi
   11d79:	5f                   	pop    %edi
   11d7a:	5d                   	pop    %ebp
   11d7b:	c2 08 00             	ret    $0x8
   11d7e:	89 f6                	mov    %esi,%esi
   11d80:	3d 1c 00 11 00       	cmp    $0x11001c,%eax
   11d85:	74 d0                	je     11d57 <_NpfsFileSystemControl@8+0x187>
   11d87:	0f 87 c3 00 00 00    	ja     11e50 <_NpfsFileSystemControl@8+0x280>
   11d8d:	3d 18 00 11 00       	cmp    $0x110018,%eax
   11d92:	75 bc                	jne    11d50 <_NpfsFileSystemControl@8+0x180>
   11d94:	8b 5f 38             	mov    0x38(%edi),%ebx
   11d97:	8b 4e 0c             	mov    0xc(%esi),%ecx
   11d9a:	8b 57 10             	mov    0x10(%edi),%edx
   11d9d:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   11da2:	85 db                	test   %ebx,%ebx
   11da4:	0f 85 72 ff ff ff    	jne    11d1c <_NpfsFileSystemControl@8+0x14c>
   11daa:	8b 42 30             	mov    0x30(%edx),%eax
   11dad:	83 c2 30             	add    $0x30,%edx
   11db0:	eb 0c                	jmp    11dbe <_NpfsFileSystemControl@8+0x1ee>
   11db2:	83 78 38 02          	cmpl   $0x2,0x38(%eax)
   11db6:	0f 84 ec 00 00 00    	je     11ea8 <_NpfsFileSystemControl@8+0x2d8>
   11dbc:	8b 00                	mov    (%eax),%eax
   11dbe:	39 c2                	cmp    %eax,%edx
   11dc0:	75 f0                	jne    11db2 <_NpfsFileSystemControl@8+0x1e2>
   11dc2:	83 ec 0c             	sub    $0xc,%esp
   11dc5:	8d 47 14             	lea    0x14(%edi),%eax
   11dc8:	51                   	push   %ecx
   11dc9:	6a 00                	push   $0x0
   11dcb:	6a 00                	push   $0x0
   11dcd:	6a 06                	push   $0x6
   11dcf:	50                   	push   %eax
   11dd0:	e8 7b 0a 00 00       	call   12850 <_KeWaitForSingleObject@20>
   11dd5:	83 c4 0c             	add    $0xc,%esp
   11dd8:	89 c3                	mov    %eax,%ebx
   11dda:	eb 57                	jmp    11e33 <_NpfsFileSystemControl@8+0x263>
   11ddc:	8d 74 26 00          	lea    0x0(%esi),%esi
   11de0:	bb 02 00 00 c0       	mov    $0xc0000002,%ebx
   11de5:	3d f8 9f 11 00       	cmp    $0x119ff8,%eax
   11dea:	0f 84 6c ff ff ff    	je     11d5c <_NpfsFileSystemControl@8+0x18c>
   11df0:	76 6a                	jbe    11e5c <_NpfsFileSystemControl@8+0x28c>
   11df2:	bb 02 00 00 c0       	mov    $0xc0000002,%ebx
   11df7:	3d 17 c0 11 00       	cmp    $0x11c017,%eax
   11dfc:	0f 84 5a ff ff ff    	je     11d5c <_NpfsFileSystemControl@8+0x18c>
   11e02:	3d ff df 11 00       	cmp    $0x11dfff,%eax
   11e07:	0f 84 4f ff ff ff    	je     11d5c <_NpfsFileSystemControl@8+0x18c>
   11e0d:	bb 01 00 00 c0       	mov    $0xc0000001,%ebx
   11e12:	e9 45 ff ff ff       	jmp    11d5c <_NpfsFileSystemControl@8+0x18c>
   11e17:	3d 0c 40 11 00       	cmp    $0x11400c,%eax
   11e1c:	0f 85 2e ff ff ff    	jne    11d50 <_NpfsFileSystemControl@8+0x180>
   11e22:	8b 42 04             	mov    0x4(%edx),%eax
   11e25:	83 f8 14             	cmp    $0x14,%eax
   11e28:	19 c0                	sbb    %eax,%eax
   11e2a:	83 e0 0b             	and    $0xb,%eax
   11e2d:	8d 98 02 00 00 c0    	lea    0xc0000002(%eax),%ebx
   11e33:	81 fb 03 01 00 00    	cmp    $0x103,%ebx
   11e39:	0f 85 1d ff ff ff    	jne    11d5c <_NpfsFileSystemControl@8+0x18c>
   11e3f:	e9 2e ff ff ff       	jmp    11d72 <_NpfsFileSystemControl@8+0x1a2>
   11e44:	bb 02 00 00 c0       	mov    $0xc0000002,%ebx
   11e49:	3d 00 00 11 00       	cmp    $0x110000,%eax
   11e4e:	eb b7                	jmp    11e07 <_NpfsFileSystemControl@8+0x237>
   11e50:	bb 02 00 00 c0       	mov    $0xc0000002,%ebx
   11e55:	3d 20 00 11 00       	cmp    $0x110020,%eax
   11e5a:	eb ab                	jmp    11e07 <_NpfsFileSystemControl@8+0x237>
   11e5c:	3d 00 60 11 00       	cmp    $0x116000,%eax
   11e61:	eb a4                	jmp    11e07 <_NpfsFileSystemControl@8+0x237>
   11e63:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
   11e68:	83 7a 04 17          	cmpl   $0x17,0x4(%edx)
   11e6c:	0f 86 aa fe ff ff    	jbe    11d1c <_NpfsFileSystemControl@8+0x14c>
   11e72:	8b 57 10             	mov    0x10(%edi),%edx
   11e75:	8b 4e 0c             	mov    0xc(%esi),%ecx
   11e78:	83 7a 50 01          	cmpl   $0x1,0x50(%edx)
   11e7c:	0f 94 01             	sete   (%ecx)
   11e7f:	83 7a 4c 01          	cmpl   $0x1,0x4c(%edx)
   11e83:	0f 94 41 01          	sete   0x1(%ecx)
   11e87:	8b 42 54             	mov    0x54(%edx),%eax
   11e8a:	85 c0                	test   %eax,%eax
   11e8c:	0f 94 41 02          	sete   0x2(%ecx)
   11e90:	8b 42 64             	mov    0x64(%edx),%eax
   11e93:	89 41 04             	mov    %eax,0x4(%ecx)
   11e96:	8b 42 68             	mov    0x68(%edx),%eax
   11e99:	89 41 08             	mov    %eax,0x8(%ecx)
   11e9c:	8b 42 70             	mov    0x70(%edx),%eax
   11e9f:	8b 52 74             	mov    0x74(%edx),%edx
   11ea2:	89 51 14             	mov    %edx,0x14(%ecx)
   11ea5:	89 41 10             	mov    %eax,0x10(%ecx)
   11ea8:	31 c0                	xor    %eax,%eax
   11eaa:	89 c3                	mov    %eax,%ebx
   11eac:	eb 85                	jmp    11e33 <_NpfsFileSystemControl@8+0x263>
   11eae:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
   11eb3:	83 7a 08 17          	cmpl   $0x17,0x8(%edx)
   11eb7:	0f 86 5f fe ff ff    	jbe    11d1c <_NpfsFileSystemControl@8+0x14c>
   11ebd:	8b 56 0c             	mov    0xc(%esi),%edx
   11ec0:	8b 4f 10             	mov    0x10(%edi),%ecx
   11ec3:	80 3a 00             	cmpb   $0x0,(%edx)
   11ec6:	0f 95 c0             	setne  %al
   11ec9:	25 ff 00 00 00       	and    $0xff,%eax
   11ece:	89 41 50             	mov    %eax,0x50(%ecx)
   11ed1:	80 3a 00             	cmpb   $0x0,(%edx)
   11ed4:	0f 95 c0             	setne  %al
   11ed7:	25 ff 00 00 00       	and    $0xff,%eax
   11edc:	89 41 4c             	mov    %eax,0x4c(%ecx)
   11edf:	80 7a 02 00          	cmpb   $0x0,0x2(%edx)
   11ee3:	0f 94 c0             	sete   %al
   11ee6:	25 ff 00 00 00       	and    $0xff,%eax
   11eeb:	89 41 54             	mov    %eax,0x54(%ecx)
   11eee:	8b 42 04             	mov    0x4(%edx),%eax
   11ef1:	89 41 64             	mov    %eax,0x64(%ecx)
   11ef4:	8b 42 08             	mov    0x8(%edx),%eax
   11ef7:	89 41 68             	mov    %eax,0x68(%ecx)
   11efa:	8b 42 10             	mov    0x10(%edx),%eax
   11efd:	8b 52 14             	mov    0x14(%edx),%edx
   11f00:	89 41 70             	mov    %eax,0x70(%ecx)
   11f03:	31 c0                	xor    %eax,%eax
   11f05:	89 51 74             	mov    %edx,0x74(%ecx)
   11f08:	eb a0                	jmp    11eaa <_NpfsFileSystemControl@8+0x2da>
   11f0a:	8b 57 38             	mov    0x38(%edi),%edx
   11f0d:	31 c0                	xor    %eax,%eax
   11f0f:	83 fa 01             	cmp    $0x1,%edx
   11f12:	0f 84 04 fe ff ff    	je     11d1c <_NpfsFileSystemControl@8+0x14c>
   11f18:	83 fa 03             	cmp    $0x3,%edx
   11f1b:	74 23                	je     11f40 <_NpfsFileSystemControl@8+0x370>
   11f1d:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
   11f22:	83 fa 04             	cmp    $0x4,%edx
   11f25:	0f 85 f1 fd ff ff    	jne    11d1c <_NpfsFileSystemControl@8+0x14c>
   11f2b:	c7 47 38 01 00 00 00 	movl   $0x1,0x38(%edi)
   11f32:	31 c0                	xor    %eax,%eax
   11f34:	c7 47 08 00 00 00 00 	movl   $0x0,0x8(%edi)
   11f3b:	e9 6a ff ff ff       	jmp    11eaa <_NpfsFileSystemControl@8+0x2da>
   11f40:	8b 47 08             	mov    0x8(%edi),%eax
   11f43:	c7 47 38 01 00 00 00 	movl   $0x1,0x38(%edi)
   11f4a:	c7 40 08 00 00 00 00 	movl   $0x0,0x8(%eax)
   11f51:	c7 40 38 01 00 00 00 	movl   $0x1,0x38(%eax)
   11f58:	eb d8                	jmp    11f32 <_NpfsFileSystemControl@8+0x362>
   11f5a:	83 ec 0c             	sub    $0xc,%esp
   11f5d:	8d 47 14             	lea    0x14(%edi),%eax
   11f60:	50                   	push   %eax
   11f61:	e8 ca 09 00 00       	call   12930 <_KeResetEvent@4>
   11f66:	b8 b2 00 00 c0       	mov    $0xc00000b2,%eax
   11f6b:	83 c4 0c             	add    $0xc,%esp
   11f6e:	89 c3                	mov    %eax,%ebx
   11f70:	e9 be fe ff ff       	jmp    11e33 <_NpfsFileSystemControl@8+0x263>
{
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
   11f75:	8b 13                	mov    (%ebx),%edx
  OldBlink = Entry->Blink;
   11f77:	8b 43 04             	mov    0x4(%ebx),%eax
   11f7a:	c7 46 18 20 01 00 c0 	movl   $0xc0000120,0x18(%esi)
   11f81:	c7 46 1c 00 00 00 00 	movl   $0x0,0x1c(%esi)
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
  OldBlink = Entry->Blink;
  OldFlink->Blink = OldBlink;
   11f88:	89 42 04             	mov    %eax,0x4(%edx)
  OldBlink->Flink = OldFlink;
   11f8b:	89 10                	mov    %edx,(%eax)
   11f8d:	50                   	push   %eax
   11f8e:	50                   	push   %eax
   11f8f:	6a 00                	push   $0x0
   11f91:	56                   	push   %esi
   11f92:	e8 09 09 00 00       	call   128a0 <_IoCompleteRequest@8>
   11f97:	6a 00                	push   $0x0
   11f99:	8b 47 10             	mov    0x10(%edi),%eax
   11f9c:	83 c0 10             	add    $0x10,%eax
   11f9f:	50                   	push   %eax
   11fa0:	e8 bb 08 00 00       	call   12860 <_KeReleaseMutex@8>
   11fa5:	50                   	push   %eax
   11fa6:	53                   	push   %ebx
   11fa7:	e8 04 09 00 00       	call   128b0 <_ExFreePool@4>
   11fac:	c7 45 f0 20 01 00 c0 	movl   $0xc0000120,0xfffffff0(%ebp)
   11fb3:	83 c4 0c             	add    $0xc,%esp
   11fb6:	e9 4f fd ff ff       	jmp    11d0a <_NpfsFileSystemControl@8+0x13a>
   11fbb:	83 c0 14             	add    $0x14,%eax
   11fbe:	52                   	push   %edx
   11fbf:	6a 00                	push   $0x0
   11fc1:	6a 00                	push   $0x0
   11fc3:	50                   	push   %eax
   11fc4:	e8 37 09 00 00       	call   12900 <_KeSetEvent@12>
   11fc9:	58                   	pop    %eax
   11fca:	e9 a7 fc ff ff       	jmp    11c76 <_NpfsFileSystemControl@8+0xa6>
   11fcf:	90                   	nop    

00011fd0 <_NpfsFlushBuffers@8>:
   11fd0:	55                   	push   %ebp
   11fd1:	89 e5                	mov    %esp,%ebp
   11fd3:	83 ec 10             	sub    $0x10,%esp
   11fd6:	8b 45 0c             	mov    0xc(%ebp),%eax
   11fd9:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
   11fe0:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
   11fe7:	6a 00                	push   $0x0
   11fe9:	50                   	push   %eax
   11fea:	e8 b1 08 00 00       	call   128a0 <_IoCompleteRequest@8>
   11fef:	31 c0                	xor    %eax,%eax
   11ff1:	c9                   	leave  
   11ff2:	c2 08 00             	ret    $0x8
   11ff5:	90                   	nop    
   11ff6:	90                   	nop    
   11ff7:	90                   	nop    
   11ff8:	90                   	nop    
   11ff9:	90                   	nop    
   11ffa:	90                   	nop    
   11ffb:	90                   	nop    
   11ffc:	90                   	nop    
   11ffd:	90                   	nop    
   11ffe:	90                   	nop    
   11fff:	90                   	nop    

00012000 <_DriverEntry@8>:

NTSTATUS STDCALL
DriverEntry(PDRIVER_OBJECT DriverObject,
	    PUNICODE_STRING RegistryPath)
{
   12000:	55                   	push   %ebp
   12001:	89 e5                	mov    %esp,%ebp
   12003:	56                   	push   %esi
   12004:	53                   	push   %ebx
   12005:	83 ec 18             	sub    $0x18,%esp
   PNPFS_DEVICE_EXTENSION DeviceExtension;
   PDEVICE_OBJECT DeviceObject;
   UNICODE_STRING DeviceName;
   NTSTATUS Status;
   
   DPRINT("Named Pipe FSD 0.0.2\n");
   
   DriverObject->MajorFunction[IRP_MJ_CREATE] = NpfsCreate;
   DriverObject->MajorFunction[IRP_MJ_CREATE_NAMED_PIPE] =
     NpfsCreateNamedPipe;
   DriverObject->MajorFunction[IRP_MJ_CLOSE] = NpfsClose;
   DriverObject->MajorFunction[IRP_MJ_READ] = NpfsRead;
   DriverObject->MajorFunction[IRP_MJ_WRITE] = NpfsWrite;
   DriverObject->MajorFunction[IRP_MJ_QUERY_INFORMATION] =
     NpfsQueryInformation;
   DriverObject->MajorFunction[IRP_MJ_SET_INFORMATION] =
     NpfsSetInformation;
   DriverObject->MajorFunction[IRP_MJ_QUERY_VOLUME_INFORMATION] = 
     NpfsQueryVolumeInformation;
//   DriverObject->MajorFunction[IRP_MJ_CLEANUP] = NpfsCleanup;
   DriverObject->MajorFunction[IRP_MJ_FLUSH_BUFFERS] = NpfsFlushBuffers;
//   DriverObject->MajorFunction[IRP_MJ_DIRECTORY_CONTROL] =
//     NpfsDirectoryControl;
   DriverObject->MajorFunction[IRP_MJ_FILE_SYSTEM_CONTROL] =
     NpfsFileSystemControl;
//   DriverObject->MajorFunction[IRP_MJ_QUERY_SECURITY] = 
//     NpfsQuerySecurity;
//   DriverObject->MajorFunction[IRP_MJ_SET_SECURITY] =
//     NpfsSetSecurity;
   
   DriverObject->DriverUnload = NULL;
   
   RtlInitUnicodeString(&DeviceName, L"\\Device\\NamedPipe");
   12008:	8d 75 f0             	lea    0xfffffff0(%ebp),%esi
   1200b:	8b 5d 08             	mov    0x8(%ebp),%ebx
   1200e:	c7 43 38 50 10 01 00 	movl   $0x11050,0x38(%ebx)
   12015:	c7 43 3c b0 13 01 00 	movl   $0x113b0,0x3c(%ebx)
   1201c:	c7 43 40 10 18 01 00 	movl   $0x11810,0x40(%ebx)
   12023:	c7 43 44 c0 20 01 00 	movl   $0x120c0,0x44(%ebx)
   1202a:	c7 43 48 f0 23 01 00 	movl   $0x123f0,0x48(%ebx)
   12031:	c7 43 4c b0 19 01 00 	movl   $0x119b0,0x4c(%ebx)
   12038:	c7 43 50 f0 1a 01 00 	movl   $0x11af0,0x50(%ebx)
   1203f:	c7 43 60 10 27 01 00 	movl   $0x12710,0x60(%ebx)
   12046:	c7 43 5c d0 1f 01 00 	movl   $0x11fd0,0x5c(%ebx)
   1204d:	c7 43 6c d0 1b 01 00 	movl   $0x11bd0,0x6c(%ebx)
   12054:	c7 43 34 00 00 00 00 	movl   $0x0,0x34(%ebx)
   1205b:	68 40 30 01 00       	push   $0x13040
   12060:	56                   	push   %esi
   12061:	e8 ea 08 00 00       	call   12950 <_RtlInitUnicodeString@8>
   Status = IoCreateDevice(DriverObject,
   12066:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
   12069:	89 04 24             	mov    %eax,(%esp)
   1206c:	6a 00                	push   $0x0
   1206e:	6a 00                	push   $0x0
   12070:	6a 11                	push   $0x11
   12072:	56                   	push   %esi
   12073:	6a 34                	push   $0x34
   12075:	53                   	push   %ebx
   12076:	e8 e5 08 00 00       	call   12960 <_IoCreateDevice@28>
			   sizeof(NPFS_DEVICE_EXTENSION),
			   &DeviceName,
			   FILE_DEVICE_NAMED_PIPE,
			   0,
			   FALSE,
			   &DeviceObject);
   if (!NT_SUCCESS(Status))
   1207b:	5a                   	pop    %edx
   1207c:	85 c0                	test   %eax,%eax
   1207e:	78 36                	js     120b6 <_DriverEntry@8+0xb6>
     {
	DPRINT("Failed to create named pipe device! (Status %x)\n", Status);
	return Status;
     }
   
   /* initialize the device object */
   DeviceObject->Flags = DO_DIRECT_IO;
   12080:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   
   /* initialize the device extension */
   DeviceExtension = DeviceObject->DeviceExtension;
   12083:	8b 58 28             	mov    0x28(%eax),%ebx
   12086:	c7 40 1c 10 00 00 00 	movl   $0x10,0x1c(%eax)
static __inline VOID
InitializeListHead(
	IN PLIST_ENTRY  ListHead)
{
	ListHead->Flink = ListHead->Blink = ListHead;
   1208d:	89 5b 04             	mov    %ebx,0x4(%ebx)
   12090:	89 1b                	mov    %ebx,(%ebx)
   InitializeListHead(&DeviceExtension->PipeListHead);
   KeInitializeMutex(&DeviceExtension->PipeListLock,
   12092:	50                   	push   %eax
   12093:	50                   	push   %eax
   12094:	8d 43 08             	lea    0x8(%ebx),%eax
   12097:	6a 00                	push   $0x0
   12099:	50                   	push   %eax
   1209a:	e8 41 08 00 00       	call   128e0 <_KeInitializeMutex@8>
		     0);

   /* set the size quotas */
   DeviceExtension->MinQuota = PAGE_SIZE;
   1209f:	c7 43 28 00 10 00 00 	movl   $0x1000,0x28(%ebx)
   DeviceExtension->DefaultQuota = 8 * PAGE_SIZE;
   120a6:	c7 43 2c 00 80 00 00 	movl   $0x8000,0x2c(%ebx)
   DeviceExtension->MaxQuota = 64 * PAGE_SIZE;
   120ad:	c7 43 30 00 00 04 00 	movl   $0x40000,0x30(%ebx)

   return STATUS_SUCCESS;
   120b4:	31 c0                	xor    %eax,%eax
}
   120b6:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
   120b9:	5b                   	pop    %ebx
   120ba:	5e                   	pop    %esi
   120bb:	5d                   	pop    %ebp
   120bc:	c2 08 00             	ret    $0x8
   120bf:	90                   	nop    

000120c0 <_NpfsRead@8>:
   120c0:	55                   	push   %ebp
   120c1:	89 e5                	mov    %esp,%ebp
   120c3:	57                   	push   %edi
   120c4:	56                   	push   %esi
   120c5:	53                   	push   %ebx
   120c6:	83 ec 2c             	sub    $0x2c,%esp
   120c9:	8b 45 0c             	mov    0xc(%ebp),%eax
   120cc:	8b 48 60             	mov    0x60(%eax),%ecx
   120cf:	c7 45 ec 01 00 00 c0 	movl   $0xc0000001,0xffffffec(%ebp)
   120d6:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
   120dd:	8b 41 18             	mov    0x18(%ecx),%eax
   120e0:	8b 78 0c             	mov    0xc(%eax),%edi
   120e3:	8b 47 08             	mov    0x8(%edi),%eax
   120e6:	8b 57 10             	mov    0x10(%edi),%edx
   120e9:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   120ec:	8b 45 0c             	mov    0xc(%ebp),%eax
   120ef:	89 55 e0             	mov    %edx,0xffffffe0(%ebp)
   120f2:	8b 50 04             	mov    0x4(%eax),%edx
   120f5:	85 d2                	test   %edx,%edx
   120f7:	0f 84 ba 01 00 00    	je     122b7 <_NpfsRead@8+0x1f7>
   120fd:	8b 5f 44             	mov    0x44(%edi),%ebx
   12100:	85 db                	test   %ebx,%ebx
   12102:	0f 84 af 01 00 00    	je     122b7 <_NpfsRead@8+0x1f7>

/* EOF */
   12108:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
   1210f:	66 8b 42 06          	mov    0x6(%edx),%ax
   12113:	8b 49 04             	mov    0x4(%ecx),%ecx
   12116:	a8 05                	test   $0x5,%al
   12118:	89 4d dc             	mov    %ecx,0xffffffdc(%ebp)
   1211b:	0f 84 75 02 00 00    	je     12396 <_NpfsRead@8+0x2d6>
   12121:	8b 52 0c             	mov    0xc(%edx),%edx
   12124:	89 55 d8             	mov    %edx,0xffffffd8(%ebp)
   12127:	8d 4f 54             	lea    0x54(%edi),%ecx
   1212a:	8d 55 f3             	lea    0xfffffff3(%ebp),%edx
   1212d:	89 4d d4             	mov    %ecx,0xffffffd4(%ebp)
   12130:	53                   	push   %ebx
   12131:	53                   	push   %ebx
   12132:	52                   	push   %edx
   12133:	51                   	push   %ecx
   12134:	e8 87 08 00 00       	call   129c0 <_KeAcquireSpinLock@8>
   12139:	5a                   	pop    %edx
   1213a:	59                   	pop    %ecx
   1213b:	90                   	nop    
   1213c:	8d 74 26 00          	lea    0x0(%esi),%esi
   12140:	8b 47 3c             	mov    0x3c(%edi),%eax
   12143:	85 c0                	test   %eax,%eax
   12145:	75 5a                	jne    121a1 <_NpfsRead@8+0xe1>
   12147:	83 7f 38 03          	cmpl   $0x3,0x38(%edi)
   1214b:	0f 84 2e 02 00 00    	je     1237f <_NpfsRead@8+0x2bf>
   12151:	50                   	push   %eax
   12152:	50                   	push   %eax
   12153:	31 c0                	xor    %eax,%eax
   12155:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   12158:	50                   	push   %eax
   12159:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
   1215c:	50                   	push   %eax
   1215d:	e8 6e 08 00 00       	call   129d0 <_KeReleaseSpinLock@8>
   12162:	8b 5d e8             	mov    0xffffffe8(%ebp),%ebx
   12165:	5e                   	pop    %esi
   12166:	85 db                	test   %ebx,%ebx
   12168:	58                   	pop    %eax
   12169:	0f 85 72 02 00 00    	jne    123e1 <_NpfsRead@8+0x321>
   1216f:	83 7f 38 03          	cmpl   $0x3,0x38(%edi)
   12173:	0f 85 5c 02 00 00    	jne    123d5 <_NpfsRead@8+0x315>
   12179:	83 ec 0c             	sub    $0xc,%esp
   1217c:	8d 47 24             	lea    0x24(%edi),%eax
   1217f:	6a 00                	push   $0x0
   12181:	6a 00                	push   $0x0
   12183:	6a 00                	push   $0x0
   12185:	6a 06                	push   $0x6
   12187:	50                   	push   %eax
   12188:	e8 c3 06 00 00       	call   12850 <_KeWaitForSingleObject@20>
   1218d:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
   12190:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   12193:	8d 45 f3             	lea    0xfffffff3(%ebp),%eax
   12196:	89 04 24             	mov    %eax,(%esp)
   12199:	51                   	push   %ecx
   1219a:	e8 21 08 00 00       	call   129c0 <_KeAcquireSpinLock@8>
   1219f:	58                   	pop    %eax
   121a0:	5a                   	pop    %edx
   121a1:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
   121a4:	8b 42 4c             	mov    0x4c(%edx),%eax
   121a7:	85 c0                	test   %eax,%eax
   121a9:	0f 85 31 01 00 00    	jne    122e0 <_NpfsRead@8+0x220>
   121af:	8b 75 dc             	mov    0xffffffdc(%ebp),%esi
   121b2:	85 f6                	test   %esi,%esi
   121b4:	0f 84 d1 00 00 00    	je     1228b <_NpfsRead@8+0x1cb>
   121ba:	8b 47 3c             	mov    0x3c(%edi),%eax
   121bd:	85 c0                	test   %eax,%eax
   121bf:	0f 84 bb 00 00 00    	je     12280 <_NpfsRead@8+0x1c0>
   121c5:	8b 4f 44             	mov    0x44(%edi),%ecx
   121c8:	89 4d d0             	mov    %ecx,0xffffffd0(%ebp)
   121cb:	8b 4f 48             	mov    0x48(%edi),%ecx
   121ce:	eb 55                	jmp    12225 <_NpfsRead@8+0x165>
   121d0:	50                   	push   %eax
   121d1:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   121d4:	56                   	push   %esi
   121d5:	51                   	push   %ecx
   121d6:	50                   	push   %eax
   121d7:	e8 a4 07 00 00       	call   12980 <_memcpy>
   121dc:	8b 47 44             	mov    0x44(%edi),%eax
   121df:	8b 57 48             	mov    0x48(%edi),%edx
   121e2:	8b 5f 50             	mov    0x50(%edi),%ebx
   121e5:	01 f2                	add    %esi,%edx
   121e7:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
   121ea:	01 d8                	add    %ebx,%eax
   121ec:	83 c4 10             	add    $0x10,%esp
   121ef:	89 d1                	mov    %edx,%ecx
   121f1:	39 c2                	cmp    %eax,%edx
   121f3:	0f 84 57 01 00 00    	je     12350 <_NpfsRead@8+0x290>
   121f9:	89 57 48             	mov    %edx,0x48(%edi)
   121fc:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   121ff:	8b 5d e8             	mov    0xffffffe8(%ebp),%ebx
   12202:	01 f0                	add    %esi,%eax
   12204:	8b 57 40             	mov    0x40(%edi),%edx
   12207:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
   1220a:	8b 47 3c             	mov    0x3c(%edi),%eax
   1220d:	01 f3                	add    %esi,%ebx
   1220f:	29 f0                	sub    %esi,%eax
   12211:	01 f2                	add    %esi,%edx
   12213:	29 75 dc             	sub    %esi,0xffffffdc(%ebp)
   12216:	89 5d e8             	mov    %ebx,0xffffffe8(%ebp)
   12219:	89 47 3c             	mov    %eax,0x3c(%edi)
   1221c:	89 57 40             	mov    %edx,0x40(%edi)
   1221f:	74 6a                	je     1228b <_NpfsRead@8+0x1cb>
   12221:	85 c0                	test   %eax,%eax
   12223:	74 5b                	je     12280 <_NpfsRead@8+0x1c0>
   12225:	89 c6                	mov    %eax,%esi
   12227:	3b 45 dc             	cmp    0xffffffdc(%ebp),%eax
   1222a:	76 03                	jbe    1222f <_NpfsRead@8+0x16f>
   1222c:	8b 75 dc             	mov    0xffffffdc(%ebp),%esi
   1222f:	8b 55 d0             	mov    0xffffffd0(%ebp),%edx
   12232:	8b 5f 50             	mov    0x50(%edi),%ebx
   12235:	8d 04 31             	lea    (%ecx,%esi,1),%eax
   12238:	01 da                	add    %ebx,%edx
   1223a:	39 d0                	cmp    %edx,%eax
   1223c:	76 92                	jbe    121d0 <_NpfsRead@8+0x110>
   1223e:	89 d3                	mov    %edx,%ebx
   12240:	29 cb                	sub    %ecx,%ebx
   12242:	50                   	push   %eax
   12243:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   12246:	53                   	push   %ebx
   12247:	51                   	push   %ecx
   12248:	50                   	push   %eax
   12249:	e8 32 07 00 00       	call   12980 <_memcpy>
   1224e:	83 c4 0c             	add    $0xc,%esp
   12251:	89 f0                	mov    %esi,%eax
   12253:	8b 4d d8             	mov    0xffffffd8(%ebp),%ecx
   12256:	29 d8                	sub    %ebx,%eax
   12258:	50                   	push   %eax
   12259:	8d 14 0b             	lea    (%ebx,%ecx,1),%edx
   1225c:	8b 47 44             	mov    0x44(%edi),%eax
   1225f:	50                   	push   %eax
   12260:	52                   	push   %edx
   12261:	e8 1a 07 00 00       	call   12980 <_memcpy>
   12266:	8b 47 44             	mov    0x44(%edi),%eax
   12269:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
   1226c:	01 f0                	add    %esi,%eax
   1226e:	29 d8                	sub    %ebx,%eax
   12270:	83 c4 10             	add    $0x10,%esp
   12273:	89 c1                	mov    %eax,%ecx
   12275:	89 47 48             	mov    %eax,0x48(%edi)
   12278:	eb 82                	jmp    121fc <_NpfsRead@8+0x13c>
   1227a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
   12280:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   12283:	85 c0                	test   %eax,%eax
   12285:	0f 85 b5 fe ff ff    	jne    12140 <_NpfsRead@8+0x80>
   1228b:	83 7f 38 03          	cmpl   $0x3,0x38(%edi)
   1228f:	0f 84 15 01 00 00    	je     123aa <_NpfsRead@8+0x2ea>
   12295:	83 ec 0c             	sub    $0xc,%esp
   12298:	8d 47 24             	lea    0x24(%edi),%eax
   1229b:	50                   	push   %eax
   1229c:	e8 8f 06 00 00       	call   12930 <_KeResetEvent@4>
   122a1:	83 c4 0c             	add    $0xc,%esp
   122a4:	31 c0                	xor    %eax,%eax
   122a6:	8b 5d d4             	mov    0xffffffd4(%ebp),%ebx
   122a9:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   122ac:	56                   	push   %esi
   122ad:	56                   	push   %esi
   122ae:	50                   	push   %eax
   122af:	53                   	push   %ebx
   122b0:	e8 1b 07 00 00       	call   129d0 <_KeReleaseSpinLock@8>
   122b5:	5a                   	pop    %edx
   122b6:	59                   	pop    %ecx
   122b7:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   122ba:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   122bd:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
   122c0:	89 41 18             	mov    %eax,0x18(%ecx)
   122c3:	89 51 1c             	mov    %edx,0x1c(%ecx)
   122c6:	50                   	push   %eax
   122c7:	50                   	push   %eax
   122c8:	6a 00                	push   $0x0
   122ca:	51                   	push   %ecx
   122cb:	e8 d0 05 00 00       	call   128a0 <_IoCompleteRequest@8>
   122d0:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   122d3:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   122d6:	5b                   	pop    %ebx
   122d7:	5e                   	pop    %esi
   122d8:	5f                   	pop    %edi
   122d9:	5d                   	pop    %ebp
   122da:	c2 08 00             	ret    $0x8
   122dd:	8d 76 00             	lea    0x0(%esi),%esi
   122e0:	8b 47 3c             	mov    0x3c(%edi),%eax
   122e3:	85 c0                	test   %eax,%eax
   122e5:	74 59                	je     12340 <_NpfsRead@8+0x280>
   122e7:	89 c6                	mov    %eax,%esi
   122e9:	3b 45 dc             	cmp    0xffffffdc(%ebp),%eax
   122ec:	76 03                	jbe    122f1 <_NpfsRead@8+0x231>
   122ee:	8b 75 dc             	mov    0xffffffdc(%ebp),%esi
   122f1:	50                   	push   %eax
   122f2:	56                   	push   %esi
   122f3:	8b 47 44             	mov    0x44(%edi),%eax
   122f6:	50                   	push   %eax
   122f7:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   122fa:	50                   	push   %eax
   122fb:	e8 80 06 00 00       	call   12980 <_memcpy>
   12300:	8b 47 3c             	mov    0x3c(%edi),%eax
   12303:	83 c4 10             	add    $0x10,%esp
   12306:	89 75 e8             	mov    %esi,0xffffffe8(%ebp)
   12309:	3b 45 dc             	cmp    0xffffffdc(%ebp),%eax
   1230c:	76 4d                	jbe    1235b <_NpfsRead@8+0x29b>
   1230e:	8b 4d dc             	mov    0xffffffdc(%ebp),%ecx
   12311:	29 c8                	sub    %ecx,%eax
   12313:	53                   	push   %ebx
   12314:	50                   	push   %eax
   12315:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   12318:	8b 57 44             	mov    0x44(%edi),%edx
   1231b:	01 d0                	add    %edx,%eax
   1231d:	50                   	push   %eax
   1231e:	8b 47 44             	mov    0x44(%edi),%eax
   12321:	50                   	push   %eax
   12322:	e8 69 06 00 00       	call   12990 <_memmove>
   12327:	8b 47 3c             	mov    0x3c(%edi),%eax
   1232a:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
   1232d:	29 d0                	sub    %edx,%eax
   1232f:	c7 45 ec 05 01 00 00 	movl   $0x105,0xffffffec(%ebp)
   12336:	89 47 3c             	mov    %eax,0x3c(%edi)
   12339:	83 c4 10             	add    $0x10,%esp
   1233c:	8d 74 26 00          	lea    0x0(%esi),%esi
   12340:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
   12343:	85 c0                	test   %eax,%eax
   12345:	0f 84 f5 fd ff ff    	je     12140 <_NpfsRead@8+0x80>
   1234b:	e9 54 ff ff ff       	jmp    122a4 <_NpfsRead@8+0x1e4>
   12350:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
   12353:	89 4f 48             	mov    %ecx,0x48(%edi)
   12356:	e9 a1 fe ff ff       	jmp    121fc <_NpfsRead@8+0x13c>
   1235b:	83 ec 0c             	sub    $0xc,%esp
   1235e:	8d 47 24             	lea    0x24(%edi),%eax
   12361:	50                   	push   %eax
   12362:	e8 c9 05 00 00       	call   12930 <_KeResetEvent@4>
   12367:	83 c4 0c             	add    $0xc,%esp
   1236a:	83 7f 38 03          	cmpl   $0x3,0x38(%edi)
   1236e:	74 51                	je     123c1 <_NpfsRead@8+0x301>
   12370:	8b 47 50             	mov    0x50(%edi),%eax
   12373:	c7 47 3c 00 00 00 00 	movl   $0x0,0x3c(%edi)
   1237a:	89 47 40             	mov    %eax,0x40(%edi)
   1237d:	eb c1                	jmp    12340 <_NpfsRead@8+0x280>
   1237f:	50                   	push   %eax
   12380:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   12383:	6a 00                	push   $0x0
   12385:	83 c0 24             	add    $0x24,%eax
   12388:	6a 00                	push   $0x0
   1238a:	50                   	push   %eax
   1238b:	e8 70 05 00 00       	call   12900 <_KeSetEvent@12>
   12390:	58                   	pop    %eax
   12391:	e9 bb fd ff ff       	jmp    12151 <_NpfsRead@8+0x91>
   12396:	51                   	push   %ecx
   12397:	51                   	push   %ecx
   12398:	6a 00                	push   $0x0
   1239a:	52                   	push   %edx
   1239b:	e8 d0 05 00 00       	call   12970 <_MmMapLockedPages@8>
   123a0:	5e                   	pop    %esi
   123a1:	5a                   	pop    %edx
   123a2:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
   123a5:	e9 7d fd ff ff       	jmp    12127 <_NpfsRead@8+0x67>
   123aa:	50                   	push   %eax
   123ab:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   123ae:	6a 00                	push   $0x0
   123b0:	83 c0 24             	add    $0x24,%eax
   123b3:	6a 00                	push   $0x0
   123b5:	50                   	push   %eax
   123b6:	e8 45 05 00 00       	call   12900 <_KeSetEvent@12>
   123bb:	58                   	pop    %eax
   123bc:	e9 d4 fe ff ff       	jmp    12295 <_NpfsRead@8+0x1d5>
   123c1:	50                   	push   %eax
   123c2:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   123c5:	6a 00                	push   $0x0
   123c7:	83 c0 24             	add    $0x24,%eax
   123ca:	6a 00                	push   $0x0
   123cc:	50                   	push   %eax
   123cd:	e8 2e 05 00 00       	call   12900 <_KeSetEvent@12>
   123d2:	58                   	pop    %eax
   123d3:	eb 9b                	jmp    12370 <_NpfsRead@8+0x2b0>
   123d5:	c7 45 ec 4b 01 00 c0 	movl   $0xc000014b,0xffffffec(%ebp)
   123dc:	e9 d6 fe ff ff       	jmp    122b7 <_NpfsRead@8+0x1f7>
   123e1:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
   123e8:	e9 ca fe ff ff       	jmp    122b7 <_NpfsRead@8+0x1f7>
   123ed:	8d 76 00             	lea    0x0(%esi),%esi

000123f0 <_NpfsWrite@8>:
   123f0:	55                   	push   %ebp
   123f1:	89 e5                	mov    %esp,%ebp
   123f3:	57                   	push   %edi
   123f4:	56                   	push   %esi
   123f5:	53                   	push   %ebx
   123f6:	83 ec 2c             	sub    $0x2c,%esp
   123f9:	c7 45 e0 00 00 00 00 	movl   $0x0,0xffffffe0(%ebp)
   12400:	8b 45 0c             	mov    0xc(%ebp),%eax
   12403:	8b 50 60             	mov    0x60(%eax),%edx
   12406:	8b 42 18             	mov    0x18(%edx),%eax
   12409:	8b 40 0c             	mov    0xc(%eax),%eax
   1240c:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
   1240f:	8b 48 10             	mov    0x10(%eax),%ecx
   12412:	8b 78 08             	mov    0x8(%eax),%edi
   12415:	89 4d e8             	mov    %ecx,0xffffffe8(%ebp)
   12418:	8b 45 0c             	mov    0xc(%ebp),%eax
   1241b:	8b 52 04             	mov    0x4(%edx),%edx
   1241e:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
   12425:	89 55 dc             	mov    %edx,0xffffffdc(%ebp)
   12428:	8b 50 04             	mov    0x4(%eax),%edx
   1242b:	85 d2                	test   %edx,%edx
   1242d:	0f 84 32 01 00 00    	je     12565 <_NpfsWrite@8+0x175>
   12433:	85 ff                	test   %edi,%edi
   12435:	0f 84 83 02 00 00    	je     126be <_NpfsWrite@8+0x2ce>
   1243b:	8b 5f 44             	mov    0x44(%edi),%ebx
   1243e:	85 db                	test   %ebx,%ebx
   12440:	0f 84 1f 01 00 00    	je     12565 <_NpfsWrite@8+0x175>
   12446:	66 8b 42 06          	mov    0x6(%edx),%ax
   1244a:	a8 05                	test   $0x5,%al
   1244c:	0f 84 58 02 00 00    	je     126aa <_NpfsWrite@8+0x2ba>
   12452:	8b 52 0c             	mov    0xc(%edx),%edx
   12455:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
   12458:	8d 4d f3             	lea    0xfffffff3(%ebp),%ecx
   1245b:	8d 47 54             	lea    0x54(%edi),%eax
   1245e:	53                   	push   %ebx
   1245f:	53                   	push   %ebx
   12460:	51                   	push   %ecx
   12461:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
   12464:	50                   	push   %eax
   12465:	e8 56 05 00 00       	call   129c0 <_KeAcquireSpinLock@8>
   1246a:	5a                   	pop    %edx
   1246b:	8d 57 24             	lea    0x24(%edi),%edx
   1246e:	59                   	pop    %ecx
   1246f:	89 55 d0             	mov    %edx,0xffffffd0(%ebp)
   12472:	8b 47 40             	mov    0x40(%edi),%eax
   12475:	85 c0                	test   %eax,%eax
   12477:	0f 84 c5 01 00 00    	je     12642 <_NpfsWrite@8+0x252>
   1247d:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
   12480:	8b 41 50             	mov    0x50(%ecx),%eax
   12483:	85 c0                	test   %eax,%eax
   12485:	0f 85 07 01 00 00    	jne    12592 <_NpfsWrite@8+0x1a2>
   1248b:	8b 75 dc             	mov    0xffffffdc(%ebp),%esi
   1248e:	85 f6                	test   %esi,%esi
   12490:	0f 84 38 01 00 00    	je     125ce <_NpfsWrite@8+0x1de>
   12496:	8b 47 40             	mov    0x40(%edi),%eax
   12499:	85 c0                	test   %eax,%eax
   1249b:	0f 84 8f 01 00 00    	je     12630 <_NpfsWrite@8+0x240>
   124a1:	8b 57 44             	mov    0x44(%edi),%edx
   124a4:	8b 4f 4c             	mov    0x4c(%edi),%ecx
   124a7:	89 55 d4             	mov    %edx,0xffffffd4(%ebp)
   124aa:	eb 61                	jmp    1250d <_NpfsWrite@8+0x11d>
   124ac:	8d 74 26 00          	lea    0x0(%esi),%esi
   124b0:	50                   	push   %eax
   124b1:	56                   	push   %esi
   124b2:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   124b5:	50                   	push   %eax
   124b6:	51                   	push   %ecx
   124b7:	e8 c4 04 00 00       	call   12980 <_memcpy>
   124bc:	8b 47 44             	mov    0x44(%edi),%eax
   124bf:	8b 57 4c             	mov    0x4c(%edi),%edx
   124c2:	8b 5f 50             	mov    0x50(%edi),%ebx
   124c5:	01 f2                	add    %esi,%edx
   124c7:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
   124ca:	01 d8                	add    %ebx,%eax
   124cc:	83 c4 10             	add    $0x10,%esp
   124cf:	89 d1                	mov    %edx,%ecx
   124d1:	39 c2                	cmp    %eax,%edx
   124d3:	0f 84 4a 01 00 00    	je     12623 <_NpfsWrite@8+0x233>
   124d9:	89 57 4c             	mov    %edx,0x4c(%edi)
   124dc:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   124df:	01 f0                	add    %esi,%eax
   124e1:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   124e4:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   124e7:	01 f0                	add    %esi,%eax
   124e9:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
   124ec:	8b 47 3c             	mov    0x3c(%edi),%eax
   124ef:	01 f0                	add    %esi,%eax
   124f1:	89 47 3c             	mov    %eax,0x3c(%edi)
   124f4:	8b 47 40             	mov    0x40(%edi),%eax
   124f7:	29 f0                	sub    %esi,%eax
   124f9:	29 75 dc             	sub    %esi,0xffffffdc(%ebp)
   124fc:	89 47 40             	mov    %eax,0x40(%edi)
   124ff:	0f 84 c9 00 00 00    	je     125ce <_NpfsWrite@8+0x1de>
   12505:	85 c0                	test   %eax,%eax
   12507:	0f 84 23 01 00 00    	je     12630 <_NpfsWrite@8+0x240>
   1250d:	89 c6                	mov    %eax,%esi
   1250f:	3b 45 dc             	cmp    0xffffffdc(%ebp),%eax
   12512:	76 03                	jbe    12517 <_NpfsWrite@8+0x127>
   12514:	8b 75 dc             	mov    0xffffffdc(%ebp),%esi
   12517:	8b 55 d4             	mov    0xffffffd4(%ebp),%edx
   1251a:	8b 5f 50             	mov    0x50(%edi),%ebx
   1251d:	8d 04 31             	lea    (%ecx,%esi,1),%eax
   12520:	01 da                	add    %ebx,%edx
   12522:	39 d0                	cmp    %edx,%eax
   12524:	76 8a                	jbe    124b0 <_NpfsWrite@8+0xc0>
   12526:	89 d3                	mov    %edx,%ebx
   12528:	29 cb                	sub    %ecx,%ebx
   1252a:	52                   	push   %edx
   1252b:	53                   	push   %ebx
   1252c:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
   1252f:	50                   	push   %eax
   12530:	51                   	push   %ecx
   12531:	e8 4a 04 00 00       	call   12980 <_memcpy>
   12536:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   12539:	83 c4 0c             	add    $0xc,%esp
   1253c:	89 f0                	mov    %esi,%eax
   1253e:	8d 14 0b             	lea    (%ebx,%ecx,1),%edx
   12541:	29 d8                	sub    %ebx,%eax
   12543:	50                   	push   %eax
   12544:	52                   	push   %edx
   12545:	8b 47 44             	mov    0x44(%edi),%eax
   12548:	50                   	push   %eax
   12549:	e8 32 04 00 00       	call   12980 <_memcpy>
   1254e:	8b 47 44             	mov    0x44(%edi),%eax
   12551:	83 c4 10             	add    $0x10,%esp
   12554:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
   12557:	01 f0                	add    %esi,%eax
   12559:	29 d8                	sub    %ebx,%eax
   1255b:	89 c1                	mov    %eax,%ecx
   1255d:	89 47 4c             	mov    %eax,0x4c(%edi)
   12560:	e9 77 ff ff ff       	jmp    124dc <_NpfsWrite@8+0xec>
   12565:	c7 45 e0 01 00 00 c0 	movl   $0xc0000001,0xffffffe0(%ebp)
   1256c:	8b 55 0c             	mov    0xc(%ebp),%edx
   1256f:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   12572:	8b 4d e0             	mov    0xffffffe0(%ebp),%ecx
   12575:	89 42 1c             	mov    %eax,0x1c(%edx)
   12578:	89 4a 18             	mov    %ecx,0x18(%edx)
   1257b:	56                   	push   %esi
   1257c:	56                   	push   %esi
   1257d:	6a 00                	push   $0x0
   1257f:	52                   	push   %edx
   12580:	e8 1b 03 00 00       	call   128a0 <_IoCompleteRequest@8>
   12585:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   12588:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1258b:	5b                   	pop    %ebx
   1258c:	5e                   	pop    %esi
   1258d:	5f                   	pop    %edi
   1258e:	5d                   	pop    %ebp
   1258f:	c2 08 00             	ret    $0x8
   12592:	8b 75 dc             	mov    0xffffffdc(%ebp),%esi
   12595:	85 f6                	test   %esi,%esi
   12597:	74 2a                	je     125c3 <_NpfsWrite@8+0x1d3>
   12599:	8b 77 40             	mov    0x40(%edi),%esi
   1259c:	3b 75 dc             	cmp    0xffffffdc(%ebp),%esi
   1259f:	76 03                	jbe    125a4 <_NpfsWrite@8+0x1b4>
   125a1:	8b 75 dc             	mov    0xffffffdc(%ebp),%esi
   125a4:	53                   	push   %ebx
   125a5:	56                   	push   %esi
   125a6:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
   125a9:	51                   	push   %ecx
   125aa:	8b 57 44             	mov    0x44(%edi),%edx
   125ad:	52                   	push   %edx
   125ae:	e8 cd 03 00 00       	call   12980 <_memcpy>
   125b3:	89 75 d8             	mov    %esi,0xffffffd8(%ebp)
   125b6:	89 77 3c             	mov    %esi,0x3c(%edi)
   125b9:	c7 47 40 00 00 00 00 	movl   $0x0,0x40(%edi)
   125c0:	83 c4 10             	add    $0x10,%esp
   125c3:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   125c6:	85 c0                	test   %eax,%eax
   125c8:	0f 84 a4 fe ff ff    	je     12472 <_NpfsWrite@8+0x82>
   125ce:	50                   	push   %eax
   125cf:	6a 00                	push   $0x0
   125d1:	6a 00                	push   $0x0
   125d3:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
   125d6:	50                   	push   %eax
   125d7:	e8 24 03 00 00       	call   12900 <_KeSetEvent@12>
   125dc:	50                   	push   %eax
   125dd:	50                   	push   %eax
   125de:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   125e1:	83 c0 24             	add    $0x24,%eax
   125e4:	50                   	push   %eax
   125e5:	e8 46 03 00 00       	call   12930 <_KeResetEvent@4>
   125ea:	31 c0                	xor    %eax,%eax
   125ec:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   125ef:	89 04 24             	mov    %eax,(%esp)
   125f2:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
   125f5:	50                   	push   %eax
   125f6:	e8 d5 03 00 00       	call   129d0 <_KeReleaseSpinLock@8>
   125fb:	8b 55 0c             	mov    0xc(%ebp),%edx
   125fe:	8b 4d e0             	mov    0xffffffe0(%ebp),%ecx
   12601:	5f                   	pop    %edi
   12602:	58                   	pop    %eax
   12603:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
   12606:	89 4a 18             	mov    %ecx,0x18(%edx)
   12609:	89 42 1c             	mov    %eax,0x1c(%edx)
   1260c:	56                   	push   %esi
   1260d:	56                   	push   %esi
   1260e:	6a 00                	push   $0x0
   12610:	52                   	push   %edx
   12611:	e8 8a 02 00 00       	call   128a0 <_IoCompleteRequest@8>
   12616:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   12619:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   1261c:	5b                   	pop    %ebx
   1261d:	5e                   	pop    %esi
   1261e:	5f                   	pop    %edi
   1261f:	5d                   	pop    %ebp
   12620:	c2 08 00             	ret    $0x8
   12623:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
   12626:	89 4f 4c             	mov    %ecx,0x4c(%edi)
   12629:	e9 ae fe ff ff       	jmp    124dc <_NpfsWrite@8+0xec>
   1262e:	89 f6                	mov    %esi,%esi
   12630:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
   12633:	85 c0                	test   %eax,%eax
   12635:	74 97                	je     125ce <_NpfsWrite@8+0x1de>
   12637:	8b 47 40             	mov    0x40(%edi),%eax
   1263a:	85 c0                	test   %eax,%eax
   1263c:	0f 85 3b fe ff ff    	jne    1247d <_NpfsWrite@8+0x8d>
   12642:	50                   	push   %eax
   12643:	6a 00                	push   $0x0
   12645:	6a 00                	push   $0x0
   12647:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
   1264a:	50                   	push   %eax
   1264b:	e8 b0 02 00 00       	call   12900 <_KeSetEvent@12>
   12650:	50                   	push   %eax
   12651:	31 c0                	xor    %eax,%eax
   12653:	8a 45 f3             	mov    0xfffffff3(%ebp),%al
   12656:	50                   	push   %eax
   12657:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
   1265a:	50                   	push   %eax
   1265b:	e8 70 03 00 00       	call   129d0 <_KeReleaseSpinLock@8>
   12660:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
   12663:	5e                   	pop    %esi
   12664:	58                   	pop    %eax
   12665:	83 79 38 03          	cmpl   $0x3,0x38(%ecx)
   12669:	0f 85 95 00 00 00    	jne    12704 <_NpfsWrite@8+0x314>
   1266f:	83 ec 0c             	sub    $0xc,%esp
   12672:	89 c8                	mov    %ecx,%eax
   12674:	83 c0 24             	add    $0x24,%eax
   12677:	6a 00                	push   $0x0
   12679:	6a 00                	push   $0x0
   1267b:	6a 00                	push   $0x0
   1267d:	6a 06                	push   $0x6
   1267f:	50                   	push   %eax
   12680:	e8 cb 01 00 00       	call   12850 <_KeWaitForSingleObject@20>
   12685:	83 c4 0c             	add    $0xc,%esp
   12688:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   1268b:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
   1268e:	83 78 38 03          	cmpl   $0x3,0x38(%eax)
   12692:	75 70                	jne    12704 <_NpfsWrite@8+0x314>
   12694:	8d 55 f3             	lea    0xfffffff3(%ebp),%edx
   12697:	53                   	push   %ebx
   12698:	53                   	push   %ebx
   12699:	52                   	push   %edx
   1269a:	8b 4d cc             	mov    0xffffffcc(%ebp),%ecx
   1269d:	51                   	push   %ecx
   1269e:	e8 1d 03 00 00       	call   129c0 <_KeAcquireSpinLock@8>
   126a3:	58                   	pop    %eax
   126a4:	5a                   	pop    %edx
   126a5:	e9 d3 fd ff ff       	jmp    1247d <_NpfsWrite@8+0x8d>
   126aa:	51                   	push   %ecx
   126ab:	51                   	push   %ecx
   126ac:	6a 00                	push   $0x0
   126ae:	52                   	push   %edx
   126af:	e8 bc 02 00 00       	call   12970 <_MmMapLockedPages@8>
   126b4:	5e                   	pop    %esi
   126b5:	5a                   	pop    %edx
   126b6:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
   126b9:	e9 9a fd ff ff       	jmp    12458 <_NpfsWrite@8+0x68>
   126be:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
   126c1:	c7 45 e0 b3 00 00 c0 	movl   $0xc00000b3,0xffffffe0(%ebp)
   126c8:	8b 42 38             	mov    0x38(%edx),%eax
   126cb:	83 f8 02             	cmp    $0x2,%eax
   126ce:	0f 84 98 fe ff ff    	je     1256c <_NpfsWrite@8+0x17c>
   126d4:	48                   	dec    %eax
   126d5:	0f 94 c0             	sete   %al
   126d8:	25 ff 00 00 00       	and    $0xff,%eax
   126dd:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   126e0:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
   126e3:	48                   	dec    %eax
   126e4:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
   126e7:	8b 7d e0             	mov    0xffffffe0(%ebp),%edi
   126ea:	81 e7 51 ff ff ff    	and    $0xffffff51,%edi
   126f0:	89 7d e0             	mov    %edi,0xffffffe0(%ebp)
   126f3:	8b 75 e0             	mov    0xffffffe0(%ebp),%esi
   126f6:	81 ee 50 ff ff 3f    	sub    $0x3fffff50,%esi
   126fc:	89 75 e0             	mov    %esi,0xffffffe0(%ebp)
   126ff:	e9 68 fe ff ff       	jmp    1256c <_NpfsWrite@8+0x17c>
   12704:	c7 45 e0 4b 01 00 c0 	movl   $0xc000014b,0xffffffe0(%ebp)
   1270b:	e9 5c fe ff ff       	jmp    1256c <_NpfsWrite@8+0x17c>

00012710 <_NpfsQueryVolumeInformation@8>:
   12710:	55                   	push   %ebp
   12711:	89 e5                	mov    %esp,%ebp
   12713:	57                   	push   %edi
   12714:	56                   	push   %esi
   12715:	53                   	push   %ebx
   12716:	83 ec 0c             	sub    $0xc,%esp
   12719:	8b 75 08             	mov    0x8(%ebp),%esi
   1271c:	85 f6                	test   %esi,%esi
   1271e:	0f 84 e4 00 00 00    	je     12808 <_NpfsQueryVolumeInformation@8+0xf8>
   12724:	8b 5d 0c             	mov    0xc(%ebp),%ebx
   12727:	85 db                	test   %ebx,%ebx
   12729:	0f 84 f4 00 00 00    	je     12823 <_NpfsQueryVolumeInformation@8+0x113>
   1272f:	8b 45 0c             	mov    0xc(%ebp),%eax
   12732:	8b 78 60             	mov    0x60(%eax),%edi
   12735:	8b 40 0c             	mov    0xc(%eax),%eax
   12738:	8b 57 08             	mov    0x8(%edi),%edx
   1273b:	8b 77 04             	mov    0x4(%edi),%esi
   1273e:	83 fa 04             	cmp    $0x4,%edx
   12741:	74 3d                	je     12780 <_NpfsQueryVolumeInformation@8+0x70>
   12743:	83 fa 05             	cmp    $0x5,%edx
   12746:	0f 84 84 00 00 00    	je     127d0 <_NpfsQueryVolumeInformation@8+0xc0>
   1274c:	8b 45 0c             	mov    0xc(%ebp),%eax
   1274f:	bb bb 00 00 c0       	mov    $0xc00000bb,%ebx
   12754:	85 db                	test   %ebx,%ebx
   12756:	89 58 18             	mov    %ebx,0x18(%eax)
   12759:	78 51                	js     127ac <_NpfsQueryVolumeInformation@8+0x9c>
   1275b:	8b 47 04             	mov    0x4(%edi),%eax
   1275e:	8b 55 0c             	mov    0xc(%ebp),%edx
   12761:	29 f0                	sub    %esi,%eax
   12763:	89 42 1c             	mov    %eax,0x1c(%edx)
   12766:	52                   	push   %edx
   12767:	52                   	push   %edx
   12768:	6a 00                	push   $0x0
   1276a:	8b 45 0c             	mov    0xc(%ebp),%eax
   1276d:	50                   	push   %eax
   1276e:	e8 2d 01 00 00       	call   128a0 <_IoCompleteRequest@8>
   12773:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   12776:	89 d8                	mov    %ebx,%eax
   12778:	5b                   	pop    %ebx
   12779:	5e                   	pop    %esi
   1277a:	5f                   	pop    %edi
   1277b:	5d                   	pop    %ebp
   1277c:	c2 08 00             	ret    $0x8
   1277f:	90                   	nop    
   12780:	ba 05 00 00 80       	mov    $0x80000005,%edx
   12785:	83 fe 07             	cmp    $0x7,%esi
   12788:	76 16                	jbe    127a0 <_NpfsQueryVolumeInformation@8+0x90>
   1278a:	c7 00 11 00 00 00    	movl   $0x11,(%eax)
   12790:	c7 40 04 00 00 00 00 	movl   $0x0,0x4(%eax)
   12797:	83 ee 08             	sub    $0x8,%esi
   1279a:	31 d2                	xor    %edx,%edx
   1279c:	8d 74 26 00          	lea    0x0(%esi),%esi
   127a0:	8b 45 0c             	mov    0xc(%ebp),%eax
   127a3:	89 d3                	mov    %edx,%ebx
   127a5:	85 db                	test   %ebx,%ebx
   127a7:	89 58 18             	mov    %ebx,0x18(%eax)
   127aa:	79 af                	jns    1275b <_NpfsQueryVolumeInformation@8+0x4b>
   127ac:	8b 4d 0c             	mov    0xc(%ebp),%ecx
   127af:	c7 41 1c 00 00 00 00 	movl   $0x0,0x1c(%ecx)
   127b6:	52                   	push   %edx
   127b7:	52                   	push   %edx
   127b8:	6a 00                	push   $0x0
   127ba:	8b 45 0c             	mov    0xc(%ebp),%eax
   127bd:	50                   	push   %eax
   127be:	e8 dd 00 00 00       	call   128a0 <_IoCompleteRequest@8>
   127c3:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
   127c6:	89 d8                	mov    %ebx,%eax
   127c8:	5b                   	pop    %ebx
   127c9:	5e                   	pop    %esi
   127ca:	5f                   	pop    %edi
   127cb:	5d                   	pop    %ebp
   127cc:	c2 08 00             	ret    $0x8
   127cf:	90                   	nop    
   127d0:	ba 05 00 00 80       	mov    $0x80000005,%edx
   127d5:	83 fe 13             	cmp    $0x13,%esi
   127d8:	76 c6                	jbe    127a0 <_NpfsQueryVolumeInformation@8+0x90>
   127da:	c7 00 02 00 00 00    	movl   $0x2,(%eax)
   127e0:	c7 40 04 ff 00 00 00 	movl   $0xff,0x4(%eax)
   127e7:	c7 40 08 08 00 00 00 	movl   $0x8,0x8(%eax)
   127ee:	83 c0 0c             	add    $0xc,%eax
   127f1:	51                   	push   %ecx
   127f2:	51                   	push   %ecx
   127f3:	68 70 30 01 00       	push   $0x13070
   127f8:	50                   	push   %eax
   127f9:	e8 b2 01 00 00       	call   129b0 <_wcscpy>
   127fe:	83 ee 14             	sub    $0x14,%esi
   12801:	83 c4 10             	add    $0x10,%esp
   12804:	31 d2                	xor    %edx,%edx
   12806:	eb 98                	jmp    127a0 <_NpfsQueryVolumeInformation@8+0x90>
   12808:	68 7a 30 01 00       	push   $0x1307a
   1280d:	6a 4d                	push   $0x4d
   1280f:	68 7b 30 01 00       	push   $0x1307b
   12814:	68 84 30 01 00       	push   $0x13084
   12819:	e8 82 01 00 00       	call   129a0 <_RtlAssert@16>
   1281e:	e9 01 ff ff ff       	jmp    12724 <_NpfsQueryVolumeInformation@8+0x14>
   12823:	68 7a 30 01 00       	push   $0x1307a
   12828:	6a 4e                	push   $0x4e
   1282a:	68 7b 30 01 00       	push   $0x1307b
   1282f:	68 84 30 01 00       	push   $0x13084
   12834:	e8 67 01 00 00       	call   129a0 <_RtlAssert@16>
   12839:	e9 f1 fe ff ff       	jmp    1272f <_NpfsQueryVolumeInformation@8+0x1f>
   1283e:	90                   	nop    
   1283f:	90                   	nop    

00012840 <_RtlCompareUnicodeString@12>:
   12840:	ff 25 08 41 01 00    	jmp    *0x14108
   12846:	90                   	nop    
   12847:	90                   	nop    
	...

00012850 <_KeWaitForSingleObject@20>:
   12850:	ff 25 fc 40 01 00    	jmp    *0x140fc
   12856:	90                   	nop    
   12857:	90                   	nop    
	...

00012860 <_KeReleaseMutex@8>:
   12860:	ff 25 f0 40 01 00    	jmp    *0x140f0
   12866:	90                   	nop    
   12867:	90                   	nop    
	...

00012870 <_ExAllocatePool@8>:
   12870:	ff 25 d0 40 01 00    	jmp    *0x140d0
   12876:	90                   	nop    
   12877:	90                   	nop    
	...

00012880 <_KeInitializeSpinLock@4>:
   12880:	ff 25 ec 40 01 00    	jmp    *0x140ec
   12886:	90                   	nop    
   12887:	90                   	nop    
	...

00012890 <_KeInitializeEvent@12>:
   12890:	ff 25 e4 40 01 00    	jmp    *0x140e4
   12896:	90                   	nop    
   12897:	90                   	nop    
	...

000128a0 <_IoCompleteRequest@8>:
   128a0:	ff 25 d8 40 01 00    	jmp    *0x140d8
   128a6:	90                   	nop    
   128a7:	90                   	nop    
	...

000128b0 <_ExFreePool@4>:
   128b0:	ff 25 d4 40 01 00    	jmp    *0x140d4
   128b6:	90                   	nop    
   128b7:	90                   	nop    
	...

000128c0 <@InterlockedExchange@8>:
   128c0:	ff 25 c8 40 01 00    	jmp    *0x140c8
   128c6:	90                   	nop    
   128c7:	90                   	nop    
	...

000128d0 <_RtlCreateUnicodeString@8>:
   128d0:	ff 25 0c 41 01 00    	jmp    *0x1410c
   128d6:	90                   	nop    
   128d7:	90                   	nop    
	...

000128e0 <_KeInitializeMutex@8>:
   128e0:	ff 25 e8 40 01 00    	jmp    *0x140e8
   128e6:	90                   	nop    
   128e7:	90                   	nop    
	...

000128f0 <_RtlFreeUnicodeString@4>:
   128f0:	ff 25 10 41 01 00    	jmp    *0x14110
   128f6:	90                   	nop    
   128f7:	90                   	nop    
	...

00012900 <_KeSetEvent@12>:
   12900:	ff 25 f8 40 01 00    	jmp    *0x140f8
   12906:	90                   	nop    
   12907:	90                   	nop    
	...

00012910 <_RtlZeroMemory@8>:
   12910:	ff 25 18 41 01 00    	jmp    *0x14118
   12916:	90                   	nop    
   12917:	90                   	nop    
	...

00012920 <_IoReleaseCancelSpinLock@4>:
   12920:	ff 25 e0 40 01 00    	jmp    *0x140e0
   12926:	90                   	nop    
   12927:	90                   	nop    
	...

00012930 <_KeResetEvent@4>:
   12930:	ff 25 f4 40 01 00    	jmp    *0x140f4
   12936:	90                   	nop    
   12937:	90                   	nop    
	...

00012940 <_DbgPrint>:
   12940:	ff 25 cc 40 01 00    	jmp    *0x140cc
   12946:	90                   	nop    
   12947:	90                   	nop    
	...

00012950 <_RtlInitUnicodeString@8>:
   12950:	ff 25 14 41 01 00    	jmp    *0x14114
   12956:	90                   	nop    
   12957:	90                   	nop    
	...

00012960 <_IoCreateDevice@28>:
   12960:	ff 25 dc 40 01 00    	jmp    *0x140dc
   12966:	90                   	nop    
   12967:	90                   	nop    
	...

00012970 <_MmMapLockedPages@8>:
   12970:	ff 25 00 41 01 00    	jmp    *0x14100
   12976:	90                   	nop    
   12977:	90                   	nop    
	...

00012980 <_memcpy>:
   12980:	ff 25 1c 41 01 00    	jmp    *0x1411c
   12986:	90                   	nop    
   12987:	90                   	nop    
	...

00012990 <_memmove>:
   12990:	ff 25 20 41 01 00    	jmp    *0x14120
   12996:	90                   	nop    
   12997:	90                   	nop    
	...

000129a0 <_RtlAssert@16>:
   129a0:	ff 25 04 41 01 00    	jmp    *0x14104
   129a6:	90                   	nop    
   129a7:	90                   	nop    
	...

000129b0 <_wcscpy>:
   129b0:	ff 25 24 41 01 00    	jmp    *0x14124
   129b6:	90                   	nop    
   129b7:	90                   	nop    
	...

000129c0 <_KeAcquireSpinLock@8>:
   129c0:	ff 25 b8 40 01 00    	jmp    *0x140b8
   129c6:	90                   	nop    
   129c7:	90                   	nop    
	...

000129d0 <_KeReleaseSpinLock@8>:
   129d0:	ff 25 bc 40 01 00    	jmp    *0x140bc
   129d6:	90                   	nop    
   129d7:	90                   	nop    
	...

000129e0 <__CTOR_LIST__>:
   129e0:	ff                   	(bad)  
   129e1:	ff                   	(bad)  
   129e2:	ff                   	(bad)  
   129e3:	ff 00                	incl   (%eax)
   129e5:	00 00                	add    %al,(%eax)
	...

000129e8 <__DTOR_LIST__>:
   129e8:	ff                   	(bad)  
   129e9:	ff                   	(bad)  
   129ea:	ff                   	(bad)  
   129eb:	ff 00                	incl   (%eax)
   129ed:	00 00                	add    %al,(%eax)
	...
