
win32csr.nostrip.dll:     file format pei-i386

Disassembly of section .text:

5ffb1000 <_DllMain@12>:
BOOL STDCALL
DllMain(HANDLE hDll,
	DWORD dwReason,
	LPVOID lpReserved)
{
5ffb1000:	55                   	push   %ebp
5ffb1001:	89 e5                	mov    %esp,%ebp
  if (DLL_PROCESS_ATTACH == dwReason)
5ffb1003:	83 7d 0c 01          	cmpl   $0x1,0xc(%ebp)
5ffb1007:	74 09                	je     5ffb1012 <_DllMain@12+0x12>
    {
      Win32CsrDllHandle = hDll;
    }

  return TRUE;
}
5ffb1009:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb100e:	5d                   	pop    %ebp
5ffb100f:	c2 0c 00             	ret    $0xc
5ffb1012:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb1015:	5d                   	pop    %ebp
5ffb1016:	a3 d0 c1 fb 5f       	mov    %eax,0x5ffbc1d0
5ffb101b:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb1020:	c2 0c 00             	ret    $0xc
5ffb1023:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb1029:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb1030 <@Win32CsrInsertObject@12>:

NTSTATUS FASTCALL
Win32CsrInsertObject(PCSRSS_PROCESS_DATA ProcessData,
                     PHANDLE Handle,
                     Object_t *Object)
{
5ffb1030:	55                   	push   %ebp
5ffb1031:	89 e5                	mov    %esp,%ebp
5ffb1033:	57                   	push   %edi
5ffb1034:	56                   	push   %esi
5ffb1035:	53                   	push   %ebx
5ffb1036:	83 ec 18             	sub    $0x18,%esp
5ffb1039:	89 cf                	mov    %ecx,%edi
5ffb103b:	8b 5d 08             	mov    0x8(%ebp),%ebx
5ffb103e:	89 d6                	mov    %edx,%esi
  InitializeCriticalSection(&(Object->Lock));
5ffb1040:	8d 43 08             	lea    0x8(%ebx),%eax
5ffb1043:	50                   	push   %eax
5ffb1044:	e8 37 7c 00 00       	call   5ffb8c80 <_InitializeCriticalSection@4>

  return (CsrExports.CsrInsertObjectProc)(ProcessData, Handle, Object);
5ffb1049:	58                   	pop    %eax
5ffb104a:	5a                   	pop    %edx
5ffb104b:	53                   	push   %ebx
5ffb104c:	56                   	push   %esi
5ffb104d:	57                   	push   %edi
5ffb104e:	ff 15 00 c0 fb 5f    	call   *0x5ffbc000
}
5ffb1054:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb1057:	5b                   	pop    %ebx
5ffb1058:	5e                   	pop    %esi
5ffb1059:	5f                   	pop    %edi
5ffb105a:	5d                   	pop    %ebp
5ffb105b:	c2 04 00             	ret    $0x4
5ffb105e:	89 f6                	mov    %esi,%esi

5ffb1060 <@Win32CsrGetObject@12>:

NTSTATUS FASTCALL
Win32CsrGetObject(PCSRSS_PROCESS_DATA ProcessData,
                 HANDLE Handle,
                 Object_t **Object)
{
5ffb1060:	55                   	push   %ebp
5ffb1061:	89 e5                	mov    %esp,%ebp
5ffb1063:	83 ec 0c             	sub    $0xc,%esp
  return (CsrExports.CsrGetObjectProc)(ProcessData, Handle, Object);
5ffb1066:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb1069:	50                   	push   %eax
5ffb106a:	52                   	push   %edx
5ffb106b:	51                   	push   %ecx
5ffb106c:	ff 15 04 c0 fb 5f    	call   *0x5ffbc004
}
5ffb1072:	c9                   	leave  
5ffb1073:	c2 04 00             	ret    $0x4
5ffb1076:	8d 76 00             	lea    0x0(%esi),%esi
5ffb1079:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb1080 <@Win32CsrLockObject@16>:

NTSTATUS FASTCALL
Win32CsrLockObject(PCSRSS_PROCESS_DATA ProcessData,
                   HANDLE Handle,
                   Object_t **Object,
                   LONG Type)
{
5ffb1080:	55                   	push   %ebp
5ffb1081:	89 e5                	mov    %esp,%ebp
5ffb1083:	53                   	push   %ebx
5ffb1084:	53                   	push   %ebx
5ffb1085:	53                   	push   %ebx
5ffb1086:	8b 5d 08             	mov    0x8(%ebp),%ebx
  NTSTATUS Status;

  Status = (CsrExports.CsrGetObjectProc)(ProcessData, Handle, Object);
5ffb1089:	53                   	push   %ebx
5ffb108a:	52                   	push   %edx
5ffb108b:	51                   	push   %ecx
5ffb108c:	ff 15 04 c0 fb 5f    	call   *0x5ffbc004
  if (! NT_SUCCESS(Status))
5ffb1092:	5a                   	pop    %edx
5ffb1093:	85 c0                	test   %eax,%eax
    {
      return Status;
5ffb1095:	89 c2                	mov    %eax,%edx
5ffb1097:	78 1c                	js     5ffb10b5 <@Win32CsrLockObject@16+0x35>
    }

  if ((*Object)->Type != Type)
5ffb1099:	8b 0b                	mov    (%ebx),%ecx
5ffb109b:	8b 45 0c             	mov    0xc(%ebp),%eax
    {
      return STATUS_INVALID_HANDLE;
5ffb109e:	ba 08 00 00 c0       	mov    $0xc0000008,%edx
5ffb10a3:	39 01                	cmp    %eax,(%ecx)
5ffb10a5:	75 0e                	jne    5ffb10b5 <@Win32CsrLockObject@16+0x35>
    }

  EnterCriticalSection(&((*Object)->Lock));
5ffb10a7:	83 ec 0c             	sub    $0xc,%esp
5ffb10aa:	8d 41 08             	lea    0x8(%ecx),%eax
5ffb10ad:	50                   	push   %eax
5ffb10ae:	e8 dd 7b 00 00       	call   5ffb8c90 <_EnterCriticalSection@4>

  return STATUS_SUCCESS;
5ffb10b3:	31 d2                	xor    %edx,%edx
}
5ffb10b5:	89 d0                	mov    %edx,%eax
5ffb10b7:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb10ba:	c9                   	leave  
5ffb10bb:	c2 08 00             	ret    $0x8
5ffb10be:	89 f6                	mov    %esi,%esi

5ffb10c0 <@Win32CsrUnlockObject@4>:

VOID FASTCALL
Win32CsrUnlockObject(Object_t *Object)
{
5ffb10c0:	55                   	push   %ebp
  LeaveCriticalSection(&(Object->Lock));
5ffb10c1:	83 c1 08             	add    $0x8,%ecx
5ffb10c4:	89 e5                	mov    %esp,%ebp
5ffb10c6:	83 ec 14             	sub    $0x14,%esp
5ffb10c9:	51                   	push   %ecx
5ffb10ca:	e8 d1 7b 00 00       	call   5ffb8ca0 <_LeaveCriticalSection@4>
5ffb10cf:	c9                   	leave  
5ffb10d0:	c3                   	ret    
5ffb10d1:	eb 0d                	jmp    5ffb10e0 <@Win32CsrReleaseObject@8>
5ffb10d3:	90                   	nop    
5ffb10d4:	90                   	nop    
5ffb10d5:	90                   	nop    
5ffb10d6:	90                   	nop    
5ffb10d7:	90                   	nop    
5ffb10d8:	90                   	nop    
5ffb10d9:	90                   	nop    
5ffb10da:	90                   	nop    
5ffb10db:	90                   	nop    
5ffb10dc:	90                   	nop    
5ffb10dd:	90                   	nop    
5ffb10de:	90                   	nop    
5ffb10df:	90                   	nop    

5ffb10e0 <@Win32CsrReleaseObject@8>:
}

NTSTATUS FASTCALL
Win32CsrReleaseObject(PCSRSS_PROCESS_DATA ProcessData,
                     HANDLE Object)
{
5ffb10e0:	55                   	push   %ebp
5ffb10e1:	89 e5                	mov    %esp,%ebp
5ffb10e3:	83 ec 10             	sub    $0x10,%esp
  return (CsrExports.CsrReleaseObjectProc)(ProcessData, Object);
5ffb10e6:	52                   	push   %edx
5ffb10e7:	51                   	push   %ecx
5ffb10e8:	ff 15 08 c0 fb 5f    	call   *0x5ffbc008
}
5ffb10ee:	c9                   	leave  
5ffb10ef:	c3                   	ret    

5ffb10f0 <_Win32CsrInitComplete@0>:

static BOOL STDCALL
Win32CsrInitComplete(void)
{
5ffb10f0:	55                   	push   %ebp
5ffb10f1:	89 e5                	mov    %esp,%ebp
5ffb10f3:	50                   	push   %eax
5ffb10f4:	50                   	push   %eax
  PrivateCsrssInitialized();
5ffb10f5:	e8 36 7d 00 00       	call   5ffb8e30 <_PrivateCsrssInitialized@0>

  return TRUE;
}
5ffb10fa:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb10ff:	c9                   	leave  
5ffb1100:	c3                   	ret    
5ffb1101:	eb 0d                	jmp    5ffb1110 <_Win32CsrInitialization@20>
5ffb1103:	90                   	nop    
5ffb1104:	90                   	nop    
5ffb1105:	90                   	nop    
5ffb1106:	90                   	nop    
5ffb1107:	90                   	nop    
5ffb1108:	90                   	nop    
5ffb1109:	90                   	nop    
5ffb110a:	90                   	nop    
5ffb110b:	90                   	nop    
5ffb110c:	90                   	nop    
5ffb110d:	90                   	nop    
5ffb110e:	90                   	nop    
5ffb110f:	90                   	nop    

5ffb1110 <_Win32CsrInitialization@20>:

BOOL STDCALL
Win32CsrInitialization(PCSRSS_API_DEFINITION *ApiDefinitions,
                       PCSRSS_OBJECT_DEFINITION *ObjectDefinitions,
                       CSRPLUGIN_INIT_COMPLETE_PROC *InitComplete,
                       PCSRSS_EXPORTED_FUNCS Exports,
                       HANDLE CsrssApiHeap)
{
5ffb1110:	55                   	push   %ebp
5ffb1111:	89 e5                	mov    %esp,%ebp
5ffb1113:	83 ec 14             	sub    $0x14,%esp
5ffb1116:	8b 55 14             	mov    0x14(%ebp),%edx
  HANDLE ThreadHandle;

  CsrExports = *Exports;
5ffb1119:	8b 02                	mov    (%edx),%eax
5ffb111b:	a3 00 c0 fb 5f       	mov    %eax,0x5ffbc000
5ffb1120:	8b 42 04             	mov    0x4(%edx),%eax
5ffb1123:	a3 04 c0 fb 5f       	mov    %eax,0x5ffbc004
5ffb1128:	8b 42 08             	mov    0x8(%edx),%eax
5ffb112b:	a3 08 c0 fb 5f       	mov    %eax,0x5ffbc008
  Win32CsrApiHeap = CsrssApiHeap;
5ffb1130:	8b 45 18             	mov    0x18(%ebp),%eax
5ffb1133:	a3 e0 c1 fb 5f       	mov    %eax,0x5ffbc1e0

  PrivateCsrssManualGuiCheck(0);
5ffb1138:	6a 00                	push   $0x0
5ffb113a:	e8 01 7d 00 00       	call   5ffb8e40 <_PrivateCsrssManualGuiCheck@4>
  CsrInitConsoleSupport();
5ffb113f:	83 c4 0c             	add    $0xc,%esp
5ffb1142:	e8 39 16 00 00       	call   5ffb2780 <_CsrInitConsoleSupport@0>
  ThreadHandle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) Console_Api, NULL, 0, NULL);
5ffb1147:	50                   	push   %eax
5ffb1148:	50                   	push   %eax
5ffb1149:	6a 00                	push   $0x0
5ffb114b:	6a 00                	push   $0x0
5ffb114d:	6a 00                	push   $0x0
5ffb114f:	68 f0 2e fb 5f       	push   $0x5ffb2ef0
5ffb1154:	6a 00                	push   $0x0
5ffb1156:	6a 00                	push   $0x0
5ffb1158:	e8 53 7b 00 00       	call   5ffb8cb0 <_CreateThread@24>
  if (NULL == ThreadHandle)
5ffb115d:	5a                   	pop    %edx
5ffb115e:	85 c0                	test   %eax,%eax
5ffb1160:	59                   	pop    %ecx
5ffb1161:	74 2d                	je     5ffb1190 <_Win32CsrInitialization@20+0x80>
    {
      DPRINT1("CSR: Unable to create console thread\n");
      return FALSE;
    }
  CloseHandle(ThreadHandle);
5ffb1163:	83 ec 0c             	sub    $0xc,%esp
5ffb1166:	50                   	push   %eax
5ffb1167:	e8 54 7b 00 00       	call   5ffb8cc0 <_CloseHandle@4>

  *ApiDefinitions = Win32CsrApiDefinitions;
5ffb116c:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb116f:	c7 00 20 a0 fb 5f    	movl   $0x5ffba020,(%eax)
  *ObjectDefinitions = Win32CsrObjectDefinitions;
5ffb1175:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb1178:	c7 00 00 a0 fb 5f    	movl   $0x5ffba000,(%eax)
  *InitComplete = Win32CsrInitComplete;
5ffb117e:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb1181:	c7 00 f0 10 fb 5f    	movl   $0x5ffb10f0,(%eax)

  return TRUE;
5ffb1187:	b8 01 00 00 00       	mov    $0x1,%eax
}
5ffb118c:	c9                   	leave  
5ffb118d:	c2 14 00             	ret    $0x14
5ffb1190:	50                   	push   %eax
5ffb1191:	68 b4 00 00 00       	push   $0xb4
5ffb1196:	68 00 b0 fb 5f       	push   $0x5ffbb000
5ffb119b:	68 0a b0 fb 5f       	push   $0x5ffbb00a
5ffb11a0:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb11a6:	c7 04 24 14 b0 fb 5f 	movl   $0x5ffbb014,(%esp)
5ffb11ad:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb11b3:	31 c0                	xor    %eax,%eax
5ffb11b5:	c9                   	leave  
5ffb11b6:	c2 14 00             	ret    $0x14
5ffb11b9:	90                   	nop    
5ffb11ba:	90                   	nop    
5ffb11bb:	90                   	nop    
5ffb11bc:	90                   	nop    
5ffb11bd:	90                   	nop    
5ffb11be:	90                   	nop    
5ffb11bf:	90                   	nop    

5ffb11c0 <@ConioConsoleFromProcessData@8>:
5ffb11c0:	55                   	push   %ebp
5ffb11c1:	89 e5                	mov    %esp,%ebp
5ffb11c3:	56                   	push   %esi
5ffb11c4:	53                   	push   %ebx
5ffb11c5:	89 d6                	mov    %edx,%esi
5ffb11c7:	8b 01                	mov    (%ecx),%eax
5ffb11c9:	89 cb                	mov    %ecx,%ebx
5ffb11cb:	85 c0                	test   %eax,%eax
5ffb11cd:	75 11                	jne    5ffb11e0 <@ConioConsoleFromProcessData@8+0x20>
5ffb11cf:	c7 02 00 00 00 00    	movl   $0x0,(%edx)
5ffb11d5:	31 c0                	xor    %eax,%eax
5ffb11d7:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb11da:	5b                   	pop    %ebx
5ffb11db:	5e                   	pop    %esi
5ffb11dc:	5d                   	pop    %ebp
5ffb11dd:	c3                   	ret    
5ffb11de:	89 f6                	mov    %esi,%esi
5ffb11e0:	83 ec 0c             	sub    $0xc,%esp
5ffb11e3:	83 c0 08             	add    $0x8,%eax
5ffb11e6:	50                   	push   %eax
5ffb11e7:	e8 a4 7a 00 00       	call   5ffb8c90 <_EnterCriticalSection@4>
5ffb11ec:	8b 03                	mov    (%ebx),%eax
5ffb11ee:	89 06                	mov    %eax,(%esi)
5ffb11f0:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb11f3:	31 c0                	xor    %eax,%eax
5ffb11f5:	5b                   	pop    %ebx
5ffb11f6:	5e                   	pop    %esi
5ffb11f7:	5d                   	pop    %ebp
5ffb11f8:	c3                   	ret    
5ffb11f9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

5ffb1200 <@ConioConsoleCtrlEvent@8>:
5ffb1200:	55                   	push   %ebp
5ffb1201:	89 e5                	mov    %esp,%ebp
5ffb1203:	57                   	push   %edi
5ffb1204:	56                   	push   %esi
5ffb1205:	53                   	push   %ebx
5ffb1206:	83 ec 3c             	sub    $0x3c,%esp
5ffb1209:	89 cf                	mov    %ecx,%edi
5ffb120b:	8b 42 30             	mov    0x30(%edx),%eax
5ffb120e:	89 d3                	mov    %edx,%ebx
5ffb1210:	85 c0                	test   %eax,%eax
5ffb1212:	75 0c                	jne    5ffb1220 <@ConioConsoleCtrlEvent@8+0x20>
5ffb1214:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb1217:	5b                   	pop    %ebx
5ffb1218:	5e                   	pop    %esi
5ffb1219:	5f                   	pop    %edi
5ffb121a:	5d                   	pop    %ebp
5ffb121b:	c3                   	ret    
5ffb121c:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb1220:	c7 45 c4 00 00 00 00 	movl   $0x0,0xffffffc4(%ebp)
5ffb1227:	c7 45 c8 18 00 00 00 	movl   $0x18,0xffffffc8(%ebp)
5ffb122e:	8b 42 0c             	mov    0xc(%edx),%eax
5ffb1231:	c7 45 d4 00 00 00 00 	movl   $0x0,0xffffffd4(%ebp)
5ffb1238:	89 45 c0             	mov    %eax,0xffffffc0(%ebp)
5ffb123b:	8d 45 c0             	lea    0xffffffc0(%ebp),%eax
5ffb123e:	c7 45 cc 00 00 00 00 	movl   $0x0,0xffffffcc(%ebp)
5ffb1245:	c7 45 d0 00 00 00 00 	movl   $0x0,0xffffffd0(%ebp)
5ffb124c:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
5ffb1253:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
5ffb125a:	50                   	push   %eax
5ffb125b:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
5ffb125e:	50                   	push   %eax
5ffb125f:	8d 45 bc             	lea    0xffffffbc(%ebp),%eax
5ffb1262:	6a 6a                	push   $0x6a
5ffb1264:	50                   	push   %eax
5ffb1265:	e8 96 79 00 00       	call   5ffb8c00 <_NtOpenProcess@16>
5ffb126a:	89 c6                	mov    %eax,%esi
5ffb126c:	85 c0                	test   %eax,%eax
5ffb126e:	78 39                	js     5ffb12a9 <@ConioConsoleCtrlEvent@8+0xa9>
5ffb1270:	56                   	push   %esi
5ffb1271:	6a 00                	push   $0x0
5ffb1273:	6a 00                	push   $0x0
5ffb1275:	57                   	push   %edi
5ffb1276:	8b 5b 30             	mov    0x30(%ebx),%ebx
5ffb1279:	53                   	push   %ebx
5ffb127a:	6a 00                	push   $0x0
5ffb127c:	6a 00                	push   $0x0
5ffb127e:	8b 4d bc             	mov    0xffffffbc(%ebp),%ecx
5ffb1281:	51                   	push   %ecx
5ffb1282:	e8 49 7a 00 00       	call   5ffb8cd0 <_CreateRemoteThread@28>
5ffb1287:	5a                   	pop    %edx
5ffb1288:	85 c0                	test   %eax,%eax
5ffb128a:	74 43                	je     5ffb12cf <@ConioConsoleCtrlEvent@8+0xcf>
5ffb128c:	83 ec 0c             	sub    $0xc,%esp
5ffb128f:	50                   	push   %eax
5ffb1290:	e8 2b 7a 00 00       	call   5ffb8cc0 <_CloseHandle@4>
5ffb1295:	8b 45 bc             	mov    0xffffffbc(%ebp),%eax
5ffb1298:	50                   	push   %eax
5ffb1299:	e8 22 7a 00 00       	call   5ffb8cc0 <_CloseHandle@4>
5ffb129e:	83 c4 0c             	add    $0xc,%esp
5ffb12a1:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb12a4:	5b                   	pop    %ebx
5ffb12a5:	5e                   	pop    %esi
5ffb12a6:	5f                   	pop    %edi
5ffb12a7:	5d                   	pop    %ebp
5ffb12a8:	c3                   	ret    
5ffb12a9:	50                   	push   %eax
5ffb12aa:	6a 67                	push   $0x67
5ffb12ac:	68 40 b0 fb 5f       	push   $0x5ffbb040
5ffb12b1:	68 48 b0 fb 5f       	push   $0x5ffbb048
5ffb12b6:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb12bc:	5f                   	pop    %edi
5ffb12bd:	58                   	pop    %eax
5ffb12be:	56                   	push   %esi
5ffb12bf:	68 54 b0 fb 5f       	push   $0x5ffbb054
5ffb12c4:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb12ca:	e9 45 ff ff ff       	jmp    5ffb1214 <@ConioConsoleCtrlEvent@8+0x14>
5ffb12cf:	57                   	push   %edi
5ffb12d0:	6a 72                	push   $0x72
5ffb12d2:	68 40 b0 fb 5f       	push   $0x5ffbb040
5ffb12d7:	68 48 b0 fb 5f       	push   $0x5ffbb048
5ffb12dc:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb12e2:	e8 f9 79 00 00       	call   5ffb8ce0 <_GetLastError@0>
5ffb12e7:	5b                   	pop    %ebx
5ffb12e8:	5e                   	pop    %esi
5ffb12e9:	50                   	push   %eax
5ffb12ea:	68 84 b0 fb 5f       	push   $0x5ffbb084
5ffb12ef:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb12f5:	59                   	pop    %ecx
5ffb12f6:	8b 55 bc             	mov    0xffffffbc(%ebp),%edx
5ffb12f9:	52                   	push   %edx
5ffb12fa:	e8 c1 79 00 00       	call   5ffb8cc0 <_CloseHandle@4>
5ffb12ff:	e9 10 ff ff ff       	jmp    5ffb1214 <@ConioConsoleCtrlEvent@8+0x14>
5ffb1304:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb130a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

5ffb1310 <@ClearLineBuffer@4>:
5ffb1310:	55                   	push   %ebp
5ffb1311:	89 e5                	mov    %esp,%ebp
5ffb1313:	56                   	push   %esi
5ffb1314:	53                   	push   %ebx
5ffb1315:	31 f6                	xor    %esi,%esi
5ffb1317:	66 8b 41 24          	mov    0x24(%ecx),%ax
5ffb131b:	8b 51 30             	mov    0x30(%ecx),%edx
5ffb131e:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb1323:	89 cb                	mov    %ecx,%ebx
5ffb1325:	0f af d0             	imul   %eax,%edx
5ffb1328:	83 f8 00             	cmp    $0x0,%eax
5ffb132b:	8d 0c 12             	lea    (%edx,%edx,1),%ecx
5ffb132e:	eb 1e                	jmp    5ffb134e <@ClearLineBuffer@4+0x3e>
5ffb1330:	8b 43 20             	mov    0x20(%ebx),%eax
5ffb1333:	46                   	inc    %esi
5ffb1334:	c6 04 01 20          	movb   $0x20,(%ecx,%eax,1)
5ffb1338:	41                   	inc    %ecx
5ffb1339:	8b 53 20             	mov    0x20(%ebx),%edx
5ffb133c:	8a 43 34             	mov    0x34(%ebx),%al
5ffb133f:	88 04 11             	mov    %al,(%ecx,%edx,1)
5ffb1342:	41                   	inc    %ecx
5ffb1343:	66 8b 43 24          	mov    0x24(%ebx),%ax
5ffb1347:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb134c:	39 f0                	cmp    %esi,%eax
5ffb134e:	77 e0                	ja     5ffb1330 <@ClearLineBuffer@4+0x20>
5ffb1350:	5b                   	pop    %ebx
5ffb1351:	5e                   	pop    %esi
5ffb1352:	5d                   	pop    %ebp
5ffb1353:	c3                   	ret    
5ffb1354:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb135a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

5ffb1360 <@CsrInitConsoleScreenBuffer@8>:
5ffb1360:	55                   	push   %ebp
5ffb1361:	89 e5                	mov    %esp,%ebp
5ffb1363:	56                   	push   %esi
5ffb1364:	53                   	push   %ebx
5ffb1365:	89 d3                	mov    %edx,%ebx
5ffb1367:	66 8b 41 60          	mov    0x60(%ecx),%ax
5ffb136b:	c7 02 02 00 00 00    	movl   $0x2,(%edx)
5ffb1371:	66 89 42 24          	mov    %ax,0x24(%edx)
5ffb1375:	c7 42 04 00 00 00 00 	movl   $0x0,0x4(%edx)
5ffb137c:	66 8b 51 62          	mov    0x62(%ecx),%dx
5ffb1380:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb1385:	66 89 53 26          	mov    %dx,0x26(%ebx)
5ffb1389:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb138f:	0f af c2             	imul   %edx,%eax
5ffb1392:	01 c0                	add    %eax,%eax
5ffb1394:	89 ce                	mov    %ecx,%esi
5ffb1396:	66 c7 43 28 00 00    	movw   $0x0,0x28(%ebx)
5ffb139c:	66 c7 43 2a 00 00    	movw   $0x0,0x2a(%ebx)
5ffb13a2:	51                   	push   %ecx
5ffb13a3:	50                   	push   %eax
5ffb13a4:	a1 e0 c1 fb 5f       	mov    0x5ffbc1e0,%eax
5ffb13a9:	6a 00                	push   $0x0
5ffb13ab:	50                   	push   %eax
5ffb13ac:	e8 3f 79 00 00       	call   5ffb8cf0 <_HeapAlloc@12>
5ffb13b1:	ba 9a 00 00 c0       	mov    $0xc000009a,%edx
5ffb13b6:	59                   	pop    %ecx
5ffb13b7:	85 c0                	test   %eax,%eax
5ffb13b9:	89 43 20             	mov    %eax,0x20(%ebx)
5ffb13bc:	74 44                	je     5ffb1402 <@CsrInitConsoleScreenBuffer@8+0xa2>
5ffb13be:	83 ec 0c             	sub    $0xc,%esp
5ffb13c1:	8d 43 08             	lea    0x8(%ebx),%eax
5ffb13c4:	50                   	push   %eax
5ffb13c5:	e8 b6 78 00 00       	call   5ffb8c80 <_InitializeCriticalSection@4>
5ffb13ca:	8b 46 70             	mov    0x70(%esi),%eax
5ffb13cd:	89 1c 24             	mov    %ebx,(%esp)
5ffb13d0:	56                   	push   %esi
5ffb13d1:	ff 10                	call   *(%eax)
5ffb13d3:	58                   	pop    %eax
5ffb13d4:	5a                   	pop    %edx
5ffb13d5:	31 d2                	xor    %edx,%edx
5ffb13d7:	66 83 7b 26 00       	cmpw   $0x0,0x26(%ebx)
5ffb13dc:	75 32                	jne    5ffb1410 <@CsrInitConsoleScreenBuffer@8+0xb0>
5ffb13de:	c7 43 3c 01 00 00 00 	movl   $0x1,0x3c(%ebx)
5ffb13e5:	c7 43 38 05 00 00 00 	movl   $0x5,0x38(%ebx)
5ffb13ec:	66 c7 43 40 03 00    	movw   $0x3,0x40(%ebx)
5ffb13f2:	c7 43 2c 00 00 00 00 	movl   $0x0,0x2c(%ebx)
5ffb13f9:	c7 43 30 00 00 00 00 	movl   $0x0,0x30(%ebx)
5ffb1400:	31 d2                	xor    %edx,%edx
5ffb1402:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb1405:	89 d0                	mov    %edx,%eax
5ffb1407:	5b                   	pop    %ebx
5ffb1408:	5e                   	pop    %esi
5ffb1409:	5d                   	pop    %ebp
5ffb140a:	c3                   	ret    
5ffb140b:	90                   	nop    
5ffb140c:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb1410:	89 53 30             	mov    %edx,0x30(%ebx)
5ffb1413:	89 d9                	mov    %ebx,%ecx
5ffb1415:	e8 f6 fe ff ff       	call   5ffb1310 <@ClearLineBuffer@4>
5ffb141a:	8b 43 30             	mov    0x30(%ebx),%eax
5ffb141d:	40                   	inc    %eax
5ffb141e:	89 c2                	mov    %eax,%edx
5ffb1420:	66 8b 43 26          	mov    0x26(%ebx),%ax
5ffb1424:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb1429:	39 c2                	cmp    %eax,%edx
5ffb142b:	73 b1                	jae    5ffb13de <@CsrInitConsoleScreenBuffer@8+0x7e>
5ffb142d:	89 53 30             	mov    %edx,0x30(%ebx)
5ffb1430:	89 d9                	mov    %ebx,%ecx
5ffb1432:	e8 d9 fe ff ff       	call   5ffb1310 <@ClearLineBuffer@4>
5ffb1437:	8b 43 30             	mov    0x30(%ebx),%eax
5ffb143a:	40                   	inc    %eax
5ffb143b:	89 c2                	mov    %eax,%edx
5ffb143d:	66 8b 43 26          	mov    0x26(%ebx),%ax
5ffb1441:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb1446:	39 c2                	cmp    %eax,%edx
5ffb1448:	72 c6                	jb     5ffb1410 <@CsrInitConsoleScreenBuffer@8+0xb0>
5ffb144a:	eb 92                	jmp    5ffb13de <@CsrInitConsoleScreenBuffer@8+0x7e>
5ffb144c:	8d 74 26 00          	lea    0x0(%esi),%esi

5ffb1450 <@ConioDrawConsole@4>:

/* EOF */
5ffb1450:	55                   	push   %ebp
5ffb1451:	89 e5                	mov    %esp,%ebp
5ffb1453:	83 ec 20             	sub    $0x20,%esp
5ffb1456:	0f bf 41 62          	movswl 0x62(%ecx),%eax
5ffb145a:	48                   	dec    %eax
5ffb145b:	8b 51 70             	mov    0x70(%ecx),%edx
5ffb145e:	89 45 f4             	mov    %eax,0xfffffff4(%ebp)
5ffb1461:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
5ffb1468:	0f bf 41 60          	movswl 0x60(%ecx),%eax
5ffb146c:	48                   	dec    %eax
5ffb146d:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
5ffb1474:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
5ffb1477:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
5ffb147a:	50                   	push   %eax
5ffb147b:	51                   	push   %ecx
5ffb147c:	ff 52 08             	call   *0x8(%edx)
5ffb147f:	c9                   	leave  
5ffb1480:	c3                   	ret    
5ffb1481:	eb 0d                	jmp    5ffb1490 <@ConioNextLine@12>
5ffb1483:	90                   	nop    
5ffb1484:	90                   	nop    
5ffb1485:	90                   	nop    
5ffb1486:	90                   	nop    
5ffb1487:	90                   	nop    
5ffb1488:	90                   	nop    
5ffb1489:	90                   	nop    
5ffb148a:	90                   	nop    
5ffb148b:	90                   	nop    
5ffb148c:	90                   	nop    
5ffb148d:	90                   	nop    
5ffb148e:	90                   	nop    
5ffb148f:	90                   	nop    

5ffb1490 <@ConioNextLine@12>:
5ffb1490:	55                   	push   %ebp
5ffb1491:	89 e5                	mov    %esp,%ebp
5ffb1493:	57                   	push   %edi
5ffb1494:	56                   	push   %esi
5ffb1495:	53                   	push   %ebx
5ffb1496:	83 ec 10             	sub    $0x10,%esp
5ffb1499:	89 ce                	mov    %ecx,%esi
5ffb149b:	66 8b 41 2a          	mov    0x2a(%ecx),%ax
5ffb149f:	89 55 f0             	mov    %edx,0xfffffff0(%ebp)
5ffb14a2:	8b 59 30             	mov    0x30(%ecx),%ebx
5ffb14a5:	89 c2                	mov    %eax,%edx
5ffb14a7:	66 8b 7e 26          	mov    0x26(%esi),%di
5ffb14ab:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb14b1:	66 89 45 ee          	mov    %ax,0xffffffee(%ebp)
5ffb14b5:	89 d9                	mov    %ebx,%ecx
5ffb14b7:	89 f8                	mov    %edi,%eax
5ffb14b9:	29 d1                	sub    %edx,%ecx
5ffb14bb:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb14c0:	31 d2                	xor    %edx,%edx
5ffb14c2:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
5ffb14c5:	8d 04 01             	lea    (%ecx,%eax,1),%eax
5ffb14c8:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
5ffb14cb:	f7 75 e8             	divl   0xffffffe8(%ebp)
5ffb14ce:	49                   	dec    %ecx
5ffb14cf:	39 ca                	cmp    %ecx,%edx
5ffb14d1:	74 4d                	je     5ffb1520 <@ConioNextLine@12+0x90>
5ffb14d3:	89 fa                	mov    %edi,%edx
5ffb14d5:	8d 4b 01             	lea    0x1(%ebx),%ecx
5ffb14d8:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb14de:	39 d1                	cmp    %edx,%ecx
5ffb14e0:	74 63                	je     5ffb1545 <@ConioNextLine@12+0xb5>
5ffb14e2:	89 4e 30             	mov    %ecx,0x30(%esi)
5ffb14e5:	89 f1                	mov    %esi,%ecx
5ffb14e7:	e8 24 fe ff ff       	call   5ffb1310 <@ClearLineBuffer@4>
5ffb14ec:	66 8b 56 24          	mov    0x24(%esi),%dx
5ffb14f0:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
5ffb14f3:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb14f9:	4a                   	dec    %edx
5ffb14fa:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
5ffb1500:	89 50 08             	mov    %edx,0x8(%eax)
5ffb1503:	8b 5e 30             	mov    0x30(%esi),%ebx
5ffb1506:	39 58 04             	cmp    %ebx,0x4(%eax)
5ffb1509:	74 45                	je     5ffb1550 <@ConioNextLine@12+0xc0>
5ffb150b:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb150e:	89 59 0c             	mov    %ebx,0xc(%ecx)
5ffb1511:	83 c4 10             	add    $0x10,%esp
5ffb1514:	5b                   	pop    %ebx
5ffb1515:	5e                   	pop    %esi
5ffb1516:	5f                   	pop    %edi
5ffb1517:	5d                   	pop    %ebp
5ffb1518:	c2 04 00             	ret    $0x4
5ffb151b:	90                   	nop    
5ffb151c:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb1520:	66 8b 45 ee          	mov    0xffffffee(%ebp),%ax
5ffb1524:	40                   	inc    %eax
5ffb1525:	66 39 f8             	cmp    %di,%ax
5ffb1528:	74 50                	je     5ffb157a <@ConioNextLine@12+0xea>
5ffb152a:	66 89 46 2a          	mov    %ax,0x2a(%esi)
5ffb152e:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb1531:	89 fa                	mov    %edi,%edx
5ffb1533:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb1539:	8b 01                	mov    (%ecx),%eax
5ffb153b:	40                   	inc    %eax
5ffb153c:	89 01                	mov    %eax,(%ecx)
5ffb153e:	8d 4b 01             	lea    0x1(%ebx),%ecx
5ffb1541:	39 d1                	cmp    %edx,%ecx
5ffb1543:	75 9d                	jne    5ffb14e2 <@ConioNextLine@12+0x52>
5ffb1545:	c7 46 30 00 00 00 00 	movl   $0x0,0x30(%esi)
5ffb154c:	eb 97                	jmp    5ffb14e5 <@ConioNextLine@12+0x55>
5ffb154e:	89 f6                	mov    %esi,%esi
5ffb1550:	66 8b 56 26          	mov    0x26(%esi),%dx
5ffb1554:	8d 4b 01             	lea    0x1(%ebx),%ecx
5ffb1557:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb155d:	39 d1                	cmp    %edx,%ecx
5ffb155f:	74 21                	je     5ffb1582 <@ConioNextLine@12+0xf2>
5ffb1561:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
5ffb1564:	89 48 04             	mov    %ecx,0x4(%eax)
5ffb1567:	8b 5e 30             	mov    0x30(%esi),%ebx
5ffb156a:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb156d:	89 59 0c             	mov    %ebx,0xc(%ecx)
5ffb1570:	83 c4 10             	add    $0x10,%esp
5ffb1573:	5b                   	pop    %ebx
5ffb1574:	5e                   	pop    %esi
5ffb1575:	5f                   	pop    %edi
5ffb1576:	5d                   	pop    %ebp
5ffb1577:	c2 04 00             	ret    $0x4
5ffb157a:	66 c7 46 2a 00 00    	movw   $0x0,0x2a(%esi)
5ffb1580:	eb ac                	jmp    5ffb152e <@ConioNextLine@12+0x9e>
5ffb1582:	c7 40 04 00 00 00 00 	movl   $0x0,0x4(%eax)
5ffb1589:	8b 5e 30             	mov    0x30(%esi),%ebx
5ffb158c:	eb dc                	jmp    5ffb156a <@ConioNextLine@12+0xda>
5ffb158e:	89 f6                	mov    %esi,%esi

5ffb1590 <@ConioPhysicalToLogical@20>:
5ffb1590:	55                   	push   %ebp
5ffb1591:	89 e5                	mov    %esp,%ebp
5ffb1593:	56                   	push   %esi
5ffb1594:	53                   	push   %ebx
5ffb1595:	89 cb                	mov    %ecx,%ebx
5ffb1597:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb159a:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb159d:	8b 75 10             	mov    0x10(%ebp),%esi
5ffb15a0:	89 10                	mov    %edx,(%eax)
5ffb15a2:	66 8b 43 2a          	mov    0x2a(%ebx),%ax
5ffb15a6:	89 c2                	mov    %eax,%edx
5ffb15a8:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb15ae:	39 ca                	cmp    %ecx,%edx
5ffb15b0:	76 15                	jbe    5ffb15c7 <@ConioPhysicalToLogical@20+0x37>
5ffb15b2:	66 8b 43 26          	mov    0x26(%ebx),%ax
5ffb15b6:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb15bb:	29 d0                	sub    %edx,%eax
5ffb15bd:	01 c8                	add    %ecx,%eax
5ffb15bf:	89 06                	mov    %eax,(%esi)
5ffb15c1:	5b                   	pop    %ebx
5ffb15c2:	5e                   	pop    %esi
5ffb15c3:	5d                   	pop    %ebp
5ffb15c4:	c2 0c 00             	ret    $0xc
5ffb15c7:	29 d1                	sub    %edx,%ecx
5ffb15c9:	89 0e                	mov    %ecx,(%esi)
5ffb15cb:	5b                   	pop    %ebx
5ffb15cc:	5e                   	pop    %esi
5ffb15cd:	5d                   	pop    %ebp
5ffb15ce:	c2 0c 00             	ret    $0xc
5ffb15d1:	eb 0d                	jmp    5ffb15e0 <@ConioWriteConsole@20>
5ffb15d3:	90                   	nop    
5ffb15d4:	90                   	nop    
5ffb15d5:	90                   	nop    
5ffb15d6:	90                   	nop    
5ffb15d7:	90                   	nop    
5ffb15d8:	90                   	nop    
5ffb15d9:	90                   	nop    
5ffb15da:	90                   	nop    
5ffb15db:	90                   	nop    
5ffb15dc:	90                   	nop    
5ffb15dd:	90                   	nop    
5ffb15de:	90                   	nop    
5ffb15df:	90                   	nop    

5ffb15e0 <@ConioWriteConsole@20>:
5ffb15e0:	55                   	push   %ebp
5ffb15e1:	89 e5                	mov    %esp,%ebp
5ffb15e3:	57                   	push   %edi
5ffb15e4:	56                   	push   %esi
5ffb15e5:	53                   	push   %ebx
5ffb15e6:	83 ec 3c             	sub    $0x3c,%esp
5ffb15e9:	8d 45 d4             	lea    0xffffffd4(%ebp),%eax
5ffb15ec:	89 d3                	mov    %edx,%ebx
5ffb15ee:	8b 52 2c             	mov    0x2c(%edx),%edx
5ffb15f1:	50                   	push   %eax
5ffb15f2:	8d 45 d0             	lea    0xffffffd0(%ebp),%eax
5ffb15f5:	50                   	push   %eax
5ffb15f6:	89 4d c8             	mov    %ecx,0xffffffc8(%ebp)
5ffb15f9:	8b 7b 30             	mov    0x30(%ebx),%edi
5ffb15fc:	89 d9                	mov    %ebx,%ecx
5ffb15fe:	57                   	push   %edi
5ffb15ff:	e8 8c ff ff ff       	call   5ffb1590 <@ConioPhysicalToLogical@20>
5ffb1604:	66 8b 73 24          	mov    0x24(%ebx),%si
5ffb1608:	c7 45 cc 00 00 00 00 	movl   $0x0,0xffffffcc(%ebp)
5ffb160f:	89 f0                	mov    %esi,%eax
5ffb1611:	c7 45 c4 00 00 00 00 	movl   $0x0,0xffffffc4(%ebp)
5ffb1618:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb161d:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
5ffb1620:	8b 53 30             	mov    0x30(%ebx),%edx
5ffb1623:	c7 45 e0 ff ff ff ff 	movl   $0xffffffff,0xffffffe0(%ebp)
5ffb162a:	89 55 dc             	mov    %edx,0xffffffdc(%ebp)
5ffb162d:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
5ffb1630:	e9 9d 00 00 00       	jmp    5ffb16d2 <@ConioWriteConsole@20+0xf2>
5ffb1635:	8b 55 c4             	mov    0xffffffc4(%ebp),%edx
5ffb1638:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb163b:	8a 14 02             	mov    (%edx,%eax,1),%dl
5ffb163e:	88 55 c3             	mov    %dl,0xffffffc3(%ebp)
5ffb1641:	80 fa 0a             	cmp    $0xa,%dl
5ffb1644:	0f 84 26 01 00 00    	je     5ffb1770 <@ConioWriteConsole@20+0x190>
5ffb164a:	80 7d c3 08          	cmpb   $0x8,0xffffffc3(%ebp)
5ffb164e:	0f 84 3c 01 00 00    	je     5ffb1790 <@ConioWriteConsole@20+0x1b0>
5ffb1654:	80 7d c3 0d          	cmpb   $0xd,0xffffffc3(%ebp)
5ffb1658:	0f 84 82 01 00 00    	je     5ffb17e0 <@ConioWriteConsole@20+0x200>
5ffb165e:	80 7d c3 09          	cmpb   $0x9,0xffffffc3(%ebp)
5ffb1662:	0f 84 eb 01 00 00    	je     5ffb1853 <@ConioWriteConsole@20+0x273>
5ffb1668:	8b 53 2c             	mov    0x2c(%ebx),%edx
5ffb166b:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
5ffb166e:	89 d1                	mov    %edx,%ecx
5ffb1670:	39 c2                	cmp    %eax,%edx
5ffb1672:	76 02                	jbe    5ffb1676 <@ConioWriteConsole@20+0x96>
5ffb1674:	89 c1                	mov    %eax,%ecx
5ffb1676:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
5ffb1679:	89 4d d8             	mov    %ecx,0xffffffd8(%ebp)
5ffb167c:	39 c2                	cmp    %eax,%edx
5ffb167e:	89 d1                	mov    %edx,%ecx
5ffb1680:	7d 02                	jge    5ffb1684 <@ConioWriteConsole@20+0xa4>
5ffb1682:	89 c1                	mov    %eax,%ecx
5ffb1684:	89 4d e0             	mov    %ecx,0xffffffe0(%ebp)
5ffb1687:	66 8b 43 24          	mov    0x24(%ebx),%ax
5ffb168b:	8b 4b 30             	mov    0x30(%ebx),%ecx
5ffb168e:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb1693:	0f af c1             	imul   %ecx,%eax
5ffb1696:	01 d0                	add    %edx,%eax
5ffb1698:	8a 55 c3             	mov    0xffffffc3(%ebp),%dl
5ffb169b:	8d 0c 00             	lea    (%eax,%eax,1),%ecx
5ffb169e:	8b 43 20             	mov    0x20(%ebx),%eax
5ffb16a1:	88 14 01             	mov    %dl,(%ecx,%eax,1)
5ffb16a4:	41                   	inc    %ecx
5ffb16a5:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb16a8:	85 c0                	test   %eax,%eax
5ffb16aa:	74 09                	je     5ffb16b5 <@ConioWriteConsole@20+0xd5>
5ffb16ac:	8b 53 20             	mov    0x20(%ebx),%edx
5ffb16af:	8a 43 34             	mov    0x34(%ebx),%al
5ffb16b2:	88 04 11             	mov    %al,(%ecx,%edx,1)
5ffb16b5:	66 8b 73 24          	mov    0x24(%ebx),%si
5ffb16b9:	8b 53 2c             	mov    0x2c(%ebx),%edx
5ffb16bc:	89 f0                	mov    %esi,%eax
5ffb16be:	42                   	inc    %edx
5ffb16bf:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb16c4:	39 c2                	cmp    %eax,%edx
5ffb16c6:	74 2d                	je     5ffb16f5 <@ConioWriteConsole@20+0x115>
5ffb16c8:	89 53 2c             	mov    %edx,0x2c(%ebx)
5ffb16cb:	8b 45 c4             	mov    0xffffffc4(%ebp),%eax
5ffb16ce:	40                   	inc    %eax
5ffb16cf:	89 45 c4             	mov    %eax,0xffffffc4(%ebp)
5ffb16d2:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb16d5:	39 45 c4             	cmp    %eax,0xffffffc4(%ebp)
5ffb16d8:	73 29                	jae    5ffb1703 <@ConioWriteConsole@20+0x123>
5ffb16da:	f6 43 40 01          	testb  $0x1,0x40(%ebx)
5ffb16de:	0f 85 51 ff ff ff    	jne    5ffb1635 <@ConioWriteConsole@20+0x55>
5ffb16e4:	8b 55 c4             	mov    0xffffffc4(%ebp),%edx
5ffb16e7:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb16ea:	8a 14 02             	mov    (%edx,%eax,1),%dl
5ffb16ed:	88 55 c3             	mov    %dl,0xffffffc3(%ebp)
5ffb16f0:	e9 73 ff ff ff       	jmp    5ffb1668 <@ConioWriteConsole@20+0x88>
5ffb16f5:	f6 43 40 02          	testb  $0x2,0x40(%ebx)
5ffb16f9:	75 75                	jne    5ffb1770 <@ConioWriteConsole@20+0x190>
5ffb16fb:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
5ffb16fe:	89 43 2c             	mov    %eax,0x2c(%ebx)
5ffb1701:	eb c8                	jmp    5ffb16cb <@ConioWriteConsole@20+0xeb>
5ffb1703:	8d 45 dc             	lea    0xffffffdc(%ebp),%eax
5ffb1706:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
5ffb1709:	50                   	push   %eax
5ffb170a:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
5ffb170d:	50                   	push   %eax
5ffb170e:	89 d9                	mov    %ebx,%ecx
5ffb1710:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
5ffb1713:	50                   	push   %eax
5ffb1714:	e8 77 fe ff ff       	call   5ffb1590 <@ConioPhysicalToLogical@20>
5ffb1719:	8d 45 e4             	lea    0xffffffe4(%ebp),%eax
5ffb171c:	8b 7d e4             	mov    0xffffffe4(%ebp),%edi
5ffb171f:	50                   	push   %eax
5ffb1720:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
5ffb1723:	8d 45 e0             	lea    0xffffffe0(%ebp),%eax
5ffb1726:	89 d9                	mov    %ebx,%ecx
5ffb1728:	50                   	push   %eax
5ffb1729:	57                   	push   %edi
5ffb172a:	e8 61 fe ff ff       	call   5ffb1590 <@ConioPhysicalToLogical@20>
5ffb172f:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
5ffb1732:	39 45 d8             	cmp    %eax,0xffffffd8(%ebp)
5ffb1735:	7f 29                	jg     5ffb1760 <@ConioWriteConsole@20+0x180>
5ffb1737:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
5ffb173a:	8b 75 c8             	mov    0xffffffc8(%ebp),%esi
5ffb173d:	39 45 dc             	cmp    %eax,0xffffffdc(%ebp)
5ffb1740:	0f 9e c2             	setle  %dl
5ffb1743:	85 f6                	test   %esi,%esi
5ffb1745:	0f 95 c0             	setne  %al
5ffb1748:	25 ff 00 00 00       	and    $0xff,%eax
5ffb174d:	85 c2                	test   %eax,%edx
5ffb174f:	74 0f                	je     5ffb1760 <@ConioWriteConsole@20+0x180>
5ffb1751:	8b 55 c8             	mov    0xffffffc8(%ebp),%edx
5ffb1754:	39 5a 38             	cmp    %ebx,0x38(%edx)
5ffb1757:	0f 84 9d 01 00 00    	je     5ffb18fa <@ConioWriteConsole@20+0x31a>
5ffb175d:	8d 76 00             	lea    0x0(%esi),%esi
5ffb1760:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb1763:	31 c0                	xor    %eax,%eax
5ffb1765:	5b                   	pop    %ebx
5ffb1766:	5e                   	pop    %esi
5ffb1767:	5f                   	pop    %edi
5ffb1768:	5d                   	pop    %ebp
5ffb1769:	c2 0c 00             	ret    $0xc
5ffb176c:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb1770:	c7 43 2c 00 00 00 00 	movl   $0x0,0x2c(%ebx)
5ffb1777:	8d 45 cc             	lea    0xffffffcc(%ebp),%eax
5ffb177a:	8d 55 d8             	lea    0xffffffd8(%ebp),%edx
5ffb177d:	89 d9                	mov    %ebx,%ecx
5ffb177f:	50                   	push   %eax
5ffb1780:	e8 0b fd ff ff       	call   5ffb1490 <@ConioNextLine@12>
5ffb1785:	e9 41 ff ff ff       	jmp    5ffb16cb <@ConioWriteConsole@20+0xeb>
5ffb178a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb1790:	8b 43 2c             	mov    0x2c(%ebx),%eax
5ffb1793:	85 c0                	test   %eax,%eax
5ffb1795:	75 6a                	jne    5ffb1801 <@ConioWriteConsole@20+0x221>
5ffb1797:	66 8b 43 2a          	mov    0x2a(%ebx),%ax
5ffb179b:	8b 53 30             	mov    0x30(%ebx),%edx
5ffb179e:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb17a3:	39 d0                	cmp    %edx,%eax
5ffb17a5:	0f 84 20 ff ff ff    	je     5ffb16cb <@ConioWriteConsole@20+0xeb>
5ffb17ab:	66 8b 73 24          	mov    0x24(%ebx),%si
5ffb17af:	89 f0                	mov    %esi,%eax
5ffb17b1:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb17b6:	48                   	dec    %eax
5ffb17b7:	85 d2                	test   %edx,%edx
5ffb17b9:	89 43 2c             	mov    %eax,0x2c(%ebx)
5ffb17bc:	8d 42 ff             	lea    0xffffffff(%edx),%eax
5ffb17bf:	0f 84 14 01 00 00    	je     5ffb18d9 <@ConioWriteConsole@20+0x2f9>
5ffb17c5:	89 43 30             	mov    %eax,0x30(%ebx)
5ffb17c8:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
5ffb17cb:	85 c0                	test   %eax,%eax
5ffb17cd:	0f 85 1d 01 00 00    	jne    5ffb18f0 <@ConioWriteConsole@20+0x310>
5ffb17d3:	8b 53 30             	mov    0x30(%ebx),%edx
5ffb17d6:	39 55 e4             	cmp    %edx,0xffffffe4(%ebp)
5ffb17d9:	73 31                	jae    5ffb180c <@ConioWriteConsole@20+0x22c>
5ffb17db:	89 55 dc             	mov    %edx,0xffffffdc(%ebp)
5ffb17de:	eb 2c                	jmp    5ffb180c <@ConioWriteConsole@20+0x22c>
5ffb17e0:	c7 43 2c 00 00 00 00 	movl   $0x0,0x2c(%ebx)
5ffb17e7:	31 d2                	xor    %edx,%edx
5ffb17e9:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
5ffb17ec:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
5ffb17f3:	39 c2                	cmp    %eax,%edx
5ffb17f5:	7d 02                	jge    5ffb17f9 <@ConioWriteConsole@20+0x219>
5ffb17f7:	89 c2                	mov    %eax,%edx
5ffb17f9:	89 55 e0             	mov    %edx,0xffffffe0(%ebp)
5ffb17fc:	e9 ca fe ff ff       	jmp    5ffb16cb <@ConioWriteConsole@20+0xeb>
5ffb1801:	48                   	dec    %eax
5ffb1802:	8b 53 30             	mov    0x30(%ebx),%edx
5ffb1805:	89 43 2c             	mov    %eax,0x2c(%ebx)
5ffb1808:	66 8b 73 24          	mov    0x24(%ebx),%si
5ffb180c:	89 f0                	mov    %esi,%eax
5ffb180e:	8b 73 2c             	mov    0x2c(%ebx),%esi
5ffb1811:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb1816:	0f af d0             	imul   %eax,%edx
5ffb1819:	01 f2                	add    %esi,%edx
5ffb181b:	8b 43 20             	mov    0x20(%ebx),%eax
5ffb181e:	8d 0c 12             	lea    (%edx,%edx,1),%ecx
5ffb1821:	c6 04 01 20          	movb   $0x20,(%ecx,%eax,1)
5ffb1825:	8b 53 20             	mov    0x20(%ebx),%edx
5ffb1828:	8a 43 34             	mov    0x34(%ebx),%al
5ffb182b:	88 44 11 01          	mov    %al,0x1(%ecx,%edx,1)
5ffb182f:	8b 53 2c             	mov    0x2c(%ebx),%edx
5ffb1832:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
5ffb1835:	89 d1                	mov    %edx,%ecx
5ffb1837:	39 c2                	cmp    %eax,%edx
5ffb1839:	76 02                	jbe    5ffb183d <@ConioWriteConsole@20+0x25d>
5ffb183b:	89 c1                	mov    %eax,%ecx
5ffb183d:	89 d0                	mov    %edx,%eax
5ffb183f:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
5ffb1842:	89 4d d8             	mov    %ecx,0xffffffd8(%ebp)
5ffb1845:	39 d0                	cmp    %edx,%eax
5ffb1847:	7d 02                	jge    5ffb184b <@ConioWriteConsole@20+0x26b>
5ffb1849:	89 d0                	mov    %edx,%eax
5ffb184b:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
5ffb184e:	e9 78 fe ff ff       	jmp    5ffb16cb <@ConioWriteConsole@20+0xeb>
5ffb1853:	8b 53 2c             	mov    0x2c(%ebx),%edx
5ffb1856:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
5ffb1859:	89 d1                	mov    %edx,%ecx
5ffb185b:	39 c2                	cmp    %eax,%edx
5ffb185d:	77 76                	ja     5ffb18d5 <@ConioWriteConsole@20+0x2f5>
5ffb185f:	66 8b 73 24          	mov    0x24(%ebx),%si
5ffb1863:	8d 7a 08             	lea    0x8(%edx),%edi
5ffb1866:	89 f0                	mov    %esi,%eax
5ffb1868:	83 e7 f8             	and    $0xfffffff8,%edi
5ffb186b:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb1870:	89 4d d8             	mov    %ecx,0xffffffd8(%ebp)
5ffb1873:	39 f8                	cmp    %edi,%eax
5ffb1875:	73 02                	jae    5ffb1879 <@ConioWriteConsole@20+0x299>
5ffb1877:	89 c7                	mov    %eax,%edi
5ffb1879:	8b 4b 30             	mov    0x30(%ebx),%ecx
5ffb187c:	0f af c1             	imul   %ecx,%eax
5ffb187f:	01 d0                	add    %edx,%eax
5ffb1881:	39 fa                	cmp    %edi,%edx
5ffb1883:	8d 0c 00             	lea    (%eax,%eax,1),%ecx
5ffb1886:	73 1b                	jae    5ffb18a3 <@ConioWriteConsole@20+0x2c3>
5ffb1888:	8b 43 20             	mov    0x20(%ebx),%eax
5ffb188b:	c6 04 01 20          	movb   $0x20,(%ecx,%eax,1)
5ffb188f:	83 c1 02             	add    $0x2,%ecx
5ffb1892:	8b 43 2c             	mov    0x2c(%ebx),%eax
5ffb1895:	40                   	inc    %eax
5ffb1896:	89 43 2c             	mov    %eax,0x2c(%ebx)
5ffb1899:	39 f8                	cmp    %edi,%eax
5ffb189b:	72 eb                	jb     5ffb1888 <@ConioWriteConsole@20+0x2a8>
5ffb189d:	89 c2                	mov    %eax,%edx
5ffb189f:	66 8b 73 24          	mov    0x24(%ebx),%si
5ffb18a3:	8d 4a ff             	lea    0xffffffff(%edx),%ecx
5ffb18a6:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
5ffb18a9:	89 cf                	mov    %ecx,%edi
5ffb18ab:	39 c1                	cmp    %eax,%ecx
5ffb18ad:	7d 02                	jge    5ffb18b1 <@ConioWriteConsole@20+0x2d1>
5ffb18af:	89 c7                	mov    %eax,%edi
5ffb18b1:	89 f0                	mov    %esi,%eax
5ffb18b3:	89 7d e0             	mov    %edi,0xffffffe0(%ebp)
5ffb18b6:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb18bb:	39 c2                	cmp    %eax,%edx
5ffb18bd:	0f 85 08 fe ff ff    	jne    5ffb16cb <@ConioWriteConsole@20+0xeb>
5ffb18c3:	f6 43 40 02          	testb  $0x2,0x40(%ebx)
5ffb18c7:	0f 85 a3 fe ff ff    	jne    5ffb1770 <@ConioWriteConsole@20+0x190>
5ffb18cd:	89 4b 2c             	mov    %ecx,0x2c(%ebx)
5ffb18d0:	e9 f6 fd ff ff       	jmp    5ffb16cb <@ConioWriteConsole@20+0xeb>
5ffb18d5:	89 c1                	mov    %eax,%ecx
5ffb18d7:	eb 86                	jmp    5ffb185f <@ConioWriteConsole@20+0x27f>
5ffb18d9:	66 8b 43 26          	mov    0x26(%ebx),%ax
5ffb18dd:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb18e2:	89 43 30             	mov    %eax,0x30(%ebx)
5ffb18e5:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
5ffb18e8:	85 c0                	test   %eax,%eax
5ffb18ea:	0f 84 e3 fe ff ff    	je     5ffb17d3 <@ConioWriteConsole@20+0x1f3>
5ffb18f0:	8b 53 30             	mov    0x30(%ebx),%edx
5ffb18f3:	39 c2                	cmp    %eax,%edx
5ffb18f5:	e9 df fe ff ff       	jmp    5ffb17d9 <@ConioWriteConsole@20+0x1f9>
5ffb18fa:	51                   	push   %ecx
5ffb18fb:	8b 42 70             	mov    0x70(%edx),%eax
5ffb18fe:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb1901:	52                   	push   %edx
5ffb1902:	8b 7d 08             	mov    0x8(%ebp),%edi
5ffb1905:	8b 75 cc             	mov    0xffffffcc(%ebp),%esi
5ffb1908:	8b 5d d4             	mov    0xffffffd4(%ebp),%ebx
5ffb190b:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
5ffb190e:	8d 55 d8             	lea    0xffffffd8(%ebp),%edx
5ffb1911:	57                   	push   %edi
5ffb1912:	56                   	push   %esi
5ffb1913:	53                   	push   %ebx
5ffb1914:	51                   	push   %ecx
5ffb1915:	52                   	push   %edx
5ffb1916:	8b 55 c8             	mov    0xffffffc8(%ebp),%edx
5ffb1919:	52                   	push   %edx
5ffb191a:	ff 50 04             	call   *0x4(%eax)
5ffb191d:	58                   	pop    %eax
5ffb191e:	e9 3d fe ff ff       	jmp    5ffb1760 <@ConioWriteConsole@20+0x180>
5ffb1923:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb1929:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb1930 <_CsrReadConsole@12>:
5ffb1930:	55                   	push   %ebp
5ffb1931:	89 e5                	mov    %esp,%ebp
5ffb1933:	57                   	push   %edi
5ffb1934:	56                   	push   %esi
5ffb1935:	53                   	push   %ebx
5ffb1936:	83 ec 1c             	sub    $0x1c,%esp
5ffb1939:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb193c:	8b 5d 08             	mov    0x8(%ebp),%ebx
5ffb193f:	8b 7d 10             	mov    0x10(%ebp),%edi
5ffb1942:	8b 42 20             	mov    0x20(%edx),%eax
5ffb1945:	83 f8 01             	cmp    $0x1,%eax
5ffb1948:	b8 20 01 00 00       	mov    $0x120,%eax
5ffb194d:	19 c9                	sbb    %ecx,%ecx
5ffb194f:	31 d2                	xor    %edx,%edx
5ffb1951:	83 c1 02             	add    $0x2,%ecx
5ffb1954:	f7 f1                	div    %ecx
5ffb1956:	89 4d e4             	mov    %ecx,0xffffffe4(%ebp)
5ffb1959:	8b 4d 0c             	mov    0xc(%ebp),%ecx
5ffb195c:	66 8b 51 24          	mov    0x24(%ecx),%dx
5ffb1960:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
5ffb1963:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb1969:	39 d0                	cmp    %edx,%eax
5ffb196b:	76 03                	jbe    5ffb1970 <_CsrReadConsole@12+0x40>
5ffb196d:	89 55 e8             	mov    %edx,0xffffffe8(%ebp)
5ffb1970:	8d 47 24             	lea    0x24(%edi),%eax
5ffb1973:	66 c7 47 02 38 00    	movw   $0x38,0x2(%edi)
5ffb1979:	66 c7 07 20 00       	movw   $0x20,(%edi)
5ffb197e:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
5ffb1981:	56                   	push   %esi
5ffb1982:	56                   	push   %esi
5ffb1983:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
5ffb1986:	8b 4d 0c             	mov    0xc(%ebp),%ecx
5ffb1989:	8b 51 1c             	mov    0x1c(%ecx),%edx
5ffb198c:	89 d9                	mov    %ebx,%ecx
5ffb198e:	6a 01                	push   $0x1
5ffb1990:	50                   	push   %eax
5ffb1991:	e8 ea f6 ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
5ffb1996:	5a                   	pop    %edx
5ffb1997:	85 c0                	test   %eax,%eax
5ffb1999:	59                   	pop    %ecx
5ffb199a:	0f 88 7e 01 00 00    	js     5ffb1b1e <_CsrReadConsole@12+0x1ee>
5ffb19a0:	8b 43 18             	mov    0x18(%ebx),%eax
5ffb19a3:	31 f6                	xor    %esi,%esi
5ffb19a5:	89 47 1c             	mov    %eax,0x1c(%edi)
5ffb19a8:	3b 75 e8             	cmp    0xffffffe8(%ebp),%esi
5ffb19ab:	0f 83 65 01 00 00    	jae    5ffb1b16 <_CsrReadConsole@12+0x1e6>
5ffb19b1:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb19b4:	8d 41 2c             	lea    0x2c(%ecx),%eax
5ffb19b7:	8b 59 2c             	mov    0x2c(%ecx),%ebx
5ffb19ba:	39 c3                	cmp    %eax,%ebx
5ffb19bc:	74 50                	je     5ffb1a0e <_CsrReadConsole@12+0xde>
5ffb19be:	89 c2                	mov    %eax,%edx
5ffb19c0:	89 d8                	mov    %ebx,%eax
{
  PLIST_ENTRY Flink;
  PLIST_ENTRY Entry;

  Entry = ListHead->Flink;
5ffb19c2:	89 c3                	mov    %eax,%ebx
  Flink = Entry->Flink;
5ffb19c4:	8b 00                	mov    (%eax),%eax
  ListHead->Flink = Flink;
5ffb19c6:	89 41 2c             	mov    %eax,0x2c(%ecx)
  Console->EarlyReturn = FALSE;
  Console->ActiveBuffer = NULL;
  InitializeListHead(&Console->InputEvents);
  InitializeListHead(&Console->ProcessList);

  Console->CodePage = GetOEMCP();
  Console->OutputCodePage = GetOEMCP();

  SecurityAttributes.nLength = sizeof(SECURITY_ATTRIBUTES);
  SecurityAttributes.lpSecurityDescriptor = NULL;
  SecurityAttributes.bInheritHandle = TRUE;

  Console->ActiveEvent = CreateEventW(&SecurityAttributes, TRUE, FALSE, NULL);
  if (NULL == Console->ActiveEvent)
    {
      RtlFreeUnicodeString(&Console->Title);
      return STATUS_UNSUCCESSFUL;
    }
  Console->PrivateData = NULL;
  InitializeCriticalSection(&Console->Header.Lock);
  GuiMode = DtbgIsDesktopVisible();
  if (! GuiMode)
    {
      Status = TuiInitConsole(Console);
      if (! NT_SUCCESS(Status))
        {
          DPRINT1("Failed to open text-mode console, switching to gui-mode\n");
          GuiMode = TRUE;
        }
    }
  if (GuiMode)
    {
      Status = GuiInitConsole(Console);
      if (! NT_SUCCESS(Status))
        {
          RtlFreeUnicodeString(&Console->Title);
	  DeleteCriticalSection(&Console->Header.Lock);
          CloseHandle(Console->ActiveEvent);
          return Status;
        }
    }

  NewBuffer = HeapAlloc(Win32CsrApiHeap, 0, sizeof(CSRSS_SCREEN_BUFFER));
  if (NULL == NewBuffer)
    {
      ConioCleanupConsole(Console);
      RtlFreeUnicodeString(&Console->Title);
      DeleteCriticalSection(&Console->Header.Lock);
      CloseHandle(Console->ActiveEvent);
      return STATUS_INSUFFICIENT_RESOURCES;
    }
  Status = CsrInitConsoleScreenBuffer(Console, NewBuffer);
  if (! NT_SUCCESS(Status))
    {
      ConioCleanupConsole(Console);
      RtlFreeUnicodeString(&Console->Title);
      DeleteCriticalSection(&Console->Header.Lock);
      CloseHandle(Console->ActiveEvent);
      HeapFree(Win32CsrApiHeap, 0, NewBuffer);
      return Status;
    }
  Console->ActiveBuffer = NewBuffer;
  /* add a reference count because the buffer is tied to the console */
  Console->ActiveBuffer->Header.ReferenceCount++;
  /* make console active, and insert into console list */
  /* copy buffer contents to screen */
  ConioDrawConsole(Console);

  return STATUS_SUCCESS;
}


CSR_API(CsrAllocConsole)
{
  PCSRSS_CONSOLE Console;
  OBJECT_ATTRIBUTES ObjectAttributes;
  CLIENT_ID ClientId;
  HANDLE Process;
  NTSTATUS Status;

  DPRINT("CsrAllocConsole\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;

  if (ProcessData == NULL)
    {
      return Reply->Status = STATUS_INVALID_PARAMETER;
    }

  if (ProcessData->Console)
    {
      Reply->Status = STATUS_INVALID_PARAMETER;
      return STATUS_INVALID_PARAMETER;
    }

  Reply->Status = STATUS_SUCCESS;
  Console = HeapAlloc(Win32CsrApiHeap, 0, sizeof(CSRSS_CONSOLE));
  if (NULL == Console)
    {
      Reply->Status = STATUS_NO_MEMORY;
      return STATUS_NO_MEMORY;
    }
  Reply->Status = CsrInitConsole(Console);
  if (! NT_SUCCESS(Reply->Status))
    {
      HeapFree(Win32CsrApiHeap, 0, Console);
      return Reply->Status;
    }
  ProcessData->Console = Console;
  Reply->Data.AllocConsoleReply.Console = Console;

  /* add a reference count because the process is tied to the console */
  Console->Header.ReferenceCount++;
  Status = Win32CsrInsertObject(ProcessData, &Reply->Data.AllocConsoleReply.InputHandle, &Console->Header);
  if (! NT_SUCCESS(Status))
    {
      ConioDeleteConsole((Object_t *) Console);
      ProcessData->Console = 0;
      return Reply->Status = Status;
    }
  Status = Win32CsrInsertObject(ProcessData, &Reply->Data.AllocConsoleReply.OutputHandle, &Console->ActiveBuffer->Header);
  if (!NT_SUCCESS(Status))
    {
      Console->Header.ReferenceCount--;
      Win32CsrReleaseObject(ProcessData, Reply->Data.AllocConsoleReply.InputHandle);
      ProcessData->Console = 0;
      return Reply->Status = Status;
    }

  ClientId.UniqueThread = NULL;
  ClientId.UniqueProcess = ProcessData->ProcessId;
  InitializeObjectAttributes(&ObjectAttributes,
                             NULL,
                             0,
                             NULL,
                             NULL);

  /* using OpenProcess is not optimal due to HANDLE vs. DWORD PIDs... */
  Status = NtOpenProcess(&Process,
                         PROCESS_DUP_HANDLE,
                         &ObjectAttributes,
                         &ClientId);
  if (!NT_SUCCESS(Status))
    {
      DPRINT1("NtOpenProcess() failed for handle duplication, Status: 0x%x\n", Status);
      Console->Header.ReferenceCount--;
      ProcessData->Console = 0;
      Win32CsrReleaseObject(ProcessData, Reply->Data.AllocConsoleReply.OutputHandle);
      Win32CsrReleaseObject(ProcessData, Reply->Data.AllocConsoleReply.InputHandle);
      Reply->Status = Status;
      return Status;
    }

  if (! DuplicateHandle(GetCurrentProcess(), ProcessData->Console->ActiveEvent,
                        Process, &ProcessData->ConsoleEvent, EVENT_ALL_ACCESS, FALSE, 0))
    {
      DPRINT1("DuplicateHandle() failed: %d\n", GetLastError);
      CloseHandle(Process);
      Console->Header.ReferenceCount--;
      Win32CsrReleaseObject(ProcessData, Reply->Data.AllocConsoleReply.OutputHandle);
      Win32CsrReleaseObject(ProcessData, Reply->Data.AllocConsoleReply.InputHandle);
      ProcessData->Console = 0;
      Reply->Status = Status;
      return Status;
    }
  CloseHandle(Process);
  ProcessData->CtrlDispatcher = Request->Data.AllocConsoleRequest.CtrlDispatcher;
  DPRINT("CSRSS:CtrlDispatcher address: %x\n", ProcessData->CtrlDispatcher);      
  InsertHeadList(&ProcessData->Console->ProcessList, &ProcessData->ProcessEntry);

  return STATUS_SUCCESS;
}

CSR_API(CsrFreeConsole)
{
  PCSRSS_CONSOLE Console;

  DPRINT("CsrFreeConsole\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;

  if (ProcessData == NULL || ProcessData->Console == NULL)
    {
      return Reply->Status = STATUS_INVALID_PARAMETER;
    }

  Console = ProcessData->Console;
  Console->Header.ReferenceCount--;
  ProcessData->Console = NULL;
  if (0 == Console->Header.ReferenceCount)
    {
      ConioDeleteConsole((Object_t *) Console);
    }
   
  return STATUS_SUCCESS;
}

STATIC VOID FASTCALL
ConioNextLine(PCSRSS_SCREEN_BUFFER Buff, RECT *UpdateRect, UINT *ScrolledLines)
{
  /* slide the viewable screen */
  if (((Buff->CurrentY - Buff->ShowY + Buff->MaxY) % Buff->MaxY) == Buff->MaxY - 1)
    {
      if (++Buff->ShowY == Buff->MaxY)
        {
          Buff->ShowY = 0;
        }
      (*ScrolledLines)++;
    }
  if (++Buff->CurrentY == Buff->MaxY)
    {
      Buff->CurrentY = 0;
    }
  ClearLineBuffer(Buff);
  UpdateRect->left = 0;
  UpdateRect->right = Buff->MaxX - 1;
  if (UpdateRect->top == Buff->CurrentY)
    {
      if (++UpdateRect->top == Buff->MaxY)
        {
          UpdateRect->top = 0;
        }
    }
  UpdateRect->bottom = Buff->CurrentY;
}

STATIC NTSTATUS FASTCALL
ConioWriteConsole(PCSRSS_CONSOLE Console, PCSRSS_SCREEN_BUFFER Buff,
                  CHAR *Buffer, DWORD Length, BOOL Attrib)
{
  int i;
  DWORD Offset;
  RECT UpdateRect;
  LONG CursorStartX, CursorStartY;
  UINT ScrolledLines;

  ConioPhysicalToLogical(Buff, Buff->CurrentX, Buff->CurrentY, &CursorStartX, &CursorStartY);
  UpdateRect.left = Buff->MaxX;
  UpdateRect.top = Buff->CurrentY;
  UpdateRect.right = -1;
  UpdateRect.bottom = Buff->CurrentY;
  ScrolledLines = 0;

  for (i = 0; i < Length; i++)
    {
      if (Buff->Mode & ENABLE_PROCESSED_OUTPUT)
        {
          /* --- LF --- */
          if (Buffer[i] == '\n')
            {
              Buff->CurrentX = 0;
              ConioNextLine(Buff, &UpdateRect, &ScrolledLines);
              continue;
            }
          /* --- BS --- */
          else if (Buffer[i] == '\b')
            {
              /* Only handle BS if we're not on the first pos of the first line */
              if (0 != Buff->CurrentX || Buff->ShowY != Buff->CurrentY)
                {
                  if (0 == Buff->CurrentX)
                    {
                      /* slide virtual position up */
                      Buff->CurrentX = Buff->MaxX - 1;
                      if (0 == Buff->CurrentY)
                        {
                          Buff->CurrentY = Buff->MaxY;
                        }
                      else
                        {
                          Buff->CurrentY--;
                        }
                      if ((0 == UpdateRect.top && UpdateRect.bottom < Buff->CurrentY)
                          || (0 != UpdateRect.top && Buff->CurrentY < UpdateRect.top))
                        {
                          UpdateRect.top = Buff->CurrentY;
                        }
                    }
                  else
                    {
                       Buff->CurrentX--;
                    }
                  Offset = 2 * ((Buff->CurrentY * Buff->MaxX) + Buff->CurrentX);
                  SET_CELL_BUFFER(Buff, Offset, ' ', Buff->DefaultAttrib);
                  UpdateRect.left = RtlRosMin(UpdateRect.left, Buff->CurrentX);
                  UpdateRect.right = RtlRosMax(UpdateRect.right, (LONG) Buff->CurrentX);
                }
                continue;
            }
          /* --- CR --- */
          else if (Buffer[i] == '\r')
            {
              Buff->CurrentX = 0;
              UpdateRect.left = RtlRosMin(UpdateRect.left, Buff->CurrentX);
              UpdateRect.right = RtlRosMax(UpdateRect.right, (LONG) Buff->CurrentX);
              continue;
            }
          /* --- TAB --- */
          else if (Buffer[i] == '\t')
            {
              UINT EndX;

              UpdateRect.left = RtlRosMin(UpdateRect.left, Buff->CurrentX);
              EndX = (Buff->CurrentX + 8) & ~7;
              if (EndX > Buff->MaxX)
                {
                  EndX = Buff->MaxX;
                }
              Offset = 2 * (((Buff->CurrentY * Buff->MaxX)) + Buff->CurrentX);
              while (Buff->CurrentX < EndX)
                {
                  Buff->Buffer[Offset] = ' ';
                  Offset += 2;
                  Buff->CurrentX++;
                }
              UpdateRect.right = RtlRosMax(UpdateRect.right, (LONG) Buff->CurrentX - 1);
              if (Buff->CurrentX == Buff->MaxX)
                {
                  if (Buff->Mode & ENABLE_WRAP_AT_EOL_OUTPUT)
                    {
                      Buff->CurrentX = 0;
                      ConioNextLine(Buff, &UpdateRect, &ScrolledLines);
                    }
                  else
                    {
                      Buff->CurrentX--;
                    }
                }
              continue;
            }
        }
      UpdateRect.left = RtlRosMin(UpdateRect.left, Buff->CurrentX);
      UpdateRect.right = RtlRosMax(UpdateRect.right, (LONG) Buff->CurrentX);
      Offset = 2 * (((Buff->CurrentY * Buff->MaxX)) + Buff->CurrentX);
      Buff->Buffer[Offset++] = Buffer[i];
      if (Attrib)
        {
          Buff->Buffer[Offset] = Buff->DefaultAttrib;
        }
      Buff->CurrentX++;
      if (Buff->CurrentX == Buff->MaxX)
        {
          if (Buff->Mode & ENABLE_WRAP_AT_EOL_OUTPUT)
            {
              Buff->CurrentX = 0;
              ConioNextLine(Buff, &UpdateRect, &ScrolledLines);
            }
          else
            {
              Buff->CurrentX = CursorStartX;
            }
        }
    }

  ConioPhysicalToLogical(Buff, UpdateRect.left, UpdateRect.top, &(UpdateRect.left),
                         &(UpdateRect.top));
  ConioPhysicalToLogical(Buff, UpdateRect.right, UpdateRect.bottom, &(UpdateRect.right),
                         &(UpdateRect.bottom));
  if (! ConioIsRectEmpty(&UpdateRect) && NULL != Console && Buff == Console->ActiveBuffer)
    {
      ConioWriteStream(Console, &UpdateRect, CursorStartX, CursorStartY, ScrolledLines,
                       Buffer, Length);
    }

  return STATUS_SUCCESS;
}

CSR_API(CsrReadConsole)
{
  PLIST_ENTRY CurrentEntry;
  ConsoleInput *Input;
  PUCHAR Buffer;
  PWCHAR UnicodeBuffer;
  int i;
  ULONG nNumberOfCharsToRead, CharSize;
  PCSRSS_CONSOLE Console;
  NTSTATUS Status;
   
  DPRINT("CsrReadConsole\n");
  
  CharSize = (Request->Data.ReadConsoleRequest.Unicode ? sizeof(WCHAR) : sizeof(CHAR));

  /* truncate length to CSRSS_MAX_READ_CONSOLE_REQUEST */
  nNumberOfCharsToRead = min(Request->Data.ReadConsoleRequest.NrCharactersToRead, CSRSS_MAX_READ_CONSOLE_REQUEST / CharSize);
  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = Reply->Header.MessageSize - LPC_MESSAGE_BASE_SIZE;

  Buffer = Reply->Data.ReadConsoleReply.Buffer;
  UnicodeBuffer = (PWCHAR)Buffer;
  Status = ConioLockConsole(ProcessData, Request->Data.ReadConsoleRequest.ConsoleHandle,
                               &Console);
  if (! NT_SUCCESS(Status))
    {
      return Reply->Status = Status;
    }
  Reply->Data.ReadConsoleReply.EventHandle = ProcessData->ConsoleEvent;
  for (i = 0; i < nNumberOfCharsToRead && Console->InputEvents.Flink != &Console->InputEvents; i++)
    {
      /* remove input event from queue */
      CurrentEntry = RemoveHeadList(&Console->InputEvents);
      if (IsListEmpty(&Console->InputEvents))
5ffb19c9:	39 d0                	cmp    %edx,%eax

  Entry = ListHead->Flink;
  Flink = Entry->Flink;
  ListHead->Flink = Flink;
  Flink->Blink = ListHead;
5ffb19cb:	89 50 04             	mov    %edx,0x4(%eax)
5ffb19ce:	0f 84 9c 01 00 00    	je     5ffb1b70 <_CsrReadConsole@12+0x240>
      {
         CHECKPOINT;
         ResetEvent(Console->ActiveEvent);
      }
      Input = CONTAINING_RECORD(CurrentEntry, ConsoleInput, ListEntry);

      /* only pay attention to valid ascii chars, on key down */
      if (KEY_EVENT == Input->InputEvent.EventType
5ffb19d4:	66 83 7b 08 01       	cmpw   $0x1,0x8(%ebx)
5ffb19d9:	0f 84 91 00 00 00    	je     5ffb1a70 <_CsrReadConsole@12+0x140>
          && Input->InputEvent.Event.KeyEvent.bKeyDown
          && Input->InputEvent.Event.KeyEvent.uChar.AsciiChar != '\0')
        {
          /* backspace handling */
          if ('\b' == Input->InputEvent.Event.KeyEvent.uChar.AsciiChar)
            {
              /* echo if it has not already been done, and either we or the client has chars to be deleted */
              if (! Input->Echoed
                  && (0 !=  i || Request->Data.ReadConsoleRequest.nCharsCanBeDeleted))
                {
                  ConioWriteConsole(Console, Console->ActiveBuffer,
                                    &Input->InputEvent.Event.KeyEvent.uChar.AsciiChar, 1, TRUE);
                }
              if (0 != i)
                {
                  i -= 2;        /* if we already have something to return, just back it up by 2 */
                }
              else
                {            /* otherwise, return STATUS_NOTIFY_CLEANUP to tell client to back up its buffer */
                  Console->WaitingChars--;
                  ConioUnlockConsole(Console);
                  HeapFree(Win32CsrApiHeap, 0, Input);
                  Reply->Data.ReadConsoleReply.NrCharactersRead = 0;
                  Reply->Status = STATUS_NOTIFY_CLEANUP;
                  return STATUS_NOTIFY_CLEANUP;
                }
              Request->Data.ReadConsoleRequest.nCharsCanBeDeleted--;
              Input->Echoed = TRUE;   /* mark as echoed so we don't echo it below */
            }
          /* do not copy backspace to buffer */
          else
            {
              if(Request->Data.ReadConsoleRequest.Unicode)
                UnicodeBuffer[i] = Input->InputEvent.Event.KeyEvent.uChar.AsciiChar; /* FIXME */
              else
                Buffer[i] = Input->InputEvent.Event.KeyEvent.uChar.AsciiChar;
            }
          /* echo to screen if enabled and we did not already echo the char */
          if (0 != (Console->Mode & ENABLE_ECHO_INPUT)
              && ! Input->Echoed
              && '\r' != Input->InputEvent.Event.KeyEvent.uChar.AsciiChar)
            {
              ConioWriteConsole(Console, Console->ActiveBuffer,
                               &Input->InputEvent.Event.KeyEvent.uChar.AsciiChar, 1, TRUE);
            }
        }
      else
        {
          i--;
5ffb19df:	4e                   	dec    %esi
5ffb19e0:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
        }
      Console->WaitingChars--;
5ffb19e3:	66 ff 49 34          	decw   0x34(%ecx)
      HeapFree(Win32CsrApiHeap, 0, Input);
5ffb19e7:	50                   	push   %eax
5ffb19e8:	53                   	push   %ebx
5ffb19e9:	6a 00                	push   $0x0
5ffb19eb:	46                   	inc    %esi
5ffb19ec:	a1 e0 c1 fb 5f       	mov    0x5ffbc1e0,%eax
5ffb19f1:	50                   	push   %eax
5ffb19f2:	e8 09 73 00 00       	call   5ffb8d00 <_HeapFree@12>
5ffb19f7:	3b 75 e8             	cmp    0xffffffe8(%ebp),%esi
5ffb19fa:	58                   	pop    %eax
5ffb19fb:	0f 83 15 01 00 00    	jae    5ffb1b16 <_CsrReadConsole@12+0x1e6>
5ffb1a01:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb1a04:	8d 51 2c             	lea    0x2c(%ecx),%edx
5ffb1a07:	8b 41 2c             	mov    0x2c(%ecx),%eax
5ffb1a0a:	39 d0                	cmp    %edx,%eax
5ffb1a0c:	75 b4                	jne    5ffb19c2 <_CsrReadConsole@12+0x92>
    }
  Reply->Data.ReadConsoleReply.NrCharactersRead = i;
5ffb1a0e:	89 77 20             	mov    %esi,0x20(%edi)
  if (0 == i)
5ffb1a11:	85 f6                	test   %esi,%esi
5ffb1a13:	0f 84 c7 00 00 00    	je     5ffb1ae0 <_CsrReadConsole@12+0x1b0>
    {
      Reply->Status = STATUS_PENDING;    /* we didn't read anything */
    }
  else if (0 != (Console->Mode & ENABLE_LINE_INPUT))
5ffb1a19:	f6 41 3c 02          	testb  $0x2,0x3c(%ecx)
5ffb1a1d:	74 2b                	je     5ffb1a4a <_CsrReadConsole@12+0x11a>
    {
      if (0 == Console->WaitingLines ||
5ffb1a1f:	66 83 79 36 00       	cmpw   $0x0,0x36(%ecx)
5ffb1a24:	0f 84 b6 00 00 00    	je     5ffb1ae0 <_CsrReadConsole@12+0x1b0>
5ffb1a2a:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb1a2d:	8b 40 20             	mov    0x20(%eax),%eax
5ffb1a30:	85 c0                	test   %eax,%eax
5ffb1a32:	0f 85 57 01 00 00    	jne    5ffb1b8f <_CsrReadConsole@12+0x25f>
5ffb1a38:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb1a3b:	80 7c 30 ff 0a       	cmpb   $0xa,0xffffffff(%eax,%esi,1)
5ffb1a40:	0f 85 9a 00 00 00    	jne    5ffb1ae0 <_CsrReadConsole@12+0x1b0>
          (Request->Data.ReadConsoleRequest.Unicode ? (L'\n' != UnicodeBuffer[i - 1]) : ('\n' != Buffer[i - 1])))
        {
          Reply->Status = STATUS_PENDING; /* line buffered, didn't get a complete line */
        }
      else
        {
          Console->WaitingLines--;
5ffb1a46:	66 ff 49 36          	decw   0x36(%ecx)
          Reply->Status = STATUS_SUCCESS; /* line buffered, did get a complete line */
        }
    }
  else
    {
      Reply->Status = STATUS_SUCCESS;  /* not line buffered, did read something */
5ffb1a4a:	c7 47 18 00 00 00 00 	movl   $0x0,0x18(%edi)
    }

  if (Reply->Status == STATUS_PENDING)
5ffb1a51:	81 7f 18 03 01 00 00 	cmpl   $0x103,0x18(%edi)
5ffb1a58:	0f 85 96 00 00 00    	jne    5ffb1af4 <_CsrReadConsole@12+0x1c4>
    {
      Console->EchoCount = nNumberOfCharsToRead - i;
5ffb1a5e:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
5ffb1a61:	66 29 f0             	sub    %si,%ax
5ffb1a64:	66 89 41 3e          	mov    %ax,0x3e(%ecx)
5ffb1a68:	e9 8d 00 00 00       	jmp    5ffb1afa <_CsrReadConsole@12+0x1ca>
5ffb1a6d:	8d 76 00             	lea    0x0(%esi),%esi
5ffb1a70:	8b 43 0c             	mov    0xc(%ebx),%eax
5ffb1a73:	85 c0                	test   %eax,%eax
5ffb1a75:	0f 84 64 ff ff ff    	je     5ffb19df <_CsrReadConsole@12+0xaf>
5ffb1a7b:	8a 43 16             	mov    0x16(%ebx),%al
5ffb1a7e:	84 c0                	test   %al,%al
5ffb1a80:	0f 84 59 ff ff ff    	je     5ffb19df <_CsrReadConsole@12+0xaf>
5ffb1a86:	3c 08                	cmp    $0x8,%al
5ffb1a88:	0f 84 9d 00 00 00    	je     5ffb1b2b <_CsrReadConsole@12+0x1fb>
5ffb1a8e:	8b 4d 0c             	mov    0xc(%ebp),%ecx
5ffb1a91:	8b 49 20             	mov    0x20(%ecx),%ecx
5ffb1a94:	85 c9                	test   %ecx,%ecx
5ffb1a96:	0f 84 e8 00 00 00    	je     5ffb1b84 <_CsrReadConsole@12+0x254>
5ffb1a9c:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
5ffb1a9f:	66 98                	cbtw   
5ffb1aa1:	66 89 04 72          	mov    %ax,(%edx,%esi,2)
5ffb1aa5:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb1aa8:	f6 41 3c 04          	testb  $0x4,0x3c(%ecx)
5ffb1aac:	0f 84 31 ff ff ff    	je     5ffb19e3 <_CsrReadConsole@12+0xb3>
5ffb1ab2:	80 7b 1c 00          	cmpb   $0x0,0x1c(%ebx)
5ffb1ab6:	0f 85 27 ff ff ff    	jne    5ffb19e3 <_CsrReadConsole@12+0xb3>
5ffb1abc:	80 7b 16 0d          	cmpb   $0xd,0x16(%ebx)
5ffb1ac0:	0f 84 1d ff ff ff    	je     5ffb19e3 <_CsrReadConsole@12+0xb3>
5ffb1ac6:	52                   	push   %edx
5ffb1ac7:	8b 51 38             	mov    0x38(%ecx),%edx
5ffb1aca:	8d 43 16             	lea    0x16(%ebx),%eax
5ffb1acd:	6a 01                	push   $0x1
5ffb1acf:	6a 01                	push   $0x1
5ffb1ad1:	50                   	push   %eax
5ffb1ad2:	e8 09 fb ff ff       	call   5ffb15e0 <@ConioWriteConsole@20>
5ffb1ad7:	58                   	pop    %eax
5ffb1ad8:	e9 03 ff ff ff       	jmp    5ffb19e0 <_CsrReadConsole@12+0xb0>
5ffb1add:	8d 76 00             	lea    0x0(%esi),%esi
5ffb1ae0:	c7 47 18 03 01 00 00 	movl   $0x103,0x18(%edi)
5ffb1ae7:	81 7f 18 03 01 00 00 	cmpl   $0x103,0x18(%edi)
5ffb1aee:	0f 84 6a ff ff ff    	je     5ffb1a5e <_CsrReadConsole@12+0x12e>
    }
  else
    {
      Console->EchoCount = 0;             /* if the client is no longer waiting on input, do not echo */
5ffb1af4:	66 c7 41 3e 00 00    	movw   $0x0,0x3e(%ecx)
    }
  Reply->Header.MessageSize += i * CharSize;
5ffb1afa:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
5ffb1afd:	0f af f0             	imul   %eax,%esi
5ffb1b00:	66 01 77 02          	add    %si,0x2(%edi)

  ConioUnlockConsole(Console);
5ffb1b04:	e8 b7 f5 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
  return Reply->Status;
5ffb1b09:	8b 47 18             	mov    0x18(%edi),%eax
}
5ffb1b0c:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb1b0f:	5b                   	pop    %ebx
5ffb1b10:	5e                   	pop    %esi
5ffb1b11:	5f                   	pop    %edi
5ffb1b12:	5d                   	pop    %ebp
5ffb1b13:	c2 0c 00             	ret    $0xc
5ffb1b16:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb1b19:	e9 f0 fe ff ff       	jmp    5ffb1a0e <_CsrReadConsole@12+0xde>
5ffb1b1e:	89 47 18             	mov    %eax,0x18(%edi)
5ffb1b21:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb1b24:	5b                   	pop    %ebx
5ffb1b25:	5e                   	pop    %esi
5ffb1b26:	5f                   	pop    %edi
5ffb1b27:	5d                   	pop    %ebp
5ffb1b28:	c2 0c 00             	ret    $0xc
5ffb1b2b:	80 7b 1c 00          	cmpb   $0x0,0x1c(%ebx)
5ffb1b2f:	75 23                	jne    5ffb1b54 <_CsrReadConsole@12+0x224>
5ffb1b31:	85 f6                	test   %esi,%esi
5ffb1b33:	75 0a                	jne    5ffb1b3f <_CsrReadConsole@12+0x20f>
5ffb1b35:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb1b38:	66 83 78 26 00       	cmpw   $0x0,0x26(%eax)
5ffb1b3d:	74 5e                	je     5ffb1b9d <_CsrReadConsole@12+0x26d>
5ffb1b3f:	50                   	push   %eax
5ffb1b40:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb1b43:	8d 43 16             	lea    0x16(%ebx),%eax
5ffb1b46:	8b 51 38             	mov    0x38(%ecx),%edx
5ffb1b49:	6a 01                	push   $0x1
5ffb1b4b:	6a 01                	push   $0x1
5ffb1b4d:	50                   	push   %eax
5ffb1b4e:	e8 8d fa ff ff       	call   5ffb15e0 <@ConioWriteConsole@20>
5ffb1b53:	58                   	pop    %eax
5ffb1b54:	85 f6                	test   %esi,%esi
5ffb1b56:	74 45                	je     5ffb1b9d <_CsrReadConsole@12+0x26d>
5ffb1b58:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb1b5b:	83 ee 02             	sub    $0x2,%esi
5ffb1b5e:	66 ff 4a 26          	decw   0x26(%edx)
5ffb1b62:	c6 43 1c 01          	movb   $0x1,0x1c(%ebx)
5ffb1b66:	e9 3a ff ff ff       	jmp    5ffb1aa5 <_CsrReadConsole@12+0x175>
5ffb1b6b:	90                   	nop    
5ffb1b6c:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb1b70:	83 ec 0c             	sub    $0xc,%esp
5ffb1b73:	8b 41 28             	mov    0x28(%ecx),%eax
5ffb1b76:	50                   	push   %eax
5ffb1b77:	e8 94 71 00 00       	call   5ffb8d10 <_ResetEvent@4>
5ffb1b7c:	83 c4 0c             	add    $0xc,%esp
5ffb1b7f:	e9 50 fe ff ff       	jmp    5ffb19d4 <_CsrReadConsole@12+0xa4>
5ffb1b84:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
5ffb1b87:	88 04 0e             	mov    %al,(%esi,%ecx,1)
5ffb1b8a:	e9 16 ff ff ff       	jmp    5ffb1aa5 <_CsrReadConsole@12+0x175>
5ffb1b8f:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
5ffb1b92:	66 83 7c 72 fe 0a    	cmpw   $0xa,0xfffffffe(%edx,%esi,2)
5ffb1b98:	e9 a3 fe ff ff       	jmp    5ffb1a40 <_CsrReadConsole@12+0x110>
5ffb1b9d:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb1ba0:	66 ff 49 34          	decw   0x34(%ecx)
5ffb1ba4:	e8 17 f5 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb1ba9:	56                   	push   %esi
5ffb1baa:	53                   	push   %ebx
5ffb1bab:	6a 00                	push   $0x0
5ffb1bad:	8b 1d e0 c1 fb 5f    	mov    0x5ffbc1e0,%ebx
5ffb1bb3:	53                   	push   %ebx
5ffb1bb4:	e8 47 71 00 00       	call   5ffb8d00 <_HeapFree@12>
5ffb1bb9:	b8 0b 01 00 00       	mov    $0x10b,%eax
5ffb1bbe:	c7 47 20 00 00 00 00 	movl   $0x0,0x20(%edi)
5ffb1bc5:	c7 47 18 0b 01 00 00 	movl   $0x10b,0x18(%edi)
5ffb1bcc:	e9 3b ff ff ff       	jmp    5ffb1b0c <_CsrReadConsole@12+0x1dc>
5ffb1bd1:	eb 0d                	jmp    5ffb1be0 <_ConioIsEqualRect>
5ffb1bd3:	90                   	nop    
5ffb1bd4:	90                   	nop    
5ffb1bd5:	90                   	nop    
5ffb1bd6:	90                   	nop    
5ffb1bd7:	90                   	nop    
5ffb1bd8:	90                   	nop    
5ffb1bd9:	90                   	nop    
5ffb1bda:	90                   	nop    
5ffb1bdb:	90                   	nop    
5ffb1bdc:	90                   	nop    
5ffb1bdd:	90                   	nop    
5ffb1bde:	90                   	nop    
5ffb1bdf:	90                   	nop    

5ffb1be0 <_ConioIsEqualRect>:

VOID FASTCALL
ConioPhysicalToLogical(PCSRSS_SCREEN_BUFFER Buff,
                       ULONG PhysicalX,
                       ULONG PhysicalY,
                       LONG *LogicalX,
                       LONG *LogicalY)
{
   *LogicalX = PhysicalX;
   if (PhysicalY < Buff->ShowY)
     {
       *LogicalY = Buff->MaxY - Buff->ShowY + PhysicalY;
     }
   else
     {
       *LogicalY = PhysicalY - Buff->ShowY;
     }
}

inline BOOLEAN ConioIsEqualRect(
  RECT *Rect1,
  RECT *Rect2)
{
5ffb1be0:	55                   	push   %ebp
5ffb1be1:	89 e5                	mov    %esp,%ebp
5ffb1be3:	53                   	push   %ebx
  return ((Rect1->left == Rect2->left) && (Rect1->right == Rect2->right) &&
5ffb1be4:	31 db                	xor    %ebx,%ebx
5ffb1be6:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb1be9:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb1bec:	8b 02                	mov    (%edx),%eax
5ffb1bee:	39 01                	cmp    %eax,(%ecx)
5ffb1bf0:	74 05                	je     5ffb1bf7 <_ConioIsEqualRect+0x17>
	  (Rect1->top == Rect2->top) && (Rect1->bottom == Rect2->bottom));
}
5ffb1bf2:	89 d8                	mov    %ebx,%eax
5ffb1bf4:	5b                   	pop    %ebx
5ffb1bf5:	5d                   	pop    %ebp
5ffb1bf6:	c3                   	ret    
5ffb1bf7:	8b 42 08             	mov    0x8(%edx),%eax
5ffb1bfa:	39 41 08             	cmp    %eax,0x8(%ecx)
5ffb1bfd:	75 f3                	jne    5ffb1bf2 <_ConioIsEqualRect+0x12>
5ffb1bff:	8b 42 04             	mov    0x4(%edx),%eax
5ffb1c02:	39 41 04             	cmp    %eax,0x4(%ecx)
5ffb1c05:	75 eb                	jne    5ffb1bf2 <_ConioIsEqualRect+0x12>
5ffb1c07:	8b 42 0c             	mov    0xc(%edx),%eax
5ffb1c0a:	39 41 0c             	cmp    %eax,0xc(%ecx)
5ffb1c0d:	75 e3                	jne    5ffb1bf2 <_ConioIsEqualRect+0x12>
5ffb1c0f:	b3 01                	mov    $0x1,%bl
5ffb1c11:	89 d8                	mov    %ebx,%eax
5ffb1c13:	5b                   	pop    %ebx
5ffb1c14:	5d                   	pop    %ebp
5ffb1c15:	c3                   	ret    
5ffb1c16:	8d 76 00             	lea    0x0(%esi),%esi
5ffb1c19:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb1c20 <_ConioGetIntersection>:

inline BOOLEAN ConioGetIntersection(
  RECT *Intersection,
  RECT *Rect1,
  RECT *Rect2)
{
5ffb1c20:	55                   	push   %ebp
5ffb1c21:	89 e5                	mov    %esp,%ebp
5ffb1c23:	57                   	push   %edi
5ffb1c24:	56                   	push   %esi
5ffb1c25:	53                   	push   %ebx
5ffb1c26:	83 ec 14             	sub    $0x14,%esp
5ffb1c29:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb1c2c:	8b 55 08             	mov    0x8(%ebp),%edx
5ffb1c2f:	8b 5d 10             	mov    0x10(%ebp),%ebx
  if (ConioIsRectEmpty(Rect1) ||
5ffb1c32:	8b 08                	mov    (%eax),%ecx
5ffb1c34:	8b 70 08             	mov    0x8(%eax),%esi
5ffb1c37:	39 f1                	cmp    %esi,%ecx
5ffb1c39:	7f 0d                	jg     5ffb1c48 <_ConioGetIntersection+0x28>
5ffb1c3b:	8b 78 04             	mov    0x4(%eax),%edi
5ffb1c3e:	8b 40 0c             	mov    0xc(%eax),%eax
5ffb1c41:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
5ffb1c44:	39 c7                	cmp    %eax,%edi
5ffb1c46:	7e 28                	jle    5ffb1c70 <_ConioGetIntersection+0x50>
    (ConioIsRectEmpty(Rect2)) ||
    (Rect1->top > Rect2->bottom) ||
    (Rect1->left > Rect2->right) ||
    (Rect1->bottom < Rect2->top) ||
    (Rect1->right < Rect2->left))
  {
    /* The rectangles do not intersect */
    ConioInitRect(Intersection, 0, -1, 0, -1);
5ffb1c48:	c7 42 04 00 00 00 00 	movl   $0x0,0x4(%edx)
5ffb1c4f:	c7 02 ff ff ff ff    	movl   $0xffffffff,(%edx)
5ffb1c55:	c7 42 0c 00 00 00 00 	movl   $0x0,0xc(%edx)
5ffb1c5c:	c7 42 08 ff ff ff ff 	movl   $0xffffffff,0x8(%edx)
    return FALSE;
5ffb1c63:	31 c0                	xor    %eax,%eax
  }

  ConioInitRect(Intersection,
               RtlRosMax(Rect1->top, Rect2->top),
               RtlRosMax(Rect1->left, Rect2->left),
               RtlRosMin(Rect1->bottom, Rect2->bottom),
               RtlRosMin(Rect1->right, Rect2->right));

  return TRUE;
}
5ffb1c65:	83 c4 14             	add    $0x14,%esp
5ffb1c68:	5b                   	pop    %ebx
5ffb1c69:	5e                   	pop    %esi
5ffb1c6a:	5f                   	pop    %edi
5ffb1c6b:	5d                   	pop    %ebp
5ffb1c6c:	c3                   	ret    
5ffb1c6d:	8d 76 00             	lea    0x0(%esi),%esi
5ffb1c70:	8b 03                	mov    (%ebx),%eax
5ffb1c72:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
5ffb1c75:	8b 43 08             	mov    0x8(%ebx),%eax
5ffb1c78:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
5ffb1c7b:	39 45 f0             	cmp    %eax,0xfffffff0(%ebp)
5ffb1c7e:	7f c8                	jg     5ffb1c48 <_ConioGetIntersection+0x28>
5ffb1c80:	8b 43 04             	mov    0x4(%ebx),%eax
5ffb1c83:	8b 5b 0c             	mov    0xc(%ebx),%ebx
5ffb1c86:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
5ffb1c89:	39 d8                	cmp    %ebx,%eax
5ffb1c8b:	7f bb                	jg     5ffb1c48 <_ConioGetIntersection+0x28>
5ffb1c8d:	39 df                	cmp    %ebx,%edi
5ffb1c8f:	7f b7                	jg     5ffb1c48 <_ConioGetIntersection+0x28>
5ffb1c91:	3b 4d ec             	cmp    0xffffffec(%ebp),%ecx
5ffb1c94:	7f b2                	jg     5ffb1c48 <_ConioGetIntersection+0x28>
5ffb1c96:	39 45 e0             	cmp    %eax,0xffffffe0(%ebp)
5ffb1c99:	7c ad                	jl     5ffb1c48 <_ConioGetIntersection+0x28>
5ffb1c9b:	3b 75 f0             	cmp    0xfffffff0(%ebp),%esi
5ffb1c9e:	7c a8                	jl     5ffb1c48 <_ConioGetIntersection+0x28>
5ffb1ca0:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
5ffb1ca3:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
5ffb1ca6:	39 f8                	cmp    %edi,%eax
5ffb1ca8:	7d 03                	jge    5ffb1cad <_ConioGetIntersection+0x8d>
5ffb1caa:	89 7d e4             	mov    %edi,0xffffffe4(%ebp)
5ffb1cad:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
5ffb1cb0:	8b 7d f0             	mov    0xfffffff0(%ebp),%edi
5ffb1cb3:	89 42 04             	mov    %eax,0x4(%edx)
5ffb1cb6:	39 cf                	cmp    %ecx,%edi
5ffb1cb8:	7d 02                	jge    5ffb1cbc <_ConioGetIntersection+0x9c>
5ffb1cba:	89 cf                	mov    %ecx,%edi
5ffb1cbc:	89 3a                	mov    %edi,(%edx)
5ffb1cbe:	89 d9                	mov    %ebx,%ecx
5ffb1cc0:	3b 5d e0             	cmp    0xffffffe0(%ebp),%ebx
5ffb1cc3:	7e 03                	jle    5ffb1cc8 <_ConioGetIntersection+0xa8>
5ffb1cc5:	8b 4d e0             	mov    0xffffffe0(%ebp),%ecx
5ffb1cc8:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb1ccb:	89 4a 0c             	mov    %ecx,0xc(%edx)
5ffb1cce:	39 f0                	cmp    %esi,%eax
5ffb1cd0:	7e 02                	jle    5ffb1cd4 <_ConioGetIntersection+0xb4>
5ffb1cd2:	89 f0                	mov    %esi,%eax
5ffb1cd4:	89 42 08             	mov    %eax,0x8(%edx)
5ffb1cd7:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb1cdc:	eb 87                	jmp    5ffb1c65 <_ConioGetIntersection+0x45>
5ffb1cde:	89 f6                	mov    %esi,%esi

5ffb1ce0 <_ConioGetUnion>:

inline BOOLEAN ConioGetUnion(
  RECT *Union,
  RECT *Rect1,
  RECT *Rect2)
{
5ffb1ce0:	55                   	push   %ebp
5ffb1ce1:	89 e5                	mov    %esp,%ebp
5ffb1ce3:	57                   	push   %edi
5ffb1ce4:	56                   	push   %esi
5ffb1ce5:	53                   	push   %ebx
5ffb1ce6:	83 ec 14             	sub    $0x14,%esp
5ffb1ce9:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb1cec:	8b 5d 08             	mov    0x8(%ebp),%ebx
5ffb1cef:	8b 4d 10             	mov    0x10(%ebp),%ecx
  if (ConioIsRectEmpty(Rect1))
5ffb1cf2:	8b 02                	mov    (%edx),%eax
5ffb1cf4:	8b 7a 08             	mov    0x8(%edx),%edi
5ffb1cf7:	39 f8                	cmp    %edi,%eax
5ffb1cf9:	7f 11                	jg     5ffb1d0c <_ConioGetUnion+0x2c>
5ffb1cfb:	8b 72 04             	mov    0x4(%edx),%esi
5ffb1cfe:	89 75 e0             	mov    %esi,0xffffffe0(%ebp)
5ffb1d01:	8b 72 0c             	mov    0xc(%edx),%esi
5ffb1d04:	89 75 f0             	mov    %esi,0xfffffff0(%ebp)
5ffb1d07:	39 75 e0             	cmp    %esi,0xffffffe0(%ebp)
5ffb1d0a:	7e 55                	jle    5ffb1d61 <_ConioGetUnion+0x81>
    {
      if (ConioIsRectEmpty(Rect2))
5ffb1d0c:	8b 11                	mov    (%ecx),%edx
5ffb1d0e:	3b 51 08             	cmp    0x8(%ecx),%edx
5ffb1d11:	7e 25                	jle    5ffb1d38 <_ConioGetUnion+0x58>
        {
          ConioInitRect(Union, 0, -1, 0, -1);
5ffb1d13:	c7 43 04 00 00 00 00 	movl   $0x0,0x4(%ebx)
5ffb1d1a:	c7 03 ff ff ff ff    	movl   $0xffffffff,(%ebx)
5ffb1d20:	c7 43 0c 00 00 00 00 	movl   $0x0,0xc(%ebx)
5ffb1d27:	c7 43 08 ff ff ff ff 	movl   $0xffffffff,0x8(%ebx)
          return FALSE;
5ffb1d2e:	31 c0                	xor    %eax,%eax
        }
      else
        {
          *Union = *Rect2;
        }
    }
  else if (ConioIsRectEmpty(Rect2))
    {
      *Union = *Rect1;
    }
  else
    {
      ConioInitRect(Union,
                   RtlRosMin(Rect1->top, Rect2->top),
                   RtlRosMin(Rect1->left, Rect2->left),
                   RtlRosMax(Rect1->bottom, Rect2->bottom),
                   RtlRosMax(Rect1->right, Rect2->right));
    }

  return TRUE;
}
5ffb1d30:	83 c4 14             	add    $0x14,%esp
5ffb1d33:	5b                   	pop    %ebx
5ffb1d34:	5e                   	pop    %esi
5ffb1d35:	5f                   	pop    %edi
5ffb1d36:	5d                   	pop    %ebp
5ffb1d37:	c3                   	ret    
5ffb1d38:	8b 41 0c             	mov    0xc(%ecx),%eax
5ffb1d3b:	39 41 04             	cmp    %eax,0x4(%ecx)
5ffb1d3e:	7f d3                	jg     5ffb1d13 <_ConioGetUnion+0x33>
5ffb1d40:	89 13                	mov    %edx,(%ebx)
5ffb1d42:	8b 41 04             	mov    0x4(%ecx),%eax
5ffb1d45:	89 43 04             	mov    %eax,0x4(%ebx)
5ffb1d48:	8b 41 08             	mov    0x8(%ecx),%eax
5ffb1d4b:	89 43 08             	mov    %eax,0x8(%ebx)
5ffb1d4e:	8b 41 0c             	mov    0xc(%ecx),%eax
5ffb1d51:	89 43 0c             	mov    %eax,0xc(%ebx)
5ffb1d54:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb1d59:	83 c4 14             	add    $0x14,%esp
5ffb1d5c:	5b                   	pop    %ebx
5ffb1d5d:	5e                   	pop    %esi
5ffb1d5e:	5f                   	pop    %edi
5ffb1d5f:	5d                   	pop    %ebp
5ffb1d60:	c3                   	ret    
5ffb1d61:	8b 31                	mov    (%ecx),%esi
5ffb1d63:	89 75 ec             	mov    %esi,0xffffffec(%ebp)
5ffb1d66:	8b 71 08             	mov    0x8(%ecx),%esi
5ffb1d69:	89 75 e8             	mov    %esi,0xffffffe8(%ebp)
5ffb1d6c:	39 75 ec             	cmp    %esi,0xffffffec(%ebp)
5ffb1d6f:	7f 43                	jg     5ffb1db4 <_ConioGetUnion+0xd4>
5ffb1d71:	8b 71 04             	mov    0x4(%ecx),%esi
5ffb1d74:	8b 49 0c             	mov    0xc(%ecx),%ecx
5ffb1d77:	89 75 e4             	mov    %esi,0xffffffe4(%ebp)
5ffb1d7a:	39 ce                	cmp    %ecx,%esi
5ffb1d7c:	7f 36                	jg     5ffb1db4 <_ConioGetUnion+0xd4>
5ffb1d7e:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
5ffb1d81:	3b 55 e0             	cmp    0xffffffe0(%ebp),%edx
5ffb1d84:	7f 44                	jg     5ffb1dca <_ConioGetUnion+0xea>
5ffb1d86:	89 53 04             	mov    %edx,0x4(%ebx)
5ffb1d89:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
5ffb1d8c:	39 c2                	cmp    %eax,%edx
5ffb1d8e:	7e 02                	jle    5ffb1d92 <_ConioGetUnion+0xb2>
5ffb1d90:	89 c2                	mov    %eax,%edx
5ffb1d92:	89 13                	mov    %edx,(%ebx)
5ffb1d94:	89 c8                	mov    %ecx,%eax
5ffb1d96:	3b 4d f0             	cmp    0xfffffff0(%ebp),%ecx
5ffb1d99:	7d 03                	jge    5ffb1d9e <_ConioGetUnion+0xbe>
5ffb1d9b:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
5ffb1d9e:	89 43 0c             	mov    %eax,0xc(%ebx)
5ffb1da1:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
5ffb1da4:	39 f8                	cmp    %edi,%eax
5ffb1da6:	7d 02                	jge    5ffb1daa <_ConioGetUnion+0xca>
5ffb1da8:	89 f8                	mov    %edi,%eax
5ffb1daa:	89 43 08             	mov    %eax,0x8(%ebx)
5ffb1dad:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb1db2:	eb a5                	jmp    5ffb1d59 <_ConioGetUnion+0x79>
5ffb1db4:	89 03                	mov    %eax,(%ebx)
5ffb1db6:	8b 42 04             	mov    0x4(%edx),%eax
5ffb1db9:	89 43 04             	mov    %eax,0x4(%ebx)
5ffb1dbc:	8b 42 08             	mov    0x8(%edx),%eax
5ffb1dbf:	89 43 08             	mov    %eax,0x8(%ebx)
5ffb1dc2:	8b 42 0c             	mov    0xc(%edx),%eax
5ffb1dc5:	89 43 0c             	mov    %eax,0xc(%ebx)
5ffb1dc8:	eb 8a                	jmp    5ffb1d54 <_ConioGetUnion+0x74>
5ffb1dca:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
5ffb1dcd:	eb b7                	jmp    5ffb1d86 <_ConioGetUnion+0xa6>
5ffb1dcf:	90                   	nop    

5ffb1dd0 <_ConioSubtractRect>:

inline BOOLEAN ConioSubtractRect(
  RECT *Subtraction,
  RECT *Rect1,
  RECT *Rect2)
{
5ffb1dd0:	55                   	push   %ebp
5ffb1dd1:	89 e5                	mov    %esp,%ebp
5ffb1dd3:	57                   	push   %edi
5ffb1dd4:	56                   	push   %esi
5ffb1dd5:	53                   	push   %ebx
5ffb1dd6:	83 ec 3c             	sub    $0x3c,%esp
5ffb1dd9:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb1ddc:	8b 5d 08             	mov    0x8(%ebp),%ebx
5ffb1ddf:	8b 75 10             	mov    0x10(%ebp),%esi
  RECT tmp;

  if (ConioIsRectEmpty(Rect1))
5ffb1de2:	8b 0a                	mov    (%edx),%ecx
5ffb1de4:	3b 4a 08             	cmp    0x8(%edx),%ecx
5ffb1de7:	7f 08                	jg     5ffb1df1 <_ConioSubtractRect+0x21>
5ffb1de9:	8b 42 0c             	mov    0xc(%edx),%eax
5ffb1dec:	39 42 04             	cmp    %eax,0x4(%edx)
5ffb1def:	7e 25                	jle    5ffb1e16 <_ConioSubtractRect+0x46>
    {
      ConioInitRect(Subtraction, 0, -1, 0, -1);
      return FALSE;
    }
  *Subtraction = *Rect1;
  if (ConioGetIntersection(&tmp, Rect1, Rect2))
    {
      if (ConioIsEqualRect(&tmp, Subtraction))
        {
          ConioInitRect(Subtraction, 0, -1, 0, -1);
5ffb1df1:	c7 43 04 00 00 00 00 	movl   $0x0,0x4(%ebx)
5ffb1df8:	c7 03 ff ff ff ff    	movl   $0xffffffff,(%ebx)
5ffb1dfe:	c7 43 0c 00 00 00 00 	movl   $0x0,0xc(%ebx)
5ffb1e05:	c7 43 08 ff ff ff ff 	movl   $0xffffffff,0x8(%ebx)
          return FALSE;
5ffb1e0c:	31 c0                	xor    %eax,%eax
        }
      if ((tmp.top == Subtraction->top) && (tmp.bottom == Subtraction->bottom))
        {
          if (tmp.left == Subtraction->left)
            {
              Subtraction->left = tmp.right;
            }
          else if (tmp.right == Subtraction->right)
            {
              Subtraction->right = tmp.left;
            }
        }
      else if ((tmp.left == Subtraction->left) && (tmp.right == Subtraction->right))
        {
          if (tmp.top == Subtraction->top)
            {
              Subtraction->top = tmp.bottom;
            }
          else if (tmp.bottom == Subtraction->bottom)
            {
              Subtraction->bottom = tmp.top;
            }
        }
    }

  return TRUE;
}
5ffb1e0e:	83 c4 3c             	add    $0x3c,%esp
5ffb1e11:	5b                   	pop    %ebx
5ffb1e12:	5e                   	pop    %esi
5ffb1e13:	5f                   	pop    %edi
5ffb1e14:	5d                   	pop    %ebp
5ffb1e15:	c3                   	ret    
5ffb1e16:	89 0b                	mov    %ecx,(%ebx)
5ffb1e18:	8b 42 04             	mov    0x4(%edx),%eax
5ffb1e1b:	89 43 04             	mov    %eax,0x4(%ebx)
5ffb1e1e:	8b 42 08             	mov    0x8(%edx),%eax
5ffb1e21:	89 43 08             	mov    %eax,0x8(%ebx)
5ffb1e24:	8b 42 0c             	mov    0xc(%edx),%eax
5ffb1e27:	89 43 0c             	mov    %eax,0xc(%ebx)
5ffb1e2a:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
5ffb1e2d:	8b 7a 08             	mov    0x8(%edx),%edi
5ffb1e30:	8b 0a                	mov    (%edx),%ecx
5ffb1e32:	89 7d c4             	mov    %edi,0xffffffc4(%ebp)
5ffb1e35:	39 f9                	cmp    %edi,%ecx
5ffb1e37:	7e 77                	jle    5ffb1eb0 <_ConioSubtractRect+0xe0>
5ffb1e39:	c7 40 04 00 00 00 00 	movl   $0x0,0x4(%eax)
5ffb1e40:	c7 00 ff ff ff ff    	movl   $0xffffffff,(%eax)
5ffb1e46:	c7 40 0c 00 00 00 00 	movl   $0x0,0xc(%eax)
5ffb1e4d:	c7 40 08 ff ff ff ff 	movl   $0xffffffff,0x8(%eax)
5ffb1e54:	31 c0                	xor    %eax,%eax
5ffb1e56:	85 c0                	test   %eax,%eax
5ffb1e58:	74 46                	je     5ffb1ea0 <_ConioSubtractRect+0xd0>
5ffb1e5a:	8b 4d d8             	mov    0xffffffd8(%ebp),%ecx
5ffb1e5d:	8b 13                	mov    (%ebx),%edx
5ffb1e5f:	31 f6                	xor    %esi,%esi
5ffb1e61:	39 d1                	cmp    %edx,%ecx
5ffb1e63:	0f 84 17 01 00 00    	je     5ffb1f80 <_ConioSubtractRect+0x1b0>
5ffb1e69:	85 f6                	test   %esi,%esi
5ffb1e6b:	75 84                	jne    5ffb1df1 <_ConioSubtractRect+0x21>
5ffb1e6d:	8b 75 dc             	mov    0xffffffdc(%ebp),%esi
5ffb1e70:	8b 7b 04             	mov    0x4(%ebx),%edi
5ffb1e73:	39 fe                	cmp    %edi,%esi
5ffb1e75:	0f 84 d5 00 00 00    	je     5ffb1f50 <_ConioSubtractRect+0x180>
5ffb1e7b:	39 d1                	cmp    %edx,%ecx
5ffb1e7d:	75 21                	jne    5ffb1ea0 <_ConioSubtractRect+0xd0>
5ffb1e7f:	8b 43 08             	mov    0x8(%ebx),%eax
5ffb1e82:	39 45 e0             	cmp    %eax,0xffffffe0(%ebp)
5ffb1e85:	75 19                	jne    5ffb1ea0 <_ConioSubtractRect+0xd0>
5ffb1e87:	39 fe                	cmp    %edi,%esi
5ffb1e89:	0f 84 2d 01 00 00    	je     5ffb1fbc <_ConioSubtractRect+0x1ec>
5ffb1e8f:	8b 43 0c             	mov    0xc(%ebx),%eax
5ffb1e92:	39 45 e4             	cmp    %eax,0xffffffe4(%ebp)
5ffb1e95:	75 09                	jne    5ffb1ea0 <_ConioSubtractRect+0xd0>
5ffb1e97:	89 73 0c             	mov    %esi,0xc(%ebx)
5ffb1e9a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb1ea0:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb1ea5:	83 c4 3c             	add    $0x3c,%esp
5ffb1ea8:	5b                   	pop    %ebx
5ffb1ea9:	5e                   	pop    %esi
5ffb1eaa:	5f                   	pop    %edi
5ffb1eab:	5d                   	pop    %ebp
5ffb1eac:	c3                   	ret    
5ffb1ead:	8d 76 00             	lea    0x0(%esi),%esi
5ffb1eb0:	8b 7a 04             	mov    0x4(%edx),%edi
5ffb1eb3:	8b 52 0c             	mov    0xc(%edx),%edx
5ffb1eb6:	89 7d d4             	mov    %edi,0xffffffd4(%ebp)
5ffb1eb9:	39 d7                	cmp    %edx,%edi
5ffb1ebb:	0f 8f 78 ff ff ff    	jg     5ffb1e39 <_ConioSubtractRect+0x69>
5ffb1ec1:	8b 3e                	mov    (%esi),%edi
5ffb1ec3:	89 7d d0             	mov    %edi,0xffffffd0(%ebp)
5ffb1ec6:	8b 7e 08             	mov    0x8(%esi),%edi
5ffb1ec9:	89 7d cc             	mov    %edi,0xffffffcc(%ebp)
5ffb1ecc:	39 7d d0             	cmp    %edi,0xffffffd0(%ebp)
5ffb1ecf:	0f 8f 64 ff ff ff    	jg     5ffb1e39 <_ConioSubtractRect+0x69>
5ffb1ed5:	8b 7e 04             	mov    0x4(%esi),%edi
5ffb1ed8:	8b 76 0c             	mov    0xc(%esi),%esi
5ffb1edb:	89 7d c8             	mov    %edi,0xffffffc8(%ebp)
5ffb1ede:	39 f7                	cmp    %esi,%edi
5ffb1ee0:	0f 8f 53 ff ff ff    	jg     5ffb1e39 <_ConioSubtractRect+0x69>
5ffb1ee6:	39 75 d4             	cmp    %esi,0xffffffd4(%ebp)
5ffb1ee9:	0f 8f 4a ff ff ff    	jg     5ffb1e39 <_ConioSubtractRect+0x69>
5ffb1eef:	3b 4d cc             	cmp    0xffffffcc(%ebp),%ecx
5ffb1ef2:	0f 8f 41 ff ff ff    	jg     5ffb1e39 <_ConioSubtractRect+0x69>
5ffb1ef8:	39 fa                	cmp    %edi,%edx
5ffb1efa:	0f 8c 39 ff ff ff    	jl     5ffb1e39 <_ConioSubtractRect+0x69>
5ffb1f00:	8b 7d d0             	mov    0xffffffd0(%ebp),%edi
5ffb1f03:	39 7d c4             	cmp    %edi,0xffffffc4(%ebp)
5ffb1f06:	0f 8c 2d ff ff ff    	jl     5ffb1e39 <_ConioSubtractRect+0x69>
5ffb1f0c:	8b 45 c8             	mov    0xffffffc8(%ebp),%eax
5ffb1f0f:	3b 45 d4             	cmp    0xffffffd4(%ebp),%eax
5ffb1f12:	7d 03                	jge    5ffb1f17 <_ConioSubtractRect+0x147>
5ffb1f14:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
5ffb1f17:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
5ffb1f1a:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
5ffb1f1d:	39 c8                	cmp    %ecx,%eax
5ffb1f1f:	7d 02                	jge    5ffb1f23 <_ConioSubtractRect+0x153>
5ffb1f21:	89 c8                	mov    %ecx,%eax
5ffb1f23:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
5ffb1f26:	39 d6                	cmp    %edx,%esi
5ffb1f28:	89 f0                	mov    %esi,%eax
5ffb1f2a:	7e 02                	jle    5ffb1f2e <_ConioSubtractRect+0x15e>
5ffb1f2c:	89 d0                	mov    %edx,%eax
5ffb1f2e:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
5ffb1f31:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
5ffb1f34:	3b 45 c4             	cmp    0xffffffc4(%ebp),%eax
5ffb1f37:	7e 03                	jle    5ffb1f3c <_ConioSubtractRect+0x16c>
5ffb1f39:	8b 45 c4             	mov    0xffffffc4(%ebp),%eax
5ffb1f3c:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
5ffb1f3f:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb1f44:	e9 0d ff ff ff       	jmp    5ffb1e56 <_ConioSubtractRect+0x86>
5ffb1f49:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
5ffb1f50:	8b 43 0c             	mov    0xc(%ebx),%eax
5ffb1f53:	39 45 e4             	cmp    %eax,0xffffffe4(%ebp)
5ffb1f56:	0f 85 1f ff ff ff    	jne    5ffb1e7b <_ConioSubtractRect+0xab>
5ffb1f5c:	39 d1                	cmp    %edx,%ecx
5ffb1f5e:	74 4d                	je     5ffb1fad <_ConioSubtractRect+0x1dd>
5ffb1f60:	8b 43 08             	mov    0x8(%ebx),%eax
5ffb1f63:	39 45 e0             	cmp    %eax,0xffffffe0(%ebp)
5ffb1f66:	0f 85 34 ff ff ff    	jne    5ffb1ea0 <_ConioSubtractRect+0xd0>
5ffb1f6c:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb1f71:	89 4b 08             	mov    %ecx,0x8(%ebx)
5ffb1f74:	e9 2c ff ff ff       	jmp    5ffb1ea5 <_ConioSubtractRect+0xd5>
5ffb1f79:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
5ffb1f80:	8b 43 08             	mov    0x8(%ebx),%eax
5ffb1f83:	39 45 e0             	cmp    %eax,0xffffffe0(%ebp)
5ffb1f86:	0f 85 dd fe ff ff    	jne    5ffb1e69 <_ConioSubtractRect+0x99>
5ffb1f8c:	8b 43 04             	mov    0x4(%ebx),%eax
5ffb1f8f:	39 45 dc             	cmp    %eax,0xffffffdc(%ebp)
5ffb1f92:	0f 85 d1 fe ff ff    	jne    5ffb1e69 <_ConioSubtractRect+0x99>
5ffb1f98:	8b 43 0c             	mov    0xc(%ebx),%eax
5ffb1f9b:	39 45 e4             	cmp    %eax,0xffffffe4(%ebp)
5ffb1f9e:	0f 85 c5 fe ff ff    	jne    5ffb1e69 <_ConioSubtractRect+0x99>
5ffb1fa4:	66 be 01 00          	mov    $0x1,%si
5ffb1fa8:	e9 bc fe ff ff       	jmp    5ffb1e69 <_ConioSubtractRect+0x99>
5ffb1fad:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
5ffb1fb0:	89 03                	mov    %eax,(%ebx)
5ffb1fb2:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb1fb7:	e9 e9 fe ff ff       	jmp    5ffb1ea5 <_ConioSubtractRect+0xd5>
5ffb1fbc:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
5ffb1fbf:	89 43 04             	mov    %eax,0x4(%ebx)
5ffb1fc2:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb1fc7:	e9 d9 fe ff ff       	jmp    5ffb1ea5 <_ConioSubtractRect+0xd5>
5ffb1fcc:	8d 74 26 00          	lea    0x0(%esi),%esi

5ffb1fd0 <@ConioInputEventToAnsi@8>:

STATIC VOID FASTCALL
ConioCopyRegion(PCSRSS_SCREEN_BUFFER ScreenBuffer,
                RECT *SrcRegion,
                RECT *DstRegion)
{
  SHORT SrcY, DstY;
  DWORD SrcOffset;
  DWORD DstOffset;
  DWORD BytesPerLine;
  ULONG i;

  DstY = DstRegion->top;
  BytesPerLine = ConioRectWidth(DstRegion) * 2;

  SrcY = (SrcRegion->top + ScreenBuffer->ShowY) % ScreenBuffer->MaxY;
  DstY = (DstRegion->top + ScreenBuffer->ShowY) % ScreenBuffer->MaxY;
  SrcOffset = (SrcY * ScreenBuffer->MaxX + SrcRegion->left + ScreenBuffer->ShowX) * 2;
  DstOffset = (DstY * ScreenBuffer->MaxX + DstRegion->left + ScreenBuffer->ShowX) * 2;
  
  for (i = SrcRegion->top; i <= SrcRegion->bottom; i++)
    {
      RtlCopyMemory(
        &ScreenBuffer->Buffer[DstOffset],
        &ScreenBuffer->Buffer[SrcOffset],
        BytesPerLine);

      if (++DstY == ScreenBuffer->MaxY)
        {
          DstY = 0;
          DstOffset = (DstRegion->left + ScreenBuffer->ShowX) * 2;
        }
      else
        {
          DstOffset += ScreenBuffer->MaxX * 2;
        }

      if (++SrcY == ScreenBuffer->MaxY)
        {
          SrcY = 0;
          SrcOffset = (SrcRegion->left + ScreenBuffer->ShowX) * 2;
        }
      else
        {
          SrcOffset += ScreenBuffer->MaxX * 2;
        }
    }
}

STATIC VOID FASTCALL
ConioFillRegion(PCSRSS_CONSOLE Console,
                PCSRSS_SCREEN_BUFFER ScreenBuffer,
                RECT *Region,
                CHAR_INFO *CharInfo,
                BOOL bUnicode)
{
  SHORT X, Y;
  DWORD Offset;
  DWORD Delta;
  ULONG i;
  CHAR Char;
  
  if(bUnicode)
    ConsoleUnicodeCharToAnsiChar(Console, &Char, &CharInfo->Char.UnicodeChar);
  else
    Char = CharInfo->Char.AsciiChar;

  Y = (Region->top + ScreenBuffer->ShowY) % ScreenBuffer->MaxY;
  Offset = (Y * ScreenBuffer->MaxX + Region->left + ScreenBuffer->ShowX) * 2;
  Delta = (ScreenBuffer->MaxX - ConioRectWidth(Region)) * 2;

  for (i = Region->top; i <= Region->bottom; i++)
    {
      for (X = Region->left; X <= Region->right; X++)
        {
          SET_CELL_BUFFER(ScreenBuffer, Offset, Char, CharInfo->Attributes);
        }
      if (++Y == ScreenBuffer->MaxY)
        {
          Y = 0;
          Offset = (Region->left + ScreenBuffer->ShowX) * 2;
        }
      else
        {
          Offset += Delta;
        }
    }
}

STATIC VOID FASTCALL
ConioInputEventToAnsi(PCSRSS_CONSOLE Console, PINPUT_RECORD InputEvent)
{
5ffb1fd0:	55                   	push   %ebp
5ffb1fd1:	89 e5                	mov    %esp,%ebp
5ffb1fd3:	50                   	push   %eax
5ffb1fd4:	50                   	push   %eax
  if (InputEvent->EventType == KEY_EVENT)
5ffb1fd5:	66 83 3a 01          	cmpw   $0x1,(%edx)
5ffb1fd9:	74 05                	je     5ffb1fe0 <@ConioInputEventToAnsi@8+0x10>
    {
      ConsoleUnicodeCharToAnsiChar(Console,
                                   &InputEvent->Event.KeyEvent.uChar.AsciiChar,
                                   &InputEvent->Event.KeyEvent.uChar.UnicodeChar);
    }
}
5ffb1fdb:	c9                   	leave  
5ffb1fdc:	c3                   	ret    
5ffb1fdd:	8d 76 00             	lea    0x0(%esi),%esi
5ffb1fe0:	8d 42 0e             	lea    0xe(%edx),%eax
5ffb1fe3:	6a 00                	push   $0x0
5ffb1fe5:	6a 00                	push   $0x0
5ffb1fe7:	6a 01                	push   $0x1
5ffb1fe9:	50                   	push   %eax
5ffb1fea:	6a 01                	push   $0x1
5ffb1fec:	50                   	push   %eax
5ffb1fed:	6a 00                	push   $0x0
5ffb1fef:	8b 41 68             	mov    0x68(%ecx),%eax
5ffb1ff2:	50                   	push   %eax
5ffb1ff3:	e8 28 6d 00 00       	call   5ffb8d20 <_WideCharToMultiByte@32>
5ffb1ff8:	c9                   	leave  
5ffb1ff9:	c3                   	ret    
5ffb1ffa:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

5ffb2000 <_CsrWriteConsole@12>:

CSR_API(CsrWriteConsole)
{
5ffb2000:	55                   	push   %ebp
5ffb2001:	89 e5                	mov    %esp,%ebp
5ffb2003:	57                   	push   %edi
5ffb2004:	56                   	push   %esi
5ffb2005:	53                   	push   %ebx
5ffb2006:	83 ec 0c             	sub    $0xc,%esp
5ffb2009:	8b 75 0c             	mov    0xc(%ebp),%esi
5ffb200c:	8b 7d 10             	mov    0x10(%ebp),%edi
  NTSTATUS Status;
  PCHAR Buffer = (PCHAR)Request->Data.WriteConsoleRequest.Buffer;
5ffb200f:	8d 46 28             	lea    0x28(%esi),%eax
5ffb2012:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
  PCSRSS_SCREEN_BUFFER Buff;
  PCSRSS_CONSOLE Console;
  ULONG CharSize = (Request->Data.WriteConsoleRequest.Unicode ? sizeof(WCHAR) : sizeof(CHAR));
5ffb2015:	8b 46 20             	mov    0x20(%esi),%eax

  DPRINT("CsrWriteConsole\n");
   
  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
5ffb2018:	66 c7 07 20 00       	movw   $0x20,(%edi)
5ffb201d:	83 f8 01             	cmp    $0x1,%eax
5ffb2020:	66 c7 47 02 38 00    	movw   $0x38,0x2(%edi)
5ffb2026:	19 c0                	sbb    %eax,%eax

  if (Request->Header.DataSize
5ffb2028:	8b 4e 24             	mov    0x24(%esi),%ecx
5ffb202b:	83 c0 02             	add    $0x2,%eax
5ffb202e:	66 8b 16             	mov    (%esi),%dx
5ffb2031:	0f af c1             	imul   %ecx,%eax
5ffb2034:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb203a:	83 c0 0f             	add    $0xf,%eax
5ffb203d:	39 c2                	cmp    %eax,%edx
5ffb203f:	0f 82 db 00 00 00    	jb     5ffb2120 <_CsrWriteConsole@12+0x120>
      < sizeof(CSRSS_WRITE_CONSOLE_REQUEST) - 1
        + (Request->Data.WriteConsoleRequest.NrCharactersToWrite * CharSize))
    {
      DPRINT1("Invalid request size\n");
      return Reply->Status = STATUS_INVALID_PARAMETER;
    }
  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb2045:	8d 55 f0             	lea    0xfffffff0(%ebp),%edx
5ffb2048:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb204b:	e8 70 f1 ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
5ffb2050:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb2052:	85 c0                	test   %eax,%eax
5ffb2054:	78 72                	js     5ffb20c8 <_CsrWriteConsole@12+0xc8>
    {
      return Reply->Status = Status;
    }

  if(Request->Data.WriteConsoleRequest.Unicode)
5ffb2056:	8b 4e 20             	mov    0x20(%esi),%ecx
5ffb2059:	85 c9                	test   %ecx,%ecx
5ffb205b:	75 7a                	jne    5ffb20d7 <_CsrWriteConsole@12+0xd7>
  {
    ConsoleUnicodeToAnsiN(Console, Buffer, (PWCHAR)Buffer, Request->Data.WriteConsoleRequest.NrCharactersToWrite);
  }

  Status = ConioLockScreenBuffer(ProcessData, Request->Data.WriteConsoleRequest.ConsoleHandle, &Buff);
5ffb205d:	50                   	push   %eax
5ffb205e:	50                   	push   %eax
5ffb205f:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
5ffb2062:	8b 56 1c             	mov    0x1c(%esi),%edx
5ffb2065:	6a 02                	push   $0x2
5ffb2067:	50                   	push   %eax
5ffb2068:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb206b:	e8 10 f0 ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
5ffb2070:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb2072:	59                   	pop    %ecx
5ffb2073:	85 db                	test   %ebx,%ebx
5ffb2075:	58                   	pop    %eax
5ffb2076:	78 49                	js     5ffb20c1 <_CsrWriteConsole@12+0xc1>
    {
      if (NULL != Console)
        {
          ConioUnlockConsole(Console);
        }
      return Reply->Status = Status;
    }

  Reply->Status = ConioWriteConsole(Console, Buff, Buffer,
5ffb2078:	52                   	push   %edx
5ffb2079:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
5ffb207c:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb207f:	6a 01                	push   $0x1
5ffb2081:	8b 46 24             	mov    0x24(%esi),%eax
5ffb2084:	50                   	push   %eax
5ffb2085:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
5ffb2088:	50                   	push   %eax
5ffb2089:	e8 52 f5 ff ff       	call   5ffb15e0 <@ConioWriteConsole@20>
                                    Request->Data.WriteConsoleRequest.NrCharactersToWrite, TRUE);
  ConioUnlockScreenBuffer(Buff);
5ffb208e:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
5ffb2091:	89 47 18             	mov    %eax,0x18(%edi)
5ffb2094:	58                   	pop    %eax
5ffb2095:	e8 26 f0 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
  if (NULL != Console)
5ffb209a:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb209d:	85 c9                	test   %ecx,%ecx
5ffb209f:	75 6f                	jne    5ffb2110 <_CsrWriteConsole@12+0x110>
    {
      ConioUnlockConsole(Console);
    }

  if(NT_SUCCESS(Reply->Status))
5ffb20a1:	8b 47 18             	mov    0x18(%edi),%eax
5ffb20a4:	85 c0                	test   %eax,%eax
5ffb20a6:	78 6f                	js     5ffb2117 <_CsrWriteConsole@12+0x117>
  {
    Reply->Data.WriteConsoleReply.NrCharactersWritten = Request->Data.WriteConsoleRequest.NrCharactersToWrite;
5ffb20a8:	8b 46 24             	mov    0x24(%esi),%eax
5ffb20ab:	89 47 1c             	mov    %eax,0x1c(%edi)
  }
  else
  {
    Reply->Data.WriteConsoleReply.NrCharactersWritten = 0; /* FIXME - return the actual number of characters written! */
  }

  return Reply->Status = STATUS_SUCCESS;
5ffb20ae:	c7 47 18 00 00 00 00 	movl   $0x0,0x18(%edi)
5ffb20b5:	31 c0                	xor    %eax,%eax
}
5ffb20b7:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb20ba:	5b                   	pop    %ebx
5ffb20bb:	5e                   	pop    %esi
5ffb20bc:	5f                   	pop    %edi
5ffb20bd:	5d                   	pop    %ebp
5ffb20be:	c2 0c 00             	ret    $0xc
5ffb20c1:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb20c4:	85 c9                	test   %ecx,%ecx
5ffb20c6:	75 36                	jne    5ffb20fe <_CsrWriteConsole@12+0xfe>
5ffb20c8:	89 5f 18             	mov    %ebx,0x18(%edi)
5ffb20cb:	89 d8                	mov    %ebx,%eax
5ffb20cd:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb20d0:	5b                   	pop    %ebx
5ffb20d1:	5e                   	pop    %esi
5ffb20d2:	5f                   	pop    %edi
5ffb20d3:	5d                   	pop    %ebp
5ffb20d4:	c2 0c 00             	ret    $0xc
5ffb20d7:	6a 00                	push   $0x0
5ffb20d9:	6a 00                	push   $0x0
5ffb20db:	8b 46 24             	mov    0x24(%esi),%eax
5ffb20de:	8d 14 00             	lea    (%eax,%eax,1),%edx
5ffb20e1:	52                   	push   %edx
5ffb20e2:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
5ffb20e5:	52                   	push   %edx
5ffb20e6:	50                   	push   %eax
5ffb20e7:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
5ffb20ea:	50                   	push   %eax
5ffb20eb:	6a 00                	push   $0x0
5ffb20ed:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
5ffb20f0:	8b 40 68             	mov    0x68(%eax),%eax
5ffb20f3:	50                   	push   %eax
5ffb20f4:	e8 27 6c 00 00       	call   5ffb8d20 <_WideCharToMultiByte@32>
5ffb20f9:	e9 5f ff ff ff       	jmp    5ffb205d <_CsrWriteConsole@12+0x5d>
5ffb20fe:	e8 bd ef ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb2103:	89 d8                	mov    %ebx,%eax
5ffb2105:	89 5f 18             	mov    %ebx,0x18(%edi)
5ffb2108:	eb c3                	jmp    5ffb20cd <_CsrWriteConsole@12+0xcd>
5ffb210a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb2110:	e8 ab ef ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb2115:	eb 8a                	jmp    5ffb20a1 <_CsrWriteConsole@12+0xa1>
5ffb2117:	c7 47 1c 00 00 00 00 	movl   $0x0,0x1c(%edi)
5ffb211e:	eb 8e                	jmp    5ffb20ae <_CsrWriteConsole@12+0xae>
5ffb2120:	53                   	push   %ebx
5ffb2121:	68 ae 03 00 00       	push   $0x3ae
5ffb2126:	68 40 b0 fb 5f       	push   $0x5ffbb040
5ffb212b:	68 48 b0 fb 5f       	push   $0x5ffbb048
5ffb2130:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb2136:	c7 04 24 aa b0 fb 5f 	movl   $0x5ffbb0aa,(%esp)
5ffb213d:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb2143:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
5ffb2148:	c7 47 18 0d 00 00 c0 	movl   $0xc000000d,0x18(%edi)
5ffb214f:	e9 63 ff ff ff       	jmp    5ffb20b7 <_CsrWriteConsole@12+0xb7>
5ffb2154:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb215a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

5ffb2160 <_ConioDeleteScreenBuffer@4>:

VOID STDCALL
ConioDeleteScreenBuffer(Object_t *Object)
{
5ffb2160:	55                   	push   %ebp
5ffb2161:	89 e5                	mov    %esp,%ebp
5ffb2163:	53                   	push   %ebx
5ffb2164:	83 ec 10             	sub    $0x10,%esp
5ffb2167:	8b 5d 08             	mov    0x8(%ebp),%ebx
  PCSRSS_SCREEN_BUFFER Buffer = (PCSRSS_SCREEN_BUFFER) Object;
  DeleteCriticalSection(&Buffer->Header.Lock);
5ffb216a:	8d 43 08             	lea    0x8(%ebx),%eax
5ffb216d:	50                   	push   %eax
5ffb216e:	e8 bd 6b 00 00       	call   5ffb8d30 <_DeleteCriticalSection@4>
  HeapFree(Win32CsrApiHeap, 0, Buffer->Buffer);
5ffb2173:	58                   	pop    %eax
5ffb2174:	8b 43 20             	mov    0x20(%ebx),%eax
5ffb2177:	5a                   	pop    %edx
5ffb2178:	50                   	push   %eax
5ffb2179:	a1 e0 c1 fb 5f       	mov    0x5ffbc1e0,%eax
5ffb217e:	6a 00                	push   $0x0
5ffb2180:	50                   	push   %eax
5ffb2181:	e8 7a 6b 00 00       	call   5ffb8d00 <_HeapFree@12>
  HeapFree(Win32CsrApiHeap, 0, Buffer);
5ffb2186:	53                   	push   %ebx
5ffb2187:	8b 1d e0 c1 fb 5f    	mov    0x5ffbc1e0,%ebx
5ffb218d:	6a 00                	push   $0x0
5ffb218f:	53                   	push   %ebx
5ffb2190:	e8 6b 6b 00 00       	call   5ffb8d00 <_HeapFree@12>
5ffb2195:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb2198:	c9                   	leave  
5ffb2199:	c2 04 00             	ret    $0x4
5ffb219c:	8d 74 26 00          	lea    0x0(%esi),%esi

5ffb21a0 <_ConioDeleteConsole@4>:
}

VOID FASTCALL
ConioDrawConsole(PCSRSS_CONSOLE Console)
{
   RECT Region;

   ConioInitRect(&Region, 0, 0, Console->Size.Y - 1, Console->Size.X - 1);

   ConioDrawRegion(Console, &Region);
}


VOID STDCALL
ConioDeleteConsole(Object_t *Object)
{
5ffb21a0:	55                   	push   %ebp
5ffb21a1:	89 e5                	mov    %esp,%ebp
5ffb21a3:	56                   	push   %esi
5ffb21a4:	53                   	push   %ebx
5ffb21a5:	8b 75 08             	mov    0x8(%ebp),%esi
  PCSRSS_CONSOLE Console = (PCSRSS_CONSOLE) Object;
  ConsoleInput *Event;

  DPRINT("ConioDeleteConsole\n");

  /* Drain input event queue */
  while (Console->InputEvents.Flink != &Console->InputEvents)
    {
      Event = (ConsoleInput *) Console->InputEvents.Flink;
      Console->InputEvents.Flink = Console->InputEvents.Flink->Flink;
      Console->InputEvents.Flink->Flink->Blink = &Console->InputEvents;
      HeapFree(Win32CsrApiHeap, 0, Event);
5ffb21a8:	8d 5e 2c             	lea    0x2c(%esi),%ebx
5ffb21ab:	eb 1f                	jmp    5ffb21cc <_ConioDeleteConsole@4+0x2c>
5ffb21ad:	8d 76 00             	lea    0x0(%esi),%esi
5ffb21b0:	89 c2                	mov    %eax,%edx
5ffb21b2:	8b 00                	mov    (%eax),%eax
5ffb21b4:	89 46 2c             	mov    %eax,0x2c(%esi)
5ffb21b7:	8b 00                	mov    (%eax),%eax
5ffb21b9:	89 58 04             	mov    %ebx,0x4(%eax)
5ffb21bc:	50                   	push   %eax
5ffb21bd:	a1 e0 c1 fb 5f       	mov    0x5ffbc1e0,%eax
5ffb21c2:	52                   	push   %edx
5ffb21c3:	6a 00                	push   $0x0
5ffb21c5:	50                   	push   %eax
5ffb21c6:	e8 35 6b 00 00       	call   5ffb8d00 <_HeapFree@12>
5ffb21cb:	58                   	pop    %eax
5ffb21cc:	8b 46 2c             	mov    0x2c(%esi),%eax
5ffb21cf:	39 d8                	cmp    %ebx,%eax
5ffb21d1:	75 dd                	jne    5ffb21b0 <_ConioDeleteConsole@4+0x10>
    }

  if (0 == --Console->ActiveBuffer->Header.ReferenceCount)
5ffb21d3:	8b 56 38             	mov    0x38(%esi),%edx
5ffb21d6:	8b 42 04             	mov    0x4(%edx),%eax
5ffb21d9:	48                   	dec    %eax
5ffb21da:	89 42 04             	mov    %eax,0x4(%edx)
5ffb21dd:	85 c0                	test   %eax,%eax
5ffb21df:	74 46                	je     5ffb2227 <_ConioDeleteConsole@4+0x87>
    {
      ConioDeleteScreenBuffer((Object_t *) Console->ActiveBuffer);
    }

  Console->ActiveBuffer = NULL;
  ConioCleanupConsole(Console);
5ffb21e1:	8b 46 70             	mov    0x70(%esi),%eax
5ffb21e4:	83 ec 0c             	sub    $0xc,%esp
5ffb21e7:	c7 46 38 00 00 00 00 	movl   $0x0,0x38(%esi)
5ffb21ee:	56                   	push   %esi
5ffb21ef:	ff 50 18             	call   *0x18(%eax)

  CloseHandle(Console->ActiveEvent);
5ffb21f2:	8b 46 28             	mov    0x28(%esi),%eax
5ffb21f5:	50                   	push   %eax
5ffb21f6:	e8 c5 6a 00 00       	call   5ffb8cc0 <_CloseHandle@4>
  DeleteCriticalSection(&Console->Header.Lock);
5ffb21fb:	8d 46 08             	lea    0x8(%esi),%eax
5ffb21fe:	50                   	push   %eax
5ffb21ff:	e8 2c 6b 00 00       	call   5ffb8d30 <_DeleteCriticalSection@4>
  RtlFreeUnicodeString(&Console->Title);
5ffb2204:	8d 46 40             	lea    0x40(%esi),%eax
5ffb2207:	50                   	push   %eax
5ffb2208:	e8 03 6a 00 00       	call   5ffb8c10 <_RtlFreeUnicodeString@4>
  HeapFree(Win32CsrApiHeap, 0, Console);
5ffb220d:	8b 0d e0 c1 fb 5f    	mov    0x5ffbc1e0,%ecx
5ffb2213:	5b                   	pop    %ebx
5ffb2214:	58                   	pop    %eax
5ffb2215:	56                   	push   %esi
5ffb2216:	6a 00                	push   $0x0
5ffb2218:	51                   	push   %ecx
5ffb2219:	e8 e2 6a 00 00       	call   5ffb8d00 <_HeapFree@12>
5ffb221e:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb2221:	5b                   	pop    %ebx
5ffb2222:	5e                   	pop    %esi
5ffb2223:	5d                   	pop    %ebp
5ffb2224:	c2 04 00             	ret    $0x4
5ffb2227:	83 ec 0c             	sub    $0xc,%esp
5ffb222a:	52                   	push   %edx
5ffb222b:	e8 30 ff ff ff       	call   5ffb2160 <_ConioDeleteScreenBuffer@4>
5ffb2230:	83 c4 0c             	add    $0xc,%esp
5ffb2233:	eb ac                	jmp    5ffb21e1 <_ConioDeleteConsole@4+0x41>
5ffb2235:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb2239:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb2240 <_CsrFreeConsole@12>:
5ffb2240:	55                   	push   %ebp
5ffb2241:	89 e5                	mov    %esp,%ebp
5ffb2243:	50                   	push   %eax
5ffb2244:	50                   	push   %eax
5ffb2245:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb2248:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb224b:	85 c9                	test   %ecx,%ecx
5ffb224d:	66 c7 40 02 38 00    	movw   $0x38,0x2(%eax)
5ffb2253:	66 c7 00 20 00       	movw   $0x20,(%eax)
5ffb2258:	74 06                	je     5ffb2260 <_CsrFreeConsole@12+0x20>
5ffb225a:	8b 11                	mov    (%ecx),%edx
5ffb225c:	85 d2                	test   %edx,%edx
5ffb225e:	75 10                	jne    5ffb2270 <_CsrFreeConsole@12+0x30>
5ffb2260:	c7 40 18 0d 00 00 c0 	movl   $0xc000000d,0x18(%eax)
5ffb2267:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
5ffb226c:	c9                   	leave  
5ffb226d:	c2 0c 00             	ret    $0xc
5ffb2270:	8b 42 04             	mov    0x4(%edx),%eax
5ffb2273:	c7 01 00 00 00 00    	movl   $0x0,(%ecx)
5ffb2279:	48                   	dec    %eax
5ffb227a:	89 42 04             	mov    %eax,0x4(%edx)
5ffb227d:	85 c0                	test   %eax,%eax
5ffb227f:	74 06                	je     5ffb2287 <_CsrFreeConsole@12+0x47>
5ffb2281:	31 c0                	xor    %eax,%eax
5ffb2283:	c9                   	leave  
5ffb2284:	c2 0c 00             	ret    $0xc
5ffb2287:	83 ec 0c             	sub    $0xc,%esp
5ffb228a:	52                   	push   %edx
5ffb228b:	e8 10 ff ff ff       	call   5ffb21a0 <_ConioDeleteConsole@4>
5ffb2290:	31 c0                	xor    %eax,%eax
5ffb2292:	83 c4 0c             	add    $0xc,%esp
5ffb2295:	eb ec                	jmp    5ffb2283 <_CsrFreeConsole@12+0x43>
5ffb2297:	89 f6                	mov    %esi,%esi
5ffb2299:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb22a0 <_CsrAllocConsole@12>:
5ffb22a0:	55                   	push   %ebp
5ffb22a1:	89 e5                	mov    %esp,%ebp
5ffb22a3:	57                   	push   %edi
5ffb22a4:	56                   	push   %esi
5ffb22a5:	53                   	push   %ebx
5ffb22a6:	83 ec 5c             	sub    $0x5c,%esp
5ffb22a9:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb22ac:	8b 55 08             	mov    0x8(%ebp),%edx
5ffb22af:	85 d2                	test   %edx,%edx
5ffb22b1:	66 c7 40 02 38 00    	movw   $0x38,0x2(%eax)
5ffb22b7:	66 c7 00 20 00       	movw   $0x20,(%eax)
5ffb22bc:	0f 84 a1 04 00 00    	je     5ffb2763 <_CsrAllocConsole@12+0x4c3>
5ffb22c2:	8b 55 08             	mov    0x8(%ebp),%edx
5ffb22c5:	8b 02                	mov    (%edx),%eax
5ffb22c7:	85 c0                	test   %eax,%eax
5ffb22c9:	0f 85 d5 03 00 00    	jne    5ffb26a4 <_CsrAllocConsole@12+0x404>
5ffb22cf:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb22d2:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
5ffb22d9:	50                   	push   %eax
5ffb22da:	6a 7c                	push   $0x7c
5ffb22dc:	6a 00                	push   $0x0
5ffb22de:	8b 3d e0 c1 fb 5f    	mov    0x5ffbc1e0,%edi
5ffb22e4:	57                   	push   %edi
5ffb22e5:	e8 06 6a 00 00       	call   5ffb8cf0 <_HeapAlloc@12>
5ffb22ea:	89 c3                	mov    %eax,%ebx
5ffb22ec:	5e                   	pop    %esi
5ffb22ed:	85 c0                	test   %eax,%eax
5ffb22ef:	0f 84 5a 04 00 00    	je     5ffb274f <_CsrAllocConsole@12+0x4af>
5ffb22f5:	8d 70 40             	lea    0x40(%eax),%esi
5ffb22f8:	66 c7 40 40 00 00    	movw   $0x0,0x40(%eax)
5ffb22fe:	66 c7 40 42 00 00    	movw   $0x0,0x42(%eax)
5ffb2304:	c7 40 44 00 00 00 00 	movl   $0x0,0x44(%eax)
5ffb230b:	51                   	push   %ecx
5ffb230c:	51                   	push   %ecx
5ffb230d:	68 c0 b0 fb 5f       	push   $0x5ffbb0c0
5ffb2312:	89 75 a4             	mov    %esi,0xffffffa4(%ebp)
5ffb2315:	56                   	push   %esi
5ffb2316:	e8 05 69 00 00       	call   5ffb8c20 <_RtlCreateUnicodeString@8>
5ffb231b:	58                   	pop    %eax

static __inline VOID
InitializeListHead(
  IN PLIST_ENTRY  ListHead)
{
5ffb231c:	8d 43 2c             	lea    0x2c(%ebx),%eax
5ffb231f:	5a                   	pop    %edx
static __inline VOID
InitializeListHead(
  IN PLIST_ENTRY  ListHead)
{
  ListHead->Flink = ListHead->Blink = ListHead;
5ffb2320:	89 43 2c             	mov    %eax,0x2c(%ebx)
5ffb2323:	89 40 04             	mov    %eax,0x4(%eax)
5ffb2326:	8d 43 74             	lea    0x74(%ebx),%eax
5ffb2329:	c7 43 04 00 00 00 00 	movl   $0x0,0x4(%ebx)
5ffb2330:	66 c7 43 34 00 00    	movw   $0x0,0x34(%ebx)
5ffb2336:	66 c7 43 36 00 00    	movw   $0x0,0x36(%ebx)
5ffb233c:	66 c7 43 3e 00 00    	movw   $0x0,0x3e(%ebx)
5ffb2342:	c7 03 01 00 00 00    	movl   $0x1,(%ebx)
5ffb2348:	66 c7 43 3c 17 00    	movw   $0x17,0x3c(%ebx)
5ffb234e:	c7 43 50 00 00 00 00 	movl   $0x0,0x50(%ebx)
5ffb2355:	c7 43 38 00 00 00 00 	movl   $0x0,0x38(%ebx)
static __inline VOID
InitializeListHead(
  IN PLIST_ENTRY  ListHead)
{
  ListHead->Flink = ListHead->Blink = ListHead;
5ffb235c:	89 40 04             	mov    %eax,0x4(%eax)
5ffb235f:	89 43 74             	mov    %eax,0x74(%ebx)
5ffb2362:	e8 d9 69 00 00       	call   5ffb8d40 <_GetOEMCP@0>
5ffb2367:	89 43 68             	mov    %eax,0x68(%ebx)
5ffb236a:	e8 d1 69 00 00       	call   5ffb8d40 <_GetOEMCP@0>
5ffb236f:	c7 45 b8 0c 00 00 00 	movl   $0xc,0xffffffb8(%ebp)
5ffb2376:	c7 45 bc 00 00 00 00 	movl   $0x0,0xffffffbc(%ebp)
5ffb237d:	89 43 6c             	mov    %eax,0x6c(%ebx)
5ffb2380:	c7 45 c0 01 00 00 00 	movl   $0x1,0xffffffc0(%ebp)
5ffb2387:	8d 45 b8             	lea    0xffffffb8(%ebp),%eax
5ffb238a:	6a 00                	push   $0x0
5ffb238c:	6a 00                	push   $0x0
5ffb238e:	6a 01                	push   $0x1
5ffb2390:	50                   	push   %eax
5ffb2391:	e8 ba 69 00 00       	call   5ffb8d50 <_CreateEventW@16>
5ffb2396:	85 c0                	test   %eax,%eax
5ffb2398:	89 43 28             	mov    %eax,0x28(%ebx)
5ffb239b:	0f 85 70 01 00 00    	jne    5ffb2511 <_CsrAllocConsole@12+0x271>
5ffb23a1:	83 ec 0c             	sub    $0xc,%esp
5ffb23a4:	56                   	push   %esi
5ffb23a5:	e8 66 68 00 00       	call   5ffb8c10 <_RtlFreeUnicodeString@4>
5ffb23aa:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
5ffb23af:	83 c4 0c             	add    $0xc,%esp
5ffb23b2:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb23b5:	85 c0                	test   %eax,%eax
5ffb23b7:	89 42 18             	mov    %eax,0x18(%edx)
5ffb23ba:	0f 88 05 02 00 00    	js     5ffb25c5 <_CsrAllocConsole@12+0x325>
5ffb23c0:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb23c3:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb23c6:	83 ec 0c             	sub    $0xc,%esp
5ffb23c9:	89 c1                	mov    %eax,%ecx
5ffb23cb:	89 18                	mov    %ebx,(%eax)
5ffb23cd:	89 5a 1c             	mov    %ebx,0x1c(%edx)
5ffb23d0:	8b 53 04             	mov    0x4(%ebx),%edx
5ffb23d3:	42                   	inc    %edx
5ffb23d4:	89 53 04             	mov    %edx,0x4(%ebx)
5ffb23d7:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb23da:	83 c2 20             	add    $0x20,%edx
5ffb23dd:	53                   	push   %ebx
5ffb23de:	e8 4d ec ff ff       	call   5ffb1030 <@Win32CsrInsertObject@12>
5ffb23e3:	83 c4 0c             	add    $0xc,%esp
5ffb23e6:	89 c6                	mov    %eax,%esi
5ffb23e8:	85 c0                	test   %eax,%eax
5ffb23ea:	0f 88 37 02 00 00    	js     5ffb2627 <_CsrAllocConsole@12+0x387>
5ffb23f0:	83 ec 0c             	sub    $0xc,%esp
5ffb23f3:	8b 43 38             	mov    0x38(%ebx),%eax
5ffb23f6:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb23f9:	50                   	push   %eax
5ffb23fa:	83 c2 24             	add    $0x24,%edx
5ffb23fd:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb2400:	e8 2b ec ff ff       	call   5ffb1030 <@Win32CsrInsertObject@12>
5ffb2405:	83 c4 0c             	add    $0xc,%esp
5ffb2408:	89 c6                	mov    %eax,%esi
5ffb240a:	85 c0                	test   %eax,%eax
5ffb240c:	0f 88 34 02 00 00    	js     5ffb2646 <_CsrAllocConsole@12+0x3a6>
5ffb2412:	8b 55 08             	mov    0x8(%ebp),%edx
5ffb2415:	c7 45 b4 00 00 00 00 	movl   $0x0,0xffffffb4(%ebp)
5ffb241c:	c7 45 c8 18 00 00 00 	movl   $0x18,0xffffffc8(%ebp)
5ffb2423:	c7 45 d4 00 00 00 00 	movl   $0x0,0xffffffd4(%ebp)
5ffb242a:	8b 42 0c             	mov    0xc(%edx),%eax
5ffb242d:	c7 45 d0 00 00 00 00 	movl   $0x0,0xffffffd0(%ebp)
5ffb2434:	89 45 b0             	mov    %eax,0xffffffb0(%ebp)
5ffb2437:	8d 45 b0             	lea    0xffffffb0(%ebp),%eax
5ffb243a:	c7 45 cc 00 00 00 00 	movl   $0x0,0xffffffcc(%ebp)
5ffb2441:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
5ffb2448:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
5ffb244f:	50                   	push   %eax
5ffb2450:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
5ffb2453:	50                   	push   %eax
5ffb2454:	8d 45 ac             	lea    0xffffffac(%ebp),%eax
5ffb2457:	6a 40                	push   $0x40
5ffb2459:	50                   	push   %eax
5ffb245a:	e8 a1 67 00 00       	call   5ffb8c00 <_NtOpenProcess@16>
5ffb245f:	89 c6                	mov    %eax,%esi
5ffb2461:	85 c0                	test   %eax,%eax
5ffb2463:	0f 88 e9 01 00 00    	js     5ffb2652 <_CsrAllocConsole@12+0x3b2>
5ffb2469:	50                   	push   %eax
5ffb246a:	6a 00                	push   $0x0
5ffb246c:	6a 00                	push   $0x0
5ffb246e:	68 03 00 1f 00       	push   $0x1f0003
5ffb2473:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb2476:	83 c0 18             	add    $0x18,%eax
5ffb2479:	50                   	push   %eax
5ffb247a:	8b 45 ac             	mov    0xffffffac(%ebp),%eax
5ffb247d:	50                   	push   %eax
5ffb247e:	8b 55 08             	mov    0x8(%ebp),%edx
5ffb2481:	8b 02                	mov    (%edx),%eax
5ffb2483:	8b 40 28             	mov    0x28(%eax),%eax
5ffb2486:	50                   	push   %eax
5ffb2487:	50                   	push   %eax
5ffb2488:	e8 d3 68 00 00       	call   5ffb8d60 <_GetCurrentProcess@0>
5ffb248d:	89 04 24             	mov    %eax,(%esp)
5ffb2490:	e8 db 68 00 00       	call   5ffb8d70 <_DuplicateHandle@28>
5ffb2495:	5f                   	pop    %edi
5ffb2496:	85 c0                	test   %eax,%eax
5ffb2498:	0f 85 47 01 00 00    	jne    5ffb25e5 <_CsrAllocConsole@12+0x345>
5ffb249e:	51                   	push   %ecx
5ffb249f:	68 5e 01 00 00       	push   $0x15e
5ffb24a4:	68 40 b0 fb 5f       	push   $0x5ffbb040
5ffb24a9:	68 48 b0 fb 5f       	push   $0x5ffbb048
5ffb24ae:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb24b4:	58                   	pop    %eax
5ffb24b5:	5a                   	pop    %edx
5ffb24b6:	68 e0 8c fb 5f       	push   $0x5ffb8ce0
5ffb24bb:	68 de b0 fb 5f       	push   $0x5ffbb0de
5ffb24c0:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb24c6:	58                   	pop    %eax
5ffb24c7:	8b 7d ac             	mov    0xffffffac(%ebp),%edi
5ffb24ca:	57                   	push   %edi
5ffb24cb:	e8 f0 67 00 00       	call   5ffb8cc0 <_CloseHandle@4>
5ffb24d0:	8b 4b 04             	mov    0x4(%ebx),%ecx
5ffb24d3:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb24d6:	49                   	dec    %ecx
5ffb24d7:	83 c4 0c             	add    $0xc,%esp
5ffb24da:	89 4b 04             	mov    %ecx,0x4(%ebx)
5ffb24dd:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb24e0:	8b 50 24             	mov    0x24(%eax),%edx
5ffb24e3:	e8 f8 eb ff ff       	call   5ffb10e0 <@Win32CsrReleaseObject@8>
5ffb24e8:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb24eb:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb24ee:	8b 50 20             	mov    0x20(%eax),%edx
5ffb24f1:	e8 ea eb ff ff       	call   5ffb10e0 <@Win32CsrReleaseObject@8>
5ffb24f6:	8b 55 08             	mov    0x8(%ebp),%edx
5ffb24f9:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb24fc:	c7 02 00 00 00 00    	movl   $0x0,(%edx)
5ffb2502:	89 70 18             	mov    %esi,0x18(%eax)
5ffb2505:	89 f0                	mov    %esi,%eax
5ffb2507:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb250a:	5b                   	pop    %ebx
5ffb250b:	5e                   	pop    %esi
5ffb250c:	5f                   	pop    %edi
5ffb250d:	5d                   	pop    %ebp
5ffb250e:	c2 0c 00             	ret    $0xc
5ffb2511:	8d 43 08             	lea    0x8(%ebx),%eax
5ffb2514:	83 ec 0c             	sub    $0xc,%esp
5ffb2517:	89 45 a8             	mov    %eax,0xffffffa8(%ebp)
5ffb251a:	c7 43 64 00 00 00 00 	movl   $0x0,0x64(%ebx)
5ffb2521:	50                   	push   %eax
5ffb2522:	e8 59 67 00 00       	call   5ffb8c80 <_InitializeCriticalSection@4>
5ffb2527:	83 c4 0c             	add    $0xc,%esp
5ffb252a:	e8 51 42 00 00       	call   5ffb6780 <@DtbgIsDesktopVisible@0>
5ffb252f:	85 c0                	test   %eax,%eax
5ffb2531:	75 31                	jne    5ffb2564 <_CsrAllocConsole@12+0x2c4>
5ffb2533:	89 d9                	mov    %ebx,%ecx
5ffb2535:	e8 86 63 00 00       	call   5ffb88c0 <@TuiInitConsole@4>
5ffb253a:	85 c0                	test   %eax,%eax
5ffb253c:	79 37                	jns    5ffb2575 <_CsrAllocConsole@12+0x2d5>
5ffb253e:	50                   	push   %eax
5ffb253f:	68 db 00 00 00       	push   $0xdb
5ffb2544:	68 40 b0 fb 5f       	push   $0x5ffbb040
5ffb2549:	68 48 b0 fb 5f       	push   $0x5ffbb048
5ffb254e:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb2554:	c7 04 24 fc b0 fb 5f 	movl   $0x5ffbb0fc,(%esp)
5ffb255b:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb2561:	83 c4 10             	add    $0x10,%esp
5ffb2564:	89 d9                	mov    %ebx,%ecx
5ffb2566:	e8 15 5c 00 00       	call   5ffb8180 <@GuiInitConsole@4>
5ffb256b:	89 c7                	mov    %eax,%edi
5ffb256d:	85 c0                	test   %eax,%eax
5ffb256f:	0f 88 b2 01 00 00    	js     5ffb2727 <_CsrAllocConsole@12+0x487>
5ffb2575:	56                   	push   %esi
5ffb2576:	6a 44                	push   $0x44
5ffb2578:	6a 00                	push   $0x0
5ffb257a:	8b 0d e0 c1 fb 5f    	mov    0x5ffbc1e0,%ecx
5ffb2580:	51                   	push   %ecx
5ffb2581:	e8 6a 67 00 00       	call   5ffb8cf0 <_HeapAlloc@12>
5ffb2586:	5a                   	pop    %edx
5ffb2587:	89 c6                	mov    %eax,%esi
5ffb2589:	85 c0                	test   %eax,%eax
5ffb258b:	0f 84 27 01 00 00    	je     5ffb26b8 <_CsrAllocConsole@12+0x418>
5ffb2591:	89 c2                	mov    %eax,%edx
5ffb2593:	89 d9                	mov    %ebx,%ecx
5ffb2595:	e8 c6 ed ff ff       	call   5ffb1360 <@CsrInitConsoleScreenBuffer@8>
5ffb259a:	89 c7                	mov    %eax,%edi
5ffb259c:	85 c0                	test   %eax,%eax
5ffb259e:	0f 88 46 01 00 00    	js     5ffb26ea <_CsrAllocConsole@12+0x44a>
5ffb25a4:	8b 7e 04             	mov    0x4(%esi),%edi
5ffb25a7:	89 73 38             	mov    %esi,0x38(%ebx)
5ffb25aa:	47                   	inc    %edi
5ffb25ab:	89 d9                	mov    %ebx,%ecx
5ffb25ad:	89 7e 04             	mov    %edi,0x4(%esi)
5ffb25b0:	e8 9b ee ff ff       	call   5ffb1450 <@ConioDrawConsole@4>
5ffb25b5:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb25b8:	31 c0                	xor    %eax,%eax
5ffb25ba:	89 42 18             	mov    %eax,0x18(%edx)
5ffb25bd:	85 c0                	test   %eax,%eax
5ffb25bf:	0f 89 fb fd ff ff    	jns    5ffb23c0 <_CsrAllocConsole@12+0x120>
5ffb25c5:	56                   	push   %esi
5ffb25c6:	53                   	push   %ebx
5ffb25c7:	6a 00                	push   $0x0
5ffb25c9:	8b 0d e0 c1 fb 5f    	mov    0x5ffbc1e0,%ecx
5ffb25cf:	51                   	push   %ecx
5ffb25d0:	e8 2b 67 00 00       	call   5ffb8d00 <_HeapFree@12>
5ffb25d5:	8b 75 10             	mov    0x10(%ebp),%esi
5ffb25d8:	8b 46 18             	mov    0x18(%esi),%eax
5ffb25db:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb25de:	5b                   	pop    %ebx
5ffb25df:	5e                   	pop    %esi
5ffb25e0:	5f                   	pop    %edi
5ffb25e1:	5d                   	pop    %ebp
5ffb25e2:	c2 0c 00             	ret    $0xc
5ffb25e5:	83 ec 0c             	sub    $0xc,%esp
5ffb25e8:	8b 55 ac             	mov    0xffffffac(%ebp),%edx
5ffb25eb:	52                   	push   %edx
5ffb25ec:	e8 cf 66 00 00       	call   5ffb8cc0 <_CloseHandle@4>
5ffb25f1:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb25f4:	8b 55 08             	mov    0x8(%ebp),%edx
static __inline VOID
InsertHeadList(
  IN PLIST_ENTRY  ListHead,
  IN PLIST_ENTRY  Entry)
{ 
5ffb25f7:	89 d6                	mov    %edx,%esi
5ffb25f9:	83 c4 0c             	add    $0xc,%esp
5ffb25fc:	8b 40 1c             	mov    0x1c(%eax),%eax
5ffb25ff:	89 42 30             	mov    %eax,0x30(%edx)
static __inline VOID
InsertHeadList(
  IN PLIST_ENTRY  ListHead,
  IN PLIST_ENTRY  Entry)
{ 
5ffb2602:	8b 12                	mov    (%edx),%edx
5ffb2604:	89 f0                	mov    %esi,%eax
5ffb2606:	83 c0 28             	add    $0x28,%eax
  PLIST_ENTRY OldFlink;
  OldFlink = ListHead->Flink;
5ffb2609:	8b 4a 74             	mov    0x74(%edx),%ecx
5ffb260c:	8d 5a 74             	lea    0x74(%edx),%ebx
  Entry->Flink = OldFlink;
5ffb260f:	89 4e 28             	mov    %ecx,0x28(%esi)
  Entry->Blink = ListHead;
5ffb2612:	89 58 04             	mov    %ebx,0x4(%eax)
  OldFlink->Blink = Entry;
  ListHead->Flink = Entry;
5ffb2615:	89 42 74             	mov    %eax,0x74(%edx)
5ffb2618:	89 41 04             	mov    %eax,0x4(%ecx)
5ffb261b:	31 c0                	xor    %eax,%eax
5ffb261d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb2620:	5b                   	pop    %ebx
5ffb2621:	5e                   	pop    %esi
5ffb2622:	5f                   	pop    %edi
5ffb2623:	5d                   	pop    %ebp
5ffb2624:	c2 0c 00             	ret    $0xc
5ffb2627:	83 ec 0c             	sub    $0xc,%esp
5ffb262a:	53                   	push   %ebx
5ffb262b:	e8 70 fb ff ff       	call   5ffb21a0 <_ConioDeleteConsole@4>
5ffb2630:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb2633:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
5ffb2639:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb263c:	89 f0                	mov    %esi,%eax
5ffb263e:	89 72 18             	mov    %esi,0x18(%edx)
5ffb2641:	e9 c1 fe ff ff       	jmp    5ffb2507 <_CsrAllocConsole@12+0x267>
5ffb2646:	8b 7b 04             	mov    0x4(%ebx),%edi
5ffb2649:	4f                   	dec    %edi
5ffb264a:	89 7b 04             	mov    %edi,0x4(%ebx)
5ffb264d:	e9 96 fe ff ff       	jmp    5ffb24e8 <_CsrAllocConsole@12+0x248>
5ffb2652:	51                   	push   %ecx
5ffb2653:	68 52 01 00 00       	push   $0x152
5ffb2658:	68 40 b0 fb 5f       	push   $0x5ffbb040
5ffb265d:	68 48 b0 fb 5f       	push   $0x5ffbb048
5ffb2662:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb2668:	58                   	pop    %eax
5ffb2669:	5a                   	pop    %edx
5ffb266a:	56                   	push   %esi
5ffb266b:	68 38 b1 fb 5f       	push   $0x5ffbb138
5ffb2670:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb2676:	8b 43 04             	mov    0x4(%ebx),%eax
5ffb2679:	48                   	dec    %eax
5ffb267a:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb267d:	89 43 04             	mov    %eax,0x4(%ebx)
5ffb2680:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb2683:	c7 00 00 00 00 00    	movl   $0x0,(%eax)
5ffb2689:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb268c:	8b 50 24             	mov    0x24(%eax),%edx
5ffb268f:	e8 4c ea ff ff       	call   5ffb10e0 <@Win32CsrReleaseObject@8>
5ffb2694:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb2697:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb269a:	8b 50 20             	mov    0x20(%eax),%edx
5ffb269d:	e8 3e ea ff ff       	call   5ffb10e0 <@Win32CsrReleaseObject@8>
5ffb26a2:	eb 95                	jmp    5ffb2639 <_CsrAllocConsole@12+0x399>
5ffb26a4:	8b 75 10             	mov    0x10(%ebp),%esi
5ffb26a7:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
5ffb26ac:	c7 46 18 0d 00 00 c0 	movl   $0xc000000d,0x18(%esi)
5ffb26b3:	e9 65 ff ff ff       	jmp    5ffb261d <_CsrAllocConsole@12+0x37d>
5ffb26b8:	8b 43 70             	mov    0x70(%ebx),%eax
5ffb26bb:	83 ec 0c             	sub    $0xc,%esp
5ffb26be:	53                   	push   %ebx
5ffb26bf:	ff 50 18             	call   *0x18(%eax)
5ffb26c2:	8b 45 a4             	mov    0xffffffa4(%ebp),%eax
5ffb26c5:	50                   	push   %eax
5ffb26c6:	e8 45 65 00 00       	call   5ffb8c10 <_RtlFreeUnicodeString@4>
5ffb26cb:	8b 45 a8             	mov    0xffffffa8(%ebp),%eax
5ffb26ce:	50                   	push   %eax
5ffb26cf:	e8 5c 66 00 00       	call   5ffb8d30 <_DeleteCriticalSection@4>
5ffb26d4:	8b 43 28             	mov    0x28(%ebx),%eax
5ffb26d7:	50                   	push   %eax
5ffb26d8:	e8 e3 65 00 00       	call   5ffb8cc0 <_CloseHandle@4>
5ffb26dd:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
5ffb26e2:	83 c4 0c             	add    $0xc,%esp
5ffb26e5:	e9 c8 fc ff ff       	jmp    5ffb23b2 <_CsrAllocConsole@12+0x112>
5ffb26ea:	8b 43 70             	mov    0x70(%ebx),%eax
5ffb26ed:	83 ec 0c             	sub    $0xc,%esp
5ffb26f0:	53                   	push   %ebx
5ffb26f1:	ff 50 18             	call   *0x18(%eax)
5ffb26f4:	8b 45 a4             	mov    0xffffffa4(%ebp),%eax
5ffb26f7:	50                   	push   %eax
5ffb26f8:	e8 13 65 00 00       	call   5ffb8c10 <_RtlFreeUnicodeString@4>
5ffb26fd:	8b 45 a8             	mov    0xffffffa8(%ebp),%eax
5ffb2700:	50                   	push   %eax
5ffb2701:	e8 2a 66 00 00       	call   5ffb8d30 <_DeleteCriticalSection@4>
5ffb2706:	8b 4b 28             	mov    0x28(%ebx),%ecx
5ffb2709:	51                   	push   %ecx
5ffb270a:	e8 b1 65 00 00       	call   5ffb8cc0 <_CloseHandle@4>
5ffb270f:	58                   	pop    %eax
5ffb2710:	5a                   	pop    %edx
5ffb2711:	56                   	push   %esi
5ffb2712:	6a 00                	push   $0x0
5ffb2714:	a1 e0 c1 fb 5f       	mov    0x5ffbc1e0,%eax
5ffb2719:	50                   	push   %eax
5ffb271a:	e8 e1 65 00 00       	call   5ffb8d00 <_HeapFree@12>
5ffb271f:	58                   	pop    %eax
5ffb2720:	89 f8                	mov    %edi,%eax
5ffb2722:	e9 8b fc ff ff       	jmp    5ffb23b2 <_CsrAllocConsole@12+0x112>
5ffb2727:	83 ec 0c             	sub    $0xc,%esp
5ffb272a:	8b 45 a4             	mov    0xffffffa4(%ebp),%eax
5ffb272d:	50                   	push   %eax
5ffb272e:	e8 dd 64 00 00       	call   5ffb8c10 <_RtlFreeUnicodeString@4>
5ffb2733:	8b 45 a8             	mov    0xffffffa8(%ebp),%eax
5ffb2736:	50                   	push   %eax
5ffb2737:	e8 f4 65 00 00       	call   5ffb8d30 <_DeleteCriticalSection@4>
5ffb273c:	8b 43 28             	mov    0x28(%ebx),%eax
5ffb273f:	50                   	push   %eax
5ffb2740:	e8 7b 65 00 00       	call   5ffb8cc0 <_CloseHandle@4>
5ffb2745:	89 f8                	mov    %edi,%eax
5ffb2747:	83 c4 0c             	add    $0xc,%esp
5ffb274a:	e9 63 fc ff ff       	jmp    5ffb23b2 <_CsrAllocConsole@12+0x112>
5ffb274f:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb2752:	b8 17 00 00 c0       	mov    $0xc0000017,%eax
5ffb2757:	c7 42 18 17 00 00 c0 	movl   $0xc0000017,0x18(%edx)
5ffb275e:	e9 ba fe ff ff       	jmp    5ffb261d <_CsrAllocConsole@12+0x37d>
5ffb2763:	c7 40 18 0d 00 00 c0 	movl   $0xc000000d,0x18(%eax)
5ffb276a:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
5ffb276f:	e9 a9 fe ff ff       	jmp    5ffb261d <_CsrAllocConsole@12+0x37d>
5ffb2774:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb277a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

5ffb2780 <_CsrInitConsoleSupport@0>:
}

VOID STDCALL
CsrInitConsoleSupport(VOID)
{
5ffb2780:	55                   	push   %ebp
5ffb2781:	89 e5                	mov    %esp,%ebp
  DPRINT("CSR: CsrInitConsoleSupport()\n");

  /* Should call LoadKeyboardLayout */
}
5ffb2783:	5d                   	pop    %ebp
5ffb2784:	c3                   	ret    
5ffb2785:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb2789:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb2790 <@ConioProcessChar@8>:

STATIC VOID FASTCALL
ConioProcessChar(PCSRSS_CONSOLE Console,
                 ConsoleInput *KeyEventRecord)
{
5ffb2790:	55                   	push   %ebp
5ffb2791:	89 e5                	mov    %esp,%ebp
5ffb2793:	57                   	push   %edi
5ffb2794:	56                   	push   %esi
5ffb2795:	53                   	push   %ebx
5ffb2796:	83 ec 1c             	sub    $0x1c,%esp
5ffb2799:	89 cf                	mov    %ecx,%edi
  BOOL updown;
  BOOL bClientWake = FALSE;
  ConsoleInput *TempInput;

  /* process Ctrl-C and Ctrl-Break */
  if (Console->Mode & ENABLE_PROCESSED_INPUT &&
5ffb279b:	66 8b 49 3c          	mov    0x3c(%ecx),%cx
5ffb279f:	89 d6                	mov    %edx,%esi
5ffb27a1:	c7 45 f0 00 00 00 00 	movl   $0x0,0xfffffff0(%ebp)
5ffb27a8:	f6 c1 01             	test   $0x1,%cl
5ffb27ab:	74 0b                	je     5ffb27b8 <@ConioProcessChar@8+0x28>
5ffb27ad:	8b 42 0c             	mov    0xc(%edx),%eax
5ffb27b0:	85 c0                	test   %eax,%eax
5ffb27b2:	0f 85 79 01 00 00    	jne    5ffb2931 <@ConioProcessChar@8+0x1a1>
5ffb27b8:	8b 46 18             	mov    0x18(%esi),%eax
      KeyEventRecord->InputEvent.Event.KeyEvent.bKeyDown &&
      ((KeyEventRecord->InputEvent.Event.KeyEvent.wVirtualKeyCode == VK_PAUSE) || 
       (KeyEventRecord->InputEvent.Event.KeyEvent.wVirtualKeyCode == 'C')) &&
      (KeyEventRecord->InputEvent.Event.KeyEvent.dwControlKeyState & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)))
    {
      PCSRSS_PROCESS_DATA current;
      PLIST_ENTRY current_entry;
      DPRINT1("Console_Api Ctrl-C\n");
      current_entry = Console->ProcessList.Flink;
      while (current_entry != &Console->ProcessList)
	{
	  current = CONTAINING_RECORD(current_entry, CSRSS_PROCESS_DATA, ProcessEntry);
	  current_entry = current_entry->Flink;
	  ConioConsoleCtrlEvent((DWORD)CTRL_C_EVENT, current);
	}
      HeapFree(Win32CsrApiHeap, 0, KeyEventRecord);
      return;
    }

  if (0 != (KeyEventRecord->InputEvent.Event.KeyEvent.dwControlKeyState
5ffb27bb:	a8 03                	test   $0x3,%al
5ffb27bd:	0f 85 b1 00 00 00    	jne    5ffb2874 <@ConioProcessChar@8+0xe4>
            & (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED))
      && (VK_UP == KeyEventRecord->InputEvent.Event.KeyEvent.wVirtualKeyCode
          || VK_DOWN == KeyEventRecord->InputEvent.Event.KeyEvent.wVirtualKeyCode))
    {
      if (KeyEventRecord->InputEvent.Event.KeyEvent.bKeyDown)
	{
	  /* scroll up or down */
	  if (NULL == Console)
	    {
	      DPRINT1("No Active Console!\n");
	      HeapFree(Win32CsrApiHeap, 0, KeyEventRecord);
	      return;
	    }
	  if (VK_UP == KeyEventRecord->InputEvent.Event.KeyEvent.wVirtualKeyCode)
	    {
	      /* only scroll up if there is room to scroll up into */
	      if (Console->ActiveBuffer->ShowY != ((Console->ActiveBuffer->CurrentY + 1) %
                                                   Console->ActiveBuffer->MaxY))
                {
                  Console->ActiveBuffer->ShowY = (Console->ActiveBuffer->ShowY +
                                                  Console->ActiveBuffer->MaxY - 1) %
                                                 Console->ActiveBuffer->MaxY;
                }
            }
	  else if (Console->ActiveBuffer->ShowY != Console->ActiveBuffer->CurrentY)
	    /* only scroll down if there is room to scroll down into */
            {
	      if (Console->ActiveBuffer->ShowY % Console->ActiveBuffer->MaxY != 
		  Console->ActiveBuffer->CurrentY)
                {
                  if (((Console->ActiveBuffer->CurrentY + 1) % Console->ActiveBuffer->MaxY) != 
                      (Console->ActiveBuffer->ShowY + Console->ActiveBuffer->MaxY) %
                      Console->ActiveBuffer->MaxY)
                    {
                      Console->ActiveBuffer->ShowY = (Console->ActiveBuffer->ShowY + 1) %
                                                     Console->ActiveBuffer->MaxY;
                    }
                }
            }
          ConioDrawConsole(Console);
        }
      HeapFree(Win32CsrApiHeap, 0, KeyEventRecord);
      return;
    }
  if (NULL == Console)
5ffb27c3:	85 ff                	test   %edi,%edi
5ffb27c5:	0f 84 cd 02 00 00    	je     5ffb2a98 <@ConioProcessChar@8+0x308>
5ffb27cb:	8d 57 2c             	lea    0x2c(%edi),%edx
5ffb27ce:	89 55 e0             	mov    %edx,0xffffffe0(%ebp)
    {
      DPRINT1("No Active Console!\n");
      HeapFree(Win32CsrApiHeap, 0, KeyEventRecord);
      return;
    }

  if (0 != (Console->Mode & (ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT)))
5ffb27d1:	f6 c1 03             	test   $0x3,%cl
5ffb27d4:	74 0a                	je     5ffb27e0 <@ConioProcessChar@8+0x50>
    {
      switch(KeyEventRecord->InputEvent.Event.KeyEvent.uChar.AsciiChar)
5ffb27d6:	80 7e 16 0d          	cmpb   $0xd,0x16(%esi)
5ffb27da:	0f 84 e3 02 00 00    	je     5ffb2ac3 <@ConioProcessChar@8+0x333>
        {
          case '\r':
            /* first add the \r */
            KeyEventRecord->InputEvent.EventType = KEY_EVENT;
            updown = KeyEventRecord->InputEvent.Event.KeyEvent.bKeyDown;
            KeyEventRecord->Echoed = FALSE;
            KeyEventRecord->InputEvent.Event.KeyEvent.wVirtualKeyCode = VK_RETURN;
            KeyEventRecord->InputEvent.Event.KeyEvent.uChar.AsciiChar = '\r';
            InsertTailList(&Console->InputEvents, &KeyEventRecord->ListEntry);
            Console->WaitingChars++;
            KeyEventRecord = HeapAlloc(Win32CsrApiHeap, 0, sizeof(ConsoleInput));
            if (NULL == KeyEventRecord)
              {
                DPRINT1("Failed to allocate KeyEventRecord\n");
                return;
              }
            KeyEventRecord->InputEvent.EventType = KEY_EVENT;
            KeyEventRecord->InputEvent.Event.KeyEvent.bKeyDown = updown;
            KeyEventRecord->InputEvent.Event.KeyEvent.wVirtualKeyCode = 0;
            KeyEventRecord->InputEvent.Event.KeyEvent.wVirtualScanCode = 0;
            KeyEventRecord->InputEvent.Event.KeyEvent.uChar.AsciiChar = '\n';
            KeyEventRecord->Fake = TRUE;
            break;
        }
    }
  /* add event to the queue */
  InsertTailList(&Console->InputEvents, &KeyEventRecord->ListEntry);
  Console->WaitingChars++;
5ffb27e0:	66 ff 47 34          	incw   0x34(%edi)
  IN PLIST_ENTRY  ListHead,
  IN PLIST_ENTRY  Entry)
{ 
  PLIST_ENTRY OldBlink;
  OldBlink = ListHead->Blink;
5ffb27e4:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
5ffb27e7:	8b 42 04             	mov    0x4(%edx),%eax
  /* if line input mode is enabled, only wake the client on enter key down */
  if (0 == (Console->Mode & ENABLE_LINE_INPUT)
5ffb27ea:	83 e1 02             	and    $0x2,%ecx
  IN PLIST_ENTRY  Entry)
{ 
  PLIST_ENTRY OldBlink;
  OldBlink = ListHead->Blink;
  Entry->Flink = ListHead;
5ffb27ed:	89 16                	mov    %edx,(%esi)
  Entry->Blink = OldBlink;
5ffb27ef:	89 46 04             	mov    %eax,0x4(%esi)
  OldBlink->Flink = Entry;
5ffb27f2:	89 30                	mov    %esi,(%eax)
  ListHead->Blink = Entry;
5ffb27f4:	89 72 04             	mov    %esi,0x4(%edx)
5ffb27f7:	74 0b                	je     5ffb2804 <@ConioProcessChar@8+0x74>
5ffb27f9:	8b 47 50             	mov    0x50(%edi),%eax
5ffb27fc:	85 c0                	test   %eax,%eax
5ffb27fe:	0f 84 94 01 00 00    	je     5ffb2998 <@ConioProcessChar@8+0x208>
5ffb2804:	8a 46 16             	mov    0x16(%esi),%al
      || Console->EarlyReturn
      || ('\n' == KeyEventRecord->InputEvent.Event.KeyEvent.uChar.AsciiChar
          && KeyEventRecord->InputEvent.Event.KeyEvent.bKeyDown))
    {
      if ('\n' == KeyEventRecord->InputEvent.Event.KeyEvent.uChar.AsciiChar)
5ffb2807:	3c 0a                	cmp    $0xa,%al
5ffb2809:	0f 84 a1 01 00 00    	je     5ffb29b0 <@ConioProcessChar@8+0x220>
        {
          Console->WaitingLines++;
        }
      bClientWake = TRUE;
      SetEvent(Console->ActiveEvent);
5ffb280f:	83 ec 0c             	sub    $0xc,%esp
5ffb2812:	c7 45 f0 01 00 00 00 	movl   $0x1,0xfffffff0(%ebp)
5ffb2819:	8b 4f 28             	mov    0x28(%edi),%ecx
5ffb281c:	51                   	push   %ecx
5ffb281d:	e8 5e 65 00 00       	call   5ffb8d80 <_SetEvent@4>
5ffb2822:	83 c4 0c             	add    $0xc,%esp
    }
  KeyEventRecord->Echoed = FALSE;
5ffb2825:	c6 46 1c 00          	movb   $0x0,0x1c(%esi)
  if (0 != (Console->Mode & (ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT))
5ffb2829:	66 8b 4f 3c          	mov    0x3c(%edi),%cx
5ffb282d:	f6 c1 03             	test   $0x3,%cl
5ffb2830:	74 0a                	je     5ffb283c <@ConioProcessChar@8+0xac>
5ffb2832:	80 7e 16 08          	cmpb   $0x8,0x16(%esi)
5ffb2836:	0f 84 c3 01 00 00    	je     5ffb29ff <@ConioProcessChar@8+0x26f>
      && '\b' == KeyEventRecord->InputEvent.Event.KeyEvent.uChar.AsciiChar
      && KeyEventRecord->InputEvent.Event.KeyEvent.bKeyDown)
    {
      /* walk the input queue looking for a char to backspace */
      for (TempInput = (ConsoleInput *) Console->InputEvents.Blink;
	   TempInput != (ConsoleInput *) &Console->InputEvents
           && (KEY_EVENT == TempInput->InputEvent.EventType
               || ! TempInput->InputEvent.Event.KeyEvent.bKeyDown
               || '\b' == TempInput->InputEvent.Event.KeyEvent.uChar.AsciiChar);
	   TempInput = (ConsoleInput *) TempInput->ListEntry.Blink)
        {
          /* NOP */;
        }
      /* if we found one, delete it, otherwise, wake the client */
      if (TempInput != (ConsoleInput *) &Console->InputEvents)
	{
	  /* delete previous key in queue, maybe echo backspace to screen, and do not place backspace on queue */
	  RemoveEntryList(&TempInput->ListEntry);
	  if (TempInput->Echoed)
            {
              ConioWriteConsole(Console, Console->ActiveBuffer,
                               &KeyEventRecord->InputEvent.Event.KeyEvent.uChar.AsciiChar,
                               1, TRUE);
            }
          HeapFree(Win32CsrApiHeap, 0, TempInput);
	  RemoveEntryList(&KeyEventRecord->ListEntry);
	  HeapFree(Win32CsrApiHeap, 0, KeyEventRecord);
	  Console->WaitingChars -= 2;
	}
      else
        {
          SetEvent(Console->ActiveEvent);
        }
    }
  else
    {
      /* echo chars if we are supposed to and client is waiting for some */
      if (0 != (Console->Mode & ENABLE_ECHO_INPUT) && Console->EchoCount
5ffb283c:	83 e1 04             	and    $0x4,%ecx
5ffb283f:	74 0f                	je     5ffb2850 <@ConioProcessChar@8+0xc0>
5ffb2841:	66 83 7f 3e 00       	cmpw   $0x0,0x3e(%edi)
5ffb2846:	0f 85 74 01 00 00    	jne    5ffb29c0 <@ConioProcessChar@8+0x230>
5ffb284c:	8d 74 26 00          	lea    0x0(%esi),%esi
          && KeyEventRecord->InputEvent.Event.KeyEvent.uChar.AsciiChar
          && KeyEventRecord->InputEvent.Event.KeyEvent.bKeyDown
          && '\r' != KeyEventRecord->InputEvent.Event.KeyEvent.uChar.AsciiChar)
        {
          /* mark the char as already echoed */
          ConioWriteConsole(Console, Console->ActiveBuffer,
                           &KeyEventRecord->InputEvent.Event.KeyEvent.uChar.AsciiChar,
                           1, TRUE);
          Console->EchoCount--;
          KeyEventRecord->Echoed = TRUE;
        }
    }

  /* Console->WaitingChars++; */
  if (bClientWake || 0 == (Console->Mode & ENABLE_LINE_INPUT))
5ffb2850:	8b 5d f0             	mov    0xfffffff0(%ebp),%ebx
5ffb2853:	85 db                	test   %ebx,%ebx
5ffb2855:	75 06                	jne    5ffb285d <@ConioProcessChar@8+0xcd>
5ffb2857:	f6 47 3c 02          	testb  $0x2,0x3c(%edi)
5ffb285b:	75 0f                	jne    5ffb286c <@ConioProcessChar@8+0xdc>
    {
      SetEvent(Console->ActiveEvent);
5ffb285d:	83 ec 0c             	sub    $0xc,%esp
5ffb2860:	8b 4f 28             	mov    0x28(%edi),%ecx
5ffb2863:	51                   	push   %ecx
5ffb2864:	e8 17 65 00 00       	call   5ffb8d80 <_SetEvent@4>
5ffb2869:	83 c4 0c             	add    $0xc,%esp
    }
}
5ffb286c:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb286f:	5b                   	pop    %ebx
5ffb2870:	5e                   	pop    %esi
5ffb2871:	5f                   	pop    %edi
5ffb2872:	5d                   	pop    %ebp
5ffb2873:	c3                   	ret    
5ffb2874:	66 8b 5e 12          	mov    0x12(%esi),%bx
5ffb2878:	66 83 fb 26          	cmp    $0x26,%bx
5ffb287c:	0f 94 c2             	sete   %dl
5ffb287f:	66 83 fb 28          	cmp    $0x28,%bx
5ffb2883:	0f 94 c0             	sete   %al
5ffb2886:	09 d0                	or     %edx,%eax
5ffb2888:	a8 01                	test   $0x1,%al
5ffb288a:	0f 84 33 ff ff ff    	je     5ffb27c3 <@ConioProcessChar@8+0x33>
5ffb2890:	8b 46 0c             	mov    0xc(%esi),%eax
5ffb2893:	85 c0                	test   %eax,%eax
5ffb2895:	0f 84 7f 00 00 00    	je     5ffb291a <@ConioProcessChar@8+0x18a>
5ffb289b:	85 ff                	test   %edi,%edi
5ffb289d:	0f 84 e3 02 00 00    	je     5ffb2b86 <@ConioProcessChar@8+0x3f6>
5ffb28a3:	66 83 fb 26          	cmp    $0x26,%bx
5ffb28a7:	0f 84 82 02 00 00    	je     5ffb2b2f <@ConioProcessChar@8+0x39f>
5ffb28ad:	8b 57 38             	mov    0x38(%edi),%edx
5ffb28b0:	89 55 e8             	mov    %edx,0xffffffe8(%ebp)
5ffb28b3:	66 8b 42 2a          	mov    0x2a(%edx),%ax
5ffb28b7:	89 c2                	mov    %eax,%edx
5ffb28b9:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb28bf:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
5ffb28c2:	8b 55 e8             	mov    0xffffffe8(%ebp),%edx
5ffb28c5:	8b 5a 30             	mov    0x30(%edx),%ebx
5ffb28c8:	39 5d e4             	cmp    %ebx,0xffffffe4(%ebp)
5ffb28cb:	74 46                	je     5ffb2913 <@ConioProcessChar@8+0x183>
5ffb28cd:	66 8b 4a 26          	mov    0x26(%edx),%cx
5ffb28d1:	31 d2                	xor    %edx,%edx
5ffb28d3:	66 f7 f1             	div    %cx
5ffb28d6:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb28dc:	39 da                	cmp    %ebx,%edx
5ffb28de:	74 33                	je     5ffb2913 <@ConioProcessChar@8+0x183>
5ffb28e0:	8d 43 01             	lea    0x1(%ebx),%eax
5ffb28e3:	89 cb                	mov    %ecx,%ebx
5ffb28e5:	81 e3 ff ff 00 00    	and    $0xffff,%ebx
5ffb28eb:	31 d2                	xor    %edx,%edx
5ffb28ed:	f7 f3                	div    %ebx
5ffb28ef:	89 d1                	mov    %edx,%ecx
5ffb28f1:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
5ffb28f4:	01 da                	add    %ebx,%edx
5ffb28f6:	89 d0                	mov    %edx,%eax
5ffb28f8:	c1 fa 1f             	sar    $0x1f,%edx
5ffb28fb:	f7 fb                	idiv   %ebx
5ffb28fd:	39 d1                	cmp    %edx,%ecx
5ffb28ff:	74 12                	je     5ffb2913 <@ConioProcessChar@8+0x183>
5ffb2901:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
5ffb2904:	42                   	inc    %edx
5ffb2905:	89 d0                	mov    %edx,%eax
5ffb2907:	c1 fa 1f             	sar    $0x1f,%edx
5ffb290a:	f7 fb                	idiv   %ebx
5ffb290c:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
5ffb290f:	66 89 50 2a          	mov    %dx,0x2a(%eax)
5ffb2913:	89 f9                	mov    %edi,%ecx
5ffb2915:	e8 36 eb ff ff       	call   5ffb1450 <@ConioDrawConsole@4>
5ffb291a:	51                   	push   %ecx
5ffb291b:	56                   	push   %esi
5ffb291c:	6a 00                	push   $0x0
5ffb291e:	a1 e0 c1 fb 5f       	mov    0x5ffbc1e0,%eax
5ffb2923:	50                   	push   %eax
5ffb2924:	e8 d7 63 00 00       	call   5ffb8d00 <_HeapFree@12>
5ffb2929:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb292c:	5b                   	pop    %ebx
5ffb292d:	5e                   	pop    %esi
5ffb292e:	5f                   	pop    %edi
5ffb292f:	5d                   	pop    %ebp
5ffb2930:	c3                   	ret    
5ffb2931:	66 8b 42 12          	mov    0x12(%edx),%ax
5ffb2935:	66 83 f8 13          	cmp    $0x13,%ax
5ffb2939:	0f 94 c2             	sete   %dl
5ffb293c:	66 83 f8 43          	cmp    $0x43,%ax
5ffb2940:	0f 94 c0             	sete   %al
5ffb2943:	09 d0                	or     %edx,%eax
5ffb2945:	a8 01                	test   $0x1,%al
5ffb2947:	0f 84 6b fe ff ff    	je     5ffb27b8 <@ConioProcessChar@8+0x28>
5ffb294d:	8b 46 18             	mov    0x18(%esi),%eax
5ffb2950:	a8 0c                	test   $0xc,%al
5ffb2952:	0f 84 63 fe ff ff    	je     5ffb27bb <@ConioProcessChar@8+0x2b>
5ffb2958:	50                   	push   %eax
5ffb2959:	68 26 04 00 00       	push   $0x426
5ffb295e:	68 40 b0 fb 5f       	push   $0x5ffbb040
5ffb2963:	68 48 b0 fb 5f       	push   $0x5ffbb048
5ffb2968:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb296e:	c7 04 24 75 b1 fb 5f 	movl   $0x5ffbb175,(%esp)
5ffb2975:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb297b:	8b 5f 74             	mov    0x74(%edi),%ebx
5ffb297e:	83 c4 10             	add    $0x10,%esp
5ffb2981:	83 c7 74             	add    $0x74,%edi
5ffb2984:	eb 0c                	jmp    5ffb2992 <@ConioProcessChar@8+0x202>
5ffb2986:	8d 53 d8             	lea    0xffffffd8(%ebx),%edx
5ffb2989:	31 c9                	xor    %ecx,%ecx
5ffb298b:	8b 1b                	mov    (%ebx),%ebx
5ffb298d:	e8 6e e8 ff ff       	call   5ffb1200 <@ConioConsoleCtrlEvent@8>
5ffb2992:	39 df                	cmp    %ebx,%edi
5ffb2994:	75 f0                	jne    5ffb2986 <@ConioProcessChar@8+0x1f6>
5ffb2996:	eb 82                	jmp    5ffb291a <@ConioProcessChar@8+0x18a>
5ffb2998:	80 7e 16 0a          	cmpb   $0xa,0x16(%esi)
5ffb299c:	0f 85 83 fe ff ff    	jne    5ffb2825 <@ConioProcessChar@8+0x95>
5ffb29a2:	8b 5e 0c             	mov    0xc(%esi),%ebx
5ffb29a5:	85 db                	test   %ebx,%ebx
5ffb29a7:	0f 84 78 fe ff ff    	je     5ffb2825 <@ConioProcessChar@8+0x95>
5ffb29ad:	8d 76 00             	lea    0x0(%esi),%esi
5ffb29b0:	66 ff 47 36          	incw   0x36(%edi)
5ffb29b4:	e9 56 fe ff ff       	jmp    5ffb280f <@ConioProcessChar@8+0x7f>
5ffb29b9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
5ffb29c0:	8a 46 16             	mov    0x16(%esi),%al
5ffb29c3:	84 c0                	test   %al,%al
5ffb29c5:	0f 84 85 fe ff ff    	je     5ffb2850 <@ConioProcessChar@8+0xc0>
5ffb29cb:	8b 56 0c             	mov    0xc(%esi),%edx
5ffb29ce:	85 d2                	test   %edx,%edx
5ffb29d0:	0f 84 7a fe ff ff    	je     5ffb2850 <@ConioProcessChar@8+0xc0>
5ffb29d6:	3c 0d                	cmp    $0xd,%al
5ffb29d8:	0f 84 72 fe ff ff    	je     5ffb2850 <@ConioProcessChar@8+0xc0>
5ffb29de:	50                   	push   %eax
5ffb29df:	8b 57 38             	mov    0x38(%edi),%edx
5ffb29e2:	8d 46 16             	lea    0x16(%esi),%eax
5ffb29e5:	89 f9                	mov    %edi,%ecx
5ffb29e7:	6a 01                	push   $0x1
5ffb29e9:	6a 01                	push   $0x1
5ffb29eb:	50                   	push   %eax
5ffb29ec:	e8 ef eb ff ff       	call   5ffb15e0 <@ConioWriteConsole@20>
5ffb29f1:	66 ff 4f 3e          	decw   0x3e(%edi)
5ffb29f5:	c6 46 1c 01          	movb   $0x1,0x1c(%esi)
5ffb29f9:	5e                   	pop    %esi
5ffb29fa:	e9 51 fe ff ff       	jmp    5ffb2850 <@ConioProcessChar@8+0xc0>
5ffb29ff:	8b 56 0c             	mov    0xc(%esi),%edx
5ffb2a02:	85 d2                	test   %edx,%edx
5ffb2a04:	0f 84 32 fe ff ff    	je     5ffb283c <@ConioProcessChar@8+0xac>
5ffb2a0a:	8b 5f 30             	mov    0x30(%edi),%ebx
5ffb2a0d:	39 5d e0             	cmp    %ebx,0xffffffe0(%ebp)
5ffb2a10:	0f 84 5c 01 00 00    	je     5ffb2b72 <@ConioProcessChar@8+0x3e2>
5ffb2a16:	66 83 7b 08 01       	cmpw   $0x1,0x8(%ebx)
5ffb2a1b:	74 0b                	je     5ffb2a28 <@ConioProcessChar@8+0x298>
5ffb2a1d:	8b 43 0c             	mov    0xc(%ebx),%eax
5ffb2a20:	85 c0                	test   %eax,%eax
5ffb2a22:	0f 85 69 01 00 00    	jne    5ffb2b91 <@ConioProcessChar@8+0x401>
5ffb2a28:	8b 5b 04             	mov    0x4(%ebx),%ebx
5ffb2a2b:	39 5d e0             	cmp    %ebx,0xffffffe0(%ebp)
5ffb2a2e:	0f 84 3e 01 00 00    	je     5ffb2b72 <@ConioProcessChar@8+0x3e2>
5ffb2a34:	66 83 7b 08 01       	cmpw   $0x1,0x8(%ebx)
5ffb2a39:	74 ed                	je     5ffb2a28 <@ConioProcessChar@8+0x298>
5ffb2a3b:	8b 43 0c             	mov    0xc(%ebx),%eax
5ffb2a3e:	85 c0                	test   %eax,%eax
5ffb2a40:	74 e6                	je     5ffb2a28 <@ConioProcessChar@8+0x298>
5ffb2a42:	80 7b 16 08          	cmpb   $0x8,0x16(%ebx)
5ffb2a46:	74 e0                	je     5ffb2a28 <@ConioProcessChar@8+0x298>
5ffb2a48:	39 5d e0             	cmp    %ebx,0xffffffe0(%ebp)
5ffb2a4b:	0f 84 21 01 00 00    	je     5ffb2b72 <@ConioProcessChar@8+0x3e2>
{
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
5ffb2a51:	8b 13                	mov    (%ebx),%edx
  OldBlink = Entry->Blink;
5ffb2a53:	8b 43 04             	mov    0x4(%ebx),%eax
  OldFlink->Blink = OldBlink;
5ffb2a56:	89 42 04             	mov    %eax,0x4(%edx)
  OldBlink->Flink = OldFlink;
5ffb2a59:	89 10                	mov    %edx,(%eax)
5ffb2a5b:	80 7b 1c 00          	cmpb   $0x0,0x1c(%ebx)
5ffb2a5f:	0f 85 63 01 00 00    	jne    5ffb2bc8 <@ConioProcessChar@8+0x438>
5ffb2a65:	50                   	push   %eax
5ffb2a66:	53                   	push   %ebx
5ffb2a67:	6a 00                	push   $0x0
5ffb2a69:	a1 e0 c1 fb 5f       	mov    0x5ffbc1e0,%eax
5ffb2a6e:	50                   	push   %eax
5ffb2a6f:	e8 8c 62 00 00       	call   5ffb8d00 <_HeapFree@12>
{
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
5ffb2a74:	8b 16                	mov    (%esi),%edx
  OldBlink = Entry->Blink;
5ffb2a76:	8b 46 04             	mov    0x4(%esi),%eax
  OldFlink->Blink = OldBlink;
5ffb2a79:	89 42 04             	mov    %eax,0x4(%edx)
  OldBlink->Flink = OldFlink;
5ffb2a7c:	89 10                	mov    %edx,(%eax)
5ffb2a7e:	56                   	push   %esi
5ffb2a7f:	6a 00                	push   $0x0
5ffb2a81:	8b 1d e0 c1 fb 5f    	mov    0x5ffbc1e0,%ebx
5ffb2a87:	53                   	push   %ebx
5ffb2a88:	e8 73 62 00 00       	call   5ffb8d00 <_HeapFree@12>
5ffb2a8d:	66 83 6f 34 02       	subw   $0x2,0x34(%edi)
5ffb2a92:	5e                   	pop    %esi
5ffb2a93:	e9 b8 fd ff ff       	jmp    5ffb2850 <@ConioProcessChar@8+0xc0>
5ffb2a98:	52                   	push   %edx
5ffb2a99:	68 61 04 00 00       	push   $0x461
5ffb2a9e:	68 40 b0 fb 5f       	push   $0x5ffbb040
5ffb2aa3:	68 48 b0 fb 5f       	push   $0x5ffbb048
5ffb2aa8:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb2aae:	c7 04 24 89 b1 fb 5f 	movl   $0x5ffbb189,(%esp)
5ffb2ab5:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb2abb:	83 c4 0c             	add    $0xc,%esp
5ffb2abe:	e9 58 fe ff ff       	jmp    5ffb291b <@ConioProcessChar@8+0x18b>
5ffb2ac3:	c6 46 1c 00          	movb   $0x0,0x1c(%esi)
5ffb2ac7:	c6 46 16 0d          	movb   $0xd,0x16(%esi)
5ffb2acb:	66 c7 46 12 0d 00    	movw   $0xd,0x12(%esi)
5ffb2ad1:	66 c7 46 08 01 00    	movw   $0x1,0x8(%esi)
  IN PLIST_ENTRY  ListHead,
  IN PLIST_ENTRY  Entry)
{ 
  PLIST_ENTRY OldBlink;
  OldBlink = ListHead->Blink;
5ffb2ad7:	8b 42 04             	mov    0x4(%edx),%eax
5ffb2ada:	8b 5e 0c             	mov    0xc(%esi),%ebx
5ffb2add:	66 ff 47 34          	incw   0x34(%edi)
{ 
  PLIST_ENTRY OldBlink;
  OldBlink = ListHead->Blink;
  Entry->Flink = ListHead;
  Entry->Blink = OldBlink;
5ffb2ae1:	89 46 04             	mov    %eax,0x4(%esi)
5ffb2ae4:	89 16                	mov    %edx,(%esi)
  OldBlink->Flink = Entry;
  ListHead->Blink = Entry;
5ffb2ae6:	89 72 04             	mov    %esi,0x4(%edx)
5ffb2ae9:	89 30                	mov    %esi,(%eax)
5ffb2aeb:	89 55 e0             	mov    %edx,0xffffffe0(%ebp)
5ffb2aee:	50                   	push   %eax
5ffb2aef:	6a 20                	push   $0x20
5ffb2af1:	6a 00                	push   $0x0
5ffb2af3:	a1 e0 c1 fb 5f       	mov    0x5ffbc1e0,%eax
5ffb2af8:	50                   	push   %eax
5ffb2af9:	e8 f2 61 00 00       	call   5ffb8cf0 <_HeapAlloc@12>
5ffb2afe:	89 c6                	mov    %eax,%esi
5ffb2b00:	58                   	pop    %eax
5ffb2b01:	85 f6                	test   %esi,%esi
5ffb2b03:	0f 84 97 00 00 00    	je     5ffb2ba0 <@ConioProcessChar@8+0x410>
5ffb2b09:	66 c7 46 08 01 00    	movw   $0x1,0x8(%esi)
5ffb2b0f:	89 5e 0c             	mov    %ebx,0xc(%esi)
5ffb2b12:	66 c7 46 12 00 00    	movw   $0x0,0x12(%esi)
5ffb2b18:	66 c7 46 14 00 00    	movw   $0x0,0x14(%esi)
5ffb2b1e:	c6 46 16 0a          	movb   $0xa,0x16(%esi)
5ffb2b22:	c6 46 1d 01          	movb   $0x1,0x1d(%esi)
5ffb2b26:	66 8b 4f 3c          	mov    0x3c(%edi),%cx
5ffb2b2a:	e9 b1 fc ff ff       	jmp    5ffb27e0 <@ConioProcessChar@8+0x50>
5ffb2b2f:	8b 5f 38             	mov    0x38(%edi),%ebx
5ffb2b32:	66 8b 43 2a          	mov    0x2a(%ebx),%ax
5ffb2b36:	66 8b 53 26          	mov    0x26(%ebx),%dx
5ffb2b3a:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb2b3f:	89 d1                	mov    %edx,%ecx
5ffb2b41:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
5ffb2b44:	8b 43 30             	mov    0x30(%ebx),%eax
5ffb2b47:	40                   	inc    %eax
5ffb2b48:	81 e1 ff ff 00 00    	and    $0xffff,%ecx
5ffb2b4e:	31 d2                	xor    %edx,%edx
5ffb2b50:	f7 f1                	div    %ecx
5ffb2b52:	39 55 ec             	cmp    %edx,0xffffffec(%ebp)
5ffb2b55:	0f 84 b8 fd ff ff    	je     5ffb2913 <@ConioProcessChar@8+0x183>
5ffb2b5b:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb2b5e:	8d 54 08 ff          	lea    0xffffffff(%eax,%ecx,1),%edx
5ffb2b62:	89 d0                	mov    %edx,%eax
5ffb2b64:	c1 fa 1f             	sar    $0x1f,%edx
5ffb2b67:	f7 f9                	idiv   %ecx
5ffb2b69:	66 89 53 2a          	mov    %dx,0x2a(%ebx)
5ffb2b6d:	e9 a1 fd ff ff       	jmp    5ffb2913 <@ConioProcessChar@8+0x183>
5ffb2b72:	83 ec 0c             	sub    $0xc,%esp
5ffb2b75:	8b 4f 28             	mov    0x28(%edi),%ecx
5ffb2b78:	51                   	push   %ecx
5ffb2b79:	e8 02 62 00 00       	call   5ffb8d80 <_SetEvent@4>
5ffb2b7e:	83 c4 0c             	add    $0xc,%esp
5ffb2b81:	e9 ca fc ff ff       	jmp    5ffb2850 <@ConioProcessChar@8+0xc0>
5ffb2b86:	53                   	push   %ebx
5ffb2b87:	68 3c 04 00 00       	push   $0x43c
5ffb2b8c:	e9 0d ff ff ff       	jmp    5ffb2a9e <@ConioProcessChar@8+0x30e>
5ffb2b91:	80 7b 16 08          	cmpb   $0x8,0x16(%ebx)
5ffb2b95:	0f 85 ad fe ff ff    	jne    5ffb2a48 <@ConioProcessChar@8+0x2b8>
5ffb2b9b:	e9 88 fe ff ff       	jmp    5ffb2a28 <@ConioProcessChar@8+0x298>
5ffb2ba0:	50                   	push   %eax
5ffb2ba1:	68 76 04 00 00       	push   $0x476
5ffb2ba6:	68 40 b0 fb 5f       	push   $0x5ffbb040
5ffb2bab:	68 48 b0 fb 5f       	push   $0x5ffbb048
5ffb2bb0:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb2bb6:	c7 04 24 a0 b1 fb 5f 	movl   $0x5ffbb1a0,(%esp)
5ffb2bbd:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb2bc3:	e9 a4 fc ff ff       	jmp    5ffb286c <@ConioProcessChar@8+0xdc>
5ffb2bc8:	50                   	push   %eax
5ffb2bc9:	8b 57 38             	mov    0x38(%edi),%edx
5ffb2bcc:	8d 46 16             	lea    0x16(%esi),%eax
5ffb2bcf:	89 f9                	mov    %edi,%ecx
5ffb2bd1:	6a 01                	push   $0x1
5ffb2bd3:	6a 01                	push   $0x1
5ffb2bd5:	50                   	push   %eax
5ffb2bd6:	e8 05 ea ff ff       	call   5ffb15e0 <@ConioWriteConsole@20>
5ffb2bdb:	58                   	pop    %eax
5ffb2bdc:	e9 84 fe ff ff       	jmp    5ffb2a65 <@ConioProcessChar@8+0x2d5>
5ffb2be1:	eb 0d                	jmp    5ffb2bf0 <_ConioProcessKey@12>
5ffb2be3:	90                   	nop    
5ffb2be4:	90                   	nop    
5ffb2be5:	90                   	nop    
5ffb2be6:	90                   	nop    
5ffb2be7:	90                   	nop    
5ffb2be8:	90                   	nop    
5ffb2be9:	90                   	nop    
5ffb2bea:	90                   	nop    
5ffb2beb:	90                   	nop    
5ffb2bec:	90                   	nop    
5ffb2bed:	90                   	nop    
5ffb2bee:	90                   	nop    
5ffb2bef:	90                   	nop    

5ffb2bf0 <_ConioProcessKey@12>:

STATIC DWORD FASTCALL
ConioGetShiftState(PBYTE KeyState)
{
  DWORD ssOut = 0;

  if (KeyState[VK_CAPITAL] & 1)
      ssOut |= CAPSLOCK_ON;

  if (KeyState[VK_NUMLOCK] & 1)
      ssOut |= NUMLOCK_ON;

  if (KeyState[VK_SCROLL] & 1)
      ssOut |= SCROLLLOCK_ON;

  if (KeyState[VK_SHIFT] & 0x80)
      ssOut |= SHIFT_PRESSED;

  if (KeyState[VK_LCONTROL] & 0x80)
      ssOut |= LEFT_CTRL_PRESSED;
  if (KeyState[VK_RCONTROL] & 0x80)
      ssOut |= RIGHT_CTRL_PRESSED;

  if (KeyState[VK_LMENU] & 0x80)
      ssOut |= LEFT_ALT_PRESSED;
  if (KeyState[VK_RMENU] & 0x80)
      ssOut |= RIGHT_ALT_PRESSED;

  return ssOut;
}

VOID STDCALL
ConioProcessKey(MSG *msg, PCSRSS_CONSOLE Console, BOOL TextMode)
{
5ffb2bf0:	55                   	push   %ebp
  static BYTE KeyState[256] = { 0 };
  /* MSDN mentions that you should use the last virtual key code received
   * when putting a virtual key identity to a WM_CHAR message since multiple
   * or translated keys may be involved. */
  static UINT LastVirtualKey = 0;
  DWORD ShiftState;
  ConsoleInput *ConInRec;
  UINT RepeatCount;
  CHAR AsciiChar;
  WCHAR UnicodeChar;
  UINT VirtualKeyCode;
  UINT VirtualScanCode;
  BOOL Down = FALSE;
  INPUT_RECORD er;
  ULONG ResultSize = 0;

  RepeatCount = 1;
  VirtualScanCode = (msg->lParam >> 16) & 0xff;
5ffb2bf1:	31 c0                	xor    %eax,%eax
5ffb2bf3:	89 e5                	mov    %esp,%ebp
5ffb2bf5:	57                   	push   %edi
5ffb2bf6:	56                   	push   %esi
5ffb2bf7:	53                   	push   %ebx
5ffb2bf8:	83 ec 3c             	sub    $0x3c,%esp
5ffb2bfb:	c7 45 bc 00 00 00 00 	movl   $0x0,0xffffffbc(%ebp)
5ffb2c02:	8b 55 08             	mov    0x8(%ebp),%edx
5ffb2c05:	8a 42 0e             	mov    0xe(%edx),%al
  Down = msg->message == WM_KEYDOWN || msg->message == WM_CHAR || 
5ffb2c08:	8b 4a 04             	mov    0x4(%edx),%ecx
5ffb2c0b:	81 f9 00 01 00 00    	cmp    $0x100,%ecx
5ffb2c11:	89 45 c0             	mov    %eax,0xffffffc0(%ebp)
5ffb2c14:	0f 94 c2             	sete   %dl
5ffb2c17:	81 f9 02 01 00 00    	cmp    $0x102,%ecx
5ffb2c1d:	0f 94 c0             	sete   %al
5ffb2c20:	09 d0                	or     %edx,%eax
5ffb2c22:	a8 01                	test   $0x1,%al
5ffb2c24:	75 10                	jne    5ffb2c36 <_ConioProcessKey@12+0x46>
5ffb2c26:	81 f9 04 01 00 00    	cmp    $0x104,%ecx
5ffb2c2c:	74 08                	je     5ffb2c36 <_ConioProcessKey@12+0x46>
5ffb2c2e:	81 f9 06 01 00 00    	cmp    $0x106,%ecx
5ffb2c34:	75 07                	jne    5ffb2c3d <_ConioProcessKey@12+0x4d>
5ffb2c36:	c7 45 bc 01 00 00 00 	movl   $0x1,0xffffffbc(%ebp)
    msg->message == WM_SYSKEYDOWN || msg->message == WM_SYSCHAR;

  GetKeyboardState(KeyState);
5ffb2c3d:	83 ec 0c             	sub    $0xc,%esp
5ffb2c40:	31 db                	xor    %ebx,%ebx
5ffb2c42:	68 10 c0 fb 5f       	push   $0x5ffbc010
5ffb2c47:	e8 04 62 00 00       	call   5ffb8e50 <_GetKeyboardState@4>
5ffb2c4c:	83 c4 0c             	add    $0xc,%esp
5ffb2c4f:	f6 05 24 c0 fb 5f 01 	testb  $0x1,0x5ffbc024
5ffb2c56:	74 02                	je     5ffb2c5a <_ConioProcessKey@12+0x6a>
5ffb2c58:	b3 80                	mov    $0x80,%bl
5ffb2c5a:	f6 05 a0 c0 fb 5f 01 	testb  $0x1,0x5ffbc0a0
5ffb2c61:	74 03                	je     5ffb2c66 <_ConioProcessKey@12+0x76>
5ffb2c63:	83 cb 20             	or     $0x20,%ebx
5ffb2c66:	f6 05 a1 c0 fb 5f 01 	testb  $0x1,0x5ffbc0a1
5ffb2c6d:	74 03                	je     5ffb2c72 <_ConioProcessKey@12+0x82>
5ffb2c6f:	83 cb 40             	or     $0x40,%ebx
5ffb2c72:	80 3d 20 c0 fb 5f 00 	cmpb   $0x0,0x5ffbc020
5ffb2c79:	0f 88 f9 01 00 00    	js     5ffb2e78 <_ConioProcessKey@12+0x288>
5ffb2c7f:	80 3d b2 c0 fb 5f 00 	cmpb   $0x0,0x5ffbc0b2
5ffb2c86:	0f 88 c4 01 00 00    	js     5ffb2e50 <_ConioProcessKey@12+0x260>
5ffb2c8c:	80 3d b3 c0 fb 5f 00 	cmpb   $0x0,0x5ffbc0b3
5ffb2c93:	0f 88 c7 01 00 00    	js     5ffb2e60 <_ConioProcessKey@12+0x270>
5ffb2c99:	80 3d b4 c0 fb 5f 00 	cmpb   $0x0,0x5ffbc0b4
5ffb2ca0:	0f 88 ca 01 00 00    	js     5ffb2e70 <_ConioProcessKey@12+0x280>
5ffb2ca6:	80 3d b5 c0 fb 5f 00 	cmpb   $0x0,0x5ffbc0b5
5ffb2cad:	0f 88 8f 01 00 00    	js     5ffb2e42 <_ConioProcessKey@12+0x252>
  ShiftState = ConioGetShiftState(KeyState);

  if (msg->message == WM_CHAR || msg->message == WM_SYSCHAR)
5ffb2cb3:	8b 55 08             	mov    0x8(%ebp),%edx
5ffb2cb6:	8b 42 04             	mov    0x4(%edx),%eax
5ffb2cb9:	3d 02 01 00 00       	cmp    $0x102,%eax
5ffb2cbe:	0f 94 c2             	sete   %dl
5ffb2cc1:	3d 06 01 00 00       	cmp    $0x106,%eax
5ffb2cc6:	0f 94 c0             	sete   %al
5ffb2cc9:	09 d0                	or     %edx,%eax
5ffb2ccb:	a8 01                	test   $0x1,%al
5ffb2ccd:	0f 84 3d 01 00 00    	je     5ffb2e10 <_ConioProcessKey@12+0x220>
    {
      VirtualKeyCode = LastVirtualKey;
      UnicodeChar = msg->wParam;
5ffb2cd3:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb2cd6:	8b 35 10 c1 fb 5f    	mov    0x5ffbc110,%esi
5ffb2cdc:	66 8b 78 08          	mov    0x8(%eax),%di
    } 
  else
    { 
      WCHAR Chars[2];
      INT RetChars = 0;

      VirtualKeyCode = msg->wParam;
      RetChars = ToUnicodeEx(VirtualKeyCode,
                             VirtualScanCode,
                             KeyState,
                             Chars,
                             2,
                             0,
                             0);
      UnicodeChar = (1 == RetChars ? Chars[0] : 0);
    }

  if (0 == ResultSize)
    {
      AsciiChar = 0;
    }
  
  er.EventType = KEY_EVENT;
  er.Event.KeyEvent.bKeyDown = Down;
5ffb2ce0:	8b 45 bc             	mov    0xffffffbc(%ebp),%eax
  er.Event.KeyEvent.wRepeatCount = RepeatCount;
  er.Event.KeyEvent.uChar.UnicodeChar = UnicodeChar;
  er.Event.KeyEvent.dwControlKeyState = ShiftState;
  er.Event.KeyEvent.wVirtualKeyCode = VirtualKeyCode;
  er.Event.KeyEvent.wVirtualScanCode = VirtualScanCode;
5ffb2ce3:	8b 55 c0             	mov    0xffffffc0(%ebp),%edx
5ffb2ce6:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)

  if (TextMode)
5ffb2ce9:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb2cec:	66 c7 45 c8 01 00    	movw   $0x1,0xffffffc8(%ebp)
5ffb2cf2:	66 c7 45 d0 01 00    	movw   $0x1,0xffffffd0(%ebp)
5ffb2cf8:	66 89 7d d6          	mov    %di,0xffffffd6(%ebp)
5ffb2cfc:	89 5d d8             	mov    %ebx,0xffffffd8(%ebp)
5ffb2cff:	66 89 75 d2          	mov    %si,0xffffffd2(%ebp)
5ffb2d03:	66 89 55 d4          	mov    %dx,0xffffffd4(%ebp)
5ffb2d07:	85 c0                	test   %eax,%eax
5ffb2d09:	74 65                	je     5ffb2d70 <_ConioProcessKey@12+0x180>
    {    
      if (0 != (ShiftState & (RIGHT_ALT_PRESSED | LEFT_ALT_PRESSED))
5ffb2d0b:	f6 c3 03             	test   $0x3,%bl
5ffb2d0e:	0f 95 c2             	setne  %dl
5ffb2d11:	83 fe 09             	cmp    $0x9,%esi
5ffb2d14:	0f 94 c0             	sete   %al
5ffb2d17:	25 ff 00 00 00       	and    $0xff,%eax
5ffb2d1c:	85 c2                	test   %eax,%edx
5ffb2d1e:	74 30                	je     5ffb2d50 <_ConioProcessKey@12+0x160>
          && VK_TAB == VirtualKeyCode)
        {
          if (Down)
5ffb2d20:	8b 45 bc             	mov    0xffffffbc(%ebp),%eax
5ffb2d23:	85 c0                	test   %eax,%eax
5ffb2d25:	74 19                	je     5ffb2d40 <_ConioProcessKey@12+0x150>
            {
              TuiSwapConsole(ShiftState & SHIFT_PRESSED ? -1 : 1);
5ffb2d27:	c1 eb 04             	shr    $0x4,%ebx
5ffb2d2a:	83 e3 01             	and    $0x1,%ebx
5ffb2d2d:	83 fb 01             	cmp    $0x1,%ebx
5ffb2d30:	19 c9                	sbb    %ecx,%ecx
5ffb2d32:	83 e1 02             	and    $0x2,%ecx
5ffb2d35:	49                   	dec    %ecx
5ffb2d36:	e8 e5 5c 00 00       	call   5ffb8a20 <@TuiSwapConsole@4>
5ffb2d3b:	90                   	nop    
5ffb2d3c:	8d 74 26 00          	lea    0x0(%esi),%esi
            }

          return;
        }
      else if (VK_MENU == VirtualKeyCode && ! Down)
        {
          if (TuiSwapConsole(0))
            {
              return;
            }
        }
    }

  if (NULL == Console) 
    {
      return;
    }

  ConInRec = HeapAlloc(Win32CsrApiHeap, 0, sizeof(ConsoleInput));

  if (NULL == ConInRec)
    {
      return;
    }
    
  ConInRec->InputEvent = er;
  ConInRec->Fake = UnicodeChar && 
    (msg->message != WM_CHAR && msg->message != WM_SYSCHAR &&
     msg->message != WM_KEYUP && msg->message != WM_SYSKEYUP);
  ConInRec->NotChar = (msg->message != WM_CHAR && msg->message != WM_SYSCHAR);
  ConInRec->Echoed = FALSE;
  if (ConInRec->NotChar)
    LastVirtualKey = msg->wParam;

  DPRINT  ("csrss: %s %s %s %s %02x %02x '%c' %04x\n",
	   Down ? "down" : "up  ",
	   (msg->message == WM_CHAR || msg->message == WM_SYSCHAR) ?
	   "char" : "key ",
	   ConInRec->Fake ? "fake" : "real",
	   ConInRec->NotChar ? "notc" : "char",
	   VirtualScanCode,
	   VirtualKeyCode,
	   (AsciiChar >= ' ') ? AsciiChar : '.',
	   ShiftState);
    
  if (! ConInRec->Fake || ! ConInRec->NotChar)
    {
      /* FIXME - convert to ascii */
      ConioProcessChar(Console, ConInRec);
    }
  else
    {
      HeapFree(Win32CsrApiHeap, 0, ConInRec);
    }
}
5ffb2d40:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb2d43:	5b                   	pop    %ebx
5ffb2d44:	5e                   	pop    %esi
5ffb2d45:	5f                   	pop    %edi
5ffb2d46:	5d                   	pop    %ebp
5ffb2d47:	c2 0c 00             	ret    $0xc
5ffb2d4a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb2d50:	8b 45 bc             	mov    0xffffffbc(%ebp),%eax
5ffb2d53:	83 fe 12             	cmp    $0x12,%esi
5ffb2d56:	0f 94 c2             	sete   %dl
5ffb2d59:	85 c0                	test   %eax,%eax
5ffb2d5b:	0f 94 c0             	sete   %al
5ffb2d5e:	25 ff 00 00 00       	and    $0xff,%eax
5ffb2d63:	85 c2                	test   %eax,%edx
5ffb2d65:	0f 85 57 01 00 00    	jne    5ffb2ec2 <_ConioProcessKey@12+0x2d2>
5ffb2d6b:	90                   	nop    
5ffb2d6c:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb2d70:	8b 75 0c             	mov    0xc(%ebp),%esi
5ffb2d73:	85 f6                	test   %esi,%esi
5ffb2d75:	74 c9                	je     5ffb2d40 <_ConioProcessKey@12+0x150>
5ffb2d77:	53                   	push   %ebx
5ffb2d78:	6a 20                	push   $0x20
5ffb2d7a:	6a 00                	push   $0x0
5ffb2d7c:	8b 0d e0 c1 fb 5f    	mov    0x5ffbc1e0,%ecx
5ffb2d82:	51                   	push   %ecx
5ffb2d83:	e8 68 5f 00 00       	call   5ffb8cf0 <_HeapAlloc@12>
5ffb2d88:	89 c1                	mov    %eax,%ecx
5ffb2d8a:	5a                   	pop    %edx
5ffb2d8b:	85 c0                	test   %eax,%eax
5ffb2d8d:	74 b1                	je     5ffb2d40 <_ConioProcessKey@12+0x150>
5ffb2d8f:	8b 45 c8             	mov    0xffffffc8(%ebp),%eax
5ffb2d92:	31 f6                	xor    %esi,%esi
5ffb2d94:	66 85 ff             	test   %di,%di
5ffb2d97:	89 41 08             	mov    %eax,0x8(%ecx)
5ffb2d9a:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
5ffb2d9d:	89 41 0c             	mov    %eax,0xc(%ecx)
5ffb2da0:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
5ffb2da3:	89 41 10             	mov    %eax,0x10(%ecx)
5ffb2da6:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
5ffb2da9:	89 41 14             	mov    %eax,0x14(%ecx)
5ffb2dac:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
5ffb2daf:	89 41 18             	mov    %eax,0x18(%ecx)
5ffb2db2:	0f 85 c8 00 00 00    	jne    5ffb2e80 <_ConioProcessKey@12+0x290>
5ffb2db8:	89 f2                	mov    %esi,%edx
5ffb2dba:	88 51 1d             	mov    %dl,0x1d(%ecx)
5ffb2dbd:	8b 5d 08             	mov    0x8(%ebp),%ebx
5ffb2dc0:	8b 43 04             	mov    0x4(%ebx),%eax
5ffb2dc3:	c6 41 1c 00          	movb   $0x0,0x1c(%ecx)
5ffb2dc7:	3d 02 01 00 00       	cmp    $0x102,%eax
5ffb2dcc:	0f 95 c2             	setne  %dl
5ffb2dcf:	3d 06 01 00 00       	cmp    $0x106,%eax
5ffb2dd4:	0f 95 c0             	setne  %al
5ffb2dd7:	21 c2                	and    %eax,%edx
5ffb2dd9:	88 51 1e             	mov    %dl,0x1e(%ecx)
5ffb2ddc:	84 d2                	test   %dl,%dl
5ffb2dde:	74 08                	je     5ffb2de8 <_ConioProcessKey@12+0x1f8>
5ffb2de0:	8b 43 08             	mov    0x8(%ebx),%eax
5ffb2de3:	a3 10 c1 fb 5f       	mov    %eax,0x5ffbc110
5ffb2de8:	89 f0                	mov    %esi,%eax
5ffb2dea:	84 c0                	test   %al,%al
5ffb2dec:	74 08                	je     5ffb2df6 <_ConioProcessKey@12+0x206>
5ffb2dee:	84 d2                	test   %dl,%dl
5ffb2df0:	0f 85 e0 00 00 00    	jne    5ffb2ed6 <_ConioProcessKey@12+0x2e6>
5ffb2df6:	89 ca                	mov    %ecx,%edx
5ffb2df8:	8b 4d 0c             	mov    0xc(%ebp),%ecx
5ffb2dfb:	e8 90 f9 ff ff       	call   5ffb2790 <@ConioProcessChar@8>
5ffb2e00:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb2e03:	5b                   	pop    %ebx
5ffb2e04:	5e                   	pop    %esi
5ffb2e05:	5f                   	pop    %edi
5ffb2e06:	5d                   	pop    %ebp
5ffb2e07:	c2 0c 00             	ret    $0xc
5ffb2e0a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb2e10:	8b 55 08             	mov    0x8(%ebp),%edx
5ffb2e13:	8d 45 c4             	lea    0xffffffc4(%ebp),%eax
5ffb2e16:	8b 72 08             	mov    0x8(%edx),%esi
5ffb2e19:	57                   	push   %edi
5ffb2e1a:	6a 00                	push   $0x0
5ffb2e1c:	6a 00                	push   $0x0
5ffb2e1e:	6a 02                	push   $0x2
5ffb2e20:	50                   	push   %eax
5ffb2e21:	68 10 c0 fb 5f       	push   $0x5ffbc010
5ffb2e26:	31 ff                	xor    %edi,%edi
5ffb2e28:	8b 4d c0             	mov    0xffffffc0(%ebp),%ecx
5ffb2e2b:	51                   	push   %ecx
5ffb2e2c:	56                   	push   %esi
5ffb2e2d:	e8 2e 60 00 00       	call   5ffb8e60 <_ToUnicodeEx@28>
5ffb2e32:	5a                   	pop    %edx
5ffb2e33:	48                   	dec    %eax
5ffb2e34:	0f 85 a6 fe ff ff    	jne    5ffb2ce0 <_ConioProcessKey@12+0xf0>
5ffb2e3a:	8b 7d c4             	mov    0xffffffc4(%ebp),%edi
5ffb2e3d:	e9 9e fe ff ff       	jmp    5ffb2ce0 <_ConioProcessKey@12+0xf0>
5ffb2e42:	83 cb 01             	or     $0x1,%ebx
5ffb2e45:	e9 69 fe ff ff       	jmp    5ffb2cb3 <_ConioProcessKey@12+0xc3>
5ffb2e4a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb2e50:	83 cb 08             	or     $0x8,%ebx
5ffb2e53:	80 3d b3 c0 fb 5f 00 	cmpb   $0x0,0x5ffbc0b3
5ffb2e5a:	0f 89 39 fe ff ff    	jns    5ffb2c99 <_ConioProcessKey@12+0xa9>
5ffb2e60:	83 cb 04             	or     $0x4,%ebx
5ffb2e63:	80 3d b4 c0 fb 5f 00 	cmpb   $0x0,0x5ffbc0b4
5ffb2e6a:	0f 89 36 fe ff ff    	jns    5ffb2ca6 <_ConioProcessKey@12+0xb6>
5ffb2e70:	83 cb 02             	or     $0x2,%ebx
5ffb2e73:	e9 2e fe ff ff       	jmp    5ffb2ca6 <_ConioProcessKey@12+0xb6>
5ffb2e78:	83 cb 10             	or     $0x10,%ebx
5ffb2e7b:	e9 ff fd ff ff       	jmp    5ffb2c7f <_ConioProcessKey@12+0x8f>
5ffb2e80:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb2e83:	8b 58 04             	mov    0x4(%eax),%ebx
5ffb2e86:	81 fb 02 01 00 00    	cmp    $0x102,%ebx
5ffb2e8c:	0f 95 c2             	setne  %dl
5ffb2e8f:	81 fb 06 01 00 00    	cmp    $0x106,%ebx
5ffb2e95:	0f 95 c0             	setne  %al
5ffb2e98:	84 d0                	test   %dl,%al
5ffb2e9a:	0f 84 18 ff ff ff    	je     5ffb2db8 <_ConioProcessKey@12+0x1c8>
5ffb2ea0:	81 fb 01 01 00 00    	cmp    $0x101,%ebx
5ffb2ea6:	0f 84 0c ff ff ff    	je     5ffb2db8 <_ConioProcessKey@12+0x1c8>
5ffb2eac:	81 fb 05 01 00 00    	cmp    $0x105,%ebx
5ffb2eb2:	0f 84 00 ff ff ff    	je     5ffb2db8 <_ConioProcessKey@12+0x1c8>
5ffb2eb8:	be 01 00 00 00       	mov    $0x1,%esi
5ffb2ebd:	e9 f6 fe ff ff       	jmp    5ffb2db8 <_ConioProcessKey@12+0x1c8>
5ffb2ec2:	31 c9                	xor    %ecx,%ecx
5ffb2ec4:	e8 57 5b 00 00       	call   5ffb8a20 <@TuiSwapConsole@4>
5ffb2ec9:	85 c0                	test   %eax,%eax
5ffb2ecb:	0f 85 6f fe ff ff    	jne    5ffb2d40 <_ConioProcessKey@12+0x150>
5ffb2ed1:	e9 9a fe ff ff       	jmp    5ffb2d70 <_ConioProcessKey@12+0x180>
5ffb2ed6:	50                   	push   %eax
5ffb2ed7:	51                   	push   %ecx
5ffb2ed8:	6a 00                	push   $0x0
5ffb2eda:	a1 e0 c1 fb 5f       	mov    0x5ffbc1e0,%eax
5ffb2edf:	50                   	push   %eax
5ffb2ee0:	e8 1b 5e 00 00       	call   5ffb8d00 <_HeapFree@12>
5ffb2ee5:	58                   	pop    %eax
5ffb2ee6:	e9 55 fe ff ff       	jmp    5ffb2d40 <_ConioProcessKey@12+0x150>
5ffb2eeb:	90                   	nop    
5ffb2eec:	8d 74 26 00          	lea    0x0(%esi),%esi

5ffb2ef0 <_Console_Api>:

VOID
Console_Api(DWORD RefreshEvent)
{
5ffb2ef0:	55                   	push   %ebp
5ffb2ef1:	89 e5                	mov    %esp,%ebp
5ffb2ef3:	53                   	push   %ebx
5ffb2ef4:	83 ec 30             	sub    $0x30,%esp
  /* keep reading events from the keyboard and stuffing them into the current
     console's input queue */
  MSG msg;

  /* This call establishes our message queue */
  PeekMessageW(&msg, 0, 0, 0, PM_NOREMOVE);
5ffb2ef7:	8d 5d d8             	lea    0xffffffd8(%ebp),%ebx
5ffb2efa:	6a 00                	push   $0x0
5ffb2efc:	6a 00                	push   $0x0
5ffb2efe:	6a 00                	push   $0x0
5ffb2f00:	6a 00                	push   $0x0
5ffb2f02:	53                   	push   %ebx
5ffb2f03:	e8 68 5f 00 00       	call   5ffb8e70 <_PeekMessageW@20>
  /* This call registers our message queue */
  PrivateCsrssRegisterPrimitive();
5ffb2f08:	83 c4 0c             	add    $0xc,%esp
5ffb2f0b:	e8 70 5f 00 00       	call   5ffb8e80 <_PrivateCsrssRegisterPrimitive@0>
  /* This call turns on the input system in win32k */
  PrivateCsrssAcquireOrReleaseInputOwnership(FALSE);
5ffb2f10:	83 ec 0c             	sub    $0xc,%esp
5ffb2f13:	6a 00                	push   $0x0
5ffb2f15:	e8 76 5f 00 00       	call   5ffb8e90 <_PrivateCsrssAcquireOrReleaseInputOwnership@4>
  
  while (TRUE)
5ffb2f1a:	83 c4 0c             	add    $0xc,%esp
5ffb2f1d:	8d 76 00             	lea    0x0(%esi),%esi
    {
      GetMessageW(&msg, 0, 0, 0);
5ffb2f20:	6a 00                	push   $0x0
5ffb2f22:	6a 00                	push   $0x0
5ffb2f24:	6a 00                	push   $0x0
5ffb2f26:	53                   	push   %ebx
5ffb2f27:	e8 74 5f 00 00       	call   5ffb8ea0 <_GetMessageW@16>
      TranslateMessage(&msg);
5ffb2f2c:	83 ec 0c             	sub    $0xc,%esp
5ffb2f2f:	53                   	push   %ebx
5ffb2f30:	e8 7b 5f 00 00       	call   5ffb8eb0 <_TranslateMessage@4>

      if (msg.message == WM_CHAR || msg.message == WM_SYSCHAR ||
5ffb2f35:	8b 4d dc             	mov    0xffffffdc(%ebp),%ecx
5ffb2f38:	83 c4 0c             	add    $0xc,%esp
5ffb2f3b:	81 f9 02 01 00 00    	cmp    $0x102,%ecx
5ffb2f41:	0f 94 c2             	sete   %dl
5ffb2f44:	81 f9 06 01 00 00    	cmp    $0x106,%ecx
5ffb2f4a:	0f 94 c0             	sete   %al
5ffb2f4d:	09 d0                	or     %edx,%eax
5ffb2f4f:	a8 01                	test   $0x1,%al
5ffb2f51:	75 20                	jne    5ffb2f73 <_Console_Api+0x83>
5ffb2f53:	81 f9 00 01 00 00    	cmp    $0x100,%ecx
5ffb2f59:	74 18                	je     5ffb2f73 <_Console_Api+0x83>
5ffb2f5b:	81 f9 01 01 00 00    	cmp    $0x101,%ecx
5ffb2f61:	74 10                	je     5ffb2f73 <_Console_Api+0x83>
5ffb2f63:	81 f9 04 01 00 00    	cmp    $0x104,%ecx
5ffb2f69:	74 08                	je     5ffb2f73 <_Console_Api+0x83>
5ffb2f6b:	81 f9 05 01 00 00    	cmp    $0x105,%ecx
5ffb2f71:	75 ad                	jne    5ffb2f20 <_Console_Api+0x30>
          msg.message == WM_KEYDOWN || msg.message == WM_KEYUP ||
          msg.message == WM_SYSKEYDOWN || msg.message == WM_SYSKEYUP)
        {
          ConioProcessKey(&msg, TuiGetFocusConsole(), TRUE);
5ffb2f73:	50                   	push   %eax
5ffb2f74:	6a 01                	push   $0x1
5ffb2f76:	50                   	push   %eax
5ffb2f77:	50                   	push   %eax
5ffb2f78:	e8 93 5a 00 00       	call   5ffb8a10 <@TuiGetFocusConsole@0>
5ffb2f7d:	5a                   	pop    %edx
5ffb2f7e:	59                   	pop    %ecx
5ffb2f7f:	50                   	push   %eax
5ffb2f80:	53                   	push   %ebx
5ffb2f81:	e8 6a fc ff ff       	call   5ffb2bf0 <_ConioProcessKey@12>
5ffb2f86:	58                   	pop    %eax
5ffb2f87:	eb 97                	jmp    5ffb2f20 <_Console_Api+0x30>
5ffb2f89:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

5ffb2f90 <_CsrGetScreenBufferInfo@12>:
        }
    }

  PrivateCsrssAcquireOrReleaseInputOwnership(TRUE);
}

CSR_API(CsrGetScreenBufferInfo)
{
5ffb2f90:	55                   	push   %ebp
5ffb2f91:	89 e5                	mov    %esp,%ebp
5ffb2f93:	57                   	push   %edi
5ffb2f94:	56                   	push   %esi
5ffb2f95:	53                   	push   %ebx
5ffb2f96:	83 ec 14             	sub    $0x14,%esp
5ffb2f99:	8b 7d 10             	mov    0x10(%ebp),%edi
  NTSTATUS Status;
  PCSRSS_SCREEN_BUFFER Buff;
  PCONSOLE_SCREEN_BUFFER_INFO pInfo;
   
  DPRINT("CsrGetScreenBufferInfo\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;

  Status = ConioLockScreenBuffer(ProcessData, Request->Data.ScreenBufferInfoRequest.ConsoleHandle, &Buff);
5ffb2f9c:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb2f9f:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb2fa2:	66 c7 47 02 38 00    	movw   $0x38,0x2(%edi)
5ffb2fa8:	66 c7 07 20 00       	movw   $0x20,(%edi)
5ffb2fad:	8b 50 1c             	mov    0x1c(%eax),%edx
5ffb2fb0:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
5ffb2fb3:	6a 02                	push   $0x2
5ffb2fb5:	50                   	push   %eax
5ffb2fb6:	e8 c5 e0 ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
  if (! NT_SUCCESS(Status))
5ffb2fbb:	5a                   	pop    %edx
5ffb2fbc:	85 c0                	test   %eax,%eax
5ffb2fbe:	59                   	pop    %ecx
5ffb2fbf:	0f 88 a0 00 00 00    	js     5ffb3065 <_CsrGetScreenBufferInfo@12+0xd5>
    {
      return Reply->Status = Status;
    }
  pInfo = &Reply->Data.ScreenBufferInfoReply.Info;
  pInfo->dwSize.X = Buff->MaxX;
5ffb2fc5:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb2fc8:	8d 5f 1c             	lea    0x1c(%edi),%ebx
5ffb2fcb:	66 8b 41 24          	mov    0x24(%ecx),%ax
5ffb2fcf:	66 89 47 1c          	mov    %ax,0x1c(%edi)
  pInfo->dwSize.Y = Buff->MaxY;
5ffb2fd3:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb2fd7:	66 89 43 02          	mov    %ax,0x2(%ebx)
  pInfo->dwCursorPosition.X = Buff->CurrentX - Buff->ShowX;
5ffb2fdb:	8b 41 2c             	mov    0x2c(%ecx),%eax
5ffb2fde:	66 2b 41 28          	sub    0x28(%ecx),%ax
5ffb2fe2:	66 89 43 04          	mov    %ax,0x4(%ebx)
  pInfo->dwCursorPosition.Y = (Buff->CurrentY + Buff->MaxY - Buff->ShowY) % Buff->MaxY;
5ffb2fe6:	8b 41 30             	mov    0x30(%ecx),%eax
5ffb2fe9:	66 8b 51 26          	mov    0x26(%ecx),%dx
5ffb2fed:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb2ff3:	01 d0                	add    %edx,%eax
5ffb2ff5:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
5ffb2ff8:	66 8b 41 2a          	mov    0x2a(%ecx),%ax
5ffb2ffc:	8b 75 ec             	mov    0xffffffec(%ebp),%esi
5ffb2fff:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3004:	29 c6                	sub    %eax,%esi
5ffb3006:	89 75 ec             	mov    %esi,0xffffffec(%ebp)
5ffb3009:	89 d6                	mov    %edx,%esi
5ffb300b:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb300e:	31 d2                	xor    %edx,%edx
5ffb3010:	f7 f6                	div    %esi
5ffb3012:	66 89 53 06          	mov    %dx,0x6(%ebx)
  pInfo->wAttributes = Buff->DefaultAttrib;
5ffb3016:	31 c0                	xor    %eax,%eax
5ffb3018:	8a 41 34             	mov    0x34(%ecx),%al
  pInfo->srWindow.Left = 0;
5ffb301b:	66 c7 43 0a 00 00    	movw   $0x0,0xa(%ebx)
5ffb3021:	66 89 43 08          	mov    %ax,0x8(%ebx)
  pInfo->srWindow.Right = Buff->MaxX - 1;
5ffb3025:	66 8b 41 24          	mov    0x24(%ecx),%ax
  pInfo->srWindow.Top = 0;
5ffb3029:	66 c7 43 0c 00 00    	movw   $0x0,0xc(%ebx)
5ffb302f:	48                   	dec    %eax
5ffb3030:	66 89 43 0e          	mov    %ax,0xe(%ebx)
  pInfo->srWindow.Bottom = Buff->MaxY - 1;
5ffb3034:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb3038:	48                   	dec    %eax
5ffb3039:	66 89 43 10          	mov    %ax,0x10(%ebx)
  pInfo->dwMaximumWindowSize.X = Buff->MaxX;
5ffb303d:	66 8b 41 24          	mov    0x24(%ecx),%ax
5ffb3041:	66 89 43 12          	mov    %ax,0x12(%ebx)
  pInfo->dwMaximumWindowSize.Y = Buff->MaxY;
5ffb3045:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb3049:	66 89 43 14          	mov    %ax,0x14(%ebx)
  ConioUnlockScreenBuffer(Buff);
5ffb304d:	e8 6e e0 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>

  Reply->Status = STATUS_SUCCESS;
5ffb3052:	c7 47 18 00 00 00 00 	movl   $0x0,0x18(%edi)

  return Reply->Status;
5ffb3059:	31 c0                	xor    %eax,%eax
}
5ffb305b:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb305e:	5b                   	pop    %ebx
5ffb305f:	5e                   	pop    %esi
5ffb3060:	5f                   	pop    %edi
5ffb3061:	5d                   	pop    %ebp
5ffb3062:	c2 0c 00             	ret    $0xc
5ffb3065:	89 47 18             	mov    %eax,0x18(%edi)
5ffb3068:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb306b:	5b                   	pop    %ebx
5ffb306c:	5e                   	pop    %esi
5ffb306d:	5f                   	pop    %edi
5ffb306e:	5d                   	pop    %ebp
5ffb306f:	c2 0c 00             	ret    $0xc
5ffb3072:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
5ffb3079:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb3080 <_CsrSetCursor@12>:

CSR_API(CsrSetCursor)
{
5ffb3080:	55                   	push   %ebp
5ffb3081:	89 e5                	mov    %esp,%ebp
5ffb3083:	57                   	push   %edi
5ffb3084:	56                   	push   %esi
5ffb3085:	53                   	push   %ebx
5ffb3086:	83 ec 1c             	sub    $0x1c,%esp
  NTSTATUS Status;
  PCSRSS_CONSOLE Console;
  PCSRSS_SCREEN_BUFFER Buff;
  LONG OldCursorX, OldCursorY;
  LONG NewCursorX, NewCursorY;
   
  DPRINT("CsrSetCursor\n");

  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb3089:	8d 55 f0             	lea    0xfffffff0(%ebp),%edx
5ffb308c:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb308f:	8b 75 0c             	mov    0xc(%ebp),%esi
5ffb3092:	8b 7d 10             	mov    0x10(%ebp),%edi
5ffb3095:	e8 26 e1 ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
5ffb309a:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb309c:	85 c0                	test   %eax,%eax
5ffb309e:	0f 88 8c 00 00 00    	js     5ffb3130 <_CsrSetCursor@12+0xb0>
    {
      return Reply->Status = Status;
    }

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
5ffb30a4:	66 c7 47 02 38 00    	movw   $0x38,0x2(%edi)
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
5ffb30aa:	66 c7 07 20 00       	movw   $0x20,(%edi)

  Status = ConioLockScreenBuffer(ProcessData, Request->Data.SetCursorRequest.ConsoleHandle, &Buff);
5ffb30af:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
5ffb30b2:	51                   	push   %ecx
5ffb30b3:	51                   	push   %ecx
5ffb30b4:	8b 56 1c             	mov    0x1c(%esi),%edx
5ffb30b7:	6a 02                	push   $0x2
5ffb30b9:	50                   	push   %eax
5ffb30ba:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb30bd:	e8 be df ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
5ffb30c2:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb30c4:	58                   	pop    %eax
5ffb30c5:	85 db                	test   %ebx,%ebx
5ffb30c7:	5a                   	pop    %edx
5ffb30c8:	78 57                	js     5ffb3121 <_CsrSetCursor@12+0xa1>
    {
      if (NULL != Console)
        {
          ConioUnlockConsole(Console);
        }
      return Reply->Status = Status;
    }

  NewCursorX = Request->Data.SetCursorRequest.Position.X;
5ffb30ca:	0f bf 5e 20          	movswl 0x20(%esi),%ebx
  NewCursorY = Request->Data.SetCursorRequest.Position.Y;
5ffb30ce:	0f bf 76 22          	movswl 0x22(%esi),%esi
  if (NewCursorX < 0 || NewCursorX >= Buff->MaxX ||
5ffb30d2:	85 db                	test   %ebx,%ebx
5ffb30d4:	0f 88 f1 00 00 00    	js     5ffb31cb <_CsrSetCursor@12+0x14b>
5ffb30da:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
5ffb30dd:	89 f2                	mov    %esi,%edx
5ffb30df:	66 8b 41 24          	mov    0x24(%ecx),%ax
5ffb30e3:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb30e8:	39 d8                	cmp    %ebx,%eax
5ffb30ea:	0f 9e c0             	setle  %al
5ffb30ed:	c1 ea 1f             	shr    $0x1f,%edx
5ffb30f0:	25 ff 00 00 00       	and    $0xff,%eax
5ffb30f5:	09 d0                	or     %edx,%eax
5ffb30f7:	75 0d                	jne    5ffb3106 <_CsrSetCursor@12+0x86>
5ffb30f9:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb30fd:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3102:	39 f0                	cmp    %esi,%eax
5ffb3104:	7f 39                	jg     5ffb313f <_CsrSetCursor@12+0xbf>
      NewCursorY < 0 || NewCursorY >= Buff->MaxY)
    {
      ConioUnlockScreenBuffer(Buff);
5ffb3106:	e8 b5 df ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
      return Reply->Status = STATUS_INVALID_PARAMETER;
5ffb310b:	c7 47 18 0d 00 00 c0 	movl   $0xc000000d,0x18(%edi)
5ffb3112:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
    }
  ConioPhysicalToLogical(Buff, Buff->CurrentX, Buff->CurrentY, &OldCursorX, &OldCursorY);
  Buff->CurrentX = NewCursorX + Buff->ShowX;
  Buff->CurrentY = (NewCursorY + Buff->ShowY) % Buff->MaxY;
  if (NULL != Console && Buff == Console->ActiveBuffer)
    {
      if (! ConioSetScreenInfo(Console, Buff, OldCursorX, OldCursorY))
        {
          ConioUnlockScreenBuffer(Buff);
          return Reply->Status = STATUS_UNSUCCESSFUL;
        }
    }

  ConioUnlockScreenBuffer(Buff);
  if (NULL != Console)
    {
      ConioUnlockConsole(Console);
    }

  return Reply->Status = STATUS_SUCCESS;
}
5ffb3117:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb311a:	5b                   	pop    %ebx
5ffb311b:	5e                   	pop    %esi
5ffb311c:	5f                   	pop    %edi
5ffb311d:	5d                   	pop    %ebp
5ffb311e:	c2 0c 00             	ret    $0xc
5ffb3121:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb3124:	85 c9                	test   %ecx,%ecx
5ffb3126:	74 08                	je     5ffb3130 <_CsrSetCursor@12+0xb0>
5ffb3128:	e8 93 df ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb312d:	8d 76 00             	lea    0x0(%esi),%esi
5ffb3130:	89 5f 18             	mov    %ebx,0x18(%edi)
5ffb3133:	89 d8                	mov    %ebx,%eax
5ffb3135:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb3138:	5b                   	pop    %ebx
5ffb3139:	5e                   	pop    %esi
5ffb313a:	5f                   	pop    %edi
5ffb313b:	5d                   	pop    %ebp
5ffb313c:	c2 0c 00             	ret    $0xc
5ffb313f:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
5ffb3142:	8b 51 2c             	mov    0x2c(%ecx),%edx
5ffb3145:	50                   	push   %eax
5ffb3146:	8d 45 e4             	lea    0xffffffe4(%ebp),%eax
5ffb3149:	50                   	push   %eax
5ffb314a:	8b 41 30             	mov    0x30(%ecx),%eax
5ffb314d:	50                   	push   %eax
5ffb314e:	e8 3d e4 ff ff       	call   5ffb1590 <@ConioPhysicalToLogical@20>
5ffb3153:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
5ffb3156:	66 8b 41 28          	mov    0x28(%ecx),%ax
5ffb315a:	66 8b 51 2a          	mov    0x2a(%ecx),%dx
5ffb315e:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3163:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb3169:	01 d8                	add    %ebx,%eax
5ffb316b:	01 f2                	add    %esi,%edx
5ffb316d:	89 41 2c             	mov    %eax,0x2c(%ecx)
5ffb3170:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb3174:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3179:	89 c3                	mov    %eax,%ebx
5ffb317b:	89 d0                	mov    %edx,%eax
5ffb317d:	c1 fa 1f             	sar    $0x1f,%edx
5ffb3180:	f7 fb                	idiv   %ebx
5ffb3182:	89 51 30             	mov    %edx,0x30(%ecx)
5ffb3185:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
5ffb3188:	85 d2                	test   %edx,%edx
5ffb318a:	74 05                	je     5ffb3191 <_CsrSetCursor@12+0x111>
5ffb318c:	39 4a 38             	cmp    %ecx,0x38(%edx)
5ffb318f:	74 1a                	je     5ffb31ab <_CsrSetCursor@12+0x12b>
5ffb3191:	e8 2a df ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb3196:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb3199:	85 c9                	test   %ecx,%ecx
5ffb319b:	75 27                	jne    5ffb31c4 <_CsrSetCursor@12+0x144>
5ffb319d:	31 c0                	xor    %eax,%eax
5ffb319f:	c7 47 18 00 00 00 00 	movl   $0x0,0x18(%edi)
5ffb31a6:	e9 6c ff ff ff       	jmp    5ffb3117 <_CsrSetCursor@12+0x97>
5ffb31ab:	8b 75 e8             	mov    0xffffffe8(%ebp),%esi
5ffb31ae:	8b 42 70             	mov    0x70(%edx),%eax
5ffb31b1:	56                   	push   %esi
5ffb31b2:	8b 5d e4             	mov    0xffffffe4(%ebp),%ebx
5ffb31b5:	53                   	push   %ebx
5ffb31b6:	51                   	push   %ecx
5ffb31b7:	52                   	push   %edx
5ffb31b8:	ff 50 10             	call   *0x10(%eax)
5ffb31bb:	85 c0                	test   %eax,%eax
5ffb31bd:	74 14                	je     5ffb31d3 <_CsrSetCursor@12+0x153>
5ffb31bf:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
5ffb31c2:	eb cd                	jmp    5ffb3191 <_CsrSetCursor@12+0x111>
5ffb31c4:	e8 f7 de ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb31c9:	eb d2                	jmp    5ffb319d <_CsrSetCursor@12+0x11d>
5ffb31cb:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
5ffb31ce:	e9 33 ff ff ff       	jmp    5ffb3106 <_CsrSetCursor@12+0x86>
5ffb31d3:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
5ffb31d6:	e8 e5 de ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb31db:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
5ffb31e0:	c7 47 18 01 00 00 c0 	movl   $0xc0000001,0x18(%edi)
5ffb31e7:	e9 2b ff ff ff       	jmp    5ffb3117 <_CsrSetCursor@12+0x97>
5ffb31ec:	8d 74 26 00          	lea    0x0(%esi),%esi

5ffb31f0 <@ConioComputeUpdateRect@16>:

STATIC FASTCALL VOID
ConioComputeUpdateRect(PCSRSS_SCREEN_BUFFER Buff, RECT *UpdateRect, COORD *Start, UINT Length)
{
5ffb31f0:	55                   	push   %ebp
5ffb31f1:	89 e5                	mov    %esp,%ebp
5ffb31f3:	57                   	push   %edi
5ffb31f4:	56                   	push   %esi
5ffb31f5:	53                   	push   %ebx
5ffb31f6:	53                   	push   %ebx
5ffb31f7:	53                   	push   %ebx
5ffb31f8:	89 4d f0             	mov    %ecx,0xfffffff0(%ebp)
  if (Buff->MaxX <= Start->X + Length)
5ffb31fb:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb31fe:	66 8b 79 24          	mov    0x24(%ecx),%di
5ffb3202:	89 d3                	mov    %edx,%ebx
5ffb3204:	89 fa                	mov    %edi,%edx
5ffb3206:	66 8b 30             	mov    (%eax),%si
5ffb3209:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb320c:	0f bf ce             	movswl %si,%ecx
5ffb320f:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb3215:	01 c8                	add    %ecx,%eax
5ffb3217:	39 c2                	cmp    %eax,%edx
5ffb3219:	77 65                	ja     5ffb3280 <@ConioComputeUpdateRect@16+0x90>
    {
      UpdateRect->left = 0;
    }
  else
    {
      UpdateRect->left = Start->X;
    }
  if (Buff->MaxX <= Start->X + Length)
5ffb321b:	89 fa                	mov    %edi,%edx
5ffb321d:	8b 4d 0c             	mov    0xc(%ebp),%ecx
5ffb3220:	0f bf c6             	movswl %si,%eax
5ffb3223:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb3229:	01 c8                	add    %ecx,%eax
5ffb322b:	c7 03 00 00 00 00    	movl   $0x0,(%ebx)
5ffb3231:	39 c2                	cmp    %eax,%edx
5ffb3233:	77 61                	ja     5ffb3296 <@ConioComputeUpdateRect@16+0xa6>
    {
      UpdateRect->right = Buff->MaxX - 1;
5ffb3235:	8d 42 ff             	lea    0xffffffff(%edx),%eax
    }
  else
    {
      UpdateRect->right = Start->X + Length - 1;
    }
  UpdateRect->top = Start->Y;
5ffb3238:	8b 55 08             	mov    0x8(%ebp),%edx
5ffb323b:	89 43 08             	mov    %eax,0x8(%ebx)
  UpdateRect->bottom = Start->Y+ (Start->X + Length - 1) / Buff->MaxX;
5ffb323e:	0f bf c6             	movswl %si,%eax
5ffb3241:	0f bf 4a 02          	movswl 0x2(%edx),%ecx
5ffb3245:	8b 75 0c             	mov    0xc(%ebp),%esi
5ffb3248:	89 fa                	mov    %edi,%edx
5ffb324a:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb3250:	89 4b 04             	mov    %ecx,0x4(%ebx)
5ffb3253:	8d 44 30 ff          	lea    0xffffffff(%eax,%esi,1),%eax
5ffb3257:	89 d6                	mov    %edx,%esi
5ffb3259:	31 d2                	xor    %edx,%edx
5ffb325b:	f7 f6                	div    %esi
5ffb325d:	8d 14 01             	lea    (%ecx,%eax,1),%edx
  if (Buff->MaxY <= UpdateRect->bottom)
5ffb3260:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb3263:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb3267:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb326c:	39 d0                	cmp    %edx,%eax
5ffb326e:	7f 30                	jg     5ffb32a0 <@ConioComputeUpdateRect@16+0xb0>
    {
      UpdateRect->bottom = Buff->MaxY - 1;
5ffb3270:	48                   	dec    %eax
5ffb3271:	89 43 0c             	mov    %eax,0xc(%ebx)
    }
}
5ffb3274:	5b                   	pop    %ebx
5ffb3275:	5e                   	pop    %esi
5ffb3276:	5b                   	pop    %ebx
5ffb3277:	5e                   	pop    %esi
5ffb3278:	5f                   	pop    %edi
5ffb3279:	5d                   	pop    %ebp
5ffb327a:	c2 08 00             	ret    $0x8
5ffb327d:	8d 76 00             	lea    0x0(%esi),%esi
5ffb3280:	89 0b                	mov    %ecx,(%ebx)
5ffb3282:	89 fa                	mov    %edi,%edx
5ffb3284:	0f bf c6             	movswl %si,%eax
5ffb3287:	8b 4d 0c             	mov    0xc(%ebp),%ecx
5ffb328a:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb3290:	01 c8                	add    %ecx,%eax
5ffb3292:	39 c2                	cmp    %eax,%edx
5ffb3294:	76 9f                	jbe    5ffb3235 <@ConioComputeUpdateRect@16+0x45>
5ffb3296:	48                   	dec    %eax
5ffb3297:	eb 9f                	jmp    5ffb3238 <@ConioComputeUpdateRect@16+0x48>
5ffb3299:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
5ffb32a0:	89 53 0c             	mov    %edx,0xc(%ebx)
5ffb32a3:	5b                   	pop    %ebx
5ffb32a4:	5e                   	pop    %esi
5ffb32a5:	5b                   	pop    %ebx
5ffb32a6:	5e                   	pop    %esi
5ffb32a7:	5f                   	pop    %edi
5ffb32a8:	5d                   	pop    %ebp
5ffb32a9:	c2 08 00             	ret    $0x8
5ffb32ac:	8d 74 26 00          	lea    0x0(%esi),%esi

5ffb32b0 <_CsrWriteConsoleOutputChar@12>:

CSR_API(CsrWriteConsoleOutputChar)
{
5ffb32b0:	55                   	push   %ebp
5ffb32b1:	89 e5                	mov    %esp,%ebp
5ffb32b3:	57                   	push   %edi
5ffb32b4:	56                   	push   %esi
5ffb32b5:	53                   	push   %ebx
5ffb32b6:	83 ec 3c             	sub    $0x3c,%esp
  NTSTATUS Status;
  PCHAR String = (PCHAR)Request->Data.WriteConsoleOutputCharRequest.String;
  PBYTE Buffer;
  PCSRSS_CONSOLE Console;
  PCSRSS_SCREEN_BUFFER Buff;
  DWORD X, Y, Length, CharSize, Written = 0;
5ffb32b9:	c7 45 c8 00 00 00 00 	movl   $0x0,0xffffffc8(%ebp)
  RECT UpdateRect;

  DPRINT("CsrWriteConsoleOutputChar\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
5ffb32c0:	8b 45 10             	mov    0x10(%ebp),%eax
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
  
  CharSize = (Request->Data.WriteConsoleOutputCharRequest.Unicode ? sizeof(WCHAR) : sizeof(CHAR));
5ffb32c3:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb32c6:	8b 7d 0c             	mov    0xc(%ebp),%edi

  if (Request->Header.DataSize
5ffb32c9:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb32cc:	66 c7 00 20 00       	movw   $0x20,(%eax)
5ffb32d1:	66 c7 40 02 38 00    	movw   $0x38,0x2(%eax)
5ffb32d7:	8b 42 20             	mov    0x20(%edx),%eax
5ffb32da:	83 c7 2a             	add    $0x2a,%edi
5ffb32dd:	83 f8 01             	cmp    $0x1,%eax
5ffb32e0:	66 8b 43 24          	mov    0x24(%ebx),%ax
5ffb32e4:	19 d2                	sbb    %edx,%edx
5ffb32e6:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb32eb:	83 c2 02             	add    $0x2,%edx
5ffb32ee:	66 8b 0b             	mov    (%ebx),%cx
5ffb32f1:	0f af c2             	imul   %edx,%eax
5ffb32f4:	81 e1 ff ff 00 00    	and    $0xffff,%ecx
5ffb32fa:	83 c0 0f             	add    $0xf,%eax
5ffb32fd:	39 c1                	cmp    %eax,%ecx
5ffb32ff:	0f 82 1e 02 00 00    	jb     5ffb3523 <_CsrWriteConsoleOutputChar@12+0x273>
      < sizeof(CSRSS_WRITE_CONSOLE_OUTPUT_CHAR_REQUEST) - 1
        + (Request->Data.WriteConsoleOutputCharRequest.Length * CharSize))
    {
      DPRINT1("Invalid request size\n");
      return Reply->Status = STATUS_INVALID_PARAMETER;
    }

  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb3305:	8d 55 d4             	lea    0xffffffd4(%ebp),%edx
5ffb3308:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb330b:	e8 b0 de ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
5ffb3310:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb3312:	85 c0                	test   %eax,%eax
5ffb3314:	0f 88 ba 01 00 00    	js     5ffb34d4 <_CsrWriteConsoleOutputChar@12+0x224>
    {
      return Reply->Status = Status;
    }

  if(Request->Data.WriteConsoleOutputCharRequest.Unicode)
5ffb331a:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb331d:	8b 42 20             	mov    0x20(%edx),%eax
5ffb3320:	85 c0                	test   %eax,%eax
5ffb3322:	0f 85 4f 01 00 00    	jne    5ffb3477 <_CsrWriteConsoleOutputChar@12+0x1c7>
  {
    ConsoleUnicodeToAnsiN(Console, String, (PWCHAR)String, Request->Data.WriteConsoleOutputCharRequest.Length);
  }

  Status = ConioLockScreenBuffer(ProcessData,
5ffb3328:	50                   	push   %eax
5ffb3329:	50                   	push   %eax
5ffb332a:	8d 45 d0             	lea    0xffffffd0(%ebp),%eax
5ffb332d:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb3330:	8b 53 1c             	mov    0x1c(%ebx),%edx
5ffb3333:	6a 02                	push   $0x2
5ffb3335:	50                   	push   %eax
5ffb3336:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb3339:	e8 42 dd ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
                                 Request->Data.WriteConsoleOutputCharRequest.ConsoleHandle,
                                 &Buff);
  if (! NT_SUCCESS(Status))
5ffb333e:	59                   	pop    %ecx
5ffb333f:	89 c3                	mov    %eax,%ebx
5ffb3341:	5e                   	pop    %esi
5ffb3342:	85 c0                	test   %eax,%eax
5ffb3344:	0f 88 71 01 00 00    	js     5ffb34bb <_CsrWriteConsoleOutputChar@12+0x20b>
    {
      if (NULL != Console)
        {
          ConioUnlockConsole(Console);
        }
      return Reply->Status = Status;
    }

  X = Request->Data.WriteConsoleOutputCharRequest.Coord.X + Buff->ShowX;
5ffb334a:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
5ffb334d:	8b 45 0c             	mov    0xc(%ebp),%eax
  Y = (Request->Data.WriteConsoleOutputCharRequest.Coord.Y + Buff->ShowY) % Buff->MaxY;
5ffb3350:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb3353:	0f bf 50 26          	movswl 0x26(%eax),%edx
5ffb3357:	66 8b 41 28          	mov    0x28(%ecx),%ax
5ffb335b:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3360:	8d 34 02             	lea    (%edx,%eax,1),%esi
5ffb3363:	66 8b 41 2a          	mov    0x2a(%ecx),%ax
5ffb3367:	0f bf 53 28          	movswl 0x28(%ebx),%edx
5ffb336b:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3370:	01 c2                	add    %eax,%edx
5ffb3372:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb3376:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb337b:	89 55 c4             	mov    %edx,0xffffffc4(%ebp)
5ffb337e:	89 c3                	mov    %eax,%ebx
5ffb3380:	89 d0                	mov    %edx,%eax
5ffb3382:	c1 fa 1f             	sar    $0x1f,%edx
5ffb3385:	f7 fb                	idiv   %ebx
5ffb3387:	89 55 cc             	mov    %edx,0xffffffcc(%ebp)
  Length = Request->Data.WriteConsoleOutputCharRequest.Length;
5ffb338a:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb338d:	66 8b 42 24          	mov    0x24(%edx),%ax
  Buffer = &Buff->Buffer[2 * (Y * Buff->MaxX + X)];
5ffb3391:	8b 55 cc             	mov    0xffffffcc(%ebp),%edx
5ffb3394:	89 c3                	mov    %eax,%ebx
5ffb3396:	66 8b 41 24          	mov    0x24(%ecx),%ax
5ffb339a:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb339f:	81 e3 ff ff 00 00    	and    $0xffff,%ebx
5ffb33a5:	0f af c2             	imul   %edx,%eax
5ffb33a8:	8b 51 20             	mov    0x20(%ecx),%edx
5ffb33ab:	01 f0                	add    %esi,%eax
5ffb33ad:	8d 14 42             	lea    (%edx,%eax,2),%edx
  while (Length--)
    {
      *Buffer = *String++;
      Written++;
      Buffer += 2;
      if (++X == Buff->MaxX)
        {
          if (++Y == Buff->MaxY)
            {
              Y = 0;
              Buffer = Buff->Buffer;
            }
          X = 0;
5ffb33b0:	4b                   	dec    %ebx
5ffb33b1:	83 fb ff             	cmp    $0xffffffff,%ebx
5ffb33b4:	74 3d                	je     5ffb33f3 <_CsrWriteConsoleOutputChar@12+0x143>
5ffb33b6:	8a 07                	mov    (%edi),%al
5ffb33b8:	46                   	inc    %esi
5ffb33b9:	88 02                	mov    %al,(%edx)
5ffb33bb:	47                   	inc    %edi
5ffb33bc:	8b 45 c8             	mov    0xffffffc8(%ebp),%eax
5ffb33bf:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
5ffb33c2:	40                   	inc    %eax
5ffb33c3:	83 c2 02             	add    $0x2,%edx
5ffb33c6:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)
5ffb33c9:	66 8b 41 24          	mov    0x24(%ecx),%ax
5ffb33cd:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb33d2:	39 c6                	cmp    %eax,%esi
5ffb33d4:	75 da                	jne    5ffb33b0 <_CsrWriteConsoleOutputChar@12+0x100>
5ffb33d6:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
5ffb33d9:	40                   	inc    %eax
5ffb33da:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
5ffb33dd:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb33e1:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb33e6:	39 45 cc             	cmp    %eax,0xffffffcc(%ebp)
5ffb33e9:	74 7b                	je     5ffb3466 <_CsrWriteConsoleOutputChar@12+0x1b6>
5ffb33eb:	31 f6                	xor    %esi,%esi
5ffb33ed:	4b                   	dec    %ebx
5ffb33ee:	83 fb ff             	cmp    $0xffffffff,%ebx
5ffb33f1:	75 c3                	jne    5ffb33b6 <_CsrWriteConsoleOutputChar@12+0x106>
        }
    }

  if (NULL != Console && Buff == Console->ActiveBuffer)
5ffb33f3:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
5ffb33f6:	85 c0                	test   %eax,%eax
5ffb33f8:	74 09                	je     5ffb3403 <_CsrWriteConsoleOutputChar@12+0x153>
5ffb33fa:	39 48 38             	cmp    %ecx,0x38(%eax)
5ffb33fd:	0f 84 ec 00 00 00    	je     5ffb34ef <_CsrWriteConsoleOutputChar@12+0x23f>
    {
      ConioComputeUpdateRect(Buff, &UpdateRect, &Request->Data.WriteConsoleOutputCharRequest.Coord,
                             Request->Data.WriteConsoleOutputCharRequest.Length);
      ConioDrawRegion(Console, &UpdateRect);
    }

  Reply->Data.WriteConsoleOutputCharReply.EndCoord.X = X - Buff->ShowX;
5ffb3403:	89 f0                	mov    %esi,%eax
5ffb3405:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb3408:	66 2b 41 28          	sub    0x28(%ecx),%ax
5ffb340c:	66 89 43 1c          	mov    %ax,0x1c(%ebx)
  Reply->Data.WriteConsoleOutputCharReply.EndCoord.Y = (Y + Buff->MaxY - Buff->ShowY) % Buff->MaxY;
5ffb3410:	66 8b 51 26          	mov    0x26(%ecx),%dx
5ffb3414:	8b 75 cc             	mov    0xffffffcc(%ebp),%esi
5ffb3417:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb341d:	66 8b 41 2a          	mov    0x2a(%ecx),%ax
5ffb3421:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3426:	8d 1c 32             	lea    (%edx,%esi,1),%ebx
5ffb3429:	89 d6                	mov    %edx,%esi
5ffb342b:	29 c3                	sub    %eax,%ebx
5ffb342d:	31 d2                	xor    %edx,%edx
5ffb342f:	89 d8                	mov    %ebx,%eax
5ffb3431:	f7 f6                	div    %esi
5ffb3433:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb3436:	66 89 50 1e          	mov    %dx,0x1e(%eax)

  ConioUnlockScreenBuffer(Buff);
5ffb343a:	e8 81 dc ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
  if (NULL != Console)
5ffb343f:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
5ffb3442:	85 c9                	test   %ecx,%ecx
5ffb3444:	0f 85 94 00 00 00    	jne    5ffb34de <_CsrWriteConsoleOutputChar@12+0x22e>
    {
      ConioUnlockConsole(Console);
    }

  Reply->Data.WriteConsoleOutputCharReply.NrCharactersWritten = Written;
5ffb344a:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb344d:	8b 5d c8             	mov    0xffffffc8(%ebp),%ebx
  return Reply->Status = STATUS_SUCCESS;
5ffb3450:	31 c0                	xor    %eax,%eax
5ffb3452:	89 5a 20             	mov    %ebx,0x20(%edx)
5ffb3455:	c7 42 18 00 00 00 00 	movl   $0x0,0x18(%edx)
}
5ffb345c:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb345f:	5b                   	pop    %ebx
5ffb3460:	5e                   	pop    %esi
5ffb3461:	5f                   	pop    %edi
5ffb3462:	5d                   	pop    %ebp
5ffb3463:	c2 0c 00             	ret    $0xc
5ffb3466:	8b 51 20             	mov    0x20(%ecx),%edx
5ffb3469:	31 f6                	xor    %esi,%esi
5ffb346b:	c7 45 cc 00 00 00 00 	movl   $0x0,0xffffffcc(%ebp)
5ffb3472:	e9 76 ff ff ff       	jmp    5ffb33ed <_CsrWriteConsoleOutputChar@12+0x13d>
5ffb3477:	6a 00                	push   $0x0
5ffb3479:	6a 00                	push   $0x0
5ffb347b:	66 8b 42 24          	mov    0x24(%edx),%ax
5ffb347f:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3484:	8d 14 00             	lea    (%eax,%eax,1),%edx
5ffb3487:	52                   	push   %edx
5ffb3488:	57                   	push   %edi
5ffb3489:	50                   	push   %eax
5ffb348a:	57                   	push   %edi
5ffb348b:	6a 00                	push   $0x0
5ffb348d:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
5ffb3490:	8b 40 68             	mov    0x68(%eax),%eax
5ffb3493:	50                   	push   %eax
5ffb3494:	e8 87 58 00 00       	call   5ffb8d20 <_WideCharToMultiByte@32>
5ffb3499:	50                   	push   %eax
5ffb349a:	50                   	push   %eax
5ffb349b:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb349e:	8d 45 d0             	lea    0xffffffd0(%ebp),%eax
5ffb34a1:	8b 53 1c             	mov    0x1c(%ebx),%edx
5ffb34a4:	6a 02                	push   $0x2
5ffb34a6:	50                   	push   %eax
5ffb34a7:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb34aa:	e8 d1 db ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
5ffb34af:	59                   	pop    %ecx
5ffb34b0:	89 c3                	mov    %eax,%ebx
5ffb34b2:	5e                   	pop    %esi
5ffb34b3:	85 c0                	test   %eax,%eax
5ffb34b5:	0f 89 8f fe ff ff    	jns    5ffb334a <_CsrWriteConsoleOutputChar@12+0x9a>
5ffb34bb:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
5ffb34be:	85 c9                	test   %ecx,%ecx
5ffb34c0:	75 26                	jne    5ffb34e8 <_CsrWriteConsoleOutputChar@12+0x238>
5ffb34c2:	8b 75 10             	mov    0x10(%ebp),%esi
5ffb34c5:	89 d8                	mov    %ebx,%eax
5ffb34c7:	89 5e 18             	mov    %ebx,0x18(%esi)
5ffb34ca:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb34cd:	5b                   	pop    %ebx
5ffb34ce:	5e                   	pop    %esi
5ffb34cf:	5f                   	pop    %edi
5ffb34d0:	5d                   	pop    %ebp
5ffb34d1:	c2 0c 00             	ret    $0xc
5ffb34d4:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb34d7:	89 58 18             	mov    %ebx,0x18(%eax)
5ffb34da:	89 d8                	mov    %ebx,%eax
5ffb34dc:	eb ec                	jmp    5ffb34ca <_CsrWriteConsoleOutputChar@12+0x21a>
5ffb34de:	e8 dd db ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb34e3:	e9 62 ff ff ff       	jmp    5ffb344a <_CsrWriteConsoleOutputChar@12+0x19a>
5ffb34e8:	e8 d3 db ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb34ed:	eb d3                	jmp    5ffb34c2 <_CsrWriteConsoleOutputChar@12+0x212>
5ffb34ef:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb34f2:	8d 5d d8             	lea    0xffffffd8(%ebp),%ebx
5ffb34f5:	66 8b 42 24          	mov    0x24(%edx),%ax
5ffb34f9:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb34fe:	50                   	push   %eax
5ffb34ff:	89 d0                	mov    %edx,%eax
5ffb3501:	83 c0 26             	add    $0x26,%eax
5ffb3504:	89 da                	mov    %ebx,%edx
5ffb3506:	50                   	push   %eax
5ffb3507:	e8 e4 fc ff ff       	call   5ffb31f0 <@ConioComputeUpdateRect@16>
5ffb350c:	50                   	push   %eax
5ffb350d:	50                   	push   %eax
5ffb350e:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
5ffb3511:	8b 50 70             	mov    0x70(%eax),%edx
5ffb3514:	53                   	push   %ebx
5ffb3515:	50                   	push   %eax
5ffb3516:	ff 52 08             	call   *0x8(%edx)
5ffb3519:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
5ffb351c:	5f                   	pop    %edi
5ffb351d:	58                   	pop    %eax
5ffb351e:	e9 e0 fe ff ff       	jmp    5ffb3403 <_CsrWriteConsoleOutputChar@12+0x153>
5ffb3523:	50                   	push   %eax
5ffb3524:	68 14 06 00 00       	push   $0x614
5ffb3529:	68 40 b0 fb 5f       	push   $0x5ffbb040
5ffb352e:	68 48 b0 fb 5f       	push   $0x5ffbb048
5ffb3533:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb3539:	c7 04 24 aa b0 fb 5f 	movl   $0x5ffbb0aa,(%esp)
5ffb3540:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb3546:	8b 75 10             	mov    0x10(%ebp),%esi
5ffb3549:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
5ffb354e:	c7 46 18 0d 00 00 c0 	movl   $0xc000000d,0x18(%esi)
5ffb3555:	e9 02 ff ff ff       	jmp    5ffb345c <_CsrWriteConsoleOutputChar@12+0x1ac>
5ffb355a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

5ffb3560 <_CsrFillOutputChar@12>:

CSR_API(CsrFillOutputChar)
{
5ffb3560:	55                   	push   %ebp
5ffb3561:	89 e5                	mov    %esp,%ebp
5ffb3563:	57                   	push   %edi
5ffb3564:	56                   	push   %esi
5ffb3565:	53                   	push   %ebx
5ffb3566:	83 ec 2c             	sub    $0x2c,%esp
  NTSTATUS Status;
  PCSRSS_CONSOLE Console;
  PCSRSS_SCREEN_BUFFER Buff;
  DWORD X, Y, Length, Written = 0;
  CHAR Char;
  PBYTE Buffer;
  RECT UpdateRect;

  DPRINT("CsrFillOutputChar\n");
   
  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;

  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb3569:	8d 55 d4             	lea    0xffffffd4(%ebp),%edx
5ffb356c:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb356f:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb3572:	66 c7 40 02 38 00    	movw   $0x38,0x2(%eax)
5ffb3578:	66 c7 00 20 00       	movw   $0x20,(%eax)
5ffb357d:	e8 3e dc ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
5ffb3582:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb3584:	85 c0                	test   %eax,%eax
5ffb3586:	0f 88 14 01 00 00    	js     5ffb36a0 <_CsrFillOutputChar@12+0x140>
    {
      return Reply->Status = Status;
    }

  Status = ConioLockScreenBuffer(ProcessData, Request->Data.FillOutputRequest.ConsoleHandle, &Buff);
5ffb358c:	51                   	push   %ecx
5ffb358d:	51                   	push   %ecx
5ffb358e:	8d 45 d0             	lea    0xffffffd0(%ebp),%eax
5ffb3591:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb3594:	8b 53 1c             	mov    0x1c(%ebx),%edx
5ffb3597:	6a 02                	push   $0x2
5ffb3599:	50                   	push   %eax
5ffb359a:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb359d:	e8 de da ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
5ffb35a2:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb35a4:	58                   	pop    %eax
5ffb35a5:	85 db                	test   %ebx,%ebx
5ffb35a7:	5a                   	pop    %edx
5ffb35a8:	0f 88 04 01 00 00    	js     5ffb36b2 <_CsrFillOutputChar@12+0x152>
    {
      if (NULL != Console)
        {
          ConioUnlockConsole(Console);
        }
      return Reply->Status = Status;
    }

  X = Request->Data.FillOutputRequest.Position.X + Buff->ShowX;
5ffb35ae:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
5ffb35b1:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb35b4:	66 8b 41 28          	mov    0x28(%ecx),%ax
5ffb35b8:	0f bf 53 26          	movswl 0x26(%ebx),%edx
5ffb35bc:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb35c1:	8d 34 02             	lea    (%edx,%eax,1),%esi
  Y = (Request->Data.FillOutputRequest.Position.Y + Buff->ShowY) % Buff->MaxY;
5ffb35c4:	66 8b 41 2a          	mov    0x2a(%ecx),%ax
5ffb35c8:	0f bf 53 28          	movswl 0x28(%ebx),%edx
5ffb35cc:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb35d1:	8d 3c 02             	lea    (%edx,%eax,1),%edi
5ffb35d4:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb35d8:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb35dd:	89 fa                	mov    %edi,%edx
5ffb35df:	c1 fa 1f             	sar    $0x1f,%edx
5ffb35e2:	89 c3                	mov    %eax,%ebx
5ffb35e4:	89 f8                	mov    %edi,%eax
5ffb35e6:	f7 fb                	idiv   %ebx
  Buffer = &Buff->Buffer[2 * (Y * Buff->MaxX + X)];
5ffb35e8:	66 8b 41 24          	mov    0x24(%ecx),%ax
5ffb35ec:	89 d7                	mov    %edx,%edi
5ffb35ee:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb35f3:	0f af c2             	imul   %edx,%eax
5ffb35f6:	8b 51 20             	mov    0x20(%ecx),%edx
5ffb35f9:	01 f0                	add    %esi,%eax
5ffb35fb:	8d 1c 42             	lea    (%edx,%eax,2),%ebx
  if(Request->Data.FillOutputRequest.Unicode)
5ffb35fe:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb3601:	8b 40 20             	mov    0x20(%eax),%eax
5ffb3604:	85 c0                	test   %eax,%eax
5ffb3606:	0f 85 b5 00 00 00    	jne    5ffb36c1 <_CsrFillOutputChar@12+0x161>
    ConsoleUnicodeCharToAnsiChar(Console, &Char, &Request->Data.FillOutputRequest.Char.UnicodeChar);
  else
    Char = Request->Data.FillOutputRequest.Char.AsciiChar;
5ffb360c:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb360f:	8a 42 24             	mov    0x24(%edx),%al
5ffb3612:	88 45 cf             	mov    %al,0xffffffcf(%ebp)
  Length = Request->Data.FillOutputRequest.Length;
5ffb3615:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb3618:	66 8b 42 2a          	mov    0x2a(%edx),%ax
5ffb361c:	89 c2                	mov    %eax,%edx
5ffb361e:	81 e2 ff ff 00 00    	and    $0xffff,%edx
  while (Length--)
    {
      *Buffer = Char;
      Buffer += 2;
      Written++;
      if (++X == Buff->MaxX)
        {
          if (++Y == Buff->MaxY)
            {
              Y = 0;
              Buffer = Buff->Buffer;
            }
          X = 0;
5ffb3624:	4a                   	dec    %edx
5ffb3625:	83 fa ff             	cmp    $0xffffffff,%edx
5ffb3628:	75 0c                	jne    5ffb3636 <_CsrFillOutputChar@12+0xd6>
5ffb362a:	e9 bf 00 00 00       	jmp    5ffb36ee <_CsrFillOutputChar@12+0x18e>
5ffb362f:	90                   	nop    
5ffb3630:	4a                   	dec    %edx
5ffb3631:	83 fa ff             	cmp    $0xffffffff,%edx
5ffb3634:	74 2f                	je     5ffb3665 <_CsrFillOutputChar@12+0x105>
5ffb3636:	8a 45 cf             	mov    0xffffffcf(%ebp),%al
5ffb3639:	46                   	inc    %esi
5ffb363a:	88 03                	mov    %al,(%ebx)
5ffb363c:	83 c3 02             	add    $0x2,%ebx
5ffb363f:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
5ffb3642:	66 8b 41 24          	mov    0x24(%ecx),%ax
5ffb3646:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb364b:	39 c6                	cmp    %eax,%esi
5ffb364d:	75 e1                	jne    5ffb3630 <_CsrFillOutputChar@12+0xd0>
5ffb364f:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb3653:	47                   	inc    %edi
5ffb3654:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3659:	39 c7                	cmp    %eax,%edi
5ffb365b:	74 34                	je     5ffb3691 <_CsrFillOutputChar@12+0x131>
5ffb365d:	31 f6                	xor    %esi,%esi
5ffb365f:	4a                   	dec    %edx
5ffb3660:	83 fa ff             	cmp    $0xffffffff,%edx
5ffb3663:	75 d1                	jne    5ffb3636 <_CsrFillOutputChar@12+0xd6>
        }
    }

  if (NULL != Console && Buff == Console->ActiveBuffer)
5ffb3665:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
5ffb3668:	85 c0                	test   %eax,%eax
5ffb366a:	74 09                	je     5ffb3675 <_CsrFillOutputChar@12+0x115>
5ffb366c:	39 48 38             	cmp    %ecx,0x38(%eax)
5ffb366f:	0f 84 88 00 00 00    	je     5ffb36fd <_CsrFillOutputChar@12+0x19d>
    {
      ConioComputeUpdateRect(Buff, &UpdateRect, &Request->Data.FillOutputRequest.Position,
                             Request->Data.FillOutputRequest.Length);
      ConioDrawRegion(Console, &UpdateRect);
    }

  ConioUnlockScreenBuffer(Buff);
5ffb3675:	e8 46 da ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
  if (NULL != Console)
5ffb367a:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
5ffb367d:	85 c9                	test   %ecx,%ecx
5ffb367f:	75 66                	jne    5ffb36e7 <_CsrFillOutputChar@12+0x187>
    {
      ConioUnlockConsole(Console);
    }

  return Reply->Status;
5ffb3681:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb3684:	8b 43 18             	mov    0x18(%ebx),%eax
}
5ffb3687:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb368a:	5b                   	pop    %ebx
5ffb368b:	5e                   	pop    %esi
5ffb368c:	5f                   	pop    %edi
5ffb368d:	5d                   	pop    %ebp
5ffb368e:	c2 0c 00             	ret    $0xc
5ffb3691:	31 ff                	xor    %edi,%edi
5ffb3693:	8b 59 20             	mov    0x20(%ecx),%ebx
5ffb3696:	31 f6                	xor    %esi,%esi
5ffb3698:	eb c5                	jmp    5ffb365f <_CsrFillOutputChar@12+0xff>
5ffb369a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb36a0:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb36a3:	89 42 18             	mov    %eax,0x18(%edx)
5ffb36a6:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb36a9:	89 d8                	mov    %ebx,%eax
5ffb36ab:	5b                   	pop    %ebx
5ffb36ac:	5e                   	pop    %esi
5ffb36ad:	5f                   	pop    %edi
5ffb36ae:	5d                   	pop    %ebp
5ffb36af:	c2 0c 00             	ret    $0xc
5ffb36b2:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
5ffb36b5:	85 c9                	test   %ecx,%ecx
5ffb36b7:	75 3d                	jne    5ffb36f6 <_CsrFillOutputChar@12+0x196>
5ffb36b9:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb36bc:	89 58 18             	mov    %ebx,0x18(%eax)
5ffb36bf:	eb e5                	jmp    5ffb36a6 <_CsrFillOutputChar@12+0x146>
5ffb36c1:	8d 45 cf             	lea    0xffffffcf(%ebp),%eax
5ffb36c4:	6a 00                	push   $0x0
5ffb36c6:	6a 00                	push   $0x0
5ffb36c8:	6a 01                	push   $0x1
5ffb36ca:	50                   	push   %eax
5ffb36cb:	6a 01                	push   $0x1
5ffb36cd:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb36d0:	83 c0 24             	add    $0x24,%eax
5ffb36d3:	50                   	push   %eax
5ffb36d4:	6a 00                	push   $0x0
5ffb36d6:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
5ffb36d9:	8b 40 68             	mov    0x68(%eax),%eax
5ffb36dc:	50                   	push   %eax
5ffb36dd:	e8 3e 56 00 00       	call   5ffb8d20 <_WideCharToMultiByte@32>
5ffb36e2:	e9 2e ff ff ff       	jmp    5ffb3615 <_CsrFillOutputChar@12+0xb5>
5ffb36e7:	e8 d4 d9 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb36ec:	eb 93                	jmp    5ffb3681 <_CsrFillOutputChar@12+0x121>
5ffb36ee:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
5ffb36f1:	e9 6f ff ff ff       	jmp    5ffb3665 <_CsrFillOutputChar@12+0x105>
5ffb36f6:	e8 c5 d9 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb36fb:	eb bc                	jmp    5ffb36b9 <_CsrFillOutputChar@12+0x159>
5ffb36fd:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb3700:	8d 5d d8             	lea    0xffffffd8(%ebp),%ebx
5ffb3703:	66 8b 42 2a          	mov    0x2a(%edx),%ax
5ffb3707:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb370c:	50                   	push   %eax
5ffb370d:	89 d0                	mov    %edx,%eax
5ffb370f:	83 c0 26             	add    $0x26,%eax
5ffb3712:	89 da                	mov    %ebx,%edx
5ffb3714:	50                   	push   %eax
5ffb3715:	e8 d6 fa ff ff       	call   5ffb31f0 <@ConioComputeUpdateRect@16>
5ffb371a:	51                   	push   %ecx
5ffb371b:	51                   	push   %ecx
5ffb371c:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
5ffb371f:	8b 50 70             	mov    0x70(%eax),%edx
5ffb3722:	53                   	push   %ebx
5ffb3723:	50                   	push   %eax
5ffb3724:	ff 52 08             	call   *0x8(%edx)
5ffb3727:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
5ffb372a:	58                   	pop    %eax
5ffb372b:	5a                   	pop    %edx
5ffb372c:	e9 44 ff ff ff       	jmp    5ffb3675 <_CsrFillOutputChar@12+0x115>
5ffb3731:	eb 0d                	jmp    5ffb3740 <_CsrReadInputEvent@12>
5ffb3733:	90                   	nop    
5ffb3734:	90                   	nop    
5ffb3735:	90                   	nop    
5ffb3736:	90                   	nop    
5ffb3737:	90                   	nop    
5ffb3738:	90                   	nop    
5ffb3739:	90                   	nop    
5ffb373a:	90                   	nop    
5ffb373b:	90                   	nop    
5ffb373c:	90                   	nop    
5ffb373d:	90                   	nop    
5ffb373e:	90                   	nop    
5ffb373f:	90                   	nop    

5ffb3740 <_CsrReadInputEvent@12>:

CSR_API(CsrReadInputEvent)
{
5ffb3740:	55                   	push   %ebp
5ffb3741:	89 e5                	mov    %esp,%ebp
5ffb3743:	57                   	push   %edi
5ffb3744:	56                   	push   %esi
5ffb3745:	53                   	push   %ebx
5ffb3746:	83 ec 14             	sub    $0x14,%esp
  PLIST_ENTRY CurrentEntry;
  PCSRSS_CONSOLE Console;
  NTSTATUS Status;
  BOOLEAN Done = FALSE;
5ffb3749:	31 ff                	xor    %edi,%edi
  ConsoleInput *Input;
   
  DPRINT("CsrReadInputEvent\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
5ffb374b:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb374e:	8b 4d 08             	mov    0x8(%ebp),%ecx
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
  Reply->Data.ReadInputReply.Event = ProcessData->ConsoleEvent;
5ffb3751:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb3754:	66 c7 40 02 38 00    	movw   $0x38,0x2(%eax)
5ffb375a:	66 c7 00 20 00       	movw   $0x20,(%eax)
5ffb375f:	8b 41 18             	mov    0x18(%ecx),%eax
5ffb3762:	89 42 34             	mov    %eax,0x34(%edx)
   
  Status = ConioLockConsole(ProcessData, Request->Data.ReadInputRequest.ConsoleHandle, &Console);
5ffb3765:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb3768:	8b 50 1c             	mov    0x1c(%eax),%edx
5ffb376b:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
5ffb376e:	6a 01                	push   $0x1
5ffb3770:	50                   	push   %eax
5ffb3771:	e8 0a d9 ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
5ffb3776:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb3778:	58                   	pop    %eax
5ffb3779:	85 db                	test   %ebx,%ebx
5ffb377b:	5a                   	pop    %edx
5ffb377c:	0f 88 f8 00 00 00    	js     5ffb387a <_CsrReadInputEvent@12+0x13a>
    {
      return Reply->Status = Status;
    }

  /* only get input if there is any */
  CurrentEntry = Console->InputEvents.Flink;
5ffb3782:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb3785:	8b 71 2c             	mov    0x2c(%ecx),%esi
  while (CurrentEntry != &Console->InputEvents)
    {
      Input = CONTAINING_RECORD(CurrentEntry, ConsoleInput, ListEntry);
      CurrentEntry = CurrentEntry->Flink;

      if (Done && !Input->Fake)
        {
	  Reply->Data.ReadInputReply.MoreEvents = TRUE;
	  break;
	}
      
      RemoveEntryList(&Input->ListEntry);

      if (!Done && !Input->Fake)
        {
          Reply->Data.ReadInputReply.Input = Input->InputEvent;
          if (Request->Data.ReadInputRequest.Unicode == FALSE)
            {
              ConioInputEventToAnsi(Console, &Reply->Data.ReadInputReply.Input);
            }
	  Done = TRUE;
	}

      if (Input->InputEvent.EventType == KEY_EVENT)
        {
          if (0 != (Console->Mode & ENABLE_LINE_INPUT)
	      && Input->InputEvent.Event.KeyEvent.bKeyDown
	      && '\r' == Input->InputEvent.Event.KeyEvent.uChar.AsciiChar)
            {
              Console->WaitingLines--;
            }
          Console->WaitingChars--;
        }
      HeapFree(Win32CsrApiHeap, 0, Input);
5ffb3788:	8d 41 2c             	lea    0x2c(%ecx),%eax
5ffb378b:	39 f0                	cmp    %esi,%eax
5ffb378d:	0f 84 d9 00 00 00    	je     5ffb386c <_CsrReadInputEvent@12+0x12c>
5ffb3793:	89 fa                	mov    %edi,%edx
5ffb3795:	89 f3                	mov    %esi,%ebx
5ffb3797:	84 d2                	test   %dl,%dl
5ffb3799:	8b 36                	mov    (%esi),%esi
5ffb379b:	74 0a                	je     5ffb37a7 <_CsrReadInputEvent@12+0x67>
5ffb379d:	80 7b 1d 00          	cmpb   $0x0,0x1d(%ebx)
5ffb37a1:	0f 84 f2 00 00 00    	je     5ffb3899 <_CsrReadInputEvent@12+0x159>
  PLIST_ENTRY OldFlink;
  PLIST_ENTRY OldBlink;

  OldFlink = Entry->Flink;
  OldBlink = Entry->Blink;
5ffb37a7:	8b 43 04             	mov    0x4(%ebx),%eax
5ffb37aa:	8b 13                	mov    (%ebx),%edx
  OldFlink->Blink = OldBlink;
  OldBlink->Flink = OldFlink;
5ffb37ac:	89 10                	mov    %edx,(%eax)
5ffb37ae:	89 42 04             	mov    %eax,0x4(%edx)
5ffb37b1:	89 f8                	mov    %edi,%eax
5ffb37b3:	84 c0                	test   %al,%al
5ffb37b5:	75 39                	jne    5ffb37f0 <_CsrReadInputEvent@12+0xb0>
5ffb37b7:	80 7b 1d 00          	cmpb   $0x0,0x1d(%ebx)
5ffb37bb:	75 33                	jne    5ffb37f0 <_CsrReadInputEvent@12+0xb0>
5ffb37bd:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb37c0:	8b 43 08             	mov    0x8(%ebx),%eax
5ffb37c3:	89 42 1c             	mov    %eax,0x1c(%edx)
5ffb37c6:	8b 43 0c             	mov    0xc(%ebx),%eax
5ffb37c9:	89 42 20             	mov    %eax,0x20(%edx)
5ffb37cc:	8b 43 10             	mov    0x10(%ebx),%eax
5ffb37cf:	89 42 24             	mov    %eax,0x24(%edx)
5ffb37d2:	8b 43 14             	mov    0x14(%ebx),%eax
5ffb37d5:	89 42 28             	mov    %eax,0x28(%edx)
5ffb37d8:	8b 43 18             	mov    0x18(%ebx),%eax
5ffb37db:	89 42 2c             	mov    %eax,0x2c(%edx)
5ffb37de:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb37e1:	8b 40 20             	mov    0x20(%eax),%eax
5ffb37e4:	85 c0                	test   %eax,%eax
5ffb37e6:	74 5b                	je     5ffb3843 <_CsrReadInputEvent@12+0x103>
5ffb37e8:	bf 01 00 00 00       	mov    $0x1,%edi
5ffb37ed:	8d 76 00             	lea    0x0(%esi),%esi
5ffb37f0:	66 83 7b 08 01       	cmpw   $0x1,0x8(%ebx)
5ffb37f5:	74 59                	je     5ffb3850 <_CsrReadInputEvent@12+0x110>
5ffb37f7:	50                   	push   %eax
5ffb37f8:	53                   	push   %ebx
5ffb37f9:	6a 00                	push   $0x0
5ffb37fb:	a1 e0 c1 fb 5f       	mov    0x5ffbc1e0,%eax
5ffb3800:	50                   	push   %eax
5ffb3801:	e8 fa 54 00 00       	call   5ffb8d00 <_HeapFree@12>
5ffb3806:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb3809:	58                   	pop    %eax
5ffb380a:	8d 41 2c             	lea    0x2c(%ecx),%eax
5ffb380d:	39 f0                	cmp    %esi,%eax
5ffb380f:	75 82                	jne    5ffb3793 <_CsrReadInputEvent@12+0x53>
    }
   
  if (Done)
5ffb3811:	89 fa                	mov    %edi,%edx
5ffb3813:	84 d2                	test   %dl,%dl
5ffb3815:	74 55                	je     5ffb386c <_CsrReadInputEvent@12+0x12c>
    {
      Status = STATUS_SUCCESS;
5ffb3817:	31 db                	xor    %ebx,%ebx
      Console->EarlyReturn = FALSE;
5ffb3819:	c7 41 50 00 00 00 00 	movl   $0x0,0x50(%ecx)
    }
  else
    {
      Status = STATUS_PENDING;
      Console->EarlyReturn = TRUE;  /* mark for early return */
    }

  if (IsListEmpty(&Console->InputEvents))
5ffb3820:	8d 41 2c             	lea    0x2c(%ecx),%eax
5ffb3823:	39 41 2c             	cmp    %eax,0x2c(%ecx)
5ffb3826:	0f 84 7c 00 00 00    	je     5ffb38a8 <_CsrReadInputEvent@12+0x168>
    {
      ResetEvent(Console->ActiveEvent);
    }

  ConioUnlockConsole(Console);
5ffb382c:	e8 8f d8 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>

  return Reply->Status = Status;
5ffb3831:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb3834:	89 58 18             	mov    %ebx,0x18(%eax)
}
5ffb3837:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb383a:	89 d8                	mov    %ebx,%eax
5ffb383c:	5b                   	pop    %ebx
5ffb383d:	5e                   	pop    %esi
5ffb383e:	5f                   	pop    %edi
5ffb383f:	5d                   	pop    %ebp
5ffb3840:	c2 0c 00             	ret    $0xc
5ffb3843:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb3846:	8d 50 1c             	lea    0x1c(%eax),%edx
5ffb3849:	e8 82 e7 ff ff       	call   5ffb1fd0 <@ConioInputEventToAnsi@8>
5ffb384e:	eb 98                	jmp    5ffb37e8 <_CsrReadInputEvent@12+0xa8>
5ffb3850:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb3853:	f6 41 3c 02          	testb  $0x2,0x3c(%ecx)
5ffb3857:	74 0d                	je     5ffb3866 <_CsrReadInputEvent@12+0x126>
5ffb3859:	8b 43 0c             	mov    0xc(%ebx),%eax
5ffb385c:	85 c0                	test   %eax,%eax
5ffb385e:	74 06                	je     5ffb3866 <_CsrReadInputEvent@12+0x126>
5ffb3860:	80 7b 16 0d          	cmpb   $0xd,0x16(%ebx)
5ffb3864:	74 26                	je     5ffb388c <_CsrReadInputEvent@12+0x14c>
5ffb3866:	66 ff 49 34          	decw   0x34(%ecx)
5ffb386a:	eb 8b                	jmp    5ffb37f7 <_CsrReadInputEvent@12+0xb7>
5ffb386c:	bb 03 01 00 00       	mov    $0x103,%ebx
5ffb3871:	c7 41 50 01 00 00 00 	movl   $0x1,0x50(%ecx)
5ffb3878:	eb a6                	jmp    5ffb3820 <_CsrReadInputEvent@12+0xe0>
5ffb387a:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb387d:	89 d8                	mov    %ebx,%eax
5ffb387f:	89 5a 18             	mov    %ebx,0x18(%edx)
5ffb3882:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb3885:	5b                   	pop    %ebx
5ffb3886:	5e                   	pop    %esi
5ffb3887:	5f                   	pop    %edi
5ffb3888:	5d                   	pop    %ebp
5ffb3889:	c2 0c 00             	ret    $0xc
5ffb388c:	66 ff 49 36          	decw   0x36(%ecx)
5ffb3890:	66 ff 49 34          	decw   0x34(%ecx)
5ffb3894:	e9 5e ff ff ff       	jmp    5ffb37f7 <_CsrReadInputEvent@12+0xb7>
5ffb3899:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb389c:	c7 40 30 01 00 00 00 	movl   $0x1,0x30(%eax)
5ffb38a3:	e9 69 ff ff ff       	jmp    5ffb3811 <_CsrReadInputEvent@12+0xd1>
5ffb38a8:	83 ec 0c             	sub    $0xc,%esp
5ffb38ab:	8b 71 28             	mov    0x28(%ecx),%esi
5ffb38ae:	56                   	push   %esi
5ffb38af:	e8 5c 54 00 00       	call   5ffb8d10 <_ResetEvent@4>
5ffb38b4:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb38b7:	83 c4 0c             	add    $0xc,%esp
5ffb38ba:	e9 6d ff ff ff       	jmp    5ffb382c <_CsrReadInputEvent@12+0xec>
5ffb38bf:	90                   	nop    

5ffb38c0 <_CsrWriteConsoleOutputAttrib@12>:

CSR_API(CsrWriteConsoleOutputAttrib)
{
5ffb38c0:	55                   	push   %ebp
5ffb38c1:	89 e5                	mov    %esp,%ebp
5ffb38c3:	57                   	push   %edi
5ffb38c4:	56                   	push   %esi
5ffb38c5:	53                   	push   %ebx
5ffb38c6:	83 ec 2c             	sub    $0x2c,%esp
  PCSRSS_CONSOLE Console;
  PCSRSS_SCREEN_BUFFER Buff;
  PUCHAR Buffer, Attribute;
  int X, Y, Length;
  NTSTATUS Status;
  RECT UpdateRect;

  DPRINT("CsrWriteConsoleOutputAttrib\n");
   
  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
5ffb38c9:	8b 45 10             	mov    0x10(%ebp),%eax
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;

  if (Request->Header.DataSize
5ffb38cc:	8b 4d 0c             	mov    0xc(%ebp),%ecx
5ffb38cf:	66 c7 00 20 00       	movw   $0x20,(%eax)
5ffb38d4:	66 c7 40 02 38 00    	movw   $0x38,0x2(%eax)
5ffb38da:	66 8b 41 20          	mov    0x20(%ecx),%ax
5ffb38de:	66 8b 11             	mov    (%ecx),%dx
5ffb38e1:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb38e6:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb38ec:	83 c0 0b             	add    $0xb,%eax
5ffb38ef:	39 c2                	cmp    %eax,%edx
5ffb38f1:	0f 82 89 01 00 00    	jb     5ffb3a80 <_CsrWriteConsoleOutputAttrib@12+0x1c0>
      < sizeof(CSRSS_WRITE_CONSOLE_OUTPUT_ATTRIB_REQUEST) - 1
        + Request->Data.WriteConsoleOutputAttribRequest.Length)
    {
      DPRINT1("Invalid request size\n");
      return Reply->Status = STATUS_INVALID_PARAMETER;
    }

  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb38f7:	8d 55 d4             	lea    0xffffffd4(%ebp),%edx
5ffb38fa:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb38fd:	e8 be d8 ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
5ffb3902:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb3904:	85 c0                	test   %eax,%eax
5ffb3906:	0f 88 49 01 00 00    	js     5ffb3a55 <_CsrWriteConsoleOutputAttrib@12+0x195>
    {
      return Reply->Status = Status;
    }

  Status = ConioLockScreenBuffer(ProcessData,
5ffb390c:	51                   	push   %ecx
5ffb390d:	51                   	push   %ecx
5ffb390e:	8d 45 d0             	lea    0xffffffd0(%ebp),%eax
5ffb3911:	8b 4d 0c             	mov    0xc(%ebp),%ecx
5ffb3914:	8b 51 1c             	mov    0x1c(%ecx),%edx
5ffb3917:	6a 02                	push   $0x2
5ffb3919:	50                   	push   %eax
5ffb391a:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb391d:	e8 5e d7 ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
5ffb3922:	89 c3                	mov    %eax,%ebx
                                 Request->Data.WriteConsoleOutputAttribRequest.ConsoleHandle,
                                 &Buff);
  if (! NT_SUCCESS(Status))
5ffb3924:	58                   	pop    %eax
5ffb3925:	85 db                	test   %ebx,%ebx
5ffb3927:	5a                   	pop    %edx
5ffb3928:	0f 88 39 01 00 00    	js     5ffb3a67 <_CsrWriteConsoleOutputAttrib@12+0x1a7>
    {
      if (NULL != Console)
        {
          ConioUnlockConsole(Console);
        }
      return Reply->Status = Status;
    }

  X = Request->Data.WriteConsoleOutputAttribRequest.Coord.X + Buff->ShowX;
5ffb392e:	8b 5d d0             	mov    0xffffffd0(%ebp),%ebx
5ffb3931:	8b 45 0c             	mov    0xc(%ebp),%eax
  Y = (Request->Data.WriteConsoleOutputAttribRequest.Coord.Y + Buff->ShowY) % Buff->MaxY;
5ffb3934:	8b 4d 0c             	mov    0xc(%ebp),%ecx
5ffb3937:	0f bf 50 22          	movswl 0x22(%eax),%edx
5ffb393b:	66 8b 43 28          	mov    0x28(%ebx),%ax
5ffb393f:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3944:	8d 3c 02             	lea    (%edx,%eax,1),%edi
5ffb3947:	66 8b 43 2a          	mov    0x2a(%ebx),%ax
5ffb394b:	0f bf 51 24          	movswl 0x24(%ecx),%edx
5ffb394f:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3954:	8d 34 02             	lea    (%edx,%eax,1),%esi
5ffb3957:	66 8b 43 26          	mov    0x26(%ebx),%ax
5ffb395b:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3960:	89 f2                	mov    %esi,%edx
5ffb3962:	c1 fa 1f             	sar    $0x1f,%edx
5ffb3965:	89 c1                	mov    %eax,%ecx
5ffb3967:	89 f0                	mov    %esi,%eax
  Length = Request->Data.WriteConsoleOutputAttribRequest.Length;
5ffb3969:	8b 75 0c             	mov    0xc(%ebp),%esi
5ffb396c:	f7 f9                	idiv   %ecx
5ffb396e:	89 55 cc             	mov    %edx,0xffffffcc(%ebp)
  Buffer = &Buff->Buffer[2 * (Y * Buff->MaxX + X) + 1];
  Attribute = (PUCHAR)Request->Data.WriteConsoleOutputAttribRequest.String;
5ffb3971:	8b 4d 0c             	mov    0xc(%ebp),%ecx
5ffb3974:	66 8b 46 20          	mov    0x20(%esi),%ax
5ffb3978:	83 c1 26             	add    $0x26,%ecx
5ffb397b:	89 c6                	mov    %eax,%esi
5ffb397d:	66 8b 43 24          	mov    0x24(%ebx),%ax
5ffb3981:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3986:	81 e6 ff ff 00 00    	and    $0xffff,%esi
5ffb398c:	0f af c2             	imul   %edx,%eax
5ffb398f:	8b 53 20             	mov    0x20(%ebx),%edx
5ffb3992:	01 f8                	add    %edi,%eax
5ffb3994:	8d 54 42 01          	lea    0x1(%edx,%eax,2),%edx
  while (Length--)
    {
      *Buffer = *Attribute++;
      Buffer += 2;
      if (++X == Buff->MaxX)
        {
          if (++Y == Buff->MaxY)
            {
              Y = 0;
              Buffer = Buff->Buffer + 1;
            }
          X = 0;
5ffb3998:	4e                   	dec    %esi
5ffb3999:	83 fe ff             	cmp    $0xffffffff,%esi
5ffb399c:	74 36                	je     5ffb39d4 <_CsrWriteConsoleOutputAttrib@12+0x114>
5ffb399e:	8a 01                	mov    (%ecx),%al
5ffb39a0:	47                   	inc    %edi
5ffb39a1:	88 02                	mov    %al,(%edx)
5ffb39a3:	41                   	inc    %ecx
5ffb39a4:	8b 5d d0             	mov    0xffffffd0(%ebp),%ebx
5ffb39a7:	83 c2 02             	add    $0x2,%edx
5ffb39aa:	66 8b 43 24          	mov    0x24(%ebx),%ax
5ffb39ae:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb39b3:	39 c7                	cmp    %eax,%edi
5ffb39b5:	75 e1                	jne    5ffb3998 <_CsrWriteConsoleOutputAttrib@12+0xd8>
5ffb39b7:	8b 7d cc             	mov    0xffffffcc(%ebp),%edi
5ffb39ba:	66 8b 43 26          	mov    0x26(%ebx),%ax
5ffb39be:	47                   	inc    %edi
5ffb39bf:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb39c4:	89 7d cc             	mov    %edi,0xffffffcc(%ebp)
5ffb39c7:	39 45 cc             	cmp    %eax,0xffffffcc(%ebp)
5ffb39ca:	74 77                	je     5ffb3a43 <_CsrWriteConsoleOutputAttrib@12+0x183>
5ffb39cc:	31 ff                	xor    %edi,%edi
5ffb39ce:	4e                   	dec    %esi
5ffb39cf:	83 fe ff             	cmp    $0xffffffff,%esi
5ffb39d2:	75 ca                	jne    5ffb399e <_CsrWriteConsoleOutputAttrib@12+0xde>
        }
    }

  if (NULL != Console && Buff == Console->ActiveBuffer)
5ffb39d4:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
5ffb39d7:	85 c9                	test   %ecx,%ecx
5ffb39d9:	74 13                	je     5ffb39ee <_CsrWriteConsoleOutputAttrib@12+0x12e>
5ffb39db:	8b 71 38             	mov    0x38(%ecx),%esi
5ffb39de:	39 de                	cmp    %ebx,%esi
5ffb39e0:	0f 84 d5 00 00 00    	je     5ffb3abb <_CsrWriteConsoleOutputAttrib@12+0x1fb>
    {
      ConioComputeUpdateRect(Buff, &UpdateRect, &Request->Data.WriteConsoleOutputAttribRequest.Coord,
                             Request->Data.WriteConsoleOutputAttribRequest.Length);
      ConioDrawRegion(Console, &UpdateRect);
    }

  if (NULL != Console)
5ffb39e6:	85 c9                	test   %ecx,%ecx
5ffb39e8:	0f 85 88 00 00 00    	jne    5ffb3a76 <_CsrWriteConsoleOutputAttrib@12+0x1b6>
    {
      ConioUnlockConsole(Console);
    }

  Reply->Data.WriteConsoleOutputAttribReply.EndCoord.X = Buff->CurrentX - Buff->ShowX;
5ffb39ee:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
5ffb39f1:	8b 75 10             	mov    0x10(%ebp),%esi
5ffb39f4:	8b 41 2c             	mov    0x2c(%ecx),%eax
5ffb39f7:	66 2b 41 28          	sub    0x28(%ecx),%ax
5ffb39fb:	66 89 46 1c          	mov    %ax,0x1c(%esi)
  Reply->Data.WriteConsoleOutputAttribReply.EndCoord.Y = (Buff->CurrentY + Buff->MaxY - Buff->ShowY) % Buff->MaxY;
5ffb39ff:	66 8b 51 26          	mov    0x26(%ecx),%dx
5ffb3a03:	8b 59 30             	mov    0x30(%ecx),%ebx
5ffb3a06:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb3a0c:	66 8b 41 2a          	mov    0x2a(%ecx),%ax
5ffb3a10:	01 d3                	add    %edx,%ebx
5ffb3a12:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3a17:	29 c3                	sub    %eax,%ebx
5ffb3a19:	89 d6                	mov    %edx,%esi
5ffb3a1b:	89 d8                	mov    %ebx,%eax
5ffb3a1d:	31 d2                	xor    %edx,%edx
5ffb3a1f:	f7 f6                	div    %esi
5ffb3a21:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb3a24:	66 89 50 1e          	mov    %dx,0x1e(%eax)

  ConioUnlockScreenBuffer(Buff);
5ffb3a28:	e8 93 d6 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>

  return Reply->Status = STATUS_SUCCESS;
5ffb3a2d:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb3a30:	31 c0                	xor    %eax,%eax
5ffb3a32:	c7 42 18 00 00 00 00 	movl   $0x0,0x18(%edx)
}
5ffb3a39:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb3a3c:	5b                   	pop    %ebx
5ffb3a3d:	5e                   	pop    %esi
5ffb3a3e:	5f                   	pop    %edi
5ffb3a3f:	5d                   	pop    %ebp
5ffb3a40:	c2 0c 00             	ret    $0xc
5ffb3a43:	8b 53 20             	mov    0x20(%ebx),%edx
5ffb3a46:	31 ff                	xor    %edi,%edi
5ffb3a48:	42                   	inc    %edx
5ffb3a49:	c7 45 cc 00 00 00 00 	movl   $0x0,0xffffffcc(%ebp)
5ffb3a50:	e9 79 ff ff ff       	jmp    5ffb39ce <_CsrWriteConsoleOutputAttrib@12+0x10e>
5ffb3a55:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb3a58:	89 58 18             	mov    %ebx,0x18(%eax)
5ffb3a5b:	89 d8                	mov    %ebx,%eax
5ffb3a5d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb3a60:	5b                   	pop    %ebx
5ffb3a61:	5e                   	pop    %esi
5ffb3a62:	5f                   	pop    %edi
5ffb3a63:	5d                   	pop    %ebp
5ffb3a64:	c2 0c 00             	ret    $0xc
5ffb3a67:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
5ffb3a6a:	85 c9                	test   %ecx,%ecx
5ffb3a6c:	75 46                	jne    5ffb3ab4 <_CsrWriteConsoleOutputAttrib@12+0x1f4>
5ffb3a6e:	8b 75 10             	mov    0x10(%ebp),%esi
5ffb3a71:	89 5e 18             	mov    %ebx,0x18(%esi)
5ffb3a74:	eb e5                	jmp    5ffb3a5b <_CsrWriteConsoleOutputAttrib@12+0x19b>
5ffb3a76:	e8 45 d6 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb3a7b:	e9 6e ff ff ff       	jmp    5ffb39ee <_CsrWriteConsoleOutputAttrib@12+0x12e>
5ffb3a80:	53                   	push   %ebx
5ffb3a81:	68 ff 06 00 00       	push   $0x6ff
5ffb3a86:	68 40 b0 fb 5f       	push   $0x5ffbb040
5ffb3a8b:	68 48 b0 fb 5f       	push   $0x5ffbb048
5ffb3a90:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb3a96:	c7 04 24 aa b0 fb 5f 	movl   $0x5ffbb0aa,(%esp)
5ffb3a9d:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb3aa3:	8b 75 10             	mov    0x10(%ebp),%esi
5ffb3aa6:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
5ffb3aab:	c7 46 18 0d 00 00 c0 	movl   $0xc000000d,0x18(%esi)
5ffb3ab2:	eb a9                	jmp    5ffb3a5d <_CsrWriteConsoleOutputAttrib@12+0x19d>
5ffb3ab4:	e8 07 d6 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb3ab9:	eb b3                	jmp    5ffb3a6e <_CsrWriteConsoleOutputAttrib@12+0x1ae>
5ffb3abb:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb3abe:	8d 5d d8             	lea    0xffffffd8(%ebp),%ebx
5ffb3ac1:	89 f1                	mov    %esi,%ecx
5ffb3ac3:	66 8b 42 20          	mov    0x20(%edx),%ax
5ffb3ac7:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3acc:	50                   	push   %eax
5ffb3acd:	89 d0                	mov    %edx,%eax
5ffb3acf:	83 c0 22             	add    $0x22,%eax
5ffb3ad2:	89 da                	mov    %ebx,%edx
5ffb3ad4:	50                   	push   %eax
5ffb3ad5:	e8 16 f7 ff ff       	call   5ffb31f0 <@ConioComputeUpdateRect@16>
5ffb3ada:	56                   	push   %esi
5ffb3adb:	56                   	push   %esi
5ffb3adc:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
5ffb3adf:	8b 50 70             	mov    0x70(%eax),%edx
5ffb3ae2:	53                   	push   %ebx
5ffb3ae3:	50                   	push   %eax
5ffb3ae4:	ff 52 08             	call   *0x8(%edx)
5ffb3ae7:	59                   	pop    %ecx
5ffb3ae8:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
5ffb3aeb:	5b                   	pop    %ebx
5ffb3aec:	e9 f5 fe ff ff       	jmp    5ffb39e6 <_CsrWriteConsoleOutputAttrib@12+0x126>
5ffb3af1:	eb 0d                	jmp    5ffb3b00 <_CsrFillOutputAttrib@12>
5ffb3af3:	90                   	nop    
5ffb3af4:	90                   	nop    
5ffb3af5:	90                   	nop    
5ffb3af6:	90                   	nop    
5ffb3af7:	90                   	nop    
5ffb3af8:	90                   	nop    
5ffb3af9:	90                   	nop    
5ffb3afa:	90                   	nop    
5ffb3afb:	90                   	nop    
5ffb3afc:	90                   	nop    
5ffb3afd:	90                   	nop    
5ffb3afe:	90                   	nop    
5ffb3aff:	90                   	nop    

5ffb3b00 <_CsrFillOutputAttrib@12>:

CSR_API(CsrFillOutputAttrib)
{
5ffb3b00:	55                   	push   %ebp
5ffb3b01:	89 e5                	mov    %esp,%ebp
5ffb3b03:	57                   	push   %edi
5ffb3b04:	56                   	push   %esi
5ffb3b05:	53                   	push   %ebx
5ffb3b06:	83 ec 2c             	sub    $0x2c,%esp
  PCSRSS_SCREEN_BUFFER Buff;
  PUCHAR Buffer;
  NTSTATUS Status;
  int X, Y, Length;
  UCHAR Attr;
  RECT UpdateRect;
  PCSRSS_CONSOLE Console;

  DPRINT("CsrFillOutputAttrib\n");

  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb3b09:	8d 55 d4             	lea    0xffffffd4(%ebp),%edx
5ffb3b0c:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb3b0f:	e8 ac d6 ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
5ffb3b14:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb3b16:	85 c0                	test   %eax,%eax
5ffb3b18:	0f 88 18 01 00 00    	js     5ffb3c36 <_CsrFillOutputAttrib@12+0x136>
    {
      return Reply->Status = Status;
    }
   
  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
5ffb3b1e:	8b 55 10             	mov    0x10(%ebp),%edx
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
  Status = ConioLockScreenBuffer(ProcessData, Request->Data.FillOutputAttribRequest.ConsoleHandle, &Buff);
5ffb3b21:	8d 45 d0             	lea    0xffffffd0(%ebp),%eax
5ffb3b24:	66 c7 42 02 38 00    	movw   $0x38,0x2(%edx)
5ffb3b2a:	66 c7 02 20 00       	movw   $0x20,(%edx)
5ffb3b2f:	51                   	push   %ecx
5ffb3b30:	51                   	push   %ecx
5ffb3b31:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb3b34:	8b 53 1c             	mov    0x1c(%ebx),%edx
5ffb3b37:	6a 02                	push   $0x2
5ffb3b39:	50                   	push   %eax
5ffb3b3a:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb3b3d:	e8 3e d5 ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
5ffb3b42:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb3b44:	58                   	pop    %eax
5ffb3b45:	85 db                	test   %ebx,%ebx
5ffb3b47:	5a                   	pop    %edx
5ffb3b48:	0f 88 dc 00 00 00    	js     5ffb3c2a <_CsrFillOutputAttrib@12+0x12a>
    {
      if (NULL != Console)
        {
          ConioUnlockConsole(Console);
        }
      return Reply->Status = Status;
    }

  X = Request->Data.FillOutputAttribRequest.Coord.X + Buff->ShowX;
5ffb3b4e:	8b 75 d0             	mov    0xffffffd0(%ebp),%esi
5ffb3b51:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb3b54:	66 8b 46 28          	mov    0x28(%esi),%ax
5ffb3b58:	0f bf 53 22          	movswl 0x22(%ebx),%edx
5ffb3b5c:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3b61:	8d 0c 02             	lea    (%edx,%eax,1),%ecx
  Y = (Request->Data.FillOutputAttribRequest.Coord.Y + Buff->ShowY) % Buff->MaxY;
5ffb3b64:	66 8b 46 2a          	mov    0x2a(%esi),%ax
5ffb3b68:	0f bf 53 24          	movswl 0x24(%ebx),%edx
5ffb3b6c:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3b71:	8d 3c 02             	lea    (%edx,%eax,1),%edi
5ffb3b74:	66 8b 46 26          	mov    0x26(%esi),%ax
5ffb3b78:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3b7d:	89 fa                	mov    %edi,%edx
5ffb3b7f:	c1 fa 1f             	sar    $0x1f,%edx
5ffb3b82:	89 c3                	mov    %eax,%ebx
5ffb3b84:	89 f8                	mov    %edi,%eax
5ffb3b86:	f7 fb                	idiv   %ebx
5ffb3b88:	89 d7                	mov    %edx,%edi
  Length = Request->Data.FillOutputAttribRequest.Length;
5ffb3b8a:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb3b8d:	66 8b 42 26          	mov    0x26(%edx),%ax
5ffb3b91:	89 c3                	mov    %eax,%ebx
  Attr = Request->Data.FillOutputAttribRequest.Attribute;
5ffb3b93:	8a 42 20             	mov    0x20(%edx),%al
5ffb3b96:	88 45 cf             	mov    %al,0xffffffcf(%ebp)
  Buffer = &Buff->Buffer[(Y * Buff->MaxX * 2) + (X * 2) + 1];
5ffb3b99:	66 8b 46 24          	mov    0x24(%esi),%ax
5ffb3b9d:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3ba2:	8b 56 20             	mov    0x20(%esi),%edx
5ffb3ba5:	0f af c7             	imul   %edi,%eax
5ffb3ba8:	01 c8                	add    %ecx,%eax
5ffb3baa:	81 e3 ff ff 00 00    	and    $0xffff,%ebx
5ffb3bb0:	8d 54 42 01          	lea    0x1(%edx,%eax,2),%edx
  while (Length--)
    {
      *Buffer = Attr;
      Buffer += 2;
      if (++X == Buff->MaxX)
        {
          if (++Y == Buff->MaxY)
            {
              Y = 0;
              Buffer = Buff->Buffer + 1;
            }
          X = 0;
5ffb3bb4:	4b                   	dec    %ebx
5ffb3bb5:	83 fb ff             	cmp    $0xffffffff,%ebx
5ffb3bb8:	74 36                	je     5ffb3bf0 <_CsrFillOutputAttrib@12+0xf0>
5ffb3bba:	8a 45 cf             	mov    0xffffffcf(%ebp),%al
5ffb3bbd:	41                   	inc    %ecx
5ffb3bbe:	88 02                	mov    %al,(%edx)
5ffb3bc0:	83 c2 02             	add    $0x2,%edx
5ffb3bc3:	8b 75 d0             	mov    0xffffffd0(%ebp),%esi
5ffb3bc6:	66 8b 46 24          	mov    0x24(%esi),%ax
5ffb3bca:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3bcf:	39 c1                	cmp    %eax,%ecx
5ffb3bd1:	75 e1                	jne    5ffb3bb4 <_CsrFillOutputAttrib@12+0xb4>
5ffb3bd3:	66 8b 46 26          	mov    0x26(%esi),%ax
5ffb3bd7:	47                   	inc    %edi
5ffb3bd8:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3bdd:	39 c7                	cmp    %eax,%edi
5ffb3bdf:	74 3f                	je     5ffb3c20 <_CsrFillOutputAttrib@12+0x120>
5ffb3be1:	31 c9                	xor    %ecx,%ecx
5ffb3be3:	4b                   	dec    %ebx
5ffb3be4:	83 fb ff             	cmp    $0xffffffff,%ebx
5ffb3be7:	75 d1                	jne    5ffb3bba <_CsrFillOutputAttrib@12+0xba>
5ffb3be9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
        }
    }

  if (NULL != Console && Buff == Console->ActiveBuffer)
5ffb3bf0:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
5ffb3bf3:	85 c0                	test   %eax,%eax
5ffb3bf5:	74 05                	je     5ffb3bfc <_CsrFillOutputAttrib@12+0xfc>
5ffb3bf7:	39 70 38             	cmp    %esi,0x38(%eax)
5ffb3bfa:	74 53                	je     5ffb3c4f <_CsrFillOutputAttrib@12+0x14f>
    {
      ConioComputeUpdateRect(Buff, &UpdateRect, &Request->Data.FillOutputAttribRequest.Coord,
                             Request->Data.FillOutputAttribRequest.Length);
      ConioDrawRegion(Console, &UpdateRect);
    }

  ConioUnlockScreenBuffer(Buff);
5ffb3bfc:	89 f1                	mov    %esi,%ecx
5ffb3bfe:	e8 bd d4 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
  if (NULL != Console)
5ffb3c03:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
5ffb3c06:	85 c9                	test   %ecx,%ecx
5ffb3c08:	75 3e                	jne    5ffb3c48 <_CsrFillOutputAttrib@12+0x148>
    {
      ConioUnlockConsole(Console);
    }

  return Reply->Status = STATUS_SUCCESS;
5ffb3c0a:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb3c0d:	31 c0                	xor    %eax,%eax
5ffb3c0f:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
}
5ffb3c16:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb3c19:	5b                   	pop    %ebx
5ffb3c1a:	5e                   	pop    %esi
5ffb3c1b:	5f                   	pop    %edi
5ffb3c1c:	5d                   	pop    %ebp
5ffb3c1d:	c2 0c 00             	ret    $0xc
5ffb3c20:	8b 56 20             	mov    0x20(%esi),%edx
5ffb3c23:	31 ff                	xor    %edi,%edi
5ffb3c25:	42                   	inc    %edx
5ffb3c26:	31 c9                	xor    %ecx,%ecx
5ffb3c28:	eb b9                	jmp    5ffb3be3 <_CsrFillOutputAttrib@12+0xe3>
5ffb3c2a:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
5ffb3c2d:	85 c9                	test   %ecx,%ecx
5ffb3c2f:	74 05                	je     5ffb3c36 <_CsrFillOutputAttrib@12+0x136>
5ffb3c31:	e8 8a d4 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb3c36:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb3c39:	89 58 18             	mov    %ebx,0x18(%eax)
5ffb3c3c:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb3c3f:	89 d8                	mov    %ebx,%eax
5ffb3c41:	5b                   	pop    %ebx
5ffb3c42:	5e                   	pop    %esi
5ffb3c43:	5f                   	pop    %edi
5ffb3c44:	5d                   	pop    %ebp
5ffb3c45:	c2 0c 00             	ret    $0xc
5ffb3c48:	e8 73 d4 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb3c4d:	eb bb                	jmp    5ffb3c0a <_CsrFillOutputAttrib@12+0x10a>
5ffb3c4f:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb3c52:	8d 5d d8             	lea    0xffffffd8(%ebp),%ebx
5ffb3c55:	89 f1                	mov    %esi,%ecx
5ffb3c57:	66 8b 42 26          	mov    0x26(%edx),%ax
5ffb3c5b:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3c60:	50                   	push   %eax
5ffb3c61:	89 d0                	mov    %edx,%eax
5ffb3c63:	83 c0 22             	add    $0x22,%eax
5ffb3c66:	89 da                	mov    %ebx,%edx
5ffb3c68:	50                   	push   %eax
5ffb3c69:	e8 82 f5 ff ff       	call   5ffb31f0 <@ConioComputeUpdateRect@16>
5ffb3c6e:	50                   	push   %eax
5ffb3c6f:	50                   	push   %eax
5ffb3c70:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
5ffb3c73:	8b 50 70             	mov    0x70(%eax),%edx
5ffb3c76:	53                   	push   %ebx
5ffb3c77:	50                   	push   %eax
5ffb3c78:	ff 52 08             	call   *0x8(%edx)
5ffb3c7b:	5e                   	pop    %esi
5ffb3c7c:	8b 75 d0             	mov    0xffffffd0(%ebp),%esi
5ffb3c7f:	5f                   	pop    %edi
5ffb3c80:	e9 77 ff ff ff       	jmp    5ffb3bfc <_CsrFillOutputAttrib@12+0xfc>
5ffb3c85:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb3c89:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb3c90 <_CsrGetCursorInfo@12>:


CSR_API(CsrGetCursorInfo)
{
5ffb3c90:	55                   	push   %ebp
5ffb3c91:	89 e5                	mov    %esp,%ebp
5ffb3c93:	53                   	push   %ebx
5ffb3c94:	83 ec 0c             	sub    $0xc,%esp
5ffb3c97:	8b 5d 10             	mov    0x10(%ebp),%ebx
  PCSRSS_SCREEN_BUFFER Buff;
  NTSTATUS Status;
   
  DPRINT("CsrGetCursorInfo\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;

  Status = ConioLockScreenBuffer(ProcessData, Request->Data.GetCursorInfoRequest.ConsoleHandle, &Buff);
5ffb3c9a:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb3c9d:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb3ca0:	66 c7 43 02 38 00    	movw   $0x38,0x2(%ebx)
5ffb3ca6:	66 c7 03 20 00       	movw   $0x20,(%ebx)
5ffb3cab:	8b 50 1c             	mov    0x1c(%eax),%edx
5ffb3cae:	8d 45 f8             	lea    0xfffffff8(%ebp),%eax
5ffb3cb1:	6a 02                	push   $0x2
5ffb3cb3:	50                   	push   %eax
5ffb3cb4:	e8 c7 d3 ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
  if (! NT_SUCCESS(Status))
5ffb3cb9:	5a                   	pop    %edx
5ffb3cba:	85 c0                	test   %eax,%eax
5ffb3cbc:	59                   	pop    %ecx
5ffb3cbd:	78 24                	js     5ffb3ce3 <_CsrGetCursorInfo@12+0x53>
    {
      return Reply->Status = Status;
    }
  Reply->Data.GetCursorInfoReply.Info = Buff->CursorInfo;
5ffb3cbf:	8b 4d f8             	mov    0xfffffff8(%ebp),%ecx
5ffb3cc2:	8b 41 38             	mov    0x38(%ecx),%eax
5ffb3cc5:	8b 51 3c             	mov    0x3c(%ecx),%edx
5ffb3cc8:	89 53 20             	mov    %edx,0x20(%ebx)
5ffb3ccb:	89 43 1c             	mov    %eax,0x1c(%ebx)
  ConioUnlockScreenBuffer(Buff);
5ffb3cce:	e8 ed d3 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>

  return Reply->Status = STATUS_SUCCESS;
5ffb3cd3:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
5ffb3cda:	31 c0                	xor    %eax,%eax
}
5ffb3cdc:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb3cdf:	c9                   	leave  
5ffb3ce0:	c2 0c 00             	ret    $0xc
5ffb3ce3:	89 43 18             	mov    %eax,0x18(%ebx)
5ffb3ce6:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb3ce9:	c9                   	leave  
5ffb3cea:	c2 0c 00             	ret    $0xc
5ffb3ced:	8d 76 00             	lea    0x0(%esi),%esi

5ffb3cf0 <_CsrSetCursorInfo@12>:

CSR_API(CsrSetCursorInfo)
{
5ffb3cf0:	55                   	push   %ebp
5ffb3cf1:	89 e5                	mov    %esp,%ebp
5ffb3cf3:	57                   	push   %edi
5ffb3cf4:	56                   	push   %esi
5ffb3cf5:	53                   	push   %ebx
5ffb3cf6:	83 ec 0c             	sub    $0xc,%esp
  PCSRSS_CONSOLE Console;
  PCSRSS_SCREEN_BUFFER Buff;
  DWORD Size;
  BOOL Visible;
  NTSTATUS Status;
   
  DPRINT("CsrSetCursorInfo\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;

  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb3cf9:	8d 55 f0             	lea    0xfffffff0(%ebp),%edx
5ffb3cfc:	8b 7d 10             	mov    0x10(%ebp),%edi
5ffb3cff:	8b 75 0c             	mov    0xc(%ebp),%esi
5ffb3d02:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb3d05:	66 c7 47 02 38 00    	movw   $0x38,0x2(%edi)
5ffb3d0b:	66 c7 07 20 00       	movw   $0x20,(%edi)
5ffb3d10:	e8 ab d4 ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
5ffb3d15:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb3d17:	85 c0                	test   %eax,%eax
5ffb3d19:	78 67                	js     5ffb3d82 <_CsrSetCursorInfo@12+0x92>
    {
      return Reply->Status = Status;
    }

  Status = ConioLockScreenBuffer(ProcessData, Request->Data.SetCursorInfoRequest.ConsoleHandle, &Buff);
5ffb3d1b:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
5ffb3d1e:	51                   	push   %ecx
5ffb3d1f:	51                   	push   %ecx
5ffb3d20:	8b 56 1c             	mov    0x1c(%esi),%edx
5ffb3d23:	6a 02                	push   $0x2
5ffb3d25:	50                   	push   %eax
5ffb3d26:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb3d29:	e8 52 d3 ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
5ffb3d2e:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb3d30:	58                   	pop    %eax
5ffb3d31:	85 db                	test   %ebx,%ebx
5ffb3d33:	5a                   	pop    %edx
5ffb3d34:	78 40                	js     5ffb3d76 <_CsrSetCursorInfo@12+0x86>
    {
      if (NULL != Console)
        {
          ConioUnlockConsole(Console);
        }
      return Reply->Status = Status;
    }

  Size = Request->Data.SetCursorInfoRequest.Info.dwSize;
5ffb3d36:	8b 46 20             	mov    0x20(%esi),%eax
  Visible = Request->Data.SetCursorInfoRequest.Info.bVisible;
5ffb3d39:	8b 56 24             	mov    0x24(%esi),%edx
  if (Size < 1)
5ffb3d3c:	85 c0                	test   %eax,%eax
5ffb3d3e:	75 51                	jne    5ffb3d91 <_CsrSetCursorInfo@12+0xa1>
    {
      Size = 1;
5ffb3d40:	b0 01                	mov    $0x1,%al
    }
  if (100 < Size)
    {
      Size = 100;
    }

  if (Size != Buff->CursorInfo.dwSize
5ffb3d42:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
5ffb3d45:	39 41 38             	cmp    %eax,0x38(%ecx)
5ffb3d48:	74 59                	je     5ffb3da3 <_CsrSetCursorInfo@12+0xb3>
      || (Visible && ! Buff->CursorInfo.bVisible) || (! Visible && Buff->CursorInfo.bVisible))
    {
      Buff->CursorInfo.dwSize = Size;
      Buff->CursorInfo.bVisible = Visible;
5ffb3d4a:	89 51 3c             	mov    %edx,0x3c(%ecx)

      if (NULL != Console && ! ConioSetCursorInfo(Console, Buff))
5ffb3d4d:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
5ffb3d50:	89 41 38             	mov    %eax,0x38(%ecx)
5ffb3d53:	85 d2                	test   %edx,%edx
5ffb3d55:	75 60                	jne    5ffb3db7 <_CsrSetCursorInfo@12+0xc7>
        {
          ConioUnlockScreenBuffer(Buff);
          ConioUnlockConsole(Console);
          return Reply->Status = STATUS_UNSUCCESSFUL;
        }
    }

  ConioUnlockScreenBuffer(Buff);
5ffb3d57:	e8 64 d3 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
  if (NULL != Console)
5ffb3d5c:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb3d5f:	85 c9                	test   %ecx,%ecx
5ffb3d61:	75 4d                	jne    5ffb3db0 <_CsrSetCursorInfo@12+0xc0>
    {
      ConioUnlockConsole(Console);
    }

  return Reply->Status = STATUS_SUCCESS;
5ffb3d63:	c7 47 18 00 00 00 00 	movl   $0x0,0x18(%edi)
5ffb3d6a:	31 c0                	xor    %eax,%eax
}
5ffb3d6c:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb3d6f:	5b                   	pop    %ebx
5ffb3d70:	5e                   	pop    %esi
5ffb3d71:	5f                   	pop    %edi
5ffb3d72:	5d                   	pop    %ebp
5ffb3d73:	c2 0c 00             	ret    $0xc
5ffb3d76:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb3d79:	85 c9                	test   %ecx,%ecx
5ffb3d7b:	74 05                	je     5ffb3d82 <_CsrSetCursorInfo@12+0x92>
5ffb3d7d:	e8 3e d3 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb3d82:	89 5f 18             	mov    %ebx,0x18(%edi)
5ffb3d85:	89 d8                	mov    %ebx,%eax
5ffb3d87:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb3d8a:	5b                   	pop    %ebx
5ffb3d8b:	5e                   	pop    %esi
5ffb3d8c:	5f                   	pop    %edi
5ffb3d8d:	5d                   	pop    %ebp
5ffb3d8e:	c2 0c 00             	ret    $0xc
5ffb3d91:	83 f8 64             	cmp    $0x64,%eax
5ffb3d94:	76 ac                	jbe    5ffb3d42 <_CsrSetCursorInfo@12+0x52>
5ffb3d96:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
5ffb3d99:	b8 64 00 00 00       	mov    $0x64,%eax
5ffb3d9e:	39 41 38             	cmp    %eax,0x38(%ecx)
5ffb3da1:	75 a7                	jne    5ffb3d4a <_CsrSetCursorInfo@12+0x5a>
5ffb3da3:	85 d2                	test   %edx,%edx
5ffb3da5:	74 25                	je     5ffb3dcc <_CsrSetCursorInfo@12+0xdc>
5ffb3da7:	8b 71 3c             	mov    0x3c(%ecx),%esi
5ffb3daa:	85 f6                	test   %esi,%esi
5ffb3dac:	74 9c                	je     5ffb3d4a <_CsrSetCursorInfo@12+0x5a>
5ffb3dae:	eb a7                	jmp    5ffb3d57 <_CsrSetCursorInfo@12+0x67>
5ffb3db0:	e8 0b d3 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb3db5:	eb ac                	jmp    5ffb3d63 <_CsrSetCursorInfo@12+0x73>
5ffb3db7:	50                   	push   %eax
5ffb3db8:	50                   	push   %eax
5ffb3db9:	8b 42 70             	mov    0x70(%edx),%eax
5ffb3dbc:	51                   	push   %ecx
5ffb3dbd:	52                   	push   %edx
5ffb3dbe:	ff 50 0c             	call   *0xc(%eax)
5ffb3dc1:	5b                   	pop    %ebx
5ffb3dc2:	85 c0                	test   %eax,%eax
5ffb3dc4:	5e                   	pop    %esi
5ffb3dc5:	74 11                	je     5ffb3dd8 <_CsrSetCursorInfo@12+0xe8>
5ffb3dc7:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
5ffb3dca:	eb 8b                	jmp    5ffb3d57 <_CsrSetCursorInfo@12+0x67>
5ffb3dcc:	8b 59 3c             	mov    0x3c(%ecx),%ebx
5ffb3dcf:	85 db                	test   %ebx,%ebx
5ffb3dd1:	74 84                	je     5ffb3d57 <_CsrSetCursorInfo@12+0x67>
5ffb3dd3:	e9 72 ff ff ff       	jmp    5ffb3d4a <_CsrSetCursorInfo@12+0x5a>
5ffb3dd8:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
5ffb3ddb:	e8 e0 d2 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb3de0:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb3de3:	e8 d8 d2 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb3de8:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
5ffb3ded:	c7 47 18 01 00 00 c0 	movl   $0xc0000001,0x18(%edi)
5ffb3df4:	e9 73 ff ff ff       	jmp    5ffb3d6c <_CsrSetCursorInfo@12+0x7c>
5ffb3df9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

5ffb3e00 <_CsrSetTextAttrib@12>:

CSR_API(CsrSetTextAttrib)
{
5ffb3e00:	55                   	push   %ebp
5ffb3e01:	89 e5                	mov    %esp,%ebp
5ffb3e03:	57                   	push   %edi
5ffb3e04:	56                   	push   %esi
5ffb3e05:	53                   	push   %ebx
5ffb3e06:	83 ec 1c             	sub    $0x1c,%esp
  NTSTATUS Status;
  PCSRSS_CONSOLE Console;
  PCSRSS_SCREEN_BUFFER Buff;
  LONG OldCursorX, OldCursorY;   

  DPRINT("CsrSetTextAttrib\n");

  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb3e09:	8d 55 f0             	lea    0xfffffff0(%ebp),%edx
5ffb3e0c:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb3e0f:	8b 75 0c             	mov    0xc(%ebp),%esi
5ffb3e12:	8b 7d 10             	mov    0x10(%ebp),%edi
5ffb3e15:	e8 a6 d3 ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
5ffb3e1a:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb3e1c:	85 c0                	test   %eax,%eax
5ffb3e1e:	78 70                	js     5ffb3e90 <_CsrSetTextAttrib@12+0x90>
    {
      return Reply->Status = Status;
    }

  Status = ConioLockScreenBuffer(ProcessData, Request->Data.SetCursorRequest.ConsoleHandle, &Buff);
5ffb3e20:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
5ffb3e23:	51                   	push   %ecx
5ffb3e24:	51                   	push   %ecx
5ffb3e25:	8b 56 1c             	mov    0x1c(%esi),%edx
5ffb3e28:	6a 02                	push   $0x2
5ffb3e2a:	50                   	push   %eax
5ffb3e2b:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb3e2e:	e8 4d d2 ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
5ffb3e33:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb3e35:	58                   	pop    %eax
5ffb3e36:	85 db                	test   %ebx,%ebx
5ffb3e38:	5a                   	pop    %edx
5ffb3e39:	78 49                	js     5ffb3e84 <_CsrSetTextAttrib@12+0x84>
    {
      if (NULL != Console)
        {
          ConioUnlockConsole(Console);
        }
      return Reply->Status = Status;
    }

  ConioPhysicalToLogical(Buff, Buff->CurrentX, Buff->CurrentY, &OldCursorX, &OldCursorY);
5ffb3e3b:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
5ffb3e3e:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
5ffb3e41:	8b 51 2c             	mov    0x2c(%ecx),%edx
5ffb3e44:	50                   	push   %eax
5ffb3e45:	8d 45 e4             	lea    0xffffffe4(%ebp),%eax
5ffb3e48:	50                   	push   %eax
5ffb3e49:	8b 41 30             	mov    0x30(%ecx),%eax
5ffb3e4c:	50                   	push   %eax
5ffb3e4d:	e8 3e d7 ff ff       	call   5ffb1590 <@ConioPhysicalToLogical@20>

  Buff->DefaultAttrib = Request->Data.SetAttribRequest.Attrib;
5ffb3e52:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb3e55:	8a 56 20             	mov    0x20(%esi),%dl
5ffb3e58:	88 50 34             	mov    %dl,0x34(%eax)
  if (NULL != Console && Buff == Console->ActiveBuffer)
5ffb3e5b:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
5ffb3e5e:	85 d2                	test   %edx,%edx
5ffb3e60:	75 3e                	jne    5ffb3ea0 <_CsrSetTextAttrib@12+0xa0>
5ffb3e62:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
    {
      if (! ConioSetScreenInfo(Console, Buff, OldCursorX, OldCursorY))
        {
          ConioUnlockScreenBuffer(Buff);
          ConioUnlockConsole(Console);
          return Reply->Status = STATUS_UNSUCCESSFUL;
        }
    }

  ConioUnlockScreenBuffer(Buff);
5ffb3e65:	e8 56 d2 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
  if (NULL != Console)
5ffb3e6a:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb3e6d:	85 c9                	test   %ecx,%ecx
5ffb3e6f:	75 76                	jne    5ffb3ee7 <_CsrSetTextAttrib@12+0xe7>
    {
      ConioUnlockConsole(Console);
    }

  return Reply->Status = STATUS_SUCCESS;
5ffb3e71:	c7 47 18 00 00 00 00 	movl   $0x0,0x18(%edi)
5ffb3e78:	31 c0                	xor    %eax,%eax
}
5ffb3e7a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb3e7d:	5b                   	pop    %ebx
5ffb3e7e:	5e                   	pop    %esi
5ffb3e7f:	5f                   	pop    %edi
5ffb3e80:	5d                   	pop    %ebp
5ffb3e81:	c2 0c 00             	ret    $0xc
5ffb3e84:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb3e87:	85 c9                	test   %ecx,%ecx
5ffb3e89:	75 55                	jne    5ffb3ee0 <_CsrSetTextAttrib@12+0xe0>
5ffb3e8b:	90                   	nop    
5ffb3e8c:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb3e90:	89 5f 18             	mov    %ebx,0x18(%edi)
5ffb3e93:	89 d8                	mov    %ebx,%eax
5ffb3e95:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb3e98:	5b                   	pop    %ebx
5ffb3e99:	5e                   	pop    %esi
5ffb3e9a:	5f                   	pop    %edi
5ffb3e9b:	5d                   	pop    %ebp
5ffb3e9c:	c2 0c 00             	ret    $0xc
5ffb3e9f:	90                   	nop    
5ffb3ea0:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
5ffb3ea3:	39 4a 38             	cmp    %ecx,0x38(%edx)
5ffb3ea6:	75 bd                	jne    5ffb3e65 <_CsrSetTextAttrib@12+0x65>
5ffb3ea8:	8b 75 e8             	mov    0xffffffe8(%ebp),%esi
5ffb3eab:	8b 42 70             	mov    0x70(%edx),%eax
5ffb3eae:	56                   	push   %esi
5ffb3eaf:	8b 5d e4             	mov    0xffffffe4(%ebp),%ebx
5ffb3eb2:	53                   	push   %ebx
5ffb3eb3:	51                   	push   %ecx
5ffb3eb4:	52                   	push   %edx
5ffb3eb5:	ff 50 10             	call   *0x10(%eax)
5ffb3eb8:	85 c0                	test   %eax,%eax
5ffb3eba:	75 a6                	jne    5ffb3e62 <_CsrSetTextAttrib@12+0x62>
5ffb3ebc:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
5ffb3ebf:	e8 fc d1 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb3ec4:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb3ec7:	e8 f4 d1 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb3ecc:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
5ffb3ed1:	c7 47 18 01 00 00 c0 	movl   $0xc0000001,0x18(%edi)
5ffb3ed8:	eb bb                	jmp    5ffb3e95 <_CsrSetTextAttrib@12+0x95>
5ffb3eda:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb3ee0:	e8 db d1 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb3ee5:	eb a9                	jmp    5ffb3e90 <_CsrSetTextAttrib@12+0x90>
5ffb3ee7:	e8 d4 d1 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb3eec:	eb 83                	jmp    5ffb3e71 <_CsrSetTextAttrib@12+0x71>
5ffb3eee:	89 f6                	mov    %esi,%esi

5ffb3ef0 <_CsrSetConsoleMode@12>:

CSR_API(CsrSetConsoleMode)
{
5ffb3ef0:	55                   	push   %ebp
5ffb3ef1:	89 e5                	mov    %esp,%ebp
5ffb3ef3:	56                   	push   %esi
5ffb3ef4:	53                   	push   %ebx
5ffb3ef5:	83 ec 1c             	sub    $0x1c,%esp
  NTSTATUS Status;
  PCSRSS_CONSOLE Console;
  PCSRSS_SCREEN_BUFFER Buff;

  DPRINT("CsrSetConsoleMode\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
  Status = Win32CsrGetObject(ProcessData,
5ffb3ef8:	8d 45 f4             	lea    0xfffffff4(%ebp),%eax
5ffb3efb:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb3efe:	8b 75 0c             	mov    0xc(%ebp),%esi
5ffb3f01:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb3f04:	66 c7 43 02 38 00    	movw   $0x38,0x2(%ebx)
5ffb3f0a:	66 c7 03 20 00       	movw   $0x20,(%ebx)
5ffb3f0f:	8b 56 1c             	mov    0x1c(%esi),%edx
5ffb3f12:	50                   	push   %eax
5ffb3f13:	e8 48 d1 ff ff       	call   5ffb1060 <@Win32CsrGetObject@12>
                             Request->Data.SetConsoleModeRequest.ConsoleHandle,
                             (Object_t **) &Console);
  if (! NT_SUCCESS(Status))
5ffb3f18:	83 c4 0c             	add    $0xc,%esp
5ffb3f1b:	85 c0                	test   %eax,%eax
5ffb3f1d:	78 41                	js     5ffb3f60 <_CsrSetConsoleMode@12+0x70>
    {
      return Reply->Status = Status;
    }

  Buff = (PCSRSS_SCREEN_BUFFER)Console;
5ffb3f1f:	8b 55 f4             	mov    0xfffffff4(%ebp),%edx
  if (CONIO_CONSOLE_MAGIC == Console->Header.Type)
5ffb3f22:	8b 02                	mov    (%edx),%eax
5ffb3f24:	83 f8 01             	cmp    $0x1,%eax
5ffb3f27:	74 27                	je     5ffb3f50 <_CsrSetConsoleMode@12+0x60>
    {
      Console->Mode = Request->Data.SetConsoleModeRequest.Mode & CONSOLE_INPUT_MODE_VALID;
    }
  else if (CONIO_SCREEN_BUFFER_MAGIC == Console->Header.Type)
5ffb3f29:	83 f8 02             	cmp    $0x2,%eax
5ffb3f2c:	75 3e                	jne    5ffb3f6c <_CsrSetConsoleMode@12+0x7c>
    {
      Buff->Mode = Request->Data.SetConsoleModeRequest.Mode & CONSOLE_OUTPUT_MODE_VALID;
5ffb3f2e:	66 8b 46 20          	mov    0x20(%esi),%ax
5ffb3f32:	83 e0 03             	and    $0x3,%eax
5ffb3f35:	66 89 42 40          	mov    %ax,0x40(%edx)
    }
  else
    {
      return Reply->Status = STATUS_INVALID_HANDLE;
    }

  Reply->Status = STATUS_SUCCESS;
5ffb3f39:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)

  return Reply->Status;
5ffb3f40:	31 c0                	xor    %eax,%eax
}
5ffb3f42:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb3f45:	5b                   	pop    %ebx
5ffb3f46:	5e                   	pop    %esi
5ffb3f47:	5d                   	pop    %ebp
5ffb3f48:	c2 0c 00             	ret    $0xc
5ffb3f4b:	90                   	nop    
5ffb3f4c:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb3f50:	66 8b 46 20          	mov    0x20(%esi),%ax
5ffb3f54:	83 e0 0f             	and    $0xf,%eax
5ffb3f57:	66 89 42 3c          	mov    %ax,0x3c(%edx)
5ffb3f5b:	eb dc                	jmp    5ffb3f39 <_CsrSetConsoleMode@12+0x49>
5ffb3f5d:	8d 76 00             	lea    0x0(%esi),%esi
5ffb3f60:	89 43 18             	mov    %eax,0x18(%ebx)
5ffb3f63:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb3f66:	5b                   	pop    %ebx
5ffb3f67:	5e                   	pop    %esi
5ffb3f68:	5d                   	pop    %ebp
5ffb3f69:	c2 0c 00             	ret    $0xc
5ffb3f6c:	b8 08 00 00 c0       	mov    $0xc0000008,%eax
5ffb3f71:	c7 43 18 08 00 00 c0 	movl   $0xc0000008,0x18(%ebx)
5ffb3f78:	eb c8                	jmp    5ffb3f42 <_CsrSetConsoleMode@12+0x52>
5ffb3f7a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

5ffb3f80 <_CsrGetConsoleMode@12>:

CSR_API(CsrGetConsoleMode)
{
5ffb3f80:	55                   	push   %ebp
5ffb3f81:	89 e5                	mov    %esp,%ebp
5ffb3f83:	53                   	push   %ebx
5ffb3f84:	83 ec 10             	sub    $0x10,%esp
5ffb3f87:	8b 5d 10             	mov    0x10(%ebp),%ebx
  NTSTATUS Status;
  PCSRSS_CONSOLE Console;
  PCSRSS_SCREEN_BUFFER Buff;   /* gee, I really wish I could use an anonymous union here */

  DPRINT("CsrGetConsoleMode\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
  Status = Win32CsrGetObject(ProcessData, Request->Data.GetConsoleModeRequest.ConsoleHandle,
5ffb3f8a:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb3f8d:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb3f90:	66 c7 43 02 38 00    	movw   $0x38,0x2(%ebx)
5ffb3f96:	66 c7 03 20 00       	movw   $0x20,(%ebx)
5ffb3f9b:	8b 50 1c             	mov    0x1c(%eax),%edx
5ffb3f9e:	8d 45 f8             	lea    0xfffffff8(%ebp),%eax
5ffb3fa1:	50                   	push   %eax
5ffb3fa2:	e8 b9 d0 ff ff       	call   5ffb1060 <@Win32CsrGetObject@12>
                             (Object_t **) &Console);
  if (! NT_SUCCESS(Status))
5ffb3fa7:	83 c4 0c             	add    $0xc,%esp
5ffb3faa:	85 c0                	test   %eax,%eax
5ffb3fac:	78 35                	js     5ffb3fe3 <_CsrGetConsoleMode@12+0x63>
    {
      return Reply->Status = Status;
    }
  Reply->Status = STATUS_SUCCESS;
  Buff = (PCSRSS_SCREEN_BUFFER) Console;
5ffb3fae:	8b 55 f8             	mov    0xfffffff8(%ebp),%edx
5ffb3fb1:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
  if (CONIO_CONSOLE_MAGIC == Console->Header.Type)
5ffb3fb8:	8b 02                	mov    (%edx),%eax
5ffb3fba:	83 f8 01             	cmp    $0x1,%eax
5ffb3fbd:	74 16                	je     5ffb3fd5 <_CsrGetConsoleMode@12+0x55>
    {
      Reply->Data.GetConsoleModeReply.ConsoleMode = Console->Mode;
    }
  else if (CONIO_SCREEN_BUFFER_MAGIC == Buff->Header.Type)
5ffb3fbf:	83 f8 02             	cmp    $0x2,%eax
5ffb3fc2:	74 2c                	je     5ffb3ff0 <_CsrGetConsoleMode@12+0x70>
    {
      Reply->Data.GetConsoleModeReply.ConsoleMode = Buff->Mode;
    }
  else
    {
      Reply->Status = STATUS_INVALID_HANDLE;
5ffb3fc4:	c7 43 18 08 00 00 c0 	movl   $0xc0000008,0x18(%ebx)
    }

  return Reply->Status;
5ffb3fcb:	8b 43 18             	mov    0x18(%ebx),%eax
}
5ffb3fce:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb3fd1:	c9                   	leave  
5ffb3fd2:	c2 0c 00             	ret    $0xc
5ffb3fd5:	66 8b 42 3c          	mov    0x3c(%edx),%ax
5ffb3fd9:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb3fde:	89 43 1c             	mov    %eax,0x1c(%ebx)
5ffb3fe1:	eb e8                	jmp    5ffb3fcb <_CsrGetConsoleMode@12+0x4b>
5ffb3fe3:	89 43 18             	mov    %eax,0x18(%ebx)
5ffb3fe6:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb3fe9:	c9                   	leave  
5ffb3fea:	c2 0c 00             	ret    $0xc
5ffb3fed:	8d 76 00             	lea    0x0(%esi),%esi
5ffb3ff0:	66 8b 42 40          	mov    0x40(%edx),%ax
5ffb3ff4:	eb e3                	jmp    5ffb3fd9 <_CsrGetConsoleMode@12+0x59>
5ffb3ff6:	8d 76 00             	lea    0x0(%esi),%esi
5ffb3ff9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb4000 <_CsrCreateScreenBuffer@12>:

CSR_API(CsrCreateScreenBuffer)
{
5ffb4000:	55                   	push   %ebp
5ffb4001:	89 e5                	mov    %esp,%ebp
5ffb4003:	57                   	push   %edi
5ffb4004:	56                   	push   %esi
5ffb4005:	53                   	push   %ebx
5ffb4006:	83 ec 0c             	sub    $0xc,%esp
5ffb4009:	8b 75 08             	mov    0x8(%ebp),%esi
5ffb400c:	8b 7d 10             	mov    0x10(%ebp),%edi
  PCSRSS_CONSOLE Console;
  PCSRSS_SCREEN_BUFFER Buff;
  NTSTATUS Status;
   
  DPRINT("CsrCreateScreenBuffer\n");

  if (ProcessData == NULL)
5ffb400f:	85 f6                	test   %esi,%esi
5ffb4011:	0f 84 a0 00 00 00    	je     5ffb40b7 <_CsrCreateScreenBuffer@12+0xb7>
    {
      return Reply->Status = STATUS_INVALID_PARAMETER;
    }

  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb4017:	8d 55 f0             	lea    0xfffffff0(%ebp),%edx
5ffb401a:	89 f1                	mov    %esi,%ecx
5ffb401c:	e8 9f d1 ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
  if (! NT_SUCCESS(Status))
5ffb4021:	85 c0                	test   %eax,%eax
5ffb4023:	78 6b                	js     5ffb4090 <_CsrCreateScreenBuffer@12+0x90>
    {
      return Reply->Status = Status;
    }
  if (NULL == Console)
5ffb4025:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
5ffb4028:	85 c0                	test   %eax,%eax
5ffb402a:	74 7d                	je     5ffb40a9 <_CsrCreateScreenBuffer@12+0xa9>
    {
      return Reply->Status = STATUS_INVALID_HANDLE;
    }

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
5ffb402c:	66 c7 47 02 38 00    	movw   $0x38,0x2(%edi)
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
5ffb4032:	66 c7 07 20 00       	movw   $0x20,(%edi)

  Buff = HeapAlloc(Win32CsrApiHeap, 0, sizeof(CSRSS_SCREEN_BUFFER));
5ffb4037:	50                   	push   %eax
5ffb4038:	6a 44                	push   $0x44
5ffb403a:	6a 00                	push   $0x0
5ffb403c:	a1 e0 c1 fb 5f       	mov    0x5ffbc1e0,%eax
5ffb4041:	50                   	push   %eax
5ffb4042:	e8 a9 4c 00 00       	call   5ffb8cf0 <_HeapAlloc@12>
5ffb4047:	89 c3                	mov    %eax,%ebx
  if (NULL == Buff)
5ffb4049:	58                   	pop    %eax
5ffb404a:	85 db                	test   %ebx,%ebx
5ffb404c:	74 52                	je     5ffb40a0 <_CsrCreateScreenBuffer@12+0xa0>
    {
      Reply->Status = STATUS_INSUFFICIENT_RESOURCES;
    }

  Status = CsrInitConsoleScreenBuffer(Console, Buff);
5ffb404e:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb4051:	89 da                	mov    %ebx,%edx
5ffb4053:	e8 08 d3 ff ff       	call   5ffb1360 <@CsrInitConsoleScreenBuffer@8>
  if(! NT_SUCCESS(Status))
5ffb4058:	85 c0                	test   %eax,%eax
5ffb405a:	78 29                	js     5ffb4085 <_CsrCreateScreenBuffer@12+0x85>
    {
      Reply->Status = Status;
    }
  else
    {
      Reply->Status = Win32CsrInsertObject(ProcessData, &Reply->Data.CreateScreenBufferReply.OutputHandle, &Buff->Header);
5ffb405c:	83 ec 0c             	sub    $0xc,%esp
5ffb405f:	8d 57 1c             	lea    0x1c(%edi),%edx
5ffb4062:	89 f1                	mov    %esi,%ecx
5ffb4064:	53                   	push   %ebx
5ffb4065:	e8 c6 cf ff ff       	call   5ffb1030 <@Win32CsrInsertObject@12>
5ffb406a:	83 c4 0c             	add    $0xc,%esp
5ffb406d:	89 47 18             	mov    %eax,0x18(%edi)
    }

  ConioUnlockConsole(Console);
5ffb4070:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb4073:	e8 48 d0 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>

  return Reply->Status;
5ffb4078:	8b 47 18             	mov    0x18(%edi),%eax
}
5ffb407b:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb407e:	5b                   	pop    %ebx
5ffb407f:	5e                   	pop    %esi
5ffb4080:	5f                   	pop    %edi
5ffb4081:	5d                   	pop    %ebp
5ffb4082:	c2 0c 00             	ret    $0xc
5ffb4085:	89 47 18             	mov    %eax,0x18(%edi)
5ffb4088:	eb e6                	jmp    5ffb4070 <_CsrCreateScreenBuffer@12+0x70>
5ffb408a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb4090:	89 47 18             	mov    %eax,0x18(%edi)
5ffb4093:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb4096:	5b                   	pop    %ebx
5ffb4097:	5e                   	pop    %esi
5ffb4098:	5f                   	pop    %edi
5ffb4099:	5d                   	pop    %ebp
5ffb409a:	c2 0c 00             	ret    $0xc
5ffb409d:	8d 76 00             	lea    0x0(%esi),%esi
5ffb40a0:	c7 47 18 9a 00 00 c0 	movl   $0xc000009a,0x18(%edi)
5ffb40a7:	eb a5                	jmp    5ffb404e <_CsrCreateScreenBuffer@12+0x4e>
5ffb40a9:	b8 08 00 00 c0       	mov    $0xc0000008,%eax
5ffb40ae:	c7 47 18 08 00 00 c0 	movl   $0xc0000008,0x18(%edi)
5ffb40b5:	eb c4                	jmp    5ffb407b <_CsrCreateScreenBuffer@12+0x7b>
5ffb40b7:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
5ffb40bc:	c7 47 18 0d 00 00 c0 	movl   $0xc000000d,0x18(%edi)
5ffb40c3:	eb b6                	jmp    5ffb407b <_CsrCreateScreenBuffer@12+0x7b>
5ffb40c5:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb40c9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb40d0 <_CsrSetScreenBuffer@12>:

CSR_API(CsrSetScreenBuffer)
{
5ffb40d0:	55                   	push   %ebp
5ffb40d1:	89 e5                	mov    %esp,%ebp
5ffb40d3:	53                   	push   %ebx
5ffb40d4:	83 ec 14             	sub    $0x14,%esp
  NTSTATUS Status;
  PCSRSS_CONSOLE Console;
  PCSRSS_SCREEN_BUFFER Buff;

  DPRINT("CsrSetScreenBuffer\n");

  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb40d7:	8d 55 f8             	lea    0xfffffff8(%ebp),%edx
5ffb40da:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb40dd:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb40e0:	e8 db d0 ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
  if (! NT_SUCCESS(Status))
5ffb40e5:	85 c0                	test   %eax,%eax
5ffb40e7:	0f 88 94 00 00 00    	js     5ffb4181 <_CsrSetScreenBuffer@12+0xb1>
    {
      return Reply->Status = Status;
    }
  if (NULL == Console)
5ffb40ed:	8b 45 f8             	mov    0xfffffff8(%ebp),%eax
5ffb40f0:	85 c0                	test   %eax,%eax
5ffb40f2:	0f 84 c9 00 00 00    	je     5ffb41c1 <_CsrSetScreenBuffer@12+0xf1>
    {
      DPRINT1("Trying to set screen buffer for app without console\n");
      return Reply->Status = STATUS_INVALID_HANDLE;
    }

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
5ffb40f8:	66 c7 43 02 38 00    	movw   $0x38,0x2(%ebx)
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
5ffb40fe:	66 c7 03 20 00       	movw   $0x20,(%ebx)

  Status = ConioLockScreenBuffer(ProcessData, Request->Data.SetScreenBufferRequest.OutputHandle, &Buff);
5ffb4103:	50                   	push   %eax
5ffb4104:	50                   	push   %eax
5ffb4105:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb4108:	8b 50 1c             	mov    0x1c(%eax),%edx
5ffb410b:	8d 45 f4             	lea    0xfffffff4(%ebp),%eax
5ffb410e:	6a 02                	push   $0x2
5ffb4110:	50                   	push   %eax
5ffb4111:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb4114:	e8 67 cf ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
  if (! NT_SUCCESS(Status))
5ffb4119:	5a                   	pop    %edx
5ffb411a:	85 c0                	test   %eax,%eax
5ffb411c:	59                   	pop    %ecx
5ffb411d:	0f 88 91 00 00 00    	js     5ffb41b4 <_CsrSetScreenBuffer@12+0xe4>
    {
      ConioUnlockConsole(Console);
      return Reply->Status;
    }

  if (Buff == Console->ActiveBuffer)
5ffb4123:	8b 45 f8             	mov    0xfffffff8(%ebp),%eax
5ffb4126:	8b 48 38             	mov    0x38(%eax),%ecx
5ffb4129:	3b 4d f4             	cmp    0xfffffff4(%ebp),%ecx
5ffb412c:	74 62                	je     5ffb4190 <_CsrSetScreenBuffer@12+0xc0>
    {
      ConioUnlockScreenBuffer(Buff);
      ConioUnlockConsole(Console);
      return STATUS_SUCCESS;
    }

  /* drop reference to old buffer, maybe delete */
  if (! InterlockedDecrement(&Console->ActiveBuffer->Header.ReferenceCount))
5ffb412e:	83 ec 0c             	sub    $0xc,%esp
5ffb4131:	8d 41 04             	lea    0x4(%ecx),%eax
5ffb4134:	50                   	push   %eax
5ffb4135:	e8 56 4c 00 00       	call   5ffb8d90 <_InterlockedDecrement@4>
5ffb413a:	83 c4 0c             	add    $0xc,%esp
5ffb413d:	85 c0                	test   %eax,%eax
5ffb413f:	74 5f                	je     5ffb41a0 <_CsrSetScreenBuffer@12+0xd0>
    {
      ConioDeleteScreenBuffer((Object_t *) Console->ActiveBuffer);
    }
  /* tie console to new buffer */
  Console->ActiveBuffer = Buff;
5ffb4141:	8b 55 f8             	mov    0xfffffff8(%ebp),%edx
5ffb4144:	8b 45 f4             	mov    0xfffffff4(%ebp),%eax
  /* inc ref count on new buffer */
  InterlockedIncrement(&Buff->Header.ReferenceCount);
5ffb4147:	83 ec 0c             	sub    $0xc,%esp
5ffb414a:	89 42 38             	mov    %eax,0x38(%edx)
5ffb414d:	83 c0 04             	add    $0x4,%eax
5ffb4150:	50                   	push   %eax
5ffb4151:	e8 4a 4c 00 00       	call   5ffb8da0 <_InterlockedIncrement@4>
  /* Redraw the console */
  ConioDrawConsole(Console);
5ffb4156:	8b 4d f8             	mov    0xfffffff8(%ebp),%ecx
5ffb4159:	83 c4 0c             	add    $0xc,%esp
5ffb415c:	e8 ef d2 ff ff       	call   5ffb1450 <@ConioDrawConsole@4>

  ConioUnlockScreenBuffer(Buff);
5ffb4161:	8b 4d f4             	mov    0xfffffff4(%ebp),%ecx
5ffb4164:	e8 57 cf ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
  ConioUnlockConsole(Console);
5ffb4169:	8b 4d f8             	mov    0xfffffff8(%ebp),%ecx
5ffb416c:	e8 4f cf ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>

  return Reply->Status = STATUS_SUCCESS;
5ffb4171:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
5ffb4178:	31 c0                	xor    %eax,%eax
}
5ffb417a:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb417d:	c9                   	leave  
5ffb417e:	c2 0c 00             	ret    $0xc
5ffb4181:	89 43 18             	mov    %eax,0x18(%ebx)
5ffb4184:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb4187:	c9                   	leave  
5ffb4188:	c2 0c 00             	ret    $0xc
5ffb418b:	90                   	nop    
5ffb418c:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb4190:	e8 2b cf ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb4195:	8b 4d f8             	mov    0xfffffff8(%ebp),%ecx
5ffb4198:	e8 23 cf ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb419d:	eb d9                	jmp    5ffb4178 <_CsrSetScreenBuffer@12+0xa8>
5ffb419f:	90                   	nop    
5ffb41a0:	8b 45 f8             	mov    0xfffffff8(%ebp),%eax
5ffb41a3:	83 ec 0c             	sub    $0xc,%esp
5ffb41a6:	8b 40 38             	mov    0x38(%eax),%eax
5ffb41a9:	50                   	push   %eax
5ffb41aa:	e8 b1 df ff ff       	call   5ffb2160 <_ConioDeleteScreenBuffer@4>
5ffb41af:	83 c4 0c             	add    $0xc,%esp
5ffb41b2:	eb 8d                	jmp    5ffb4141 <_CsrSetScreenBuffer@12+0x71>
5ffb41b4:	8b 4d f8             	mov    0xfffffff8(%ebp),%ecx
5ffb41b7:	e8 04 cf ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb41bc:	8b 43 18             	mov    0x18(%ebx),%eax
5ffb41bf:	eb b9                	jmp    5ffb417a <_CsrSetScreenBuffer@12+0xaa>
5ffb41c1:	50                   	push   %eax
5ffb41c2:	68 88 08 00 00       	push   $0x888
5ffb41c7:	68 40 b0 fb 5f       	push   $0x5ffbb040
5ffb41cc:	68 48 b0 fb 5f       	push   $0x5ffbb048
5ffb41d1:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb41d7:	c7 04 24 c4 b1 fb 5f 	movl   $0x5ffbb1c4,(%esp)
5ffb41de:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb41e4:	b8 08 00 00 c0       	mov    $0xc0000008,%eax
5ffb41e9:	c7 43 18 08 00 00 c0 	movl   $0xc0000008,0x18(%ebx)
5ffb41f0:	eb 88                	jmp    5ffb417a <_CsrSetScreenBuffer@12+0xaa>
5ffb41f2:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
5ffb41f9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb4200 <_CsrSetTitle@12>:

CSR_API(CsrSetTitle)
{
5ffb4200:	55                   	push   %ebp
5ffb4201:	89 e5                	mov    %esp,%ebp
5ffb4203:	56                   	push   %esi
5ffb4204:	53                   	push   %ebx
5ffb4205:	83 ec 10             	sub    $0x10,%esp
5ffb4208:	8b 75 10             	mov    0x10(%ebp),%esi
5ffb420b:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb420e:	8b 4d 08             	mov    0x8(%ebp),%ecx
  NTSTATUS Status;
  PCSRSS_CONSOLE Console;

  DPRINT("CsrSetTitle\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
5ffb4211:	66 c7 06 20 00       	movw   $0x20,(%esi)
5ffb4216:	66 c7 46 02 38 00    	movw   $0x38,0x2(%esi)

  if (Request->Header.DataSize
5ffb421c:	66 8b 03             	mov    (%ebx),%ax
5ffb421f:	8b 53 20             	mov    0x20(%ebx),%edx
5ffb4222:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb4227:	83 c2 0b             	add    $0xb,%edx
5ffb422a:	39 d0                	cmp    %edx,%eax
5ffb422c:	72 66                	jb     5ffb4294 <_CsrSetTitle@12+0x94>
      < sizeof(CSRSS_SET_TITLE_REQUEST) - 1
        + Request->Data.SetTitleRequest.Length)
    {
      DPRINT1("Invalid request size\n");
      return Reply->Status = STATUS_INVALID_PARAMETER;
    }

  Status = ConioLockConsole(ProcessData, Request->Data.SetTitleRequest.Console, &Console);
5ffb422e:	50                   	push   %eax
5ffb422f:	50                   	push   %eax
5ffb4230:	8d 45 f4             	lea    0xfffffff4(%ebp),%eax
5ffb4233:	8b 53 1c             	mov    0x1c(%ebx),%edx
5ffb4236:	6a 01                	push   $0x1
5ffb4238:	50                   	push   %eax
5ffb4239:	e8 42 ce ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
  if(! NT_SUCCESS(Status))
5ffb423e:	5a                   	pop    %edx
5ffb423f:	85 c0                	test   %eax,%eax
5ffb4241:	59                   	pop    %ecx
5ffb4242:	78 39                	js     5ffb427d <_CsrSetTitle@12+0x7d>
    {
      Reply->Status = Status;  
    }
  else
    {
      /* copy title to console */
      RtlFreeUnicodeString(&Console->Title);
5ffb4244:	83 ec 0c             	sub    $0xc,%esp
5ffb4247:	8b 45 f4             	mov    0xfffffff4(%ebp),%eax
5ffb424a:	83 c0 40             	add    $0x40,%eax
5ffb424d:	50                   	push   %eax
5ffb424e:	e8 bd 49 00 00       	call   5ffb8c10 <_RtlFreeUnicodeString@4>
      RtlCreateUnicodeString(&Console->Title, Request->Data.SetTitleRequest.Title);
5ffb4253:	8d 43 24             	lea    0x24(%ebx),%eax
5ffb4256:	89 04 24             	mov    %eax,(%esp)
5ffb4259:	8b 45 f4             	mov    0xfffffff4(%ebp),%eax
5ffb425c:	83 c0 40             	add    $0x40,%eax
5ffb425f:	50                   	push   %eax
5ffb4260:	e8 bb 49 00 00       	call   5ffb8c20 <_RtlCreateUnicodeString@8>
      if (! ConioChangeTitle(Console))
5ffb4265:	50                   	push   %eax
5ffb4266:	8b 45 f4             	mov    0xfffffff4(%ebp),%eax
5ffb4269:	8b 50 70             	mov    0x70(%eax),%edx
5ffb426c:	50                   	push   %eax
5ffb426d:	ff 52 14             	call   *0x14(%edx)
5ffb4270:	83 c4 0c             	add    $0xc,%esp
        {
          Reply->Status = STATUS_UNSUCCESSFUL;
5ffb4273:	83 f8 01             	cmp    $0x1,%eax
5ffb4276:	19 c0                	sbb    %eax,%eax
5ffb4278:	25 01 00 00 c0       	and    $0xc0000001,%eax
5ffb427d:	89 46 18             	mov    %eax,0x18(%esi)
        }
      else
        {
          Reply->Status = STATUS_SUCCESS;
        }
    }
  ConioUnlockConsole(Console);
5ffb4280:	8b 4d f4             	mov    0xfffffff4(%ebp),%ecx
5ffb4283:	e8 38 ce ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>

  return Reply->Status;
5ffb4288:	8b 46 18             	mov    0x18(%esi),%eax
}
5ffb428b:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb428e:	5b                   	pop    %ebx
5ffb428f:	5e                   	pop    %esi
5ffb4290:	5d                   	pop    %ebp
5ffb4291:	c2 0c 00             	ret    $0xc
5ffb4294:	50                   	push   %eax
5ffb4295:	68 bd 08 00 00       	push   $0x8bd
5ffb429a:	68 40 b0 fb 5f       	push   $0x5ffbb040
5ffb429f:	68 48 b0 fb 5f       	push   $0x5ffbb048
5ffb42a4:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb42aa:	c7 04 24 aa b0 fb 5f 	movl   $0x5ffbb0aa,(%esp)
5ffb42b1:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb42b7:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
5ffb42bc:	c7 46 18 0d 00 00 c0 	movl   $0xc000000d,0x18(%esi)
5ffb42c3:	eb c6                	jmp    5ffb428b <_CsrSetTitle@12+0x8b>
5ffb42c5:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb42c9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb42d0 <_CsrGetTitle@12>:

CSR_API(CsrGetTitle)
{
5ffb42d0:	55                   	push   %ebp
5ffb42d1:	89 e5                	mov    %esp,%ebp
5ffb42d3:	57                   	push   %edi
5ffb42d4:	56                   	push   %esi
5ffb42d5:	53                   	push   %ebx
5ffb42d6:	83 ec 14             	sub    $0x14,%esp
  NTSTATUS Status;
  PCSRSS_CONSOLE Console;
  
  DPRINT("CsrGetTitle\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
  Status = ConioLockConsole(ProcessData,
5ffb42d9:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
5ffb42dc:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb42df:	8b 75 0c             	mov    0xc(%ebp),%esi
5ffb42e2:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb42e5:	66 c7 43 02 38 00    	movw   $0x38,0x2(%ebx)
5ffb42eb:	66 c7 03 20 00       	movw   $0x20,(%ebx)
5ffb42f0:	8b 56 1c             	mov    0x1c(%esi),%edx
5ffb42f3:	6a 01                	push   $0x1
5ffb42f5:	50                   	push   %eax
5ffb42f6:	e8 85 cd ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
5ffb42fb:	89 c7                	mov    %eax,%edi
                            Request->Data.GetTitleRequest.ConsoleHandle,
                            &Console);
  if (! NT_SUCCESS(Status))
5ffb42fd:	58                   	pop    %eax
5ffb42fe:	85 ff                	test   %edi,%edi
5ffb4300:	5a                   	pop    %edx
5ffb4301:	78 5d                	js     5ffb4360 <_CsrGetTitle@12+0x90>
    {
      DPRINT1("Can't get console\n");
      return Reply->Status = Status;
    }
		
  /* Copy title of the console to the user title buffer */
  RtlZeroMemory(&Reply->Data.GetTitleReply, sizeof(CSRSS_GET_TITLE_REPLY));
5ffb4303:	fc                   	cld    
5ffb4304:	8d 7b 1c             	lea    0x1c(%ebx),%edi
5ffb4307:	31 c0                	xor    %eax,%eax
5ffb4309:	b9 03 00 00 00       	mov    $0x3,%ecx
5ffb430e:	f3 ab                	repz stos %eax,%es:(%edi)
  Reply->Data.GetTitleReply.ConsoleHandle = Request->Data.GetTitleRequest.ConsoleHandle;
  Reply->Data.GetTitleReply.Length = Console->Title.Length;
5ffb4310:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
5ffb4313:	8b 46 1c             	mov    0x1c(%esi),%eax
5ffb4316:	89 43 1c             	mov    %eax,0x1c(%ebx)
5ffb4319:	66 8b 42 40          	mov    0x40(%edx),%ax
5ffb431d:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb4322:	89 43 20             	mov    %eax,0x20(%ebx)
  wcscpy (Reply->Data.GetTitleReply.Title, Console->Title.Buffer);
5ffb4325:	50                   	push   %eax
5ffb4326:	50                   	push   %eax
5ffb4327:	8b 42 44             	mov    0x44(%edx),%eax
5ffb432a:	50                   	push   %eax
5ffb432b:	8d 43 24             	lea    0x24(%ebx),%eax
5ffb432e:	50                   	push   %eax
5ffb432f:	e8 0c 49 00 00       	call   5ffb8c40 <_wcscpy>
  Reply->Header.MessageSize += Console->Title.Length;
5ffb4334:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb4337:	66 8b 41 40          	mov    0x40(%ecx),%ax
5ffb433b:	66 01 43 02          	add    %ax,0x2(%ebx)
  Reply->Header.DataSize += Console->Title.Length;
5ffb433f:	66 8b 41 40          	mov    0x40(%ecx),%ax
  Reply->Status = STATUS_SUCCESS;
5ffb4343:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
5ffb434a:	66 01 03             	add    %ax,(%ebx)

  ConioUnlockConsole(Console);
5ffb434d:	e8 6e cd ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>

  return Reply->Status;
5ffb4352:	8b 43 18             	mov    0x18(%ebx),%eax
}
5ffb4355:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb4358:	5b                   	pop    %ebx
5ffb4359:	5e                   	pop    %esi
5ffb435a:	5f                   	pop    %edi
5ffb435b:	5d                   	pop    %ebp
5ffb435c:	c2 0c 00             	ret    $0xc
5ffb435f:	90                   	nop    
5ffb4360:	50                   	push   %eax
5ffb4361:	68 e7 08 00 00       	push   $0x8e7
5ffb4366:	68 40 b0 fb 5f       	push   $0x5ffbb040
5ffb436b:	68 48 b0 fb 5f       	push   $0x5ffbb048
5ffb4370:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb4376:	c7 04 24 f9 b1 fb 5f 	movl   $0x5ffbb1f9,(%esp)
5ffb437d:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb4383:	89 7b 18             	mov    %edi,0x18(%ebx)
5ffb4386:	89 f8                	mov    %edi,%eax
5ffb4388:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb438b:	5b                   	pop    %ebx
5ffb438c:	5e                   	pop    %esi
5ffb438d:	5f                   	pop    %edi
5ffb438e:	5d                   	pop    %ebp
5ffb438f:	c2 0c 00             	ret    $0xc
5ffb4392:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
5ffb4399:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb43a0 <_CsrWriteConsoleOutput@12>:

CSR_API(CsrWriteConsoleOutput)
{
5ffb43a0:	55                   	push   %ebp
5ffb43a1:	89 e5                	mov    %esp,%ebp
5ffb43a3:	57                   	push   %edi
5ffb43a4:	56                   	push   %esi
5ffb43a5:	53                   	push   %ebx
5ffb43a6:	83 ec 5c             	sub    $0x5c,%esp
  SHORT i, X, Y, SizeX, SizeY;
  PCSRSS_CONSOLE Console;
  PCSRSS_SCREEN_BUFFER Buff;
  RECT ScreenBuffer;
  CHAR_INFO* CurCharInfo;
  RECT WriteRegion;
  CHAR_INFO* CharInfo;
  COORD BufferCoord;
  COORD BufferSize;
  NTSTATUS Status;
  DWORD Offset;
  DWORD PSize;

  DPRINT("CsrWriteConsoleOutput\n");

  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb43a9:	8d 55 c4             	lea    0xffffffc4(%ebp),%edx
5ffb43ac:	8b 75 08             	mov    0x8(%ebp),%esi
5ffb43af:	89 f1                	mov    %esi,%ecx
5ffb43b1:	e8 0a ce ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
5ffb43b6:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb43b8:	85 c0                	test   %eax,%eax
5ffb43ba:	0f 88 9a 00 00 00    	js     5ffb445a <_CsrWriteConsoleOutput@12+0xba>
    {
      return Reply->Status = Status;
    }

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
5ffb43c0:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb43c3:	66 c7 42 02 38 00    	movw   $0x38,0x2(%edx)
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
5ffb43c9:	66 c7 02 20 00       	movw   $0x20,(%edx)
  Status = ConioLockScreenBuffer(ProcessData,
5ffb43ce:	50                   	push   %eax
5ffb43cf:	50                   	push   %eax
5ffb43d0:	8b 4d 0c             	mov    0xc(%ebp),%ecx
5ffb43d3:	8d 45 c0             	lea    0xffffffc0(%ebp),%eax
5ffb43d6:	8b 51 1c             	mov    0x1c(%ecx),%edx
5ffb43d9:	89 f1                	mov    %esi,%ecx
5ffb43db:	6a 02                	push   $0x2
5ffb43dd:	50                   	push   %eax
5ffb43de:	e8 9d cc ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
5ffb43e3:	89 c3                	mov    %eax,%ebx
                                 Request->Data.WriteConsoleOutputRequest.ConsoleHandle,
                                 &Buff);
  if (! NT_SUCCESS(Status))
5ffb43e5:	5f                   	pop    %edi
5ffb43e6:	85 db                	test   %ebx,%ebx
5ffb43e8:	58                   	pop    %eax
5ffb43e9:	78 63                	js     5ffb444e <_CsrWriteConsoleOutput@12+0xae>
    {
      if (NULL != Console)
        {
          ConioUnlockConsole(Console);
        }
      return Reply->Status = Status;
    }

  BufferSize = Request->Data.WriteConsoleOutputRequest.BufferSize;
5ffb43eb:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb43ee:	8b 7a 24             	mov    0x24(%edx),%edi
  PSize = BufferSize.X * BufferSize.Y * sizeof(CHAR_INFO);
5ffb43f1:	0f bf cf             	movswl %di,%ecx
5ffb43f4:	89 fb                	mov    %edi,%ebx
5ffb43f6:	89 c8                	mov    %ecx,%eax
5ffb43f8:	c1 fb 10             	sar    $0x10,%ebx
5ffb43fb:	89 4d 98             	mov    %ecx,0xffffff98(%ebp)
5ffb43fe:	0f af c3             	imul   %ebx,%eax
  BufferCoord = Request->Data.WriteConsoleOutputRequest.BufferCoord;
5ffb4401:	8b 52 28             	mov    0x28(%edx),%edx
  CharInfo = Request->Data.WriteConsoleOutputRequest.CharInfo;
5ffb4404:	8b 4d 0c             	mov    0xc(%ebp),%ecx
5ffb4407:	c1 e0 02             	shl    $0x2,%eax
5ffb440a:	89 55 ac             	mov    %edx,0xffffffac(%ebp)
5ffb440d:	8b 49 34             	mov    0x34(%ecx),%ecx
  if (((PVOID)CharInfo < ProcessData->CsrSectionViewBase) ||
5ffb4410:	8b 56 1c             	mov    0x1c(%esi),%edx
5ffb4413:	89 4d b0             	mov    %ecx,0xffffffb0(%ebp)
5ffb4416:	39 ca                	cmp    %ecx,%edx
5ffb4418:	77 0b                	ja     5ffb4425 <_CsrWriteConsoleOutput@12+0x85>
5ffb441a:	01 c8                	add    %ecx,%eax
5ffb441c:	8b 4e 20             	mov    0x20(%esi),%ecx
5ffb441f:	01 ca                	add    %ecx,%edx
5ffb4421:	39 d0                	cmp    %edx,%eax
5ffb4423:	76 47                	jbe    5ffb446c <_CsrWriteConsoleOutput@12+0xcc>
      (((PVOID)CharInfo + PSize) > 
       (ProcessData->CsrSectionViewBase + ProcessData->CsrSectionViewSize)))
    {
      ConioUnlockScreenBuffer(Buff);
5ffb4425:	8b 4d c0             	mov    0xffffffc0(%ebp),%ecx
5ffb4428:	e8 93 cc ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
      ConioUnlockConsole(Console);
5ffb442d:	8b 4d c4             	mov    0xffffffc4(%ebp),%ecx
5ffb4430:	e8 8b cc ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
      return Reply->Status = STATUS_ACCESS_VIOLATION;
5ffb4435:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb4438:	b8 05 00 00 c0       	mov    $0xc0000005,%eax
5ffb443d:	c7 43 18 05 00 00 c0 	movl   $0xc0000005,0x18(%ebx)
    }
  WriteRegion.left = Request->Data.WriteConsoleOutputRequest.WriteRegion.Left;
  WriteRegion.top = Request->Data.WriteConsoleOutputRequest.WriteRegion.Top;
  WriteRegion.right = Request->Data.WriteConsoleOutputRequest.WriteRegion.Right;
  WriteRegion.bottom = Request->Data.WriteConsoleOutputRequest.WriteRegion.Bottom;

  SizeY = RtlRosMin(BufferSize.Y - BufferCoord.Y, ConioRectHeight(&WriteRegion));
  SizeX = RtlRosMin(BufferSize.X - BufferCoord.X, ConioRectWidth(&WriteRegion));
  WriteRegion.bottom = WriteRegion.top + SizeY - 1;
  WriteRegion.right = WriteRegion.left + SizeX - 1;

  /* Make sure WriteRegion is inside the screen buffer */
  ConioInitRect(&ScreenBuffer, 0, 0, Buff->MaxY - 1, Buff->MaxX - 1);
  if (! ConioGetIntersection(&WriteRegion, &ScreenBuffer, &WriteRegion))
    {
      ConioUnlockScreenBuffer(Buff);
      ConioUnlockConsole(Console);

      /* It is okay to have a WriteRegion completely outside the screen buffer.
         No data is written then. */
      return Reply->Status = STATUS_SUCCESS;
    }

  for (i = 0, Y = WriteRegion.top; Y <= WriteRegion.bottom; i++, Y++)
    {
      CurCharInfo = CharInfo + (i + BufferCoord.Y) * BufferSize.X + BufferCoord.X;
      Offset = (((Y + Buff->ShowY) % Buff->MaxY) * Buff->MaxX + WriteRegion.left) * 2;
      for (X = WriteRegion.left; X <= WriteRegion.right; X++)
        {
          if (Request->Data.WriteConsoleOutputRequest.Unicode)
            {
              CHAR AsciiChar;
              ConsoleUnicodeCharToAnsiChar(Console, &AsciiChar, &CurCharInfo->Char.UnicodeChar);
              SET_CELL_BUFFER(Buff, Offset, AsciiChar, CurCharInfo->Attributes);
            }
          else
            {
              SET_CELL_BUFFER(Buff, Offset, CurCharInfo->Char.AsciiChar, CurCharInfo->Attributes);
            }
          CurCharInfo++;
        }
    }

  if (NULL != Console)
    {
      ConioDrawRegion(Console, &WriteRegion);
    }

  ConioUnlockScreenBuffer(Buff);
  ConioUnlockConsole(Console);

  Reply->Data.WriteConsoleOutputReply.WriteRegion.Right = WriteRegion.left + SizeX - 1;
  Reply->Data.WriteConsoleOutputReply.WriteRegion.Bottom = WriteRegion.top + SizeY - 1;
  Reply->Data.WriteConsoleOutputReply.WriteRegion.Left = WriteRegion.left;
  Reply->Data.WriteConsoleOutputReply.WriteRegion.Top = WriteRegion.top;

  return Reply->Status = STATUS_SUCCESS;
}
5ffb4444:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb4447:	5b                   	pop    %ebx
5ffb4448:	5e                   	pop    %esi
5ffb4449:	5f                   	pop    %edi
5ffb444a:	5d                   	pop    %ebp
5ffb444b:	c2 0c 00             	ret    $0xc
5ffb444e:	8b 4d c4             	mov    0xffffffc4(%ebp),%ecx
5ffb4451:	85 c9                	test   %ecx,%ecx
5ffb4453:	74 05                	je     5ffb445a <_CsrWriteConsoleOutput@12+0xba>
5ffb4455:	e8 66 cc ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb445a:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb445d:	89 58 18             	mov    %ebx,0x18(%eax)
5ffb4460:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb4463:	89 d8                	mov    %ebx,%eax
5ffb4465:	5b                   	pop    %ebx
5ffb4466:	5e                   	pop    %esi
5ffb4467:	5f                   	pop    %edi
5ffb4468:	5d                   	pop    %ebp
5ffb4469:	c2 0c 00             	ret    $0xc
5ffb446c:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb446f:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb4472:	0f bf 40 2c          	movswl 0x2c(%eax),%eax
5ffb4476:	89 45 a8             	mov    %eax,0xffffffa8(%ebp)
5ffb4479:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb447c:	0f bf 52 2e          	movswl 0x2e(%edx),%edx
5ffb4480:	89 55 a4             	mov    %edx,0xffffffa4(%ebp)
5ffb4483:	0f bf 50 32          	movswl 0x32(%eax),%edx
5ffb4487:	0f bf 48 30          	movswl 0x30(%eax),%ecx
5ffb448b:	89 55 a0             	mov    %edx,0xffffffa0(%ebp)
5ffb448e:	8b 45 ac             	mov    0xffffffac(%ebp),%eax
5ffb4491:	c1 f8 10             	sar    $0x10,%eax
5ffb4494:	89 da                	mov    %ebx,%edx
5ffb4496:	8b 5d a0             	mov    0xffffffa0(%ebp),%ebx
5ffb4499:	29 c2                	sub    %eax,%edx
5ffb449b:	39 5d a4             	cmp    %ebx,0xffffffa4(%ebp)
5ffb449e:	0f 8e 1c 01 00 00    	jle    5ffb45c0 <_CsrWriteConsoleOutput@12+0x220>
5ffb44a4:	85 d2                	test   %edx,%edx
5ffb44a6:	0f 88 24 01 00 00    	js     5ffb45d0 <_CsrWriteConsoleOutput@12+0x230>
5ffb44ac:	8b 45 a0             	mov    0xffffffa0(%ebp),%eax
5ffb44af:	66 c7 45 b6 00 00    	movw   $0x0,0xffffffb6(%ebp)
5ffb44b5:	39 45 a4             	cmp    %eax,0xffffffa4(%ebp)
5ffb44b8:	7f 0c                	jg     5ffb44c6 <_CsrWriteConsoleOutput@12+0x126>
5ffb44ba:	8b 45 a0             	mov    0xffffffa0(%ebp),%eax
5ffb44bd:	66 2b 45 a4          	sub    0xffffffa4(%ebp),%ax
5ffb44c1:	40                   	inc    %eax
5ffb44c2:	66 89 45 b6          	mov    %ax,0xffffffb6(%ebp)
5ffb44c6:	0f bf 55 ac          	movswl 0xffffffac(%ebp),%edx
5ffb44ca:	89 55 9c             	mov    %edx,0xffffff9c(%ebp)
5ffb44cd:	8b 55 98             	mov    0xffffff98(%ebp),%edx
5ffb44d0:	8b 75 9c             	mov    0xffffff9c(%ebp),%esi
5ffb44d3:	29 f2                	sub    %esi,%edx
5ffb44d5:	39 4d a8             	cmp    %ecx,0xffffffa8(%ebp)
5ffb44d8:	0f 8f a0 02 00 00    	jg     5ffb477e <_CsrWriteConsoleOutput@12+0x3de>
5ffb44de:	89 c8                	mov    %ecx,%eax
5ffb44e0:	8b 5d a8             	mov    0xffffffa8(%ebp),%ebx
5ffb44e3:	29 d8                	sub    %ebx,%eax
5ffb44e5:	40                   	inc    %eax
5ffb44e6:	39 c2                	cmp    %eax,%edx
5ffb44e8:	0f 8c 98 02 00 00    	jl     5ffb4786 <_CsrWriteConsoleOutput@12+0x3e6>
5ffb44ee:	66 c7 45 b8 00 00    	movw   $0x0,0xffffffb8(%ebp)
5ffb44f4:	39 4d a8             	cmp    %ecx,0xffffffa8(%ebp)
5ffb44f7:	7f 0b                	jg     5ffb4504 <_CsrWriteConsoleOutput@12+0x164>
5ffb44f9:	89 c8                	mov    %ecx,%eax
5ffb44fb:	66 2b 45 a8          	sub    0xffffffa8(%ebp),%ax
5ffb44ff:	40                   	inc    %eax
5ffb4500:	66 89 45 b8          	mov    %ax,0xffffffb8(%ebp)
5ffb4504:	0f bf 45 b6          	movswl 0xffffffb6(%ebp),%eax
5ffb4508:	8b 4d a4             	mov    0xffffffa4(%ebp),%ecx
5ffb450b:	8b 5d a8             	mov    0xffffffa8(%ebp),%ebx
5ffb450e:	8b 75 c0             	mov    0xffffffc0(%ebp),%esi
5ffb4511:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
5ffb4518:	8d 44 01 ff          	lea    0xffffffff(%ecx,%eax,1),%eax
5ffb451c:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
5ffb4523:	89 45 a0             	mov    %eax,0xffffffa0(%ebp)
5ffb4526:	0f bf 45 b8          	movswl 0xffffffb8(%ebp),%eax
5ffb452a:	8d 4c 03 ff          	lea    0xffffffff(%ebx,%eax,1),%ecx
5ffb452e:	66 8b 46 26          	mov    0x26(%esi),%ax
5ffb4532:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb4537:	8d 78 ff             	lea    0xffffffff(%eax),%edi
5ffb453a:	66 8b 46 24          	mov    0x24(%esi),%ax
5ffb453e:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb4543:	89 7d e4             	mov    %edi,0xffffffe4(%ebp)
5ffb4546:	8d 58 ff             	lea    0xffffffff(%eax),%ebx
5ffb4549:	31 c0                	xor    %eax,%eax
5ffb454b:	89 5d e0             	mov    %ebx,0xffffffe0(%ebp)
5ffb454e:	39 d8                	cmp    %ebx,%eax
5ffb4550:	0f 8f 91 00 00 00    	jg     5ffb45e7 <_CsrWriteConsoleOutput@12+0x247>
5ffb4556:	39 f8                	cmp    %edi,%eax
5ffb4558:	0f 8f 89 00 00 00    	jg     5ffb45e7 <_CsrWriteConsoleOutput@12+0x247>
5ffb455e:	39 4d a8             	cmp    %ecx,0xffffffa8(%ebp)
5ffb4561:	0f 8f 80 00 00 00    	jg     5ffb45e7 <_CsrWriteConsoleOutput@12+0x247>
5ffb4567:	8b 55 a0             	mov    0xffffffa0(%ebp),%edx
5ffb456a:	39 55 a4             	cmp    %edx,0xffffffa4(%ebp)
5ffb456d:	7f 78                	jg     5ffb45e7 <_CsrWriteConsoleOutput@12+0x247>
5ffb456f:	39 d0                	cmp    %edx,%eax
5ffb4571:	7f 74                	jg     5ffb45e7 <_CsrWriteConsoleOutput@12+0x247>
5ffb4573:	39 c8                	cmp    %ecx,%eax
5ffb4575:	7f 70                	jg     5ffb45e7 <_CsrWriteConsoleOutput@12+0x247>
5ffb4577:	3b 7d a4             	cmp    0xffffffa4(%ebp),%edi
5ffb457a:	7c 6b                	jl     5ffb45e7 <_CsrWriteConsoleOutput@12+0x247>
5ffb457c:	3b 5d a8             	cmp    0xffffffa8(%ebp),%ebx
5ffb457f:	7c 66                	jl     5ffb45e7 <_CsrWriteConsoleOutput@12+0x247>
5ffb4581:	8b 55 a4             	mov    0xffffffa4(%ebp),%edx
5ffb4584:	89 d0                	mov    %edx,%eax
5ffb4586:	83 f0 ff             	xor    $0xffffffff,%eax
5ffb4589:	c1 f8 1f             	sar    $0x1f,%eax
5ffb458c:	21 d0                	and    %edx,%eax
5ffb458e:	8b 55 a8             	mov    0xffffffa8(%ebp),%edx
5ffb4591:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
5ffb4594:	89 d0                	mov    %edx,%eax
5ffb4596:	83 f0 ff             	xor    $0xffffffff,%eax
5ffb4599:	c1 f8 1f             	sar    $0x1f,%eax
5ffb459c:	21 d0                	and    %edx,%eax
5ffb459e:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)
5ffb45a1:	8b 45 a0             	mov    0xffffffa0(%ebp),%eax
5ffb45a4:	39 f8                	cmp    %edi,%eax
5ffb45a6:	7e 02                	jle    5ffb45aa <_CsrWriteConsoleOutput@12+0x20a>
5ffb45a8:	89 f8                	mov    %edi,%eax
5ffb45aa:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
5ffb45ad:	39 d9                	cmp    %ebx,%ecx
5ffb45af:	89 c8                	mov    %ecx,%eax
5ffb45b1:	7e 02                	jle    5ffb45b5 <_CsrWriteConsoleOutput@12+0x215>
5ffb45b3:	89 d8                	mov    %ebx,%eax
5ffb45b5:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
5ffb45b8:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb45bd:	eb 46                	jmp    5ffb4605 <_CsrWriteConsoleOutput@12+0x265>
5ffb45bf:	90                   	nop    
5ffb45c0:	89 d8                	mov    %ebx,%eax
5ffb45c2:	8b 5d a4             	mov    0xffffffa4(%ebp),%ebx
5ffb45c5:	29 d8                	sub    %ebx,%eax
5ffb45c7:	40                   	inc    %eax
5ffb45c8:	39 c2                	cmp    %eax,%edx
5ffb45ca:	0f 8d dc fe ff ff    	jge    5ffb44ac <_CsrWriteConsoleOutput@12+0x10c>
5ffb45d0:	89 fa                	mov    %edi,%edx
5ffb45d2:	8b 45 ac             	mov    0xffffffac(%ebp),%eax
5ffb45d5:	c1 fa 10             	sar    $0x10,%edx
5ffb45d8:	c1 f8 10             	sar    $0x10,%eax
5ffb45db:	66 29 c2             	sub    %ax,%dx
5ffb45de:	66 89 55 b6          	mov    %dx,0xffffffb6(%ebp)
5ffb45e2:	e9 df fe ff ff       	jmp    5ffb44c6 <_CsrWriteConsoleOutput@12+0x126>
5ffb45e7:	c7 45 cc 00 00 00 00 	movl   $0x0,0xffffffcc(%ebp)
5ffb45ee:	c7 45 c8 ff ff ff ff 	movl   $0xffffffff,0xffffffc8(%ebp)
5ffb45f5:	c7 45 d4 00 00 00 00 	movl   $0x0,0xffffffd4(%ebp)
5ffb45fc:	c7 45 d0 ff ff ff ff 	movl   $0xffffffff,0xffffffd0(%ebp)
5ffb4603:	31 c0                	xor    %eax,%eax
5ffb4605:	85 c0                	test   %eax,%eax
5ffb4607:	0f 84 86 01 00 00    	je     5ffb4793 <_CsrWriteConsoleOutput@12+0x3f3>
5ffb460d:	8b 5d cc             	mov    0xffffffcc(%ebp),%ebx
5ffb4610:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
5ffb4613:	66 89 5d ba          	mov    %bx,0xffffffba(%ebp)
5ffb4617:	66 c7 45 bc 00 00    	movw   $0x0,0xffffffbc(%ebp)
5ffb461d:	0f bf 5d ba          	movswl 0xffffffba(%ebp),%ebx
5ffb4621:	89 45 a0             	mov    %eax,0xffffffa0(%ebp)
5ffb4624:	39 c3                	cmp    %eax,%ebx
5ffb4626:	0f 8f f9 00 00 00    	jg     5ffb4725 <_CsrWriteConsoleOutput@12+0x385>
5ffb462c:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
5ffb462f:	90                   	nop    
5ffb4630:	0f bf 45 bc          	movswl 0xffffffbc(%ebp),%eax
5ffb4634:	8b 55 ac             	mov    0xffffffac(%ebp),%edx
5ffb4637:	8b 7d 98             	mov    0xffffff98(%ebp),%edi
5ffb463a:	c1 fa 10             	sar    $0x10,%edx
5ffb463d:	01 d0                	add    %edx,%eax
5ffb463f:	8b 55 9c             	mov    0xffffff9c(%ebp),%edx
5ffb4642:	0f af c7             	imul   %edi,%eax
5ffb4645:	01 d0                	add    %edx,%eax
5ffb4647:	8b 55 b0             	mov    0xffffffb0(%ebp),%edx
5ffb464a:	8d 3c 82             	lea    (%edx,%eax,4),%edi
5ffb464d:	66 8b 56 2a          	mov    0x2a(%esi),%dx
5ffb4651:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb4657:	66 8b 46 26          	mov    0x26(%esi),%ax
5ffb465b:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb4660:	8d 14 13             	lea    (%ebx,%edx,1),%edx
5ffb4663:	89 c3                	mov    %eax,%ebx
5ffb4665:	89 d0                	mov    %edx,%eax
5ffb4667:	c1 fa 1f             	sar    $0x1f,%edx
5ffb466a:	f7 fb                	idiv   %ebx
5ffb466c:	66 8b 46 24          	mov    0x24(%esi),%ax
5ffb4670:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb4675:	0f af d0             	imul   %eax,%edx
5ffb4678:	8b 45 c8             	mov    0xffffffc8(%ebp),%eax
5ffb467b:	01 c2                	add    %eax,%edx
5ffb467d:	89 c6                	mov    %eax,%esi
5ffb467f:	98                   	cwtl   
5ffb4680:	8d 1c 12             	lea    (%edx,%edx,1),%ebx
5ffb4683:	39 c8                	cmp    %ecx,%eax
5ffb4685:	7e 31                	jle    5ffb46b8 <_CsrWriteConsoleOutput@12+0x318>
5ffb4687:	e9 80 00 00 00       	jmp    5ffb470c <_CsrWriteConsoleOutput@12+0x36c>
5ffb468c:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb4690:	8b 45 c0             	mov    0xffffffc0(%ebp),%eax
5ffb4693:	46                   	inc    %esi
5ffb4694:	8b 50 20             	mov    0x20(%eax),%edx
5ffb4697:	8a 07                	mov    (%edi),%al
5ffb4699:	88 04 13             	mov    %al,(%ebx,%edx,1)
5ffb469c:	43                   	inc    %ebx
5ffb469d:	8b 45 c0             	mov    0xffffffc0(%ebp),%eax
5ffb46a0:	8b 50 20             	mov    0x20(%eax),%edx
5ffb46a3:	66 8b 47 02          	mov    0x2(%edi),%ax
5ffb46a7:	83 c7 04             	add    $0x4,%edi
5ffb46aa:	88 04 13             	mov    %al,(%ebx,%edx,1)
5ffb46ad:	43                   	inc    %ebx
5ffb46ae:	0f bf c6             	movswl %si,%eax
5ffb46b1:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
5ffb46b4:	39 c8                	cmp    %ecx,%eax
5ffb46b6:	7f 4e                	jg     5ffb4706 <_CsrWriteConsoleOutput@12+0x366>
5ffb46b8:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb46bb:	8b 40 20             	mov    0x20(%eax),%eax
5ffb46be:	85 c0                	test   %eax,%eax
5ffb46c0:	74 ce                	je     5ffb4690 <_CsrWriteConsoleOutput@12+0x2f0>
5ffb46c2:	8d 45 bf             	lea    0xffffffbf(%ebp),%eax
5ffb46c5:	6a 00                	push   $0x0
5ffb46c7:	6a 00                	push   $0x0
5ffb46c9:	6a 01                	push   $0x1
5ffb46cb:	50                   	push   %eax
5ffb46cc:	6a 01                	push   $0x1
5ffb46ce:	57                   	push   %edi
5ffb46cf:	6a 00                	push   $0x0
5ffb46d1:	8b 45 c4             	mov    0xffffffc4(%ebp),%eax
5ffb46d4:	46                   	inc    %esi
5ffb46d5:	8b 40 68             	mov    0x68(%eax),%eax
5ffb46d8:	50                   	push   %eax
5ffb46d9:	e8 42 46 00 00       	call   5ffb8d20 <_WideCharToMultiByte@32>
5ffb46de:	8b 45 c0             	mov    0xffffffc0(%ebp),%eax
5ffb46e1:	8b 50 20             	mov    0x20(%eax),%edx
5ffb46e4:	8a 45 bf             	mov    0xffffffbf(%ebp),%al
5ffb46e7:	88 04 13             	mov    %al,(%ebx,%edx,1)
5ffb46ea:	43                   	inc    %ebx
5ffb46eb:	8b 45 c0             	mov    0xffffffc0(%ebp),%eax
5ffb46ee:	8b 50 20             	mov    0x20(%eax),%edx
5ffb46f1:	66 8b 47 02          	mov    0x2(%edi),%ax
5ffb46f5:	83 c7 04             	add    $0x4,%edi
5ffb46f8:	88 04 13             	mov    %al,(%ebx,%edx,1)
5ffb46fb:	43                   	inc    %ebx
5ffb46fc:	0f bf c6             	movswl %si,%eax
5ffb46ff:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
5ffb4702:	39 c8                	cmp    %ecx,%eax
5ffb4704:	7e b2                	jle    5ffb46b8 <_CsrWriteConsoleOutput@12+0x318>
5ffb4706:	8b 55 d4             	mov    0xffffffd4(%ebp),%edx
5ffb4709:	89 55 a0             	mov    %edx,0xffffffa0(%ebp)
5ffb470c:	66 ff 45 ba          	incw   0xffffffba(%ebp)
5ffb4710:	0f bf 5d ba          	movswl 0xffffffba(%ebp),%ebx
5ffb4714:	66 ff 45 bc          	incw   0xffffffbc(%ebp)
5ffb4718:	3b 5d a0             	cmp    0xffffffa0(%ebp),%ebx
5ffb471b:	7f 08                	jg     5ffb4725 <_CsrWriteConsoleOutput@12+0x385>
5ffb471d:	8b 75 c0             	mov    0xffffffc0(%ebp),%esi
5ffb4720:	e9 0b ff ff ff       	jmp    5ffb4630 <_CsrWriteConsoleOutput@12+0x290>
5ffb4725:	8b 55 c4             	mov    0xffffffc4(%ebp),%edx
5ffb4728:	85 d2                	test   %edx,%edx
5ffb472a:	0f 85 80 00 00 00    	jne    5ffb47b0 <_CsrWriteConsoleOutput@12+0x410>
5ffb4730:	8b 4d c0             	mov    0xffffffc0(%ebp),%ecx
5ffb4733:	e8 88 c9 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb4738:	8b 4d c4             	mov    0xffffffc4(%ebp),%ecx
5ffb473b:	e8 80 c9 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb4740:	8b 5d b8             	mov    0xffffffb8(%ebp),%ebx
5ffb4743:	8b 4d c8             	mov    0xffffffc8(%ebp),%ecx
5ffb4746:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb4749:	8d 44 0b ff          	lea    0xffffffff(%ebx,%ecx,1),%eax
5ffb474d:	66 89 42 20          	mov    %ax,0x20(%edx)
5ffb4751:	66 8b 5d b6          	mov    0xffffffb6(%ebp),%bx
5ffb4755:	8b 55 cc             	mov    0xffffffcc(%ebp),%edx
5ffb4758:	8d 44 13 ff          	lea    0xffffffff(%ebx,%edx,1),%eax
5ffb475c:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb475f:	66 89 43 22          	mov    %ax,0x22(%ebx)
5ffb4763:	66 89 4b 1c          	mov    %cx,0x1c(%ebx)
5ffb4767:	66 89 53 1e          	mov    %dx,0x1e(%ebx)
5ffb476b:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
5ffb4772:	31 c0                	xor    %eax,%eax
5ffb4774:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb4777:	5b                   	pop    %ebx
5ffb4778:	5e                   	pop    %esi
5ffb4779:	5f                   	pop    %edi
5ffb477a:	5d                   	pop    %ebp
5ffb477b:	c2 0c 00             	ret    $0xc
5ffb477e:	85 d2                	test   %edx,%edx
5ffb4780:	0f 89 68 fd ff ff    	jns    5ffb44ee <_CsrWriteConsoleOutput@12+0x14e>
5ffb4786:	66 2b 7d ac          	sub    0xffffffac(%ebp),%di
5ffb478a:	66 89 7d b8          	mov    %di,0xffffffb8(%ebp)
5ffb478e:	e9 71 fd ff ff       	jmp    5ffb4504 <_CsrWriteConsoleOutput@12+0x164>
5ffb4793:	89 f1                	mov    %esi,%ecx
5ffb4795:	e8 26 c9 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb479a:	8b 4d c4             	mov    0xffffffc4(%ebp),%ecx
5ffb479d:	e8 1e c9 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb47a2:	8b 4d 10             	mov    0x10(%ebp),%ecx
5ffb47a5:	31 c0                	xor    %eax,%eax
5ffb47a7:	c7 41 18 00 00 00 00 	movl   $0x0,0x18(%ecx)
5ffb47ae:	eb c4                	jmp    5ffb4774 <_CsrWriteConsoleOutput@12+0x3d4>
5ffb47b0:	56                   	push   %esi
5ffb47b1:	56                   	push   %esi
5ffb47b2:	8d 4d c8             	lea    0xffffffc8(%ebp),%ecx
5ffb47b5:	8b 42 70             	mov    0x70(%edx),%eax
5ffb47b8:	51                   	push   %ecx
5ffb47b9:	52                   	push   %edx
5ffb47ba:	ff 50 08             	call   *0x8(%eax)
5ffb47bd:	59                   	pop    %ecx
5ffb47be:	5b                   	pop    %ebx
5ffb47bf:	e9 6c ff ff ff       	jmp    5ffb4730 <_CsrWriteConsoleOutput@12+0x390>
5ffb47c4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb47ca:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

5ffb47d0 <_CsrFlushInputBuffer@12>:

CSR_API(CsrFlushInputBuffer)
{
5ffb47d0:	55                   	push   %ebp
5ffb47d1:	89 e5                	mov    %esp,%ebp
5ffb47d3:	56                   	push   %esi
5ffb47d4:	53                   	push   %ebx
5ffb47d5:	83 ec 18             	sub    $0x18,%esp
5ffb47d8:	8b 75 10             	mov    0x10(%ebp),%esi
  PLIST_ENTRY CurrentEntry;
  PCSRSS_CONSOLE Console;
  ConsoleInput* Input;
  NTSTATUS Status;

  DPRINT("CsrFlushInputBuffer\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
  Status = ConioLockConsole(ProcessData,
5ffb47db:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb47de:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb47e1:	66 c7 46 02 38 00    	movw   $0x38,0x2(%esi)
5ffb47e7:	66 c7 06 20 00       	movw   $0x20,(%esi)
5ffb47ec:	8b 50 1c             	mov    0x1c(%eax),%edx
5ffb47ef:	8d 45 f4             	lea    0xfffffff4(%ebp),%eax
5ffb47f2:	6a 01                	push   $0x1
5ffb47f4:	50                   	push   %eax
5ffb47f5:	e8 86 c8 ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
                            Request->Data.FlushInputBufferRequest.ConsoleInput,
                            &Console);
  if(! NT_SUCCESS(Status))
5ffb47fa:	59                   	pop    %ecx
5ffb47fb:	85 c0                	test   %eax,%eax
5ffb47fd:	5b                   	pop    %ebx
5ffb47fe:	78 67                	js     5ffb4867 <_CsrFlushInputBuffer@12+0x97>
    {
      return Reply->Status = Status;
    }

  /* Discard all entries in the input event queue */
  while (!IsListEmpty(&Console->InputEvents))
    {
      CurrentEntry = RemoveHeadList(&Console->InputEvents);
      Input = CONTAINING_RECORD(CurrentEntry, ConsoleInput, ListEntry);
      /* Destroy the event */
      HeapFree(Win32CsrApiHeap, 0, Input);
5ffb4800:	8b 4d f4             	mov    0xfffffff4(%ebp),%ecx
5ffb4803:	8d 51 2c             	lea    0x2c(%ecx),%edx
5ffb4806:	8b 41 2c             	mov    0x2c(%ecx),%eax
5ffb4809:	39 d0                	cmp    %edx,%eax
5ffb480b:	74 2b                	je     5ffb4838 <_CsrFlushInputBuffer@12+0x68>
5ffb480d:	89 d3                	mov    %edx,%ebx
5ffb480f:	89 c2                	mov    %eax,%edx
{
  PLIST_ENTRY Flink;
  PLIST_ENTRY Entry;

  Entry = ListHead->Flink;
5ffb4811:	89 d0                	mov    %edx,%eax
  Flink = Entry->Flink;
5ffb4813:	8b 12                	mov    (%edx),%edx
  ListHead->Flink = Flink;
5ffb4815:	89 51 2c             	mov    %edx,0x2c(%ecx)
  Flink->Blink = ListHead;
5ffb4818:	89 5a 04             	mov    %ebx,0x4(%edx)
5ffb481b:	52                   	push   %edx
5ffb481c:	50                   	push   %eax
5ffb481d:	6a 00                	push   $0x0
5ffb481f:	a1 e0 c1 fb 5f       	mov    0x5ffbc1e0,%eax
5ffb4824:	50                   	push   %eax
5ffb4825:	e8 d6 44 00 00       	call   5ffb8d00 <_HeapFree@12>
5ffb482a:	8b 4d f4             	mov    0xfffffff4(%ebp),%ecx
5ffb482d:	58                   	pop    %eax
5ffb482e:	8d 59 2c             	lea    0x2c(%ecx),%ebx
5ffb4831:	8b 51 2c             	mov    0x2c(%ecx),%edx
5ffb4834:	39 da                	cmp    %ebx,%edx
5ffb4836:	75 d9                	jne    5ffb4811 <_CsrFlushInputBuffer@12+0x41>
    }
  ResetEvent(Console->ActiveEvent);
5ffb4838:	83 ec 0c             	sub    $0xc,%esp
5ffb483b:	8b 41 28             	mov    0x28(%ecx),%eax
5ffb483e:	50                   	push   %eax
5ffb483f:	e8 cc 44 00 00       	call   5ffb8d10 <_ResetEvent@4>
  Console->WaitingChars=0;
5ffb4844:	8b 4d f4             	mov    0xfffffff4(%ebp),%ecx

  ConioUnlockConsole(Console);
5ffb4847:	83 c4 0c             	add    $0xc,%esp
5ffb484a:	66 c7 41 34 00 00    	movw   $0x0,0x34(%ecx)
5ffb4850:	e8 6b c8 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>

  return Reply->Status = STATUS_SUCCESS;
5ffb4855:	c7 46 18 00 00 00 00 	movl   $0x0,0x18(%esi)
5ffb485c:	31 c0                	xor    %eax,%eax
}
5ffb485e:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb4861:	5b                   	pop    %ebx
5ffb4862:	5e                   	pop    %esi
5ffb4863:	5d                   	pop    %ebp
5ffb4864:	c2 0c 00             	ret    $0xc
5ffb4867:	89 46 18             	mov    %eax,0x18(%esi)
5ffb486a:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb486d:	5b                   	pop    %ebx
5ffb486e:	5e                   	pop    %esi
5ffb486f:	5d                   	pop    %ebp
5ffb4870:	c2 0c 00             	ret    $0xc
5ffb4873:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb4879:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb4880 <_CsrScrollConsoleScreenBuffer@12>:

CSR_API(CsrScrollConsoleScreenBuffer)
{
5ffb4880:	55                   	push   %ebp
5ffb4881:	89 e5                	mov    %esp,%ebp
5ffb4883:	57                   	push   %edi
5ffb4884:	56                   	push   %esi
5ffb4885:	53                   	push   %ebx
5ffb4886:	81 ec 0c 01 00 00    	sub    $0x10c,%esp
  PCSRSS_CONSOLE Console;
  PCSRSS_SCREEN_BUFFER Buff;
  RECT ScreenBuffer;
  RECT SrcRegion;
  RECT DstRegion;
  RECT FillRegion;
  RECT ScrollRectangle;
  RECT ClipRectangle;
  NTSTATUS Status;
  BOOLEAN DoFill;

  DPRINT("CsrScrollConsoleScreenBuffer\n");

  ALIAS(ConsoleHandle,Request->Data.ScrollConsoleScreenBufferRequest.ConsoleHandle);
5ffb488c:	8b 45 0c             	mov    0xc(%ebp),%eax
  ALIAS(UseClipRectangle,Request->Data.ScrollConsoleScreenBufferRequest.UseClipRectangle);
5ffb488f:	8a 50 2c             	mov    0x2c(%eax),%dl
5ffb4892:	8b 70 1c             	mov    0x1c(%eax),%esi
5ffb4895:	88 95 69 ff ff ff    	mov    %dl,0xffffff69(%ebp)
  ALIAS(DestinationOrigin,Request->Data.ScrollConsoleScreenBufferRequest.DestinationOrigin);
  ALIAS(Fill,Request->Data.ScrollConsoleScreenBufferRequest.Fill);

  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb489b:	8d 95 74 ff ff ff    	lea    0xffffff74(%ebp),%edx
5ffb48a1:	8b 48 36             	mov    0x36(%eax),%ecx
5ffb48a4:	89 8d 64 ff ff ff    	mov    %ecx,0xffffff64(%ebp)
5ffb48aa:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb48ad:	8b 40 3a             	mov    0x3a(%eax),%eax
5ffb48b0:	89 85 6c ff ff ff    	mov    %eax,0xffffff6c(%ebp)
5ffb48b6:	e8 05 c9 ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
5ffb48bb:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb48bd:	85 c0                	test   %eax,%eax
5ffb48bf:	0f 88 2b 04 00 00    	js     5ffb4cf0 <_CsrScrollConsoleScreenBuffer@12+0x470>
    {
      return Reply->Status = Status;
    }

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
5ffb48c5:	8b 45 10             	mov    0x10(%ebp),%eax
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
  Status = ConioLockScreenBuffer(ProcessData, ConsoleHandle, &Buff);
5ffb48c8:	89 f2                	mov    %esi,%edx
5ffb48ca:	66 c7 40 02 38 00    	movw   $0x38,0x2(%eax)
5ffb48d0:	66 c7 00 20 00       	movw   $0x20,(%eax)
5ffb48d5:	8d 85 70 ff ff ff    	lea    0xffffff70(%ebp),%eax
5ffb48db:	51                   	push   %ecx
5ffb48dc:	51                   	push   %ecx
5ffb48dd:	6a 02                	push   $0x2
5ffb48df:	50                   	push   %eax
5ffb48e0:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb48e3:	e8 98 c7 ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
5ffb48e8:	89 c3                	mov    %eax,%ebx
  if (! NT_SUCCESS(Status))
5ffb48ea:	58                   	pop    %eax
5ffb48eb:	85 db                	test   %ebx,%ebx
5ffb48ed:	5a                   	pop    %edx
5ffb48ee:	0f 88 56 05 00 00    	js     5ffb4e4a <_CsrScrollConsoleScreenBuffer@12+0x5ca>
    {
      if (NULL != Console)
        {
          ConioUnlockConsole(Console);
        }
      return Reply->Status = Status;
    }

  ScrollRectangle.left = Request->Data.ScrollConsoleScreenBufferRequest.ScrollRectangle.Left;
5ffb48f4:	8b 4d 0c             	mov    0xc(%ebp),%ecx
  ScrollRectangle.top = Request->Data.ScrollConsoleScreenBufferRequest.ScrollRectangle.Top;
5ffb48f7:	8b 45 0c             	mov    0xc(%ebp),%eax
  ScrollRectangle.right = Request->Data.ScrollConsoleScreenBufferRequest.ScrollRectangle.Right;
  ScrollRectangle.bottom = Request->Data.ScrollConsoleScreenBufferRequest.ScrollRectangle.Bottom;
  ClipRectangle.left = Request->Data.ScrollConsoleScreenBufferRequest.ClipRectangle.Left;
  ClipRectangle.top = Request->Data.ScrollConsoleScreenBufferRequest.ClipRectangle.Top;
  ClipRectangle.right = Request->Data.ScrollConsoleScreenBufferRequest.ClipRectangle.Right;
  ClipRectangle.bottom = Request->Data.ScrollConsoleScreenBufferRequest.ClipRectangle.Bottom;

  /* Make sure source rectangle is inside the screen buffer */
  ConioInitRect(&ScreenBuffer, 0, 0, Buff->MaxY - 1, Buff->MaxX - 1);
5ffb48fa:	8b bd 70 ff ff ff    	mov    0xffffff70(%ebp),%edi
5ffb4900:	0f bf 49 24          	movswl 0x24(%ecx),%ecx
5ffb4904:	89 8d 60 ff ff ff    	mov    %ecx,0xffffff60(%ebp)
5ffb490a:	89 4d 98             	mov    %ecx,0xffffff98(%ebp)
5ffb490d:	0f bf 70 26          	movswl 0x26(%eax),%esi
5ffb4911:	89 75 9c             	mov    %esi,0xffffff9c(%ebp)
5ffb4914:	0f bf 58 28          	movswl 0x28(%eax),%ebx
5ffb4918:	89 5d a0             	mov    %ebx,0xffffffa0(%ebp)
5ffb491b:	0f bf 48 2a          	movswl 0x2a(%eax),%ecx
5ffb491f:	89 4d a4             	mov    %ecx,0xffffffa4(%ebp)
5ffb4922:	0f bf 50 2e          	movswl 0x2e(%eax),%edx
5ffb4926:	89 95 5c ff ff ff    	mov    %edx,0xffffff5c(%ebp)
5ffb492c:	89 55 88             	mov    %edx,0xffffff88(%ebp)
5ffb492f:	0f bf 40 30          	movswl 0x30(%eax),%eax
5ffb4933:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb4936:	89 85 58 ff ff ff    	mov    %eax,0xffffff58(%ebp)
5ffb493c:	89 45 8c             	mov    %eax,0xffffff8c(%ebp)
5ffb493f:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb4942:	0f bf 52 32          	movswl 0x32(%edx),%edx
5ffb4946:	89 95 54 ff ff ff    	mov    %edx,0xffffff54(%ebp)
5ffb494c:	89 55 90             	mov    %edx,0xffffff90(%ebp)
5ffb494f:	0f bf 40 34          	movswl 0x34(%eax),%eax
5ffb4953:	89 85 50 ff ff ff    	mov    %eax,0xffffff50(%ebp)
5ffb4959:	89 45 94             	mov    %eax,0xffffff94(%ebp)
5ffb495c:	66 8b 47 26          	mov    0x26(%edi),%ax
5ffb4960:	31 d2                	xor    %edx,%edx
5ffb4962:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb4967:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
5ffb496e:	48                   	dec    %eax
5ffb496f:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
5ffb4976:	89 85 4c ff ff ff    	mov    %eax,0xffffff4c(%ebp)
5ffb497c:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
5ffb497f:	66 8b 47 24          	mov    0x24(%edi),%ax
5ffb4983:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb4988:	48                   	dec    %eax
5ffb4989:	89 85 48 ff ff ff    	mov    %eax,0xffffff48(%ebp)
5ffb498f:	39 c2                	cmp    %eax,%edx
5ffb4991:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
5ffb4994:	7f 0c                	jg     5ffb49a2 <_CsrScrollConsoleScreenBuffer@12+0x122>
5ffb4996:	3b 95 4c ff ff ff    	cmp    0xffffff4c(%ebp),%edx
5ffb499c:	0f 8e c1 04 00 00    	jle    5ffb4e63 <_CsrScrollConsoleScreenBuffer@12+0x5e3>
5ffb49a2:	c7 45 cc 00 00 00 00 	movl   $0x0,0xffffffcc(%ebp)
5ffb49a9:	c7 45 c8 ff ff ff ff 	movl   $0xffffffff,0xffffffc8(%ebp)
5ffb49b0:	c7 45 d4 00 00 00 00 	movl   $0x0,0xffffffd4(%ebp)
5ffb49b7:	c7 45 d0 ff ff ff ff 	movl   $0xffffffff,0xffffffd0(%ebp)
5ffb49be:	31 d2                	xor    %edx,%edx
5ffb49c0:	85 d2                	test   %edx,%edx
5ffb49c2:	0f 84 cc 09 00 00    	je     5ffb5394 <_CsrScrollConsoleScreenBuffer@12+0xb14>
  if (! ConioGetIntersection(&SrcRegion, &ScreenBuffer, &ScrollRectangle))
    {
      ConioUnlockScreenBuffer(Buff);
      return Reply->Status = STATUS_INVALID_PARAMETER;
    }

  if (UseClipRectangle && ! ConioGetIntersection(&SrcRegion, &SrcRegion, &ClipRectangle))
5ffb49c8:	80 bd 69 ff ff ff 00 	cmpb   $0x0,0xffffff69(%ebp)
5ffb49cf:	74 53                	je     5ffb4a24 <_CsrScrollConsoleScreenBuffer@12+0x1a4>
5ffb49d1:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
5ffb49d4:	8b 55 c8             	mov    0xffffffc8(%ebp),%edx
5ffb49d7:	89 85 44 ff ff ff    	mov    %eax,0xffffff44(%ebp)
5ffb49dd:	39 c2                	cmp    %eax,%edx
5ffb49df:	0f 8e 0b 05 00 00    	jle    5ffb4ef0 <_CsrScrollConsoleScreenBuffer@12+0x670>
5ffb49e5:	c7 45 cc 00 00 00 00 	movl   $0x0,0xffffffcc(%ebp)
5ffb49ec:	c7 45 c8 ff ff ff ff 	movl   $0xffffffff,0xffffffc8(%ebp)
5ffb49f3:	c7 45 d4 00 00 00 00 	movl   $0x0,0xffffffd4(%ebp)
5ffb49fa:	c7 45 d0 ff ff ff ff 	movl   $0xffffffff,0xffffffd0(%ebp)
5ffb4a01:	31 d2                	xor    %edx,%edx
5ffb4a03:	85 d2                	test   %edx,%edx
5ffb4a05:	75 1d                	jne    5ffb4a24 <_CsrScrollConsoleScreenBuffer@12+0x1a4>
    {
      ConioUnlockScreenBuffer(Buff);
5ffb4a07:	89 f9                	mov    %edi,%ecx
5ffb4a09:	e8 b2 c6 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
      return Reply->Status = STATUS_SUCCESS;
5ffb4a0e:	8b 55 10             	mov    0x10(%ebp),%edx
    }


  ConioInitRect(&DstRegion,
               DestinationOrigin.Y,
               DestinationOrigin.X,
               DestinationOrigin.Y + ConioRectHeight(&ScrollRectangle) - 1,
               DestinationOrigin.X + ConioRectWidth(&ScrollRectangle) - 1);

  /* Make sure destination rectangle is inside the screen buffer */
  if (! ConioGetIntersection(&DstRegion, &DstRegion, &ScreenBuffer))
    {
      ConioUnlockScreenBuffer(Buff);
      return Reply->Status = STATUS_INVALID_PARAMETER;
    }

  ConioCopyRegion(Buff, &SrcRegion, &DstRegion);

  /* Get the region that should be filled with the specified character and attributes */

  DoFill = FALSE;

  ConioGetUnion(&FillRegion, &SrcRegion, &DstRegion);

  if (ConioSubtractRect(&FillRegion, &FillRegion, &DstRegion))
    {
      /* FIXME: The subtracted rectangle is off by one line */
      FillRegion.top += 1;

      ConioFillRegion(Console, Buff, &FillRegion, &Fill, Request->Data.ScrollConsoleScreenBufferRequest.Unicode);
      DoFill = TRUE;
    }

  if (NULL != Console && Buff == Console->ActiveBuffer)
    {
      /* Draw destination region */
      ConioDrawRegion(Console, &DstRegion);

      if (DoFill)
        {
          /* Draw filled region */
          ConioDrawRegion(Console, &FillRegion);
        }
    }

  ConioUnlockScreenBuffer(Buff);
  if (NULL != Console)
    {
      ConioUnlockConsole(Console);
    }

  return Reply->Status = STATUS_SUCCESS;
5ffb4a11:	31 c0                	xor    %eax,%eax
5ffb4a13:	c7 42 18 00 00 00 00 	movl   $0x0,0x18(%edx)
}
5ffb4a1a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb4a1d:	5b                   	pop    %ebx
5ffb4a1e:	5e                   	pop    %esi
5ffb4a1f:	5f                   	pop    %edi
5ffb4a20:	5d                   	pop    %ebp
5ffb4a21:	c2 0c 00             	ret    $0xc
5ffb4a24:	0f bf 85 64 ff ff ff 	movswl 0xffffff64(%ebp),%eax
5ffb4a2b:	8b 95 64 ff ff ff    	mov    0xffffff64(%ebp),%edx
5ffb4a31:	89 85 00 ff ff ff    	mov    %eax,0xffffff00(%ebp)
5ffb4a37:	c1 fa 10             	sar    $0x10,%edx
5ffb4a3a:	39 ce                	cmp    %ecx,%esi
5ffb4a3c:	0f 8f cc 02 00 00    	jg     5ffb4d0e <_CsrScrollConsoleScreenBuffer@12+0x48e>
5ffb4a42:	29 f1                	sub    %esi,%ecx
5ffb4a44:	8d 0c 0a             	lea    (%edx,%ecx,1),%ecx
5ffb4a47:	39 9d 60 ff ff ff    	cmp    %ebx,0xffffff60(%ebp)
5ffb4a4d:	0f 8f af 02 00 00    	jg     5ffb4d02 <_CsrScrollConsoleScreenBuffer@12+0x482>
5ffb4a53:	8b 85 60 ff ff ff    	mov    0xffffff60(%ebp),%eax
5ffb4a59:	29 c3                	sub    %eax,%ebx
5ffb4a5b:	8b 85 00 ff ff ff    	mov    0xffffff00(%ebp),%eax
5ffb4a61:	01 d8                	add    %ebx,%eax
5ffb4a63:	89 85 fc fe ff ff    	mov    %eax,0xfffffefc(%ebp)
5ffb4a69:	39 85 00 ff ff ff    	cmp    %eax,0xffffff00(%ebp)
5ffb4a6f:	7f 08                	jg     5ffb4a79 <_CsrScrollConsoleScreenBuffer@12+0x1f9>
5ffb4a71:	39 ca                	cmp    %ecx,%edx
5ffb4a73:	0f 8e 67 05 00 00    	jle    5ffb4fe0 <_CsrScrollConsoleScreenBuffer@12+0x760>
5ffb4a79:	c7 45 bc 00 00 00 00 	movl   $0x0,0xffffffbc(%ebp)
5ffb4a80:	c7 45 b8 ff ff ff ff 	movl   $0xffffffff,0xffffffb8(%ebp)
5ffb4a87:	c7 45 c4 00 00 00 00 	movl   $0x0,0xffffffc4(%ebp)
5ffb4a8e:	c7 45 c0 ff ff ff ff 	movl   $0xffffffff,0xffffffc0(%ebp)
5ffb4a95:	31 c0                	xor    %eax,%eax
5ffb4a97:	85 c0                	test   %eax,%eax
5ffb4a99:	0f 84 10 09 00 00    	je     5ffb53af <_CsrScrollConsoleScreenBuffer@12+0xb2f>
5ffb4a9f:	8b 55 b8             	mov    0xffffffb8(%ebp),%edx
5ffb4aa2:	8b 4d c0             	mov    0xffffffc0(%ebp),%ecx
5ffb4aa5:	89 95 00 ff ff ff    	mov    %edx,0xffffff00(%ebp)
5ffb4aab:	89 8d fc fe ff ff    	mov    %ecx,0xfffffefc(%ebp)
5ffb4ab1:	c7 85 30 ff ff ff 00 	movl   $0x0,0xffffff30(%ebp)
5ffb4ab8:	00 00 00 
5ffb4abb:	39 ca                	cmp    %ecx,%edx
5ffb4abd:	7f 0e                	jg     5ffb4acd <_CsrScrollConsoleScreenBuffer@12+0x24d>
5ffb4abf:	89 c8                	mov    %ecx,%eax
5ffb4ac1:	29 d0                	sub    %edx,%eax
5ffb4ac3:	8d 44 00 02          	lea    0x2(%eax,%eax,1),%eax
5ffb4ac7:	89 85 30 ff ff ff    	mov    %eax,0xffffff30(%ebp)
5ffb4acd:	66 8b 57 2a          	mov    0x2a(%edi),%dx
5ffb4ad1:	8b 5d cc             	mov    0xffffffcc(%ebp),%ebx
5ffb4ad4:	89 d6                	mov    %edx,%esi
5ffb4ad6:	66 8b 47 26          	mov    0x26(%edi),%ax
5ffb4ada:	81 e6 ff ff 00 00    	and    $0xffff,%esi
5ffb4ae0:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb4ae5:	89 85 f4 fe ff ff    	mov    %eax,0xfffffef4(%ebp)
5ffb4aeb:	8d 0c 33             	lea    (%ebx,%esi,1),%ecx
5ffb4aee:	89 ca                	mov    %ecx,%edx
5ffb4af0:	89 c8                	mov    %ecx,%eax
5ffb4af2:	c1 fa 1f             	sar    $0x1f,%edx
5ffb4af5:	f7 bd f4 fe ff ff    	idivl  0xfffffef4(%ebp)
5ffb4afb:	8b 45 bc             	mov    0xffffffbc(%ebp),%eax
5ffb4afe:	89 d1                	mov    %edx,%ecx
5ffb4b00:	01 c6                	add    %eax,%esi
5ffb4b02:	66 89 95 3a ff ff ff 	mov    %dx,0xffffff3a(%ebp)
5ffb4b09:	89 f2                	mov    %esi,%edx
5ffb4b0b:	89 f0                	mov    %esi,%eax
5ffb4b0d:	c1 fa 1f             	sar    $0x1f,%edx
5ffb4b10:	8b 75 b8             	mov    0xffffffb8(%ebp),%esi
5ffb4b13:	f7 bd f4 fe ff ff    	idivl  0xfffffef4(%ebp)
5ffb4b19:	0f bf c1             	movswl %cx,%eax
5ffb4b1c:	66 8b 4f 24          	mov    0x24(%edi),%cx
5ffb4b20:	66 89 95 38 ff ff ff 	mov    %dx,0xffffff38(%ebp)
5ffb4b27:	81 e1 ff ff 00 00    	and    $0xffff,%ecx
5ffb4b2d:	8b 55 c8             	mov    0xffffffc8(%ebp),%edx
5ffb4b30:	0f af c1             	imul   %ecx,%eax
5ffb4b33:	01 d0                	add    %edx,%eax
5ffb4b35:	66 8b 57 28          	mov    0x28(%edi),%dx
5ffb4b39:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb4b3f:	01 d0                	add    %edx,%eax
5ffb4b41:	01 c0                	add    %eax,%eax
5ffb4b43:	89 85 34 ff ff ff    	mov    %eax,0xffffff34(%ebp)
5ffb4b49:	0f bf 85 38 ff ff ff 	movswl 0xffffff38(%ebp),%eax
5ffb4b50:	0f af c1             	imul   %ecx,%eax
5ffb4b53:	01 f0                	add    %esi,%eax
5ffb4b55:	01 d0                	add    %edx,%eax
5ffb4b57:	39 5d d4             	cmp    %ebx,0xffffffd4(%ebp)
5ffb4b5a:	8d 34 00             	lea    (%eax,%eax,1),%esi
5ffb4b5d:	0f 83 fe 01 00 00    	jae    5ffb4d61 <_CsrScrollConsoleScreenBuffer@12+0x4e1>
5ffb4b63:	8b 45 c8             	mov    0xffffffc8(%ebp),%eax
5ffb4b66:	8b 4d d0             	mov    0xffffffd0(%ebp),%ecx
5ffb4b69:	c6 85 6a ff ff ff 00 	movb   $0x0,0xffffff6a(%ebp)
5ffb4b70:	39 c8                	cmp    %ecx,%eax
5ffb4b72:	7f 7c                	jg     5ffb4bf0 <_CsrScrollConsoleScreenBuffer@12+0x370>
5ffb4b74:	8b 55 cc             	mov    0xffffffcc(%ebp),%edx
5ffb4b77:	8b 5d d4             	mov    0xffffffd4(%ebp),%ebx
5ffb4b7a:	39 da                	cmp    %ebx,%edx
5ffb4b7c:	7f 72                	jg     5ffb4bf0 <_CsrScrollConsoleScreenBuffer@12+0x370>
5ffb4b7e:	8b b5 fc fe ff ff    	mov    0xfffffefc(%ebp),%esi
5ffb4b84:	39 b5 00 ff ff ff    	cmp    %esi,0xffffff00(%ebp)
5ffb4b8a:	0f 8f 66 05 00 00    	jg     5ffb50f6 <_CsrScrollConsoleScreenBuffer@12+0x876>
5ffb4b90:	8b 75 bc             	mov    0xffffffbc(%ebp),%esi
5ffb4b93:	89 b5 f0 fe ff ff    	mov    %esi,0xfffffef0(%ebp)
5ffb4b99:	8b 75 c4             	mov    0xffffffc4(%ebp),%esi
5ffb4b9c:	89 b5 28 ff ff ff    	mov    %esi,0xffffff28(%ebp)
5ffb4ba2:	39 b5 f0 fe ff ff    	cmp    %esi,0xfffffef0(%ebp)
5ffb4ba8:	0f 8f 48 05 00 00    	jg     5ffb50f6 <_CsrScrollConsoleScreenBuffer@12+0x876>
5ffb4bae:	8b b5 f0 fe ff ff    	mov    0xfffffef0(%ebp),%esi
5ffb4bb4:	39 d6                	cmp    %edx,%esi
5ffb4bb6:	7e 02                	jle    5ffb4bba <_CsrScrollConsoleScreenBuffer@12+0x33a>
5ffb4bb8:	89 d6                	mov    %edx,%esi
5ffb4bba:	8b 95 00 ff ff ff    	mov    0xffffff00(%ebp),%edx
5ffb4bc0:	89 75 ac             	mov    %esi,0xffffffac(%ebp)
5ffb4bc3:	39 c2                	cmp    %eax,%edx
5ffb4bc5:	7e 02                	jle    5ffb4bc9 <_CsrScrollConsoleScreenBuffer@12+0x349>
5ffb4bc7:	89 c2                	mov    %eax,%edx
5ffb4bc9:	8b 85 28 ff ff ff    	mov    0xffffff28(%ebp),%eax
5ffb4bcf:	89 55 a8             	mov    %edx,0xffffffa8(%ebp)
5ffb4bd2:	39 d8                	cmp    %ebx,%eax
5ffb4bd4:	7d 02                	jge    5ffb4bd8 <_CsrScrollConsoleScreenBuffer@12+0x358>
5ffb4bd6:	89 d8                	mov    %ebx,%eax
5ffb4bd8:	89 45 b4             	mov    %eax,0xffffffb4(%ebp)
5ffb4bdb:	8b 85 fc fe ff ff    	mov    0xfffffefc(%ebp),%eax
5ffb4be1:	39 c8                	cmp    %ecx,%eax
5ffb4be3:	7d 02                	jge    5ffb4be7 <_CsrScrollConsoleScreenBuffer@12+0x367>
5ffb4be5:	89 c8                	mov    %ecx,%eax
5ffb4be7:	89 45 b0             	mov    %eax,0xffffffb0(%ebp)
5ffb4bea:	eb 32                	jmp    5ffb4c1e <_CsrScrollConsoleScreenBuffer@12+0x39e>
5ffb4bec:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb4bf0:	8b 95 fc fe ff ff    	mov    0xfffffefc(%ebp),%edx
5ffb4bf6:	39 95 00 ff ff ff    	cmp    %edx,0xffffff00(%ebp)
5ffb4bfc:	0f 8e 1d 02 00 00    	jle    5ffb4e1f <_CsrScrollConsoleScreenBuffer@12+0x59f>
5ffb4c02:	c7 45 ac 00 00 00 00 	movl   $0x0,0xffffffac(%ebp)
5ffb4c09:	c7 45 a8 ff ff ff ff 	movl   $0xffffffff,0xffffffa8(%ebp)
5ffb4c10:	c7 45 b4 00 00 00 00 	movl   $0x0,0xffffffb4(%ebp)
5ffb4c17:	c7 45 b0 ff ff ff ff 	movl   $0xffffffff,0xffffffb0(%ebp)
5ffb4c1e:	8b 45 a8             	mov    0xffffffa8(%ebp),%eax
5ffb4c21:	8b 55 b0             	mov    0xffffffb0(%ebp),%edx
5ffb4c24:	39 d0                	cmp    %edx,%eax
5ffb4c26:	0f 8f db 04 00 00    	jg     5ffb5107 <_CsrScrollConsoleScreenBuffer@12+0x887>
5ffb4c2c:	8b 4d ac             	mov    0xffffffac(%ebp),%ecx
5ffb4c2f:	8b 5d b4             	mov    0xffffffb4(%ebp),%ebx
5ffb4c32:	39 d9                	cmp    %ebx,%ecx
5ffb4c34:	0f 8f cd 04 00 00    	jg     5ffb5107 <_CsrScrollConsoleScreenBuffer@12+0x887>
5ffb4c3a:	8b b5 fc fe ff ff    	mov    0xfffffefc(%ebp),%esi
5ffb4c40:	89 45 a8             	mov    %eax,0xffffffa8(%ebp)
5ffb4c43:	89 4d ac             	mov    %ecx,0xffffffac(%ebp)
5ffb4c46:	89 55 b0             	mov    %edx,0xffffffb0(%ebp)
5ffb4c49:	89 5d b4             	mov    %ebx,0xffffffb4(%ebp)
5ffb4c4c:	39 b5 00 ff ff ff    	cmp    %esi,0xffffff00(%ebp)
5ffb4c52:	0f 8f 28 04 00 00    	jg     5ffb5080 <_CsrScrollConsoleScreenBuffer@12+0x800>
5ffb4c58:	8b 75 bc             	mov    0xffffffbc(%ebp),%esi
5ffb4c5b:	89 b5 24 ff ff ff    	mov    %esi,0xffffff24(%ebp)
5ffb4c61:	8b 75 c4             	mov    0xffffffc4(%ebp),%esi
5ffb4c64:	89 b5 20 ff ff ff    	mov    %esi,0xffffff20(%ebp)
5ffb4c6a:	39 b5 24 ff ff ff    	cmp    %esi,0xffffff24(%ebp)
5ffb4c70:	0f 8f 0a 04 00 00    	jg     5ffb5080 <_CsrScrollConsoleScreenBuffer@12+0x800>
5ffb4c76:	39 f1                	cmp    %esi,%ecx
5ffb4c78:	0f 8f 02 04 00 00    	jg     5ffb5080 <_CsrScrollConsoleScreenBuffer@12+0x800>
5ffb4c7e:	3b 85 fc fe ff ff    	cmp    0xfffffefc(%ebp),%eax
5ffb4c84:	0f 8f f6 03 00 00    	jg     5ffb5080 <_CsrScrollConsoleScreenBuffer@12+0x800>
5ffb4c8a:	3b 9d 24 ff ff ff    	cmp    0xffffff24(%ebp),%ebx
5ffb4c90:	0f 8c ea 03 00 00    	jl     5ffb5080 <_CsrScrollConsoleScreenBuffer@12+0x800>
5ffb4c96:	3b 95 00 ff ff ff    	cmp    0xffffff00(%ebp),%edx
5ffb4c9c:	0f 8c de 03 00 00    	jl     5ffb5080 <_CsrScrollConsoleScreenBuffer@12+0x800>
5ffb4ca2:	8b b5 24 ff ff ff    	mov    0xffffff24(%ebp),%esi
5ffb4ca8:	39 ce                	cmp    %ecx,%esi
5ffb4caa:	7d 02                	jge    5ffb4cae <_CsrScrollConsoleScreenBuffer@12+0x42e>
5ffb4cac:	89 ce                	mov    %ecx,%esi
5ffb4cae:	8b 8d 00 ff ff ff    	mov    0xffffff00(%ebp),%ecx
5ffb4cb4:	89 b5 7c ff ff ff    	mov    %esi,0xffffff7c(%ebp)
5ffb4cba:	39 c1                	cmp    %eax,%ecx
5ffb4cbc:	7d 02                	jge    5ffb4cc0 <_CsrScrollConsoleScreenBuffer@12+0x440>
5ffb4cbe:	89 c1                	mov    %eax,%ecx
5ffb4cc0:	8b 85 20 ff ff ff    	mov    0xffffff20(%ebp),%eax
5ffb4cc6:	89 8d 78 ff ff ff    	mov    %ecx,0xffffff78(%ebp)
5ffb4ccc:	39 d8                	cmp    %ebx,%eax
5ffb4cce:	7e 02                	jle    5ffb4cd2 <_CsrScrollConsoleScreenBuffer@12+0x452>
5ffb4cd0:	89 d8                	mov    %ebx,%eax
5ffb4cd2:	89 45 84             	mov    %eax,0xffffff84(%ebp)
5ffb4cd5:	8b 85 fc fe ff ff    	mov    0xfffffefc(%ebp),%eax
5ffb4cdb:	39 d0                	cmp    %edx,%eax
5ffb4cdd:	7e 02                	jle    5ffb4ce1 <_CsrScrollConsoleScreenBuffer@12+0x461>
5ffb4cdf:	89 d0                	mov    %edx,%eax
5ffb4ce1:	89 45 80             	mov    %eax,0xffffff80(%ebp)
5ffb4ce4:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb4ce9:	e9 b6 03 00 00       	jmp    5ffb50a4 <_CsrScrollConsoleScreenBuffer@12+0x824>
5ffb4cee:	89 f6                	mov    %esi,%esi
5ffb4cf0:	8b 4d 10             	mov    0x10(%ebp),%ecx
5ffb4cf3:	89 41 18             	mov    %eax,0x18(%ecx)
5ffb4cf6:	89 d8                	mov    %ebx,%eax
5ffb4cf8:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb4cfb:	5b                   	pop    %ebx
5ffb4cfc:	5e                   	pop    %esi
5ffb4cfd:	5f                   	pop    %edi
5ffb4cfe:	5d                   	pop    %ebp
5ffb4cff:	c2 0c 00             	ret    $0xc
5ffb4d02:	8b 85 00 ff ff ff    	mov    0xffffff00(%ebp),%eax
5ffb4d08:	48                   	dec    %eax
5ffb4d09:	e9 55 fd ff ff       	jmp    5ffb4a63 <_CsrScrollConsoleScreenBuffer@12+0x1e3>
5ffb4d0e:	8d 4a ff             	lea    0xffffffff(%edx),%ecx
5ffb4d11:	e9 31 fd ff ff       	jmp    5ffb4a47 <_CsrScrollConsoleScreenBuffer@12+0x1c7>
5ffb4d16:	66 ff 85 3a ff ff ff 	incw   0xffffff3a(%ebp)
5ffb4d1d:	66 8b 47 24          	mov    0x24(%edi),%ax
5ffb4d21:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb4d26:	0f bf 95 3a ff ff ff 	movswl 0xffffff3a(%ebp),%edx
5ffb4d2d:	8d 34 46             	lea    (%esi,%eax,2),%esi
5ffb4d30:	89 c8                	mov    %ecx,%eax
5ffb4d32:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb4d37:	39 c2                	cmp    %eax,%edx
5ffb4d39:	0f 84 9a 00 00 00    	je     5ffb4dd9 <_CsrScrollConsoleScreenBuffer@12+0x559>
5ffb4d3f:	66 8b 47 24          	mov    0x24(%edi),%ax
5ffb4d43:	8b 8d 34 ff ff ff    	mov    0xffffff34(%ebp),%ecx
5ffb4d49:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb4d4e:	43                   	inc    %ebx
5ffb4d4f:	39 5d d4             	cmp    %ebx,0xffffffd4(%ebp)
5ffb4d52:	8d 0c 41             	lea    (%ecx,%eax,2),%ecx
5ffb4d55:	89 8d 34 ff ff ff    	mov    %ecx,0xffffff34(%ebp)
5ffb4d5b:	0f 82 a1 00 00 00    	jb     5ffb4e02 <_CsrScrollConsoleScreenBuffer@12+0x582>
5ffb4d61:	8b 47 20             	mov    0x20(%edi),%eax
5ffb4d64:	8b 8d 34 ff ff ff    	mov    0xffffff34(%ebp),%ecx
5ffb4d6a:	8d 14 06             	lea    (%esi,%eax,1),%edx
5ffb4d6d:	01 c8                	add    %ecx,%eax
5ffb4d6f:	51                   	push   %ecx
5ffb4d70:	8b 8d 30 ff ff ff    	mov    0xffffff30(%ebp),%ecx
5ffb4d76:	51                   	push   %ecx
5ffb4d77:	50                   	push   %eax
5ffb4d78:	52                   	push   %edx
5ffb4d79:	e8 b2 3e 00 00       	call   5ffb8c30 <_memcpy>
5ffb4d7e:	66 ff 85 38 ff ff ff 	incw   0xffffff38(%ebp)
5ffb4d85:	66 8b 4f 26          	mov    0x26(%edi),%cx
5ffb4d89:	0f bf 95 38 ff ff ff 	movswl 0xffffff38(%ebp),%edx
5ffb4d90:	89 c8                	mov    %ecx,%eax
5ffb4d92:	83 c4 10             	add    $0x10,%esp
5ffb4d95:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb4d9a:	39 c2                	cmp    %eax,%edx
5ffb4d9c:	0f 85 74 ff ff ff    	jne    5ffb4d16 <_CsrScrollConsoleScreenBuffer@12+0x496>
5ffb4da2:	66 8b 47 28          	mov    0x28(%edi),%ax
5ffb4da6:	8b 75 b8             	mov    0xffffffb8(%ebp),%esi
5ffb4da9:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb4dae:	66 c7 85 38 ff ff ff 	movw   $0x0,0xffffff38(%ebp)
5ffb4db5:	00 00 
5ffb4db7:	66 ff 85 3a ff ff ff 	incw   0xffffff3a(%ebp)
5ffb4dbe:	01 f0                	add    %esi,%eax
5ffb4dc0:	0f bf 95 3a ff ff ff 	movswl 0xffffff3a(%ebp),%edx
5ffb4dc7:	8d 34 00             	lea    (%eax,%eax,1),%esi
5ffb4dca:	89 c8                	mov    %ecx,%eax
5ffb4dcc:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb4dd1:	39 c2                	cmp    %eax,%edx
5ffb4dd3:	0f 85 66 ff ff ff    	jne    5ffb4d3f <_CsrScrollConsoleScreenBuffer@12+0x4bf>
5ffb4dd9:	66 8b 47 28          	mov    0x28(%edi),%ax
5ffb4ddd:	8b 55 c8             	mov    0xffffffc8(%ebp),%edx
5ffb4de0:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb4de5:	43                   	inc    %ebx
5ffb4de6:	01 d0                	add    %edx,%eax
5ffb4de8:	66 c7 85 3a ff ff ff 	movw   $0x0,0xffffff3a(%ebp)
5ffb4def:	00 00 
5ffb4df1:	01 c0                	add    %eax,%eax
5ffb4df3:	39 5d d4             	cmp    %ebx,0xffffffd4(%ebp)
5ffb4df6:	89 85 34 ff ff ff    	mov    %eax,0xffffff34(%ebp)
5ffb4dfc:	0f 83 5f ff ff ff    	jae    5ffb4d61 <_CsrScrollConsoleScreenBuffer@12+0x4e1>
5ffb4e02:	8b 75 b8             	mov    0xffffffb8(%ebp),%esi
5ffb4e05:	8b 45 c0             	mov    0xffffffc0(%ebp),%eax
5ffb4e08:	8b bd 70 ff ff ff    	mov    0xffffff70(%ebp),%edi
5ffb4e0e:	89 b5 00 ff ff ff    	mov    %esi,0xffffff00(%ebp)
5ffb4e14:	89 85 fc fe ff ff    	mov    %eax,0xfffffefc(%ebp)
5ffb4e1a:	e9 44 fd ff ff       	jmp    5ffb4b63 <_CsrScrollConsoleScreenBuffer@12+0x2e3>
5ffb4e1f:	8b 45 bc             	mov    0xffffffbc(%ebp),%eax
5ffb4e22:	8b 55 c4             	mov    0xffffffc4(%ebp),%edx
5ffb4e25:	39 d0                	cmp    %edx,%eax
5ffb4e27:	0f 8f d5 fd ff ff    	jg     5ffb4c02 <_CsrScrollConsoleScreenBuffer@12+0x382>
5ffb4e2d:	8b 8d 00 ff ff ff    	mov    0xffffff00(%ebp),%ecx
5ffb4e33:	8b b5 fc fe ff ff    	mov    0xfffffefc(%ebp),%esi
5ffb4e39:	89 4d a8             	mov    %ecx,0xffffffa8(%ebp)
5ffb4e3c:	89 45 ac             	mov    %eax,0xffffffac(%ebp)
5ffb4e3f:	89 75 b0             	mov    %esi,0xffffffb0(%ebp)
5ffb4e42:	89 55 b4             	mov    %edx,0xffffffb4(%ebp)
5ffb4e45:	e9 d4 fd ff ff       	jmp    5ffb4c1e <_CsrScrollConsoleScreenBuffer@12+0x39e>
5ffb4e4a:	8b 8d 74 ff ff ff    	mov    0xffffff74(%ebp),%ecx
5ffb4e50:	85 c9                	test   %ecx,%ecx
5ffb4e52:	0f 85 f8 04 00 00    	jne    5ffb5350 <_CsrScrollConsoleScreenBuffer@12+0xad0>
5ffb4e58:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb4e5b:	89 5a 18             	mov    %ebx,0x18(%edx)
5ffb4e5e:	e9 93 fe ff ff       	jmp    5ffb4cf6 <_CsrScrollConsoleScreenBuffer@12+0x476>
5ffb4e63:	39 9d 60 ff ff ff    	cmp    %ebx,0xffffff60(%ebp)
5ffb4e69:	0f 8f 33 fb ff ff    	jg     5ffb49a2 <_CsrScrollConsoleScreenBuffer@12+0x122>
5ffb4e6f:	39 ce                	cmp    %ecx,%esi
5ffb4e71:	0f 8f 2b fb ff ff    	jg     5ffb49a2 <_CsrScrollConsoleScreenBuffer@12+0x122>
5ffb4e77:	39 ca                	cmp    %ecx,%edx
5ffb4e79:	0f 8f 23 fb ff ff    	jg     5ffb49a2 <_CsrScrollConsoleScreenBuffer@12+0x122>
5ffb4e7f:	39 da                	cmp    %ebx,%edx
5ffb4e81:	0f 8f 1b fb ff ff    	jg     5ffb49a2 <_CsrScrollConsoleScreenBuffer@12+0x122>
5ffb4e87:	39 b5 4c ff ff ff    	cmp    %esi,0xffffff4c(%ebp)
5ffb4e8d:	0f 8c 0f fb ff ff    	jl     5ffb49a2 <_CsrScrollConsoleScreenBuffer@12+0x122>
5ffb4e93:	8b 95 60 ff ff ff    	mov    0xffffff60(%ebp),%edx
5ffb4e99:	39 d0                	cmp    %edx,%eax
5ffb4e9b:	0f 8c 01 fb ff ff    	jl     5ffb49a2 <_CsrScrollConsoleScreenBuffer@12+0x122>
5ffb4ea1:	89 f0                	mov    %esi,%eax
5ffb4ea3:	83 fe 00             	cmp    $0x0,%esi
5ffb4ea6:	7d 02                	jge    5ffb4eaa <_CsrScrollConsoleScreenBuffer@12+0x62a>
5ffb4ea8:	31 c0                	xor    %eax,%eax
5ffb4eaa:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
5ffb4ead:	8b 85 60 ff ff ff    	mov    0xffffff60(%ebp),%eax
5ffb4eb3:	83 f8 00             	cmp    $0x0,%eax
5ffb4eb6:	7d 02                	jge    5ffb4eba <_CsrScrollConsoleScreenBuffer@12+0x63a>
5ffb4eb8:	31 c0                	xor    %eax,%eax
5ffb4eba:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)
5ffb4ebd:	3b 8d 4c ff ff ff    	cmp    0xffffff4c(%ebp),%ecx
5ffb4ec3:	89 c8                	mov    %ecx,%eax
5ffb4ec5:	7e 06                	jle    5ffb4ecd <_CsrScrollConsoleScreenBuffer@12+0x64d>
5ffb4ec7:	8b 85 4c ff ff ff    	mov    0xffffff4c(%ebp),%eax
5ffb4ecd:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
5ffb4ed0:	3b 9d 48 ff ff ff    	cmp    0xffffff48(%ebp),%ebx
5ffb4ed6:	89 d8                	mov    %ebx,%eax
5ffb4ed8:	7e 06                	jle    5ffb4ee0 <_CsrScrollConsoleScreenBuffer@12+0x660>
5ffb4eda:	8b 85 48 ff ff ff    	mov    0xffffff48(%ebp),%eax
5ffb4ee0:	ba 01 00 00 00       	mov    $0x1,%edx
5ffb4ee5:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
5ffb4ee8:	e9 d3 fa ff ff       	jmp    5ffb49c0 <_CsrScrollConsoleScreenBuffer@12+0x140>
5ffb4eed:	8d 76 00             	lea    0x0(%esi),%esi
5ffb4ef0:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
5ffb4ef3:	89 85 f4 fe ff ff    	mov    %eax,0xfffffef4(%ebp)
5ffb4ef9:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
5ffb4efc:	89 85 40 ff ff ff    	mov    %eax,0xffffff40(%ebp)
5ffb4f02:	39 85 f4 fe ff ff    	cmp    %eax,0xfffffef4(%ebp)
5ffb4f08:	0f 8f d7 fa ff ff    	jg     5ffb49e5 <_CsrScrollConsoleScreenBuffer@12+0x165>
5ffb4f0e:	8b 85 54 ff ff ff    	mov    0xffffff54(%ebp),%eax
5ffb4f14:	39 85 5c ff ff ff    	cmp    %eax,0xffffff5c(%ebp)
5ffb4f1a:	0f 8f c5 fa ff ff    	jg     5ffb49e5 <_CsrScrollConsoleScreenBuffer@12+0x165>
5ffb4f20:	8b 85 50 ff ff ff    	mov    0xffffff50(%ebp),%eax
5ffb4f26:	39 85 58 ff ff ff    	cmp    %eax,0xffffff58(%ebp)
5ffb4f2c:	0f 8f b3 fa ff ff    	jg     5ffb49e5 <_CsrScrollConsoleScreenBuffer@12+0x165>
5ffb4f32:	39 85 f4 fe ff ff    	cmp    %eax,0xfffffef4(%ebp)
5ffb4f38:	0f 8f a7 fa ff ff    	jg     5ffb49e5 <_CsrScrollConsoleScreenBuffer@12+0x165>
5ffb4f3e:	3b 95 54 ff ff ff    	cmp    0xffffff54(%ebp),%edx
5ffb4f44:	0f 8f 9b fa ff ff    	jg     5ffb49e5 <_CsrScrollConsoleScreenBuffer@12+0x165>
5ffb4f4a:	8b 85 58 ff ff ff    	mov    0xffffff58(%ebp),%eax
5ffb4f50:	39 85 40 ff ff ff    	cmp    %eax,0xffffff40(%ebp)
5ffb4f56:	0f 8c 89 fa ff ff    	jl     5ffb49e5 <_CsrScrollConsoleScreenBuffer@12+0x165>
5ffb4f5c:	8b 85 5c ff ff ff    	mov    0xffffff5c(%ebp),%eax
5ffb4f62:	39 85 44 ff ff ff    	cmp    %eax,0xffffff44(%ebp)
5ffb4f68:	0f 8c 77 fa ff ff    	jl     5ffb49e5 <_CsrScrollConsoleScreenBuffer@12+0x165>
5ffb4f6e:	8b 85 58 ff ff ff    	mov    0xffffff58(%ebp),%eax
5ffb4f74:	89 85 3c ff ff ff    	mov    %eax,0xffffff3c(%ebp)
5ffb4f7a:	8b 85 f4 fe ff ff    	mov    0xfffffef4(%ebp),%eax
5ffb4f80:	39 85 3c ff ff ff    	cmp    %eax,0xffffff3c(%ebp)
5ffb4f86:	7d 06                	jge    5ffb4f8e <_CsrScrollConsoleScreenBuffer@12+0x70e>
5ffb4f88:	89 85 3c ff ff ff    	mov    %eax,0xffffff3c(%ebp)
5ffb4f8e:	8b 85 3c ff ff ff    	mov    0xffffff3c(%ebp),%eax
5ffb4f94:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
5ffb4f97:	8b 85 5c ff ff ff    	mov    0xffffff5c(%ebp),%eax
5ffb4f9d:	39 d0                	cmp    %edx,%eax
5ffb4f9f:	7d 02                	jge    5ffb4fa3 <_CsrScrollConsoleScreenBuffer@12+0x723>
5ffb4fa1:	89 d0                	mov    %edx,%eax
5ffb4fa3:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)
5ffb4fa6:	8b 85 50 ff ff ff    	mov    0xffffff50(%ebp),%eax
5ffb4fac:	3b 85 40 ff ff ff    	cmp    0xffffff40(%ebp),%eax
5ffb4fb2:	7e 06                	jle    5ffb4fba <_CsrScrollConsoleScreenBuffer@12+0x73a>
5ffb4fb4:	8b 85 40 ff ff ff    	mov    0xffffff40(%ebp),%eax
5ffb4fba:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
5ffb4fbd:	8b 85 54 ff ff ff    	mov    0xffffff54(%ebp),%eax
5ffb4fc3:	3b 85 44 ff ff ff    	cmp    0xffffff44(%ebp),%eax
5ffb4fc9:	7e 06                	jle    5ffb4fd1 <_CsrScrollConsoleScreenBuffer@12+0x751>
5ffb4fcb:	8b 85 44 ff ff ff    	mov    0xffffff44(%ebp),%eax
5ffb4fd1:	ba 01 00 00 00       	mov    $0x1,%edx
5ffb4fd6:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
5ffb4fd9:	e9 25 fa ff ff       	jmp    5ffb4a03 <_CsrScrollConsoleScreenBuffer@12+0x183>
5ffb4fde:	89 f6                	mov    %esi,%esi
5ffb4fe0:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
5ffb4fe3:	3b 85 48 ff ff ff    	cmp    0xffffff48(%ebp),%eax
5ffb4fe9:	0f 8f 8a fa ff ff    	jg     5ffb4a79 <_CsrScrollConsoleScreenBuffer@12+0x1f9>
5ffb4fef:	8b 5d dc             	mov    0xffffffdc(%ebp),%ebx
5ffb4ff2:	3b 9d 4c ff ff ff    	cmp    0xffffff4c(%ebp),%ebx
5ffb4ff8:	0f 8f 7b fa ff ff    	jg     5ffb4a79 <_CsrScrollConsoleScreenBuffer@12+0x1f9>
5ffb4ffe:	3b 95 4c ff ff ff    	cmp    0xffffff4c(%ebp),%edx
5ffb5004:	0f 8f 6f fa ff ff    	jg     5ffb4a79 <_CsrScrollConsoleScreenBuffer@12+0x1f9>
5ffb500a:	8b b5 48 ff ff ff    	mov    0xffffff48(%ebp),%esi
5ffb5010:	39 b5 00 ff ff ff    	cmp    %esi,0xffffff00(%ebp)
5ffb5016:	0f 8f 5d fa ff ff    	jg     5ffb4a79 <_CsrScrollConsoleScreenBuffer@12+0x1f9>
5ffb501c:	39 d9                	cmp    %ebx,%ecx
5ffb501e:	0f 8c 55 fa ff ff    	jl     5ffb4a79 <_CsrScrollConsoleScreenBuffer@12+0x1f9>
5ffb5024:	39 85 fc fe ff ff    	cmp    %eax,0xfffffefc(%ebp)
5ffb502a:	0f 8c 49 fa ff ff    	jl     5ffb4a79 <_CsrScrollConsoleScreenBuffer@12+0x1f9>
5ffb5030:	39 d3                	cmp    %edx,%ebx
5ffb5032:	7d 02                	jge    5ffb5036 <_CsrScrollConsoleScreenBuffer@12+0x7b6>
5ffb5034:	89 d3                	mov    %edx,%ebx
5ffb5036:	89 5d bc             	mov    %ebx,0xffffffbc(%ebp)
5ffb5039:	3b 85 00 ff ff ff    	cmp    0xffffff00(%ebp),%eax
5ffb503f:	7d 06                	jge    5ffb5047 <_CsrScrollConsoleScreenBuffer@12+0x7c7>
5ffb5041:	8b 85 00 ff ff ff    	mov    0xffffff00(%ebp),%eax
5ffb5047:	89 45 b8             	mov    %eax,0xffffffb8(%ebp)
5ffb504a:	8b 85 4c ff ff ff    	mov    0xffffff4c(%ebp),%eax
5ffb5050:	39 c8                	cmp    %ecx,%eax
5ffb5052:	7e 02                	jle    5ffb5056 <_CsrScrollConsoleScreenBuffer@12+0x7d6>
5ffb5054:	89 c8                	mov    %ecx,%eax
5ffb5056:	89 45 c4             	mov    %eax,0xffffffc4(%ebp)
5ffb5059:	8b 85 48 ff ff ff    	mov    0xffffff48(%ebp),%eax
5ffb505f:	3b 85 fc fe ff ff    	cmp    0xfffffefc(%ebp),%eax
5ffb5065:	7e 06                	jle    5ffb506d <_CsrScrollConsoleScreenBuffer@12+0x7ed>
5ffb5067:	8b 85 fc fe ff ff    	mov    0xfffffefc(%ebp),%eax
5ffb506d:	89 45 c0             	mov    %eax,0xffffffc0(%ebp)
5ffb5070:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb5075:	e9 1d fa ff ff       	jmp    5ffb4a97 <_CsrScrollConsoleScreenBuffer@12+0x217>
5ffb507a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb5080:	c7 85 7c ff ff ff 00 	movl   $0x0,0xffffff7c(%ebp)
5ffb5087:	00 00 00 
5ffb508a:	c7 85 78 ff ff ff ff 	movl   $0xffffffff,0xffffff78(%ebp)
5ffb5091:	ff ff ff 
5ffb5094:	c7 45 84 00 00 00 00 	movl   $0x0,0xffffff84(%ebp)
5ffb509b:	c7 45 80 ff ff ff ff 	movl   $0xffffffff,0xffffff80(%ebp)
5ffb50a2:	31 c0                	xor    %eax,%eax
5ffb50a4:	85 c0                	test   %eax,%eax
5ffb50a6:	74 47                	je     5ffb50ef <_CsrScrollConsoleScreenBuffer@12+0x86f>
5ffb50a8:	8b 8d 78 ff ff ff    	mov    0xffffff78(%ebp),%ecx
5ffb50ae:	8b 55 a8             	mov    0xffffffa8(%ebp),%edx
5ffb50b1:	31 db                	xor    %ebx,%ebx
5ffb50b3:	39 d1                	cmp    %edx,%ecx
5ffb50b5:	0f 84 63 02 00 00    	je     5ffb531e <_CsrScrollConsoleScreenBuffer@12+0xa9e>
5ffb50bb:	85 db                	test   %ebx,%ebx
5ffb50bd:	75 48                	jne    5ffb5107 <_CsrScrollConsoleScreenBuffer@12+0x887>
5ffb50bf:	8b 9d 7c ff ff ff    	mov    0xffffff7c(%ebp),%ebx
5ffb50c5:	8b 75 ac             	mov    0xffffffac(%ebp),%esi
5ffb50c8:	39 f3                	cmp    %esi,%ebx
5ffb50ca:	0f 84 fa 02 00 00    	je     5ffb53ca <_CsrScrollConsoleScreenBuffer@12+0xb4a>
5ffb50d0:	39 d1                	cmp    %edx,%ecx
5ffb50d2:	75 1b                	jne    5ffb50ef <_CsrScrollConsoleScreenBuffer@12+0x86f>
5ffb50d4:	8b 45 b0             	mov    0xffffffb0(%ebp),%eax
5ffb50d7:	39 45 80             	cmp    %eax,0xffffff80(%ebp)
5ffb50da:	75 13                	jne    5ffb50ef <_CsrScrollConsoleScreenBuffer@12+0x86f>
5ffb50dc:	39 f3                	cmp    %esi,%ebx
5ffb50de:	0f 84 0f 03 00 00    	je     5ffb53f3 <_CsrScrollConsoleScreenBuffer@12+0xb73>
5ffb50e4:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
5ffb50e7:	39 45 84             	cmp    %eax,0xffffff84(%ebp)
5ffb50ea:	75 03                	jne    5ffb50ef <_CsrScrollConsoleScreenBuffer@12+0x86f>
5ffb50ec:	89 5d b4             	mov    %ebx,0xffffffb4(%ebp)
5ffb50ef:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb50f4:	eb 2f                	jmp    5ffb5125 <_CsrScrollConsoleScreenBuffer@12+0x8a5>
5ffb50f6:	89 45 a8             	mov    %eax,0xffffffa8(%ebp)
5ffb50f9:	89 55 ac             	mov    %edx,0xffffffac(%ebp)
5ffb50fc:	89 4d b0             	mov    %ecx,0xffffffb0(%ebp)
5ffb50ff:	89 5d b4             	mov    %ebx,0xffffffb4(%ebp)
5ffb5102:	e9 17 fb ff ff       	jmp    5ffb4c1e <_CsrScrollConsoleScreenBuffer@12+0x39e>
5ffb5107:	c7 45 ac 00 00 00 00 	movl   $0x0,0xffffffac(%ebp)
5ffb510e:	c7 45 a8 ff ff ff ff 	movl   $0xffffffff,0xffffffa8(%ebp)
5ffb5115:	c7 45 b4 00 00 00 00 	movl   $0x0,0xffffffb4(%ebp)
5ffb511c:	c7 45 b0 ff ff ff ff 	movl   $0xffffffff,0xffffffb0(%ebp)
5ffb5123:	31 c0                	xor    %eax,%eax
5ffb5125:	85 c0                	test   %eax,%eax
5ffb5127:	0f 84 63 01 00 00    	je     5ffb5290 <_CsrScrollConsoleScreenBuffer@12+0xa10>
5ffb512d:	8b 75 ac             	mov    0xffffffac(%ebp),%esi
5ffb5130:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb5133:	46                   	inc    %esi
5ffb5134:	8b 95 74 ff ff ff    	mov    0xffffff74(%ebp),%edx
5ffb513a:	89 75 ac             	mov    %esi,0xffffffac(%ebp)
5ffb513d:	8b 58 20             	mov    0x20(%eax),%ebx
5ffb5140:	85 db                	test   %ebx,%ebx
5ffb5142:	0f 85 b0 01 00 00    	jne    5ffb52f8 <_CsrScrollConsoleScreenBuffer@12+0xa78>
5ffb5148:	8a 85 6c ff ff ff    	mov    0xffffff6c(%ebp),%al
5ffb514e:	88 85 6b ff ff ff    	mov    %al,0xffffff6b(%ebp)
5ffb5154:	66 8b 57 2a          	mov    0x2a(%edi),%dx
5ffb5158:	8b 75 ac             	mov    0xffffffac(%ebp),%esi
5ffb515b:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb5161:	66 8b 47 26          	mov    0x26(%edi),%ax
5ffb5165:	01 f2                	add    %esi,%edx
5ffb5167:	66 89 85 06 ff ff ff 	mov    %ax,0xffffff06(%ebp)
5ffb516e:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb5173:	8b 5d a8             	mov    0xffffffa8(%ebp),%ebx
5ffb5176:	89 c1                	mov    %eax,%ecx
5ffb5178:	89 d0                	mov    %edx,%eax
5ffb517a:	c1 fa 1f             	sar    $0x1f,%edx
5ffb517d:	89 b5 0c ff ff ff    	mov    %esi,0xffffff0c(%ebp)
5ffb5183:	f7 f9                	idiv   %ecx
5ffb5185:	66 89 95 1e ff ff ff 	mov    %dx,0xffffff1e(%ebp)
5ffb518c:	66 8b 47 24          	mov    0x24(%edi),%ax
5ffb5190:	0f bf 95 1e ff ff ff 	movswl 0xffffff1e(%ebp),%edx
5ffb5197:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb519c:	8b 75 b0             	mov    0xffffffb0(%ebp),%esi
5ffb519f:	0f af d0             	imul   %eax,%edx
5ffb51a2:	89 85 10 ff ff ff    	mov    %eax,0xffffff10(%ebp)
5ffb51a8:	66 8b 47 28          	mov    0x28(%edi),%ax
5ffb51ac:	01 da                	add    %ebx,%edx
5ffb51ae:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb51b3:	01 c2                	add    %eax,%edx
5ffb51b5:	39 f3                	cmp    %esi,%ebx
5ffb51b7:	8d 0c 12             	lea    (%edx,%edx,1),%ecx
5ffb51ba:	0f 8f 2b 01 00 00    	jg     5ffb52eb <_CsrScrollConsoleScreenBuffer@12+0xa6b>
5ffb51c0:	89 d8                	mov    %ebx,%eax
5ffb51c2:	8b 95 10 ff ff ff    	mov    0xffffff10(%ebp),%edx
5ffb51c8:	29 f0                	sub    %esi,%eax
5ffb51ca:	01 d0                	add    %edx,%eax
5ffb51cc:	8d 44 00 fe          	lea    0xfffffffe(%eax,%eax,1),%eax
5ffb51d0:	8b 95 0c ff ff ff    	mov    0xffffff0c(%ebp),%edx
5ffb51d6:	89 85 18 ff ff ff    	mov    %eax,0xffffff18(%ebp)
5ffb51dc:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
5ffb51df:	89 95 14 ff ff ff    	mov    %edx,0xffffff14(%ebp)
5ffb51e5:	89 85 08 ff ff ff    	mov    %eax,0xffffff08(%ebp)
5ffb51eb:	39 d0                	cmp    %edx,%eax
5ffb51ed:	0f 82 90 00 00 00    	jb     5ffb5283 <_CsrScrollConsoleScreenBuffer@12+0xa03>
5ffb51f3:	0f bf c3             	movswl %bx,%eax
5ffb51f6:	39 f0                	cmp    %esi,%eax
5ffb51f8:	7f 40                	jg     5ffb523a <_CsrScrollConsoleScreenBuffer@12+0x9ba>
5ffb51fa:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb5200:	8b 57 20             	mov    0x20(%edi),%edx
5ffb5203:	8a 85 6b ff ff ff    	mov    0xffffff6b(%ebp),%al
5ffb5209:	43                   	inc    %ebx
5ffb520a:	88 04 11             	mov    %al,(%ecx,%edx,1)
5ffb520d:	41                   	inc    %ecx
5ffb520e:	8b 57 20             	mov    0x20(%edi),%edx
5ffb5211:	66 8b 85 6e ff ff ff 	mov    0xffffff6e(%ebp),%ax
5ffb5218:	88 04 11             	mov    %al,(%ecx,%edx,1)
5ffb521b:	41                   	inc    %ecx
5ffb521c:	0f bf c3             	movswl %bx,%eax
5ffb521f:	8b 75 b0             	mov    0xffffffb0(%ebp),%esi
5ffb5222:	39 f0                	cmp    %esi,%eax
5ffb5224:	7e da                	jle    5ffb5200 <_CsrScrollConsoleScreenBuffer@12+0x980>
5ffb5226:	66 8b 57 26          	mov    0x26(%edi),%dx
5ffb522a:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
5ffb522d:	66 89 95 06 ff ff ff 	mov    %dx,0xffffff06(%ebp)
5ffb5234:	89 85 08 ff ff ff    	mov    %eax,0xffffff08(%ebp)
5ffb523a:	66 ff 85 1e ff ff ff 	incw   0xffffff1e(%ebp)
5ffb5241:	66 8b 85 06 ff ff ff 	mov    0xffffff06(%ebp),%ax
5ffb5248:	0f bf 95 1e ff ff ff 	movswl 0xffffff1e(%ebp),%edx
5ffb524f:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb5254:	39 c2                	cmp    %eax,%edx
5ffb5256:	74 6d                	je     5ffb52c5 <_CsrScrollConsoleScreenBuffer@12+0xa45>
5ffb5258:	8b 85 18 ff ff ff    	mov    0xffffff18(%ebp),%eax
5ffb525e:	01 c1                	add    %eax,%ecx
5ffb5260:	8b 9d 14 ff ff ff    	mov    0xffffff14(%ebp),%ebx
5ffb5266:	43                   	inc    %ebx
5ffb5267:	89 9d 14 ff ff ff    	mov    %ebx,0xffffff14(%ebp)
5ffb526d:	8b 95 14 ff ff ff    	mov    0xffffff14(%ebp),%edx
5ffb5273:	39 95 08 ff ff ff    	cmp    %edx,0xffffff08(%ebp)
5ffb5279:	72 08                	jb     5ffb5283 <_CsrScrollConsoleScreenBuffer@12+0xa03>
5ffb527b:	8b 5d a8             	mov    0xffffffa8(%ebp),%ebx
5ffb527e:	e9 70 ff ff ff       	jmp    5ffb51f3 <_CsrScrollConsoleScreenBuffer@12+0x973>
5ffb5283:	c6 85 6a ff ff ff 01 	movb   $0x1,0xffffff6a(%ebp)
5ffb528a:	8b bd 70 ff ff ff    	mov    0xffffff70(%ebp),%edi
5ffb5290:	8b 95 74 ff ff ff    	mov    0xffffff74(%ebp),%edx
5ffb5296:	85 d2                	test   %edx,%edx
5ffb5298:	74 09                	je     5ffb52a3 <_CsrScrollConsoleScreenBuffer@12+0xa23>
5ffb529a:	39 7a 38             	cmp    %edi,0x38(%edx)
5ffb529d:	0f 84 b7 00 00 00    	je     5ffb535a <_CsrScrollConsoleScreenBuffer@12+0xada>
5ffb52a3:	89 f9                	mov    %edi,%ecx
5ffb52a5:	e8 16 be ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb52aa:	8b 8d 74 ff ff ff    	mov    0xffffff74(%ebp),%ecx
5ffb52b0:	85 c9                	test   %ecx,%ecx
5ffb52b2:	75 30                	jne    5ffb52e4 <_CsrScrollConsoleScreenBuffer@12+0xa64>
5ffb52b4:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb52b7:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
5ffb52be:	31 c0                	xor    %eax,%eax
5ffb52c0:	e9 55 f7 ff ff       	jmp    5ffb4a1a <_CsrScrollConsoleScreenBuffer@12+0x19a>
5ffb52c5:	66 8b 47 28          	mov    0x28(%edi),%ax
5ffb52c9:	8b 55 a8             	mov    0xffffffa8(%ebp),%edx
5ffb52cc:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb52d1:	66 c7 85 1e ff ff ff 	movw   $0x0,0xffffff1e(%ebp)
5ffb52d8:	00 00 
5ffb52da:	01 d0                	add    %edx,%eax
5ffb52dc:	8d 0c 00             	lea    (%eax,%eax,1),%ecx
5ffb52df:	e9 7c ff ff ff       	jmp    5ffb5260 <_CsrScrollConsoleScreenBuffer@12+0x9e0>
5ffb52e4:	e8 d7 bd ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb52e9:	eb c9                	jmp    5ffb52b4 <_CsrScrollConsoleScreenBuffer@12+0xa34>
5ffb52eb:	8b 85 10 ff ff ff    	mov    0xffffff10(%ebp),%eax
5ffb52f1:	01 c0                	add    %eax,%eax
5ffb52f3:	e9 d8 fe ff ff       	jmp    5ffb51d0 <_CsrScrollConsoleScreenBuffer@12+0x950>
5ffb52f8:	8d 8d 6c ff ff ff    	lea    0xffffff6c(%ebp),%ecx
5ffb52fe:	8d 85 6b ff ff ff    	lea    0xffffff6b(%ebp),%eax
5ffb5304:	6a 00                	push   $0x0
5ffb5306:	6a 00                	push   $0x0
5ffb5308:	6a 01                	push   $0x1
5ffb530a:	50                   	push   %eax
5ffb530b:	6a 01                	push   $0x1
5ffb530d:	51                   	push   %ecx
5ffb530e:	6a 00                	push   $0x0
5ffb5310:	8b 4a 68             	mov    0x68(%edx),%ecx
5ffb5313:	51                   	push   %ecx
5ffb5314:	e8 07 3a 00 00       	call   5ffb8d20 <_WideCharToMultiByte@32>
5ffb5319:	e9 36 fe ff ff       	jmp    5ffb5154 <_CsrScrollConsoleScreenBuffer@12+0x8d4>
5ffb531e:	8b 45 b0             	mov    0xffffffb0(%ebp),%eax
5ffb5321:	39 45 80             	cmp    %eax,0xffffff80(%ebp)
5ffb5324:	0f 85 91 fd ff ff    	jne    5ffb50bb <_CsrScrollConsoleScreenBuffer@12+0x83b>
5ffb532a:	8b 45 ac             	mov    0xffffffac(%ebp),%eax
5ffb532d:	39 85 7c ff ff ff    	cmp    %eax,0xffffff7c(%ebp)
5ffb5333:	0f 85 82 fd ff ff    	jne    5ffb50bb <_CsrScrollConsoleScreenBuffer@12+0x83b>
5ffb5339:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
5ffb533c:	39 45 84             	cmp    %eax,0xffffff84(%ebp)
5ffb533f:	0f 85 76 fd ff ff    	jne    5ffb50bb <_CsrScrollConsoleScreenBuffer@12+0x83b>
5ffb5345:	b3 01                	mov    $0x1,%bl
5ffb5347:	e9 6f fd ff ff       	jmp    5ffb50bb <_CsrScrollConsoleScreenBuffer@12+0x83b>
5ffb534c:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb5350:	e8 6b bd ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb5355:	e9 fe fa ff ff       	jmp    5ffb4e58 <_CsrScrollConsoleScreenBuffer@12+0x5d8>
5ffb535a:	51                   	push   %ecx
5ffb535b:	51                   	push   %ecx
5ffb535c:	8d 4d b8             	lea    0xffffffb8(%ebp),%ecx
5ffb535f:	8b 42 70             	mov    0x70(%edx),%eax
5ffb5362:	51                   	push   %ecx
5ffb5363:	52                   	push   %edx
5ffb5364:	ff 50 08             	call   *0x8(%eax)
5ffb5367:	80 bd 6a ff ff ff 00 	cmpb   $0x0,0xffffff6a(%ebp)
5ffb536e:	58                   	pop    %eax
5ffb536f:	5a                   	pop    %edx
5ffb5370:	75 0b                	jne    5ffb537d <_CsrScrollConsoleScreenBuffer@12+0xafd>
5ffb5372:	8b bd 70 ff ff ff    	mov    0xffffff70(%ebp),%edi
5ffb5378:	e9 26 ff ff ff       	jmp    5ffb52a3 <_CsrScrollConsoleScreenBuffer@12+0xa23>
5ffb537d:	50                   	push   %eax
5ffb537e:	50                   	push   %eax
5ffb537f:	8d 75 a8             	lea    0xffffffa8(%ebp),%esi
5ffb5382:	8b 85 74 ff ff ff    	mov    0xffffff74(%ebp),%eax
5ffb5388:	8b 50 70             	mov    0x70(%eax),%edx
5ffb538b:	56                   	push   %esi
5ffb538c:	50                   	push   %eax
5ffb538d:	ff 52 08             	call   *0x8(%edx)
5ffb5390:	5e                   	pop    %esi
5ffb5391:	5f                   	pop    %edi
5ffb5392:	eb de                	jmp    5ffb5372 <_CsrScrollConsoleScreenBuffer@12+0xaf2>
5ffb5394:	89 f9                	mov    %edi,%ecx
5ffb5396:	e8 25 bd ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb539b:	8b 4d 10             	mov    0x10(%ebp),%ecx
5ffb539e:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
5ffb53a3:	c7 41 18 0d 00 00 c0 	movl   $0xc000000d,0x18(%ecx)
5ffb53aa:	e9 49 f9 ff ff       	jmp    5ffb4cf8 <_CsrScrollConsoleScreenBuffer@12+0x478>
5ffb53af:	89 f9                	mov    %edi,%ecx
5ffb53b1:	e8 0a bd ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb53b6:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb53b9:	c7 40 18 0d 00 00 c0 	movl   $0xc000000d,0x18(%eax)
5ffb53c0:	b8 0d 00 00 c0       	mov    $0xc000000d,%eax
5ffb53c5:	e9 2e f9 ff ff       	jmp    5ffb4cf8 <_CsrScrollConsoleScreenBuffer@12+0x478>
5ffb53ca:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
5ffb53cd:	39 45 84             	cmp    %eax,0xffffff84(%ebp)
5ffb53d0:	0f 85 fa fc ff ff    	jne    5ffb50d0 <_CsrScrollConsoleScreenBuffer@12+0x850>
5ffb53d6:	39 d1                	cmp    %edx,%ecx
5ffb53d8:	74 29                	je     5ffb5403 <_CsrScrollConsoleScreenBuffer@12+0xb83>
5ffb53da:	8b 45 b0             	mov    0xffffffb0(%ebp),%eax
5ffb53dd:	39 45 80             	cmp    %eax,0xffffff80(%ebp)
5ffb53e0:	0f 85 09 fd ff ff    	jne    5ffb50ef <_CsrScrollConsoleScreenBuffer@12+0x86f>
5ffb53e6:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb53eb:	89 4d b0             	mov    %ecx,0xffffffb0(%ebp)
5ffb53ee:	e9 32 fd ff ff       	jmp    5ffb5125 <_CsrScrollConsoleScreenBuffer@12+0x8a5>
5ffb53f3:	8b 45 84             	mov    0xffffff84(%ebp),%eax
5ffb53f6:	89 45 ac             	mov    %eax,0xffffffac(%ebp)
5ffb53f9:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb53fe:	e9 22 fd ff ff       	jmp    5ffb5125 <_CsrScrollConsoleScreenBuffer@12+0x8a5>
5ffb5403:	8b 45 80             	mov    0xffffff80(%ebp),%eax
5ffb5406:	89 45 a8             	mov    %eax,0xffffffa8(%ebp)
5ffb5409:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb540e:	e9 12 fd ff ff       	jmp    5ffb5125 <_CsrScrollConsoleScreenBuffer@12+0x8a5>
5ffb5413:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb5419:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb5420 <_CsrReadConsoleOutputChar@12>:

CSR_API(CsrReadConsoleOutputChar)
{
5ffb5420:	55                   	push   %ebp
5ffb5421:	89 e5                	mov    %esp,%ebp
5ffb5423:	57                   	push   %edi
5ffb5424:	56                   	push   %esi
5ffb5425:	53                   	push   %ebx
5ffb5426:	83 ec 1c             	sub    $0x1c,%esp
  NTSTATUS Status;
  PCSRSS_CONSOLE Console;
  PCSRSS_SCREEN_BUFFER Buff;
  DWORD Xpos, Ypos;
  PCHAR ReadBuffer;
  DWORD i;
  ULONG CharSize;
  CHAR Char;

  DPRINT("CsrReadConsoleOutputChar\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
5ffb5429:	8b 45 10             	mov    0x10(%ebp),%eax
  Reply->Header.DataSize = Reply->Header.MessageSize - LPC_MESSAGE_BASE_SIZE;
  ReadBuffer = Reply->Data.ReadConsoleOutputCharReply.String;
  
  CharSize = (Request->Data.ReadConsoleOutputCharRequest.Unicode ? sizeof(WCHAR) : sizeof(CHAR));
5ffb542c:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb542f:	89 c7                	mov    %eax,%edi
  
  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb5431:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb5434:	66 c7 40 02 38 00    	movw   $0x38,0x2(%eax)
5ffb543a:	66 c7 00 20 00       	movw   $0x20,(%eax)
5ffb543f:	8b 42 20             	mov    0x20(%edx),%eax
5ffb5442:	83 c7 24             	add    $0x24,%edi
5ffb5445:	83 f8 01             	cmp    $0x1,%eax
5ffb5448:	8d 55 f0             	lea    0xfffffff0(%ebp),%edx
5ffb544b:	19 db                	sbb    %ebx,%ebx
5ffb544d:	83 c3 02             	add    $0x2,%ebx
5ffb5450:	89 5d e0             	mov    %ebx,0xffffffe0(%ebp)
5ffb5453:	e8 68 bd ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
  if (! NT_SUCCESS(Status))
5ffb5458:	85 c0                	test   %eax,%eax
5ffb545a:	0f 88 a7 01 00 00    	js     5ffb5607 <_CsrReadConsoleOutputChar@12+0x1e7>
    {
      return Reply->Status = Status;
    }

  Status = ConioLockScreenBuffer(ProcessData, Request->Data.ReadConsoleOutputCharRequest.ConsoleHandle, &Buff);
5ffb5460:	53                   	push   %ebx
5ffb5461:	53                   	push   %ebx
5ffb5462:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
5ffb5465:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb5468:	8b 53 1c             	mov    0x1c(%ebx),%edx
5ffb546b:	6a 02                	push   $0x2
5ffb546d:	50                   	push   %eax
5ffb546e:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb5471:	e8 0a bc ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
  if (! NT_SUCCESS(Status))
5ffb5476:	5a                   	pop    %edx
5ffb5477:	85 c0                	test   %eax,%eax
5ffb5479:	59                   	pop    %ecx
5ffb547a:	0f 88 87 01 00 00    	js     5ffb5607 <_CsrReadConsoleOutputChar@12+0x1e7>
    {
      return Reply->Status = Status;
    }

  Xpos = Request->Data.ReadConsoleOutputCharRequest.ReadCoord.X + Buff->ShowX;
5ffb5480:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
5ffb5483:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb5486:	66 8b 41 28          	mov    0x28(%ecx),%ax
5ffb548a:	0f bf 53 28          	movswl 0x28(%ebx),%edx
5ffb548e:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb5493:	8d 1c 02             	lea    (%edx,%eax,1),%ebx
  Ypos = (Request->Data.ReadConsoleOutputCharRequest.ReadCoord.Y + Buff->ShowY) % Buff->MaxY;
5ffb5496:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb5499:	0f bf 50 2a          	movswl 0x2a(%eax),%edx
5ffb549d:	66 8b 41 2a          	mov    0x2a(%ecx),%ax

  for (i = 0; i < Request->Data.ReadConsoleOutputCharRequest.NumCharsToRead; ++i)
5ffb54a1:	c7 45 e4 00 00 00 00 	movl   $0x0,0xffffffe4(%ebp)
5ffb54a8:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb54ad:	8d 34 02             	lea    (%edx,%eax,1),%esi
5ffb54b0:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb54b4:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb54b9:	89 f2                	mov    %esi,%edx
5ffb54bb:	c1 fa 1f             	sar    $0x1f,%edx
5ffb54be:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
5ffb54c1:	89 f0                	mov    %esi,%eax
5ffb54c3:	f7 7d dc             	idivl  0xffffffdc(%ebp)
5ffb54c6:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb54c9:	89 d6                	mov    %edx,%esi
5ffb54cb:	8b 40 24             	mov    0x24(%eax),%eax
5ffb54ce:	85 c0                	test   %eax,%eax
5ffb54d0:	75 2c                	jne    5ffb54fe <_CsrReadConsoleOutputChar@12+0xde>
5ffb54d2:	e9 a9 00 00 00       	jmp    5ffb5580 <_CsrReadConsoleOutputChar@12+0x160>
    {
      Char = Buff->Buffer[(Xpos * 2) + (Ypos * 2 * Buff->MaxX)];
      
      if(Request->Data.ReadConsoleOutputCharRequest.Unicode)
      {
        ConsoleAnsiCharToUnicodeChar(Console, (WCHAR*)ReadBuffer, &Char);
        ReadBuffer += sizeof(WCHAR);
      }
      else
        *(ReadBuffer++) = Char;
5ffb54d7:	88 07                	mov    %al,(%edi)

      Xpos++;
5ffb54d9:	43                   	inc    %ebx

      if (Xpos == Buff->MaxX)
5ffb54da:	66 8b 41 24          	mov    0x24(%ecx),%ax
5ffb54de:	47                   	inc    %edi
5ffb54df:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb54e4:	39 d8                	cmp    %ebx,%eax
5ffb54e6:	74 68                	je     5ffb5550 <_CsrReadConsoleOutputChar@12+0x130>
5ffb54e8:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
5ffb54eb:	40                   	inc    %eax
5ffb54ec:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
5ffb54ef:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb54f2:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
5ffb54f5:	39 50 24             	cmp    %edx,0x24(%eax)
5ffb54f8:	0f 86 82 00 00 00    	jbe    5ffb5580 <_CsrReadConsoleOutputChar@12+0x160>
5ffb54fe:	66 8b 41 24          	mov    0x24(%ecx),%ax
5ffb5502:	8b 51 20             	mov    0x20(%ecx),%edx
5ffb5505:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb550a:	0f af c6             	imul   %esi,%eax
5ffb550d:	8d 04 03             	lea    (%ebx,%eax,1),%eax
5ffb5510:	8a 04 42             	mov    (%edx,%eax,2),%al
5ffb5513:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb5516:	88 45 eb             	mov    %al,0xffffffeb(%ebp)
5ffb5519:	8b 52 20             	mov    0x20(%edx),%edx
5ffb551c:	85 d2                	test   %edx,%edx
5ffb551e:	74 b7                	je     5ffb54d7 <_CsrReadConsoleOutputChar@12+0xb7>
5ffb5520:	50                   	push   %eax
5ffb5521:	50                   	push   %eax
5ffb5522:	8d 45 eb             	lea    0xffffffeb(%ebp),%eax
5ffb5525:	6a 01                	push   $0x1
5ffb5527:	57                   	push   %edi
5ffb5528:	6a 01                	push   $0x1
5ffb552a:	50                   	push   %eax
5ffb552b:	6a 00                	push   $0x0
5ffb552d:	43                   	inc    %ebx
5ffb552e:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
5ffb5531:	83 c7 02             	add    $0x2,%edi
5ffb5534:	8b 48 68             	mov    0x68(%eax),%ecx
5ffb5537:	51                   	push   %ecx
5ffb5538:	e8 73 38 00 00       	call   5ffb8db0 <_MultiByteToWideChar@24>
5ffb553d:	8b 4d ec             	mov    0xffffffec(%ebp),%ecx
5ffb5540:	58                   	pop    %eax
5ffb5541:	5a                   	pop    %edx
5ffb5542:	66 8b 41 24          	mov    0x24(%ecx),%ax
5ffb5546:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb554b:	39 d8                	cmp    %ebx,%eax
5ffb554d:	75 99                	jne    5ffb54e8 <_CsrReadConsoleOutputChar@12+0xc8>
5ffb554f:	90                   	nop    
	{
	  Xpos = 0;
	  Ypos++;

	  if (Ypos == Buff->MaxY)
5ffb5550:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb5554:	46                   	inc    %esi
5ffb5555:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb555a:	31 db                	xor    %ebx,%ebx
            {
              Ypos = 0;
5ffb555c:	39 f0                	cmp    %esi,%eax
5ffb555e:	0f 95 c0             	setne  %al
5ffb5561:	25 ff 00 00 00       	and    $0xff,%eax
5ffb5566:	f7 d8                	neg    %eax
5ffb5568:	21 c6                	and    %eax,%esi
5ffb556a:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
5ffb556d:	40                   	inc    %eax
5ffb556e:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
5ffb5571:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb5574:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
5ffb5577:	39 50 24             	cmp    %edx,0x24(%eax)
5ffb557a:	0f 87 7e ff ff ff    	ja     5ffb54fe <_CsrReadConsoleOutputChar@12+0xde>
            }
	}
    }

  *ReadBuffer = 0;
5ffb5580:	c6 07 00             	movb   $0x0,(%edi)
  Reply->Status = STATUS_SUCCESS;
5ffb5583:	8b 45 10             	mov    0x10(%ebp),%eax
  Reply->Data.ReadConsoleOutputCharReply.EndCoord.X = Xpos - Buff->ShowX;
5ffb5586:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb5589:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
5ffb5590:	89 d8                	mov    %ebx,%eax
5ffb5592:	66 2b 41 28          	sub    0x28(%ecx),%ax
5ffb5596:	66 89 42 1c          	mov    %ax,0x1c(%edx)
  Reply->Data.ReadConsoleOutputCharReply.EndCoord.Y = (Ypos - Buff->ShowY + Buff->MaxY) % Buff->MaxY;
5ffb559a:	66 8b 41 2a          	mov    0x2a(%ecx),%ax
5ffb559e:	66 8b 51 26          	mov    0x26(%ecx),%dx
5ffb55a2:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb55a7:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb55ad:	29 c6                	sub    %eax,%esi
5ffb55af:	89 d3                	mov    %edx,%ebx
5ffb55b1:	8d 04 16             	lea    (%esi,%edx,1),%eax
5ffb55b4:	31 d2                	xor    %edx,%edx
5ffb55b6:	f7 f3                	div    %ebx
5ffb55b8:	8b 45 10             	mov    0x10(%ebp),%eax
  Reply->Header.MessageSize += Request->Data.ReadConsoleOutputCharRequest.NumCharsToRead;
5ffb55bb:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb55be:	66 89 50 1e          	mov    %dx,0x1e(%eax)
5ffb55c2:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb55c5:	66 8b 42 02          	mov    0x2(%edx),%ax
5ffb55c9:	66 03 43 24          	add    0x24(%ebx),%ax
5ffb55cd:	66 89 42 02          	mov    %ax,0x2(%edx)
  Reply->Header.DataSize += Request->Data.ReadConsoleOutputCharRequest.NumCharsToRead;
5ffb55d1:	66 8b 02             	mov    (%edx),%ax
5ffb55d4:	66 03 43 24          	add    0x24(%ebx),%ax
5ffb55d8:	66 89 02             	mov    %ax,(%edx)

  ConioUnlockScreenBuffer(Buff);
5ffb55db:	e8 e0 ba ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
  if (NULL != Console)
5ffb55e0:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb55e3:	85 c9                	test   %ecx,%ecx
5ffb55e5:	75 30                	jne    5ffb5617 <_CsrReadConsoleOutputChar@12+0x1f7>
    {
      ConioUnlockConsole(Console);
    }
  
  Reply->Data.ReadConsoleOutputCharReply.CharsRead = (DWORD)((ULONG_PTR)ReadBuffer - (ULONG_PTR)Reply->Data.ReadConsoleOutputCharReply.String) / CharSize;
5ffb55e7:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb55ea:	31 d2                	xor    %edx,%edx
5ffb55ec:	29 df                	sub    %ebx,%edi
5ffb55ee:	8d 47 dc             	lea    0xffffffdc(%edi),%eax
5ffb55f1:	f7 75 e0             	divl   0xffffffe0(%ebp)
5ffb55f4:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb55f7:	89 42 20             	mov    %eax,0x20(%edx)

  return Reply->Status;
5ffb55fa:	8b 42 18             	mov    0x18(%edx),%eax
}
5ffb55fd:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb5600:	5b                   	pop    %ebx
5ffb5601:	5e                   	pop    %esi
5ffb5602:	5f                   	pop    %edi
5ffb5603:	5d                   	pop    %ebp
5ffb5604:	c2 0c 00             	ret    $0xc
5ffb5607:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb560a:	89 42 18             	mov    %eax,0x18(%edx)
5ffb560d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb5610:	5b                   	pop    %ebx
5ffb5611:	5e                   	pop    %esi
5ffb5612:	5f                   	pop    %edi
5ffb5613:	5d                   	pop    %ebp
5ffb5614:	c2 0c 00             	ret    $0xc
5ffb5617:	e8 a4 ba ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb561c:	eb c9                	jmp    5ffb55e7 <_CsrReadConsoleOutputChar@12+0x1c7>
5ffb561e:	89 f6                	mov    %esi,%esi

5ffb5620 <_CsrReadConsoleOutputAttrib@12>:


CSR_API(CsrReadConsoleOutputAttrib)
{
5ffb5620:	55                   	push   %ebp
5ffb5621:	89 e5                	mov    %esp,%ebp
5ffb5623:	57                   	push   %edi
5ffb5624:	56                   	push   %esi
5ffb5625:	53                   	push   %ebx
5ffb5626:	83 ec 14             	sub    $0x14,%esp
  NTSTATUS Status;
  PCSRSS_SCREEN_BUFFER Buff;
  DWORD Xpos, Ypos;
  CHAR* ReadBuffer;
  DWORD i;

  DPRINT("CsrReadConsoleOutputAttrib\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
5ffb5629:	8b 45 10             	mov    0x10(%ebp),%eax
  Reply->Header.DataSize = Reply->Header.MessageSize - LPC_MESSAGE_BASE_SIZE;
  ReadBuffer = Reply->Data.ReadConsoleOutputAttribReply.String;

  Status = ConioLockScreenBuffer(ProcessData, Request->Data.ReadConsoleOutputAttribRequest.ConsoleHandle, &Buff);
5ffb562c:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb562f:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb5632:	89 c7                	mov    %eax,%edi
5ffb5634:	66 c7 40 02 38 00    	movw   $0x38,0x2(%eax)
5ffb563a:	66 c7 00 20 00       	movw   $0x20,(%eax)
5ffb563f:	8b 53 1c             	mov    0x1c(%ebx),%edx
5ffb5642:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
5ffb5645:	6a 02                	push   $0x2
5ffb5647:	50                   	push   %eax
5ffb5648:	e8 33 ba ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
5ffb564d:	83 c7 20             	add    $0x20,%edi
  if (! NT_SUCCESS(Status))
5ffb5650:	5a                   	pop    %edx
5ffb5651:	85 c0                	test   %eax,%eax
5ffb5653:	59                   	pop    %ecx
5ffb5654:	0f 88 28 01 00 00    	js     5ffb5782 <_CsrReadConsoleOutputAttrib@12+0x162>
    {
      return Reply->Status = Status;
    }

  Xpos = Request->Data.ReadConsoleOutputAttribRequest.ReadCoord.X + Buff->ShowX;
5ffb565a:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb565d:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb5660:	66 8b 41 28          	mov    0x28(%ecx),%ax
5ffb5664:	0f bf 53 24          	movswl 0x24(%ebx),%edx
5ffb5668:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb566d:	8d 1c 02             	lea    (%edx,%eax,1),%ebx
  Ypos = (Request->Data.ReadConsoleOutputAttribRequest.ReadCoord.Y + Buff->ShowY) % Buff->MaxY;
5ffb5670:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb5673:	0f bf 50 26          	movswl 0x26(%eax),%edx
5ffb5677:	66 8b 41 2a          	mov    0x2a(%ecx),%ax

  for (i = 0; i < Request->Data.ReadConsoleOutputAttribRequest.NumAttrsToRead; ++i)
5ffb567b:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
5ffb5682:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb5687:	8d 34 02             	lea    (%edx,%eax,1),%esi
5ffb568a:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb568e:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb5693:	89 f2                	mov    %esi,%edx
5ffb5695:	c1 fa 1f             	sar    $0x1f,%edx
5ffb5698:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
5ffb569b:	89 f0                	mov    %esi,%eax
5ffb569d:	f7 7d e8             	idivl  0xffffffe8(%ebp)
5ffb56a0:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb56a3:	89 d6                	mov    %edx,%esi
5ffb56a5:	8b 40 20             	mov    0x20(%eax),%eax
5ffb56a8:	85 c0                	test   %eax,%eax
5ffb56aa:	75 16                	jne    5ffb56c2 <_CsrReadConsoleOutputAttrib@12+0xa2>
5ffb56ac:	eb 67                	jmp    5ffb5715 <_CsrReadConsoleOutputAttrib@12+0xf5>
5ffb56ae:	89 f6                	mov    %esi,%esi
5ffb56b0:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb56b3:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb56b6:	40                   	inc    %eax
5ffb56b7:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
5ffb56ba:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb56bd:	39 42 20             	cmp    %eax,0x20(%edx)
5ffb56c0:	76 53                	jbe    5ffb5715 <_CsrReadConsoleOutputAttrib@12+0xf5>
    {
      *ReadBuffer = Buff->Buffer[(Xpos * 2) + (Ypos * 2 * Buff->MaxX) + 1];
5ffb56c2:	66 8b 41 24          	mov    0x24(%ecx),%ax
5ffb56c6:	8b 51 20             	mov    0x20(%ecx),%edx
5ffb56c9:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb56ce:	0f af c6             	imul   %esi,%eax
5ffb56d1:	8d 04 03             	lea    (%ebx,%eax,1),%eax

      ReadBuffer++;
      Xpos++;
5ffb56d4:	43                   	inc    %ebx
5ffb56d5:	8a 44 42 01          	mov    0x1(%edx,%eax,2),%al
5ffb56d9:	88 07                	mov    %al,(%edi)
5ffb56db:	47                   	inc    %edi

      if (Xpos == Buff->MaxX)
5ffb56dc:	66 8b 41 24          	mov    0x24(%ecx),%ax
5ffb56e0:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb56e5:	39 d8                	cmp    %ebx,%eax
5ffb56e7:	75 c7                	jne    5ffb56b0 <_CsrReadConsoleOutputAttrib@12+0x90>
        {
          Xpos = 0;
          Ypos++;

          if (Ypos == Buff->MaxY)
5ffb56e9:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb56ed:	46                   	inc    %esi
5ffb56ee:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb56f3:	31 db                	xor    %ebx,%ebx
            {
              Ypos = 0;
5ffb56f5:	39 f0                	cmp    %esi,%eax
5ffb56f7:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb56fa:	0f 95 c0             	setne  %al
5ffb56fd:	25 ff 00 00 00       	and    $0xff,%eax
5ffb5702:	f7 d8                	neg    %eax
5ffb5704:	21 c6                	and    %eax,%esi
5ffb5706:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb5709:	40                   	inc    %eax
5ffb570a:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
5ffb570d:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb5710:	39 42 20             	cmp    %eax,0x20(%edx)
5ffb5713:	77 ad                	ja     5ffb56c2 <_CsrReadConsoleOutputAttrib@12+0xa2>
            }
        }
    }

  *ReadBuffer = 0;
5ffb5715:	c6 07 00             	movb   $0x0,(%edi)

  Reply->Status = STATUS_SUCCESS;
  Reply->Data.ReadConsoleOutputAttribReply.EndCoord.X = Xpos - Buff->ShowX;
5ffb5718:	89 d8                	mov    %ebx,%eax
5ffb571a:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb571d:	c7 42 18 00 00 00 00 	movl   $0x0,0x18(%edx)
5ffb5724:	66 2b 41 28          	sub    0x28(%ecx),%ax
5ffb5728:	66 89 42 1c          	mov    %ax,0x1c(%edx)
  Reply->Data.ReadConsoleOutputAttribReply.EndCoord.Y = (Ypos - Buff->ShowY + Buff->MaxY) % Buff->MaxY;
5ffb572c:	66 8b 41 2a          	mov    0x2a(%ecx),%ax
5ffb5730:	66 8b 51 26          	mov    0x26(%ecx),%dx
5ffb5734:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb5739:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb573f:	29 c6                	sub    %eax,%esi
5ffb5741:	89 d3                	mov    %edx,%ebx
5ffb5743:	8d 04 16             	lea    (%esi,%edx,1),%eax
5ffb5746:	31 d2                	xor    %edx,%edx
5ffb5748:	f7 f3                	div    %ebx
5ffb574a:	8b 45 10             	mov    0x10(%ebp),%eax
  Reply->Header.MessageSize += Request->Data.ReadConsoleOutputAttribRequest.NumAttrsToRead;
5ffb574d:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb5750:	66 89 50 1e          	mov    %dx,0x1e(%eax)
5ffb5754:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb5757:	66 8b 42 02          	mov    0x2(%edx),%ax
5ffb575b:	66 03 43 20          	add    0x20(%ebx),%ax
5ffb575f:	66 89 42 02          	mov    %ax,0x2(%edx)
  Reply->Header.DataSize += Request->Data.ReadConsoleOutputAttribRequest.NumAttrsToRead;
5ffb5763:	66 8b 02             	mov    (%edx),%ax
5ffb5766:	66 03 43 20          	add    0x20(%ebx),%ax
5ffb576a:	66 89 02             	mov    %ax,(%edx)

  ConioUnlockScreenBuffer(Buff);
5ffb576d:	e8 4e b9 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>

  return Reply->Status;
5ffb5772:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb5775:	8b 42 18             	mov    0x18(%edx),%eax
}
5ffb5778:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb577b:	5b                   	pop    %ebx
5ffb577c:	5e                   	pop    %esi
5ffb577d:	5f                   	pop    %edi
5ffb577e:	5d                   	pop    %ebp
5ffb577f:	c2 0c 00             	ret    $0xc
5ffb5782:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb5785:	89 42 18             	mov    %eax,0x18(%edx)
5ffb5788:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb578b:	5b                   	pop    %ebx
5ffb578c:	5e                   	pop    %esi
5ffb578d:	5f                   	pop    %edi
5ffb578e:	5d                   	pop    %ebp
5ffb578f:	c2 0c 00             	ret    $0xc
5ffb5792:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
5ffb5799:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb57a0 <_CsrGetNumberOfConsoleInputEvents@12>:


CSR_API(CsrGetNumberOfConsoleInputEvents)
{
5ffb57a0:	55                   	push   %ebp
5ffb57a1:	89 e5                	mov    %esp,%ebp
5ffb57a3:	57                   	push   %edi
5ffb57a4:	56                   	push   %esi
5ffb57a5:	53                   	push   %ebx
5ffb57a6:	83 ec 14             	sub    $0x14,%esp
5ffb57a9:	8b 7d 10             	mov    0x10(%ebp),%edi
  NTSTATUS Status;
  PCSRSS_CONSOLE Console;
  PLIST_ENTRY CurrentItem;
  DWORD NumEvents;
  ConsoleInput *Input;
  
  DPRINT("CsrGetNumberOfConsoleInputEvents\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = Reply->Header.MessageSize - LPC_MESSAGE_BASE_SIZE;

  Status = ConioLockConsole(ProcessData, Request->Data.GetNumInputEventsRequest.ConsoleHandle, &Console);
5ffb57ac:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb57af:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb57b2:	66 c7 47 02 38 00    	movw   $0x38,0x2(%edi)
5ffb57b8:	66 c7 07 20 00       	movw   $0x20,(%edi)
5ffb57bd:	8b 50 1c             	mov    0x1c(%eax),%edx
5ffb57c0:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
5ffb57c3:	6a 01                	push   $0x1
5ffb57c5:	50                   	push   %eax
5ffb57c6:	e8 b5 b8 ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
  if (! NT_SUCCESS(Status))
5ffb57cb:	5b                   	pop    %ebx
5ffb57cc:	85 c0                	test   %eax,%eax
5ffb57ce:	5e                   	pop    %esi
5ffb57cf:	78 3e                	js     5ffb580f <_CsrGetNumberOfConsoleInputEvents@12+0x6f>
    {
      return Reply->Status = Status;
    }
  
  CurrentItem = Console->InputEvents.Flink;
5ffb57d1:	8b 75 f0             	mov    0xfffffff0(%ebp),%esi
  NumEvents = 0;
5ffb57d4:	31 db                	xor    %ebx,%ebx
5ffb57d6:	8b 56 2c             	mov    0x2c(%esi),%edx
  
  /* If there are any events ... */
  while (CurrentItem != &Console->InputEvents)
    {
      Input = CONTAINING_RECORD(CurrentItem, ConsoleInput, ListEntry);
      CurrentItem = CurrentItem->Flink;
      if (!Input->Fake)
        {
          NumEvents++;
5ffb57d9:	8d 46 2c             	lea    0x2c(%esi),%eax
5ffb57dc:	39 d0                	cmp    %edx,%eax
5ffb57de:	74 12                	je     5ffb57f2 <_CsrGetNumberOfConsoleInputEvents@12+0x52>
5ffb57e0:	89 c1                	mov    %eax,%ecx
5ffb57e2:	89 d0                	mov    %edx,%eax
5ffb57e4:	8b 12                	mov    (%edx),%edx
5ffb57e6:	8a 40 1d             	mov    0x1d(%eax),%al
5ffb57e9:	3c 01                	cmp    $0x1,%al
5ffb57eb:	83 d3 00             	adc    $0x0,%ebx
5ffb57ee:	39 d1                	cmp    %edx,%ecx
5ffb57f0:	75 f0                	jne    5ffb57e2 <_CsrGetNumberOfConsoleInputEvents@12+0x42>
	}
    }

  ConioUnlockConsole(Console);
5ffb57f2:	89 f1                	mov    %esi,%ecx
5ffb57f4:	e8 c7 b8 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
  
  Reply->Status = STATUS_SUCCESS;
5ffb57f9:	c7 47 18 00 00 00 00 	movl   $0x0,0x18(%edi)
  Reply->Data.GetNumInputEventsReply.NumInputEvents = NumEvents;
5ffb5800:	89 5f 1c             	mov    %ebx,0x1c(%edi)
   
  return Reply->Status;
5ffb5803:	31 c0                	xor    %eax,%eax
}
5ffb5805:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb5808:	5b                   	pop    %ebx
5ffb5809:	5e                   	pop    %esi
5ffb580a:	5f                   	pop    %edi
5ffb580b:	5d                   	pop    %ebp
5ffb580c:	c2 0c 00             	ret    $0xc
5ffb580f:	89 47 18             	mov    %eax,0x18(%edi)
5ffb5812:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb5815:	5b                   	pop    %ebx
5ffb5816:	5e                   	pop    %esi
5ffb5817:	5f                   	pop    %edi
5ffb5818:	5d                   	pop    %ebp
5ffb5819:	c2 0c 00             	ret    $0xc
5ffb581c:	8d 74 26 00          	lea    0x0(%esi),%esi

5ffb5820 <_CsrPeekConsoleInput@12>:


CSR_API(CsrPeekConsoleInput)
{
5ffb5820:	55                   	push   %ebp
5ffb5821:	89 e5                	mov    %esp,%ebp
5ffb5823:	57                   	push   %edi
5ffb5824:	56                   	push   %esi
5ffb5825:	53                   	push   %ebx
5ffb5826:	83 ec 14             	sub    $0x14,%esp
  NTSTATUS Status;
  PCSRSS_CONSOLE Console;
  DWORD Size;
  DWORD Length;
  PLIST_ENTRY CurrentItem;
  PINPUT_RECORD InputRecord;
  ConsoleInput* Item;
  UINT NumItems;
   
  DPRINT("CsrPeekConsoleInput\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
5ffb5829:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb582c:	8b 5d 08             	mov    0x8(%ebp),%ebx
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
   
  Status = ConioLockConsole(ProcessData, Request->Data.GetNumInputEventsRequest.ConsoleHandle, &Console);
5ffb582f:	89 d9                	mov    %ebx,%ecx
5ffb5831:	66 c7 40 02 38 00    	movw   $0x38,0x2(%eax)
5ffb5837:	66 c7 00 20 00       	movw   $0x20,(%eax)
5ffb583c:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb583f:	8b 50 1c             	mov    0x1c(%eax),%edx
5ffb5842:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
5ffb5845:	6a 01                	push   $0x1
5ffb5847:	50                   	push   %eax
5ffb5848:	e8 33 b8 ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
  if(! NT_SUCCESS(Status))
5ffb584d:	5e                   	pop    %esi
5ffb584e:	85 c0                	test   %eax,%eax
5ffb5850:	5f                   	pop    %edi
5ffb5851:	0f 88 ed 00 00 00    	js     5ffb5944 <_CsrPeekConsoleInput@12+0x124>
    {
      return Reply->Status = Status;
    }
   
  InputRecord = Request->Data.PeekConsoleInputRequest.InputRecord;
5ffb5857:	8b 45 0c             	mov    0xc(%ebp),%eax
  Length = Request->Data.PeekConsoleInputRequest.Length;
  Size = Length * sizeof(INPUT_RECORD);
   
  if (((PVOID)InputRecord < ProcessData->CsrSectionViewBase)
5ffb585a:	8b 53 1c             	mov    0x1c(%ebx),%edx
5ffb585d:	8b 78 24             	mov    0x24(%eax),%edi
5ffb5860:	8b 70 28             	mov    0x28(%eax),%esi
5ffb5863:	8d 04 bf             	lea    (%edi,%edi,4),%eax
5ffb5866:	c1 e0 02             	shl    $0x2,%eax
5ffb5869:	39 f2                	cmp    %esi,%edx
5ffb586b:	77 76                	ja     5ffb58e3 <_CsrPeekConsoleInput@12+0xc3>
5ffb586d:	8b 4b 20             	mov    0x20(%ebx),%ecx
5ffb5870:	8d 04 06             	lea    (%esi,%eax,1),%eax
5ffb5873:	01 ca                	add    %ecx,%edx
5ffb5875:	39 d0                	cmp    %edx,%eax
5ffb5877:	77 6a                	ja     5ffb58e3 <_CsrPeekConsoleInput@12+0xc3>
      || (((PVOID)InputRecord + Size) > (ProcessData->CsrSectionViewBase + ProcessData->CsrSectionViewSize)))
    {
      ConioUnlockConsole(Console);
      Reply->Status = STATUS_ACCESS_VIOLATION;
      return Reply->Status ;
    }
   
  NumItems = 0;
   
  if (! IsListEmpty(&Console->InputEvents))
5ffb5879:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb587c:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
5ffb5883:	8d 51 2c             	lea    0x2c(%ecx),%edx
5ffb5886:	8b 41 2c             	mov    0x2c(%ecx),%eax
5ffb5889:	39 d0                	cmp    %edx,%eax
5ffb588b:	74 35                	je     5ffb58c2 <_CsrPeekConsoleInput@12+0xa2>
    {
      CurrentItem = Console->InputEvents.Flink;
   
      while (CurrentItem != &Console->InputEvents && NumItems < Length)
        {
          Item = CONTAINING_RECORD(CurrentItem, ConsoleInput, ListEntry);

          if (Item->Fake)
            {
              CurrentItem = CurrentItem->Flink;
              continue;
            }
          
          ++NumItems;
          *InputRecord = Item->InputEvent;

          if (Request->Data.ReadInputRequest.Unicode == FALSE)
            {
              ConioInputEventToAnsi(Console, InputRecord);
            }
         
          InputRecord++;
          CurrentItem = CurrentItem->Flink;
5ffb588d:	39 c2                	cmp    %eax,%edx
5ffb588f:	89 c3                	mov    %eax,%ebx
5ffb5891:	0f 95 c2             	setne  %dl
5ffb5894:	39 7d ec             	cmp    %edi,0xffffffec(%ebp)
5ffb5897:	0f 92 c0             	setb   %al
5ffb589a:	25 ff 00 00 00       	and    $0xff,%eax
5ffb589f:	85 c2                	test   %eax,%edx
5ffb58a1:	74 1f                	je     5ffb58c2 <_CsrPeekConsoleInput@12+0xa2>
5ffb58a3:	80 7b 1d 00          	cmpb   $0x0,0x1d(%ebx)
5ffb58a7:	74 5b                	je     5ffb5904 <_CsrPeekConsoleInput@12+0xe4>
5ffb58a9:	8b 1b                	mov    (%ebx),%ebx
5ffb58ab:	8d 41 2c             	lea    0x2c(%ecx),%eax
5ffb58ae:	39 d8                	cmp    %ebx,%eax
5ffb58b0:	0f 95 c2             	setne  %dl
5ffb58b3:	39 7d ec             	cmp    %edi,0xffffffec(%ebp)
5ffb58b6:	0f 92 c0             	setb   %al
5ffb58b9:	25 ff 00 00 00       	and    $0xff,%eax
5ffb58be:	85 c2                	test   %eax,%edx
5ffb58c0:	75 e1                	jne    5ffb58a3 <_CsrPeekConsoleInput@12+0x83>
        }
    }

  ConioUnlockConsole(Console);
5ffb58c2:	e8 f9 b7 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>

  Reply->Status = STATUS_SUCCESS;
5ffb58c7:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb58ca:	c7 42 18 00 00 00 00 	movl   $0x0,0x18(%edx)
  Reply->Data.PeekConsoleInputReply.Length = NumItems;
5ffb58d1:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb58d4:	89 42 1c             	mov    %eax,0x1c(%edx)

  return Reply->Status;
}
5ffb58d7:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb58da:	31 c0                	xor    %eax,%eax
5ffb58dc:	5b                   	pop    %ebx
5ffb58dd:	5e                   	pop    %esi
5ffb58de:	5f                   	pop    %edi
5ffb58df:	5d                   	pop    %ebp
5ffb58e0:	c2 0c 00             	ret    $0xc
5ffb58e3:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb58e6:	e8 d5 b7 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb58eb:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb58ee:	b8 05 00 00 c0       	mov    $0xc0000005,%eax
5ffb58f3:	c7 42 18 05 00 00 c0 	movl   $0xc0000005,0x18(%edx)
5ffb58fa:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb58fd:	5b                   	pop    %ebx
5ffb58fe:	5e                   	pop    %esi
5ffb58ff:	5f                   	pop    %edi
5ffb5900:	5d                   	pop    %ebp
5ffb5901:	c2 0c 00             	ret    $0xc
5ffb5904:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb5907:	40                   	inc    %eax
5ffb5908:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
5ffb590b:	8b 43 08             	mov    0x8(%ebx),%eax
5ffb590e:	89 06                	mov    %eax,(%esi)
5ffb5910:	8b 43 0c             	mov    0xc(%ebx),%eax
5ffb5913:	89 46 04             	mov    %eax,0x4(%esi)
5ffb5916:	8b 43 10             	mov    0x10(%ebx),%eax
5ffb5919:	89 46 08             	mov    %eax,0x8(%esi)
5ffb591c:	8b 43 14             	mov    0x14(%ebx),%eax
5ffb591f:	89 46 0c             	mov    %eax,0xc(%esi)
5ffb5922:	8b 43 18             	mov    0x18(%ebx),%eax
5ffb5925:	89 46 10             	mov    %eax,0x10(%esi)
5ffb5928:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb592b:	8b 40 20             	mov    0x20(%eax),%eax
5ffb592e:	85 c0                	test   %eax,%eax
5ffb5930:	74 22                	je     5ffb5954 <_CsrPeekConsoleInput@12+0x134>
5ffb5932:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb5935:	8b 1b                	mov    (%ebx),%ebx
5ffb5937:	83 c6 14             	add    $0x14,%esi
5ffb593a:	8d 41 2c             	lea    0x2c(%ecx),%eax
5ffb593d:	39 d8                	cmp    %ebx,%eax
5ffb593f:	e9 6c ff ff ff       	jmp    5ffb58b0 <_CsrPeekConsoleInput@12+0x90>
5ffb5944:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb5947:	89 42 18             	mov    %eax,0x18(%edx)
5ffb594a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb594d:	5b                   	pop    %ebx
5ffb594e:	5e                   	pop    %esi
5ffb594f:	5f                   	pop    %edi
5ffb5950:	5d                   	pop    %ebp
5ffb5951:	c2 0c 00             	ret    $0xc
5ffb5954:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb5957:	89 f2                	mov    %esi,%edx
5ffb5959:	e8 72 c6 ff ff       	call   5ffb1fd0 <@ConioInputEventToAnsi@8>
5ffb595e:	eb d2                	jmp    5ffb5932 <_CsrPeekConsoleInput@12+0x112>

5ffb5960 <_CsrReadConsoleOutput@12>:


CSR_API(CsrReadConsoleOutput)
{
5ffb5960:	55                   	push   %ebp
5ffb5961:	89 e5                	mov    %esp,%ebp
5ffb5963:	57                   	push   %edi
5ffb5964:	56                   	push   %esi
5ffb5965:	53                   	push   %ebx
5ffb5966:	83 ec 74             	sub    $0x74,%esp
  PCHAR_INFO CharInfo;
  PCHAR_INFO CurCharInfo;
  PCSRSS_SCREEN_BUFFER Buff;
  DWORD Size;
  DWORD Length;
  DWORD SizeX, SizeY;
  NTSTATUS Status;
  COORD BufferSize;
  COORD BufferCoord;
  RECT ReadRegion;
  RECT ScreenRect;
  DWORD i, Y, X, Offset;
  UINT CodePage;
      
  DPRINT("CsrReadConsoleOutput\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
5ffb5969:	8b 45 10             	mov    0x10(%ebp),%eax
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
  
  Status = ConioLockScreenBuffer(ProcessData, Request->Data.ReadConsoleOutputRequest.ConsoleHandle, &Buff);
5ffb596c:	8b 4d 0c             	mov    0xc(%ebp),%ecx
5ffb596f:	66 c7 40 02 38 00    	movw   $0x38,0x2(%eax)
5ffb5975:	66 c7 00 20 00       	movw   $0x20,(%eax)
5ffb597a:	8d 45 c4             	lea    0xffffffc4(%ebp),%eax
5ffb597d:	8b 51 1c             	mov    0x1c(%ecx),%edx
5ffb5980:	6a 02                	push   $0x2
5ffb5982:	50                   	push   %eax
5ffb5983:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb5986:	e8 f5 b6 ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
  if (! NT_SUCCESS(Status))
5ffb598b:	5a                   	pop    %edx
5ffb598c:	85 c0                	test   %eax,%eax
5ffb598e:	59                   	pop    %ecx
5ffb598f:	0f 88 df 01 00 00    	js     5ffb5b74 <_CsrReadConsoleOutput@12+0x214>
    {
      return Reply->Status = Status;
    }
   
  CharInfo = Request->Data.ReadConsoleOutputRequest.CharInfo;
5ffb5995:	8b 7d 0c             	mov    0xc(%ebp),%edi
  ReadRegion.left = Request->Data.ReadConsoleOutputRequest.ReadRegion.Left;
5ffb5998:	8b 45 0c             	mov    0xc(%ebp),%eax
  ReadRegion.top = Request->Data.ReadConsoleOutputRequest.ReadRegion.Top;
5ffb599b:	8b 55 0c             	mov    0xc(%ebp),%edx
  ReadRegion.right = Request->Data.ReadConsoleOutputRequest.ReadRegion.Right;
5ffb599e:	8b 4d 0c             	mov    0xc(%ebp),%ecx
5ffb59a1:	8b 7f 34             	mov    0x34(%edi),%edi
  ReadRegion.bottom = Request->Data.ReadConsoleOutputRequest.ReadRegion.Bottom;
5ffb59a4:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb59a7:	89 7d c0             	mov    %edi,0xffffffc0(%ebp)
  BufferSize = Request->Data.ReadConsoleOutputRequest.BufferSize;
5ffb59aa:	8b 7d 0c             	mov    0xc(%ebp),%edi
5ffb59ad:	0f bf 40 2c          	movswl 0x2c(%eax),%eax
5ffb59b1:	89 45 ac             	mov    %eax,0xffffffac(%ebp)
5ffb59b4:	0f bf 52 2e          	movswl 0x2e(%edx),%edx
5ffb59b8:	89 55 a8             	mov    %edx,0xffffffa8(%ebp)
5ffb59bb:	0f bf 49 30          	movswl 0x30(%ecx),%ecx
5ffb59bf:	89 4d a0             	mov    %ecx,0xffffffa0(%ebp)
  BufferCoord = Request->Data.ReadConsoleOutputRequest.BufferCoord;
  Length = BufferSize.X * BufferSize.Y;
  Size = Length * sizeof(CHAR_INFO);

  /* FIXME: Is this correct? */
  CodePage = ProcessData->Console->OutputCodePage;
5ffb59c2:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb59c5:	0f bf 5b 32          	movswl 0x32(%ebx),%ebx
5ffb59c9:	89 5d 9c             	mov    %ebx,0xffffff9c(%ebp)
5ffb59cc:	8b 77 24             	mov    0x24(%edi),%esi
5ffb59cf:	8b 57 28             	mov    0x28(%edi),%edx
5ffb59d2:	89 f7                	mov    %esi,%edi
5ffb59d4:	0f bf c6             	movswl %si,%eax
5ffb59d7:	c1 ff 10             	sar    $0x10,%edi
5ffb59da:	89 45 a4             	mov    %eax,0xffffffa4(%ebp)
5ffb59dd:	0f af c7             	imul   %edi,%eax
5ffb59e0:	8d 1c 85 00 00 00 00 	lea    0x0(,%eax,4),%ebx
5ffb59e7:	8b 01                	mov    (%ecx),%eax
   
  if (((PVOID)CharInfo < ProcessData->CsrSectionViewBase)
5ffb59e9:	8b 49 1c             	mov    0x1c(%ecx),%ecx
5ffb59ec:	8b 40 6c             	mov    0x6c(%eax),%eax
5ffb59ef:	3b 4d c0             	cmp    0xffffffc0(%ebp),%ecx
5ffb59f2:	89 45 b0             	mov    %eax,0xffffffb0(%ebp)
5ffb59f5:	77 0f                	ja     5ffb5a06 <_CsrReadConsoleOutput@12+0xa6>
5ffb59f7:	8b 45 c0             	mov    0xffffffc0(%ebp),%eax
5ffb59fa:	01 d8                	add    %ebx,%eax
5ffb59fc:	8b 5d 08             	mov    0x8(%ebp),%ebx
5ffb59ff:	03 4b 20             	add    0x20(%ebx),%ecx
5ffb5a02:	39 c8                	cmp    %ecx,%eax
5ffb5a04:	76 39                	jbe    5ffb5a3f <_CsrReadConsoleOutput@12+0xdf>
5ffb5a06:	8b 7d ac             	mov    0xffffffac(%ebp),%edi
5ffb5a09:	8b 45 a8             	mov    0xffffffa8(%ebp),%eax
5ffb5a0c:	8b 4d 9c             	mov    0xffffff9c(%ebp),%ecx
5ffb5a0f:	8b 55 a0             	mov    0xffffffa0(%ebp),%edx
5ffb5a12:	89 7d d8             	mov    %edi,0xffffffd8(%ebp)
5ffb5a15:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
5ffb5a18:	89 4d e4             	mov    %ecx,0xffffffe4(%ebp)
5ffb5a1b:	89 55 e0             	mov    %edx,0xffffffe0(%ebp)
      || (((PVOID)CharInfo + Size) > (ProcessData->CsrSectionViewBase + ProcessData->CsrSectionViewSize)))
    {
      ConioUnlockScreenBuffer(Buff);
5ffb5a1e:	8b 4d c4             	mov    0xffffffc4(%ebp),%ecx
5ffb5a21:	e8 9a b6 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
      Reply->Status = STATUS_ACCESS_VIOLATION;
5ffb5a26:	8b 5d 10             	mov    0x10(%ebp),%ebx
      return Reply->Status ;
5ffb5a29:	b8 05 00 00 c0       	mov    $0xc0000005,%eax
5ffb5a2e:	c7 43 18 05 00 00 c0 	movl   $0xc0000005,0x18(%ebx)
    }
   
  SizeY = RtlRosMin(BufferSize.Y - BufferCoord.Y, ConioRectHeight(&ReadRegion));
  SizeX = RtlRosMin(BufferSize.X - BufferCoord.X, ConioRectWidth(&ReadRegion));
  ReadRegion.bottom = ReadRegion.top + SizeY;
  ReadRegion.right = ReadRegion.left + SizeX;

  ConioInitRect(&ScreenRect, 0, 0, Buff->MaxY, Buff->MaxX);
  if (! ConioGetIntersection(&ReadRegion, &ScreenRect, &ReadRegion))
    {
      ConioUnlockScreenBuffer(Buff);
      Reply->Status = STATUS_SUCCESS;
      return Reply->Status;
    }

  for (i = 0, Y = ReadRegion.top; Y < ReadRegion.bottom; ++i, ++Y)
    {
      CurCharInfo = CharInfo + (i * BufferSize.X);
     
      Offset = (((Y + Buff->ShowY) % Buff->MaxY) * Buff->MaxX + ReadRegion.left) * 2;
      for (X = ReadRegion.left; X < ReadRegion.right; ++X)
        {
          if (Request->Data.ReadConsoleOutputRequest.Unicode)
            {
              MultiByteToWideChar(CodePage, 0,
                                  (PCHAR)&GET_CELL_BUFFER(Buff, Offset), 1,
                                  &CurCharInfo->Char.UnicodeChar, 1);
            }
          else
            {
              CurCharInfo->Char.AsciiChar = GET_CELL_BUFFER(Buff, Offset);
            }
          CurCharInfo->Attributes = GET_CELL_BUFFER(Buff, Offset);
          ++CurCharInfo;
        }
    }

  ConioUnlockScreenBuffer(Buff);
  
  Reply->Status = STATUS_SUCCESS;
  Reply->Data.ReadConsoleOutputReply.ReadRegion.Right = ReadRegion.left + SizeX - 1;
  Reply->Data.ReadConsoleOutputReply.ReadRegion.Bottom = ReadRegion.top + SizeY - 1;
  Reply->Data.ReadConsoleOutputReply.ReadRegion.Left = ReadRegion.left;
  Reply->Data.ReadConsoleOutputReply.ReadRegion.Top = ReadRegion.top;
   
  return Reply->Status;
}
5ffb5a35:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb5a38:	5b                   	pop    %ebx
5ffb5a39:	5e                   	pop    %esi
5ffb5a3a:	5f                   	pop    %edi
5ffb5a3b:	5d                   	pop    %ebp
5ffb5a3c:	c2 0c 00             	ret    $0xc
5ffb5a3f:	89 d0                	mov    %edx,%eax
5ffb5a41:	89 f9                	mov    %edi,%ecx
5ffb5a43:	c1 f8 10             	sar    $0x10,%eax
5ffb5a46:	8b 7d 9c             	mov    0xffffff9c(%ebp),%edi
5ffb5a49:	29 c1                	sub    %eax,%ecx
5ffb5a4b:	39 7d a8             	cmp    %edi,0xffffffa8(%ebp)
5ffb5a4e:	0f 8e 30 01 00 00    	jle    5ffb5b84 <_CsrReadConsoleOutput@12+0x224>
5ffb5a54:	85 c9                	test   %ecx,%ecx
5ffb5a56:	0f 88 38 01 00 00    	js     5ffb5b94 <_CsrReadConsoleOutput@12+0x234>
5ffb5a5c:	8b 45 9c             	mov    0xffffff9c(%ebp),%eax
5ffb5a5f:	c7 45 b8 00 00 00 00 	movl   $0x0,0xffffffb8(%ebp)
5ffb5a66:	39 45 a8             	cmp    %eax,0xffffffa8(%ebp)
5ffb5a69:	7f 09                	jg     5ffb5a74 <_CsrReadConsoleOutput@12+0x114>
5ffb5a6b:	8b 4d a8             	mov    0xffffffa8(%ebp),%ecx
5ffb5a6e:	29 c8                	sub    %ecx,%eax
5ffb5a70:	40                   	inc    %eax
5ffb5a71:	89 45 b8             	mov    %eax,0xffffffb8(%ebp)
5ffb5a74:	0f bf ca             	movswl %dx,%ecx
5ffb5a77:	8b 5d a0             	mov    0xffffffa0(%ebp),%ebx
5ffb5a7a:	8b 55 a4             	mov    0xffffffa4(%ebp),%edx
5ffb5a7d:	29 ca                	sub    %ecx,%edx
5ffb5a7f:	39 5d ac             	cmp    %ebx,0xffffffac(%ebp)
5ffb5a82:	0f 8f 8f 02 00 00    	jg     5ffb5d17 <_CsrReadConsoleOutput@12+0x3b7>
5ffb5a88:	89 d8                	mov    %ebx,%eax
5ffb5a8a:	8b 5d ac             	mov    0xffffffac(%ebp),%ebx
5ffb5a8d:	29 d8                	sub    %ebx,%eax
5ffb5a8f:	40                   	inc    %eax
5ffb5a90:	39 c2                	cmp    %eax,%edx
5ffb5a92:	0f 8c 87 02 00 00    	jl     5ffb5d1f <_CsrReadConsoleOutput@12+0x3bf>
5ffb5a98:	8b 45 a0             	mov    0xffffffa0(%ebp),%eax
5ffb5a9b:	c7 45 bc 00 00 00 00 	movl   $0x0,0xffffffbc(%ebp)
5ffb5aa2:	39 45 ac             	cmp    %eax,0xffffffac(%ebp)
5ffb5aa5:	7f 09                	jg     5ffb5ab0 <_CsrReadConsoleOutput@12+0x150>
5ffb5aa7:	8b 55 ac             	mov    0xffffffac(%ebp),%edx
5ffb5aaa:	29 d0                	sub    %edx,%eax
5ffb5aac:	40                   	inc    %eax
5ffb5aad:	89 45 bc             	mov    %eax,0xffffffbc(%ebp)
5ffb5ab0:	8b 45 b8             	mov    0xffffffb8(%ebp),%eax
5ffb5ab3:	8b 4d a8             	mov    0xffffffa8(%ebp),%ecx
5ffb5ab6:	01 c1                	add    %eax,%ecx
5ffb5ab8:	8b 5d ac             	mov    0xffffffac(%ebp),%ebx
5ffb5abb:	89 4d 9c             	mov    %ecx,0xffffff9c(%ebp)
5ffb5abe:	8b 4d c4             	mov    0xffffffc4(%ebp),%ecx
5ffb5ac1:	8b 45 bc             	mov    0xffffffbc(%ebp),%eax
5ffb5ac4:	31 d2                	xor    %edx,%edx
5ffb5ac6:	01 c3                	add    %eax,%ebx
5ffb5ac8:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb5acc:	89 5d a0             	mov    %ebx,0xffffffa0(%ebp)
5ffb5acf:	89 c3                	mov    %eax,%ebx
5ffb5ad1:	66 8b 41 24          	mov    0x24(%ecx),%ax
5ffb5ad5:	81 e3 ff ff 00 00    	and    $0xffff,%ebx
5ffb5adb:	89 c6                	mov    %eax,%esi
5ffb5add:	c7 45 cc 00 00 00 00 	movl   $0x0,0xffffffcc(%ebp)
5ffb5ae4:	81 e6 ff ff 00 00    	and    $0xffff,%esi
5ffb5aea:	c7 45 c8 00 00 00 00 	movl   $0x0,0xffffffc8(%ebp)
5ffb5af1:	89 5d d4             	mov    %ebx,0xffffffd4(%ebp)
5ffb5af4:	89 75 d0             	mov    %esi,0xffffffd0(%ebp)
5ffb5af7:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
5ffb5afa:	39 da                	cmp    %ebx,%edx
5ffb5afc:	0f 8f aa 00 00 00    	jg     5ffb5bac <_CsrReadConsoleOutput@12+0x24c>
5ffb5b02:	8b 7d a0             	mov    0xffffffa0(%ebp),%edi
5ffb5b05:	39 7d ac             	cmp    %edi,0xffffffac(%ebp)
5ffb5b08:	0f 8f 9e 00 00 00    	jg     5ffb5bac <_CsrReadConsoleOutput@12+0x24c>
5ffb5b0e:	8b 7d 9c             	mov    0xffffff9c(%ebp),%edi
5ffb5b11:	39 7d a8             	cmp    %edi,0xffffffa8(%ebp)
5ffb5b14:	0f 8f 92 00 00 00    	jg     5ffb5bac <_CsrReadConsoleOutput@12+0x24c>
5ffb5b1a:	39 fa                	cmp    %edi,%edx
5ffb5b1c:	0f 8f 8a 00 00 00    	jg     5ffb5bac <_CsrReadConsoleOutput@12+0x24c>
5ffb5b22:	3b 55 a0             	cmp    0xffffffa0(%ebp),%edx
5ffb5b25:	0f 8f 81 00 00 00    	jg     5ffb5bac <_CsrReadConsoleOutput@12+0x24c>
5ffb5b2b:	3b 5d a8             	cmp    0xffffffa8(%ebp),%ebx
5ffb5b2e:	7c 7c                	jl     5ffb5bac <_CsrReadConsoleOutput@12+0x24c>
5ffb5b30:	3b 75 ac             	cmp    0xffffffac(%ebp),%esi
5ffb5b33:	7c 77                	jl     5ffb5bac <_CsrReadConsoleOutput@12+0x24c>
5ffb5b35:	8b 55 a8             	mov    0xffffffa8(%ebp),%edx
5ffb5b38:	89 d0                	mov    %edx,%eax
5ffb5b3a:	83 f0 ff             	xor    $0xffffffff,%eax
5ffb5b3d:	c1 f8 1f             	sar    $0x1f,%eax
5ffb5b40:	21 d0                	and    %edx,%eax
5ffb5b42:	8b 55 ac             	mov    0xffffffac(%ebp),%edx
5ffb5b45:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
5ffb5b48:	89 d0                	mov    %edx,%eax
5ffb5b4a:	83 f0 ff             	xor    $0xffffffff,%eax
5ffb5b4d:	c1 f8 1f             	sar    $0x1f,%eax
5ffb5b50:	21 d0                	and    %edx,%eax
5ffb5b52:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
5ffb5b55:	8b 45 9c             	mov    0xffffff9c(%ebp),%eax
5ffb5b58:	39 d8                	cmp    %ebx,%eax
5ffb5b5a:	7e 02                	jle    5ffb5b5e <_CsrReadConsoleOutput@12+0x1fe>
5ffb5b5c:	89 d8                	mov    %ebx,%eax
5ffb5b5e:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
5ffb5b61:	8b 45 a0             	mov    0xffffffa0(%ebp),%eax
5ffb5b64:	39 f0                	cmp    %esi,%eax
5ffb5b66:	7e 02                	jle    5ffb5b6a <_CsrReadConsoleOutput@12+0x20a>
5ffb5b68:	89 f0                	mov    %esi,%eax
5ffb5b6a:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
5ffb5b6d:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb5b72:	eb 55                	jmp    5ffb5bc9 <_CsrReadConsoleOutput@12+0x269>
5ffb5b74:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb5b77:	89 43 18             	mov    %eax,0x18(%ebx)
5ffb5b7a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb5b7d:	5b                   	pop    %ebx
5ffb5b7e:	5e                   	pop    %esi
5ffb5b7f:	5f                   	pop    %edi
5ffb5b80:	5d                   	pop    %ebp
5ffb5b81:	c2 0c 00             	ret    $0xc
5ffb5b84:	89 f8                	mov    %edi,%eax
5ffb5b86:	8b 7d a8             	mov    0xffffffa8(%ebp),%edi
5ffb5b89:	29 f8                	sub    %edi,%eax
5ffb5b8b:	40                   	inc    %eax
5ffb5b8c:	39 c1                	cmp    %eax,%ecx
5ffb5b8e:	0f 8d c8 fe ff ff    	jge    5ffb5a5c <_CsrReadConsoleOutput@12+0xfc>
5ffb5b94:	c1 fe 10             	sar    $0x10,%esi
5ffb5b97:	89 d0                	mov    %edx,%eax
5ffb5b99:	c1 f8 10             	sar    $0x10,%eax
5ffb5b9c:	89 75 b8             	mov    %esi,0xffffffb8(%ebp)
5ffb5b9f:	8b 75 b8             	mov    0xffffffb8(%ebp),%esi
5ffb5ba2:	29 c6                	sub    %eax,%esi
5ffb5ba4:	89 75 b8             	mov    %esi,0xffffffb8(%ebp)
5ffb5ba7:	e9 c8 fe ff ff       	jmp    5ffb5a74 <_CsrReadConsoleOutput@12+0x114>
5ffb5bac:	c7 40 04 00 00 00 00 	movl   $0x0,0x4(%eax)
5ffb5bb3:	c7 00 ff ff ff ff    	movl   $0xffffffff,(%eax)
5ffb5bb9:	c7 40 0c 00 00 00 00 	movl   $0x0,0xc(%eax)
5ffb5bc0:	c7 40 08 ff ff ff ff 	movl   $0xffffffff,0x8(%eax)
5ffb5bc7:	31 c0                	xor    %eax,%eax
5ffb5bc9:	85 c0                	test   %eax,%eax
5ffb5bcb:	0f 84 5b 01 00 00    	je     5ffb5d2c <_CsrReadConsoleOutput@12+0x3cc>
5ffb5bd1:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
5ffb5bd4:	8b 5d e4             	mov    0xffffffe4(%ebp),%ebx
5ffb5bd7:	89 55 b4             	mov    %edx,0xffffffb4(%ebp)
5ffb5bda:	89 5d 9c             	mov    %ebx,0xffffff9c(%ebp)
5ffb5bdd:	39 d3                	cmp    %edx,%ebx
5ffb5bdf:	0f 86 f0 00 00 00    	jbe    5ffb5cd5 <_CsrReadConsoleOutput@12+0x375>
5ffb5be5:	8b 7d e0             	mov    0xffffffe0(%ebp),%edi
5ffb5be8:	c7 45 98 00 00 00 00 	movl   $0x0,0xffffff98(%ebp)
5ffb5bef:	89 7d a0             	mov    %edi,0xffffffa0(%ebp)
5ffb5bf2:	8b 45 c0             	mov    0xffffffc0(%ebp),%eax
5ffb5bf5:	8b 7d 98             	mov    0xffffff98(%ebp),%edi
5ffb5bf8:	01 c7                	add    %eax,%edi
5ffb5bfa:	66 8b 41 2a          	mov    0x2a(%ecx),%ax
5ffb5bfe:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb5c03:	8b 5d b4             	mov    0xffffffb4(%ebp),%ebx
5ffb5c06:	8d 14 18             	lea    (%eax,%ebx,1),%edx
5ffb5c09:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb5c0d:	89 c3                	mov    %eax,%ebx
5ffb5c0f:	89 d0                	mov    %edx,%eax
5ffb5c11:	81 e3 ff ff 00 00    	and    $0xffff,%ebx
5ffb5c17:	31 d2                	xor    %edx,%edx
5ffb5c19:	f7 f3                	div    %ebx
5ffb5c1b:	66 8b 41 24          	mov    0x24(%ecx),%ax
5ffb5c1f:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb5c24:	0f af d0             	imul   %eax,%edx
5ffb5c27:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
5ffb5c2a:	01 c2                	add    %eax,%edx
5ffb5c2c:	89 c6                	mov    %eax,%esi
5ffb5c2e:	39 45 a0             	cmp    %eax,0xffffffa0(%ebp)
5ffb5c31:	8d 1c 12             	lea    (%edx,%edx,1),%ebx
5ffb5c34:	77 2e                	ja     5ffb5c64 <_CsrReadConsoleOutput@12+0x304>
5ffb5c36:	eb 7e                	jmp    5ffb5cb6 <_CsrReadConsoleOutput@12+0x356>
5ffb5c38:	8b 51 20             	mov    0x20(%ecx),%edx
5ffb5c3b:	89 d8                	mov    %ebx,%eax
5ffb5c3d:	43                   	inc    %ebx
5ffb5c3e:	46                   	inc    %esi
5ffb5c3f:	8a 04 10             	mov    (%eax,%edx,1),%al
5ffb5c42:	88 07                	mov    %al,(%edi)
5ffb5c44:	8b 4d c4             	mov    0xffffffc4(%ebp),%ecx
5ffb5c47:	8b 41 20             	mov    0x20(%ecx),%eax
5ffb5c4a:	8a 04 03             	mov    (%ebx,%eax,1),%al
5ffb5c4d:	43                   	inc    %ebx
5ffb5c4e:	25 ff 00 00 00       	and    $0xff,%eax
5ffb5c53:	66 89 47 02          	mov    %ax,0x2(%edi)
5ffb5c57:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
5ffb5c5a:	83 c7 04             	add    $0x4,%edi
5ffb5c5d:	89 45 a0             	mov    %eax,0xffffffa0(%ebp)
5ffb5c60:	39 f0                	cmp    %esi,%eax
5ffb5c62:	76 4c                	jbe    5ffb5cb0 <_CsrReadConsoleOutput@12+0x350>
5ffb5c64:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb5c67:	8b 42 20             	mov    0x20(%edx),%eax
5ffb5c6a:	85 c0                	test   %eax,%eax
5ffb5c6c:	74 ca                	je     5ffb5c38 <_CsrReadConsoleOutput@12+0x2d8>
5ffb5c6e:	50                   	push   %eax
5ffb5c6f:	50                   	push   %eax
5ffb5c70:	6a 01                	push   $0x1
5ffb5c72:	57                   	push   %edi
5ffb5c73:	6a 01                	push   $0x1
5ffb5c75:	8b 41 20             	mov    0x20(%ecx),%eax
5ffb5c78:	46                   	inc    %esi
5ffb5c79:	01 d8                	add    %ebx,%eax
5ffb5c7b:	43                   	inc    %ebx
5ffb5c7c:	50                   	push   %eax
5ffb5c7d:	6a 00                	push   $0x0
5ffb5c7f:	8b 4d b0             	mov    0xffffffb0(%ebp),%ecx
5ffb5c82:	51                   	push   %ecx
5ffb5c83:	e8 28 31 00 00       	call   5ffb8db0 <_MultiByteToWideChar@24>
5ffb5c88:	8b 4d c4             	mov    0xffffffc4(%ebp),%ecx
5ffb5c8b:	58                   	pop    %eax
5ffb5c8c:	5a                   	pop    %edx
5ffb5c8d:	8b 41 20             	mov    0x20(%ecx),%eax
5ffb5c90:	8a 04 03             	mov    (%ebx,%eax,1),%al
5ffb5c93:	43                   	inc    %ebx
5ffb5c94:	25 ff 00 00 00       	and    $0xff,%eax
5ffb5c99:	66 89 47 02          	mov    %ax,0x2(%edi)
5ffb5c9d:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
5ffb5ca0:	83 c7 04             	add    $0x4,%edi
5ffb5ca3:	89 45 a0             	mov    %eax,0xffffffa0(%ebp)
5ffb5ca6:	39 f0                	cmp    %esi,%eax
5ffb5ca8:	77 ba                	ja     5ffb5c64 <_CsrReadConsoleOutput@12+0x304>
5ffb5caa:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb5cb0:	8b 55 e4             	mov    0xffffffe4(%ebp),%edx
5ffb5cb3:	89 55 9c             	mov    %edx,0xffffff9c(%ebp)
5ffb5cb6:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
5ffb5cb9:	8b 7d 98             	mov    0xffffff98(%ebp),%edi
5ffb5cbc:	40                   	inc    %eax
5ffb5cbd:	8b 5d a4             	mov    0xffffffa4(%ebp),%ebx
5ffb5cc0:	89 45 b4             	mov    %eax,0xffffffb4(%ebp)
5ffb5cc3:	8d 3c 9f             	lea    (%edi,%ebx,4),%edi
5ffb5cc6:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
5ffb5cc9:	89 7d 98             	mov    %edi,0xffffff98(%ebp)
5ffb5ccc:	39 45 9c             	cmp    %eax,0xffffff9c(%ebp)
5ffb5ccf:	0f 87 1d ff ff ff    	ja     5ffb5bf2 <_CsrReadConsoleOutput@12+0x292>
5ffb5cd5:	e8 e6 b3 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb5cda:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb5cdd:	c7 42 18 00 00 00 00 	movl   $0x0,0x18(%edx)
5ffb5ce4:	8b 5d bc             	mov    0xffffffbc(%ebp),%ebx
5ffb5ce7:	8b 4d d8             	mov    0xffffffd8(%ebp),%ecx
5ffb5cea:	8d 04 19             	lea    (%ecx,%ebx,1),%eax
5ffb5ced:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb5cf0:	48                   	dec    %eax
5ffb5cf1:	66 89 42 20          	mov    %ax,0x20(%edx)
5ffb5cf5:	8b 55 dc             	mov    0xffffffdc(%ebp),%edx
5ffb5cf8:	8b 7d b8             	mov    0xffffffb8(%ebp),%edi
5ffb5cfb:	66 89 4b 1c          	mov    %cx,0x1c(%ebx)
5ffb5cff:	66 89 53 1e          	mov    %dx,0x1e(%ebx)
5ffb5d03:	8d 04 3a             	lea    (%edx,%edi,1),%eax
5ffb5d06:	48                   	dec    %eax
5ffb5d07:	66 89 43 22          	mov    %ax,0x22(%ebx)
5ffb5d0b:	31 c0                	xor    %eax,%eax
5ffb5d0d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb5d10:	5b                   	pop    %ebx
5ffb5d11:	5e                   	pop    %esi
5ffb5d12:	5f                   	pop    %edi
5ffb5d13:	5d                   	pop    %ebp
5ffb5d14:	c2 0c 00             	ret    $0xc
5ffb5d17:	85 d2                	test   %edx,%edx
5ffb5d19:	0f 89 79 fd ff ff    	jns    5ffb5a98 <_CsrReadConsoleOutput@12+0x138>
5ffb5d1f:	8b 7d a4             	mov    0xffffffa4(%ebp),%edi
5ffb5d22:	29 cf                	sub    %ecx,%edi
5ffb5d24:	89 7d bc             	mov    %edi,0xffffffbc(%ebp)
5ffb5d27:	e9 84 fd ff ff       	jmp    5ffb5ab0 <_CsrReadConsoleOutput@12+0x150>
5ffb5d2c:	e8 8f b3 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb5d31:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb5d34:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
5ffb5d3b:	31 c0                	xor    %eax,%eax
5ffb5d3d:	eb ce                	jmp    5ffb5d0d <_CsrReadConsoleOutput@12+0x3ad>
5ffb5d3f:	90                   	nop    

5ffb5d40 <_CsrWriteConsoleInput@12>:


CSR_API(CsrWriteConsoleInput)
{
5ffb5d40:	55                   	push   %ebp
5ffb5d41:	89 e5                	mov    %esp,%ebp
5ffb5d43:	57                   	push   %edi
5ffb5d44:	56                   	push   %esi
5ffb5d45:	53                   	push   %ebx
5ffb5d46:	83 ec 14             	sub    $0x14,%esp
  PINPUT_RECORD InputRecord;
  PCSRSS_CONSOLE Console;
  NTSTATUS Status;
  DWORD Length;
  DWORD Size;
  DWORD i;
  ConsoleInput* Record;
   
  DPRINT("CsrWriteConsoleInput\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
5ffb5d49:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb5d4c:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb5d4f:	66 c7 40 02 38 00    	movw   $0x38,0x2(%eax)
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
5ffb5d55:	66 c7 00 20 00       	movw   $0x20,(%eax)
   
  Status = ConioLockConsole(ProcessData, Request->Data.WriteConsoleInputRequest.ConsoleHandle, &Console);
5ffb5d5a:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
5ffb5d5d:	8b 53 1c             	mov    0x1c(%ebx),%edx
5ffb5d60:	6a 01                	push   $0x1
5ffb5d62:	50                   	push   %eax
5ffb5d63:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb5d66:	e8 15 b3 ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
  if (! NT_SUCCESS(Status))
5ffb5d6b:	5e                   	pop    %esi
5ffb5d6c:	85 c0                	test   %eax,%eax
5ffb5d6e:	5f                   	pop    %edi
5ffb5d6f:	0f 88 dc 00 00 00    	js     5ffb5e51 <_CsrWriteConsoleInput@12+0x111>
    {
      return Reply->Status = Status;
    }
   
  InputRecord = Request->Data.WriteConsoleInputRequest.InputRecord;
  Length = Request->Data.WriteConsoleInputRequest.Length;
5ffb5d75:	8b 7b 24             	mov    0x24(%ebx),%edi
  Size = Length * sizeof(INPUT_RECORD);
   
  if (((PVOID)InputRecord < ProcessData->CsrSectionViewBase)
5ffb5d78:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb5d7b:	8b 73 28             	mov    0x28(%ebx),%esi
5ffb5d7e:	8d 04 bf             	lea    (%edi,%edi,4),%eax
5ffb5d81:	8b 51 1c             	mov    0x1c(%ecx),%edx
5ffb5d84:	c1 e0 02             	shl    $0x2,%eax
5ffb5d87:	39 f2                	cmp    %esi,%edx
5ffb5d89:	0f 87 a1 00 00 00    	ja     5ffb5e30 <_CsrWriteConsoleInput@12+0xf0>
5ffb5d8f:	8b 59 20             	mov    0x20(%ecx),%ebx
5ffb5d92:	8d 04 06             	lea    (%esi,%eax,1),%eax
5ffb5d95:	01 da                	add    %ebx,%edx
5ffb5d97:	39 d0                	cmp    %edx,%eax
5ffb5d99:	0f 87 91 00 00 00    	ja     5ffb5e30 <_CsrWriteConsoleInput@12+0xf0>
      || (((PVOID)InputRecord + Size) > (ProcessData->CsrSectionViewBase + ProcessData->CsrSectionViewSize)))
    {
      ConioUnlockConsole(Console);
      Reply->Status = STATUS_ACCESS_VIOLATION;
      return Reply->Status ;
    }
   
  for (i = 0; i < Length; i++)
5ffb5d9f:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
5ffb5da6:	39 7d ec             	cmp    %edi,0xffffffec(%ebp)
5ffb5da9:	73 5d                	jae    5ffb5e08 <_CsrWriteConsoleInput@12+0xc8>
5ffb5dab:	90                   	nop    
5ffb5dac:	8d 74 26 00          	lea    0x0(%esi),%esi
    {
      Record = HeapAlloc(Win32CsrApiHeap, 0, sizeof(ConsoleInput));
5ffb5db0:	50                   	push   %eax
5ffb5db1:	6a 20                	push   $0x20
5ffb5db3:	6a 00                	push   $0x0
5ffb5db5:	a1 e0 c1 fb 5f       	mov    0x5ffbc1e0,%eax
5ffb5dba:	50                   	push   %eax
5ffb5dbb:	e8 30 2f 00 00       	call   5ffb8cf0 <_HeapAlloc@12>
5ffb5dc0:	89 c3                	mov    %eax,%ebx
      if (NULL == Record)
5ffb5dc2:	58                   	pop    %eax
5ffb5dc3:	85 db                	test   %ebx,%ebx
5ffb5dc5:	0f 84 a2 00 00 00    	je     5ffb5e6d <_CsrWriteConsoleInput@12+0x12d>
        {
          ConioUnlockConsole(Console);
          Reply->Status = STATUS_INSUFFICIENT_RESOURCES;
          return Reply->Status;
        }

      Record->Echoed = FALSE;
      Record->Fake = FALSE;
      Record->InputEvent = *InputRecord++;
5ffb5dcb:	89 f2                	mov    %esi,%edx
5ffb5dcd:	c6 43 1c 00          	movb   $0x0,0x1c(%ebx)
5ffb5dd1:	c6 43 1d 00          	movb   $0x0,0x1d(%ebx)
5ffb5dd5:	83 c6 14             	add    $0x14,%esi
5ffb5dd8:	8b 02                	mov    (%edx),%eax
5ffb5dda:	89 43 08             	mov    %eax,0x8(%ebx)
5ffb5ddd:	8b 42 04             	mov    0x4(%edx),%eax
5ffb5de0:	89 43 0c             	mov    %eax,0xc(%ebx)
5ffb5de3:	8b 42 08             	mov    0x8(%edx),%eax
5ffb5de6:	89 43 10             	mov    %eax,0x10(%ebx)
5ffb5de9:	8b 42 0c             	mov    0xc(%edx),%eax
5ffb5dec:	89 43 14             	mov    %eax,0x14(%ebx)
5ffb5def:	8b 42 10             	mov    0x10(%edx),%eax
5ffb5df2:	89 43 18             	mov    %eax,0x18(%ebx)
      if (KEY_EVENT == Record->InputEvent.EventType)
5ffb5df5:	66 83 7b 08 01       	cmpw   $0x1,0x8(%ebx)
5ffb5dfa:	74 65                	je     5ffb5e61 <_CsrWriteConsoleInput@12+0x121>
5ffb5dfc:	8b 5d ec             	mov    0xffffffec(%ebp),%ebx
5ffb5dff:	43                   	inc    %ebx
5ffb5e00:	89 5d ec             	mov    %ebx,0xffffffec(%ebp)
5ffb5e03:	39 7d ec             	cmp    %edi,0xffffffec(%ebp)
5ffb5e06:	72 a8                	jb     5ffb5db0 <_CsrWriteConsoleInput@12+0x70>
        {
          /* FIXME - convert from unicode to ascii!! */
          ConioProcessChar(Console, Record);
        }
    }

  ConioUnlockConsole(Console);
5ffb5e08:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb5e0b:	e8 b0 b2 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
   
  Reply->Status = STATUS_SUCCESS;
5ffb5e10:	8b 4d 10             	mov    0x10(%ebp),%ecx
5ffb5e13:	c7 41 18 00 00 00 00 	movl   $0x0,0x18(%ecx)
  Reply->Data.WriteConsoleInputReply.Length = i;
5ffb5e1a:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb5e1d:	89 41 1c             	mov    %eax,0x1c(%ecx)

  return Reply->Status;
}
5ffb5e20:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb5e23:	31 c0                	xor    %eax,%eax
5ffb5e25:	5b                   	pop    %ebx
5ffb5e26:	5e                   	pop    %esi
5ffb5e27:	5f                   	pop    %edi
5ffb5e28:	5d                   	pop    %ebp
5ffb5e29:	c2 0c 00             	ret    $0xc
5ffb5e2c:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb5e30:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb5e33:	e8 88 b2 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb5e38:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb5e3b:	c7 40 18 05 00 00 c0 	movl   $0xc0000005,0x18(%eax)
5ffb5e42:	b8 05 00 00 c0       	mov    $0xc0000005,%eax
5ffb5e47:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb5e4a:	5b                   	pop    %ebx
5ffb5e4b:	5e                   	pop    %esi
5ffb5e4c:	5f                   	pop    %edi
5ffb5e4d:	5d                   	pop    %ebp
5ffb5e4e:	c2 0c 00             	ret    $0xc
5ffb5e51:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb5e54:	89 42 18             	mov    %eax,0x18(%edx)
5ffb5e57:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb5e5a:	5b                   	pop    %ebx
5ffb5e5b:	5e                   	pop    %esi
5ffb5e5c:	5f                   	pop    %edi
5ffb5e5d:	5d                   	pop    %ebp
5ffb5e5e:	c2 0c 00             	ret    $0xc
5ffb5e61:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb5e64:	89 da                	mov    %ebx,%edx
5ffb5e66:	e8 25 c9 ff ff       	call   5ffb2790 <@ConioProcessChar@8>
5ffb5e6b:	eb 8f                	jmp    5ffb5dfc <_CsrWriteConsoleInput@12+0xbc>
5ffb5e6d:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb5e70:	e8 4b b2 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb5e75:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb5e78:	b8 9a 00 00 c0       	mov    $0xc000009a,%eax
5ffb5e7d:	c7 42 18 9a 00 00 c0 	movl   $0xc000009a,0x18(%edx)
5ffb5e84:	eb c1                	jmp    5ffb5e47 <_CsrWriteConsoleInput@12+0x107>
5ffb5e86:	8d 76 00             	lea    0x0(%esi),%esi
5ffb5e89:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb5e90 <_CsrHardwareStateProperty@12>:

/**********************************************************************
 *	HardwareStateProperty
 *
 *	DESCRIPTION
 *		Set/Get the value of the HardwareState and switch
 *		between direct video buffer ouput and GDI windowed
 *		output.
 *	ARGUMENTS
 *		Client hands us a CSRSS_CONSOLE_HARDWARE_STATE
 *		object. We use the same object to reply.
 *	NOTE
 *		ConsoleHwState has the correct size to be compatible
 *		with NT's, but values are not.
 */
STATIC NTSTATUS FASTCALL
SetConsoleHardwareState (PCSRSS_CONSOLE Console, DWORD ConsoleHwState)
{
  DPRINT1("Console Hardware State: %d\n", ConsoleHwState);

  if ((CONSOLE_HARDWARE_STATE_GDI_MANAGED == ConsoleHwState)
      ||(CONSOLE_HARDWARE_STATE_DIRECT == ConsoleHwState))
    {
      if (Console->HardwareState != ConsoleHwState)
        {
          /* TODO: implement switching from full screen to windowed mode */
          /* TODO: or back; now simply store the hardware state */
          Console->HardwareState = ConsoleHwState;
        }

      return STATUS_SUCCESS;	
    }

  return STATUS_INVALID_PARAMETER_3; /* Client: (handle, set_get, [mode]) */
}

CSR_API(CsrHardwareStateProperty)
{
5ffb5e90:	55                   	push   %ebp
5ffb5e91:	89 e5                	mov    %esp,%ebp
5ffb5e93:	57                   	push   %edi
5ffb5e94:	56                   	push   %esi
5ffb5e95:	53                   	push   %ebx
5ffb5e96:	83 ec 14             	sub    $0x14,%esp
  PCSRSS_CONSOLE Console;
  NTSTATUS Status;
 
  DPRINT("CsrHardwareStateProperty\n");

  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
   
  Status = ConioLockConsole(ProcessData,
5ffb5e99:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
5ffb5e9c:	8b 7d 10             	mov    0x10(%ebp),%edi
5ffb5e9f:	8b 75 0c             	mov    0xc(%ebp),%esi
5ffb5ea2:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb5ea5:	66 c7 47 02 38 00    	movw   $0x38,0x2(%edi)
5ffb5eab:	66 c7 07 20 00       	movw   $0x20,(%edi)
5ffb5eb0:	8b 56 1c             	mov    0x1c(%esi),%edx
5ffb5eb3:	6a 01                	push   $0x1
5ffb5eb5:	50                   	push   %eax
5ffb5eb6:	e8 c5 b1 ff ff       	call   5ffb1080 <@Win32CsrLockObject@16>
5ffb5ebb:	89 c3                	mov    %eax,%ebx
                            Request->Data.ConsoleHardwareStateRequest.ConsoleHandle,
                            &Console);
  if (! NT_SUCCESS(Status))
5ffb5ebd:	58                   	pop    %eax
5ffb5ebe:	85 db                	test   %ebx,%ebx
5ffb5ec0:	5a                   	pop    %edx
5ffb5ec1:	78 31                	js     5ffb5ef4 <_CsrHardwareStateProperty@12+0x64>
    {
      DPRINT1("Failed to get console handle in SetConsoleHardwareState\n");
      return Reply->Status = Status;
    }

  switch (Request->Data.ConsoleHardwareStateRequest.SetGet)
5ffb5ec3:	8b 46 20             	mov    0x20(%esi),%eax
5ffb5ec6:	85 c0                	test   %eax,%eax
5ffb5ec8:	75 1b                	jne    5ffb5ee5 <_CsrHardwareStateProperty@12+0x55>
    {
      case CONSOLE_HARDWARE_STATE_GET:
        Reply->Data.ConsoleHardwareStateReply.State = Console->HardwareState;
5ffb5eca:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb5ecd:	8b 41 54             	mov    0x54(%ecx),%eax
5ffb5ed0:	89 47 24             	mov    %eax,0x24(%edi)
        break;
      
      case CONSOLE_HARDWARE_STATE_SET:
        DPRINT("Setting console hardware state.\n");
        Reply->Status = SetConsoleHardwareState(Console, Request->Data.ConsoleHardwareStateRequest.State);
        break;

      default:
        Reply->Status = STATUS_INVALID_PARAMETER_2; /* Client: (handle, [set_get], mode) */
        break;
    }

  ConioUnlockConsole(Console);
5ffb5ed3:	e8 e8 b1 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>

  return Reply->Status;
5ffb5ed8:	8b 47 18             	mov    0x18(%edi),%eax
}
5ffb5edb:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb5ede:	5b                   	pop    %ebx
5ffb5edf:	5e                   	pop    %esi
5ffb5ee0:	5f                   	pop    %edi
5ffb5ee1:	5d                   	pop    %ebp
5ffb5ee2:	c2 0c 00             	ret    $0xc
5ffb5ee5:	48                   	dec    %eax
5ffb5ee6:	74 3e                	je     5ffb5f26 <_CsrHardwareStateProperty@12+0x96>
5ffb5ee8:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb5eeb:	c7 47 18 f0 00 00 c0 	movl   $0xc00000f0,0x18(%edi)
5ffb5ef2:	eb df                	jmp    5ffb5ed3 <_CsrHardwareStateProperty@12+0x43>
5ffb5ef4:	56                   	push   %esi
5ffb5ef5:	68 bf 0b 00 00       	push   $0xbbf
5ffb5efa:	68 40 b0 fb 5f       	push   $0x5ffbb040
5ffb5eff:	68 48 b0 fb 5f       	push   $0x5ffbb048
5ffb5f04:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb5f0a:	c7 04 24 0c b2 fb 5f 	movl   $0x5ffbb20c,(%esp)
5ffb5f11:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb5f17:	89 5f 18             	mov    %ebx,0x18(%edi)
5ffb5f1a:	89 d8                	mov    %ebx,%eax
5ffb5f1c:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb5f1f:	5b                   	pop    %ebx
5ffb5f20:	5e                   	pop    %esi
5ffb5f21:	5f                   	pop    %edi
5ffb5f22:	5d                   	pop    %ebp
5ffb5f23:	c2 0c 00             	ret    $0xc
5ffb5f26:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
5ffb5f29:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
5ffb5f2c:	8b 5e 24             	mov    0x24(%esi),%ebx
5ffb5f2f:	51                   	push   %ecx
5ffb5f30:	68 9e 0b 00 00       	push   $0xb9e
5ffb5f35:	68 40 b0 fb 5f       	push   $0x5ffbb040
5ffb5f3a:	68 48 b0 fb 5f       	push   $0x5ffbb048
5ffb5f3f:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb5f45:	58                   	pop    %eax
5ffb5f46:	5a                   	pop    %edx
5ffb5f47:	53                   	push   %ebx
5ffb5f48:	68 45 b2 fb 5f       	push   $0x5ffbb245
5ffb5f4d:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb5f53:	83 c4 10             	add    $0x10,%esp
5ffb5f56:	b8 f1 00 00 c0       	mov    $0xc00000f1,%eax
5ffb5f5b:	83 fb 01             	cmp    $0x1,%ebx
5ffb5f5e:	77 0d                	ja     5ffb5f6d <_CsrHardwareStateProperty@12+0xdd>
5ffb5f60:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb5f63:	39 58 54             	cmp    %ebx,0x54(%eax)
5ffb5f66:	74 03                	je     5ffb5f6b <_CsrHardwareStateProperty@12+0xdb>
5ffb5f68:	89 58 54             	mov    %ebx,0x54(%eax)
5ffb5f6b:	31 c0                	xor    %eax,%eax
5ffb5f6d:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb5f70:	89 47 18             	mov    %eax,0x18(%edi)
5ffb5f73:	e9 5b ff ff ff       	jmp    5ffb5ed3 <_CsrHardwareStateProperty@12+0x43>
5ffb5f78:	90                   	nop    
5ffb5f79:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

5ffb5f80 <_CsrGetConsoleWindow@12>:

CSR_API(CsrGetConsoleWindow)
{
5ffb5f80:	55                   	push   %ebp
5ffb5f81:	89 e5                	mov    %esp,%ebp
5ffb5f83:	53                   	push   %ebx
5ffb5f84:	53                   	push   %ebx
5ffb5f85:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb5f88:	8b 4d 08             	mov    0x8(%ebp),%ecx
  PCSRSS_CONSOLE Console;
  NTSTATUS Status;

  DPRINT("CsrGetConsoleWindow\n");
 
  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
   
  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb5f8b:	8d 55 f8             	lea    0xfffffff8(%ebp),%edx
5ffb5f8e:	66 c7 43 02 38 00    	movw   $0x38,0x2(%ebx)
5ffb5f94:	66 c7 03 20 00       	movw   $0x20,(%ebx)
5ffb5f99:	e8 22 b2 ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
  if (! NT_SUCCESS(Status))
5ffb5f9e:	85 c0                	test   %eax,%eax
5ffb5fa0:	78 1e                	js     5ffb5fc0 <_CsrGetConsoleWindow@12+0x40>
    {
      return Reply->Status = Status;
    }

  Reply->Data.GetConsoleWindowReply.WindowHandle = Console->hWindow;
5ffb5fa2:	8b 4d f8             	mov    0xfffffff8(%ebp),%ecx
5ffb5fa5:	8b 41 58             	mov    0x58(%ecx),%eax
5ffb5fa8:	89 43 1c             	mov    %eax,0x1c(%ebx)
  ConioUnlockConsole(Console);
5ffb5fab:	e8 10 b1 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>

  return Reply->Status = STATUS_SUCCESS;
5ffb5fb0:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
5ffb5fb7:	31 c0                	xor    %eax,%eax
}
5ffb5fb9:	59                   	pop    %ecx
5ffb5fba:	5b                   	pop    %ebx
5ffb5fbb:	5d                   	pop    %ebp
5ffb5fbc:	c2 0c 00             	ret    $0xc
5ffb5fbf:	90                   	nop    
5ffb5fc0:	89 43 18             	mov    %eax,0x18(%ebx)
5ffb5fc3:	59                   	pop    %ecx
5ffb5fc4:	5b                   	pop    %ebx
5ffb5fc5:	5d                   	pop    %ebp
5ffb5fc6:	c2 0c 00             	ret    $0xc
5ffb5fc9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

5ffb5fd0 <_CsrSetConsoleIcon@12>:

CSR_API(CsrSetConsoleIcon)
{
5ffb5fd0:	55                   	push   %ebp
5ffb5fd1:	89 e5                	mov    %esp,%ebp
5ffb5fd3:	53                   	push   %ebx
5ffb5fd4:	50                   	push   %eax
5ffb5fd5:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb5fd8:	8b 4d 08             	mov    0x8(%ebp),%ecx
  PCSRSS_CONSOLE Console;
  NTSTATUS Status;

  DPRINT("CsrSetConsoleIcon\n");
 
  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
   
  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb5fdb:	8d 55 f8             	lea    0xfffffff8(%ebp),%edx
5ffb5fde:	66 c7 43 02 38 00    	movw   $0x38,0x2(%ebx)
5ffb5fe4:	66 c7 03 20 00       	movw   $0x20,(%ebx)
5ffb5fe9:	e8 d2 b1 ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
  if (! NT_SUCCESS(Status))
5ffb5fee:	85 c0                	test   %eax,%eax
5ffb5ff0:	78 3e                	js     5ffb6030 <_CsrSetConsoleIcon@12+0x60>
    {
      return Reply->Status = Status;
    }

  Console->hWindowIcon = Request->Data.SetConsoleIconRequest.WindowIcon;
5ffb5ff2:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb5ff5:	8b 55 f8             	mov    0xfffffff8(%ebp),%edx
  Reply->Status = (ConioChangeIcon(Console) ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
5ffb5ff8:	83 ec 0c             	sub    $0xc,%esp
5ffb5ffb:	8b 40 1c             	mov    0x1c(%eax),%eax
5ffb5ffe:	89 42 5c             	mov    %eax,0x5c(%edx)
5ffb6001:	8b 42 70             	mov    0x70(%edx),%eax
5ffb6004:	52                   	push   %edx
5ffb6005:	ff 50 1c             	call   *0x1c(%eax)
  ConioUnlockConsole(Console);
5ffb6008:	8b 4d f8             	mov    0xfffffff8(%ebp),%ecx
5ffb600b:	83 c4 0c             	add    $0xc,%esp
5ffb600e:	83 f8 01             	cmp    $0x1,%eax
5ffb6011:	19 c0                	sbb    %eax,%eax
5ffb6013:	25 01 00 00 c0       	and    $0xc0000001,%eax
5ffb6018:	89 43 18             	mov    %eax,0x18(%ebx)
5ffb601b:	e8 a0 b0 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>

  return Reply->Status;
5ffb6020:	8b 43 18             	mov    0x18(%ebx),%eax
}
5ffb6023:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb6026:	c9                   	leave  
5ffb6027:	c2 0c 00             	ret    $0xc
5ffb602a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb6030:	89 43 18             	mov    %eax,0x18(%ebx)
5ffb6033:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb6036:	c9                   	leave  
5ffb6037:	c2 0c 00             	ret    $0xc
5ffb603a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

5ffb6040 <_CsrGetConsoleCodePage@12>:

CSR_API(CsrGetConsoleCodePage)
{
5ffb6040:	55                   	push   %ebp
5ffb6041:	89 e5                	mov    %esp,%ebp
5ffb6043:	53                   	push   %ebx
5ffb6044:	51                   	push   %ecx
5ffb6045:	8b 4d 08             	mov    0x8(%ebp),%ecx
  PCSRSS_CONSOLE Console;
  NTSTATUS Status;

  DPRINT("CsrGetConsoleCodePage\n");

  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb6048:	8d 55 f8             	lea    0xfffffff8(%ebp),%edx
5ffb604b:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb604e:	e8 6d b1 ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
  if (! NT_SUCCESS(Status))
5ffb6053:	85 c0                	test   %eax,%eax
5ffb6055:	78 29                	js     5ffb6080 <_CsrGetConsoleCodePage@12+0x40>
    {
      return Reply->Status = Status;
    }
 
  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
  Reply->Data.GetConsoleCodePage.CodePage = Console->CodePage;
5ffb6057:	8b 4d f8             	mov    0xfffffff8(%ebp),%ecx
5ffb605a:	66 c7 43 02 38 00    	movw   $0x38,0x2(%ebx)
5ffb6060:	66 c7 03 20 00       	movw   $0x20,(%ebx)
5ffb6065:	8b 41 68             	mov    0x68(%ecx),%eax
5ffb6068:	89 43 1c             	mov    %eax,0x1c(%ebx)
  ConioUnlockConsole(Console);
5ffb606b:	e8 50 b0 ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
  return Reply->Status = STATUS_SUCCESS;
5ffb6070:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
5ffb6077:	31 c0                	xor    %eax,%eax
}
5ffb6079:	5a                   	pop    %edx
5ffb607a:	5b                   	pop    %ebx
5ffb607b:	5d                   	pop    %ebp
5ffb607c:	c2 0c 00             	ret    $0xc
5ffb607f:	90                   	nop    
5ffb6080:	89 43 18             	mov    %eax,0x18(%ebx)
5ffb6083:	5a                   	pop    %edx
5ffb6084:	5b                   	pop    %ebx
5ffb6085:	5d                   	pop    %ebp
5ffb6086:	c2 0c 00             	ret    $0xc
5ffb6089:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

5ffb6090 <_CsrSetConsoleCodePage@12>:

CSR_API(CsrSetConsoleCodePage)
{
5ffb6090:	55                   	push   %ebp
5ffb6091:	89 e5                	mov    %esp,%ebp
5ffb6093:	56                   	push   %esi
5ffb6094:	53                   	push   %ebx
5ffb6095:	83 ec 10             	sub    $0x10,%esp
  PCSRSS_CONSOLE Console;
  NTSTATUS Status;

  DPRINT("CsrSetConsoleCodePage\n");

  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb6098:	8d 55 f4             	lea    0xfffffff4(%ebp),%edx
5ffb609b:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb609e:	8b 75 0c             	mov    0xc(%ebp),%esi
5ffb60a1:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb60a4:	e8 17 b1 ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
  if (! NT_SUCCESS(Status))
5ffb60a9:	85 c0                	test   %eax,%eax
5ffb60ab:	78 43                	js     5ffb60f0 <_CsrSetConsoleCodePage@12+0x60>
    {
      return Reply->Status = Status;
    }
 
  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
5ffb60ad:	66 c7 43 02 38 00    	movw   $0x38,0x2(%ebx)
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
5ffb60b3:	66 c7 03 20 00       	movw   $0x20,(%ebx)
  if (IsValidCodePage(Request->Data.SetConsoleCodePage.CodePage))
5ffb60b8:	83 ec 0c             	sub    $0xc,%esp
5ffb60bb:	8b 46 1c             	mov    0x1c(%esi),%eax
5ffb60be:	50                   	push   %eax
5ffb60bf:	e8 fc 2c 00 00       	call   5ffb8dc0 <_IsValidCodePage@4>
5ffb60c4:	83 c4 0c             	add    $0xc,%esp
5ffb60c7:	85 c0                	test   %eax,%eax
5ffb60c9:	74 31                	je     5ffb60fc <_CsrSetConsoleCodePage@12+0x6c>
    {
      Console->CodePage = Request->Data.SetConsoleCodePage.CodePage;
5ffb60cb:	8b 4d f4             	mov    0xfffffff4(%ebp),%ecx
5ffb60ce:	8b 46 1c             	mov    0x1c(%esi),%eax
5ffb60d1:	89 41 68             	mov    %eax,0x68(%ecx)
      ConioUnlockConsole(Console);
5ffb60d4:	e8 e7 af ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
      return Reply->Status = STATUS_SUCCESS;
5ffb60d9:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
5ffb60e0:	31 c0                	xor    %eax,%eax
    }
  ConioUnlockConsole(Console);
  return Reply->Status = STATUS_UNSUCCESSFUL;
}
5ffb60e2:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb60e5:	5b                   	pop    %ebx
5ffb60e6:	5e                   	pop    %esi
5ffb60e7:	5d                   	pop    %ebp
5ffb60e8:	c2 0c 00             	ret    $0xc
5ffb60eb:	90                   	nop    
5ffb60ec:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb60f0:	89 43 18             	mov    %eax,0x18(%ebx)
5ffb60f3:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb60f6:	5b                   	pop    %ebx
5ffb60f7:	5e                   	pop    %esi
5ffb60f8:	5d                   	pop    %ebp
5ffb60f9:	c2 0c 00             	ret    $0xc
5ffb60fc:	8b 4d f4             	mov    0xfffffff4(%ebp),%ecx
5ffb60ff:	e8 bc af ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb6104:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
5ffb6109:	c7 43 18 01 00 00 c0 	movl   $0xc0000001,0x18(%ebx)
5ffb6110:	eb d0                	jmp    5ffb60e2 <_CsrSetConsoleCodePage@12+0x52>
5ffb6112:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
5ffb6119:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb6120 <_CsrGetConsoleOutputCodePage@12>:

CSR_API(CsrGetConsoleOutputCodePage)
{
5ffb6120:	55                   	push   %ebp
5ffb6121:	89 e5                	mov    %esp,%ebp
5ffb6123:	53                   	push   %ebx
5ffb6124:	51                   	push   %ecx
5ffb6125:	8b 4d 08             	mov    0x8(%ebp),%ecx
  PCSRSS_CONSOLE Console;
  NTSTATUS Status;

  DPRINT("CsrGetConsoleOutputCodePage\n");

  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb6128:	8d 55 f8             	lea    0xfffffff8(%ebp),%edx
5ffb612b:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb612e:	e8 8d b0 ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
  if (! NT_SUCCESS(Status))
5ffb6133:	85 c0                	test   %eax,%eax
5ffb6135:	78 29                	js     5ffb6160 <_CsrGetConsoleOutputCodePage@12+0x40>
    {
      return Reply->Status = Status;
    }
 
  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
  Reply->Data.GetConsoleOutputCodePage.CodePage = Console->OutputCodePage;
5ffb6137:	8b 4d f8             	mov    0xfffffff8(%ebp),%ecx
5ffb613a:	66 c7 43 02 38 00    	movw   $0x38,0x2(%ebx)
5ffb6140:	66 c7 03 20 00       	movw   $0x20,(%ebx)
5ffb6145:	8b 41 6c             	mov    0x6c(%ecx),%eax
5ffb6148:	89 43 1c             	mov    %eax,0x1c(%ebx)
  ConioUnlockConsole(Console);
5ffb614b:	e8 70 af ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
  return Reply->Status = STATUS_SUCCESS;
5ffb6150:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
5ffb6157:	31 c0                	xor    %eax,%eax
}
5ffb6159:	5a                   	pop    %edx
5ffb615a:	5b                   	pop    %ebx
5ffb615b:	5d                   	pop    %ebp
5ffb615c:	c2 0c 00             	ret    $0xc
5ffb615f:	90                   	nop    
5ffb6160:	89 43 18             	mov    %eax,0x18(%ebx)
5ffb6163:	5a                   	pop    %edx
5ffb6164:	5b                   	pop    %ebx
5ffb6165:	5d                   	pop    %ebp
5ffb6166:	c2 0c 00             	ret    $0xc
5ffb6169:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

5ffb6170 <_CsrSetConsoleOutputCodePage@12>:

CSR_API(CsrSetConsoleOutputCodePage)
{
5ffb6170:	55                   	push   %ebp
5ffb6171:	89 e5                	mov    %esp,%ebp
5ffb6173:	56                   	push   %esi
5ffb6174:	53                   	push   %ebx
5ffb6175:	83 ec 10             	sub    $0x10,%esp
  PCSRSS_CONSOLE Console;
  NTSTATUS Status;

  DPRINT("CsrSetConsoleOutputCodePage\n");

  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb6178:	8d 55 f4             	lea    0xfffffff4(%ebp),%edx
5ffb617b:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb617e:	8b 75 0c             	mov    0xc(%ebp),%esi
5ffb6181:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb6184:	e8 37 b0 ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
  if (! NT_SUCCESS(Status))
5ffb6189:	85 c0                	test   %eax,%eax
5ffb618b:	78 43                	js     5ffb61d0 <_CsrSetConsoleOutputCodePage@12+0x60>
    {
      return Reply->Status = Status;
    }
 
  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
5ffb618d:	66 c7 43 02 38 00    	movw   $0x38,0x2(%ebx)
  Reply->Header.DataSize = sizeof(CSRSS_API_REPLY) - LPC_MESSAGE_BASE_SIZE;
5ffb6193:	66 c7 03 20 00       	movw   $0x20,(%ebx)
  if (IsValidCodePage(Request->Data.SetConsoleOutputCodePage.CodePage))
5ffb6198:	83 ec 0c             	sub    $0xc,%esp
5ffb619b:	8b 46 1c             	mov    0x1c(%esi),%eax
5ffb619e:	50                   	push   %eax
5ffb619f:	e8 1c 2c 00 00       	call   5ffb8dc0 <_IsValidCodePage@4>
5ffb61a4:	83 c4 0c             	add    $0xc,%esp
5ffb61a7:	85 c0                	test   %eax,%eax
5ffb61a9:	74 31                	je     5ffb61dc <_CsrSetConsoleOutputCodePage@12+0x6c>
    {
      Console->OutputCodePage = Request->Data.SetConsoleOutputCodePage.CodePage;
5ffb61ab:	8b 4d f4             	mov    0xfffffff4(%ebp),%ecx
5ffb61ae:	8b 46 1c             	mov    0x1c(%esi),%eax
5ffb61b1:	89 41 6c             	mov    %eax,0x6c(%ecx)
      ConioUnlockConsole(Console);
5ffb61b4:	e8 07 af ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
      return Reply->Status = STATUS_SUCCESS;
5ffb61b9:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
5ffb61c0:	31 c0                	xor    %eax,%eax
    }
  ConioUnlockConsole(Console);
  return Reply->Status = STATUS_UNSUCCESSFUL;
}
5ffb61c2:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb61c5:	5b                   	pop    %ebx
5ffb61c6:	5e                   	pop    %esi
5ffb61c7:	5d                   	pop    %ebp
5ffb61c8:	c2 0c 00             	ret    $0xc
5ffb61cb:	90                   	nop    
5ffb61cc:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb61d0:	89 43 18             	mov    %eax,0x18(%ebx)
5ffb61d3:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb61d6:	5b                   	pop    %ebx
5ffb61d7:	5e                   	pop    %esi
5ffb61d8:	5d                   	pop    %ebp
5ffb61d9:	c2 0c 00             	ret    $0xc
5ffb61dc:	8b 4d f4             	mov    0xfffffff4(%ebp),%ecx
5ffb61df:	e8 dc ae ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
5ffb61e4:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
5ffb61e9:	c7 43 18 01 00 00 c0 	movl   $0xc0000001,0x18(%ebx)
5ffb61f0:	eb d0                	jmp    5ffb61c2 <_CsrSetConsoleOutputCodePage@12+0x52>
5ffb61f2:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
5ffb61f9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb6200 <_CsrGetProcessList@12>:

CSR_API(CsrGetProcessList)
{
5ffb6200:	55                   	push   %ebp
5ffb6201:	89 e5                	mov    %esp,%ebp
5ffb6203:	57                   	push   %edi
5ffb6204:	56                   	push   %esi
5ffb6205:	53                   	push   %ebx
5ffb6206:	83 ec 1c             	sub    $0x1c,%esp
  PHANDLE Buffer;
  PCSRSS_CONSOLE Console;
  PCSRSS_PROCESS_DATA current;
  PLIST_ENTRY current_entry;
  ULONG nItems, nCopied;
  NTSTATUS Status;

  DPRINT("CsrGetProcessList\n");
  
  Buffer = Reply->Data.GetProcessListReply.ProcessId;
  Reply->Header.MessageSize = sizeof(CSRSS_API_REPLY);
  Reply->Header.DataSize = Reply->Header.MessageSize - LPC_MESSAGE_BASE_SIZE;
  
  nItems = nCopied = 0;
  Reply->Data.GetProcessListReply.nProcessIdsCopied = 0;
  Reply->Data.GetProcessListReply.nProcessIdsTotal = 0;
  
  Status = ConioConsoleFromProcessData(ProcessData, &Console);
5ffb6209:	8d 55 f0             	lea    0xfffffff0(%ebp),%edx
5ffb620c:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb620f:	8b 75 10             	mov    0x10(%ebp),%esi
5ffb6212:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb6215:	83 c6 24             	add    $0x24,%esi
5ffb6218:	66 c7 40 02 38 00    	movw   $0x38,0x2(%eax)
5ffb621e:	66 c7 00 20 00       	movw   $0x20,(%eax)
5ffb6223:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
5ffb622a:	c7 40 1c 00 00 00 00 	movl   $0x0,0x1c(%eax)
5ffb6231:	c7 40 20 00 00 00 00 	movl   $0x0,0x20(%eax)
5ffb6238:	31 ff                	xor    %edi,%edi
5ffb623a:	e8 81 af ff ff       	call   5ffb11c0 <@ConioConsoleFromProcessData@8>
  if (! NT_SUCCESS(Status))
5ffb623f:	85 c0                	test   %eax,%eax
5ffb6241:	0f 88 86 00 00 00    	js     5ffb62cd <_CsrGetProcessList@12+0xcd>
  {
    return Reply->Status = Status;
  }

  DPRINT1("Console_Api Ctrl-C\n");
5ffb6247:	50                   	push   %eax
5ffb6248:	68 78 0c 00 00       	push   $0xc78
5ffb624d:	68 40 b0 fb 5f       	push   $0x5ffbb040
5ffb6252:	68 48 b0 fb 5f       	push   $0x5ffbb048
5ffb6257:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb625d:	c7 04 24 75 b1 fb 5f 	movl   $0x5ffbb175,(%esp)
5ffb6264:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4

  for(current_entry = Console->ProcessList.Flink;
5ffb626a:	8b 5d f0             	mov    0xfffffff0(%ebp),%ebx
5ffb626d:	89 d8                	mov    %ebx,%eax
5ffb626f:	8b 53 74             	mov    0x74(%ebx),%edx
5ffb6272:	83 c0 74             	add    $0x74,%eax
5ffb6275:	83 c4 10             	add    $0x10,%esp
5ffb6278:	89 5d e8             	mov    %ebx,0xffffffe8(%ebp)
5ffb627b:	39 d0                	cmp    %edx,%eax
5ffb627d:	74 27                	je     5ffb62a6 <_CsrGetProcessList@12+0xa6>
5ffb627f:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
      current_entry != &Console->ProcessList;
      current_entry = current_entry->Flink)
  {
    current = CONTAINING_RECORD(current_entry, CSRSS_PROCESS_DATA, ProcessEntry);
    if(nItems++ < Request->Data.GetProcessListRequest.nMaxIds)
5ffb6282:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb6285:	89 f8                	mov    %edi,%eax
5ffb6287:	8d 4a d8             	lea    0xffffffd8(%edx),%ecx
5ffb628a:	47                   	inc    %edi
5ffb628b:	3b 43 1c             	cmp    0x1c(%ebx),%eax
5ffb628e:	73 0f                	jae    5ffb629f <_CsrGetProcessList@12+0x9f>
    {
      *(Buffer++) = current->ProcessId;
5ffb6290:	8b 41 0c             	mov    0xc(%ecx),%eax
5ffb6293:	89 06                	mov    %eax,(%esi)
      nCopied++;
5ffb6295:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb6298:	40                   	inc    %eax
5ffb6299:	83 c6 04             	add    $0x4,%esi
5ffb629c:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
5ffb629f:	8b 12                	mov    (%edx),%edx
5ffb62a1:	39 55 e4             	cmp    %edx,0xffffffe4(%ebp)
5ffb62a4:	75 dc                	jne    5ffb6282 <_CsrGetProcessList@12+0x82>
    }
  }

  ConioUnlockConsole(Console);
5ffb62a6:	8b 4d e8             	mov    0xffffffe8(%ebp),%ecx
5ffb62a9:	e8 12 ae ff ff       	call   5ffb10c0 <@Win32CsrUnlockObject@4>
  
  Reply->Data.GetProcessListReply.nProcessIdsCopied = nCopied;
5ffb62ae:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb62b1:	8b 55 ec             	mov    0xffffffec(%ebp),%edx
  Reply->Data.GetProcessListReply.nProcessIdsTotal = nItems;
5ffb62b4:	89 78 20             	mov    %edi,0x20(%eax)
5ffb62b7:	89 50 1c             	mov    %edx,0x1c(%eax)
  
  return Reply->Status = STATUS_SUCCESS;
5ffb62ba:	c7 40 18 00 00 00 00 	movl   $0x0,0x18(%eax)
}
5ffb62c1:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb62c4:	31 c0                	xor    %eax,%eax
5ffb62c6:	5b                   	pop    %ebx
5ffb62c7:	5e                   	pop    %esi
5ffb62c8:	5f                   	pop    %edi
5ffb62c9:	5d                   	pop    %ebp
5ffb62ca:	c2 0c 00             	ret    $0xc
5ffb62cd:	8b 55 10             	mov    0x10(%ebp),%edx
5ffb62d0:	89 42 18             	mov    %eax,0x18(%edx)
5ffb62d3:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb62d6:	5b                   	pop    %ebx
5ffb62d7:	5e                   	pop    %esi
5ffb62d8:	5f                   	pop    %edi
5ffb62d9:	5d                   	pop    %ebp
5ffb62da:	c2 0c 00             	ret    $0xc
5ffb62dd:	90                   	nop    
5ffb62de:	90                   	nop    
5ffb62df:	90                   	nop    

5ffb62e0 <_DtbgWindowProc@16>:
5ffb62e0:	55                   	push   %ebp
5ffb62e1:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb62e6:	89 e5                	mov    %esp,%ebp
5ffb62e8:	56                   	push   %esi
5ffb62e9:	53                   	push   %ebx
5ffb62ea:	83 ec 50             	sub    $0x50,%esp
5ffb62ed:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb62f0:	8b 75 08             	mov    0x8(%ebp),%esi
5ffb62f3:	8b 4d 14             	mov    0x14(%ebp),%ecx
5ffb62f6:	83 fa 14             	cmp    $0x14,%edx
5ffb62f9:	74 14                	je     5ffb630f <_DtbgWindowProc@16+0x2f>
5ffb62fb:	77 1b                	ja     5ffb6318 <_DtbgWindowProc@16+0x38>
5ffb62fd:	30 c0                	xor    %al,%al
5ffb62ff:	83 fa 01             	cmp    $0x1,%edx
5ffb6302:	74 0b                	je     5ffb630f <_DtbgWindowProc@16+0x2f>
5ffb6304:	83 fa 0f             	cmp    $0xf,%edx
5ffb6307:	0f 84 8e 00 00 00    	je     5ffb639b <_DtbgWindowProc@16+0xbb>
5ffb630d:	31 c0                	xor    %eax,%eax
5ffb630f:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb6312:	5b                   	pop    %ebx
5ffb6313:	5e                   	pop    %esi
5ffb6314:	5d                   	pop    %ebp
5ffb6315:	c2 10 00             	ret    $0x10
5ffb6318:	83 fa 4e             	cmp    $0x4e,%edx
5ffb631b:	74 33                	je     5ffb6350 <_DtbgWindowProc@16+0x70>
5ffb631d:	77 21                	ja     5ffb6340 <_DtbgWindowProc@16+0x60>
5ffb631f:	83 fa 20             	cmp    $0x20,%edx
5ffb6322:	75 e9                	jne    5ffb630d <_DtbgWindowProc@16+0x2d>
5ffb6324:	83 ec 18             	sub    $0x18,%esp
5ffb6327:	68 00 7f 00 00       	push   $0x7f00
5ffb632c:	6a 00                	push   $0x0
5ffb632e:	e8 8d 2b 00 00       	call   5ffb8ec0 <_LoadCursorW@8>
5ffb6333:	83 c4 0c             	add    $0xc,%esp
5ffb6336:	50                   	push   %eax
5ffb6337:	e8 94 2b 00 00       	call   5ffb8ed0 <_SetCursor@4>
5ffb633c:	eb d1                	jmp    5ffb630f <_DtbgWindowProc@16+0x2f>
5ffb633e:	89 f6                	mov    %esi,%esi
5ffb6340:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb6345:	81 fa 81 00 00 00    	cmp    $0x81,%edx
5ffb634b:	75 c0                	jne    5ffb630d <_DtbgWindowProc@16+0x2d>
5ffb634d:	eb c0                	jmp    5ffb630f <_DtbgWindowProc@16+0x2f>
5ffb634f:	90                   	nop    
5ffb6350:	8b 41 08             	mov    0x8(%ecx),%eax
5ffb6353:	83 f8 01             	cmp    $0x1,%eax
5ffb6356:	0f 84 84 00 00 00    	je     5ffb63e0 <_DtbgWindowProc@16+0x100>
5ffb635c:	83 f8 02             	cmp    $0x2,%eax
5ffb635f:	75 ac                	jne    5ffb630d <_DtbgWindowProc@16+0x2d>
5ffb6361:	51                   	push   %ecx
5ffb6362:	68 97 00 00 00       	push   $0x97
5ffb6367:	6a 00                	push   $0x0
5ffb6369:	6a 00                	push   $0x0
5ffb636b:	6a 00                	push   $0x0
5ffb636d:	6a 00                	push   $0x0
5ffb636f:	6a 00                	push   $0x0
5ffb6371:	56                   	push   %esi
5ffb6372:	e8 69 2b 00 00       	call   5ffb8ee0 <_SetWindowPos@28>
5ffb6377:	85 c0                	test   %eax,%eax
5ffb6379:	52                   	push   %edx
5ffb637a:	52                   	push   %edx
5ffb637b:	0f 94 c3             	sete   %bl
5ffb637e:	56                   	push   %esi
5ffb637f:	e8 6c 2b 00 00       	call   5ffb8ef0 <_UpdateWindow@4>
5ffb6384:	81 e3 ff 00 00 00    	and    $0xff,%ebx
5ffb638a:	c7 05 20 c1 fb 5f 00 	movl   $0x0,0x5ffbc120
5ffb6391:	00 00 00 
5ffb6394:	89 d8                	mov    %ebx,%eax
5ffb6396:	e9 74 ff ff ff       	jmp    5ffb630f <_DtbgWindowProc@16+0x2f>
5ffb639b:	50                   	push   %eax
5ffb639c:	8d 45 a8             	lea    0xffffffa8(%ebp),%eax
5ffb639f:	6a 00                	push   $0x0
5ffb63a1:	50                   	push   %eax
5ffb63a2:	56                   	push   %esi
5ffb63a3:	e8 58 2b 00 00       	call   5ffb8f00 <_GetUpdateRect@12>
5ffb63a8:	5b                   	pop    %ebx
5ffb63a9:	85 c0                	test   %eax,%eax
5ffb63ab:	0f 84 5c ff ff ff    	je     5ffb630d <_DtbgWindowProc@16+0x2d>
5ffb63b1:	8d 5d b8             	lea    0xffffffb8(%ebp),%ebx
5ffb63b4:	51                   	push   %ecx
5ffb63b5:	51                   	push   %ecx
5ffb63b6:	53                   	push   %ebx
5ffb63b7:	56                   	push   %esi
5ffb63b8:	e8 53 2b 00 00       	call   5ffb8f10 <_BeginPaint@8>
5ffb63bd:	59                   	pop    %ecx
5ffb63be:	85 c0                	test   %eax,%eax
5ffb63c0:	5a                   	pop    %edx
5ffb63c1:	0f 84 46 ff ff ff    	je     5ffb630d <_DtbgWindowProc@16+0x2d>
5ffb63c7:	83 ec 0c             	sub    $0xc,%esp
5ffb63ca:	50                   	push   %eax
5ffb63cb:	e8 50 2b 00 00       	call   5ffb8f20 <_PaintDesktop@4>
5ffb63d0:	89 1c 24             	mov    %ebx,(%esp)
5ffb63d3:	56                   	push   %esi
5ffb63d4:	e8 57 2b 00 00       	call   5ffb8f30 <_EndPaint@8>
5ffb63d9:	58                   	pop    %eax
5ffb63da:	5a                   	pop    %edx
5ffb63db:	e9 2d ff ff ff       	jmp    5ffb630d <_DtbgWindowProc@16+0x2d>
5ffb63e0:	50                   	push   %eax
5ffb63e1:	6a 54                	push   $0x54
5ffb63e3:	8b 41 10             	mov    0x10(%ecx),%eax
5ffb63e6:	50                   	push   %eax
5ffb63e7:	8b 41 0c             	mov    0xc(%ecx),%eax
5ffb63ea:	50                   	push   %eax
5ffb63eb:	6a 00                	push   $0x0
5ffb63ed:	6a 00                	push   $0x0
5ffb63ef:	6a 00                	push   $0x0
5ffb63f1:	56                   	push   %esi
5ffb63f2:	e8 e9 2a 00 00       	call   5ffb8ee0 <_SetWindowPos@28>
5ffb63f7:	85 c0                	test   %eax,%eax
5ffb63f9:	53                   	push   %ebx
5ffb63fa:	53                   	push   %ebx
5ffb63fb:	0f 94 c3             	sete   %bl
5ffb63fe:	56                   	push   %esi
5ffb63ff:	e8 ec 2a 00 00       	call   5ffb8ef0 <_UpdateWindow@4>
5ffb6404:	81 e3 ff 00 00 00    	and    $0xff,%ebx
5ffb640a:	89 35 20 c1 fb 5f    	mov    %esi,0x5ffbc120
5ffb6410:	89 d8                	mov    %ebx,%eax
5ffb6412:	e9 f8 fe ff ff       	jmp    5ffb630f <_DtbgWindowProc@16+0x2f>
5ffb6417:	89 f6                	mov    %esi,%esi
5ffb6419:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb6420 <_DtbgDesktopThread@4>:
5ffb6420:	55                   	push   %ebp
5ffb6421:	89 e5                	mov    %esp,%ebp
5ffb6423:	53                   	push   %ebx
5ffb6424:	83 ec 30             	sub    $0x30,%esp
5ffb6427:	8b 5d 08             	mov    0x8(%ebp),%ebx
5ffb642a:	8b 03                	mov    (%ebx),%eax
5ffb642c:	50                   	push   %eax
5ffb642d:	e8 0e 2b 00 00       	call   5ffb8f40 <_SetThreadDesktop@4>
5ffb6432:	83 c4 0c             	add    $0xc,%esp
5ffb6435:	85 c0                	test   %eax,%eax
5ffb6437:	75 47                	jne    5ffb6480 <_DtbgDesktopThread@4+0x60>
5ffb6439:	50                   	push   %eax
5ffb643a:	68 b1 00 00 00       	push   $0xb1
5ffb643f:	68 70 b2 fb 5f       	push   $0x5ffbb270
5ffb6444:	68 7c b2 fb 5f       	push   $0x5ffbb27c
5ffb6449:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb644f:	c7 04 24 85 b2 fb 5f 	movl   $0x5ffbb285,(%esp)
5ffb6456:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb645c:	c7 43 08 01 00 00 c0 	movl   $0xc0000001,0x8(%ebx)
5ffb6463:	58                   	pop    %eax
5ffb6464:	8b 43 04             	mov    0x4(%ebx),%eax
5ffb6467:	50                   	push   %eax
5ffb6468:	e8 13 29 00 00       	call   5ffb8d80 <_SetEvent@4>
5ffb646d:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb6472:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb6475:	c9                   	leave  
5ffb6476:	c2 04 00             	ret    $0x4
5ffb6479:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
5ffb6480:	6a 00                	push   $0x0
5ffb6482:	50                   	push   %eax
5ffb6483:	50                   	push   %eax
5ffb6484:	6a 00                	push   $0x0
5ffb6486:	e8 45 29 00 00       	call   5ffb8dd0 <_GetModuleHandleW@4>
5ffb648b:	5a                   	pop    %edx
5ffb648c:	59                   	pop    %ecx
5ffb648d:	50                   	push   %eax
5ffb648e:	6a 00                	push   $0x0
5ffb6490:	6a 00                	push   $0x0
5ffb6492:	6a 00                	push   $0x0
5ffb6494:	6a 00                	push   $0x0
5ffb6496:	6a 00                	push   $0x0
5ffb6498:	6a 00                	push   $0x0
5ffb649a:	68 00 00 00 82       	push   $0x82000000
5ffb649f:	68 a4 b2 fb 5f       	push   $0x5ffbb2a4
5ffb64a4:	68 70 80 00 00       	push   $0x8070
5ffb64a9:	6a 00                	push   $0x0
5ffb64ab:	e8 a0 2a 00 00       	call   5ffb8f50 <_CreateWindowExW@48>
5ffb64b0:	85 c0                	test   %eax,%eax
5ffb64b2:	74 4a                	je     5ffb64fe <_DtbgDesktopThread@4+0xde>
5ffb64b4:	83 ec 0c             	sub    $0xc,%esp
5ffb64b7:	c7 43 08 00 00 00 00 	movl   $0x0,0x8(%ebx)
5ffb64be:	8b 43 04             	mov    0x4(%ebx),%eax
5ffb64c1:	8d 5d d8             	lea    0xffffffd8(%ebp),%ebx
5ffb64c4:	50                   	push   %eax
5ffb64c5:	e8 b6 28 00 00       	call   5ffb8d80 <_SetEvent@4>
5ffb64ca:	83 c4 0c             	add    $0xc,%esp
5ffb64cd:	eb 13                	jmp    5ffb64e2 <_DtbgDesktopThread@4+0xc2>
5ffb64cf:	90                   	nop    
5ffb64d0:	83 ec 0c             	sub    $0xc,%esp
5ffb64d3:	53                   	push   %ebx
5ffb64d4:	e8 d7 29 00 00       	call   5ffb8eb0 <_TranslateMessage@4>
5ffb64d9:	53                   	push   %ebx
5ffb64da:	e8 81 2a 00 00       	call   5ffb8f60 <_DispatchMessageW@4>
5ffb64df:	83 c4 0c             	add    $0xc,%esp
5ffb64e2:	6a 00                	push   $0x0
5ffb64e4:	6a 00                	push   $0x0
5ffb64e6:	6a 00                	push   $0x0
5ffb64e8:	53                   	push   %ebx
5ffb64e9:	e8 b2 29 00 00       	call   5ffb8ea0 <_GetMessageW@16>
5ffb64ee:	85 c0                	test   %eax,%eax
5ffb64f0:	75 de                	jne    5ffb64d0 <_DtbgDesktopThread@4+0xb0>
5ffb64f2:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb64f7:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb64fa:	c9                   	leave  
5ffb64fb:	c2 04 00             	ret    $0x4
5ffb64fe:	50                   	push   %eax
5ffb64ff:	68 c3 00 00 00       	push   $0xc3
5ffb6504:	68 70 b2 fb 5f       	push   $0x5ffbb270
5ffb6509:	68 7c b2 fb 5f       	push   $0x5ffbb27c
5ffb650e:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb6514:	c7 04 24 a8 b2 fb 5f 	movl   $0x5ffbb2a8,(%esp)
5ffb651b:	e9 36 ff ff ff       	jmp    5ffb6456 <_DtbgDesktopThread@4+0x36>

5ffb6520 <_CsrCreateDesktop@12>:
5ffb6520:	55                   	push   %ebp
5ffb6521:	89 e5                	mov    %esp,%ebp
5ffb6523:	53                   	push   %ebx
5ffb6524:	83 ec 44             	sub    $0x44,%esp
5ffb6527:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb652a:	a1 30 c1 fb 5f       	mov    0x5ffbc130,%eax
5ffb652f:	85 c0                	test   %eax,%eax
5ffb6531:	66 c7 43 02 38 00    	movw   $0x38,0x2(%ebx)
5ffb6537:	66 c7 03 20 00       	movw   $0x20,(%ebx)
5ffb653c:	75 7f                	jne    5ffb65bd <_CsrCreateDesktop@12+0x9d>
5ffb653e:	83 ec 0c             	sub    $0xc,%esp
5ffb6541:	c7 45 b8 30 00 00 00 	movl   $0x30,0xffffffb8(%ebp)
5ffb6548:	c7 45 bc 00 00 00 00 	movl   $0x0,0xffffffbc(%ebp)
5ffb654f:	c7 45 c0 e0 62 fb 5f 	movl   $0x5ffb62e0,0xffffffc0(%ebp)
5ffb6556:	c7 45 c4 00 00 00 00 	movl   $0x0,0xffffffc4(%ebp)
5ffb655d:	c7 45 c8 00 00 00 00 	movl   $0x0,0xffffffc8(%ebp)
5ffb6564:	c7 05 30 c1 fb 5f 01 	movl   $0x1,0x5ffbc130
5ffb656b:	00 00 00 
5ffb656e:	6a 00                	push   $0x0
5ffb6570:	e8 5b 28 00 00       	call   5ffb8dd0 <_GetModuleHandleW@4>
5ffb6575:	c7 45 d0 00 00 00 00 	movl   $0x0,0xffffffd0(%ebp)
5ffb657c:	c7 45 d4 00 00 00 00 	movl   $0x0,0xffffffd4(%ebp)
5ffb6583:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
5ffb6586:	6a 01                	push   $0x1
5ffb6588:	e8 e3 29 00 00       	call   5ffb8f70 <_GetSysColorBrush@4>
5ffb658d:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
5ffb6594:	c7 45 e0 70 80 00 00 	movl   $0x8070,0xffffffe0(%ebp)
5ffb659b:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
5ffb659e:	8d 45 b8             	lea    0xffffffb8(%ebp),%eax
5ffb65a1:	50                   	push   %eax
5ffb65a2:	e8 d9 29 00 00       	call   5ffb8f80 <_RegisterClassExW@4>
5ffb65a7:	83 c4 0c             	add    $0xc,%esp
5ffb65aa:	66 85 c0             	test   %ax,%ax
5ffb65ad:	0f 84 7d 00 00 00    	je     5ffb6630 <_CsrCreateDesktop@12+0x110>
5ffb65b3:	c7 05 20 c1 fb 5f 00 	movl   $0x0,0x5ffbc120
5ffb65ba:	00 00 00 
5ffb65bd:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb65c0:	8b 40 1c             	mov    0x1c(%eax),%eax
5ffb65c3:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
5ffb65c6:	6a 00                	push   $0x0
5ffb65c8:	6a 00                	push   $0x0
5ffb65ca:	6a 00                	push   $0x0
5ffb65cc:	6a 00                	push   $0x0
5ffb65ce:	e8 7d 27 00 00       	call   5ffb8d50 <_CreateEventW@16>
5ffb65d3:	85 c0                	test   %eax,%eax
5ffb65d5:	89 45 ec             	mov    %eax,0xffffffec(%ebp)
5ffb65d8:	0f 84 91 00 00 00    	je     5ffb666f <_CsrCreateDesktop@12+0x14f>
5ffb65de:	50                   	push   %eax
5ffb65df:	50                   	push   %eax
5ffb65e0:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
5ffb65e3:	6a 00                	push   $0x0
5ffb65e5:	6a 00                	push   $0x0
5ffb65e7:	50                   	push   %eax
5ffb65e8:	68 20 64 fb 5f       	push   $0x5ffb6420
5ffb65ed:	6a 00                	push   $0x0
5ffb65ef:	6a 00                	push   $0x0
5ffb65f1:	e8 ba 26 00 00       	call   5ffb8cb0 <_CreateThread@24>
5ffb65f6:	5a                   	pop    %edx
5ffb65f7:	85 c0                	test   %eax,%eax
5ffb65f9:	59                   	pop    %ecx
5ffb65fa:	0f 84 9a 00 00 00    	je     5ffb669a <_CsrCreateDesktop@12+0x17a>
5ffb6600:	83 ec 0c             	sub    $0xc,%esp
5ffb6603:	50                   	push   %eax
5ffb6604:	e8 b7 26 00 00       	call   5ffb8cc0 <_CloseHandle@4>
5ffb6609:	c7 04 24 ff ff ff ff 	movl   $0xffffffff,(%esp)
5ffb6610:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb6613:	50                   	push   %eax
5ffb6614:	e8 c7 27 00 00       	call   5ffb8de0 <_WaitForSingleObject@8>
5ffb6619:	50                   	push   %eax
5ffb661a:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb661d:	50                   	push   %eax
5ffb661e:	e8 9d 26 00 00       	call   5ffb8cc0 <_CloseHandle@4>
5ffb6623:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
5ffb6626:	89 43 18             	mov    %eax,0x18(%ebx)
5ffb6629:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb662c:	c9                   	leave  
5ffb662d:	c2 0c 00             	ret    $0xc
5ffb6630:	50                   	push   %eax
5ffb6631:	68 9f 00 00 00       	push   $0x9f
5ffb6636:	68 70 b2 fb 5f       	push   $0x5ffbb270
5ffb663b:	68 7c b2 fb 5f       	push   $0x5ffbb27c
5ffb6640:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb6646:	e8 95 26 00 00       	call   5ffb8ce0 <_GetLastError@0>
5ffb664b:	5a                   	pop    %edx
5ffb664c:	59                   	pop    %ecx
5ffb664d:	50                   	push   %eax
5ffb664e:	68 d4 b2 fb 5f       	push   $0x5ffbb2d4
5ffb6653:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb6659:	83 c4 10             	add    $0x10,%esp
5ffb665c:	c7 43 18 01 00 00 c0 	movl   $0xc0000001,0x18(%ebx)
5ffb6663:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
5ffb6668:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb666b:	c9                   	leave  
5ffb666c:	c2 0c 00             	ret    $0xc
5ffb666f:	50                   	push   %eax
5ffb6670:	68 f0 00 00 00       	push   $0xf0
5ffb6675:	68 70 b2 fb 5f       	push   $0x5ffbb270
5ffb667a:	68 7c b2 fb 5f       	push   $0x5ffbb27c
5ffb667f:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb6685:	e8 56 26 00 00       	call   5ffb8ce0 <_GetLastError@0>
5ffb668a:	5a                   	pop    %edx
5ffb668b:	59                   	pop    %ecx
5ffb668c:	50                   	push   %eax
5ffb668d:	68 0c b3 fb 5f       	push   $0x5ffbb30c
5ffb6692:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb6698:	eb c2                	jmp    5ffb665c <_CsrCreateDesktop@12+0x13c>
5ffb669a:	83 ec 0c             	sub    $0xc,%esp
5ffb669d:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb66a0:	50                   	push   %eax
5ffb66a1:	e8 1a 26 00 00       	call   5ffb8cc0 <_CloseHandle@4>
5ffb66a6:	5a                   	pop    %edx
5ffb66a7:	59                   	pop    %ecx
5ffb66a8:	68 fc 00 00 00       	push   $0xfc
5ffb66ad:	68 70 b2 fb 5f       	push   $0x5ffbb270
5ffb66b2:	68 7c b2 fb 5f       	push   $0x5ffbb27c
5ffb66b7:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb66bd:	c7 04 24 30 b3 fb 5f 	movl   $0x5ffbb330,(%esp)
5ffb66c4:	eb cc                	jmp    5ffb6692 <_CsrCreateDesktop@12+0x172>
5ffb66c6:	8d 76 00             	lea    0x0(%esi),%esi
5ffb66c9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb66d0 <_CsrShowDesktop@12>:
5ffb66d0:	55                   	push   %ebp
5ffb66d1:	89 e5                	mov    %esp,%ebp
5ffb66d3:	53                   	push   %ebx
5ffb66d4:	83 ec 24             	sub    $0x24,%esp
5ffb66d7:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb66da:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb66dd:	66 c7 43 02 38 00    	movw   $0x38,0x2(%ebx)
5ffb66e3:	66 c7 03 20 00       	movw   $0x20,(%ebx)
5ffb66e8:	8b 4a 1c             	mov    0x1c(%edx),%ecx
5ffb66eb:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
5ffb66f2:	89 4d d8             	mov    %ecx,0xffffffd8(%ebp)
5ffb66f5:	c7 45 e0 01 00 00 00 	movl   $0x1,0xffffffe0(%ebp)
5ffb66fc:	8b 42 20             	mov    0x20(%edx),%eax
5ffb66ff:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
5ffb6702:	8b 42 24             	mov    0x24(%edx),%eax
5ffb6705:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
5ffb6708:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
5ffb670b:	50                   	push   %eax
5ffb670c:	51                   	push   %ecx
5ffb670d:	6a 4e                	push   $0x4e
5ffb670f:	51                   	push   %ecx
5ffb6710:	e8 7b 28 00 00       	call   5ffb8f90 <_SendMessageW@16>
5ffb6715:	83 f8 01             	cmp    $0x1,%eax
5ffb6718:	19 c0                	sbb    %eax,%eax
5ffb671a:	83 f0 ff             	xor    $0xffffffff,%eax
5ffb671d:	25 01 00 00 c0       	and    $0xc0000001,%eax
5ffb6722:	89 43 18             	mov    %eax,0x18(%ebx)
5ffb6725:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb6728:	c9                   	leave  
5ffb6729:	c2 0c 00             	ret    $0xc
5ffb672c:	8d 74 26 00          	lea    0x0(%esi),%esi

5ffb6730 <_CsrHideDesktop@12>:
5ffb6730:	55                   	push   %ebp
5ffb6731:	89 e5                	mov    %esp,%ebp
5ffb6733:	53                   	push   %ebx
5ffb6734:	83 ec 24             	sub    $0x24,%esp
5ffb6737:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb673a:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb673d:	66 c7 43 02 38 00    	movw   $0x38,0x2(%ebx)
5ffb6743:	66 c7 03 20 00       	movw   $0x20,(%ebx)
5ffb6748:	8b 50 1c             	mov    0x1c(%eax),%edx
5ffb674b:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
5ffb674e:	50                   	push   %eax
5ffb674f:	89 55 d8             	mov    %edx,0xffffffd8(%ebp)
5ffb6752:	52                   	push   %edx
5ffb6753:	c7 45 dc 00 00 00 00 	movl   $0x0,0xffffffdc(%ebp)
5ffb675a:	c7 45 e0 02 00 00 00 	movl   $0x2,0xffffffe0(%ebp)
5ffb6761:	6a 4e                	push   $0x4e
5ffb6763:	52                   	push   %edx
5ffb6764:	e8 27 28 00 00       	call   5ffb8f90 <_SendMessageW@16>
5ffb6769:	83 f8 01             	cmp    $0x1,%eax
5ffb676c:	19 c0                	sbb    %eax,%eax
5ffb676e:	83 f0 ff             	xor    $0xffffffff,%eax
5ffb6771:	25 01 00 00 c0       	and    $0xc0000001,%eax
5ffb6776:	89 43 18             	mov    %eax,0x18(%ebx)
5ffb6779:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb677c:	c9                   	leave  
5ffb677d:	c2 0c 00             	ret    $0xc

5ffb6780 <@DtbgIsDesktopVisible@0>:
5ffb6780:	55                   	push   %ebp
5ffb6781:	89 e5                	mov    %esp,%ebp
5ffb6783:	50                   	push   %eax
5ffb6784:	50                   	push   %eax
5ffb6785:	a1 20 c1 fb 5f       	mov    0x5ffbc120,%eax
5ffb678a:	85 c0                	test   %eax,%eax
5ffb678c:	75 12                	jne    5ffb67a0 <@DtbgIsDesktopVisible@0+0x20>
5ffb678e:	85 c0                	test   %eax,%eax
5ffb6790:	c9                   	leave  
5ffb6791:	0f 95 c0             	setne  %al
5ffb6794:	25 ff 00 00 00       	and    $0xff,%eax
5ffb6799:	c3                   	ret    
5ffb679a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb67a0:	83 ec 0c             	sub    $0xc,%esp
5ffb67a3:	50                   	push   %eax
5ffb67a4:	e8 f7 27 00 00       	call   5ffb8fa0 <_IsWindowVisible@4>
5ffb67a9:	83 c4 0c             	add    $0xc,%esp
5ffb67ac:	85 c0                	test   %eax,%eax
5ffb67ae:	75 16                	jne    5ffb67c6 <@DtbgIsDesktopVisible@0+0x46>
5ffb67b0:	85 c0                	test   %eax,%eax
5ffb67b2:	c7 05 20 c1 fb 5f 00 	movl   $0x0,0x5ffbc120
5ffb67b9:	00 00 00 
5ffb67bc:	0f 95 c0             	setne  %al
5ffb67bf:	25 ff 00 00 00       	and    $0xff,%eax
5ffb67c4:	c9                   	leave  
5ffb67c5:	c3                   	ret    
5ffb67c6:	a1 20 c1 fb 5f       	mov    0x5ffbc120,%eax
5ffb67cb:	c9                   	leave  
5ffb67cc:	85 c0                	test   %eax,%eax
5ffb67ce:	0f 95 c0             	setne  %al
5ffb67d1:	25 ff 00 00 00       	and    $0xff,%eax
5ffb67d6:	c3                   	ret    
5ffb67d7:	90                   	nop    
5ffb67d8:	90                   	nop    
5ffb67d9:	90                   	nop    
5ffb67da:	90                   	nop    
5ffb67db:	90                   	nop    
5ffb67dc:	90                   	nop    
5ffb67dd:	90                   	nop    
5ffb67de:	90                   	nop    
5ffb67df:	90                   	nop    

5ffb67e0 <_CsrRegisterLogonProcess@12>:
5ffb67e0:	55                   	push   %ebp
5ffb67e1:	89 e5                	mov    %esp,%ebp
5ffb67e3:	56                   	push   %esi
5ffb67e4:	53                   	push   %ebx
5ffb67e5:	8b 75 10             	mov    0x10(%ebp),%esi
5ffb67e8:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb67eb:	66 c7 46 02 38 00    	movw   $0x38,0x2(%esi)
5ffb67f1:	66 c7 06 20 00       	movw   $0x20,(%esi)
5ffb67f6:	8b 43 20             	mov    0x20(%ebx),%eax
5ffb67f9:	85 c0                	test   %eax,%eax
5ffb67fb:	74 23                	je     5ffb6820 <_CsrRegisterLogonProcess@12+0x40>
5ffb67fd:	a1 50 c1 fb 5f       	mov    0x5ffbc150,%eax
5ffb6802:	85 c0                	test   %eax,%eax
5ffb6804:	75 6a                	jne    5ffb6870 <_CsrRegisterLogonProcess@12+0x90>
5ffb6806:	8b 43 1c             	mov    0x1c(%ebx),%eax
5ffb6809:	a3 50 c1 fb 5f       	mov    %eax,0x5ffbc150
5ffb680e:	c7 46 18 00 00 00 00 	movl   $0x0,0x18(%esi)
5ffb6815:	31 c0                	xor    %eax,%eax
5ffb6817:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb681a:	5b                   	pop    %ebx
5ffb681b:	5e                   	pop    %esi
5ffb681c:	5d                   	pop    %ebp
5ffb681d:	c2 0c 00             	ret    $0xc
5ffb6820:	a1 50 c1 fb 5f       	mov    0x5ffbc150,%eax
5ffb6825:	39 43 08             	cmp    %eax,0x8(%ebx)
5ffb6828:	74 5b                	je     5ffb6885 <_CsrRegisterLogonProcess@12+0xa5>
5ffb682a:	51                   	push   %ecx
5ffb682b:	6a 28                	push   $0x28
5ffb682d:	68 60 b3 fb 5f       	push   $0x5ffbb360
5ffb6832:	68 6a b3 fb 5f       	push   $0x5ffbb36a
5ffb6837:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb683d:	83 c4 0c             	add    $0xc,%esp
5ffb6840:	8b 53 08             	mov    0x8(%ebx),%edx
5ffb6843:	52                   	push   %edx
5ffb6844:	a1 50 c1 fb 5f       	mov    0x5ffbc150,%eax
5ffb6849:	50                   	push   %eax
5ffb684a:	68 74 b3 fb 5f       	push   $0x5ffbb374
5ffb684f:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb6855:	c7 46 18 ed 00 00 c0 	movl   $0xc00000ed,0x18(%esi)
5ffb685c:	b8 ed 00 00 c0       	mov    $0xc00000ed,%eax
5ffb6861:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb6864:	5b                   	pop    %ebx
5ffb6865:	5e                   	pop    %esi
5ffb6866:	5d                   	pop    %ebp
5ffb6867:	c2 0c 00             	ret    $0xc
5ffb686a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb6870:	c7 46 18 ee 00 00 c0 	movl   $0xc00000ee,0x18(%esi)
5ffb6877:	b8 ee 00 00 c0       	mov    $0xc00000ee,%eax
5ffb687c:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb687f:	5b                   	pop    %ebx
5ffb6880:	5e                   	pop    %esi
5ffb6881:	5d                   	pop    %ebp
5ffb6882:	c2 0c 00             	ret    $0xc
5ffb6885:	c7 05 50 c1 fb 5f 00 	movl   $0x0,0x5ffbc150
5ffb688c:	00 00 00 
5ffb688f:	e9 7a ff ff ff       	jmp    5ffb680e <_CsrRegisterLogonProcess@12+0x2e>
5ffb6894:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb689a:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

5ffb68a0 <_CsrSetLogonNotifyWindow@12>:
5ffb68a0:	55                   	push   %ebp
5ffb68a1:	89 e5                	mov    %esp,%ebp
5ffb68a3:	56                   	push   %esi
5ffb68a4:	53                   	push   %ebx
5ffb68a5:	83 ec 18             	sub    $0x18,%esp
5ffb68a8:	8d 45 f4             	lea    0xfffffff4(%ebp),%eax
5ffb68ab:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb68ae:	8b 75 0c             	mov    0xc(%ebp),%esi
5ffb68b1:	66 c7 43 02 38 00    	movw   $0x38,0x2(%ebx)
5ffb68b7:	66 c7 03 20 00       	movw   $0x20,(%ebx)
5ffb68bc:	50                   	push   %eax
5ffb68bd:	8b 46 1c             	mov    0x1c(%esi),%eax
5ffb68c0:	50                   	push   %eax
5ffb68c1:	e8 ea 26 00 00       	call   5ffb8fb0 <_GetWindowThreadProcessId@8>
5ffb68c6:	5a                   	pop    %edx
5ffb68c7:	85 c0                	test   %eax,%eax
5ffb68c9:	59                   	pop    %ecx
5ffb68ca:	74 64                	je     5ffb6930 <_CsrSetLogonNotifyWindow@12+0x90>
5ffb68cc:	8b 45 f4             	mov    0xfffffff4(%ebp),%eax
5ffb68cf:	39 05 50 c1 fb 5f    	cmp    %eax,0x5ffbc150
5ffb68d5:	74 39                	je     5ffb6910 <_CsrSetLogonNotifyWindow@12+0x70>
5ffb68d7:	50                   	push   %eax
5ffb68d8:	6a 45                	push   $0x45
5ffb68da:	68 60 b3 fb 5f       	push   $0x5ffbb360
5ffb68df:	68 6a b3 fb 5f       	push   $0x5ffbb36a
5ffb68e4:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb68ea:	c7 04 24 b4 b3 fb 5f 	movl   $0x5ffbb3b4,(%esp)
5ffb68f1:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb68f7:	c7 43 18 22 00 00 c0 	movl   $0xc0000022,0x18(%ebx)
5ffb68fe:	b8 22 00 00 c0       	mov    $0xc0000022,%eax
5ffb6903:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb6906:	5b                   	pop    %ebx
5ffb6907:	5e                   	pop    %esi
5ffb6908:	5d                   	pop    %ebp
5ffb6909:	c2 0c 00             	ret    $0xc
5ffb690c:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb6910:	8b 46 1c             	mov    0x1c(%esi),%eax
5ffb6913:	a3 40 c1 fb 5f       	mov    %eax,0x5ffbc140
5ffb6918:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
5ffb691f:	31 c0                	xor    %eax,%eax
5ffb6921:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb6924:	5b                   	pop    %ebx
5ffb6925:	5e                   	pop    %esi
5ffb6926:	5d                   	pop    %ebp
5ffb6927:	c2 0c 00             	ret    $0xc
5ffb692a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb6930:	50                   	push   %eax
5ffb6931:	6a 3f                	push   $0x3f
5ffb6933:	68 60 b3 fb 5f       	push   $0x5ffbb360
5ffb6938:	68 6a b3 fb 5f       	push   $0x5ffbb36a
5ffb693d:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb6943:	c7 04 24 f8 b3 fb 5f 	movl   $0x5ffbb3f8,(%esp)
5ffb694a:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb6950:	c7 43 18 08 00 00 c0 	movl   $0xc0000008,0x18(%ebx)
5ffb6957:	b8 08 00 00 c0       	mov    $0xc0000008,%eax
5ffb695c:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb695f:	5b                   	pop    %ebx
5ffb6960:	5e                   	pop    %esi
5ffb6961:	5d                   	pop    %ebp
5ffb6962:	c2 0c 00             	ret    $0xc
5ffb6965:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb6969:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb6970 <_CsrExitReactos@12>:
5ffb6970:	55                   	push   %ebp
5ffb6971:	89 e5                	mov    %esp,%ebp
5ffb6973:	53                   	push   %ebx
5ffb6974:	50                   	push   %eax
5ffb6975:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb6978:	a1 40 c1 fb 5f       	mov    0x5ffbc140,%eax
5ffb697d:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb6980:	85 c0                	test   %eax,%eax
5ffb6982:	66 c7 43 02 38 00    	movw   $0x38,0x2(%ebx)
5ffb6988:	66 c7 03 20 00       	movw   $0x20,(%ebx)
5ffb698d:	75 33                	jne    5ffb69c2 <_CsrExitReactos@12+0x52>
5ffb698f:	50                   	push   %eax
5ffb6990:	6a 58                	push   $0x58
5ffb6992:	68 60 b3 fb 5f       	push   $0x5ffbb360
5ffb6997:	68 6a b3 fb 5f       	push   $0x5ffbb36a
5ffb699c:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb69a2:	c7 04 24 14 b4 fb 5f 	movl   $0x5ffbb414,(%esp)
5ffb69a9:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb69af:	c7 43 18 25 02 00 c0 	movl   $0xc0000225,0x18(%ebx)
5ffb69b6:	b8 25 02 00 c0       	mov    $0xc0000225,%eax
5ffb69bb:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb69be:	c9                   	leave  
5ffb69bf:	c2 0c 00             	ret    $0xc
5ffb69c2:	8b 4a 1c             	mov    0x1c(%edx),%ecx
5ffb69c5:	51                   	push   %ecx
5ffb69c6:	8b 52 08             	mov    0x8(%edx),%edx
5ffb69c9:	52                   	push   %edx
5ffb69ca:	68 00 80 00 00       	push   $0x8000
5ffb69cf:	50                   	push   %eax
5ffb69d0:	e8 bb 25 00 00       	call   5ffb8f90 <_SendMessageW@16>
5ffb69d5:	83 f8 01             	cmp    $0x1,%eax
5ffb69d8:	74 1e                	je     5ffb69f8 <_CsrExitReactos@12+0x88>
5ffb69da:	85 c0                	test   %eax,%eax
5ffb69dc:	75 12                	jne    5ffb69f0 <_CsrExitReactos@12+0x80>
5ffb69de:	c7 43 18 02 00 00 c0 	movl   $0xc0000002,0x18(%ebx)
5ffb69e5:	8b 43 18             	mov    0x18(%ebx),%eax
5ffb69e8:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb69eb:	c9                   	leave  
5ffb69ec:	c2 0c 00             	ret    $0xc
5ffb69ef:	90                   	nop    
5ffb69f0:	89 43 18             	mov    %eax,0x18(%ebx)
5ffb69f3:	8b 43 18             	mov    0x18(%ebx),%eax
5ffb69f6:	eb f0                	jmp    5ffb69e8 <_CsrExitReactos@12+0x78>
5ffb69f8:	c7 43 18 00 00 00 00 	movl   $0x0,0x18(%ebx)
5ffb69ff:	8b 43 18             	mov    0x18(%ebx),%eax
5ffb6a02:	eb e4                	jmp    5ffb69e8 <_CsrExitReactos@12+0x78>
5ffb6a04:	90                   	nop    
5ffb6a05:	90                   	nop    
5ffb6a06:	90                   	nop    
5ffb6a07:	90                   	nop    
5ffb6a08:	90                   	nop    
5ffb6a09:	90                   	nop    
5ffb6a0a:	90                   	nop    
5ffb6a0b:	90                   	nop    
5ffb6a0c:	90                   	nop    
5ffb6a0d:	90                   	nop    
5ffb6a0e:	90                   	nop    
5ffb6a0f:	90                   	nop    

5ffb6a10 <@GuiConsoleGetDataPointers@12>:
5ffb6a10:	55                   	push   %ebp
5ffb6a11:	89 e5                	mov    %esp,%ebp
5ffb6a13:	53                   	push   %ebx
5ffb6a14:	83 ec 0c             	sub    $0xc,%esp
5ffb6a17:	89 d3                	mov    %edx,%ebx
5ffb6a19:	6a eb                	push   $0xffffffeb
5ffb6a1b:	51                   	push   %ecx
5ffb6a1c:	e8 9f 25 00 00       	call   5ffb8fc0 <_GetWindowLongW@8>
5ffb6a21:	5a                   	pop    %edx
5ffb6a22:	31 d2                	xor    %edx,%edx
5ffb6a24:	89 03                	mov    %eax,(%ebx)
5ffb6a26:	59                   	pop    %ecx
5ffb6a27:	85 c0                	test   %eax,%eax
5ffb6a29:	74 03                	je     5ffb6a2e <@GuiConsoleGetDataPointers@12+0x1e>
5ffb6a2b:	8b 50 64             	mov    0x64(%eax),%edx
5ffb6a2e:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb6a31:	89 10                	mov    %edx,(%eax)
5ffb6a33:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb6a36:	c9                   	leave  
5ffb6a37:	c2 04 00             	ret    $0x4
5ffb6a3a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

5ffb6a40 <@GuiConsoleRGBFromAttribute@4>:
5ffb6a40:	31 d2                	xor    %edx,%edx
5ffb6a42:	55                   	push   %ebp
5ffb6a43:	88 ca                	mov    %cl,%dl
5ffb6a45:	89 e5                	mov    %esp,%ebp
5ffb6a47:	56                   	push   %esi
5ffb6a48:	31 f6                	xor    %esi,%esi
5ffb6a4a:	53                   	push   %ebx
5ffb6a4b:	f6 c2 04             	test   $0x4,%dl
5ffb6a4e:	74 14                	je     5ffb6a64 <@GuiConsoleRGBFromAttribute@4+0x24>
5ffb6a50:	c1 ea 03             	shr    $0x3,%edx
5ffb6a53:	83 e2 01             	and    $0x1,%edx
5ffb6a56:	83 fa 01             	cmp    $0x1,%edx
5ffb6a59:	19 f6                	sbb    %esi,%esi
5ffb6a5b:	83 e6 81             	and    $0xffffff81,%esi
5ffb6a5e:	81 c6 ff 00 00 00    	add    $0xff,%esi
5ffb6a64:	31 c0                	xor    %eax,%eax
5ffb6a66:	31 d2                	xor    %edx,%edx
5ffb6a68:	88 c8                	mov    %cl,%al
5ffb6a6a:	a8 02                	test   $0x2,%al
5ffb6a6c:	74 14                	je     5ffb6a82 <@GuiConsoleRGBFromAttribute@4+0x42>
5ffb6a6e:	c1 e8 03             	shr    $0x3,%eax
5ffb6a71:	83 e0 01             	and    $0x1,%eax
5ffb6a74:	83 f8 01             	cmp    $0x1,%eax
5ffb6a77:	19 d2                	sbb    %edx,%edx
5ffb6a79:	83 e2 81             	and    $0xffffff81,%edx
5ffb6a7c:	81 c2 ff 00 00 00    	add    $0xff,%edx
5ffb6a82:	81 e1 ff 00 00 00    	and    $0xff,%ecx
5ffb6a88:	31 db                	xor    %ebx,%ebx
5ffb6a8a:	f6 c1 01             	test   $0x1,%cl
5ffb6a8d:	74 14                	je     5ffb6aa3 <@GuiConsoleRGBFromAttribute@4+0x63>
5ffb6a8f:	c1 e9 03             	shr    $0x3,%ecx
5ffb6a92:	83 e1 01             	and    $0x1,%ecx
5ffb6a95:	83 f9 01             	cmp    $0x1,%ecx
5ffb6a98:	19 db                	sbb    %ebx,%ebx
5ffb6a9a:	83 e3 81             	and    $0xffffff81,%ebx
5ffb6a9d:	81 c3 ff 00 00 00    	add    $0xff,%ebx
5ffb6aa3:	89 f0                	mov    %esi,%eax
5ffb6aa5:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb6aab:	c1 e2 08             	shl    $0x8,%edx
5ffb6aae:	25 ff 00 00 00       	and    $0xff,%eax
5ffb6ab3:	09 d0                	or     %edx,%eax
5ffb6ab5:	31 d2                	xor    %edx,%edx
5ffb6ab7:	88 da                	mov    %bl,%dl
5ffb6ab9:	5b                   	pop    %ebx
5ffb6aba:	c1 e2 10             	shl    $0x10,%edx
5ffb6abd:	5e                   	pop    %esi
5ffb6abe:	09 d0                	or     %edx,%eax
5ffb6ac0:	5d                   	pop    %ebp
5ffb6ac1:	c3                   	ret    
5ffb6ac2:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
5ffb6ac9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb6ad0 <@GuiConsoleSetTextColors@8>:
5ffb6ad0:	55                   	push   %ebp
5ffb6ad1:	89 e5                	mov    %esp,%ebp
5ffb6ad3:	56                   	push   %esi
5ffb6ad4:	53                   	push   %ebx
5ffb6ad5:	53                   	push   %ebx
5ffb6ad6:	53                   	push   %ebx
5ffb6ad7:	31 db                	xor    %ebx,%ebx
5ffb6ad9:	89 ce                	mov    %ecx,%esi
5ffb6adb:	88 d3                	mov    %dl,%bl
5ffb6add:	89 d9                	mov    %ebx,%ecx
5ffb6adf:	c1 eb 04             	shr    $0x4,%ebx
5ffb6ae2:	83 e1 0f             	and    $0xf,%ecx
5ffb6ae5:	e8 56 ff ff ff       	call   5ffb6a40 <@GuiConsoleRGBFromAttribute@4>
5ffb6aea:	50                   	push   %eax
5ffb6aeb:	56                   	push   %esi
5ffb6aec:	e8 1f 26 00 00       	call   5ffb9110 <_SetTextColor@8>
5ffb6af1:	89 d9                	mov    %ebx,%ecx
5ffb6af3:	e8 48 ff ff ff       	call   5ffb6a40 <@GuiConsoleRGBFromAttribute@4>
5ffb6af8:	50                   	push   %eax
5ffb6af9:	56                   	push   %esi
5ffb6afa:	e8 21 26 00 00       	call   5ffb9120 <_SetBkColor@8>
5ffb6aff:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb6b02:	5b                   	pop    %ebx
5ffb6b03:	5e                   	pop    %esi
5ffb6b04:	5d                   	pop    %ebp
5ffb6b05:	c3                   	ret    
5ffb6b06:	8d 76 00             	lea    0x0(%esi),%esi
5ffb6b09:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb6b10 <@GuiConsoleGetLogicalCursorPos@12>:
5ffb6b10:	55                   	push   %ebp
5ffb6b11:	8b 41 2c             	mov    0x2c(%ecx),%eax
5ffb6b14:	89 e5                	mov    %esp,%ebp
5ffb6b16:	56                   	push   %esi
5ffb6b17:	53                   	push   %ebx
5ffb6b18:	89 02                	mov    %eax,(%edx)
5ffb6b1a:	66 8b 41 2a          	mov    0x2a(%ecx),%ax
5ffb6b1e:	8b 51 30             	mov    0x30(%ecx),%edx
5ffb6b21:	89 c3                	mov    %eax,%ebx
5ffb6b23:	8b 75 08             	mov    0x8(%ebp),%esi
5ffb6b26:	81 e3 ff ff 00 00    	and    $0xffff,%ebx
5ffb6b2c:	39 da                	cmp    %ebx,%edx
5ffb6b2e:	73 15                	jae    5ffb6b45 <@GuiConsoleGetLogicalCursorPos@12+0x35>
5ffb6b30:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb6b34:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb6b39:	29 d8                	sub    %ebx,%eax
5ffb6b3b:	01 d0                	add    %edx,%eax
5ffb6b3d:	89 06                	mov    %eax,(%esi)
5ffb6b3f:	5b                   	pop    %ebx
5ffb6b40:	5e                   	pop    %esi
5ffb6b41:	5d                   	pop    %ebp
5ffb6b42:	c2 04 00             	ret    $0x4
5ffb6b45:	29 da                	sub    %ebx,%edx
5ffb6b47:	89 16                	mov    %edx,(%esi)
5ffb6b49:	5b                   	pop    %ebx
5ffb6b4a:	5e                   	pop    %esi
5ffb6b4b:	5d                   	pop    %ebp
5ffb6b4c:	c2 04 00             	ret    $0x4
5ffb6b4f:	90                   	nop    

5ffb6b50 <@GuiConsoleUpdateSelection@12>:
5ffb6b50:	55                   	push   %ebp
5ffb6b51:	89 e5                	mov    %esp,%ebp
5ffb6b53:	57                   	push   %edi
5ffb6b54:	56                   	push   %esi
5ffb6b55:	53                   	push   %ebx
5ffb6b56:	83 ec 5c             	sub    $0x5c,%esp
5ffb6b59:	89 d7                	mov    %edx,%edi
5ffb6b5b:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb6b5e:	8b 55 08             	mov    0x8(%ebp),%edx
5ffb6b61:	89 4d c4             	mov    %ecx,0xffffffc4(%ebp)
5ffb6b64:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb6b67:	8b 40 38             	mov    0x38(%eax),%eax
5ffb6b6a:	85 ff                	test   %edi,%edi
5ffb6b6c:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
5ffb6b6f:	89 45 c0             	mov    %eax,0xffffffc0(%ebp)
5ffb6b72:	8b 52 3c             	mov    0x3c(%edx),%edx
5ffb6b75:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb6b78:	89 55 dc             	mov    %edx,0xffffffdc(%ebp)
5ffb6b7b:	89 55 bc             	mov    %edx,0xffffffbc(%ebp)
5ffb6b7e:	8b 49 40             	mov    0x40(%ecx),%ecx
5ffb6b81:	89 4d e0             	mov    %ecx,0xffffffe0(%ebp)
5ffb6b84:	89 4d b8             	mov    %ecx,0xffffffb8(%ebp)
5ffb6b87:	8b 40 44             	mov    0x44(%eax),%eax
5ffb6b8a:	89 45 b4             	mov    %eax,0xffffffb4(%ebp)
5ffb6b8d:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
5ffb6b90:	0f 84 3b 01 00 00    	je     5ffb6cd1 <@GuiConsoleUpdateSelection@12+0x181>
5ffb6b96:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb6b99:	8b 17                	mov    (%edi),%edx
5ffb6b9b:	8b 4f 04             	mov    0x4(%edi),%ecx
5ffb6b9e:	8b 5f 08             	mov    0x8(%edi),%ebx
5ffb6ba1:	8b 77 0c             	mov    0xc(%edi),%esi
5ffb6ba4:	89 50 38             	mov    %edx,0x38(%eax)
5ffb6ba7:	89 4d a4             	mov    %ecx,0xffffffa4(%ebp)
5ffb6baa:	8b 4f 04             	mov    0x4(%edi),%ecx
5ffb6bad:	89 48 3c             	mov    %ecx,0x3c(%eax)
5ffb6bb0:	8b 4f 08             	mov    0x8(%edi),%ecx
5ffb6bb3:	89 48 40             	mov    %ecx,0x40(%eax)
5ffb6bb6:	8b 4f 0c             	mov    0xc(%edi),%ecx
5ffb6bb9:	89 48 44             	mov    %ecx,0x44(%eax)
5ffb6bbc:	8b 40 04             	mov    0x4(%eax),%eax
5ffb6bbf:	0f af d0             	imul   %eax,%edx
5ffb6bc2:	8b 4d 08             	mov    0x8(%ebp),%ecx
5ffb6bc5:	89 45 b0             	mov    %eax,0xffffffb0(%ebp)
5ffb6bc8:	89 55 c8             	mov    %edx,0xffffffc8(%ebp)
5ffb6bcb:	8b 45 a4             	mov    0xffffffa4(%ebp),%eax
5ffb6bce:	8b 51 08             	mov    0x8(%ecx),%edx
5ffb6bd1:	8b 4d c0             	mov    0xffffffc0(%ebp),%ecx
5ffb6bd4:	0f af c2             	imul   %edx,%eax
5ffb6bd7:	89 45 cc             	mov    %eax,0xffffffcc(%ebp)
5ffb6bda:	8b 45 b0             	mov    0xffffffb0(%ebp),%eax
5ffb6bdd:	0f af d8             	imul   %eax,%ebx
5ffb6be0:	0f af f2             	imul   %edx,%esi
5ffb6be3:	89 5d d0             	mov    %ebx,0xffffffd0(%ebp)
5ffb6be6:	89 75 d4             	mov    %esi,0xffffffd4(%ebp)
5ffb6be9:	39 0f                	cmp    %ecx,(%edi)
5ffb6beb:	0f 84 8f 00 00 00    	je     5ffb6c80 <@GuiConsoleUpdateSelection@12+0x130>
5ffb6bf1:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
5ffb6bf4:	83 f8 ff             	cmp    $0xffffffff,%eax
5ffb6bf7:	0f 84 a9 00 00 00    	je     5ffb6ca6 <@GuiConsoleUpdateSelection@12+0x156>
5ffb6bfd:	8b 5d b0             	mov    0xffffffb0(%ebp),%ebx
5ffb6c00:	8b 4d e0             	mov    0xffffffe0(%ebp),%ecx
5ffb6c03:	0f af c3             	imul   %ebx,%eax
5ffb6c06:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
5ffb6c09:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
5ffb6c0c:	0f af c2             	imul   %edx,%eax
5ffb6c0f:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
5ffb6c12:	8b 45 b0             	mov    0xffffffb0(%ebp),%eax
5ffb6c15:	0f af c1             	imul   %ecx,%eax
5ffb6c18:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
5ffb6c1b:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
5ffb6c1e:	0f af c2             	imul   %edx,%eax
5ffb6c21:	83 ec 0c             	sub    $0xc,%esp
5ffb6c24:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
5ffb6c27:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
5ffb6c2a:	50                   	push   %eax
5ffb6c2b:	e8 00 25 00 00       	call   5ffb9130 <_CreateRectRgnIndirect@4>
5ffb6c30:	83 c4 0c             	add    $0xc,%esp
5ffb6c33:	89 c3                	mov    %eax,%ebx
5ffb6c35:	85 c0                	test   %eax,%eax
5ffb6c37:	74 3b                	je     5ffb6c74 <@GuiConsoleUpdateSelection@12+0x124>
5ffb6c39:	83 ec 0c             	sub    $0xc,%esp
5ffb6c3c:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
5ffb6c3f:	50                   	push   %eax
5ffb6c40:	e8 eb 24 00 00       	call   5ffb9130 <_CreateRectRgnIndirect@4>
5ffb6c45:	83 c4 0c             	add    $0xc,%esp
5ffb6c48:	89 c6                	mov    %eax,%esi
5ffb6c4a:	85 c0                	test   %eax,%eax
5ffb6c4c:	74 1a                	je     5ffb6c68 <@GuiConsoleUpdateSelection@12+0x118>
5ffb6c4e:	6a 03                	push   $0x3
5ffb6c50:	53                   	push   %ebx
5ffb6c51:	50                   	push   %eax
5ffb6c52:	53                   	push   %ebx
5ffb6c53:	e8 e8 24 00 00       	call   5ffb9140 <_CombineRgn@16>
5ffb6c58:	85 c0                	test   %eax,%eax
5ffb6c5a:	75 65                	jne    5ffb6cc1 <@GuiConsoleUpdateSelection@12+0x171>
5ffb6c5c:	83 ec 0c             	sub    $0xc,%esp
5ffb6c5f:	56                   	push   %esi
5ffb6c60:	e8 eb 24 00 00       	call   5ffb9150 <_DeleteObject@4>
5ffb6c65:	83 c4 0c             	add    $0xc,%esp
5ffb6c68:	83 ec 0c             	sub    $0xc,%esp
5ffb6c6b:	53                   	push   %ebx
5ffb6c6c:	e8 df 24 00 00       	call   5ffb9150 <_DeleteObject@4>
5ffb6c71:	83 c4 0c             	add    $0xc,%esp
5ffb6c74:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb6c77:	5b                   	pop    %ebx
5ffb6c78:	5e                   	pop    %esi
5ffb6c79:	5f                   	pop    %edi
5ffb6c7a:	5d                   	pop    %ebp
5ffb6c7b:	c2 04 00             	ret    $0x4
5ffb6c7e:	89 f6                	mov    %esi,%esi
5ffb6c80:	8b 45 bc             	mov    0xffffffbc(%ebp),%eax
5ffb6c83:	39 47 04             	cmp    %eax,0x4(%edi)
5ffb6c86:	0f 85 65 ff ff ff    	jne    5ffb6bf1 <@GuiConsoleUpdateSelection@12+0xa1>
5ffb6c8c:	8b 4d b8             	mov    0xffffffb8(%ebp),%ecx
5ffb6c8f:	39 4f 08             	cmp    %ecx,0x8(%edi)
5ffb6c92:	0f 85 59 ff ff ff    	jne    5ffb6bf1 <@GuiConsoleUpdateSelection@12+0xa1>
5ffb6c98:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
5ffb6c9b:	39 47 0c             	cmp    %eax,0xc(%edi)
5ffb6c9e:	0f 85 4d ff ff ff    	jne    5ffb6bf1 <@GuiConsoleUpdateSelection@12+0xa1>
5ffb6ca4:	eb ce                	jmp    5ffb6c74 <@GuiConsoleUpdateSelection@12+0x124>
5ffb6ca6:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
5ffb6ca9:	53                   	push   %ebx
5ffb6caa:	6a 00                	push   $0x0
5ffb6cac:	50                   	push   %eax
5ffb6cad:	8b 7d c4             	mov    0xffffffc4(%ebp),%edi
5ffb6cb0:	57                   	push   %edi
5ffb6cb1:	e8 1a 23 00 00       	call   5ffb8fd0 <_InvalidateRect@12>
5ffb6cb6:	5e                   	pop    %esi
5ffb6cb7:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb6cba:	5b                   	pop    %ebx
5ffb6cbb:	5e                   	pop    %esi
5ffb6cbc:	5f                   	pop    %edi
5ffb6cbd:	5d                   	pop    %ebp
5ffb6cbe:	c2 04 00             	ret    $0x4
5ffb6cc1:	50                   	push   %eax
5ffb6cc2:	6a 00                	push   $0x0
5ffb6cc4:	53                   	push   %ebx
5ffb6cc5:	8b 45 c4             	mov    0xffffffc4(%ebp),%eax
5ffb6cc8:	50                   	push   %eax
5ffb6cc9:	e8 12 23 00 00       	call   5ffb8fe0 <_InvalidateRgn@12>
5ffb6cce:	5f                   	pop    %edi
5ffb6ccf:	eb 8b                	jmp    5ffb6c5c <@GuiConsoleUpdateSelection@12+0x10c>
5ffb6cd1:	83 7d c0 ff          	cmpl   $0xffffffff,0xffffffc0(%ebp)
5ffb6cd5:	74 9d                	je     5ffb6c74 <@GuiConsoleUpdateSelection@12+0x124>
5ffb6cd7:	8b 55 08             	mov    0x8(%ebp),%edx
5ffb6cda:	8b 45 c0             	mov    0xffffffc0(%ebp),%eax
5ffb6cdd:	89 d1                	mov    %edx,%ecx
5ffb6cdf:	c7 42 38 ff ff ff ff 	movl   $0xffffffff,0x38(%edx)
5ffb6ce6:	8b 52 04             	mov    0x4(%edx),%edx
5ffb6ce9:	0f af c2             	imul   %edx,%eax
5ffb6cec:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
5ffb6cef:	8b 41 08             	mov    0x8(%ecx),%eax
5ffb6cf2:	8b 4d bc             	mov    0xffffffbc(%ebp),%ecx
5ffb6cf5:	0f af c8             	imul   %eax,%ecx
5ffb6cf8:	89 4d dc             	mov    %ecx,0xffffffdc(%ebp)
5ffb6cfb:	8b 4d b8             	mov    0xffffffb8(%ebp),%ecx
5ffb6cfe:	0f af d1             	imul   %ecx,%edx
5ffb6d01:	89 55 e0             	mov    %edx,0xffffffe0(%ebp)
5ffb6d04:	8b 55 b4             	mov    0xffffffb4(%ebp),%edx
5ffb6d07:	0f af c2             	imul   %edx,%eax
5ffb6d0a:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
5ffb6d0d:	50                   	push   %eax
5ffb6d0e:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
5ffb6d11:	6a 00                	push   $0x0
5ffb6d13:	eb 97                	jmp    5ffb6cac <@GuiConsoleUpdateSelection@12+0x15c>
5ffb6d15:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb6d19:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb6d20 <@GuiConsoleUpdateBitmap@20>:
5ffb6d20:	55                   	push   %ebp
5ffb6d21:	89 e5                	mov    %esp,%ebp
5ffb6d23:	57                   	push   %edi
5ffb6d24:	56                   	push   %esi
5ffb6d25:	53                   	push   %ebx
5ffb6d26:	83 ec 58             	sub    $0x58,%esp
5ffb6d29:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
5ffb6d2c:	8d 55 ec             	lea    0xffffffec(%ebp),%edx
5ffb6d2f:	89 4d e0             	mov    %ecx,0xffffffe0(%ebp)
5ffb6d32:	50                   	push   %eax
5ffb6d33:	e8 d8 fc ff ff       	call   5ffb6a10 <@GuiConsoleGetDataPointers@12>
5ffb6d38:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb6d3b:	83 c4 0c             	add    $0xc,%esp
5ffb6d3e:	85 c0                	test   %eax,%eax
5ffb6d40:	74 11                	je     5ffb6d53 <@GuiConsoleUpdateBitmap@20+0x33>
5ffb6d42:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
5ffb6d45:	85 d2                	test   %edx,%edx
5ffb6d47:	74 0a                	je     5ffb6d53 <@GuiConsoleUpdateBitmap@20+0x33>
5ffb6d49:	8b 40 38             	mov    0x38(%eax),%eax
5ffb6d4c:	89 45 c0             	mov    %eax,0xffffffc0(%ebp)
5ffb6d4f:	85 c0                	test   %eax,%eax
5ffb6d51:	75 0a                	jne    5ffb6d5d <@GuiConsoleUpdateBitmap@20+0x3d>
5ffb6d53:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb6d56:	5b                   	pop    %ebx
5ffb6d57:	5e                   	pop    %esi
5ffb6d58:	5f                   	pop    %edi
5ffb6d59:	5d                   	pop    %ebp
5ffb6d5a:	c2 10 00             	ret    $0x10
5ffb6d5d:	83 ec 0c             	sub    $0xc,%esp
5ffb6d60:	83 c0 08             	add    $0x8,%eax
5ffb6d63:	89 45 ac             	mov    %eax,0xffffffac(%ebp)
5ffb6d66:	50                   	push   %eax
5ffb6d67:	e8 24 1f 00 00       	call   5ffb8c90 <_EnterCriticalSection@4>
5ffb6d6c:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
5ffb6d6f:	50                   	push   %eax
5ffb6d70:	e8 7b 22 00 00       	call   5ffb8ff0 <_GetDC@4>
5ffb6d75:	83 c4 0c             	add    $0xc,%esp
5ffb6d78:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
5ffb6d7b:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb6d7e:	39 45 10             	cmp    %eax,0x10(%ebp)
5ffb6d81:	7e 08                	jle    5ffb6d8b <@GuiConsoleUpdateBitmap@20+0x6b>
5ffb6d83:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb6d86:	39 45 14             	cmp    %eax,0x14(%ebp)
5ffb6d89:	7f 1b                	jg     5ffb6da6 <@GuiConsoleUpdateBitmap@20+0x86>
5ffb6d8b:	8b 7d dc             	mov    0xffffffdc(%ebp),%edi
5ffb6d8e:	8b 75 e0             	mov    0xffffffe0(%ebp),%esi
5ffb6d91:	50                   	push   %eax
5ffb6d92:	50                   	push   %eax
5ffb6d93:	57                   	push   %edi
5ffb6d94:	56                   	push   %esi
5ffb6d95:	e8 66 22 00 00       	call   5ffb9000 <_ReleaseDC@8>
5ffb6d9a:	8b 4d ac             	mov    0xffffffac(%ebp),%ecx
5ffb6d9d:	53                   	push   %ebx
5ffb6d9e:	51                   	push   %ecx
5ffb6d9f:	e8 fc 1e 00 00       	call   5ffb8ca0 <_LeaveCriticalSection@4>
5ffb6da4:	eb ad                	jmp    5ffb6d53 <@GuiConsoleUpdateBitmap@20+0x33>
5ffb6da6:	83 ec 0c             	sub    $0xc,%esp
5ffb6da9:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
5ffb6dac:	83 c0 18             	add    $0x18,%eax
5ffb6daf:	50                   	push   %eax
5ffb6db0:	e8 db 1e 00 00       	call   5ffb8c90 <_EnterCriticalSection@4>
5ffb6db5:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb6db8:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb6dbb:	31 d2                	xor    %edx,%edx
5ffb6dbd:	8b 5d c0             	mov    0xffffffc0(%ebp),%ebx
5ffb6dc0:	8b 71 08             	mov    0x8(%ecx),%esi
5ffb6dc3:	83 c4 0c             	add    $0xc,%esp
5ffb6dc6:	f7 f6                	div    %esi
5ffb6dc8:	89 45 bc             	mov    %eax,0xffffffbc(%ebp)
5ffb6dcb:	8b 45 14             	mov    0x14(%ebp),%eax
5ffb6dce:	01 f0                	add    %esi,%eax
5ffb6dd0:	31 d2                	xor    %edx,%edx
5ffb6dd2:	48                   	dec    %eax
5ffb6dd3:	f7 f6                	div    %esi
5ffb6dd5:	48                   	dec    %eax
5ffb6dd6:	8b 71 04             	mov    0x4(%ecx),%esi
5ffb6dd9:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
5ffb6ddc:	31 d2                	xor    %edx,%edx
5ffb6dde:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb6de1:	8b 49 30             	mov    0x30(%ecx),%ecx
5ffb6de4:	f7 f6                	div    %esi
5ffb6de6:	89 45 b4             	mov    %eax,0xffffffb4(%ebp)
5ffb6de9:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb6dec:	01 f0                	add    %esi,%eax
5ffb6dee:	31 d2                	xor    %edx,%edx
5ffb6df0:	48                   	dec    %eax
5ffb6df1:	8b 7d b4             	mov    0xffffffb4(%ebp),%edi
5ffb6df4:	f7 f6                	div    %esi
5ffb6df6:	48                   	dec    %eax
5ffb6df7:	8b 55 bc             	mov    0xffffffbc(%ebp),%edx
5ffb6dfa:	89 45 d4             	mov    %eax,0xffffffd4(%ebp)
5ffb6dfd:	66 8b 43 24          	mov    0x24(%ebx),%ax
5ffb6e01:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb6e06:	0f af c2             	imul   %edx,%eax
5ffb6e09:	8b 53 20             	mov    0x20(%ebx),%edx
5ffb6e0c:	01 f8                	add    %edi,%eax
5ffb6e0e:	8a 44 42 01          	mov    0x1(%edx,%eax,2),%al
5ffb6e12:	31 d2                	xor    %edx,%edx
5ffb6e14:	88 c2                	mov    %al,%dl
5ffb6e16:	88 45 c7             	mov    %al,0xffffffc7(%ebp)
5ffb6e19:	e8 b2 fc ff ff       	call   5ffb6ad0 <@GuiConsoleSetTextColors@8>
5ffb6e1e:	8b 45 bc             	mov    0xffffffbc(%ebp),%eax
5ffb6e21:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
5ffb6e24:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
5ffb6e27:	39 d0                	cmp    %edx,%eax
5ffb6e29:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
5ffb6e30:	0f 87 5f 01 00 00    	ja     5ffb6f95 <@GuiConsoleUpdateBitmap@20+0x275>
5ffb6e36:	8b 4d c0             	mov    0xffffffc0(%ebp),%ecx
5ffb6e39:	8b 5d d0             	mov    0xffffffd0(%ebp),%ebx
5ffb6e3c:	66 8b 41 2a          	mov    0x2a(%ecx),%ax
5ffb6e40:	89 c1                	mov    %eax,%ecx
5ffb6e42:	81 e1 ff ff 00 00    	and    $0xffff,%ecx
5ffb6e48:	8d 14 19             	lea    (%ecx,%ebx,1),%edx
5ffb6e4b:	8b 5d c0             	mov    0xffffffc0(%ebp),%ebx
5ffb6e4e:	66 8b 43 26          	mov    0x26(%ebx),%ax
5ffb6e52:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb6e57:	39 c2                	cmp    %eax,%edx
5ffb6e59:	0f 83 0a 01 00 00    	jae    5ffb6f69 <@GuiConsoleUpdateBitmap@20+0x249>
5ffb6e5f:	66 8b 43 24          	mov    0x24(%ebx),%ax
5ffb6e63:	8b 75 b4             	mov    0xffffffb4(%ebp),%esi
5ffb6e66:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb6e6b:	0f af d0             	imul   %eax,%edx
5ffb6e6e:	8b 43 20             	mov    0x20(%ebx),%eax
5ffb6e71:	01 f2                	add    %esi,%edx
5ffb6e73:	8d 14 50             	lea    (%eax,%edx,2),%edx
5ffb6e76:	89 55 c8             	mov    %edx,0xffffffc8(%ebp)
5ffb6e79:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
5ffb6e7c:	8b 5d b4             	mov    0xffffffb4(%ebp),%ebx
5ffb6e7f:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
5ffb6e82:	89 5d cc             	mov    %ebx,0xffffffcc(%ebp)
5ffb6e85:	8b 72 0c             	mov    0xc(%edx),%esi
5ffb6e88:	89 df                	mov    %ebx,%edi
5ffb6e8a:	39 c3                	cmp    %eax,%ebx
5ffb6e8c:	0f 87 94 00 00 00    	ja     5ffb6f26 <@GuiConsoleUpdateBitmap@20+0x206>
5ffb6e92:	8b 4d c8             	mov    0xffffffc8(%ebp),%ecx
5ffb6e95:	8a 55 c7             	mov    0xffffffc7(%ebp),%dl
5ffb6e98:	38 51 01             	cmp    %dl,0x1(%ecx)
5ffb6e9b:	74 55                	je     5ffb6ef2 <@GuiConsoleUpdateBitmap@20+0x1d2>
5ffb6e9d:	83 ec 0c             	sub    $0xc,%esp
5ffb6ea0:	8b 55 cc             	mov    0xffffffcc(%ebp),%edx
5ffb6ea3:	89 f8                	mov    %edi,%eax
5ffb6ea5:	29 d0                	sub    %edx,%eax
5ffb6ea7:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
5ffb6eaa:	50                   	push   %eax
5ffb6eab:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
5ffb6eae:	8b 72 0c             	mov    0xc(%edx),%esi
5ffb6eb1:	56                   	push   %esi
5ffb6eb2:	8b 5a 08             	mov    0x8(%edx),%ebx
5ffb6eb5:	0f af c3             	imul   %ebx,%eax
5ffb6eb8:	50                   	push   %eax
5ffb6eb9:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
5ffb6ebc:	8b 4a 04             	mov    0x4(%edx),%ecx
5ffb6ebf:	0f af c1             	imul   %ecx,%eax
5ffb6ec2:	50                   	push   %eax
5ffb6ec3:	8b 42 30             	mov    0x30(%edx),%eax
5ffb6ec6:	50                   	push   %eax
5ffb6ec7:	e8 94 22 00 00       	call   5ffb9160 <_TextOutW@20>
5ffb6ecc:	8b 55 c8             	mov    0xffffffc8(%ebp),%edx
5ffb6ecf:	89 7d cc             	mov    %edi,0xffffffcc(%ebp)
5ffb6ed2:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
5ffb6ed5:	83 c4 0c             	add    $0xc,%esp
5ffb6ed8:	8a 5a 01             	mov    0x1(%edx),%bl
5ffb6edb:	8b 70 0c             	mov    0xc(%eax),%esi
5ffb6ede:	3a 5d c7             	cmp    0xffffffc7(%ebp),%bl
5ffb6ee1:	74 0f                	je     5ffb6ef2 <@GuiConsoleUpdateBitmap@20+0x1d2>
5ffb6ee3:	31 d2                	xor    %edx,%edx
5ffb6ee5:	8b 48 30             	mov    0x30(%eax),%ecx
5ffb6ee8:	88 da                	mov    %bl,%dl
5ffb6eea:	e8 e1 fb ff ff       	call   5ffb6ad0 <@GuiConsoleSetTextColors@8>
5ffb6eef:	88 5d c7             	mov    %bl,0xffffffc7(%ebp)
5ffb6ef2:	50                   	push   %eax
5ffb6ef3:	50                   	push   %eax
5ffb6ef4:	8b 45 c8             	mov    0xffffffc8(%ebp),%eax
5ffb6ef7:	6a 01                	push   $0x1
5ffb6ef9:	56                   	push   %esi
5ffb6efa:	6a 01                	push   $0x1
5ffb6efc:	50                   	push   %eax
5ffb6efd:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb6f00:	6a 00                	push   $0x0
5ffb6f02:	47                   	inc    %edi
5ffb6f03:	83 c6 02             	add    $0x2,%esi
5ffb6f06:	8b 58 6c             	mov    0x6c(%eax),%ebx
5ffb6f09:	53                   	push   %ebx
5ffb6f0a:	e8 a1 1e 00 00       	call   5ffb8db0 <_MultiByteToWideChar@24>
5ffb6f0f:	8b 4d c8             	mov    0xffffffc8(%ebp),%ecx
5ffb6f12:	58                   	pop    %eax
5ffb6f13:	83 c1 02             	add    $0x2,%ecx
5ffb6f16:	5a                   	pop    %edx
5ffb6f17:	89 4d c8             	mov    %ecx,0xffffffc8(%ebp)
5ffb6f1a:	3b 7d d4             	cmp    0xffffffd4(%ebp),%edi
5ffb6f1d:	0f 86 6f ff ff ff    	jbe    5ffb6e92 <@GuiConsoleUpdateBitmap@20+0x172>
5ffb6f23:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
5ffb6f26:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
5ffb6f29:	8b 7d cc             	mov    0xffffffcc(%ebp),%edi
5ffb6f2c:	83 ec 0c             	sub    $0xc,%esp
5ffb6f2f:	29 f8                	sub    %edi,%eax
5ffb6f31:	40                   	inc    %eax
5ffb6f32:	50                   	push   %eax
5ffb6f33:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
5ffb6f36:	8b 72 0c             	mov    0xc(%edx),%esi
5ffb6f39:	56                   	push   %esi
5ffb6f3a:	8b 5a 08             	mov    0x8(%edx),%ebx
5ffb6f3d:	0f af c3             	imul   %ebx,%eax
5ffb6f40:	50                   	push   %eax
5ffb6f41:	8b 45 cc             	mov    0xffffffcc(%ebp),%eax
5ffb6f44:	8b 4a 04             	mov    0x4(%edx),%ecx
5ffb6f47:	0f af c1             	imul   %ecx,%eax
5ffb6f4a:	50                   	push   %eax
5ffb6f4b:	8b 42 30             	mov    0x30(%edx),%eax
5ffb6f4e:	50                   	push   %eax
5ffb6f4f:	e8 0c 22 00 00       	call   5ffb9160 <_TextOutW@20>
5ffb6f54:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
5ffb6f57:	8b 4d d8             	mov    0xffffffd8(%ebp),%ecx
5ffb6f5a:	40                   	inc    %eax
5ffb6f5b:	83 c4 0c             	add    $0xc,%esp
5ffb6f5e:	89 45 d0             	mov    %eax,0xffffffd0(%ebp)
5ffb6f61:	39 4d d0             	cmp    %ecx,0xffffffd0(%ebp)
5ffb6f64:	e9 c7 fe ff ff       	jmp    5ffb6e30 <@GuiConsoleUpdateBitmap@20+0x110>
5ffb6f69:	29 c8                	sub    %ecx,%eax
5ffb6f6b:	8b 55 d0             	mov    0xffffffd0(%ebp),%edx
5ffb6f6e:	8b 4d c0             	mov    0xffffffc0(%ebp),%ecx
5ffb6f71:	29 c2                	sub    %eax,%edx
5ffb6f73:	89 d0                	mov    %edx,%eax
5ffb6f75:	8b 5d b4             	mov    0xffffffb4(%ebp),%ebx
5ffb6f78:	66 8b 51 24          	mov    0x24(%ecx),%dx
5ffb6f7c:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb6f82:	0f af c2             	imul   %edx,%eax
5ffb6f85:	8b 51 20             	mov    0x20(%ecx),%edx
5ffb6f88:	01 d8                	add    %ebx,%eax
5ffb6f8a:	8d 04 42             	lea    (%edx,%eax,2),%eax
5ffb6f8d:	89 45 c8             	mov    %eax,0xffffffc8(%ebp)
5ffb6f90:	e9 e4 fe ff ff       	jmp    5ffb6e79 <@GuiConsoleUpdateBitmap@20+0x159>
5ffb6f95:	8b 5d c0             	mov    0xffffffc0(%ebp),%ebx
5ffb6f98:	8b 43 3c             	mov    0x3c(%ebx),%eax
5ffb6f9b:	85 c0                	test   %eax,%eax
5ffb6f9d:	0f 84 29 01 00 00    	je     5ffb70cc <@GuiConsoleUpdateBitmap@20+0x3ac>
5ffb6fa3:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
5ffb6fa6:	8b 42 10             	mov    0x10(%edx),%eax
5ffb6fa9:	85 c0                	test   %eax,%eax
5ffb6fab:	74 07                	je     5ffb6fb4 <@GuiConsoleUpdateBitmap@20+0x294>
5ffb6fad:	8b 7a 14             	mov    0x14(%edx),%edi
5ffb6fb0:	85 ff                	test   %edi,%edi
5ffb6fb2:	74 3b                	je     5ffb6fef <@GuiConsoleUpdateBitmap@20+0x2cf>
5ffb6fb4:	83 ec 0c             	sub    $0xc,%esp
5ffb6fb7:	8d 42 18             	lea    0x18(%edx),%eax
5ffb6fba:	50                   	push   %eax
5ffb6fbb:	e8 e0 1c 00 00       	call   5ffb8ca0 <_LeaveCriticalSection@4>
5ffb6fc0:	8b 7d dc             	mov    0xffffffdc(%ebp),%edi
5ffb6fc3:	58                   	pop    %eax
5ffb6fc4:	8b 75 e0             	mov    0xffffffe0(%ebp),%esi
5ffb6fc7:	57                   	push   %edi
5ffb6fc8:	56                   	push   %esi
5ffb6fc9:	e8 32 20 00 00       	call   5ffb9000 <_ReleaseDC@8>
5ffb6fce:	8b 4d ac             	mov    0xffffffac(%ebp),%ecx
5ffb6fd1:	53                   	push   %ebx
5ffb6fd2:	51                   	push   %ecx
5ffb6fd3:	e8 c8 1c 00 00       	call   5ffb8ca0 <_LeaveCriticalSection@4>
5ffb6fd8:	58                   	pop    %eax
5ffb6fd9:	8d 45 08             	lea    0x8(%ebp),%eax
5ffb6fdc:	5a                   	pop    %edx
5ffb6fdd:	6a 00                	push   $0x0
5ffb6fdf:	50                   	push   %eax
5ffb6fe0:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
5ffb6fe3:	50                   	push   %eax
5ffb6fe4:	e8 e7 1f 00 00       	call   5ffb8fd0 <_InvalidateRect@12>
5ffb6fe9:	58                   	pop    %eax
5ffb6fea:	e9 64 fd ff ff       	jmp    5ffb6d53 <@GuiConsoleUpdateBitmap@20+0x33>
5ffb6fef:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
5ffb6ff2:	8d 55 e4             	lea    0xffffffe4(%ebp),%edx
5ffb6ff5:	89 d9                	mov    %ebx,%ecx
5ffb6ff7:	50                   	push   %eax
5ffb6ff8:	e8 13 fb ff ff       	call   5ffb6b10 <@GuiConsoleGetLogicalCursorPos@12>
5ffb6ffd:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
5ffb7000:	39 45 b4             	cmp    %eax,0xffffffb4(%ebp)
5ffb7003:	0f 87 c3 00 00 00    	ja     5ffb70cc <@GuiConsoleUpdateBitmap@20+0x3ac>
5ffb7009:	3b 45 d4             	cmp    0xffffffd4(%ebp),%eax
5ffb700c:	0f 87 ba 00 00 00    	ja     5ffb70cc <@GuiConsoleUpdateBitmap@20+0x3ac>
5ffb7012:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
5ffb7015:	39 45 bc             	cmp    %eax,0xffffffbc(%ebp)
5ffb7018:	0f 87 ae 00 00 00    	ja     5ffb70cc <@GuiConsoleUpdateBitmap@20+0x3ac>
5ffb701e:	3b 45 d8             	cmp    0xffffffd8(%ebp),%eax
5ffb7021:	0f 87 a5 00 00 00    	ja     5ffb70cc <@GuiConsoleUpdateBitmap@20+0x3ac>
5ffb7027:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
5ffb702a:	8b 53 38             	mov    0x38(%ebx),%edx
5ffb702d:	8b 70 08             	mov    0x8(%eax),%esi
5ffb7030:	b8 1f 85 eb 51       	mov    $0x51eb851f,%eax
5ffb7035:	0f af d6             	imul   %esi,%edx
5ffb7038:	f7 e2                	mul    %edx
5ffb703a:	89 d7                	mov    %edx,%edi
5ffb703c:	c1 ef 05             	shr    $0x5,%edi
5ffb703f:	75 05                	jne    5ffb7046 <@GuiConsoleUpdateBitmap@20+0x326>
5ffb7041:	bf 01 00 00 00       	mov    $0x1,%edi
5ffb7046:	8b 55 c0             	mov    0xffffffc0(%ebp),%edx
5ffb7049:	83 ec 0c             	sub    $0xc,%esp
5ffb704c:	66 8b 42 24          	mov    0x24(%edx),%ax
5ffb7050:	8b 5a 30             	mov    0x30(%edx),%ebx
5ffb7053:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb7058:	8b 4a 2c             	mov    0x2c(%edx),%ecx
5ffb705b:	0f af c3             	imul   %ebx,%eax
5ffb705e:	8b 52 20             	mov    0x20(%edx),%edx
5ffb7061:	01 c8                	add    %ecx,%eax
5ffb7063:	31 c9                	xor    %ecx,%ecx
5ffb7065:	8a 4c 42 01          	mov    0x1(%edx,%eax,2),%cl
5ffb7069:	e8 d2 f9 ff ff       	call   5ffb6a40 <@GuiConsoleRGBFromAttribute@4>
5ffb706e:	50                   	push   %eax
5ffb706f:	e8 fc 20 00 00       	call   5ffb9170 <_CreateSolidBrush@4>
5ffb7074:	89 c3                	mov    %eax,%ebx
5ffb7076:	89 04 24             	mov    %eax,(%esp)
5ffb7079:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
5ffb707c:	8b 50 30             	mov    0x30(%eax),%edx
5ffb707f:	52                   	push   %edx
5ffb7080:	e8 fb 20 00 00       	call   5ffb9180 <_SelectObject@8>
5ffb7085:	8b 4d f0             	mov    0xfffffff0(%ebp),%ecx
5ffb7088:	89 c6                	mov    %eax,%esi
5ffb708a:	68 21 00 f0 00       	push   $0xf00021
5ffb708f:	57                   	push   %edi
5ffb7090:	8b 41 04             	mov    0x4(%ecx),%eax
5ffb7093:	50                   	push   %eax
5ffb7094:	8b 41 08             	mov    0x8(%ecx),%eax
5ffb7097:	89 c2                	mov    %eax,%edx
5ffb7099:	29 f8                	sub    %edi,%eax
5ffb709b:	0f af 55 e8          	imul   0xffffffe8(%ebp),%edx
5ffb709f:	01 c2                	add    %eax,%edx
5ffb70a1:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
5ffb70a4:	52                   	push   %edx
5ffb70a5:	8b 51 04             	mov    0x4(%ecx),%edx
5ffb70a8:	0f af c2             	imul   %edx,%eax
5ffb70ab:	50                   	push   %eax
5ffb70ac:	8b 41 30             	mov    0x30(%ecx),%eax
5ffb70af:	50                   	push   %eax
5ffb70b0:	e8 db 20 00 00       	call   5ffb9190 <_PatBlt@24>
5ffb70b5:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
5ffb70b8:	56                   	push   %esi
5ffb70b9:	8b 40 30             	mov    0x30(%eax),%eax
5ffb70bc:	50                   	push   %eax
5ffb70bd:	e8 be 20 00 00       	call   5ffb9180 <_SelectObject@8>
5ffb70c2:	50                   	push   %eax
5ffb70c3:	53                   	push   %ebx
5ffb70c4:	e8 87 20 00 00       	call   5ffb9150 <_DeleteObject@4>
5ffb70c9:	83 c4 0c             	add    $0xc,%esp
5ffb70cc:	8b 55 f0             	mov    0xfffffff0(%ebp),%edx
5ffb70cf:	e9 e0 fe ff ff       	jmp    5ffb6fb4 <@GuiConsoleUpdateBitmap@20+0x294>
5ffb70d4:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb70da:	8d bf 00 00 00 00    	lea    0x0(%edi),%edi

5ffb70e0 <@GuiConsoleHandlePaint@4>:
5ffb70e0:	55                   	push   %ebp
5ffb70e1:	89 e5                	mov    %esp,%ebp
5ffb70e3:	57                   	push   %edi
5ffb70e4:	56                   	push   %esi
5ffb70e5:	53                   	push   %ebx
5ffb70e6:	83 ec 78             	sub    $0x78,%esp
5ffb70e9:	8d 45 94             	lea    0xffffff94(%ebp),%eax
5ffb70ec:	89 4d 8c             	mov    %ecx,0xffffff8c(%ebp)
5ffb70ef:	8d 55 90             	lea    0xffffff90(%ebp),%edx
5ffb70f2:	50                   	push   %eax
5ffb70f3:	e8 18 f9 ff ff       	call   5ffb6a10 <@GuiConsoleGetDataPointers@12>
5ffb70f8:	8b 55 90             	mov    0xffffff90(%ebp),%edx
5ffb70fb:	83 c4 0c             	add    $0xc,%esp
5ffb70fe:	85 d2                	test   %edx,%edx
5ffb7100:	74 07                	je     5ffb7109 <@GuiConsoleHandlePaint@4+0x29>
5ffb7102:	8b 45 94             	mov    0xffffff94(%ebp),%eax
5ffb7105:	85 c0                	test   %eax,%eax
5ffb7107:	75 27                	jne    5ffb7130 <@GuiConsoleHandlePaint@4+0x50>
5ffb7109:	8d 5d a8             	lea    0xffffffa8(%ebp),%ebx
5ffb710c:	50                   	push   %eax
5ffb710d:	50                   	push   %eax
5ffb710e:	53                   	push   %ebx
5ffb710f:	8b 7d 8c             	mov    0xffffff8c(%ebp),%edi
5ffb7112:	57                   	push   %edi
5ffb7113:	e8 f8 1d 00 00       	call   5ffb8f10 <_BeginPaint@8>
5ffb7118:	53                   	push   %ebx
5ffb7119:	8b 75 8c             	mov    0xffffff8c(%ebp),%esi
5ffb711c:	56                   	push   %esi
5ffb711d:	e8 0e 1e 00 00       	call   5ffb8f30 <_EndPaint@8>
5ffb7122:	59                   	pop    %ecx
5ffb7123:	5b                   	pop    %ebx
5ffb7124:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb7127:	5b                   	pop    %ebx
5ffb7128:	5e                   	pop    %esi
5ffb7129:	5f                   	pop    %edi
5ffb712a:	5d                   	pop    %ebp
5ffb712b:	c3                   	ret    
5ffb712c:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb7130:	83 ec 0c             	sub    $0xc,%esp
5ffb7133:	83 c0 18             	add    $0x18,%eax
5ffb7136:	50                   	push   %eax
5ffb7137:	e8 54 1b 00 00       	call   5ffb8c90 <_EnterCriticalSection@4>
5ffb713c:	8d 45 a8             	lea    0xffffffa8(%ebp),%eax
5ffb713f:	89 04 24             	mov    %eax,(%esp)
5ffb7142:	8b 45 8c             	mov    0xffffff8c(%ebp),%eax
5ffb7145:	50                   	push   %eax
5ffb7146:	e8 c5 1d 00 00       	call   5ffb8f10 <_BeginPaint@8>
5ffb714b:	89 45 88             	mov    %eax,0xffffff88(%ebp)
5ffb714e:	50                   	push   %eax
5ffb714f:	68 20 00 cc 00       	push   $0xcc0020
5ffb7154:	8b 45 b4             	mov    0xffffffb4(%ebp),%eax
5ffb7157:	50                   	push   %eax
5ffb7158:	8b 45 b0             	mov    0xffffffb0(%ebp),%eax
5ffb715b:	50                   	push   %eax
5ffb715c:	8b 45 94             	mov    0xffffff94(%ebp),%eax
5ffb715f:	8b 40 30             	mov    0x30(%eax),%eax
5ffb7162:	50                   	push   %eax
5ffb7163:	8b 45 bc             	mov    0xffffffbc(%ebp),%eax
5ffb7166:	8b 4d b4             	mov    0xffffffb4(%ebp),%ecx
5ffb7169:	29 c8                	sub    %ecx,%eax
5ffb716b:	40                   	inc    %eax
5ffb716c:	50                   	push   %eax
5ffb716d:	8b 45 b8             	mov    0xffffffb8(%ebp),%eax
5ffb7170:	8b 55 b0             	mov    0xffffffb0(%ebp),%edx
5ffb7173:	29 d0                	sub    %edx,%eax
5ffb7175:	40                   	inc    %eax
5ffb7176:	50                   	push   %eax
5ffb7177:	51                   	push   %ecx
5ffb7178:	52                   	push   %edx
5ffb7179:	8b 45 88             	mov    0xffffff88(%ebp),%eax
5ffb717c:	50                   	push   %eax
5ffb717d:	e8 1e 20 00 00       	call   5ffb91a0 <_BitBlt@36>
5ffb7182:	8b 5d 94             	mov    0xffffff94(%ebp),%ebx
5ffb7185:	83 c4 0c             	add    $0xc,%esp
5ffb7188:	8b 7b 38             	mov    0x38(%ebx),%edi
5ffb718b:	83 ff ff             	cmp    $0xffffffff,%edi
5ffb718e:	74 44                	je     5ffb71d4 <@GuiConsoleHandlePaint@4+0xf4>
5ffb7190:	89 7d 98             	mov    %edi,0xffffff98(%ebp)
5ffb7193:	8b 73 04             	mov    0x4(%ebx),%esi
5ffb7196:	8b 43 3c             	mov    0x3c(%ebx),%eax
5ffb7199:	89 45 9c             	mov    %eax,0xffffff9c(%ebp)
5ffb719c:	8b 53 40             	mov    0x40(%ebx),%edx
5ffb719f:	89 55 a0             	mov    %edx,0xffffffa0(%ebp)
5ffb71a2:	8b 4b 44             	mov    0x44(%ebx),%ecx
5ffb71a5:	8b 5b 08             	mov    0x8(%ebx),%ebx
5ffb71a8:	0f af fe             	imul   %esi,%edi
5ffb71ab:	0f af d6             	imul   %esi,%edx
5ffb71ae:	0f af c3             	imul   %ebx,%eax
5ffb71b1:	0f af cb             	imul   %ebx,%ecx
5ffb71b4:	89 7d 98             	mov    %edi,0xffffff98(%ebp)
5ffb71b7:	89 45 9c             	mov    %eax,0xffffff9c(%ebp)
5ffb71ba:	89 55 a0             	mov    %edx,0xffffffa0(%ebp)
5ffb71bd:	89 4d a4             	mov    %ecx,0xffffffa4(%ebp)
5ffb71c0:	8d 55 98             	lea    0xffffff98(%ebp),%edx
5ffb71c3:	8d 45 b0             	lea    0xffffffb0(%ebp),%eax
5ffb71c6:	57                   	push   %edi
5ffb71c7:	52                   	push   %edx
5ffb71c8:	50                   	push   %eax
5ffb71c9:	52                   	push   %edx
5ffb71ca:	e8 41 1e 00 00       	call   5ffb9010 <_IntersectRect@12>
5ffb71cf:	5e                   	pop    %esi
5ffb71d0:	85 c0                	test   %eax,%eax
5ffb71d2:	75 27                	jne    5ffb71fb <@GuiConsoleHandlePaint@4+0x11b>
5ffb71d4:	50                   	push   %eax
5ffb71d5:	50                   	push   %eax
5ffb71d6:	8d 45 a8             	lea    0xffffffa8(%ebp),%eax
5ffb71d9:	50                   	push   %eax
5ffb71da:	8b 45 8c             	mov    0xffffff8c(%ebp),%eax
5ffb71dd:	50                   	push   %eax
5ffb71de:	e8 4d 1d 00 00       	call   5ffb8f30 <_EndPaint@8>
5ffb71e3:	50                   	push   %eax
5ffb71e4:	8b 45 94             	mov    0xffffff94(%ebp),%eax
5ffb71e7:	83 c0 18             	add    $0x18,%eax
5ffb71ea:	50                   	push   %eax
5ffb71eb:	e8 b0 1a 00 00       	call   5ffb8ca0 <_LeaveCriticalSection@4>
5ffb71f0:	83 c4 0c             	add    $0xc,%esp
5ffb71f3:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb71f6:	5b                   	pop    %ebx
5ffb71f7:	5e                   	pop    %esi
5ffb71f8:	5f                   	pop    %edi
5ffb71f9:	5d                   	pop    %ebp
5ffb71fa:	c3                   	ret    
5ffb71fb:	53                   	push   %ebx
5ffb71fc:	53                   	push   %ebx
5ffb71fd:	68 09 00 55 00       	push   $0x550009
5ffb7202:	8b 4d 9c             	mov    0xffffff9c(%ebp),%ecx
5ffb7205:	8b 45 a4             	mov    0xffffffa4(%ebp),%eax
5ffb7208:	29 c8                	sub    %ecx,%eax
5ffb720a:	50                   	push   %eax
5ffb720b:	8b 55 98             	mov    0xffffff98(%ebp),%edx
5ffb720e:	8b 45 a0             	mov    0xffffffa0(%ebp),%eax
5ffb7211:	29 d0                	sub    %edx,%eax
5ffb7213:	50                   	push   %eax
5ffb7214:	51                   	push   %ecx
5ffb7215:	52                   	push   %edx
5ffb7216:	8b 4d 88             	mov    0xffffff88(%ebp),%ecx
5ffb7219:	51                   	push   %ecx
5ffb721a:	e8 71 1f 00 00       	call   5ffb9190 <_PatBlt@24>
5ffb721f:	58                   	pop    %eax
5ffb7220:	5a                   	pop    %edx
5ffb7221:	eb b1                	jmp    5ffb71d4 <@GuiConsoleHandlePaint@4+0xf4>
5ffb7223:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi
5ffb7229:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb7230 <@GuiIntDrawRegion@12>:
5ffb7230:	55                   	push   %ebp
5ffb7231:	89 e5                	mov    %esp,%ebp
5ffb7233:	57                   	push   %edi
5ffb7234:	56                   	push   %esi
5ffb7235:	53                   	push   %ebx
5ffb7236:	83 ec 2c             	sub    $0x2c,%esp
5ffb7239:	89 55 d4             	mov    %edx,0xffffffd4(%ebp)
5ffb723c:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb723f:	8b 59 04             	mov    0x4(%ecx),%ebx
5ffb7242:	8b 49 08             	mov    0x8(%ecx),%ecx
5ffb7245:	8b 38                	mov    (%eax),%edi
5ffb7247:	8b 70 04             	mov    0x4(%eax),%esi
5ffb724a:	8b 50 08             	mov    0x8(%eax),%edx
5ffb724d:	8b 40 0c             	mov    0xc(%eax),%eax
5ffb7250:	42                   	inc    %edx
5ffb7251:	40                   	inc    %eax
5ffb7252:	0f af fb             	imul   %ebx,%edi
5ffb7255:	0f af f1             	imul   %ecx,%esi
5ffb7258:	0f af d3             	imul   %ebx,%edx
5ffb725b:	0f af c1             	imul   %ecx,%eax
5ffb725e:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
5ffb7261:	50                   	push   %eax
5ffb7262:	89 7d d8             	mov    %edi,0xffffffd8(%ebp)
5ffb7265:	89 75 dc             	mov    %esi,0xffffffdc(%ebp)
5ffb7268:	52                   	push   %edx
5ffb7269:	89 55 e0             	mov    %edx,0xffffffe0(%ebp)
5ffb726c:	56                   	push   %esi
5ffb726d:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
5ffb7270:	57                   	push   %edi
5ffb7271:	e8 aa fa ff ff       	call   5ffb6d20 <@GuiConsoleUpdateBitmap@20>
5ffb7276:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb7279:	5b                   	pop    %ebx
5ffb727a:	5e                   	pop    %esi
5ffb727b:	5f                   	pop    %edi
5ffb727c:	5d                   	pop    %ebp
5ffb727d:	c2 04 00             	ret    $0x4

5ffb7280 <_GuiDrawRegion@8>:
5ffb7280:	55                   	push   %ebp
5ffb7281:	89 e5                	mov    %esp,%ebp
5ffb7283:	53                   	push   %ebx
5ffb7284:	50                   	push   %eax
5ffb7285:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb7288:	8b 58 64             	mov    0x64(%eax),%ebx
5ffb728b:	8b 48 58             	mov    0x58(%eax),%ecx
5ffb728e:	85 c9                	test   %ecx,%ecx
5ffb7290:	0f 94 c2             	sete   %dl
5ffb7293:	85 db                	test   %ebx,%ebx
5ffb7295:	0f 94 c0             	sete   %al
5ffb7298:	09 d0                	or     %edx,%eax
5ffb729a:	a8 01                	test   $0x1,%al
5ffb729c:	74 07                	je     5ffb72a5 <_GuiDrawRegion@8+0x25>
5ffb729e:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb72a1:	c9                   	leave  
5ffb72a2:	c2 08 00             	ret    $0x8
5ffb72a5:	83 ec 0c             	sub    $0xc,%esp
5ffb72a8:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb72ab:	89 ca                	mov    %ecx,%edx
5ffb72ad:	89 d9                	mov    %ebx,%ecx
5ffb72af:	50                   	push   %eax
5ffb72b0:	e8 7b ff ff ff       	call   5ffb7230 <@GuiIntDrawRegion@12>
5ffb72b5:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb72b8:	c9                   	leave  
5ffb72b9:	c2 08 00             	ret    $0x8
5ffb72bc:	8d 74 26 00          	lea    0x0(%esi),%esi

5ffb72c0 <@GuiInvalidateCell@16>:
5ffb72c0:	55                   	push   %ebp
5ffb72c1:	89 e5                	mov    %esp,%ebp
5ffb72c3:	53                   	push   %ebx
5ffb72c4:	83 ec 20             	sub    $0x20,%esp
5ffb72c7:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb72ca:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb72cd:	89 45 e8             	mov    %eax,0xffffffe8(%ebp)
5ffb72d0:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
5ffb72d3:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
5ffb72d6:	89 5d ec             	mov    %ebx,0xffffffec(%ebp)
5ffb72d9:	89 5d f4             	mov    %ebx,0xfffffff4(%ebp)
5ffb72dc:	50                   	push   %eax
5ffb72dd:	e8 4e ff ff ff       	call   5ffb7230 <@GuiIntDrawRegion@12>
5ffb72e2:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb72e5:	c9                   	leave  
5ffb72e6:	c2 08 00             	ret    $0x8
5ffb72e9:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

5ffb72f0 <_GuiConsoleCopyRegion@12>:
5ffb72f0:	55                   	push   %ebp
5ffb72f1:	89 e5                	mov    %esp,%ebp
5ffb72f3:	57                   	push   %edi
5ffb72f4:	56                   	push   %esi
5ffb72f5:	53                   	push   %ebx
5ffb72f6:	83 ec 38             	sub    $0x38,%esp
5ffb72f9:	8d 45 d4             	lea    0xffffffd4(%ebp),%eax
5ffb72fc:	8b 7d 08             	mov    0x8(%ebp),%edi
5ffb72ff:	8d 55 d0             	lea    0xffffffd0(%ebp),%edx
5ffb7302:	89 f9                	mov    %edi,%ecx
5ffb7304:	8b 5d 10             	mov    0x10(%ebp),%ebx
5ffb7307:	8b 75 0c             	mov    0xc(%ebp),%esi
5ffb730a:	50                   	push   %eax
5ffb730b:	e8 00 f7 ff ff       	call   5ffb6a10 <@GuiConsoleGetDataPointers@12>
5ffb7310:	8b 55 d4             	mov    0xffffffd4(%ebp),%edx
5ffb7313:	8b 03                	mov    (%ebx),%eax
5ffb7315:	8b 4a 04             	mov    0x4(%edx),%ecx
5ffb7318:	0f af c1             	imul   %ecx,%eax
5ffb731b:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
5ffb731e:	8b 43 08             	mov    0x8(%ebx),%eax
5ffb7321:	40                   	inc    %eax
5ffb7322:	0f af c1             	imul   %ecx,%eax
5ffb7325:	8b 4a 08             	mov    0x8(%edx),%ecx
5ffb7328:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
5ffb732b:	8b 43 04             	mov    0x4(%ebx),%eax
5ffb732e:	83 c2 18             	add    $0x18,%edx
5ffb7331:	0f af c1             	imul   %ecx,%eax
5ffb7334:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
5ffb7337:	8b 43 0c             	mov    0xc(%ebx),%eax
5ffb733a:	40                   	inc    %eax
5ffb733b:	52                   	push   %edx
5ffb733c:	0f af c1             	imul   %ecx,%eax
5ffb733f:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
5ffb7342:	e8 49 19 00 00       	call   5ffb8c90 <_EnterCriticalSection@4>
5ffb7347:	8b 4d d4             	mov    0xffffffd4(%ebp),%ecx
5ffb734a:	68 20 00 cc 00       	push   $0xcc0020
5ffb734f:	8b 5e 04             	mov    0x4(%esi),%ebx
5ffb7352:	8b 41 08             	mov    0x8(%ecx),%eax
5ffb7355:	0f af c3             	imul   %ebx,%eax
5ffb7358:	50                   	push   %eax
5ffb7359:	8b 16                	mov    (%esi),%edx
5ffb735b:	8b 41 04             	mov    0x4(%ecx),%eax
5ffb735e:	0f af c2             	imul   %edx,%eax
5ffb7361:	50                   	push   %eax
5ffb7362:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
5ffb7365:	8b 59 30             	mov    0x30(%ecx),%ebx
5ffb7368:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
5ffb736b:	53                   	push   %ebx
5ffb736c:	8b 5d dc             	mov    0xffffffdc(%ebp),%ebx
5ffb736f:	29 d8                	sub    %ebx,%eax
5ffb7371:	50                   	push   %eax
5ffb7372:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
5ffb7375:	29 d0                	sub    %edx,%eax
5ffb7377:	50                   	push   %eax
5ffb7378:	53                   	push   %ebx
5ffb7379:	52                   	push   %edx
5ffb737a:	8b 49 30             	mov    0x30(%ecx),%ecx
5ffb737d:	51                   	push   %ecx
5ffb737e:	e8 1d 1e 00 00       	call   5ffb91a0 <_BitBlt@36>
5ffb7383:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
5ffb7386:	83 c0 18             	add    $0x18,%eax
5ffb7389:	50                   	push   %eax
5ffb738a:	e8 11 19 00 00       	call   5ffb8ca0 <_LeaveCriticalSection@4>
5ffb738f:	58                   	pop    %eax
5ffb7390:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
5ffb7393:	5a                   	pop    %edx
5ffb7394:	6a 00                	push   $0x0
5ffb7396:	50                   	push   %eax
5ffb7397:	57                   	push   %edi
5ffb7398:	e8 33 1c 00 00       	call   5ffb8fd0 <_InvalidateRect@12>
5ffb739d:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb73a0:	5b                   	pop    %ebx
5ffb73a1:	5e                   	pop    %esi
5ffb73a2:	5f                   	pop    %edi
5ffb73a3:	5d                   	pop    %ebp
5ffb73a4:	c2 0c 00             	ret    $0xc
5ffb73a7:	89 f6                	mov    %esi,%esi
5ffb73a9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb73b0 <_GuiWriteStream@28>:
5ffb73b0:	55                   	push   %ebp
5ffb73b1:	89 e5                	mov    %esp,%ebp
5ffb73b3:	57                   	push   %edi
5ffb73b4:	56                   	push   %esi
5ffb73b5:	53                   	push   %ebx
5ffb73b6:	83 ec 3c             	sub    $0x3c,%esp
5ffb73b9:	8b 7d 08             	mov    0x8(%ebp),%edi
5ffb73bc:	8b 75 18             	mov    0x18(%ebp),%esi
5ffb73bf:	8b 47 64             	mov    0x64(%edi),%eax
5ffb73c2:	8b 57 38             	mov    0x38(%edi),%edx
5ffb73c5:	8b 5f 58             	mov    0x58(%edi),%ebx
5ffb73c8:	89 45 bc             	mov    %eax,0xffffffbc(%ebp)
5ffb73cb:	85 db                	test   %ebx,%ebx
5ffb73cd:	89 55 b8             	mov    %edx,0xffffffb8(%ebp)
5ffb73d0:	0f 94 c2             	sete   %dl
5ffb73d3:	85 c0                	test   %eax,%eax
5ffb73d5:	0f 94 c0             	sete   %al
5ffb73d8:	09 d0                	or     %edx,%eax
5ffb73da:	a8 01                	test   $0x1,%al
5ffb73dc:	0f 85 9f 00 00 00    	jne    5ffb7481 <_GuiWriteStream@28+0xd1>
5ffb73e2:	85 f6                	test   %esi,%esi
5ffb73e4:	0f 85 bc 00 00 00    	jne    5ffb74a6 <_GuiWriteStream@28+0xf6>
5ffb73ea:	83 ec 0c             	sub    $0xc,%esp
5ffb73ed:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb73f0:	89 da                	mov    %ebx,%edx
5ffb73f2:	8b 4d bc             	mov    0xffffffbc(%ebp),%ecx
5ffb73f5:	50                   	push   %eax
5ffb73f6:	e8 35 fe ff ff       	call   5ffb7230 <@GuiIntDrawRegion@12>
5ffb73fb:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb73fe:	8b 4d 10             	mov    0x10(%ebp),%ecx
5ffb7401:	83 c4 0c             	add    $0xc,%esp
5ffb7404:	39 0a                	cmp    %ecx,(%edx)
5ffb7406:	77 09                	ja     5ffb7411 <_GuiWriteStream@28+0x61>
5ffb7408:	39 4a 08             	cmp    %ecx,0x8(%edx)
5ffb740b:	0f 83 7f 00 00 00    	jae    5ffb7490 <_GuiWriteStream@28+0xe0>
5ffb7411:	8b 4d 10             	mov    0x10(%ebp),%ecx
5ffb7414:	8b 5d 14             	mov    0x14(%ebp),%ebx
5ffb7417:	56                   	push   %esi
5ffb7418:	56                   	push   %esi
5ffb7419:	8b 57 58             	mov    0x58(%edi),%edx
5ffb741c:	53                   	push   %ebx
5ffb741d:	51                   	push   %ecx
5ffb741e:	8b 4d bc             	mov    0xffffffbc(%ebp),%ecx
5ffb7421:	e8 9a fe ff ff       	call   5ffb72c0 <@GuiInvalidateCell@16>
5ffb7426:	58                   	pop    %eax
5ffb7427:	5a                   	pop    %edx
5ffb7428:	8b 4d b8             	mov    0xffffffb8(%ebp),%ecx
5ffb742b:	50                   	push   %eax
5ffb742c:	8d 45 c4             	lea    0xffffffc4(%ebp),%eax
5ffb742f:	8b 51 2c             	mov    0x2c(%ecx),%edx
5ffb7432:	50                   	push   %eax
5ffb7433:	8d 45 c0             	lea    0xffffffc0(%ebp),%eax
5ffb7436:	50                   	push   %eax
5ffb7437:	8b 41 30             	mov    0x30(%ecx),%eax
5ffb743a:	50                   	push   %eax
5ffb743b:	e8 50 a1 ff ff       	call   5ffb1590 <@ConioPhysicalToLogical@20>
5ffb7440:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb7443:	8b 45 c0             	mov    0xffffffc0(%ebp),%eax
5ffb7446:	5e                   	pop    %esi
5ffb7447:	39 02                	cmp    %eax,(%edx)
5ffb7449:	7f 15                	jg     5ffb7460 <_GuiWriteStream@28+0xb0>
5ffb744b:	39 42 08             	cmp    %eax,0x8(%edx)
5ffb744e:	7c 10                	jl     5ffb7460 <_GuiWriteStream@28+0xb0>
5ffb7450:	8b 4d 0c             	mov    0xc(%ebp),%ecx
5ffb7453:	8b 55 c4             	mov    0xffffffc4(%ebp),%edx
5ffb7456:	39 51 04             	cmp    %edx,0x4(%ecx)
5ffb7459:	7f 05                	jg     5ffb7460 <_GuiWriteStream@28+0xb0>
5ffb745b:	39 51 0c             	cmp    %edx,0xc(%ecx)
5ffb745e:	7d 21                	jge    5ffb7481 <_GuiWriteStream@28+0xd1>
5ffb7460:	3b 45 10             	cmp    0x10(%ebp),%eax
5ffb7463:	75 08                	jne    5ffb746d <_GuiWriteStream@28+0xbd>
5ffb7465:	8b 55 14             	mov    0x14(%ebp),%edx
5ffb7468:	39 55 c4             	cmp    %edx,0xffffffc4(%ebp)
5ffb746b:	74 14                	je     5ffb7481 <_GuiWriteStream@28+0xd1>
5ffb746d:	8b 4d c4             	mov    0xffffffc4(%ebp),%ecx
5ffb7470:	53                   	push   %ebx
5ffb7471:	53                   	push   %ebx
5ffb7472:	8b 57 58             	mov    0x58(%edi),%edx
5ffb7475:	51                   	push   %ecx
5ffb7476:	8b 4d bc             	mov    0xffffffbc(%ebp),%ecx
5ffb7479:	50                   	push   %eax
5ffb747a:	e8 41 fe ff ff       	call   5ffb72c0 <@GuiInvalidateCell@16>
5ffb747f:	5e                   	pop    %esi
5ffb7480:	5f                   	pop    %edi
5ffb7481:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb7484:	5b                   	pop    %ebx
5ffb7485:	5e                   	pop    %esi
5ffb7486:	5f                   	pop    %edi
5ffb7487:	5d                   	pop    %ebp
5ffb7488:	c2 1c 00             	ret    $0x1c
5ffb748b:	90                   	nop    
5ffb748c:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb7490:	8b 45 14             	mov    0x14(%ebp),%eax
5ffb7493:	39 42 04             	cmp    %eax,0x4(%edx)
5ffb7496:	0f 87 75 ff ff ff    	ja     5ffb7411 <_GuiWriteStream@28+0x61>
5ffb749c:	39 42 0c             	cmp    %eax,0xc(%edx)
5ffb749f:	73 87                	jae    5ffb7428 <_GuiWriteStream@28+0x78>
5ffb74a1:	e9 6b ff ff ff       	jmp    5ffb7411 <_GuiWriteStream@28+0x61>
5ffb74a6:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb74a9:	89 75 dc             	mov    %esi,0xffffffdc(%ebp)
5ffb74ac:	0f bf 4f 60          	movswl 0x60(%edi),%ecx
5ffb74b0:	8b 50 04             	mov    0x4(%eax),%edx
5ffb74b3:	49                   	dec    %ecx
5ffb74b4:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
5ffb74bb:	89 4d e0             	mov    %ecx,0xffffffe0(%ebp)
5ffb74be:	8d 44 32 ff          	lea    0xffffffff(%edx,%esi,1),%eax
5ffb74c2:	4a                   	dec    %edx
5ffb74c3:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
5ffb74c6:	50                   	push   %eax
5ffb74c7:	8d 45 c8             	lea    0xffffffc8(%ebp),%eax
5ffb74ca:	50                   	push   %eax
5ffb74cb:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
5ffb74ce:	50                   	push   %eax
5ffb74cf:	c7 45 c8 00 00 00 00 	movl   $0x0,0xffffffc8(%ebp)
5ffb74d6:	53                   	push   %ebx
5ffb74d7:	c7 45 cc 00 00 00 00 	movl   $0x0,0xffffffcc(%ebp)
5ffb74de:	89 4d d0             	mov    %ecx,0xffffffd0(%ebp)
5ffb74e1:	89 55 d4             	mov    %edx,0xffffffd4(%ebp)
5ffb74e4:	e8 07 fe ff ff       	call   5ffb72f0 <_GuiConsoleCopyRegion@12>
5ffb74e9:	8b 5f 58             	mov    0x58(%edi),%ebx
5ffb74ec:	58                   	pop    %eax
5ffb74ed:	e9 f8 fe ff ff       	jmp    5ffb73ea <_GuiWriteStream@28+0x3a>
5ffb74f2:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
5ffb74f9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb7500 <_GuiSetCursorInfo@8>:
5ffb7500:	55                   	push   %ebp
5ffb7501:	89 e5                	mov    %esp,%ebp
5ffb7503:	56                   	push   %esi
5ffb7504:	53                   	push   %ebx
5ffb7505:	83 ec 10             	sub    $0x10,%esp
5ffb7508:	8b 75 08             	mov    0x8(%ebp),%esi
5ffb750b:	8b 4e 38             	mov    0x38(%esi),%ecx
5ffb750e:	3b 4d 0c             	cmp    0xc(%ebp),%ecx
5ffb7511:	74 0e                	je     5ffb7521 <_GuiSetCursorInfo@8+0x21>
5ffb7513:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb7516:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb751b:	5b                   	pop    %ebx
5ffb751c:	5e                   	pop    %esi
5ffb751d:	5d                   	pop    %ebp
5ffb751e:	c2 08 00             	ret    $0x8
5ffb7521:	8d 5d e8             	lea    0xffffffe8(%ebp),%ebx
5ffb7524:	50                   	push   %eax
5ffb7525:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
5ffb7528:	8b 51 2c             	mov    0x2c(%ecx),%edx
5ffb752b:	50                   	push   %eax
5ffb752c:	53                   	push   %ebx
5ffb752d:	8b 41 30             	mov    0x30(%ecx),%eax
5ffb7530:	50                   	push   %eax
5ffb7531:	e8 5a a0 ff ff       	call   5ffb1590 <@ConioPhysicalToLogical@20>
5ffb7536:	8b 45 e8             	mov    0xffffffe8(%ebp),%eax
5ffb7539:	51                   	push   %ecx
5ffb753a:	89 45 f0             	mov    %eax,0xfffffff0(%ebp)
5ffb753d:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb7540:	89 45 f4             	mov    %eax,0xfffffff4(%ebp)
5ffb7543:	8b 46 70             	mov    0x70(%esi),%eax
5ffb7546:	53                   	push   %ebx
5ffb7547:	56                   	push   %esi
5ffb7548:	ff 50 08             	call   *0x8(%eax)
5ffb754b:	58                   	pop    %eax
5ffb754c:	5a                   	pop    %edx
5ffb754d:	eb c4                	jmp    5ffb7513 <_GuiSetCursorInfo@8+0x13>
5ffb754f:	90                   	nop    

5ffb7550 <_GuiSetScreenInfo@16>:
5ffb7550:	55                   	push   %ebp
5ffb7551:	89 e5                	mov    %esp,%ebp
5ffb7553:	57                   	push   %edi
5ffb7554:	56                   	push   %esi
5ffb7555:	53                   	push   %ebx
5ffb7556:	83 ec 1c             	sub    $0x1c,%esp
5ffb7559:	8b 7d 08             	mov    0x8(%ebp),%edi
5ffb755c:	8b 45 10             	mov    0x10(%ebp),%eax
5ffb755f:	8b 55 14             	mov    0x14(%ebp),%edx
5ffb7562:	8b 77 38             	mov    0x38(%edi),%esi
5ffb7565:	3b 75 0c             	cmp    0xc(%ebp),%esi
5ffb7568:	74 0f                	je     5ffb7579 <_GuiSetScreenInfo@16+0x29>
5ffb756a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb756d:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb7572:	5b                   	pop    %ebx
5ffb7573:	5e                   	pop    %esi
5ffb7574:	5f                   	pop    %edi
5ffb7575:	5d                   	pop    %ebp
5ffb7576:	c2 10 00             	ret    $0x10
5ffb7579:	89 45 d8             	mov    %eax,0xffffffd8(%ebp)
5ffb757c:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
5ffb757f:	50                   	push   %eax
5ffb7580:	50                   	push   %eax
5ffb7581:	8d 5d d8             	lea    0xffffffd8(%ebp),%ebx
5ffb7584:	8b 47 70             	mov    0x70(%edi),%eax
5ffb7587:	89 55 dc             	mov    %edx,0xffffffdc(%ebp)
5ffb758a:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
5ffb758d:	53                   	push   %ebx
5ffb758e:	57                   	push   %edi
5ffb758f:	ff 50 08             	call   *0x8(%eax)
5ffb7592:	8d 45 dc             	lea    0xffffffdc(%ebp),%eax
5ffb7595:	8b 56 2c             	mov    0x2c(%esi),%edx
5ffb7598:	89 04 24             	mov    %eax,(%esp)
5ffb759b:	53                   	push   %ebx
5ffb759c:	89 f1                	mov    %esi,%ecx
5ffb759e:	8b 46 30             	mov    0x30(%esi),%eax
5ffb75a1:	50                   	push   %eax
5ffb75a2:	e8 e9 9f ff ff       	call   5ffb1590 <@ConioPhysicalToLogical@20>
5ffb75a7:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
5ffb75aa:	51                   	push   %ecx
5ffb75ab:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
5ffb75ae:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
5ffb75b1:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
5ffb75b4:	8b 47 70             	mov    0x70(%edi),%eax
5ffb75b7:	53                   	push   %ebx
5ffb75b8:	57                   	push   %edi
5ffb75b9:	ff 50 08             	call   *0x8(%eax)
5ffb75bc:	58                   	pop    %eax
5ffb75bd:	5a                   	pop    %edx
5ffb75be:	eb aa                	jmp    5ffb756a <_GuiSetScreenInfo@16+0x1a>

5ffb75c0 <_GuiConsoleWndProc@16>:
5ffb75c0:	55                   	push   %ebp
5ffb75c1:	89 e5                	mov    %esp,%ebp
5ffb75c3:	57                   	push   %edi
5ffb75c4:	56                   	push   %esi
5ffb75c5:	53                   	push   %ebx
5ffb75c6:	81 ec 1c 01 00 00    	sub    $0x11c,%esp
5ffb75cc:	c7 85 ec fe ff ff 00 	movl   $0x0,0xfffffeec(%ebp)
5ffb75d3:	00 00 00 
5ffb75d6:	8b 5d 0c             	mov    0xc(%ebp),%ebx
5ffb75d9:	8b 7d 08             	mov    0x8(%ebp),%edi
5ffb75dc:	8b 75 10             	mov    0x10(%ebp),%esi
5ffb75df:	81 fb 05 01 00 00    	cmp    $0x105,%ebx
5ffb75e5:	0f 87 95 00 00 00    	ja     5ffb7680 <_GuiConsoleWndProc@16+0xc0>
5ffb75eb:	81 fb 04 01 00 00    	cmp    $0x104,%ebx
5ffb75f1:	0f 83 bb 01 00 00    	jae    5ffb77b2 <_GuiConsoleWndProc@16+0x1f2>
5ffb75f7:	81 fb 81 00 00 00    	cmp    $0x81,%ebx
5ffb75fd:	0f 84 0b 03 00 00    	je     5ffb790e <_GuiConsoleWndProc@16+0x34e>
5ffb7603:	0f 87 8e 01 00 00    	ja     5ffb7797 <_GuiConsoleWndProc@16+0x1d7>
5ffb7609:	83 fb 0f             	cmp    $0xf,%ebx
5ffb760c:	0f 84 b8 05 00 00    	je     5ffb7bca <_GuiConsoleWndProc@16+0x60a>
5ffb7612:	83 fb 10             	cmp    $0x10,%ebx
5ffb7615:	0f 85 21 02 00 00    	jne    5ffb783c <_GuiConsoleWndProc@16+0x27c>
5ffb761b:	83 ec 0c             	sub    $0xc,%esp
5ffb761e:	8d 85 1c ff ff ff    	lea    0xffffff1c(%ebp),%eax
5ffb7624:	8d 95 18 ff ff ff    	lea    0xffffff18(%ebp),%edx
5ffb762a:	89 f9                	mov    %edi,%ecx
5ffb762c:	50                   	push   %eax
5ffb762d:	e8 de f3 ff ff       	call   5ffb6a10 <@GuiConsoleGetDataPointers@12>
5ffb7632:	8b 85 18 ff ff ff    	mov    0xffffff18(%ebp),%eax
5ffb7638:	83 c0 08             	add    $0x8,%eax
5ffb763b:	50                   	push   %eax
5ffb763c:	e8 4f 16 00 00       	call   5ffb8c90 <_EnterCriticalSection@4>
5ffb7641:	8b 95 18 ff ff ff    	mov    0xffffff18(%ebp),%edx
5ffb7647:	83 c4 0c             	add    $0xc,%esp
5ffb764a:	8b 5a 74             	mov    0x74(%edx),%ebx
5ffb764d:	eb 16                	jmp    5ffb7665 <_GuiConsoleWndProc@16+0xa5>
5ffb764f:	90                   	nop    
5ffb7650:	8d 53 d8             	lea    0xffffffd8(%ebx),%edx
5ffb7653:	b9 02 00 00 00       	mov    $0x2,%ecx
5ffb7658:	8b 1b                	mov    (%ebx),%ebx
5ffb765a:	e8 a1 9b ff ff       	call   5ffb1200 <@ConioConsoleCtrlEvent@8>
5ffb765f:	8b 95 18 ff ff ff    	mov    0xffffff18(%ebp),%edx
5ffb7665:	8d 42 74             	lea    0x74(%edx),%eax
5ffb7668:	39 d8                	cmp    %ebx,%eax
5ffb766a:	75 e4                	jne    5ffb7650 <_GuiConsoleWndProc@16+0x90>
5ffb766c:	83 ec 0c             	sub    $0xc,%esp
5ffb766f:	8d 42 08             	lea    0x8(%edx),%eax
5ffb7672:	50                   	push   %eax
5ffb7673:	e8 28 16 00 00       	call   5ffb8ca0 <_LeaveCriticalSection@4>
5ffb7678:	83 c4 0c             	add    $0xc,%esp
5ffb767b:	e9 ce 01 00 00       	jmp    5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb7680:	81 fb 01 02 00 00    	cmp    $0x201,%ebx
5ffb7686:	0f 84 d2 01 00 00    	je     5ffb785e <_GuiConsoleWndProc@16+0x29e>
5ffb768c:	0f 87 92 01 00 00    	ja     5ffb7824 <_GuiConsoleWndProc@16+0x264>
5ffb7692:	81 fb 13 01 00 00    	cmp    $0x113,%ebx
5ffb7698:	0f 84 38 03 00 00    	je     5ffb79d6 <_GuiConsoleWndProc@16+0x416>
5ffb769e:	81 fb 00 02 00 00    	cmp    $0x200,%ebx
5ffb76a4:	0f 85 92 01 00 00    	jne    5ffb783c <_GuiConsoleWndProc@16+0x27c>
5ffb76aa:	83 e6 01             	and    $0x1,%esi
5ffb76ad:	0f 84 9b 01 00 00    	je     5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb76b3:	83 ec 0c             	sub    $0xc,%esp
5ffb76b6:	8d 85 f4 fe ff ff    	lea    0xfffffef4(%ebp),%eax
5ffb76bc:	8d 95 f0 fe ff ff    	lea    0xfffffef0(%ebp),%edx
5ffb76c2:	89 f9                	mov    %edi,%ecx
5ffb76c4:	50                   	push   %eax
5ffb76c5:	e8 46 f3 ff ff       	call   5ffb6a10 <@GuiConsoleGetDataPointers@12>
5ffb76ca:	8b 85 f0 fe ff ff    	mov    0xfffffef0(%ebp),%eax
5ffb76d0:	83 c4 0c             	add    $0xc,%esp
5ffb76d3:	85 c0                	test   %eax,%eax
5ffb76d5:	0f 84 73 01 00 00    	je     5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb76db:	8b 8d f4 fe ff ff    	mov    0xfffffef4(%ebp),%ecx
5ffb76e1:	85 c9                	test   %ecx,%ecx
5ffb76e3:	0f 84 65 01 00 00    	je     5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb76e9:	8b 41 50             	mov    0x50(%ecx),%eax
5ffb76ec:	85 c0                	test   %eax,%eax
5ffb76ee:	0f 84 5a 01 00 00    	je     5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb76f4:	8b 59 48             	mov    0x48(%ecx),%ebx
5ffb76f7:	31 f6                	xor    %esi,%esi
5ffb76f9:	89 9d 38 ff ff ff    	mov    %ebx,0xffffff38(%ebp)
5ffb76ff:	8b 51 4c             	mov    0x4c(%ecx),%edx
5ffb7702:	89 95 dc fe ff ff    	mov    %edx,0xfffffedc(%ebp)
5ffb7708:	66 83 7d 14 00       	cmpw   $0x0,0x14(%ebp)
5ffb770d:	78 0c                	js     5ffb771b <_GuiConsoleWndProc@16+0x15b>
5ffb770f:	0f bf 45 14          	movswl 0x14(%ebp),%eax
5ffb7713:	31 d2                	xor    %edx,%edx
5ffb7715:	f7 71 04             	divl   0x4(%ecx)
5ffb7718:	8d 70 01             	lea    0x1(%eax),%esi
5ffb771b:	8b 45 14             	mov    0x14(%ebp),%eax
5ffb771e:	31 d2                	xor    %edx,%edx
5ffb7720:	c1 f8 10             	sar    $0x10,%eax
5ffb7723:	66 85 c0             	test   %ax,%ax
5ffb7726:	78 08                	js     5ffb7730 <_GuiConsoleWndProc@16+0x170>
5ffb7728:	31 d2                	xor    %edx,%edx
5ffb772a:	f7 71 08             	divl   0x8(%ecx)
5ffb772d:	8d 50 01             	lea    0x1(%eax),%edx
5ffb7730:	39 f3                	cmp    %esi,%ebx
5ffb7732:	0f 8c 56 07 00 00    	jl     5ffb7e8e <_GuiConsoleWndProc@16+0x8ce>
5ffb7738:	89 f0                	mov    %esi,%eax
5ffb773a:	48                   	dec    %eax
5ffb773b:	0f 88 6d 07 00 00    	js     5ffb7eae <_GuiConsoleWndProc@16+0x8ee>
5ffb7741:	89 85 38 ff ff ff    	mov    %eax,0xffffff38(%ebp)
5ffb7747:	8d 43 01             	lea    0x1(%ebx),%eax
5ffb774a:	89 85 40 ff ff ff    	mov    %eax,0xffffff40(%ebp)
5ffb7750:	39 95 dc fe ff ff    	cmp    %edx,0xfffffedc(%ebp)
5ffb7756:	0f 8c 1b 07 00 00    	jl     5ffb7e77 <_GuiConsoleWndProc@16+0x8b7>
5ffb775c:	89 d0                	mov    %edx,%eax
5ffb775e:	48                   	dec    %eax
5ffb775f:	0f 88 42 07 00 00    	js     5ffb7ea7 <_GuiConsoleWndProc@16+0x8e7>
5ffb7765:	89 85 3c ff ff ff    	mov    %eax,0xffffff3c(%ebp)
5ffb776b:	8b 85 dc fe ff ff    	mov    0xfffffedc(%ebp),%eax
5ffb7771:	40                   	inc    %eax
5ffb7772:	89 85 44 ff ff ff    	mov    %eax,0xffffff44(%ebp)
5ffb7778:	83 ec 0c             	sub    $0xc,%esp
5ffb777b:	8d 95 38 ff ff ff    	lea    0xffffff38(%ebp),%edx
5ffb7781:	8b 85 f4 fe ff ff    	mov    0xfffffef4(%ebp),%eax
5ffb7787:	50                   	push   %eax
5ffb7788:	89 f9                	mov    %edi,%ecx
5ffb778a:	e8 c1 f3 ff ff       	call   5ffb6b50 <@GuiConsoleUpdateSelection@12>
5ffb778f:	83 c4 0c             	add    $0xc,%esp
5ffb7792:	e9 b7 00 00 00       	jmp    5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb7797:	81 fb 82 00 00 00    	cmp    $0x82,%ebx
5ffb779d:	0f 84 33 04 00 00    	je     5ffb7bd6 <_GuiConsoleWndProc@16+0x616>
5ffb77a3:	8d 83 00 ff ff ff    	lea    0xffffff00(%ebx),%eax
5ffb77a9:	83 f8 02             	cmp    $0x2,%eax
5ffb77ac:	0f 87 8a 00 00 00    	ja     5ffb783c <_GuiConsoleWndProc@16+0x27c>
5ffb77b2:	83 ec 0c             	sub    $0xc,%esp
5ffb77b5:	8d 85 34 ff ff ff    	lea    0xffffff34(%ebp),%eax
5ffb77bb:	8d 95 30 ff ff ff    	lea    0xffffff30(%ebp),%edx
5ffb77c1:	89 f9                	mov    %edi,%ecx
5ffb77c3:	50                   	push   %eax
5ffb77c4:	e8 47 f2 ff ff       	call   5ffb6a10 <@GuiConsoleGetDataPointers@12>
5ffb77c9:	8b 55 14             	mov    0x14(%ebp),%edx
5ffb77cc:	83 c4 0c             	add    $0xc,%esp
5ffb77cf:	89 55 84             	mov    %edx,0xffffff84(%ebp)
5ffb77d2:	81 fb 02 01 00 00    	cmp    $0x102,%ebx
5ffb77d8:	0f 94 c2             	sete   %dl
5ffb77db:	81 fb 04 01 00 00    	cmp    $0x104,%ebx
5ffb77e1:	89 bd 78 ff ff ff    	mov    %edi,0xffffff78(%ebp)
5ffb77e7:	0f 94 c0             	sete   %al
5ffb77ea:	09 d0                	or     %edx,%eax
5ffb77ec:	89 9d 7c ff ff ff    	mov    %ebx,0xffffff7c(%ebp)
5ffb77f2:	89 75 80             	mov    %esi,0xffffff80(%ebp)
5ffb77f5:	a8 01                	test   $0x1,%al
5ffb77f7:	0f 85 f6 00 00 00    	jne    5ffb78f3 <_GuiConsoleWndProc@16+0x333>
5ffb77fd:	50                   	push   %eax
5ffb77fe:	6a 00                	push   $0x0
5ffb7800:	8b 85 30 ff ff ff    	mov    0xffffff30(%ebp),%eax
5ffb7806:	50                   	push   %eax
5ffb7807:	8d 85 78 ff ff ff    	lea    0xffffff78(%ebp),%eax
5ffb780d:	50                   	push   %eax
5ffb780e:	e8 dd b3 ff ff       	call   5ffb2bf0 <_ConioProcessKey@12>
5ffb7813:	58                   	pop    %eax
5ffb7814:	8b 85 ec fe ff ff    	mov    0xfffffeec(%ebp),%eax
5ffb781a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb781d:	5b                   	pop    %ebx
5ffb781e:	5e                   	pop    %esi
5ffb781f:	5f                   	pop    %edi
5ffb7820:	5d                   	pop    %ebp
5ffb7821:	c2 10 00             	ret    $0x10
5ffb7824:	81 fb 02 02 00 00    	cmp    $0x202,%ebx
5ffb782a:	0f 84 31 02 00 00    	je     5ffb7a61 <_GuiConsoleWndProc@16+0x4a1>
5ffb7830:	81 fb 04 02 00 00    	cmp    $0x204,%ebx
5ffb7836:	0f 84 43 03 00 00    	je     5ffb7b7f <_GuiConsoleWndProc@16+0x5bf>
5ffb783c:	8b 45 14             	mov    0x14(%ebp),%eax
5ffb783f:	50                   	push   %eax
5ffb7840:	56                   	push   %esi
5ffb7841:	53                   	push   %ebx
5ffb7842:	57                   	push   %edi
5ffb7843:	e8 d8 17 00 00       	call   5ffb9020 <_DefWindowProcW@16>
5ffb7848:	89 85 ec fe ff ff    	mov    %eax,0xfffffeec(%ebp)
5ffb784e:	8b 85 ec fe ff ff    	mov    0xfffffeec(%ebp),%eax
5ffb7854:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb7857:	5b                   	pop    %ebx
5ffb7858:	5e                   	pop    %esi
5ffb7859:	5f                   	pop    %edi
5ffb785a:	5d                   	pop    %ebp
5ffb785b:	c2 10 00             	ret    $0x10
5ffb785e:	83 ec 0c             	sub    $0xc,%esp
5ffb7861:	8d 85 0c ff ff ff    	lea    0xffffff0c(%ebp),%eax
5ffb7867:	8d 95 08 ff ff ff    	lea    0xffffff08(%ebp),%edx
5ffb786d:	89 f9                	mov    %edi,%ecx
5ffb786f:	50                   	push   %eax
5ffb7870:	e8 9b f1 ff ff       	call   5ffb6a10 <@GuiConsoleGetDataPointers@12>
5ffb7875:	8b 85 08 ff ff ff    	mov    0xffffff08(%ebp),%eax
5ffb787b:	83 c4 0c             	add    $0xc,%esp
5ffb787e:	85 c0                	test   %eax,%eax
5ffb7880:	74 cc                	je     5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb7882:	8b 9d 0c ff ff ff    	mov    0xffffff0c(%ebp),%ebx
5ffb7888:	85 db                	test   %ebx,%ebx
5ffb788a:	74 c2                	je     5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb788c:	0f bf 4d 14          	movswl 0x14(%ebp),%ecx
5ffb7890:	8b 75 14             	mov    0x14(%ebp),%esi
5ffb7893:	89 c8                	mov    %ecx,%eax
5ffb7895:	31 d2                	xor    %edx,%edx
5ffb7897:	83 ec 0c             	sub    $0xc,%esp
5ffb789a:	c1 fe 10             	sar    $0x10,%esi
5ffb789d:	f7 73 04             	divl   0x4(%ebx)
5ffb78a0:	89 75 14             	mov    %esi,0x14(%ebp)
5ffb78a3:	89 85 58 ff ff ff    	mov    %eax,0xffffff58(%ebp)
5ffb78a9:	89 c1                	mov    %eax,%ecx
5ffb78ab:	31 d2                	xor    %edx,%edx
5ffb78ad:	8b 45 14             	mov    0x14(%ebp),%eax
5ffb78b0:	f7 73 08             	divl   0x8(%ebx)
5ffb78b3:	89 85 5c ff ff ff    	mov    %eax,0xffffff5c(%ebp)
5ffb78b9:	8d 51 01             	lea    0x1(%ecx),%edx
5ffb78bc:	40                   	inc    %eax
5ffb78bd:	89 95 60 ff ff ff    	mov    %edx,0xffffff60(%ebp)
5ffb78c3:	89 85 64 ff ff ff    	mov    %eax,0xffffff64(%ebp)
5ffb78c9:	89 4b 48             	mov    %ecx,0x48(%ebx)
5ffb78cc:	8b 85 5c ff ff ff    	mov    0xffffff5c(%ebp),%eax
5ffb78d2:	89 43 4c             	mov    %eax,0x4c(%ebx)
5ffb78d5:	57                   	push   %edi
5ffb78d6:	e8 55 17 00 00       	call   5ffb9030 <_SetCapture@4>
5ffb78db:	8b 85 0c ff ff ff    	mov    0xffffff0c(%ebp),%eax
5ffb78e1:	8d 95 58 ff ff ff    	lea    0xffffff58(%ebp),%edx
5ffb78e7:	c7 40 50 01 00 00 00 	movl   $0x1,0x50(%eax)
5ffb78ee:	e9 94 fe ff ff       	jmp    5ffb7787 <_GuiConsoleWndProc@16+0x1c7>
5ffb78f3:	83 ec 0c             	sub    $0xc,%esp
5ffb78f6:	8b 85 34 ff ff ff    	mov    0xffffff34(%ebp),%eax
5ffb78fc:	31 d2                	xor    %edx,%edx
5ffb78fe:	89 f9                	mov    %edi,%ecx
5ffb7900:	50                   	push   %eax
5ffb7901:	e8 4a f2 ff ff       	call   5ffb6b50 <@GuiConsoleUpdateSelection@12>
5ffb7906:	83 c4 0c             	add    $0xc,%esp
5ffb7909:	e9 ef fe ff ff       	jmp    5ffb77fd <_GuiConsoleWndProc@16+0x23d>
5ffb790e:	8b 45 14             	mov    0x14(%ebp),%eax
5ffb7911:	8b 00                	mov    (%eax),%eax
5ffb7913:	89 85 e8 fe ff ff    	mov    %eax,0xfffffee8(%ebp)
5ffb7919:	52                   	push   %edx
5ffb791a:	0f bf 40 60          	movswl 0x60(%eax),%eax
5ffb791e:	8d 44 00 56          	lea    0x56(%eax,%eax,1),%eax
5ffb7922:	50                   	push   %eax
5ffb7923:	6a 08                	push   $0x8
5ffb7925:	a1 e0 c1 fb 5f       	mov    0x5ffbc1e0,%eax
5ffb792a:	50                   	push   %eax
5ffb792b:	e8 c0 13 00 00       	call   5ffb8cf0 <_HeapAlloc@12>
5ffb7930:	5e                   	pop    %esi
5ffb7931:	85 c0                	test   %eax,%eax
5ffb7933:	89 c6                	mov    %eax,%esi
5ffb7935:	0f 84 1a 02 00 00    	je     5ffb7b55 <_GuiConsoleWndProc@16+0x595>
5ffb793b:	8d 50 18             	lea    0x18(%eax),%edx
5ffb793e:	83 ec 0c             	sub    $0xc,%esp
5ffb7941:	89 95 e0 fe ff ff    	mov    %edx,0xfffffee0(%ebp)
5ffb7947:	52                   	push   %edx
5ffb7948:	e8 33 13 00 00       	call   5ffb8c80 <_InitializeCriticalSection@4>
5ffb794d:	8d 46 54             	lea    0x54(%esi),%eax
5ffb7950:	89 46 0c             	mov    %eax,0xc(%esi)
5ffb7953:	c7 04 24 40 b4 fb 5f 	movl   $0x5ffbb440,(%esp)
5ffb795a:	6a 01                	push   $0x1
5ffb795c:	6a 03                	push   $0x3
5ffb795e:	6a 00                	push   $0x0
5ffb7960:	6a 00                	push   $0x0
5ffb7962:	68 ff 00 00 00       	push   $0xff
5ffb7967:	6a 00                	push   $0x0
5ffb7969:	6a 00                	push   $0x0
5ffb796b:	6a 00                	push   $0x0
5ffb796d:	68 90 01 00 00       	push   $0x190
5ffb7972:	6a 18                	push   $0x18
5ffb7974:	6a 00                	push   $0x0
5ffb7976:	6a 00                	push   $0x0
5ffb7978:	6a 0c                	push   $0xc
5ffb797a:	e8 31 18 00 00       	call   5ffb91b0 <_CreateFontW@56>
5ffb797f:	5a                   	pop    %edx
5ffb7980:	85 c0                	test   %eax,%eax
5ffb7982:	59                   	pop    %ecx
5ffb7983:	89 06                	mov    %eax,(%esi)
5ffb7985:	0f 85 b7 02 00 00    	jne    5ffb7c42 <_GuiConsoleWndProc@16+0x682>
5ffb798b:	50                   	push   %eax
5ffb798c:	6a 5a                	push   $0x5a
5ffb798e:	68 72 b4 fb 5f       	push   $0x5ffbb472
5ffb7993:	68 7f b4 fb 5f       	push   $0x5ffbb47f
5ffb7998:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb799e:	c7 04 24 88 b4 fb 5f 	movl   $0x5ffbb488,(%esp)
5ffb79a5:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb79ab:	83 c4 10             	add    $0x10,%esp
5ffb79ae:	83 ec 0c             	sub    $0xc,%esp
5ffb79b1:	8b 85 e0 fe ff ff    	mov    0xfffffee0(%ebp),%eax
5ffb79b7:	50                   	push   %eax
5ffb79b8:	e8 73 13 00 00       	call   5ffb8d30 <_DeleteCriticalSection@4>
5ffb79bd:	5f                   	pop    %edi
5ffb79be:	58                   	pop    %eax
5ffb79bf:	56                   	push   %esi
5ffb79c0:	6a 00                	push   $0x0
5ffb79c2:	8b 1d e0 c1 fb 5f    	mov    0x5ffbc1e0,%ebx
5ffb79c8:	53                   	push   %ebx
5ffb79c9:	e8 32 13 00 00       	call   5ffb8d00 <_HeapFree@12>
5ffb79ce:	31 c0                	xor    %eax,%eax
5ffb79d0:	59                   	pop    %ecx
5ffb79d1:	e9 72 fe ff ff       	jmp    5ffb7848 <_GuiConsoleWndProc@16+0x288>
5ffb79d6:	83 ec 0c             	sub    $0xc,%esp
5ffb79d9:	8d 85 2c ff ff ff    	lea    0xffffff2c(%ebp),%eax
5ffb79df:	89 f9                	mov    %edi,%ecx
5ffb79e1:	8d 95 28 ff ff ff    	lea    0xffffff28(%ebp),%edx
5ffb79e7:	50                   	push   %eax
5ffb79e8:	e8 23 f0 ff ff       	call   5ffb6a10 <@GuiConsoleGetDataPointers@12>
5ffb79ed:	8b 95 2c ff ff ff    	mov    0xffffff2c(%ebp),%edx
5ffb79f3:	83 c4 0c             	add    $0xc,%esp
5ffb79f6:	8b 42 10             	mov    0x10(%edx),%eax
5ffb79f9:	85 c0                	test   %eax,%eax
5ffb79fb:	0f 94 c0             	sete   %al
5ffb79fe:	25 ff 00 00 00       	and    $0xff,%eax
5ffb7a03:	89 42 10             	mov    %eax,0x10(%edx)
5ffb7a06:	8b 85 28 ff ff ff    	mov    0xffffff28(%ebp),%eax
5ffb7a0c:	8d 95 20 ff ff ff    	lea    0xffffff20(%ebp),%edx
5ffb7a12:	8b 48 38             	mov    0x38(%eax),%ecx
5ffb7a15:	8d 85 24 ff ff ff    	lea    0xffffff24(%ebp),%eax
5ffb7a1b:	50                   	push   %eax
5ffb7a1c:	e8 ef f0 ff ff       	call   5ffb6b10 <@GuiConsoleGetLogicalCursorPos@12>
5ffb7a21:	8b 85 24 ff ff ff    	mov    0xffffff24(%ebp),%eax
5ffb7a27:	8b 95 20 ff ff ff    	mov    0xffffff20(%ebp),%edx
5ffb7a2d:	89 85 6c ff ff ff    	mov    %eax,0xffffff6c(%ebp)
5ffb7a33:	89 85 74 ff ff ff    	mov    %eax,0xffffff74(%ebp)
5ffb7a39:	89 95 68 ff ff ff    	mov    %edx,0xffffff68(%ebp)
5ffb7a3f:	89 95 70 ff ff ff    	mov    %edx,0xffffff70(%ebp)
5ffb7a45:	50                   	push   %eax
5ffb7a46:	50                   	push   %eax
5ffb7a47:	8d 85 68 ff ff ff    	lea    0xffffff68(%ebp),%eax
5ffb7a4d:	50                   	push   %eax
5ffb7a4e:	8b 85 28 ff ff ff    	mov    0xffffff28(%ebp),%eax
5ffb7a54:	50                   	push   %eax
5ffb7a55:	e8 26 f8 ff ff       	call   5ffb7280 <_GuiDrawRegion@8>
5ffb7a5a:	5e                   	pop    %esi
5ffb7a5b:	5f                   	pop    %edi
5ffb7a5c:	e9 ed fd ff ff       	jmp    5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb7a61:	83 ec 0c             	sub    $0xc,%esp
5ffb7a64:	8d 85 04 ff ff ff    	lea    0xffffff04(%ebp),%eax
5ffb7a6a:	8d 95 00 ff ff ff    	lea    0xffffff00(%ebp),%edx
5ffb7a70:	89 f9                	mov    %edi,%ecx
5ffb7a72:	50                   	push   %eax
5ffb7a73:	e8 98 ef ff ff       	call   5ffb6a10 <@GuiConsoleGetDataPointers@12>
5ffb7a78:	8b 9d 00 ff ff ff    	mov    0xffffff00(%ebp),%ebx
5ffb7a7e:	83 c4 0c             	add    $0xc,%esp
5ffb7a81:	85 db                	test   %ebx,%ebx
5ffb7a83:	0f 84 c5 fd ff ff    	je     5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb7a89:	8b 9d 04 ff ff ff    	mov    0xffffff04(%ebp),%ebx
5ffb7a8f:	85 db                	test   %ebx,%ebx
5ffb7a91:	0f 84 b7 fd ff ff    	je     5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb7a97:	83 7b 38 ff          	cmpl   $0xffffffff,0x38(%ebx)
5ffb7a9b:	0f 84 ad fd ff ff    	je     5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb7aa1:	8b 4b 50             	mov    0x50(%ebx),%ecx
5ffb7aa4:	85 c9                	test   %ecx,%ecx
5ffb7aa6:	0f 84 a2 fd ff ff    	je     5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb7aac:	8b 73 48             	mov    0x48(%ebx),%esi
5ffb7aaf:	31 c9                	xor    %ecx,%ecx
5ffb7ab1:	89 b5 48 ff ff ff    	mov    %esi,0xffffff48(%ebp)
5ffb7ab7:	8b 53 4c             	mov    0x4c(%ebx),%edx
5ffb7aba:	89 95 d8 fe ff ff    	mov    %edx,0xfffffed8(%ebp)
5ffb7ac0:	66 83 7d 14 00       	cmpw   $0x0,0x14(%ebp)
5ffb7ac5:	78 0c                	js     5ffb7ad3 <_GuiConsoleWndProc@16+0x513>
5ffb7ac7:	0f bf 45 14          	movswl 0x14(%ebp),%eax
5ffb7acb:	31 d2                	xor    %edx,%edx
5ffb7acd:	f7 73 04             	divl   0x4(%ebx)
5ffb7ad0:	8d 48 01             	lea    0x1(%eax),%ecx
5ffb7ad3:	8b 45 14             	mov    0x14(%ebp),%eax
5ffb7ad6:	31 d2                	xor    %edx,%edx
5ffb7ad8:	c1 f8 10             	sar    $0x10,%eax
5ffb7adb:	66 85 c0             	test   %ax,%ax
5ffb7ade:	78 08                	js     5ffb7ae8 <_GuiConsoleWndProc@16+0x528>
5ffb7ae0:	31 d2                	xor    %edx,%edx
5ffb7ae2:	f7 73 08             	divl   0x8(%ebx)
5ffb7ae5:	8d 50 01             	lea    0x1(%eax),%edx
5ffb7ae8:	39 ce                	cmp    %ecx,%esi
5ffb7aea:	0f 8c 7c 03 00 00    	jl     5ffb7e6c <_GuiConsoleWndProc@16+0x8ac>
5ffb7af0:	89 c8                	mov    %ecx,%eax
5ffb7af2:	48                   	dec    %eax
5ffb7af3:	0f 88 a7 03 00 00    	js     5ffb7ea0 <_GuiConsoleWndProc@16+0x8e0>
5ffb7af9:	89 85 48 ff ff ff    	mov    %eax,0xffffff48(%ebp)
5ffb7aff:	8d 46 01             	lea    0x1(%esi),%eax
5ffb7b02:	89 85 50 ff ff ff    	mov    %eax,0xffffff50(%ebp)
5ffb7b08:	39 95 d8 fe ff ff    	cmp    %edx,0xfffffed8(%ebp)
5ffb7b0e:	0f 8c 41 03 00 00    	jl     5ffb7e55 <_GuiConsoleWndProc@16+0x895>
5ffb7b14:	89 d0                	mov    %edx,%eax
5ffb7b16:	48                   	dec    %eax
5ffb7b17:	0f 88 7c 03 00 00    	js     5ffb7e99 <_GuiConsoleWndProc@16+0x8d9>
5ffb7b1d:	89 85 4c ff ff ff    	mov    %eax,0xffffff4c(%ebp)
5ffb7b23:	8b 85 d8 fe ff ff    	mov    0xfffffed8(%ebp),%eax
5ffb7b29:	40                   	inc    %eax
5ffb7b2a:	89 85 54 ff ff ff    	mov    %eax,0xffffff54(%ebp)
5ffb7b30:	83 ec 0c             	sub    $0xc,%esp
5ffb7b33:	c7 43 50 00 00 00 00 	movl   $0x0,0x50(%ebx)
5ffb7b3a:	8d 95 48 ff ff ff    	lea    0xffffff48(%ebp),%edx
5ffb7b40:	89 f9                	mov    %edi,%ecx
5ffb7b42:	53                   	push   %ebx
5ffb7b43:	e8 08 f0 ff ff       	call   5ffb6b50 <@GuiConsoleUpdateSelection@12>
5ffb7b48:	83 c4 0c             	add    $0xc,%esp
5ffb7b4b:	e8 f0 14 00 00       	call   5ffb9040 <_ReleaseCapture@0>
5ffb7b50:	e9 f9 fc ff ff       	jmp    5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb7b55:	53                   	push   %ebx
5ffb7b56:	6a 4b                	push   $0x4b
5ffb7b58:	68 72 b4 fb 5f       	push   $0x5ffbb472
5ffb7b5d:	68 7f b4 fb 5f       	push   $0x5ffbb47f
5ffb7b62:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb7b68:	c7 04 24 b0 b4 fb 5f 	movl   $0x5ffbb4b0,(%esp)
5ffb7b6f:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb7b75:	83 c4 10             	add    $0x10,%esp
5ffb7b78:	31 c0                	xor    %eax,%eax
5ffb7b7a:	e9 c9 fc ff ff       	jmp    5ffb7848 <_GuiConsoleWndProc@16+0x288>
5ffb7b7f:	83 ec 0c             	sub    $0xc,%esp
5ffb7b82:	8d 85 fc fe ff ff    	lea    0xfffffefc(%ebp),%eax
5ffb7b88:	8d 95 f8 fe ff ff    	lea    0xfffffef8(%ebp),%edx
5ffb7b8e:	89 f9                	mov    %edi,%ecx
5ffb7b90:	50                   	push   %eax
5ffb7b91:	e8 7a ee ff ff       	call   5ffb6a10 <@GuiConsoleGetDataPointers@12>
5ffb7b96:	8b 95 f8 fe ff ff    	mov    0xfffffef8(%ebp),%edx
5ffb7b9c:	83 c4 0c             	add    $0xc,%esp
5ffb7b9f:	85 d2                	test   %edx,%edx
5ffb7ba1:	0f 84 a7 fc ff ff    	je     5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb7ba7:	8b 85 fc fe ff ff    	mov    0xfffffefc(%ebp),%eax
5ffb7bad:	85 c0                	test   %eax,%eax
5ffb7baf:	0f 84 99 fc ff ff    	je     5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb7bb5:	83 78 38 ff          	cmpl   $0xffffffff,0x38(%eax)
5ffb7bb9:	0f 84 8f fc ff ff    	je     5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb7bbf:	83 ec 0c             	sub    $0xc,%esp
5ffb7bc2:	31 d2                	xor    %edx,%edx
5ffb7bc4:	50                   	push   %eax
5ffb7bc5:	e9 be fb ff ff       	jmp    5ffb7788 <_GuiConsoleWndProc@16+0x1c8>
5ffb7bca:	89 f9                	mov    %edi,%ecx
5ffb7bcc:	e8 0f f5 ff ff       	call   5ffb70e0 <@GuiConsoleHandlePaint@4>
5ffb7bd1:	e9 78 fc ff ff       	jmp    5ffb784e <_GuiConsoleWndProc@16+0x28e>
5ffb7bd6:	83 ec 0c             	sub    $0xc,%esp
5ffb7bd9:	8d 95 10 ff ff ff    	lea    0xffffff10(%ebp),%edx
5ffb7bdf:	8d 85 14 ff ff ff    	lea    0xffffff14(%ebp),%eax
5ffb7be5:	89 f9                	mov    %edi,%ecx
5ffb7be7:	50                   	push   %eax
5ffb7be8:	e8 23 ee ff ff       	call   5ffb6a10 <@GuiConsoleGetDataPointers@12>
5ffb7bed:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
5ffb7bf4:	57                   	push   %edi
5ffb7bf5:	e8 56 14 00 00       	call   5ffb9050 <_KillTimer@8>
5ffb7bfa:	53                   	push   %ebx
5ffb7bfb:	8b 85 10 ff ff ff    	mov    0xffffff10(%ebp),%eax
5ffb7c01:	c7 40 64 00 00 00 00 	movl   $0x0,0x64(%eax)
5ffb7c08:	8b 85 14 ff ff ff    	mov    0xffffff14(%ebp),%eax
5ffb7c0e:	8b 48 30             	mov    0x30(%eax),%ecx
5ffb7c11:	51                   	push   %ecx
5ffb7c12:	e8 a9 15 00 00       	call   5ffb91c0 <_DeleteDC@4>
5ffb7c17:	8b 85 14 ff ff ff    	mov    0xffffff14(%ebp),%eax
5ffb7c1d:	83 c0 18             	add    $0x18,%eax
5ffb7c20:	50                   	push   %eax
5ffb7c21:	e8 0a 11 00 00       	call   5ffb8d30 <_DeleteCriticalSection@4>
5ffb7c26:	58                   	pop    %eax
5ffb7c27:	8b 85 14 ff ff ff    	mov    0xffffff14(%ebp),%eax
5ffb7c2d:	5a                   	pop    %edx
5ffb7c2e:	50                   	push   %eax
5ffb7c2f:	6a 00                	push   $0x0
5ffb7c31:	a1 e0 c1 fb 5f       	mov    0x5ffbc1e0,%eax
5ffb7c36:	50                   	push   %eax
5ffb7c37:	e8 c4 10 00 00       	call   5ffb8d00 <_HeapFree@12>
5ffb7c3c:	58                   	pop    %eax
5ffb7c3d:	e9 d2 fb ff ff       	jmp    5ffb7814 <_GuiConsoleWndProc@16+0x254>
5ffb7c42:	83 ec 0c             	sub    $0xc,%esp
5ffb7c45:	57                   	push   %edi
5ffb7c46:	e8 a5 13 00 00       	call   5ffb8ff0 <_GetDC@4>
5ffb7c4b:	83 c4 0c             	add    $0xc,%esp
5ffb7c4e:	89 c3                	mov    %eax,%ebx
5ffb7c50:	85 c0                	test   %eax,%eax
5ffb7c52:	0f 84 ad 01 00 00    	je     5ffb7e05 <_GuiConsoleWndProc@16+0x845>
5ffb7c58:	50                   	push   %eax
5ffb7c59:	50                   	push   %eax
5ffb7c5a:	8b 06                	mov    (%esi),%eax
5ffb7c5c:	50                   	push   %eax
5ffb7c5d:	53                   	push   %ebx
5ffb7c5e:	e8 1d 15 00 00       	call   5ffb9180 <_SelectObject@8>
5ffb7c63:	5a                   	pop    %edx
5ffb7c64:	85 c0                	test   %eax,%eax
5ffb7c66:	59                   	pop    %ecx
5ffb7c67:	89 85 e4 fe ff ff    	mov    %eax,0xfffffee4(%ebp)
5ffb7c6d:	0f 84 ba 01 00 00    	je     5ffb7e2d <_GuiConsoleWndProc@16+0x86d>
5ffb7c73:	50                   	push   %eax
5ffb7c74:	50                   	push   %eax
5ffb7c75:	8d 45 98             	lea    0xffffff98(%ebp),%eax
5ffb7c78:	50                   	push   %eax
5ffb7c79:	53                   	push   %ebx
5ffb7c7a:	e8 51 15 00 00       	call   5ffb91d0 <_GetTextMetricsW@8>
5ffb7c7f:	5a                   	pop    %edx
5ffb7c80:	85 c0                	test   %eax,%eax
5ffb7c82:	59                   	pop    %ecx
5ffb7c83:	75 4f                	jne    5ffb7cd4 <_GuiConsoleWndProc@16+0x714>
5ffb7c85:	51                   	push   %ecx
5ffb7c86:	6a 74                	push   $0x74
5ffb7c88:	68 72 b4 fb 5f       	push   $0x5ffbb472
5ffb7c8d:	68 7f b4 fb 5f       	push   $0x5ffbb47f
5ffb7c92:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb7c98:	c7 04 24 d8 b4 fb 5f 	movl   $0x5ffbb4d8,(%esp)
5ffb7c9f:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb7ca5:	8b 8d e4 fe ff ff    	mov    0xfffffee4(%ebp),%ecx
5ffb7cab:	58                   	pop    %eax
5ffb7cac:	5a                   	pop    %edx
5ffb7cad:	51                   	push   %ecx
5ffb7cae:	53                   	push   %ebx
5ffb7caf:	e8 cc 14 00 00       	call   5ffb9180 <_SelectObject@8>
5ffb7cb4:	58                   	pop    %eax
5ffb7cb5:	5a                   	pop    %edx
5ffb7cb6:	51                   	push   %ecx
5ffb7cb7:	51                   	push   %ecx
5ffb7cb8:	53                   	push   %ebx
5ffb7cb9:	57                   	push   %edi
5ffb7cba:	e8 41 13 00 00       	call   5ffb9000 <_ReleaseDC@8>
5ffb7cbf:	58                   	pop    %eax
5ffb7cc0:	5a                   	pop    %edx
5ffb7cc1:	83 ec 0c             	sub    $0xc,%esp
5ffb7cc4:	8b 06                	mov    (%esi),%eax
5ffb7cc6:	50                   	push   %eax
5ffb7cc7:	e8 84 14 00 00       	call   5ffb9150 <_DeleteObject@4>
5ffb7ccc:	83 c4 0c             	add    $0xc,%esp
5ffb7ccf:	e9 da fc ff ff       	jmp    5ffb79ae <_GuiConsoleWndProc@16+0x3ee>
5ffb7cd4:	8b 45 b0             	mov    0xffffffb0(%ebp),%eax
5ffb7cd7:	8b 55 98             	mov    0xffffff98(%ebp),%edx
5ffb7cda:	89 46 04             	mov    %eax,0x4(%esi)
5ffb7cdd:	8b 45 a8             	mov    0xffffffa8(%ebp),%eax
5ffb7ce0:	01 d0                	add    %edx,%eax
5ffb7ce2:	89 46 08             	mov    %eax,0x8(%esi)
5ffb7ce5:	50                   	push   %eax
5ffb7ce6:	50                   	push   %eax
5ffb7ce7:	8b 85 e4 fe ff ff    	mov    0xfffffee4(%ebp),%eax
5ffb7ced:	50                   	push   %eax
5ffb7cee:	53                   	push   %ebx
5ffb7cef:	e8 8c 14 00 00       	call   5ffb9180 <_SelectObject@8>
5ffb7cf4:	50                   	push   %eax
5ffb7cf5:	53                   	push   %ebx
5ffb7cf6:	e8 e5 14 00 00       	call   5ffb91e0 <_CreateCompatibleDC@4>
5ffb7cfb:	5a                   	pop    %edx
5ffb7cfc:	8b 95 e8 fe ff ff    	mov    0xfffffee8(%ebp),%edx
5ffb7d02:	59                   	pop    %ecx
5ffb7d03:	89 46 30             	mov    %eax,0x30(%esi)
5ffb7d06:	0f bf 42 62          	movswl 0x62(%edx),%eax
5ffb7d0a:	8b 4e 08             	mov    0x8(%esi),%ecx
5ffb7d0d:	0f af c1             	imul   %ecx,%eax
5ffb7d10:	50                   	push   %eax
5ffb7d11:	0f bf 42 60          	movswl 0x60(%edx),%eax
5ffb7d15:	8b 4e 04             	mov    0x4(%esi),%ecx
5ffb7d18:	0f af c1             	imul   %ecx,%eax
5ffb7d1b:	50                   	push   %eax
5ffb7d1c:	53                   	push   %ebx
5ffb7d1d:	e8 ce 14 00 00       	call   5ffb91f0 <_CreateCompatibleBitmap@12>
5ffb7d22:	52                   	push   %edx
5ffb7d23:	89 46 34             	mov    %eax,0x34(%esi)
5ffb7d26:	50                   	push   %eax
5ffb7d27:	8b 46 30             	mov    0x30(%esi),%eax
5ffb7d2a:	50                   	push   %eax
5ffb7d2b:	e8 50 14 00 00       	call   5ffb9180 <_SelectObject@8>
5ffb7d30:	8b 06                	mov    (%esi),%eax
5ffb7d32:	50                   	push   %eax
5ffb7d33:	8b 46 30             	mov    0x30(%esi),%eax
5ffb7d36:	50                   	push   %eax
5ffb7d37:	e8 44 14 00 00       	call   5ffb9180 <_SelectObject@8>
5ffb7d3c:	53                   	push   %ebx
5ffb7d3d:	57                   	push   %edi
5ffb7d3e:	e8 bd 12 00 00       	call   5ffb9000 <_ReleaseDC@8>
5ffb7d43:	8b 85 e8 fe ff ff    	mov    0xfffffee8(%ebp),%eax
5ffb7d49:	c7 46 10 01 00 00 00 	movl   $0x1,0x10(%esi)
5ffb7d50:	c7 46 14 00 00 00 00 	movl   $0x0,0x14(%esi)
5ffb7d57:	c7 46 38 ff ff ff ff 	movl   $0xffffffff,0x38(%esi)
5ffb7d5e:	89 70 64             	mov    %esi,0x64(%eax)
5ffb7d61:	89 04 24             	mov    %eax,(%esp)
5ffb7d64:	6a eb                	push   $0xffffffeb
5ffb7d66:	57                   	push   %edi
5ffb7d67:	e8 f4 12 00 00       	call   5ffb9060 <_SetWindowLongW@12>
5ffb7d6c:	50                   	push   %eax
5ffb7d6d:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
5ffb7d70:	50                   	push   %eax
5ffb7d71:	57                   	push   %edi
5ffb7d72:	e8 f9 12 00 00       	call   5ffb9070 <_GetWindowRect@8>
5ffb7d77:	53                   	push   %ebx
5ffb7d78:	8b 95 e8 fe ff ff    	mov    0xfffffee8(%ebp),%edx
5ffb7d7e:	8b 4e 04             	mov    0x4(%esi),%ecx
5ffb7d81:	0f bf 5a 60          	movswl 0x60(%edx),%ebx
5ffb7d85:	0f af d9             	imul   %ecx,%ebx
5ffb7d88:	6a 07                	push   $0x7
5ffb7d8a:	e8 f1 12 00 00       	call   5ffb9080 <_GetSystemMetrics@4>
5ffb7d8f:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
5ffb7d92:	8d 04 43             	lea    (%ebx,%eax,2),%eax
5ffb7d95:	01 d0                	add    %edx,%eax
5ffb7d97:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
5ffb7d9a:	8b 85 e8 fe ff ff    	mov    0xfffffee8(%ebp),%eax
5ffb7da0:	0f bf 58 62          	movswl 0x62(%eax),%ebx
5ffb7da4:	8b 46 08             	mov    0x8(%esi),%eax
5ffb7da7:	6a 08                	push   $0x8
5ffb7da9:	0f af d8             	imul   %eax,%ebx
5ffb7dac:	e8 cf 12 00 00       	call   5ffb9080 <_GetSystemMetrics@4>
5ffb7db1:	8b 75 dc             	mov    0xffffffdc(%ebp),%esi
5ffb7db4:	8d 1c 43             	lea    (%ebx,%eax,2),%ebx
5ffb7db7:	6a 04                	push   $0x4
5ffb7db9:	e8 c2 12 00 00       	call   5ffb9080 <_GetSystemMetrics@4>
5ffb7dbe:	01 f3                	add    %esi,%ebx
5ffb7dc0:	8d 04 03             	lea    (%ebx,%eax,1),%eax
5ffb7dc3:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
5ffb7dc6:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
5ffb7dcd:	8b 4d dc             	mov    0xffffffdc(%ebp),%ecx
5ffb7dd0:	29 c8                	sub    %ecx,%eax
5ffb7dd2:	50                   	push   %eax
5ffb7dd3:	8b 55 d8             	mov    0xffffffd8(%ebp),%edx
5ffb7dd6:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
5ffb7dd9:	29 d0                	sub    %edx,%eax
5ffb7ddb:	50                   	push   %eax
5ffb7ddc:	51                   	push   %ecx
5ffb7ddd:	52                   	push   %edx
5ffb7dde:	57                   	push   %edi
5ffb7ddf:	e8 ac 12 00 00       	call   5ffb9090 <_MoveWindow@24>
5ffb7de4:	59                   	pop    %ecx
5ffb7de5:	5b                   	pop    %ebx
5ffb7de6:	6a 00                	push   $0x0
5ffb7de8:	68 f4 01 00 00       	push   $0x1f4
5ffb7ded:	6a 01                	push   $0x1
5ffb7def:	57                   	push   %edi
5ffb7df0:	e8 ab 12 00 00       	call   5ffb90a0 <_SetTimer@16>
5ffb7df5:	8b 55 14             	mov    0x14(%ebp),%edx
5ffb7df8:	52                   	push   %edx
5ffb7df9:	6a 00                	push   $0x0
5ffb7dfb:	68 81 00 00 00       	push   $0x81
5ffb7e00:	e9 3d fa ff ff       	jmp    5ffb7842 <_GuiConsoleWndProc@16+0x282>
5ffb7e05:	50                   	push   %eax
5ffb7e06:	6a 62                	push   $0x62
5ffb7e08:	68 72 b4 fb 5f       	push   $0x5ffbb472
5ffb7e0d:	68 7f b4 fb 5f       	push   $0x5ffbb47f
5ffb7e12:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb7e18:	c7 04 24 04 b5 fb 5f 	movl   $0x5ffbb504,(%esp)
5ffb7e1f:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb7e25:	83 c4 10             	add    $0x10,%esp
5ffb7e28:	e9 94 fe ff ff       	jmp    5ffb7cc1 <_GuiConsoleWndProc@16+0x701>
5ffb7e2d:	50                   	push   %eax
5ffb7e2e:	6a 6b                	push   $0x6b
5ffb7e30:	68 72 b4 fb 5f       	push   $0x5ffbb472
5ffb7e35:	68 7f b4 fb 5f       	push   $0x5ffbb47f
5ffb7e3a:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb7e40:	c7 04 24 28 b5 fb 5f 	movl   $0x5ffbb528,(%esp)
5ffb7e47:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb7e4d:	83 c4 10             	add    $0x10,%esp
5ffb7e50:	e9 61 fe ff ff       	jmp    5ffb7cb6 <_GuiConsoleWndProc@16+0x6f6>
5ffb7e55:	8b 85 d8 fe ff ff    	mov    0xfffffed8(%ebp),%eax
5ffb7e5b:	89 95 54 ff ff ff    	mov    %edx,0xffffff54(%ebp)
5ffb7e61:	89 85 4c ff ff ff    	mov    %eax,0xffffff4c(%ebp)
5ffb7e67:	e9 c4 fc ff ff       	jmp    5ffb7b30 <_GuiConsoleWndProc@16+0x570>
5ffb7e6c:	89 8d 50 ff ff ff    	mov    %ecx,0xffffff50(%ebp)
5ffb7e72:	e9 91 fc ff ff       	jmp    5ffb7b08 <_GuiConsoleWndProc@16+0x548>
5ffb7e77:	8b 85 dc fe ff ff    	mov    0xfffffedc(%ebp),%eax
5ffb7e7d:	89 95 44 ff ff ff    	mov    %edx,0xffffff44(%ebp)
5ffb7e83:	89 85 3c ff ff ff    	mov    %eax,0xffffff3c(%ebp)
5ffb7e89:	e9 ea f8 ff ff       	jmp    5ffb7778 <_GuiConsoleWndProc@16+0x1b8>
5ffb7e8e:	89 b5 40 ff ff ff    	mov    %esi,0xffffff40(%ebp)
5ffb7e94:	e9 b7 f8 ff ff       	jmp    5ffb7750 <_GuiConsoleWndProc@16+0x190>
5ffb7e99:	31 c0                	xor    %eax,%eax
5ffb7e9b:	e9 7d fc ff ff       	jmp    5ffb7b1d <_GuiConsoleWndProc@16+0x55d>
5ffb7ea0:	31 c0                	xor    %eax,%eax
5ffb7ea2:	e9 52 fc ff ff       	jmp    5ffb7af9 <_GuiConsoleWndProc@16+0x539>
5ffb7ea7:	31 c0                	xor    %eax,%eax
5ffb7ea9:	e9 b7 f8 ff ff       	jmp    5ffb7765 <_GuiConsoleWndProc@16+0x1a5>
5ffb7eae:	31 c0                	xor    %eax,%eax
5ffb7eb0:	e9 8c f8 ff ff       	jmp    5ffb7741 <_GuiConsoleWndProc@16+0x181>
5ffb7eb5:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb7eb9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb7ec0 <_GuiConsoleNotifyWndProc@16>:
5ffb7ec0:	55                   	push   %ebp
5ffb7ec1:	89 e5                	mov    %esp,%ebp
5ffb7ec3:	57                   	push   %edi
5ffb7ec4:	56                   	push   %esi
5ffb7ec5:	53                   	push   %ebx
5ffb7ec6:	83 ec 2c             	sub    $0x2c,%esp
5ffb7ec9:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb7ecc:	8b 7d 08             	mov    0x8(%ebp),%edi
5ffb7ecf:	8b 75 14             	mov    0x14(%ebp),%esi
5ffb7ed2:	3d 01 80 00 00       	cmp    $0x8001,%eax
5ffb7ed7:	74 47                	je     5ffb7f20 <_GuiConsoleNotifyWndProc@16+0x60>
5ffb7ed9:	76 25                	jbe    5ffb7f00 <_GuiConsoleNotifyWndProc@16+0x40>
5ffb7edb:	3d 02 80 00 00       	cmp    $0x8002,%eax
5ffb7ee0:	0f 84 aa 00 00 00    	je     5ffb7f90 <_GuiConsoleNotifyWndProc@16+0xd0>
5ffb7ee6:	56                   	push   %esi
5ffb7ee7:	8b 4d 10             	mov    0x10(%ebp),%ecx
5ffb7eea:	51                   	push   %ecx
5ffb7eeb:	50                   	push   %eax
5ffb7eec:	57                   	push   %edi
5ffb7eed:	e8 2e 11 00 00       	call   5ffb9020 <_DefWindowProcW@16>
5ffb7ef2:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb7ef5:	5b                   	pop    %ebx
5ffb7ef6:	5e                   	pop    %esi
5ffb7ef7:	5f                   	pop    %edi
5ffb7ef8:	5d                   	pop    %ebp
5ffb7ef9:	c2 10 00             	ret    $0x10
5ffb7efc:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb7f00:	83 f8 01             	cmp    $0x1,%eax
5ffb7f03:	75 e1                	jne    5ffb7ee6 <_GuiConsoleNotifyWndProc@16+0x26>
5ffb7f05:	56                   	push   %esi
5ffb7f06:	6a 00                	push   $0x0
5ffb7f08:	6a eb                	push   $0xffffffeb
5ffb7f0a:	57                   	push   %edi
5ffb7f0b:	e8 50 11 00 00       	call   5ffb9060 <_SetWindowLongW@12>
5ffb7f10:	31 c0                	xor    %eax,%eax
5ffb7f12:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb7f15:	5b                   	pop    %ebx
5ffb7f16:	5e                   	pop    %esi
5ffb7f17:	5f                   	pop    %edi
5ffb7f18:	5d                   	pop    %ebp
5ffb7f19:	c2 10 00             	ret    $0x10
5ffb7f1c:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb7f20:	56                   	push   %esi
5ffb7f21:	53                   	push   %ebx
5ffb7f22:	53                   	push   %ebx
5ffb7f23:	6a 00                	push   $0x0
5ffb7f25:	e8 a6 0e 00 00       	call   5ffb8dd0 <_GetModuleHandleW@4>
5ffb7f2a:	5a                   	pop    %edx
5ffb7f2b:	59                   	pop    %ecx
5ffb7f2c:	50                   	push   %eax
5ffb7f2d:	6a 00                	push   $0x0
5ffb7f2f:	6a 00                	push   $0x0
5ffb7f31:	68 00 00 00 80       	push   $0x80000000
5ffb7f36:	68 00 00 00 80       	push   $0x80000000
5ffb7f3b:	68 00 00 00 80       	push   $0x80000000
5ffb7f40:	68 00 00 00 80       	push   $0x80000000
5ffb7f45:	68 00 00 ca 00       	push   $0xca0000
5ffb7f4a:	8b 46 44             	mov    0x44(%esi),%eax
5ffb7f4d:	50                   	push   %eax
5ffb7f4e:	68 54 b5 fb 5f       	push   $0x5ffbb554
5ffb7f53:	6a 00                	push   $0x0
5ffb7f55:	e8 f6 0f 00 00       	call   5ffb8f50 <_CreateWindowExW@48>
5ffb7f5a:	89 c3                	mov    %eax,%ebx
5ffb7f5c:	85 c0                	test   %eax,%eax
5ffb7f5e:	89 46 58             	mov    %eax,0x58(%esi)
5ffb7f61:	74 21                	je     5ffb7f84 <_GuiConsoleNotifyWndProc@16+0xc4>
5ffb7f63:	56                   	push   %esi
5ffb7f64:	56                   	push   %esi
5ffb7f65:	6a eb                	push   $0xffffffeb
5ffb7f67:	57                   	push   %edi
5ffb7f68:	e8 53 10 00 00       	call   5ffb8fc0 <_GetWindowLongW@8>
5ffb7f6d:	40                   	inc    %eax
5ffb7f6e:	89 04 24             	mov    %eax,(%esp)
5ffb7f71:	6a eb                	push   $0xffffffeb
5ffb7f73:	57                   	push   %edi
5ffb7f74:	e8 e7 10 00 00       	call   5ffb9060 <_SetWindowLongW@12>
5ffb7f79:	51                   	push   %ecx
5ffb7f7a:	6a 05                	push   $0x5
5ffb7f7c:	53                   	push   %ebx
5ffb7f7d:	e8 2e 11 00 00       	call   5ffb90b0 <_ShowWindow@8>
5ffb7f82:	58                   	pop    %eax
5ffb7f83:	5a                   	pop    %edx
5ffb7f84:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb7f87:	89 d8                	mov    %ebx,%eax
5ffb7f89:	5b                   	pop    %ebx
5ffb7f8a:	5e                   	pop    %esi
5ffb7f8b:	5f                   	pop    %edi
5ffb7f8c:	5d                   	pop    %ebp
5ffb7f8d:	c2 10 00             	ret    $0x10
5ffb7f90:	8d 5d c8             	lea    0xffffffc8(%ebp),%ebx
5ffb7f93:	eb 12                	jmp    5ffb7fa7 <_GuiConsoleNotifyWndProc@16+0xe7>
5ffb7f95:	83 ec 0c             	sub    $0xc,%esp
5ffb7f98:	53                   	push   %ebx
5ffb7f99:	e8 12 0f 00 00       	call   5ffb8eb0 <_TranslateMessage@4>
5ffb7f9e:	53                   	push   %ebx
5ffb7f9f:	e8 bc 0f 00 00       	call   5ffb8f60 <_DispatchMessageW@4>
5ffb7fa4:	83 c4 0c             	add    $0xc,%esp
5ffb7fa7:	83 ec 0c             	sub    $0xc,%esp
5ffb7faa:	6a 01                	push   $0x1
5ffb7fac:	6a 00                	push   $0x0
5ffb7fae:	6a 00                	push   $0x0
5ffb7fb0:	6a 00                	push   $0x0
5ffb7fb2:	53                   	push   %ebx
5ffb7fb3:	e8 b8 0e 00 00       	call   5ffb8e70 <_PeekMessageW@20>
5ffb7fb8:	83 c4 0c             	add    $0xc,%esp
5ffb7fbb:	85 c0                	test   %eax,%eax
5ffb7fbd:	75 d6                	jne    5ffb7f95 <_GuiConsoleNotifyWndProc@16+0xd5>
5ffb7fbf:	83 ec 0c             	sub    $0xc,%esp
5ffb7fc2:	8b 46 58             	mov    0x58(%esi),%eax
5ffb7fc5:	50                   	push   %eax
5ffb7fc6:	e8 f5 10 00 00       	call   5ffb90c0 <_DestroyWindow@4>
5ffb7fcb:	c7 46 58 00 00 00 00 	movl   $0x0,0x58(%esi)
5ffb7fd2:	c7 04 24 eb ff ff ff 	movl   $0xffffffeb,(%esp)
5ffb7fd9:	57                   	push   %edi
5ffb7fda:	e8 e1 0f 00 00       	call   5ffb8fc0 <_GetWindowLongW@8>
5ffb7fdf:	89 c3                	mov    %eax,%ebx
5ffb7fe1:	4b                   	dec    %ebx
5ffb7fe2:	89 1c 24             	mov    %ebx,(%esp)
5ffb7fe5:	6a eb                	push   $0xffffffeb
5ffb7fe7:	57                   	push   %edi
5ffb7fe8:	e8 73 10 00 00       	call   5ffb9060 <_SetWindowLongW@12>
5ffb7fed:	85 db                	test   %ebx,%ebx
5ffb7fef:	5e                   	pop    %esi
5ffb7ff0:	0f 85 1a ff ff ff    	jne    5ffb7f10 <_GuiConsoleNotifyWndProc@16+0x50>
5ffb7ff6:	83 ec 0c             	sub    $0xc,%esp
5ffb7ff9:	c7 05 70 c1 fb 5f 00 	movl   $0x0,0x5ffbc170
5ffb8000:	00 00 00 
5ffb8003:	57                   	push   %edi
5ffb8004:	e8 b7 10 00 00       	call   5ffb90c0 <_DestroyWindow@4>
5ffb8009:	6a ff                	push   $0xffffffff
5ffb800b:	e8 30 0e 00 00       	call   5ffb8e40 <_PrivateCsrssManualGuiCheck@4>
5ffb8010:	6a 00                	push   $0x0
5ffb8012:	e8 b9 10 00 00       	call   5ffb90d0 <_PostQuitMessage@4>
5ffb8017:	31 c0                	xor    %eax,%eax
5ffb8019:	83 c4 0c             	add    $0xc,%esp
5ffb801c:	e9 f1 fe ff ff       	jmp    5ffb7f12 <_GuiConsoleNotifyWndProc@16+0x52>
5ffb8021:	eb 0d                	jmp    5ffb8030 <_GuiConsoleGuiThread@4>
5ffb8023:	90                   	nop    
5ffb8024:	90                   	nop    
5ffb8025:	90                   	nop    
5ffb8026:	90                   	nop    
5ffb8027:	90                   	nop    
5ffb8028:	90                   	nop    
5ffb8029:	90                   	nop    
5ffb802a:	90                   	nop    
5ffb802b:	90                   	nop    
5ffb802c:	90                   	nop    
5ffb802d:	90                   	nop    
5ffb802e:	90                   	nop    
5ffb802f:	90                   	nop    

5ffb8030 <_GuiConsoleGuiThread@4>:
5ffb8030:	55                   	push   %ebp
5ffb8031:	89 e5                	mov    %esp,%ebp
5ffb8033:	53                   	push   %ebx
5ffb8034:	83 ec 24             	sub    $0x24,%esp
5ffb8037:	8b 5d 08             	mov    0x8(%ebp),%ebx
5ffb803a:	6a 00                	push   $0x0
5ffb803c:	50                   	push   %eax
5ffb803d:	50                   	push   %eax
5ffb803e:	6a 00                	push   $0x0
5ffb8040:	e8 8b 0d 00 00       	call   5ffb8dd0 <_GetModuleHandleW@4>
5ffb8045:	5a                   	pop    %edx
5ffb8046:	59                   	pop    %ecx
5ffb8047:	50                   	push   %eax
5ffb8048:	6a 00                	push   $0x0
5ffb804a:	6a 00                	push   $0x0
5ffb804c:	68 00 00 00 80       	push   $0x80000000
5ffb8051:	68 00 00 00 80       	push   $0x80000000
5ffb8056:	68 00 00 00 80       	push   $0x80000000
5ffb805b:	68 00 00 00 80       	push   $0x80000000
5ffb8060:	68 00 00 cf 00       	push   $0xcf0000
5ffb8065:	68 7a b5 fb 5f       	push   $0x5ffbb57a
5ffb806a:	68 7c b5 fb 5f       	push   $0x5ffbb57c
5ffb806f:	6a 00                	push   $0x0
5ffb8071:	e8 da 0e 00 00       	call   5ffb8f50 <_CreateWindowExW@48>
5ffb8076:	a3 70 c1 fb 5f       	mov    %eax,0x5ffbc170
5ffb807b:	85 c0                	test   %eax,%eax
5ffb807d:	75 1e                	jne    5ffb809d <_GuiConsoleGuiThread@4+0x6d>
5ffb807f:	83 ec 0c             	sub    $0xc,%esp
5ffb8082:	6a ff                	push   $0xffffffff
5ffb8084:	e8 b7 0d 00 00       	call   5ffb8e40 <_PrivateCsrssManualGuiCheck@4>
5ffb8089:	8b 03                	mov    (%ebx),%eax
5ffb808b:	50                   	push   %eax
5ffb808c:	e8 ef 0c 00 00       	call   5ffb8d80 <_SetEvent@4>
5ffb8091:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb8096:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb8099:	c9                   	leave  
5ffb809a:	c2 04 00             	ret    $0x4
5ffb809d:	83 ec 0c             	sub    $0xc,%esp
5ffb80a0:	8b 03                	mov    (%ebx),%eax
5ffb80a2:	8d 5d d8             	lea    0xffffffd8(%ebp),%ebx
5ffb80a5:	50                   	push   %eax
5ffb80a6:	e8 d5 0c 00 00       	call   5ffb8d80 <_SetEvent@4>
5ffb80ab:	83 c4 0c             	add    $0xc,%esp
5ffb80ae:	eb 12                	jmp    5ffb80c2 <_GuiConsoleGuiThread@4+0x92>
5ffb80b0:	83 ec 0c             	sub    $0xc,%esp
5ffb80b3:	53                   	push   %ebx
5ffb80b4:	e8 f7 0d 00 00       	call   5ffb8eb0 <_TranslateMessage@4>
5ffb80b9:	53                   	push   %ebx
5ffb80ba:	e8 a1 0e 00 00       	call   5ffb8f60 <_DispatchMessageW@4>
5ffb80bf:	83 c4 0c             	add    $0xc,%esp
5ffb80c2:	6a 00                	push   $0x0
5ffb80c4:	6a 00                	push   $0x0
5ffb80c6:	6a 00                	push   $0x0
5ffb80c8:	53                   	push   %ebx
5ffb80c9:	e8 d2 0d 00 00       	call   5ffb8ea0 <_GetMessageW@16>
5ffb80ce:	85 c0                	test   %eax,%eax
5ffb80d0:	75 de                	jne    5ffb80b0 <_GuiConsoleGuiThread@4+0x80>
5ffb80d2:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb80d7:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb80da:	c9                   	leave  
5ffb80db:	c2 04 00             	ret    $0x4
5ffb80de:	89 f6                	mov    %esi,%esi

5ffb80e0 <_GuiInitScreenBuffer@8>:
5ffb80e0:	55                   	push   %ebp
5ffb80e1:	89 e5                	mov    %esp,%ebp
5ffb80e3:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb80e6:	c6 40 34 0f          	movb   $0xf,0x34(%eax)
5ffb80ea:	5d                   	pop    %ebp
5ffb80eb:	c2 08 00             	ret    $0x8
5ffb80ee:	89 f6                	mov    %esi,%esi

5ffb80f0 <_GuiChangeTitle@4>:
5ffb80f0:	55                   	push   %ebp
5ffb80f1:	89 e5                	mov    %esp,%ebp
5ffb80f3:	51                   	push   %ecx
5ffb80f4:	51                   	push   %ecx
5ffb80f5:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb80f8:	8b 50 44             	mov    0x44(%eax),%edx
5ffb80fb:	52                   	push   %edx
5ffb80fc:	6a 00                	push   $0x0
5ffb80fe:	6a 0c                	push   $0xc
5ffb8100:	8b 40 58             	mov    0x58(%eax),%eax
5ffb8103:	50                   	push   %eax
5ffb8104:	e8 87 0e 00 00       	call   5ffb8f90 <_SendMessageW@16>
5ffb8109:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb810e:	c9                   	leave  
5ffb810f:	c2 04 00             	ret    $0x4
5ffb8112:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
5ffb8119:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb8120 <_GuiChangeIcon@4>:
5ffb8120:	55                   	push   %ebp
5ffb8121:	89 e5                	mov    %esp,%ebp
5ffb8123:	53                   	push   %ebx
5ffb8124:	50                   	push   %eax
5ffb8125:	8b 5d 08             	mov    0x8(%ebp),%ebx
5ffb8128:	8b 43 5c             	mov    0x5c(%ebx),%eax
5ffb812b:	50                   	push   %eax
5ffb812c:	6a 01                	push   $0x1
5ffb812e:	68 80 00 00 00       	push   $0x80
5ffb8133:	8b 43 58             	mov    0x58(%ebx),%eax
5ffb8136:	50                   	push   %eax
5ffb8137:	e8 54 0e 00 00       	call   5ffb8f90 <_SendMessageW@16>
5ffb813c:	8b 43 5c             	mov    0x5c(%ebx),%eax
5ffb813f:	50                   	push   %eax
5ffb8140:	6a 00                	push   $0x0
5ffb8142:	68 80 00 00 00       	push   $0x80
5ffb8147:	8b 5b 58             	mov    0x58(%ebx),%ebx
5ffb814a:	53                   	push   %ebx
5ffb814b:	e8 40 0e 00 00       	call   5ffb8f90 <_SendMessageW@16>
5ffb8150:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb8155:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb8158:	c9                   	leave  
5ffb8159:	c2 04 00             	ret    $0x4
5ffb815c:	8d 74 26 00          	lea    0x0(%esi),%esi

5ffb8160 <_GuiCleanupConsole@4>:
5ffb8160:	55                   	push   %ebp
5ffb8161:	89 e5                	mov    %esp,%ebp
5ffb8163:	52                   	push   %edx
5ffb8164:	52                   	push   %edx
5ffb8165:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb8168:	50                   	push   %eax
5ffb8169:	a1 70 c1 fb 5f       	mov    0x5ffbc170,%eax
5ffb816e:	6a 00                	push   $0x0
5ffb8170:	68 02 80 00 00       	push   $0x8002
5ffb8175:	50                   	push   %eax
5ffb8176:	e8 15 0e 00 00       	call   5ffb8f90 <_SendMessageW@16>
5ffb817b:	c9                   	leave  
5ffb817c:	c2 04 00             	ret    $0x4
5ffb817f:	90                   	nop    

5ffb8180 <@GuiInitConsole@4>:
5ffb8180:	55                   	push   %ebp
5ffb8181:	89 e5                	mov    %esp,%ebp
5ffb8183:	56                   	push   %esi
5ffb8184:	53                   	push   %ebx
5ffb8185:	89 ce                	mov    %ecx,%esi
5ffb8187:	83 ec 40             	sub    $0x40,%esp
5ffb818a:	a1 60 c1 fb 5f       	mov    0x5ffbc160,%eax
5ffb818f:	85 c0                	test   %eax,%eax
5ffb8191:	0f 85 6a 01 00 00    	jne    5ffb8301 <@GuiInitConsole@4+0x181>
5ffb8197:	a1 70 c1 fb 5f       	mov    0x5ffbc170,%eax
5ffb819c:	c7 05 60 c1 fb 5f 01 	movl   $0x1,0x5ffbc160
5ffb81a3:	00 00 00 
5ffb81a6:	85 c0                	test   %eax,%eax
5ffb81a8:	0f 84 03 02 00 00    	je     5ffb83b1 <@GuiInitConsole@4+0x231>
5ffb81ae:	83 ec 0c             	sub    $0xc,%esp
5ffb81b1:	c7 45 c8 30 00 00 00 	movl   $0x30,0xffffffc8(%ebp)
5ffb81b8:	c7 45 f0 7c b5 fb 5f 	movl   $0x5ffbb57c,0xfffffff0(%ebp)
5ffb81bf:	c7 45 d0 c0 7e fb 5f 	movl   $0x5ffb7ec0,0xffffffd0(%ebp)
5ffb81c6:	c7 45 cc 00 00 00 00 	movl   $0x0,0xffffffcc(%ebp)
5ffb81cd:	6a 00                	push   $0x0
5ffb81cf:	e8 fc 0b 00 00       	call   5ffb8dd0 <_GetModuleHandleW@4>
5ffb81d4:	8d 5d c8             	lea    0xffffffc8(%ebp),%ebx
5ffb81d7:	c7 45 e0 00 00 00 00 	movl   $0x0,0xffffffe0(%ebp)
5ffb81de:	c7 45 e4 00 00 00 00 	movl   $0x0,0xffffffe4(%ebp)
5ffb81e5:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
5ffb81e8:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
5ffb81ef:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
5ffb81f6:	c7 45 d4 00 00 00 00 	movl   $0x0,0xffffffd4(%ebp)
5ffb81fd:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
5ffb8204:	c7 45 f4 00 00 00 00 	movl   $0x0,0xfffffff4(%ebp)
5ffb820b:	53                   	push   %ebx
5ffb820c:	e8 6f 0d 00 00       	call   5ffb8f80 <_RegisterClassExW@4>
5ffb8211:	83 c4 0c             	add    $0xc,%esp
5ffb8214:	66 85 c0             	test   %ax,%ax
5ffb8217:	75 3e                	jne    5ffb8257 <@GuiInitConsole@4+0xd7>
5ffb8219:	50                   	push   %eax
5ffb821a:	68 88 03 00 00       	push   $0x388
5ffb821f:	68 72 b4 fb 5f       	push   $0x5ffbb472
5ffb8224:	68 7f b4 fb 5f       	push   $0x5ffbb47f
5ffb8229:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb822f:	c7 04 24 a8 b5 fb 5f 	movl   $0x5ffbb5a8,(%esp)
5ffb8236:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb823c:	83 c4 10             	add    $0x10,%esp
5ffb823f:	c7 05 60 c1 fb 5f 00 	movl   $0x0,0x5ffbc160
5ffb8246:	00 00 00 
5ffb8249:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
5ffb824e:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb8251:	89 d0                	mov    %edx,%eax
5ffb8253:	5b                   	pop    %ebx
5ffb8254:	5e                   	pop    %esi
5ffb8255:	5d                   	pop    %ebp
5ffb8256:	c3                   	ret    
5ffb8257:	83 ec 0c             	sub    $0xc,%esp
5ffb825a:	c7 45 c8 30 00 00 00 	movl   $0x30,0xffffffc8(%ebp)
5ffb8261:	c7 45 f0 54 b5 fb 5f 	movl   $0x5ffbb554,0xfffffff0(%ebp)
5ffb8268:	c7 45 d0 c0 75 fb 5f 	movl   $0x5ffb75c0,0xffffffd0(%ebp)
5ffb826f:	c7 45 cc 00 00 00 00 	movl   $0x0,0xffffffcc(%ebp)
5ffb8276:	6a 00                	push   $0x0
5ffb8278:	e8 53 0b 00 00       	call   5ffb8dd0 <_GetModuleHandleW@4>
5ffb827d:	89 45 dc             	mov    %eax,0xffffffdc(%ebp)
5ffb8280:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
5ffb8287:	a1 d0 c1 fb 5f       	mov    0x5ffbc1d0,%eax
5ffb828c:	50                   	push   %eax
5ffb828d:	e8 4e 0e 00 00       	call   5ffb90e0 <_LoadIconW@8>
5ffb8292:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
5ffb8295:	68 00 7f 00 00       	push   $0x7f00
5ffb829a:	6a 00                	push   $0x0
5ffb829c:	e8 1f 0c 00 00       	call   5ffb8ec0 <_LoadCursorW@8>
5ffb82a1:	c7 45 e8 00 00 00 00 	movl   $0x0,0xffffffe8(%ebp)
5ffb82a8:	c7 45 ec 00 00 00 00 	movl   $0x0,0xffffffec(%ebp)
5ffb82af:	89 45 e4             	mov    %eax,0xffffffe4(%ebp)
5ffb82b2:	c7 45 d4 00 00 00 00 	movl   $0x0,0xffffffd4(%ebp)
5ffb82b9:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
5ffb82c0:	68 00 80 00 00       	push   $0x8000
5ffb82c5:	6a 32                	push   $0x32
5ffb82c7:	e8 b4 0d 00 00       	call   5ffb9080 <_GetSystemMetrics@4>
5ffb82cc:	50                   	push   %eax
5ffb82cd:	83 ec 0c             	sub    $0xc,%esp
5ffb82d0:	6a 31                	push   $0x31
5ffb82d2:	e8 a9 0d 00 00       	call   5ffb9080 <_GetSystemMetrics@4>
5ffb82d7:	83 c4 0c             	add    $0xc,%esp
5ffb82da:	50                   	push   %eax
5ffb82db:	6a 01                	push   $0x1
5ffb82dd:	6a 01                	push   $0x1
5ffb82df:	8b 0d d0 c1 fb 5f    	mov    0x5ffbc1d0,%ecx
5ffb82e5:	51                   	push   %ecx
5ffb82e6:	e8 05 0e 00 00       	call   5ffb90f0 <_LoadImageW@24>
5ffb82eb:	52                   	push   %edx
5ffb82ec:	89 45 f4             	mov    %eax,0xfffffff4(%ebp)
5ffb82ef:	53                   	push   %ebx
5ffb82f0:	e8 8b 0c 00 00       	call   5ffb8f80 <_RegisterClassExW@4>
5ffb82f5:	83 c4 0c             	add    $0xc,%esp
5ffb82f8:	66 85 c0             	test   %ax,%ax
5ffb82fb:	0f 84 c2 00 00 00    	je     5ffb83c3 <@GuiInitConsole@4+0x243>
5ffb8301:	8b 1d 70 c1 fb 5f    	mov    0x5ffbc170,%ebx
5ffb8307:	c7 46 70 e0 a2 fb 5f 	movl   $0x5ffba2e0,0x70(%esi)
5ffb830e:	66 c7 46 60 50 00    	movw   $0x50,0x60(%esi)
5ffb8314:	66 c7 46 62 19 00    	movw   $0x19,0x62(%esi)
5ffb831a:	85 db                	test   %ebx,%ebx
5ffb831c:	75 74                	jne    5ffb8392 <@GuiInitConsole@4+0x212>
5ffb831e:	6a 00                	push   $0x0
5ffb8320:	6a 00                	push   $0x0
5ffb8322:	6a 00                	push   $0x0
5ffb8324:	6a 00                	push   $0x0
5ffb8326:	e8 25 0a 00 00       	call   5ffb8d50 <_CreateEventW@16>
5ffb832b:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
5ffb8330:	85 c0                	test   %eax,%eax
5ffb8332:	89 45 c4             	mov    %eax,0xffffffc4(%ebp)
5ffb8335:	74 71                	je     5ffb83a8 <@GuiInitConsole@4+0x228>
5ffb8337:	8d 45 c4             	lea    0xffffffc4(%ebp),%eax
5ffb833a:	51                   	push   %ecx
5ffb833b:	51                   	push   %ecx
5ffb833c:	6a 00                	push   $0x0
5ffb833e:	6a 00                	push   $0x0
5ffb8340:	50                   	push   %eax
5ffb8341:	68 30 80 fb 5f       	push   $0x5ffb8030
5ffb8346:	6a 00                	push   $0x0
5ffb8348:	6a 00                	push   $0x0
5ffb834a:	e8 61 09 00 00       	call   5ffb8cb0 <_CreateThread@24>
5ffb834f:	89 c3                	mov    %eax,%ebx
5ffb8351:	58                   	pop    %eax
5ffb8352:	85 db                	test   %ebx,%ebx
5ffb8354:	5a                   	pop    %edx
5ffb8355:	0f 84 b7 00 00 00    	je     5ffb8412 <@GuiInitConsole@4+0x292>
5ffb835b:	50                   	push   %eax
5ffb835c:	50                   	push   %eax
5ffb835d:	6a 02                	push   $0x2
5ffb835f:	53                   	push   %ebx
5ffb8360:	e8 8b 0a 00 00       	call   5ffb8df0 <_SetThreadPriority@8>
5ffb8365:	50                   	push   %eax
5ffb8366:	53                   	push   %ebx
5ffb8367:	e8 54 09 00 00       	call   5ffb8cc0 <_CloseHandle@4>
5ffb836c:	c7 04 24 ff ff ff ff 	movl   $0xffffffff,(%esp)
5ffb8373:	8b 45 c4             	mov    0xffffffc4(%ebp),%eax
5ffb8376:	50                   	push   %eax
5ffb8377:	e8 64 0a 00 00       	call   5ffb8de0 <_WaitForSingleObject@8>
5ffb837c:	50                   	push   %eax
5ffb837d:	8b 45 c4             	mov    0xffffffc4(%ebp),%eax
5ffb8380:	50                   	push   %eax
5ffb8381:	e8 3a 09 00 00       	call   5ffb8cc0 <_CloseHandle@4>
5ffb8386:	a1 70 c1 fb 5f       	mov    0x5ffbc170,%eax
5ffb838b:	83 c4 0c             	add    $0xc,%esp
5ffb838e:	85 c0                	test   %eax,%eax
5ffb8390:	74 53                	je     5ffb83e5 <@GuiInitConsole@4+0x265>
5ffb8392:	56                   	push   %esi
5ffb8393:	6a 00                	push   $0x0
5ffb8395:	68 01 80 00 00       	push   $0x8001
5ffb839a:	8b 0d 70 c1 fb 5f    	mov    0x5ffbc170,%ecx
5ffb83a0:	51                   	push   %ecx
5ffb83a1:	e8 5a 0d 00 00       	call   5ffb9100 <_PostMessageW@16>
5ffb83a6:	31 d2                	xor    %edx,%edx
5ffb83a8:	8d 65 f8             	lea    0xfffffff8(%ebp),%esp
5ffb83ab:	89 d0                	mov    %edx,%eax
5ffb83ad:	5b                   	pop    %ebx
5ffb83ae:	5e                   	pop    %esi
5ffb83af:	5d                   	pop    %ebp
5ffb83b0:	c3                   	ret    
5ffb83b1:	83 ec 0c             	sub    $0xc,%esp
5ffb83b4:	6a 01                	push   $0x1
5ffb83b6:	e8 85 0a 00 00       	call   5ffb8e40 <_PrivateCsrssManualGuiCheck@4>
5ffb83bb:	83 c4 0c             	add    $0xc,%esp
5ffb83be:	e9 eb fd ff ff       	jmp    5ffb81ae <@GuiInitConsole@4+0x2e>
5ffb83c3:	56                   	push   %esi
5ffb83c4:	68 9c 03 00 00       	push   $0x39c
5ffb83c9:	68 72 b4 fb 5f       	push   $0x5ffbb472
5ffb83ce:	68 7f b4 fb 5f       	push   $0x5ffbb47f
5ffb83d3:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb83d9:	c7 04 24 cc b5 fb 5f 	movl   $0x5ffbb5cc,(%esp)
5ffb83e0:	e9 51 fe ff ff       	jmp    5ffb8236 <@GuiInitConsole@4+0xb6>
5ffb83e5:	53                   	push   %ebx
5ffb83e6:	68 fb 03 00 00       	push   $0x3fb
5ffb83eb:	68 72 b4 fb 5f       	push   $0x5ffbb472
5ffb83f0:	68 7f b4 fb 5f       	push   $0x5ffbb47f
5ffb83f5:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb83fb:	c7 04 24 f0 b5 fb 5f 	movl   $0x5ffbb5f0,(%esp)
5ffb8402:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb8408:	ba 01 00 00 c0       	mov    $0xc0000001,%edx
5ffb840d:	e9 3c fe ff ff       	jmp    5ffb824e <@GuiInitConsole@4+0xce>
5ffb8412:	83 ec 0c             	sub    $0xc,%esp
5ffb8415:	8b 5d c4             	mov    0xffffffc4(%ebp),%ebx
5ffb8418:	53                   	push   %ebx
5ffb8419:	e8 32 08 00 00       	call   5ffb8c50 <_NtClose@4>
5ffb841e:	5a                   	pop    %edx
5ffb841f:	59                   	pop    %ecx
5ffb8420:	68 f0 03 00 00       	push   $0x3f0
5ffb8425:	68 72 b4 fb 5f       	push   $0x5ffbb472
5ffb842a:	68 7f b4 fb 5f       	push   $0x5ffbb47f
5ffb842f:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb8435:	c7 04 24 24 b6 fb 5f 	movl   $0x5ffbb624,(%esp)
5ffb843c:	eb c4                	jmp    5ffb8402 <@GuiInitConsole@4+0x282>
5ffb843e:	90                   	nop    
5ffb843f:	90                   	nop    

5ffb8440 <_TuiInitScreenBuffer@8>:
5ffb8440:	55                   	push   %ebp
5ffb8441:	89 e5                	mov    %esp,%ebp
5ffb8443:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb8446:	c6 40 34 17          	movb   $0x17,0x34(%eax)
5ffb844a:	5d                   	pop    %ebp
5ffb844b:	c2 08 00             	ret    $0x8
5ffb844e:	89 f6                	mov    %esi,%esi

5ffb8450 <_TuiDrawRegion@8>:
5ffb8450:	55                   	push   %ebp
5ffb8451:	89 e5                	mov    %esp,%ebp
5ffb8453:	57                   	push   %edi
5ffb8454:	56                   	push   %esi
5ffb8455:	53                   	push   %ebx
5ffb8456:	83 ec 3c             	sub    $0x3c,%esp
5ffb8459:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb845c:	39 05 c0 c1 fb 5f    	cmp    %eax,0x5ffbc1c0
5ffb8462:	8b 50 38             	mov    0x38(%eax),%edx
5ffb8465:	89 55 e4             	mov    %edx,0xffffffe4(%ebp)
5ffb8468:	74 0a                	je     5ffb8474 <_TuiDrawRegion@8+0x24>
5ffb846a:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb846d:	5b                   	pop    %ebx
5ffb846e:	5e                   	pop    %esi
5ffb846f:	5f                   	pop    %edi
5ffb8470:	5d                   	pop    %ebp
5ffb8471:	c2 08 00             	ret    $0x8
5ffb8474:	8b 4d 0c             	mov    0xc(%ebp),%ecx
5ffb8477:	c7 45 dc 18 00 00 00 	movl   $0x18,0xffffffdc(%ebp)
5ffb847e:	8b 59 04             	mov    0x4(%ecx),%ebx
5ffb8481:	8b 51 0c             	mov    0xc(%ecx),%edx
5ffb8484:	39 d3                	cmp    %edx,%ebx
5ffb8486:	7f 0f                	jg     5ffb8497 <_TuiDrawRegion@8+0x47>
5ffb8488:	89 ce                	mov    %ecx,%esi
5ffb848a:	8b 09                	mov    (%ecx),%ecx
5ffb848c:	8b 46 08             	mov    0x8(%esi),%eax
5ffb848f:	39 c1                	cmp    %eax,%ecx
5ffb8491:	0f 8e c5 01 00 00    	jle    5ffb865c <_TuiDrawRegion@8+0x20c>
5ffb8497:	56                   	push   %esi
5ffb8498:	8b 5d dc             	mov    0xffffffdc(%ebp),%ebx
5ffb849b:	53                   	push   %ebx
5ffb849c:	6a 00                	push   $0x0
5ffb849e:	8b 0d e0 c1 fb 5f    	mov    0x5ffbc1e0,%ecx
5ffb84a4:	51                   	push   %ecx
5ffb84a5:	e8 46 08 00 00       	call   5ffb8cf0 <_HeapAlloc@12>
5ffb84aa:	85 c0                	test   %eax,%eax
5ffb84ac:	89 45 e0             	mov    %eax,0xffffffe0(%ebp)
5ffb84af:	5a                   	pop    %edx
5ffb84b0:	0f 84 bd 01 00 00    	je     5ffb8673 <_TuiDrawRegion@8+0x223>
5ffb84b6:	50                   	push   %eax
5ffb84b7:	8b 45 e4             	mov    0xffffffe4(%ebp),%eax
5ffb84ba:	8b 50 2c             	mov    0x2c(%eax),%edx
5ffb84bd:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
5ffb84c0:	50                   	push   %eax
5ffb84c1:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
5ffb84c4:	50                   	push   %eax
5ffb84c5:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
5ffb84c8:	8b 41 30             	mov    0x30(%ecx),%eax
5ffb84cb:	50                   	push   %eax
5ffb84cc:	e8 bf 90 ff ff       	call   5ffb1590 <@ConioPhysicalToLogical@20>
5ffb84d1:	8b 75 0c             	mov    0xc(%ebp),%esi
5ffb84d4:	8b 55 0c             	mov    0xc(%ebp),%edx
5ffb84d7:	8b 45 e0             	mov    0xffffffe0(%ebp),%eax
5ffb84da:	8b 4d 0c             	mov    0xc(%ebp),%ecx
5ffb84dd:	8b 36                	mov    (%esi),%esi
5ffb84df:	8b 52 04             	mov    0x4(%edx),%edx
5ffb84e2:	89 30                	mov    %esi,(%eax)
5ffb84e4:	89 50 04             	mov    %edx,0x4(%eax)
5ffb84e7:	8b 49 08             	mov    0x8(%ecx),%ecx
5ffb84ea:	89 75 c4             	mov    %esi,0xffffffc4(%ebp)
5ffb84ed:	89 55 cc             	mov    %edx,0xffffffcc(%ebp)
5ffb84f0:	31 c0                	xor    %eax,%eax
5ffb84f2:	5f                   	pop    %edi
5ffb84f3:	39 ce                	cmp    %ecx,%esi
5ffb84f5:	89 4d c8             	mov    %ecx,0xffffffc8(%ebp)
5ffb84f8:	7f 05                	jg     5ffb84ff <_TuiDrawRegion@8+0xaf>
5ffb84fa:	89 c8                	mov    %ecx,%eax
5ffb84fc:	29 f0                	sub    %esi,%eax
5ffb84fe:	40                   	inc    %eax
5ffb84ff:	8b 75 e0             	mov    0xffffffe0(%ebp),%esi
5ffb8502:	89 46 08             	mov    %eax,0x8(%esi)
5ffb8505:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb8508:	8b 40 0c             	mov    0xc(%eax),%eax
5ffb850b:	89 45 c0             	mov    %eax,0xffffffc0(%ebp)
5ffb850e:	31 c0                	xor    %eax,%eax
5ffb8510:	8b 55 c0             	mov    0xffffffc0(%ebp),%edx
5ffb8513:	39 55 cc             	cmp    %edx,0xffffffcc(%ebp)
5ffb8516:	7f 08                	jg     5ffb8520 <_TuiDrawRegion@8+0xd0>
5ffb8518:	89 d0                	mov    %edx,%eax
5ffb851a:	8b 5d cc             	mov    0xffffffcc(%ebp),%ebx
5ffb851d:	29 d8                	sub    %ebx,%eax
5ffb851f:	40                   	inc    %eax
5ffb8520:	8b 4d e0             	mov    0xffffffe0(%ebp),%ecx
5ffb8523:	8b 75 e4             	mov    0xffffffe4(%ebp),%esi
5ffb8526:	89 cf                	mov    %ecx,%edi
5ffb8528:	c7 45 d8 00 00 00 00 	movl   $0x0,0xffffffd8(%ebp)
5ffb852f:	89 41 0c             	mov    %eax,0xc(%ecx)
5ffb8532:	8b 45 ec             	mov    0xffffffec(%ebp),%eax
5ffb8535:	89 41 10             	mov    %eax,0x10(%ecx)
5ffb8538:	66 8b 56 2a          	mov    0x2a(%esi),%dx
5ffb853c:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
5ffb853f:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb8545:	89 41 14             	mov    %eax,0x14(%ecx)
5ffb8548:	8b 4d cc             	mov    0xffffffcc(%ebp),%ecx
5ffb854b:	01 ca                	add    %ecx,%edx
5ffb854d:	66 8b 4e 26          	mov    0x26(%esi),%cx
5ffb8551:	81 e1 ff ff 00 00    	and    $0xffff,%ecx
5ffb8557:	89 d0                	mov    %edx,%eax
5ffb8559:	66 8b 5e 24          	mov    0x24(%esi),%bx
5ffb855d:	83 c7 18             	add    $0x18,%edi
5ffb8560:	c1 fa 1f             	sar    $0x1f,%edx
5ffb8563:	81 e3 ff ff 00 00    	and    $0xffff,%ebx
5ffb8569:	f7 f9                	idiv   %ecx
5ffb856b:	0f af d3             	imul   %ebx,%edx
5ffb856e:	0f af cb             	imul   %ebx,%ecx
5ffb8571:	8b 45 c4             	mov    0xffffffc4(%ebp),%eax
5ffb8574:	01 c2                	add    %eax,%edx
5ffb8576:	66 8b 46 28          	mov    0x28(%esi),%ax
5ffb857a:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb857f:	01 c2                	add    %eax,%edx
5ffb8581:	8b 46 20             	mov    0x20(%esi),%eax
5ffb8584:	8d 0c 48             	lea    (%eax,%ecx,2),%ecx
5ffb8587:	8d 34 50             	lea    (%eax,%edx,2),%esi
5ffb858a:	89 4d d4             	mov    %ecx,0xffffffd4(%ebp)
5ffb858d:	8d 14 1b             	lea    (%ebx,%ebx,1),%edx
5ffb8590:	8b 4d c8             	mov    0xffffffc8(%ebp),%ecx
5ffb8593:	89 55 d0             	mov    %edx,0xffffffd0(%ebp)
5ffb8596:	39 4d c4             	cmp    %ecx,0xffffffc4(%ebp)
5ffb8599:	7f 0c                	jg     5ffb85a7 <_TuiDrawRegion@8+0x157>
5ffb859b:	8b 45 c4             	mov    0xffffffc4(%ebp),%eax
5ffb859e:	29 c1                	sub    %eax,%ecx
5ffb85a0:	8d 54 09 02          	lea    0x2(%ecx,%ecx,1),%edx
5ffb85a4:	89 55 d8             	mov    %edx,0xffffffd8(%ebp)
5ffb85a7:	8b 5d cc             	mov    0xffffffcc(%ebp),%ebx
5ffb85aa:	39 5d c0             	cmp    %ebx,0xffffffc0(%ebp)
5ffb85ad:	72 45                	jb     5ffb85f4 <_TuiDrawRegion@8+0x1a4>
5ffb85af:	90                   	nop    
5ffb85b0:	50                   	push   %eax
5ffb85b1:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
5ffb85b4:	50                   	push   %eax
5ffb85b5:	56                   	push   %esi
5ffb85b6:	57                   	push   %edi
5ffb85b7:	e8 74 06 00 00       	call   5ffb8c30 <_memcpy>
5ffb85bc:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
5ffb85bf:	83 c4 10             	add    $0x10,%esp
5ffb85c2:	01 c6                	add    %eax,%esi
5ffb85c4:	39 75 d4             	cmp    %esi,0xffffffd4(%ebp)
5ffb85c7:	77 1d                	ja     5ffb85e6 <_TuiDrawRegion@8+0x196>
5ffb85c9:	8b 4d e4             	mov    0xffffffe4(%ebp),%ecx
5ffb85cc:	66 8b 41 26          	mov    0x26(%ecx),%ax
5ffb85d0:	66 8b 51 24          	mov    0x24(%ecx),%dx
5ffb85d4:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb85d9:	81 e2 ff ff 00 00    	and    $0xffff,%edx
5ffb85df:	0f af c2             	imul   %edx,%eax
5ffb85e2:	01 c0                	add    %eax,%eax
5ffb85e4:	29 c6                	sub    %eax,%esi
5ffb85e6:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
5ffb85e9:	43                   	inc    %ebx
5ffb85ea:	01 c7                	add    %eax,%edi
5ffb85ec:	8b 45 0c             	mov    0xc(%ebp),%eax
5ffb85ef:	39 58 0c             	cmp    %ebx,0xc(%eax)
5ffb85f2:	73 bc                	jae    5ffb85b0 <_TuiDrawRegion@8+0x160>
5ffb85f4:	8d 45 e8             	lea    0xffffffe8(%ebp),%eax
5ffb85f7:	6a 00                	push   $0x0
5ffb85f9:	50                   	push   %eax
5ffb85fa:	8b 45 dc             	mov    0xffffffdc(%ebp),%eax
5ffb85fd:	50                   	push   %eax
5ffb85fe:	8b 7d e0             	mov    0xffffffe0(%ebp),%edi
5ffb8601:	57                   	push   %edi
5ffb8602:	6a 00                	push   $0x0
5ffb8604:	6a 00                	push   $0x0
5ffb8606:	68 c1 a0 1c 00       	push   $0x1ca0c1
5ffb860b:	8b 35 b0 c1 fb 5f    	mov    0x5ffbc1b0,%esi
5ffb8611:	56                   	push   %esi
5ffb8612:	e8 e9 07 00 00       	call   5ffb8e00 <_DeviceIoControl@32>
5ffb8617:	85 c0                	test   %eax,%eax
5ffb8619:	75 3e                	jne    5ffb8659 <_TuiDrawRegion@8+0x209>
5ffb861b:	53                   	push   %ebx
5ffb861c:	6a 76                	push   $0x76
5ffb861e:	68 70 b6 fb 5f       	push   $0x5ffbb670
5ffb8623:	68 7d b6 fb 5f       	push   $0x5ffbb67d
5ffb8628:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb862e:	c7 04 24 86 b6 fb 5f 	movl   $0x5ffbb686,(%esp)
5ffb8635:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb863b:	83 c4 0c             	add    $0xc,%esp
5ffb863e:	8b 55 e0             	mov    0xffffffe0(%ebp),%edx
5ffb8641:	52                   	push   %edx
5ffb8642:	6a 00                	push   $0x0
5ffb8644:	a1 e0 c1 fb 5f       	mov    0x5ffbc1e0,%eax
5ffb8649:	50                   	push   %eax
5ffb864a:	e8 b1 06 00 00       	call   5ffb8d00 <_HeapFree@12>
5ffb864f:	8d 65 f4             	lea    0xfffffff4(%ebp),%esp
5ffb8652:	5b                   	pop    %ebx
5ffb8653:	5e                   	pop    %esi
5ffb8654:	5f                   	pop    %edi
5ffb8655:	5d                   	pop    %ebp
5ffb8656:	c2 08 00             	ret    $0x8
5ffb8659:	51                   	push   %ecx
5ffb865a:	eb e2                	jmp    5ffb863e <_TuiDrawRegion@8+0x1ee>
5ffb865c:	29 c8                	sub    %ecx,%eax
5ffb865e:	29 da                	sub    %ebx,%edx
5ffb8660:	8d 44 00 02          	lea    0x2(%eax,%eax,1),%eax
5ffb8664:	0f af d0             	imul   %eax,%edx
5ffb8667:	8d 54 02 18          	lea    0x18(%edx,%eax,1),%edx
5ffb866b:	89 55 dc             	mov    %edx,0xffffffdc(%ebp)
5ffb866e:	e9 24 fe ff ff       	jmp    5ffb8497 <_TuiDrawRegion@8+0x47>
5ffb8673:	50                   	push   %eax
5ffb8674:	6a 66                	push   $0x66
5ffb8676:	68 70 b6 fb 5f       	push   $0x5ffbb670
5ffb867b:	68 7d b6 fb 5f       	push   $0x5ffbb67d
5ffb8680:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb8686:	c7 04 24 9e b6 fb 5f 	movl   $0x5ffbb69e,(%esp)
5ffb868d:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb8693:	e9 d2 fd ff ff       	jmp    5ffb846a <_TuiDrawRegion@8+0x1a>
5ffb8698:	90                   	nop    
5ffb8699:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

5ffb86a0 <_TuiWriteStream@28>:
5ffb86a0:	55                   	push   %ebp
5ffb86a1:	89 e5                	mov    %esp,%ebp
5ffb86a3:	50                   	push   %eax
5ffb86a4:	50                   	push   %eax
5ffb86a5:	a1 c0 c1 fb 5f       	mov    0x5ffbc1c0,%eax
5ffb86aa:	8b 50 38             	mov    0x38(%eax),%edx
5ffb86ad:	8b 45 08             	mov    0x8(%ebp),%eax
5ffb86b0:	3b 50 38             	cmp    0x38(%eax),%edx
5ffb86b3:	74 04                	je     5ffb86b9 <_TuiWriteStream@28+0x19>
5ffb86b5:	c9                   	leave  
5ffb86b6:	c2 1c 00             	ret    $0x1c
5ffb86b9:	83 ec 0c             	sub    $0xc,%esp
5ffb86bc:	8d 45 fc             	lea    0xfffffffc(%ebp),%eax
5ffb86bf:	6a 00                	push   $0x0
5ffb86c1:	50                   	push   %eax
5ffb86c2:	8b 45 20             	mov    0x20(%ebp),%eax
5ffb86c5:	50                   	push   %eax
5ffb86c6:	8b 45 1c             	mov    0x1c(%ebp),%eax
5ffb86c9:	50                   	push   %eax
5ffb86ca:	a1 b0 c1 fb 5f       	mov    0x5ffbc1b0,%eax
5ffb86cf:	50                   	push   %eax
5ffb86d0:	e8 3b 07 00 00       	call   5ffb8e10 <_WriteFile@20>
5ffb86d5:	83 c4 0c             	add    $0xc,%esp
5ffb86d8:	85 c0                	test   %eax,%eax
5ffb86da:	75 d9                	jne    5ffb86b5 <_TuiWriteStream@28+0x15>
5ffb86dc:	50                   	push   %eax
5ffb86dd:	68 8c 00 00 00       	push   $0x8c
5ffb86e2:	68 70 b6 fb 5f       	push   $0x5ffbb670
5ffb86e7:	68 7d b6 fb 5f       	push   $0x5ffbb67d
5ffb86ec:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb86f2:	c7 04 24 b0 b6 fb 5f 	movl   $0x5ffbb6b0,(%esp)
5ffb86f9:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb86ff:	83 c4 10             	add    $0x10,%esp
5ffb8702:	c9                   	leave  
5ffb8703:	c2 1c 00             	ret    $0x1c
5ffb8706:	8d 76 00             	lea    0x0(%esi),%esi
5ffb8709:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb8710 <_TuiSetCursorInfo@8>:
5ffb8710:	55                   	push   %ebp
5ffb8711:	89 e5                	mov    %esp,%ebp
5ffb8713:	51                   	push   %ecx
5ffb8714:	51                   	push   %ecx
5ffb8715:	b9 01 00 00 00       	mov    $0x1,%ecx
5ffb871a:	a1 c0 c1 fb 5f       	mov    0x5ffbc1c0,%eax
5ffb871f:	8b 50 38             	mov    0x38(%eax),%edx
5ffb8722:	3b 55 0c             	cmp    0xc(%ebp),%edx
5ffb8725:	74 06                	je     5ffb872d <_TuiSetCursorInfo@8+0x1d>
5ffb8727:	89 c8                	mov    %ecx,%eax
5ffb8729:	c9                   	leave  
5ffb872a:	c2 08 00             	ret    $0x8
5ffb872d:	8d 45 fc             	lea    0xfffffffc(%ebp),%eax
5ffb8730:	6a 00                	push   $0x0
5ffb8732:	50                   	push   %eax
5ffb8733:	8d 42 38             	lea    0x38(%edx),%eax
5ffb8736:	8b 15 b0 c1 fb 5f    	mov    0x5ffbc1b0,%edx
5ffb873c:	6a 00                	push   $0x0
5ffb873e:	6a 00                	push   $0x0
5ffb8740:	6a 08                	push   $0x8
5ffb8742:	50                   	push   %eax
5ffb8743:	68 10 a0 1c 00       	push   $0x1ca010
5ffb8748:	52                   	push   %edx
5ffb8749:	e8 b2 06 00 00       	call   5ffb8e00 <_DeviceIoControl@32>
5ffb874e:	b9 01 00 00 00       	mov    $0x1,%ecx
5ffb8753:	85 c0                	test   %eax,%eax
5ffb8755:	75 d0                	jne    5ffb8727 <_TuiSetCursorInfo@8+0x17>
5ffb8757:	50                   	push   %eax
5ffb8758:	68 9e 00 00 00       	push   $0x9e
5ffb875d:	68 70 b6 fb 5f       	push   $0x5ffbb670
5ffb8762:	68 7d b6 fb 5f       	push   $0x5ffbb67d
5ffb8767:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb876d:	c7 04 24 cd b6 fb 5f 	movl   $0x5ffbb6cd,(%esp)
5ffb8774:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb877a:	31 c9                	xor    %ecx,%ecx
5ffb877c:	eb a9                	jmp    5ffb8727 <_TuiSetCursorInfo@8+0x17>
5ffb877e:	89 f6                	mov    %esi,%esi

5ffb8780 <_TuiSetScreenInfo@16>:
5ffb8780:	55                   	push   %ebp
5ffb8781:	ba 01 00 00 00       	mov    $0x1,%edx
5ffb8786:	89 e5                	mov    %esp,%ebp
5ffb8788:	53                   	push   %ebx
5ffb8789:	83 ec 34             	sub    $0x34,%esp
5ffb878c:	a1 c0 c1 fb 5f       	mov    0x5ffbc1c0,%eax
5ffb8791:	8b 58 38             	mov    0x38(%eax),%ebx
5ffb8794:	3b 5d 0c             	cmp    0xc(%ebp),%ebx
5ffb8797:	74 09                	je     5ffb87a2 <_TuiSetScreenInfo@16+0x22>
5ffb8799:	89 d0                	mov    %edx,%eax
5ffb879b:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb879e:	c9                   	leave  
5ffb879f:	c2 10 00             	ret    $0x10
5ffb87a2:	50                   	push   %eax
5ffb87a3:	8d 45 d4             	lea    0xffffffd4(%ebp),%eax
5ffb87a6:	8b 53 2c             	mov    0x2c(%ebx),%edx
5ffb87a9:	50                   	push   %eax
5ffb87aa:	8d 45 d0             	lea    0xffffffd0(%ebp),%eax
5ffb87ad:	50                   	push   %eax
5ffb87ae:	89 d9                	mov    %ebx,%ecx
5ffb87b0:	8b 43 30             	mov    0x30(%ebx),%eax
5ffb87b3:	50                   	push   %eax
5ffb87b4:	e8 d7 8d ff ff       	call   5ffb1590 <@ConioPhysicalToLogical@20>
5ffb87b9:	8b 45 d0             	mov    0xffffffd0(%ebp),%eax
5ffb87bc:	66 89 45 dc          	mov    %ax,0xffffffdc(%ebp)
5ffb87c0:	8b 45 d4             	mov    0xffffffd4(%ebp),%eax
5ffb87c3:	66 89 45 de          	mov    %ax,0xffffffde(%ebp)
5ffb87c7:	31 c0                	xor    %eax,%eax
5ffb87c9:	8a 43 34             	mov    0x34(%ebx),%al
5ffb87cc:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
5ffb87d3:	66 89 45 e0          	mov    %ax,0xffffffe0(%ebp)
5ffb87d7:	8d 45 cc             	lea    0xffffffcc(%ebp),%eax
5ffb87da:	50                   	push   %eax
5ffb87db:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
5ffb87de:	6a 00                	push   $0x0
5ffb87e0:	6a 00                	push   $0x0
5ffb87e2:	6a 16                	push   $0x16
5ffb87e4:	50                   	push   %eax
5ffb87e5:	a1 b0 c1 fb 5f       	mov    0x5ffbc1b0,%eax
5ffb87ea:	68 08 a0 1c 00       	push   $0x1ca008
5ffb87ef:	50                   	push   %eax
5ffb87f0:	e8 0b 06 00 00       	call   5ffb8e00 <_DeviceIoControl@32>
5ffb87f5:	ba 01 00 00 00       	mov    $0x1,%edx
5ffb87fa:	85 c0                	test   %eax,%eax
5ffb87fc:	75 9b                	jne    5ffb8799 <_TuiSetScreenInfo@16+0x19>
5ffb87fe:	53                   	push   %ebx
5ffb87ff:	68 ba 00 00 00       	push   $0xba
5ffb8804:	68 70 b6 fb 5f       	push   $0x5ffbb670
5ffb8809:	68 7d b6 fb 5f       	push   $0x5ffbb67d
5ffb880e:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb8814:	c7 04 24 e8 b6 fb 5f 	movl   $0x5ffbb6e8,(%esp)
5ffb881b:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb8821:	31 d2                	xor    %edx,%edx
5ffb8823:	e9 71 ff ff ff       	jmp    5ffb8799 <_TuiSetScreenInfo@16+0x19>
5ffb8828:	90                   	nop    
5ffb8829:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi

5ffb8830 <_TuiChangeTitle@4>:
5ffb8830:	55                   	push   %ebp
5ffb8831:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb8836:	89 e5                	mov    %esp,%ebp
5ffb8838:	5d                   	pop    %ebp
5ffb8839:	c2 04 00             	ret    $0x4
5ffb883c:	8d 74 26 00          	lea    0x0(%esi),%esi

5ffb8840 <_TuiCleanupConsole@4>:
5ffb8840:	55                   	push   %ebp
5ffb8841:	89 e5                	mov    %esp,%ebp
5ffb8843:	53                   	push   %ebx
5ffb8844:	83 ec 10             	sub    $0x10,%esp
5ffb8847:	8b 5d 08             	mov    0x8(%ebp),%ebx
5ffb884a:	68 f0 c1 fb 5f       	push   $0x5ffbc1f0
5ffb884f:	e8 3c 04 00 00       	call   5ffb8c90 <_EnterCriticalSection@4>
5ffb8854:	83 c4 0c             	add    $0xc,%esp
5ffb8857:	39 1d c0 c1 fb 5f    	cmp    %ebx,0x5ffbc1c0
5ffb885d:	74 41                	je     5ffb88a0 <_TuiCleanupConsole@4+0x60>
5ffb885f:	8b 43 24             	mov    0x24(%ebx),%eax
5ffb8862:	39 d8                	cmp    %ebx,%eax
5ffb8864:	74 0c                	je     5ffb8872 <_TuiCleanupConsole@4+0x32>
5ffb8866:	8b 53 20             	mov    0x20(%ebx),%edx
5ffb8869:	89 42 24             	mov    %eax,0x24(%edx)
5ffb886c:	8b 43 24             	mov    0x24(%ebx),%eax
5ffb886f:	89 50 20             	mov    %edx,0x20(%eax)
5ffb8872:	83 ec 0c             	sub    $0xc,%esp
5ffb8875:	68 f0 c1 fb 5f       	push   $0x5ffbc1f0
5ffb887a:	e8 21 04 00 00       	call   5ffb8ca0 <_LeaveCriticalSection@4>
5ffb887f:	8b 0d c0 c1 fb 5f    	mov    0x5ffbc1c0,%ecx
5ffb8885:	83 c4 0c             	add    $0xc,%esp
5ffb8888:	85 c9                	test   %ecx,%ecx
5ffb888a:	75 07                	jne    5ffb8893 <_TuiCleanupConsole@4+0x53>
5ffb888c:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb888f:	c9                   	leave  
5ffb8890:	c2 04 00             	ret    $0x4
5ffb8893:	e8 b8 8b ff ff       	call   5ffb1450 <@ConioDrawConsole@4>
5ffb8898:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb889b:	c9                   	leave  
5ffb889c:	c2 04 00             	ret    $0x4
5ffb889f:	90                   	nop    
5ffb88a0:	8b 43 24             	mov    0x24(%ebx),%eax
5ffb88a3:	39 d8                	cmp    %ebx,%eax
5ffb88a5:	74 07                	je     5ffb88ae <_TuiCleanupConsole@4+0x6e>
5ffb88a7:	a3 c0 c1 fb 5f       	mov    %eax,0x5ffbc1c0
5ffb88ac:	eb b1                	jmp    5ffb885f <_TuiCleanupConsole@4+0x1f>
5ffb88ae:	31 c0                	xor    %eax,%eax
5ffb88b0:	eb f5                	jmp    5ffb88a7 <_TuiCleanupConsole@4+0x67>
5ffb88b2:	8d b4 26 00 00 00 00 	lea    0x0(%esi),%esi
5ffb88b9:	8d bc 27 00 00 00 00 	lea    0x0(%edi),%edi

5ffb88c0 <@TuiInitConsole@4>:
5ffb88c0:	55                   	push   %ebp
5ffb88c1:	89 e5                	mov    %esp,%ebp
5ffb88c3:	53                   	push   %ebx
5ffb88c4:	83 ec 34             	sub    $0x34,%esp
5ffb88c7:	89 cb                	mov    %ecx,%ebx
5ffb88c9:	a1 80 c1 fb 5f       	mov    0x5ffbc180,%eax
5ffb88ce:	85 c0                	test   %eax,%eax
5ffb88d0:	75 7e                	jne    5ffb8950 <@TuiInitConsole@4+0x90>
5ffb88d2:	c7 05 80 c1 fb 5f 01 	movl   $0x1,0x5ffbc180
5ffb88d9:	00 00 00 
5ffb88dc:	51                   	push   %ecx
5ffb88dd:	6a 00                	push   $0x0
5ffb88df:	6a 00                	push   $0x0
5ffb88e1:	6a 03                	push   $0x3
5ffb88e3:	6a 00                	push   $0x0
5ffb88e5:	6a 00                	push   $0x0
5ffb88e7:	68 ff 01 1f 00       	push   $0x1f01ff
5ffb88ec:	68 08 b7 fb 5f       	push   $0x5ffbb708
5ffb88f1:	e8 2a 05 00 00       	call   5ffb8e20 <_CreateFileW@28>
5ffb88f6:	5a                   	pop    %edx
5ffb88f7:	a3 b0 c1 fb 5f       	mov    %eax,0x5ffbc1b0
5ffb88fc:	40                   	inc    %eax
5ffb88fd:	0f 84 b1 00 00 00    	je     5ffb89b4 <@TuiInitConsole@4+0xf4>
5ffb8903:	83 ec 0c             	sub    $0xc,%esp
5ffb8906:	c7 05 c0 c1 fb 5f 00 	movl   $0x0,0x5ffbc1c0
5ffb890d:	00 00 00 
5ffb8910:	68 f0 c1 fb 5f       	push   $0x5ffbc1f0
5ffb8915:	e8 66 03 00 00       	call   5ffb8c80 <_InitializeCriticalSection@4>
5ffb891a:	83 c4 0c             	add    $0xc,%esp
5ffb891d:	8d 45 d4             	lea    0xffffffd4(%ebp),%eax
5ffb8920:	6a 00                	push   $0x0
5ffb8922:	50                   	push   %eax
5ffb8923:	8d 45 d8             	lea    0xffffffd8(%ebp),%eax
5ffb8926:	6a 16                	push   $0x16
5ffb8928:	50                   	push   %eax
5ffb8929:	6a 00                	push   $0x0
5ffb892b:	6a 00                	push   $0x0
5ffb892d:	68 04 60 1c 00       	push   $0x1c6004
5ffb8932:	a1 b0 c1 fb 5f       	mov    0x5ffbc1b0,%eax
5ffb8937:	50                   	push   %eax
5ffb8938:	e8 c3 04 00 00       	call   5ffb8e00 <_DeviceIoControl@32>
5ffb893d:	85 c0                	test   %eax,%eax
5ffb893f:	0f 84 ab 00 00 00    	je     5ffb89f0 <@TuiInitConsole@4+0x130>
5ffb8945:	8b 45 d8             	mov    0xffffffd8(%ebp),%eax
5ffb8948:	a3 a0 c1 fb 5f       	mov    %eax,0x5ffbc1a0
5ffb894d:	8d 76 00             	lea    0x0(%esi),%esi
5ffb8950:	a1 a0 c1 fb 5f       	mov    0x5ffbc1a0,%eax
5ffb8955:	83 ec 0c             	sub    $0xc,%esp
5ffb8958:	c7 43 70 00 a3 fb 5f 	movl   $0x5ffba300,0x70(%ebx)
5ffb895f:	c7 43 58 00 00 00 00 	movl   $0x0,0x58(%ebx)
5ffb8966:	89 43 60             	mov    %eax,0x60(%ebx)
5ffb8969:	68 f0 c1 fb 5f       	push   $0x5ffbc1f0
5ffb896e:	e8 1d 03 00 00       	call   5ffb8c90 <_EnterCriticalSection@4>
5ffb8973:	8b 15 c0 c1 fb 5f    	mov    0x5ffbc1c0,%edx
5ffb8979:	83 c4 0c             	add    $0xc,%esp
5ffb897c:	85 d2                	test   %edx,%edx
5ffb897e:	75 20                	jne    5ffb89a0 <@TuiInitConsole@4+0xe0>
5ffb8980:	89 5b 20             	mov    %ebx,0x20(%ebx)
5ffb8983:	89 5b 24             	mov    %ebx,0x24(%ebx)
5ffb8986:	83 ec 0c             	sub    $0xc,%esp
5ffb8989:	89 1d c0 c1 fb 5f    	mov    %ebx,0x5ffbc1c0
5ffb898f:	68 f0 c1 fb 5f       	push   $0x5ffbc1f0
5ffb8994:	e8 07 03 00 00       	call   5ffb8ca0 <_LeaveCriticalSection@4>
5ffb8999:	31 c0                	xor    %eax,%eax
5ffb899b:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb899e:	c9                   	leave  
5ffb899f:	c3                   	ret    
5ffb89a0:	8b 42 24             	mov    0x24(%edx),%eax
5ffb89a3:	89 53 20             	mov    %edx,0x20(%ebx)
5ffb89a6:	89 43 24             	mov    %eax,0x24(%ebx)
5ffb89a9:	8b 42 24             	mov    0x24(%edx),%eax
5ffb89ac:	89 5a 24             	mov    %ebx,0x24(%edx)
5ffb89af:	89 58 20             	mov    %ebx,0x20(%eax)
5ffb89b2:	eb d2                	jmp    5ffb8986 <@TuiInitConsole@4+0xc6>
5ffb89b4:	50                   	push   %eax
5ffb89b5:	6a 25                	push   $0x25
5ffb89b7:	68 70 b6 fb 5f       	push   $0x5ffbb670
5ffb89bc:	68 7d b6 fb 5f       	push   $0x5ffbb67d
5ffb89c1:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb89c7:	c7 04 24 26 b7 fb 5f 	movl   $0x5ffbb726,(%esp)
5ffb89ce:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb89d4:	c7 05 80 c1 fb 5f 00 	movl   $0x0,0x5ffbc180
5ffb89db:	00 00 00 
5ffb89de:	83 c4 10             	add    $0x10,%esp
5ffb89e1:	b8 01 00 00 c0       	mov    $0xc0000001,%eax
5ffb89e6:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb89e9:	c9                   	leave  
5ffb89ea:	c3                   	ret    
5ffb89eb:	90                   	nop    
5ffb89ec:	8d 74 26 00          	lea    0x0(%esi),%esi
5ffb89f0:	50                   	push   %eax
5ffb89f1:	6a 2e                	push   $0x2e
5ffb89f3:	68 70 b6 fb 5f       	push   $0x5ffbb670
5ffb89f8:	68 7d b6 fb 5f       	push   $0x5ffbb67d
5ffb89fd:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb8a03:	c7 04 24 42 b7 fb 5f 	movl   $0x5ffbb742,(%esp)
5ffb8a0a:	eb c2                	jmp    5ffb89ce <@TuiInitConsole@4+0x10e>
5ffb8a0c:	8d 74 26 00          	lea    0x0(%esi),%esi

5ffb8a10 <@TuiGetFocusConsole@0>:
5ffb8a10:	55                   	push   %ebp
5ffb8a11:	a1 c0 c1 fb 5f       	mov    0x5ffbc1c0,%eax
5ffb8a16:	89 e5                	mov    %esp,%ebp
5ffb8a18:	5d                   	pop    %ebp
5ffb8a19:	c3                   	ret    
5ffb8a1a:	8d b6 00 00 00 00    	lea    0x0(%esi),%esi

5ffb8a20 <@TuiSwapConsole@4>:
5ffb8a20:	55                   	push   %ebp
5ffb8a21:	89 e5                	mov    %esp,%ebp
5ffb8a23:	53                   	push   %ebx
5ffb8a24:	83 ec 14             	sub    $0x14,%esp
5ffb8a27:	89 cb                	mov    %ecx,%ebx
5ffb8a29:	85 c9                	test   %ecx,%ecx
5ffb8a2b:	75 73                	jne    5ffb8aa0 <@TuiSwapConsole@4+0x80>
5ffb8a2d:	8b 15 90 c1 fb 5f    	mov    0x5ffbc190,%edx
5ffb8a33:	31 c0                	xor    %eax,%eax
5ffb8a35:	85 d2                	test   %edx,%edx
5ffb8a37:	75 07                	jne    5ffb8a40 <@TuiSwapConsole@4+0x20>
5ffb8a39:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb8a3c:	c9                   	leave  
5ffb8a3d:	c3                   	ret    
5ffb8a3e:	89 f6                	mov    %esi,%esi
5ffb8a40:	83 ec 0c             	sub    $0xc,%esp
5ffb8a43:	68 f0 c1 fb 5f       	push   $0x5ffbc1f0
5ffb8a48:	e8 43 02 00 00       	call   5ffb8c90 <_EnterCriticalSection@4>
5ffb8a4d:	8b 0d 90 c1 fb 5f    	mov    0x5ffbc190,%ecx
5ffb8a53:	8b 1d c0 c1 fb 5f    	mov    0x5ffbc1c0,%ebx
5ffb8a59:	83 c4 0c             	add    $0xc,%esp
5ffb8a5c:	39 d9                	cmp    %ebx,%ecx
5ffb8a5e:	74 21                	je     5ffb8a81 <@TuiSwapConsole@4+0x61>
5ffb8a60:	8b 51 20             	mov    0x20(%ecx),%edx
5ffb8a63:	8b 41 24             	mov    0x24(%ecx),%eax
5ffb8a66:	89 42 24             	mov    %eax,0x24(%edx)
5ffb8a69:	8b 41 24             	mov    0x24(%ecx),%eax
5ffb8a6c:	89 59 24             	mov    %ebx,0x24(%ecx)
5ffb8a6f:	89 50 20             	mov    %edx,0x20(%eax)
5ffb8a72:	8b 43 20             	mov    0x20(%ebx),%eax
5ffb8a75:	89 41 20             	mov    %eax,0x20(%ecx)
5ffb8a78:	8b 43 20             	mov    0x20(%ebx),%eax
5ffb8a7b:	89 4b 20             	mov    %ecx,0x20(%ebx)
5ffb8a7e:	89 48 24             	mov    %ecx,0x24(%eax)
5ffb8a81:	89 0d c0 c1 fb 5f    	mov    %ecx,0x5ffbc1c0
5ffb8a87:	c7 05 90 c1 fb 5f 00 	movl   $0x0,0x5ffbc190
5ffb8a8e:	00 00 00 
5ffb8a91:	e8 ba 89 ff ff       	call   5ffb1450 <@ConioDrawConsole@4>
5ffb8a96:	83 ec 0c             	sub    $0xc,%esp
5ffb8a99:	e9 f5 00 00 00       	jmp    5ffb8b93 <@TuiSwapConsole@4+0x173>
5ffb8a9e:	89 f6                	mov    %esi,%esi
5ffb8aa0:	83 ec 0c             	sub    $0xc,%esp
5ffb8aa3:	68 f0 c1 fb 5f       	push   $0x5ffbc1f0
5ffb8aa8:	e8 e3 01 00 00       	call   5ffb8c90 <_EnterCriticalSection@4>
5ffb8aad:	8b 0d 90 c1 fb 5f    	mov    0x5ffbc190,%ecx
5ffb8ab3:	83 c4 0c             	add    $0xc,%esp
5ffb8ab6:	85 c9                	test   %ecx,%ecx
5ffb8ab8:	0f 84 e9 00 00 00    	je     5ffb8ba7 <@TuiSwapConsole@4+0x187>
5ffb8abe:	85 db                	test   %ebx,%ebx
5ffb8ac0:	0f 8e 1a 01 00 00    	jle    5ffb8be0 <@TuiSwapConsole@4+0x1c0>
5ffb8ac6:	8b 41 24             	mov    0x24(%ecx),%eax
5ffb8ac9:	83 ec 0c             	sub    $0xc,%esp
5ffb8acc:	a3 90 c1 fb 5f       	mov    %eax,0x5ffbc190
5ffb8ad1:	83 c0 40             	add    $0x40,%eax
5ffb8ad4:	50                   	push   %eax
5ffb8ad5:	e8 86 01 00 00       	call   5ffb8c60 <_RtlUnicodeStringToAnsiSize@4>
5ffb8ada:	66 c7 45 f0 00 00    	movw   $0x0,0xfffffff0(%ebp)
5ffb8ae0:	66 89 45 f2          	mov    %ax,0xfffffff2(%ebp)
5ffb8ae4:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb8ae9:	5a                   	pop    %edx
5ffb8aea:	83 c0 04             	add    $0x4,%eax
5ffb8aed:	59                   	pop    %ecx
5ffb8aee:	50                   	push   %eax
5ffb8aef:	6a 00                	push   $0x0
5ffb8af1:	a1 e0 c1 fb 5f       	mov    0x5ffbc1e0,%eax
5ffb8af6:	50                   	push   %eax
5ffb8af7:	e8 f4 01 00 00       	call   5ffb8cf0 <_HeapAlloc@12>
5ffb8afc:	89 c3                	mov    %eax,%ebx
5ffb8afe:	8d 40 04             	lea    0x4(%eax),%eax
5ffb8b01:	89 45 f4             	mov    %eax,0xfffffff4(%ebp)
5ffb8b04:	6a 00                	push   $0x0
5ffb8b06:	a1 90 c1 fb 5f       	mov    0x5ffbc190,%eax
5ffb8b0b:	83 c0 40             	add    $0x40,%eax
5ffb8b0e:	50                   	push   %eax
5ffb8b0f:	8d 45 f0             	lea    0xfffffff0(%ebp),%eax
5ffb8b12:	50                   	push   %eax
5ffb8b13:	e8 58 01 00 00       	call   5ffb8c70 <_RtlUnicodeStringToAnsiString@12>
5ffb8b18:	66 a1 a2 c1 fb 5f    	mov    0x5ffbc1a2,%ax
5ffb8b1e:	8b 0d c0 c1 fb 5f    	mov    0x5ffbc1c0,%ecx
5ffb8b24:	89 c2                	mov    %eax,%edx
5ffb8b26:	66 c1 ea 0f          	shr    $0xf,%dx
5ffb8b2a:	01 d0                	add    %edx,%eax
5ffb8b2c:	66 d1 f8             	sar    %ax
5ffb8b2f:	66 89 43 02          	mov    %ax,0x2(%ebx)
5ffb8b33:	0f bf 15 a0 c1 fb 5f 	movswl 0x5ffbc1a0,%edx
5ffb8b3a:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
5ffb8b3d:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb8b42:	29 c2                	sub    %eax,%edx
5ffb8b44:	89 d0                	mov    %edx,%eax
5ffb8b46:	c1 e8 1f             	shr    $0x1f,%eax
5ffb8b49:	01 c2                	add    %eax,%edx
5ffb8b4b:	d1 fa                	sar    %edx
5ffb8b4d:	66 89 13             	mov    %dx,(%ebx)
5ffb8b50:	58                   	pop    %eax
5ffb8b51:	e8 fa 88 ff ff       	call   5ffb1450 <@ConioDrawConsole@4>
5ffb8b56:	8d 45 ec             	lea    0xffffffec(%ebp),%eax
5ffb8b59:	6a 00                	push   $0x0
5ffb8b5b:	50                   	push   %eax
5ffb8b5c:	8b 45 f0             	mov    0xfffffff0(%ebp),%eax
5ffb8b5f:	25 ff ff 00 00       	and    $0xffff,%eax
5ffb8b64:	83 c0 04             	add    $0x4,%eax
5ffb8b67:	50                   	push   %eax
5ffb8b68:	53                   	push   %ebx
5ffb8b69:	6a 00                	push   $0x0
5ffb8b6b:	6a 00                	push   $0x0
5ffb8b6d:	68 89 20 1c 00       	push   $0x1c2089
5ffb8b72:	a1 b0 c1 fb 5f       	mov    0x5ffbc1b0,%eax
5ffb8b77:	50                   	push   %eax
5ffb8b78:	e8 83 02 00 00       	call   5ffb8e00 <_DeviceIoControl@32>
5ffb8b7d:	85 c0                	test   %eax,%eax
5ffb8b7f:	74 37                	je     5ffb8bb8 <@TuiSwapConsole@4+0x198>
5ffb8b81:	50                   	push   %eax
5ffb8b82:	53                   	push   %ebx
5ffb8b83:	6a 00                	push   $0x0
5ffb8b85:	8b 1d e0 c1 fb 5f    	mov    0x5ffbc1e0,%ebx
5ffb8b8b:	53                   	push   %ebx
5ffb8b8c:	e8 6f 01 00 00       	call   5ffb8d00 <_HeapFree@12>
5ffb8b91:	51                   	push   %ecx
5ffb8b92:	51                   	push   %ecx
5ffb8b93:	68 f0 c1 fb 5f       	push   $0x5ffbc1f0
5ffb8b98:	e8 03 01 00 00       	call   5ffb8ca0 <_LeaveCriticalSection@4>
5ffb8b9d:	b8 01 00 00 00       	mov    $0x1,%eax
5ffb8ba2:	8b 5d fc             	mov    0xfffffffc(%ebp),%ebx
5ffb8ba5:	c9                   	leave  
5ffb8ba6:	c3                   	ret    
5ffb8ba7:	8b 0d c0 c1 fb 5f    	mov    0x5ffbc1c0,%ecx
5ffb8bad:	89 0d 90 c1 fb 5f    	mov    %ecx,0x5ffbc190
5ffb8bb3:	e9 06 ff ff ff       	jmp    5ffb8abe <@TuiSwapConsole@4+0x9e>
5ffb8bb8:	50                   	push   %eax
5ffb8bb9:	68 39 01 00 00       	push   $0x139
5ffb8bbe:	68 70 b6 fb 5f       	push   $0x5ffbb670
5ffb8bc3:	68 7d b6 fb 5f       	push   $0x5ffbb67d
5ffb8bc8:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb8bce:	c7 04 24 5e b7 fb 5f 	movl   $0x5ffbb75e,(%esp)
5ffb8bd5:	ff 15 c4 e2 fb 5f    	call   *0x5ffbe2c4
5ffb8bdb:	83 c4 10             	add    $0x10,%esp
5ffb8bde:	eb a1                	jmp    5ffb8b81 <@TuiSwapConsole@4+0x161>
5ffb8be0:	8b 41 20             	mov    0x20(%ecx),%eax
5ffb8be3:	e9 e1 fe ff ff       	jmp    5ffb8ac9 <@TuiSwapConsole@4+0xa9>
5ffb8be8:	90                   	nop    
5ffb8be9:	90                   	nop    
5ffb8bea:	90                   	nop    
5ffb8beb:	90                   	nop    
5ffb8bec:	90                   	nop    
5ffb8bed:	90                   	nop    
5ffb8bee:	90                   	nop    
5ffb8bef:	90                   	nop    

5ffb8bf0 <_DbgPrint>:
5ffb8bf0:	ff 25 c4 e2 fb 5f    	jmp    *0x5ffbe2c4
5ffb8bf6:	90                   	nop    
5ffb8bf7:	90                   	nop    
	...

5ffb8c00 <_NtOpenProcess@16>:
5ffb8c00:	ff 25 cc e2 fb 5f    	jmp    *0x5ffbe2cc
5ffb8c06:	90                   	nop    
5ffb8c07:	90                   	nop    
	...

5ffb8c10 <_RtlFreeUnicodeString@4>:
5ffb8c10:	ff 25 d4 e2 fb 5f    	jmp    *0x5ffbe2d4
5ffb8c16:	90                   	nop    
5ffb8c17:	90                   	nop    
	...

5ffb8c20 <_RtlCreateUnicodeString@8>:
5ffb8c20:	ff 25 d0 e2 fb 5f    	jmp    *0x5ffbe2d0
5ffb8c26:	90                   	nop    
5ffb8c27:	90                   	nop    
	...

5ffb8c30 <_memcpy>:
5ffb8c30:	ff 25 e0 e2 fb 5f    	jmp    *0x5ffbe2e0
5ffb8c36:	90                   	nop    
5ffb8c37:	90                   	nop    
	...

5ffb8c40 <_wcscpy>:
5ffb8c40:	ff 25 e4 e2 fb 5f    	jmp    *0x5ffbe2e4
5ffb8c46:	90                   	nop    
5ffb8c47:	90                   	nop    
	...

5ffb8c50 <_NtClose@4>:
5ffb8c50:	ff 25 c8 e2 fb 5f    	jmp    *0x5ffbe2c8
5ffb8c56:	90                   	nop    
5ffb8c57:	90                   	nop    
	...

5ffb8c60 <_RtlUnicodeStringToAnsiSize@4>:
5ffb8c60:	ff 25 d8 e2 fb 5f    	jmp    *0x5ffbe2d8
5ffb8c66:	90                   	nop    
5ffb8c67:	90                   	nop    
	...

5ffb8c70 <_RtlUnicodeStringToAnsiString@12>:
5ffb8c70:	ff 25 dc e2 fb 5f    	jmp    *0x5ffbe2dc
5ffb8c76:	90                   	nop    
5ffb8c77:	90                   	nop    
	...

5ffb8c80 <_InitializeCriticalSection@4>:
5ffb8c80:	ff 25 8c e2 fb 5f    	jmp    *0x5ffbe28c
5ffb8c86:	90                   	nop    
5ffb8c87:	90                   	nop    
	...

5ffb8c90 <_EnterCriticalSection@4>:
5ffb8c90:	ff 25 70 e2 fb 5f    	jmp    *0x5ffbe270
5ffb8c96:	90                   	nop    
5ffb8c97:	90                   	nop    
	...

5ffb8ca0 <_LeaveCriticalSection@4>:
5ffb8ca0:	ff 25 9c e2 fb 5f    	jmp    *0x5ffbe29c
5ffb8ca6:	90                   	nop    
5ffb8ca7:	90                   	nop    
	...

5ffb8cb0 <_CreateThread@24>:
5ffb8cb0:	ff 25 60 e2 fb 5f    	jmp    *0x5ffbe260
5ffb8cb6:	90                   	nop    
5ffb8cb7:	90                   	nop    
	...

5ffb8cc0 <_CloseHandle@4>:
5ffb8cc0:	ff 25 50 e2 fb 5f    	jmp    *0x5ffbe250
5ffb8cc6:	90                   	nop    
5ffb8cc7:	90                   	nop    
	...

5ffb8cd0 <_CreateRemoteThread@28>:
5ffb8cd0:	ff 25 5c e2 fb 5f    	jmp    *0x5ffbe25c
5ffb8cd6:	90                   	nop    
5ffb8cd7:	90                   	nop    
	...

5ffb8ce0 <_GetLastError@0>:
5ffb8ce0:	ff 25 78 e2 fb 5f    	jmp    *0x5ffbe278
5ffb8ce6:	90                   	nop    
5ffb8ce7:	90                   	nop    
	...

5ffb8cf0 <_HeapAlloc@12>:
5ffb8cf0:	ff 25 84 e2 fb 5f    	jmp    *0x5ffbe284
5ffb8cf6:	90                   	nop    
5ffb8cf7:	90                   	nop    
	...

5ffb8d00 <_HeapFree@12>:
5ffb8d00:	ff 25 88 e2 fb 5f    	jmp    *0x5ffbe288
5ffb8d06:	90                   	nop    
5ffb8d07:	90                   	nop    
	...

5ffb8d10 <_ResetEvent@4>:
5ffb8d10:	ff 25 a4 e2 fb 5f    	jmp    *0x5ffbe2a4
5ffb8d16:	90                   	nop    
5ffb8d17:	90                   	nop    
	...

5ffb8d20 <_WideCharToMultiByte@32>:
5ffb8d20:	ff 25 b4 e2 fb 5f    	jmp    *0x5ffbe2b4
5ffb8d26:	90                   	nop    
5ffb8d27:	90                   	nop    
	...

5ffb8d30 <_DeleteCriticalSection@4>:
5ffb8d30:	ff 25 64 e2 fb 5f    	jmp    *0x5ffbe264
5ffb8d36:	90                   	nop    
5ffb8d37:	90                   	nop    
	...

5ffb8d40 <_GetOEMCP@0>:
5ffb8d40:	ff 25 80 e2 fb 5f    	jmp    *0x5ffbe280
5ffb8d46:	90                   	nop    
5ffb8d47:	90                   	nop    
	...

5ffb8d50 <_CreateEventW@16>:
5ffb8d50:	ff 25 54 e2 fb 5f    	jmp    *0x5ffbe254
5ffb8d56:	90                   	nop    
5ffb8d57:	90                   	nop    
	...

5ffb8d60 <_GetCurrentProcess@0>:
5ffb8d60:	ff 25 74 e2 fb 5f    	jmp    *0x5ffbe274
5ffb8d66:	90                   	nop    
5ffb8d67:	90                   	nop    
	...

5ffb8d70 <_DuplicateHandle@28>:
5ffb8d70:	ff 25 6c e2 fb 5f    	jmp    *0x5ffbe26c
5ffb8d76:	90                   	nop    
5ffb8d77:	90                   	nop    
	...

5ffb8d80 <_SetEvent@4>:
5ffb8d80:	ff 25 a8 e2 fb 5f    	jmp    *0x5ffbe2a8
5ffb8d86:	90                   	nop    
5ffb8d87:	90                   	nop    
	...

5ffb8d90 <_InterlockedDecrement@4>:
5ffb8d90:	ff 25 90 e2 fb 5f    	jmp    *0x5ffbe290
5ffb8d96:	90                   	nop    
5ffb8d97:	90                   	nop    
	...

5ffb8da0 <_InterlockedIncrement@4>:
5ffb8da0:	ff 25 94 e2 fb 5f    	jmp    *0x5ffbe294
5ffb8da6:	90                   	nop    
5ffb8da7:	90                   	nop    
	...

5ffb8db0 <_MultiByteToWideChar@24>:
5ffb8db0:	ff 25 a0 e2 fb 5f    	jmp    *0x5ffbe2a0
5ffb8db6:	90                   	nop    
5ffb8db7:	90                   	nop    
	...

5ffb8dc0 <_IsValidCodePage@4>:
5ffb8dc0:	ff 25 98 e2 fb 5f    	jmp    *0x5ffbe298
5ffb8dc6:	90                   	nop    
5ffb8dc7:	90                   	nop    
	...

5ffb8dd0 <_GetModuleHandleW@4>:
5ffb8dd0:	ff 25 7c e2 fb 5f    	jmp    *0x5ffbe27c
5ffb8dd6:	90                   	nop    
5ffb8dd7:	90                   	nop    
	...

5ffb8de0 <_WaitForSingleObject@8>:
5ffb8de0:	ff 25 b0 e2 fb 5f    	jmp    *0x5ffbe2b0
5ffb8de6:	90                   	nop    
5ffb8de7:	90                   	nop    
	...

5ffb8df0 <_SetThreadPriority@8>:
5ffb8df0:	ff 25 ac e2 fb 5f    	jmp    *0x5ffbe2ac
5ffb8df6:	90                   	nop    
5ffb8df7:	90                   	nop    
	...

5ffb8e00 <_DeviceIoControl@32>:
5ffb8e00:	ff 25 68 e2 fb 5f    	jmp    *0x5ffbe268
5ffb8e06:	90                   	nop    
5ffb8e07:	90                   	nop    
	...

5ffb8e10 <_WriteFile@20>:
5ffb8e10:	ff 25 b8 e2 fb 5f    	jmp    *0x5ffbe2b8
5ffb8e16:	90                   	nop    
5ffb8e17:	90                   	nop    
	...

5ffb8e20 <_CreateFileW@28>:
5ffb8e20:	ff 25 58 e2 fb 5f    	jmp    *0x5ffbe258
5ffb8e26:	90                   	nop    
5ffb8e27:	90                   	nop    
	...

5ffb8e30 <_PrivateCsrssInitialized@0>:
5ffb8e30:	ff 25 64 e3 fb 5f    	jmp    *0x5ffbe364
5ffb8e36:	90                   	nop    
5ffb8e37:	90                   	nop    
	...

5ffb8e40 <_PrivateCsrssManualGuiCheck@4>:
5ffb8e40:	ff 25 68 e3 fb 5f    	jmp    *0x5ffbe368
5ffb8e46:	90                   	nop    
5ffb8e47:	90                   	nop    
	...

5ffb8e50 <_GetKeyboardState@4>:
5ffb8e50:	ff 25 0c e3 fb 5f    	jmp    *0x5ffbe30c
5ffb8e56:	90                   	nop    
5ffb8e57:	90                   	nop    
	...

5ffb8e60 <_ToUnicodeEx@28>:
5ffb8e60:	ff 25 9c e3 fb 5f    	jmp    *0x5ffbe39c
5ffb8e66:	90                   	nop    
5ffb8e67:	90                   	nop    
	...

5ffb8e70 <_PeekMessageW@20>:
5ffb8e70:	ff 25 54 e3 fb 5f    	jmp    *0x5ffbe354
5ffb8e76:	90                   	nop    
5ffb8e77:	90                   	nop    
	...

5ffb8e80 <_PrivateCsrssRegisterPrimitive@0>:
5ffb8e80:	ff 25 6c e3 fb 5f    	jmp    *0x5ffbe36c
5ffb8e86:	90                   	nop    
5ffb8e87:	90                   	nop    
	...

5ffb8e90 <_PrivateCsrssAcquireOrReleaseInputOwnership@4>:
5ffb8e90:	ff 25 60 e3 fb 5f    	jmp    *0x5ffbe360
5ffb8e96:	90                   	nop    
5ffb8e97:	90                   	nop    
	...

5ffb8ea0 <_GetMessageW@16>:
5ffb8ea0:	ff 25 10 e3 fb 5f    	jmp    *0x5ffbe310
5ffb8ea6:	90                   	nop    
5ffb8ea7:	90                   	nop    
	...

5ffb8eb0 <_TranslateMessage@4>:
5ffb8eb0:	ff 25 a0 e3 fb 5f    	jmp    *0x5ffbe3a0
5ffb8eb6:	90                   	nop    
5ffb8eb7:	90                   	nop    
	...

5ffb8ec0 <_LoadCursorW@8>:
5ffb8ec0:	ff 25 40 e3 fb 5f    	jmp    *0x5ffbe340
5ffb8ec6:	90                   	nop    
5ffb8ec7:	90                   	nop    
	...

5ffb8ed0 <_SetCursor@4>:
5ffb8ed0:	ff 25 84 e3 fb 5f    	jmp    *0x5ffbe384
5ffb8ed6:	90                   	nop    
5ffb8ed7:	90                   	nop    
	...

5ffb8ee0 <_SetWindowPos@28>:
5ffb8ee0:	ff 25 94 e3 fb 5f    	jmp    *0x5ffbe394
5ffb8ee6:	90                   	nop    
5ffb8ee7:	90                   	nop    
	...

5ffb8ef0 <_UpdateWindow@4>:
5ffb8ef0:	ff 25 a4 e3 fb 5f    	jmp    *0x5ffbe3a4
5ffb8ef6:	90                   	nop    
5ffb8ef7:	90                   	nop    
	...

5ffb8f00 <_GetUpdateRect@12>:
5ffb8f00:	ff 25 1c e3 fb 5f    	jmp    *0x5ffbe31c
5ffb8f06:	90                   	nop    
5ffb8f07:	90                   	nop    
	...

5ffb8f10 <_BeginPaint@8>:
5ffb8f10:	ff 25 f0 e2 fb 5f    	jmp    *0x5ffbe2f0
5ffb8f16:	90                   	nop    
5ffb8f17:	90                   	nop    
	...

5ffb8f20 <_PaintDesktop@4>:
5ffb8f20:	ff 25 50 e3 fb 5f    	jmp    *0x5ffbe350
5ffb8f26:	90                   	nop    
5ffb8f27:	90                   	nop    
	...

5ffb8f30 <_EndPaint@8>:
5ffb8f30:	ff 25 04 e3 fb 5f    	jmp    *0x5ffbe304
5ffb8f36:	90                   	nop    
5ffb8f37:	90                   	nop    
	...

5ffb8f40 <_SetThreadDesktop@4>:
5ffb8f40:	ff 25 88 e3 fb 5f    	jmp    *0x5ffbe388
5ffb8f46:	90                   	nop    
5ffb8f47:	90                   	nop    
	...

5ffb8f50 <_CreateWindowExW@48>:
5ffb8f50:	ff 25 f4 e2 fb 5f    	jmp    *0x5ffbe2f4
5ffb8f56:	90                   	nop    
5ffb8f57:	90                   	nop    
	...

5ffb8f60 <_DispatchMessageW@4>:
5ffb8f60:	ff 25 00 e3 fb 5f    	jmp    *0x5ffbe300
5ffb8f66:	90                   	nop    
5ffb8f67:	90                   	nop    
	...

5ffb8f70 <_GetSysColorBrush@4>:
5ffb8f70:	ff 25 14 e3 fb 5f    	jmp    *0x5ffbe314
5ffb8f76:	90                   	nop    
5ffb8f77:	90                   	nop    
	...

5ffb8f80 <_RegisterClassExW@4>:
5ffb8f80:	ff 25 70 e3 fb 5f    	jmp    *0x5ffbe370
5ffb8f86:	90                   	nop    
5ffb8f87:	90                   	nop    
	...

5ffb8f90 <_SendMessageW@16>:
5ffb8f90:	ff 25 7c e3 fb 5f    	jmp    *0x5ffbe37c
5ffb8f96:	90                   	nop    
5ffb8f97:	90                   	nop    
	...

5ffb8fa0 <_IsWindowVisible@4>:
5ffb8fa0:	ff 25 38 e3 fb 5f    	jmp    *0x5ffbe338
5ffb8fa6:	90                   	nop    
5ffb8fa7:	90                   	nop    
	...

5ffb8fb0 <_GetWindowThreadProcessId@8>:
5ffb8fb0:	ff 25 28 e3 fb 5f    	jmp    *0x5ffbe328
5ffb8fb6:	90                   	nop    
5ffb8fb7:	90                   	nop    
	...

5ffb8fc0 <_GetWindowLongW@8>:
5ffb8fc0:	ff 25 20 e3 fb 5f    	jmp    *0x5ffbe320
5ffb8fc6:	90                   	nop    
5ffb8fc7:	90                   	nop    
	...

5ffb8fd0 <_InvalidateRect@12>:
5ffb8fd0:	ff 25 30 e3 fb 5f    	jmp    *0x5ffbe330
5ffb8fd6:	90                   	nop    
5ffb8fd7:	90                   	nop    
	...

5ffb8fe0 <_InvalidateRgn@12>:
5ffb8fe0:	ff 25 34 e3 fb 5f    	jmp    *0x5ffbe334
5ffb8fe6:	90                   	nop    
5ffb8fe7:	90                   	nop    
	...

5ffb8ff0 <_GetDC@4>:
5ffb8ff0:	ff 25 08 e3 fb 5f    	jmp    *0x5ffbe308
5ffb8ff6:	90                   	nop    
5ffb8ff7:	90                   	nop    
	...

5ffb9000 <_ReleaseDC@8>:
5ffb9000:	ff 25 78 e3 fb 5f    	jmp    *0x5ffbe378
5ffb9006:	90                   	nop    
5ffb9007:	90                   	nop    
	...

5ffb9010 <_IntersectRect@12>:
5ffb9010:	ff 25 2c e3 fb 5f    	jmp    *0x5ffbe32c
5ffb9016:	90                   	nop    
5ffb9017:	90                   	nop    
	...

5ffb9020 <_DefWindowProcW@16>:
5ffb9020:	ff 25 f8 e2 fb 5f    	jmp    *0x5ffbe2f8
5ffb9026:	90                   	nop    
5ffb9027:	90                   	nop    
	...

5ffb9030 <_SetCapture@4>:
5ffb9030:	ff 25 80 e3 fb 5f    	jmp    *0x5ffbe380
5ffb9036:	90                   	nop    
5ffb9037:	90                   	nop    
	...

5ffb9040 <_ReleaseCapture@0>:
5ffb9040:	ff 25 74 e3 fb 5f    	jmp    *0x5ffbe374
5ffb9046:	90                   	nop    
5ffb9047:	90                   	nop    
	...

5ffb9050 <_KillTimer@8>:
5ffb9050:	ff 25 3c e3 fb 5f    	jmp    *0x5ffbe33c
5ffb9056:	90                   	nop    
5ffb9057:	90                   	nop    
	...

5ffb9060 <_SetWindowLongW@12>:
5ffb9060:	ff 25 90 e3 fb 5f    	jmp    *0x5ffbe390
5ffb9066:	90                   	nop    
5ffb9067:	90                   	nop    
	...

5ffb9070 <_GetWindowRect@8>:
5ffb9070:	ff 25 24 e3 fb 5f    	jmp    *0x5ffbe324
5ffb9076:	90                   	nop    
5ffb9077:	90                   	nop    
	...

5ffb9080 <_GetSystemMetrics@4>:
5ffb9080:	ff 25 18 e3 fb 5f    	jmp    *0x5ffbe318
5ffb9086:	90                   	nop    
5ffb9087:	90                   	nop    
	...

5ffb9090 <_MoveWindow@24>:
5ffb9090:	ff 25 4c e3 fb 5f    	jmp    *0x5ffbe34c
5ffb9096:	90                   	nop    
5ffb9097:	90                   	nop    
	...

5ffb90a0 <_SetTimer@16>:
5ffb90a0:	ff 25 8c e3 fb 5f    	jmp    *0x5ffbe38c
5ffb90a6:	90                   	nop    
5ffb90a7:	90                   	nop    
	...

5ffb90b0 <_ShowWindow@8>:
5ffb90b0:	ff 25 98 e3 fb 5f    	jmp    *0x5ffbe398
5ffb90b6:	90                   	nop    
5ffb90b7:	90                   	nop    
	...

5ffb90c0 <_DestroyWindow@4>:
5ffb90c0:	ff 25 fc e2 fb 5f    	jmp    *0x5ffbe2fc
5ffb90c6:	90                   	nop    
5ffb90c7:	90                   	nop    
	...

5ffb90d0 <_PostQuitMessage@4>:
5ffb90d0:	ff 25 5c e3 fb 5f    	jmp    *0x5ffbe35c
5ffb90d6:	90                   	nop    
5ffb90d7:	90                   	nop    
	...

5ffb90e0 <_LoadIconW@8>:
5ffb90e0:	ff 25 44 e3 fb 5f    	jmp    *0x5ffbe344
5ffb90e6:	90                   	nop    
5ffb90e7:	90                   	nop    
	...

5ffb90f0 <_LoadImageW@24>:
5ffb90f0:	ff 25 48 e3 fb 5f    	jmp    *0x5ffbe348
5ffb90f6:	90                   	nop    
5ffb90f7:	90                   	nop    
	...

5ffb9100 <_PostMessageW@16>:
5ffb9100:	ff 25 58 e3 fb 5f    	jmp    *0x5ffbe358
5ffb9106:	90                   	nop    
5ffb9107:	90                   	nop    
	...

5ffb9110 <_SetTextColor@8>:
5ffb9110:	ff 25 40 e2 fb 5f    	jmp    *0x5ffbe240
5ffb9116:	90                   	nop    
5ffb9117:	90                   	nop    
	...

5ffb9120 <_SetBkColor@8>:
5ffb9120:	ff 25 3c e2 fb 5f    	jmp    *0x5ffbe23c
5ffb9126:	90                   	nop    
5ffb9127:	90                   	nop    
	...

5ffb9130 <_CreateRectRgnIndirect@4>:
5ffb9130:	ff 25 20 e2 fb 5f    	jmp    *0x5ffbe220
5ffb9136:	90                   	nop    
5ffb9137:	90                   	nop    
	...

5ffb9140 <_CombineRgn@16>:
5ffb9140:	ff 25 10 e2 fb 5f    	jmp    *0x5ffbe210
5ffb9146:	90                   	nop    
5ffb9147:	90                   	nop    
	...

5ffb9150 <_DeleteObject@4>:
5ffb9150:	ff 25 2c e2 fb 5f    	jmp    *0x5ffbe22c
5ffb9156:	90                   	nop    
5ffb9157:	90                   	nop    
	...

5ffb9160 <_TextOutW@20>:
5ffb9160:	ff 25 44 e2 fb 5f    	jmp    *0x5ffbe244
5ffb9166:	90                   	nop    
5ffb9167:	90                   	nop    
	...

5ffb9170 <_CreateSolidBrush@4>:
5ffb9170:	ff 25 24 e2 fb 5f    	jmp    *0x5ffbe224
5ffb9176:	90                   	nop    
5ffb9177:	90                   	nop    
	...

5ffb9180 <_SelectObject@8>:
5ffb9180:	ff 25 38 e2 fb 5f    	jmp    *0x5ffbe238
5ffb9186:	90                   	nop    
5ffb9187:	90                   	nop    
	...

5ffb9190 <_PatBlt@24>:
5ffb9190:	ff 25 34 e2 fb 5f    	jmp    *0x5ffbe234
5ffb9196:	90                   	nop    
5ffb9197:	90                   	nop    
	...

5ffb91a0 <_BitBlt@36>:
5ffb91a0:	ff 25 0c e2 fb 5f    	jmp    *0x5ffbe20c
5ffb91a6:	90                   	nop    
5ffb91a7:	90                   	nop    
	...

5ffb91b0 <_CreateFontW@56>:
5ffb91b0:	ff 25 1c e2 fb 5f    	jmp    *0x5ffbe21c
5ffb91b6:	90                   	nop    
5ffb91b7:	90                   	nop    
	...

5ffb91c0 <_DeleteDC@4>:
5ffb91c0:	ff 25 28 e2 fb 5f    	jmp    *0x5ffbe228
5ffb91c6:	90                   	nop    
5ffb91c7:	90                   	nop    
	...

5ffb91d0 <_GetTextMetricsW@8>:
5ffb91d0:	ff 25 30 e2 fb 5f    	jmp    *0x5ffbe230
5ffb91d6:	90                   	nop    
5ffb91d7:	90                   	nop    
	...

5ffb91e0 <_CreateCompatibleDC@4>:
5ffb91e0:	ff 25 18 e2 fb 5f    	jmp    *0x5ffbe218
5ffb91e6:	90                   	nop    
5ffb91e7:	90                   	nop    
	...

5ffb91f0 <_CreateCompatibleBitmap@12>:
5ffb91f0:	ff 25 14 e2 fb 5f    	jmp    *0x5ffbe214
5ffb91f6:	90                   	nop    
5ffb91f7:	90                   	nop    
	...

5ffb9200 <__CTOR_LIST__>:
5ffb9200:	ff                   	(bad)  
5ffb9201:	ff                   	(bad)  
5ffb9202:	ff                   	(bad)  
5ffb9203:	ff 00                	incl   (%eax)
5ffb9205:	00 00                	add    %al,(%eax)
	...

5ffb9208 <__DTOR_LIST__>:
5ffb9208:	ff                   	(bad)  
5ffb9209:	ff                   	(bad)  
5ffb920a:	ff                   	(bad)  
5ffb920b:	ff 00                	incl   (%eax)
5ffb920d:	00 00                	add    %al,(%eax)
	...
