; Listing generated by Microsoft (R) Optimizing Compiler Version 15.00.21022.08 

	TITLE	c:\Develop\DScaler423a\DScaler\MultiMon.cpp
	.686P
	.XMM
	include listing.inc
	.model	flat

INCLUDELIB OLDNAMES

PUBLIC	_g_pfnGetSystemMetrics
PUBLIC	_g_pfnMonitorFromWindow
PUBLIC	_g_pfnMonitorFromRect
PUBLIC	_g_pfnMonitorFromPoint
PUBLIC	_g_pfnGetMonitorInfo
PUBLIC	_g_pfnEnumDisplayMonitors
PUBLIC	_g_pfnEnumDisplayDevices
PUBLIC	_g_fMultiMonInitDone
PUBLIC	_g_fMultimonPlatformNT
PUBLIC	??_C@_1O@HBFFNGEC@?$AAU?$AAS?$AAE?$AAR?$AA3?$AA2?$AA?$AA@ ; `string'
PUBLIC	??_C@_0BB@BFCABEPI@GetSystemMetrics?$AA@	; `string'
PUBLIC	??_C@_0BC@CHFENAPF@MonitorFromWindow?$AA@	; `string'
PUBLIC	??_C@_0BA@DPLKJPEB@MonitorFromRect?$AA@		; `string'
PUBLIC	??_C@_0BB@DDMDAIAD@MonitorFromPoint?$AA@	; `string'
PUBLIC	??_C@_0BE@OHNDFFJG@EnumDisplayMonitors?$AA@	; `string'
PUBLIC	??_C@_0BE@MDNGANML@EnumDisplayDevicesW?$AA@	; `string'
PUBLIC	??_C@_0BA@LEJEHBCO@GetMonitorInfoW?$AA@		; `string'
PUBLIC	??_C@_0BA@KIAMMEPJ@GetMonitorInfoA?$AA@		; `string'
PUBLIC	??_C@_07JPHDIPNG@DISPLAY?$AA@			; `string'
EXTRN	__imp__GetVersionExA@4:PROC
EXTRN	__imp__SystemParametersInfoA@16:PROC
EXTRN	__imp__GetClipBox@8:PROC
EXTRN	__imp__GetDCOrgEx@8:PROC
EXTRN	__imp__GetSystemMetrics@4:PROC
EXTRN	__imp__MultiByteToWideChar@24:PROC
_g_pfnGetSystemMetrics DD 01H DUP (?)
_g_pfnMonitorFromWindow DD 01H DUP (?)
_g_pfnMonitorFromRect DD 01H DUP (?)
_g_pfnMonitorFromPoint DD 01H DUP (?)
_g_pfnGetMonitorInfo DD 01H DUP (?)
_g_pfnEnumDisplayMonitors DD 01H DUP (?)
_g_pfnEnumDisplayDevices DD 01H DUP (?)
_g_fMultiMonInitDone DD 01H DUP (?)
_g_fMultimonPlatformNT DD 01H DUP (?)
;	COMDAT ??_C@_07JPHDIPNG@DISPLAY?$AA@
CONST	SEGMENT
??_C@_07JPHDIPNG@DISPLAY?$AA@ DB 'DISPLAY', 00H		; `string'
CONST	ENDS
;	COMDAT ??_C@_0BA@KIAMMEPJ@GetMonitorInfoA?$AA@
CONST	SEGMENT
??_C@_0BA@KIAMMEPJ@GetMonitorInfoA?$AA@ DB 'GetMonitorInfoA', 00H ; `string'
CONST	ENDS
;	COMDAT ??_C@_0BA@LEJEHBCO@GetMonitorInfoW?$AA@
CONST	SEGMENT
??_C@_0BA@LEJEHBCO@GetMonitorInfoW?$AA@ DB 'GetMonitorInfoW', 00H ; `string'
CONST	ENDS
;	COMDAT ??_C@_0BE@MDNGANML@EnumDisplayDevicesW?$AA@
CONST	SEGMENT
??_C@_0BE@MDNGANML@EnumDisplayDevicesW?$AA@ DB 'EnumDisplayDevicesW', 00H ; `string'
CONST	ENDS
;	COMDAT ??_C@_0BE@OHNDFFJG@EnumDisplayMonitors?$AA@
CONST	SEGMENT
??_C@_0BE@OHNDFFJG@EnumDisplayMonitors?$AA@ DB 'EnumDisplayMonitors', 00H ; `string'
CONST	ENDS
;	COMDAT ??_C@_0BB@DDMDAIAD@MonitorFromPoint?$AA@
CONST	SEGMENT
??_C@_0BB@DDMDAIAD@MonitorFromPoint?$AA@ DB 'MonitorFromPoint', 00H ; `string'
CONST	ENDS
;	COMDAT ??_C@_0BA@DPLKJPEB@MonitorFromRect?$AA@
CONST	SEGMENT
??_C@_0BA@DPLKJPEB@MonitorFromRect?$AA@ DB 'MonitorFromRect', 00H ; `string'
CONST	ENDS
;	COMDAT ??_C@_0BC@CHFENAPF@MonitorFromWindow?$AA@
CONST	SEGMENT
??_C@_0BC@CHFENAPF@MonitorFromWindow?$AA@ DB 'MonitorFromWindow', 00H ; `string'
CONST	ENDS
;	COMDAT ??_C@_0BB@BFCABEPI@GetSystemMetrics?$AA@
CONST	SEGMENT
??_C@_0BB@BFCABEPI@GetSystemMetrics?$AA@ DB 'GetSystemMetrics', 00H ; `string'
CONST	ENDS
;	COMDAT ??_C@_1O@HBFFNGEC@?$AAU?$AAS?$AAE?$AAR?$AA3?$AA2?$AA?$AA@
CONST	SEGMENT
??_C@_1O@HBFFNGEC@?$AAU?$AAS?$AAE?$AAR?$AA3?$AA2?$AA?$AA@ DB 'U', 00H, 'S'
	DB	00H, 'E', 00H, 'R', 00H, '3', 00H, '2', 00H, 00H, 00H ; `string'
PUBLIC	__$ArrayPad$
PUBLIC	_IsPlatformNT
; Function compile flags: /Odtp
; File c:\program files\microsoft sdks\windows\v6.1\include\multimon.h
;	COMDAT _IsPlatformNT
_TEXT	SEGMENT
_osvi$ = -160						; size = 148
__$ArrayPad$ = -4					; size = 4
_IsPlatformNT PROC					; COMDAT

; 177  : { 

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	81 ec a0 00 00
	00		 sub	 esp, 160		; 000000a0H
  00009	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  0000e	33 c5		 xor	 eax, ebp
  00010	89 45 fc	 mov	 DWORD PTR __$ArrayPad$[ebp], eax

; 178  :     OSVERSIONINFOA osvi = {0};

  00013	c7 85 60 ff ff
	ff 00 00 00 00	 mov	 DWORD PTR _osvi$[ebp], 0
  0001d	68 90 00 00 00	 push	 144			; 00000090H
  00022	6a 00		 push	 0
  00024	8d 85 64 ff ff
	ff		 lea	 eax, DWORD PTR _osvi$[ebp+4]
  0002a	50		 push	 eax
  0002b	e8 00 00 00 00	 call	 _memset
  00030	83 c4 0c	 add	 esp, 12			; 0000000cH

; 179  :     osvi.dwOSVersionInfoSize = sizeof(osvi);

  00033	c7 85 60 ff ff
	ff 94 00 00 00	 mov	 DWORD PTR _osvi$[ebp], 148 ; 00000094H

; 180  :     GetVersionExA((OSVERSIONINFOA*)&osvi);

  0003d	8d 8d 60 ff ff
	ff		 lea	 ecx, DWORD PTR _osvi$[ebp]
  00043	51		 push	 ecx
  00044	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetVersionExA@4

; 181  :     return (VER_PLATFORM_WIN32_NT == osvi.dwPlatformId);    

  0004a	33 c0		 xor	 eax, eax
  0004c	83 bd 70 ff ff
	ff 02		 cmp	 DWORD PTR _osvi$[ebp+16], 2
  00053	0f 94 c0	 sete	 al

; 182  : }

  00056	8b 4d fc	 mov	 ecx, DWORD PTR __$ArrayPad$[ebp]
  00059	33 cd		 xor	 ecx, ebp
  0005b	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00060	8b e5		 mov	 esp, ebp
  00062	5d		 pop	 ebp
  00063	c3		 ret	 0
_IsPlatformNT ENDP
PUBLIC	_InitMultipleMonitorStubs
; Function compile flags: /Odtp
;	COMDAT _InitMultipleMonitorStubs
_TEXT	SEGMENT
tv134 = -8						; size = 4
_hUser32$ = -4						; size = 4
_InitMultipleMonitorStubs PROC				; COMDAT

; 185  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 08	 sub	 esp, 8

; 186  :     HMODULE hUser32;
; 187  :     if (g_fMultiMonInitDone)

  00006	83 3d 00 00 00
	00 00		 cmp	 DWORD PTR _g_fMultiMonInitDone, 0
  0000d	74 11		 je	 SHORT $LN3@InitMultip

; 188  :     {
; 189  :         return g_pfnGetMonitorInfo != NULL;

  0000f	33 c0		 xor	 eax, eax
  00011	83 3d 00 00 00
	00 00		 cmp	 DWORD PTR _g_pfnGetMonitorInfo, 0
  00018	0f 95 c0	 setne	 al
  0001b	e9 86 01 00 00	 jmp	 $LN4@InitMultip
$LN3@InitMultip:

; 190  :     }
; 191  : 
; 192  :     g_fMultimonPlatformNT = IsPlatformNT();

  00020	e8 00 00 00 00	 call	 _IsPlatformNT
  00025	a3 00 00 00 00	 mov	 DWORD PTR _g_fMultimonPlatformNT, eax

; 193  :     hUser32 = GetModuleHandle(TEXT("USER32"));

  0002a	68 00 00 00 00	 push	 OFFSET ??_C@_1O@HBFFNGEC@?$AAU?$AAS?$AAE?$AAR?$AA3?$AA2?$AA?$AA@
  0002f	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetModuleHandleW@4
  00035	89 45 fc	 mov	 DWORD PTR _hUser32$[ebp], eax

; 194  :     if (hUser32 &&
; 195  :         (*(FARPROC*)&g_pfnGetSystemMetrics    = GetProcAddress(hUser32,"GetSystemMetrics")) != NULL &&
; 196  :         (*(FARPROC*)&g_pfnMonitorFromWindow   = GetProcAddress(hUser32,"MonitorFromWindow")) != NULL &&
; 197  :         (*(FARPROC*)&g_pfnMonitorFromRect     = GetProcAddress(hUser32,"MonitorFromRect")) != NULL &&
; 198  :         (*(FARPROC*)&g_pfnMonitorFromPoint    = GetProcAddress(hUser32,"MonitorFromPoint")) != NULL &&
; 199  :         (*(FARPROC*)&g_pfnEnumDisplayMonitors = GetProcAddress(hUser32,"EnumDisplayMonitors")) != NULL &&
; 200  : #ifdef UNICODE
; 201  :         (*(FARPROC*)&g_pfnEnumDisplayDevices  = GetProcAddress(hUser32,"EnumDisplayDevicesW")) != NULL &&
; 202  :         (*(FARPROC*)&g_pfnGetMonitorInfo      = g_fMultimonPlatformNT ? GetProcAddress(hUser32,"GetMonitorInfoW") : 
; 203  :                                                 GetProcAddress(hUser32,"GetMonitorInfoA")) != NULL
; 204  : #else
; 205  :         (*(FARPROC*)&g_pfnGetMonitorInfo      = GetProcAddress(hUser32,"GetMonitorInfoA")) != NULL &&
; 206  :         (*(FARPROC*)&g_pfnEnumDisplayDevices  = GetProcAddress(hUser32,"EnumDisplayDevicesA")) != NULL
; 207  : #endif
; 208  :     ) {

  00038	83 7d fc 00	 cmp	 DWORD PTR _hUser32$[ebp], 0
  0003c	0f 84 12 01 00
	00		 je	 $LN2@InitMultip
  00042	68 00 00 00 00	 push	 OFFSET ??_C@_0BB@BFCABEPI@GetSystemMetrics?$AA@
  00047	8b 45 fc	 mov	 eax, DWORD PTR _hUser32$[ebp]
  0004a	50		 push	 eax
  0004b	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetProcAddress@8
  00051	a3 00 00 00 00	 mov	 DWORD PTR _g_pfnGetSystemMetrics, eax
  00056	83 3d 00 00 00
	00 00		 cmp	 DWORD PTR _g_pfnGetSystemMetrics, 0
  0005d	0f 84 f1 00 00
	00		 je	 $LN2@InitMultip
  00063	68 00 00 00 00	 push	 OFFSET ??_C@_0BC@CHFENAPF@MonitorFromWindow?$AA@
  00068	8b 4d fc	 mov	 ecx, DWORD PTR _hUser32$[ebp]
  0006b	51		 push	 ecx
  0006c	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetProcAddress@8
  00072	a3 00 00 00 00	 mov	 DWORD PTR _g_pfnMonitorFromWindow, eax
  00077	83 3d 00 00 00
	00 00		 cmp	 DWORD PTR _g_pfnMonitorFromWindow, 0
  0007e	0f 84 d0 00 00
	00		 je	 $LN2@InitMultip
  00084	68 00 00 00 00	 push	 OFFSET ??_C@_0BA@DPLKJPEB@MonitorFromRect?$AA@
  00089	8b 55 fc	 mov	 edx, DWORD PTR _hUser32$[ebp]
  0008c	52		 push	 edx
  0008d	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetProcAddress@8
  00093	a3 00 00 00 00	 mov	 DWORD PTR _g_pfnMonitorFromRect, eax
  00098	83 3d 00 00 00
	00 00		 cmp	 DWORD PTR _g_pfnMonitorFromRect, 0
  0009f	0f 84 af 00 00
	00		 je	 $LN2@InitMultip
  000a5	68 00 00 00 00	 push	 OFFSET ??_C@_0BB@DDMDAIAD@MonitorFromPoint?$AA@
  000aa	8b 45 fc	 mov	 eax, DWORD PTR _hUser32$[ebp]
  000ad	50		 push	 eax
  000ae	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetProcAddress@8
  000b4	a3 00 00 00 00	 mov	 DWORD PTR _g_pfnMonitorFromPoint, eax
  000b9	83 3d 00 00 00
	00 00		 cmp	 DWORD PTR _g_pfnMonitorFromPoint, 0
  000c0	0f 84 8e 00 00
	00		 je	 $LN2@InitMultip
  000c6	68 00 00 00 00	 push	 OFFSET ??_C@_0BE@OHNDFFJG@EnumDisplayMonitors?$AA@
  000cb	8b 4d fc	 mov	 ecx, DWORD PTR _hUser32$[ebp]
  000ce	51		 push	 ecx
  000cf	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetProcAddress@8
  000d5	a3 00 00 00 00	 mov	 DWORD PTR _g_pfnEnumDisplayMonitors, eax
  000da	83 3d 00 00 00
	00 00		 cmp	 DWORD PTR _g_pfnEnumDisplayMonitors, 0
  000e1	74 71		 je	 SHORT $LN2@InitMultip
  000e3	68 00 00 00 00	 push	 OFFSET ??_C@_0BE@MDNGANML@EnumDisplayDevicesW?$AA@
  000e8	8b 55 fc	 mov	 edx, DWORD PTR _hUser32$[ebp]
  000eb	52		 push	 edx
  000ec	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetProcAddress@8
  000f2	a3 00 00 00 00	 mov	 DWORD PTR _g_pfnEnumDisplayDevices, eax
  000f7	83 3d 00 00 00
	00 00		 cmp	 DWORD PTR _g_pfnEnumDisplayDevices, 0
  000fe	74 54		 je	 SHORT $LN2@InitMultip
  00100	83 3d 00 00 00
	00 00		 cmp	 DWORD PTR _g_fMultimonPlatformNT, 0
  00107	74 14		 je	 SHORT $LN6@InitMultip
  00109	68 00 00 00 00	 push	 OFFSET ??_C@_0BA@LEJEHBCO@GetMonitorInfoW?$AA@
  0010e	8b 45 fc	 mov	 eax, DWORD PTR _hUser32$[ebp]
  00111	50		 push	 eax
  00112	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetProcAddress@8
  00118	89 45 f8	 mov	 DWORD PTR tv134[ebp], eax
  0011b	eb 12		 jmp	 SHORT $LN7@InitMultip
$LN6@InitMultip:
  0011d	68 00 00 00 00	 push	 OFFSET ??_C@_0BA@KIAMMEPJ@GetMonitorInfoA?$AA@
  00122	8b 4d fc	 mov	 ecx, DWORD PTR _hUser32$[ebp]
  00125	51		 push	 ecx
  00126	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetProcAddress@8
  0012c	89 45 f8	 mov	 DWORD PTR tv134[ebp], eax
$LN7@InitMultip:
  0012f	8b 55 f8	 mov	 edx, DWORD PTR tv134[ebp]
  00132	89 15 00 00 00
	00		 mov	 DWORD PTR _g_pfnGetMonitorInfo, edx
  00138	83 3d 00 00 00
	00 00		 cmp	 DWORD PTR _g_pfnGetMonitorInfo, 0
  0013f	74 13		 je	 SHORT $LN2@InitMultip

; 209  :         g_fMultiMonInitDone = TRUE;

  00141	c7 05 00 00 00
	00 01 00 00 00	 mov	 DWORD PTR _g_fMultiMonInitDone, 1

; 210  :         return TRUE;

  0014b	b8 01 00 00 00	 mov	 eax, 1
  00150	eb 54		 jmp	 SHORT $LN4@InitMultip

; 211  :     }
; 212  :     else

  00152	eb 52		 jmp	 SHORT $LN4@InitMultip
$LN2@InitMultip:

; 213  :     {
; 214  :         g_pfnGetSystemMetrics    = NULL;

  00154	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _g_pfnGetSystemMetrics, 0

; 215  :         g_pfnMonitorFromWindow   = NULL;

  0015e	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _g_pfnMonitorFromWindow, 0

; 216  :         g_pfnMonitorFromRect     = NULL;

  00168	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _g_pfnMonitorFromRect, 0

; 217  :         g_pfnMonitorFromPoint    = NULL;

  00172	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _g_pfnMonitorFromPoint, 0

; 218  :         g_pfnGetMonitorInfo      = NULL;

  0017c	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _g_pfnGetMonitorInfo, 0

; 219  :         g_pfnEnumDisplayMonitors = NULL;

  00186	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _g_pfnEnumDisplayMonitors, 0

; 220  :         g_pfnEnumDisplayDevices  = NULL;

  00190	c7 05 00 00 00
	00 00 00 00 00	 mov	 DWORD PTR _g_pfnEnumDisplayDevices, 0

; 221  : 
; 222  :         g_fMultiMonInitDone = TRUE;

  0019a	c7 05 00 00 00
	00 01 00 00 00	 mov	 DWORD PTR _g_fMultiMonInitDone, 1

; 223  :         return FALSE;

  001a4	33 c0		 xor	 eax, eax
$LN4@InitMultip:

; 224  :     }
; 225  : }

  001a6	8b e5		 mov	 esp, ebp
  001a8	5d		 pop	 ebp
  001a9	c3		 ret	 0
_InitMultipleMonitorStubs ENDP
PUBLIC	_xEnumDisplayDevices@16
; Function compile flags: /Odtp
;	COMDAT _xEnumDisplayDevices@16
_TEXT	SEGMENT
_Unused$ = 8						; size = 4
_iDevNum$ = 12						; size = 4
_lpDisplayDevice$ = 16					; size = 4
_dwFlags$ = 20						; size = 4
_xEnumDisplayDevices@16 PROC				; COMDAT

; 441  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp

; 442  :     if (InitMultipleMonitorStubs())

  00003	e8 00 00 00 00	 call	 _InitMultipleMonitorStubs
  00008	85 c0		 test	 eax, eax
  0000a	74 18		 je	 SHORT $LN5@xEnumDispl

; 443  :         return g_pfnEnumDisplayDevices(Unused, iDevNum, lpDisplayDevice, dwFlags);

  0000c	8b 45 14	 mov	 eax, DWORD PTR _dwFlags$[ebp]
  0000f	50		 push	 eax
  00010	8b 4d 10	 mov	 ecx, DWORD PTR _lpDisplayDevice$[ebp]
  00013	51		 push	 ecx
  00014	8b 55 0c	 mov	 edx, DWORD PTR _iDevNum$[ebp]
  00017	52		 push	 edx
  00018	8b 45 08	 mov	 eax, DWORD PTR _Unused$[ebp]
  0001b	50		 push	 eax
  0001c	ff 15 00 00 00
	00		 call	 DWORD PTR _g_pfnEnumDisplayDevices
  00022	eb 72		 jmp	 SHORT $LN6@xEnumDispl
$LN5@xEnumDispl:

; 444  : 
; 445  :     if (Unused != NULL)

  00024	83 7d 08 00	 cmp	 DWORD PTR _Unused$[ebp], 0
  00028	74 04		 je	 SHORT $LN4@xEnumDispl

; 446  :         return FALSE;

  0002a	33 c0		 xor	 eax, eax
  0002c	eb 68		 jmp	 SHORT $LN6@xEnumDispl
$LN4@xEnumDispl:

; 447  : 
; 448  :     if (iDevNum != 0)

  0002e	83 7d 0c 00	 cmp	 DWORD PTR _iDevNum$[ebp], 0
  00032	74 04		 je	 SHORT $LN3@xEnumDispl

; 449  :         return FALSE;

  00034	33 c0		 xor	 eax, eax
  00036	eb 5e		 jmp	 SHORT $LN6@xEnumDispl
$LN3@xEnumDispl:

; 450  : 
; 451  :     if (lpDisplayDevice == NULL || lpDisplayDevice->cb < sizeof(DISPLAY_DEVICE))

  00038	83 7d 10 00	 cmp	 DWORD PTR _lpDisplayDevice$[ebp], 0
  0003c	74 0b		 je	 SHORT $LN1@xEnumDispl
  0003e	8b 4d 10	 mov	 ecx, DWORD PTR _lpDisplayDevice$[ebp]
  00041	81 39 48 03 00
	00		 cmp	 DWORD PTR [ecx], 840	; 00000348H
  00047	73 04		 jae	 SHORT $LN2@xEnumDispl
$LN1@xEnumDispl:

; 452  :         return FALSE;

  00049	33 c0		 xor	 eax, eax
  0004b	eb 49		 jmp	 SHORT $LN6@xEnumDispl
$LN2@xEnumDispl:

; 453  : 
; 454  : #ifdef UNICODE
; 455  :     MultiByteToWideChar(CP_ACP, 0, "DISPLAY", -1, lpDisplayDevice->DeviceName, (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)));

  0004d	6a 20		 push	 32			; 00000020H
  0004f	8b 55 10	 mov	 edx, DWORD PTR _lpDisplayDevice$[ebp]
  00052	83 c2 04	 add	 edx, 4
  00055	52		 push	 edx
  00056	6a ff		 push	 -1
  00058	68 00 00 00 00	 push	 OFFSET ??_C@_07JPHDIPNG@DISPLAY?$AA@
  0005d	6a 00		 push	 0
  0005f	6a 00		 push	 0
  00061	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__MultiByteToWideChar@24

; 456  :     MultiByteToWideChar(CP_ACP, 0, "DISPLAY", -1, lpDisplayDevice->DeviceString, (sizeof(lpDisplayDevice->DeviceString)/sizeof(TCHAR)));

  00067	68 80 00 00 00	 push	 128			; 00000080H
  0006c	8b 45 10	 mov	 eax, DWORD PTR _lpDisplayDevice$[ebp]
  0006f	83 c0 44	 add	 eax, 68			; 00000044H
  00072	50		 push	 eax
  00073	6a ff		 push	 -1
  00075	68 00 00 00 00	 push	 OFFSET ??_C@_07JPHDIPNG@DISPLAY?$AA@
  0007a	6a 00		 push	 0
  0007c	6a 00		 push	 0
  0007e	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__MultiByteToWideChar@24

; 457  : #else // UNICODE
; 458  : #if _MULTIMON_USE_SECURE_CRT
; 459  :     strncpy_s((LPTSTR)lpDisplayDevice->DeviceName, (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)), TEXT("DISPLAY"), (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)) - 1);
; 460  :     strncpy_s((LPTSTR)lpDisplayDevice->DeviceString, (sizeof(lpDisplayDevice->DeviceString)/sizeof(TCHAR)), TEXT("DISPLAY"), (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)) - 1);
; 461  : #else
; 462  :     lstrcpyn((LPTSTR)lpDisplayDevice->DeviceName,   TEXT("DISPLAY"), (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)));
; 463  :     lstrcpyn((LPTSTR)lpDisplayDevice->DeviceString, TEXT("DISPLAY"), (sizeof(lpDisplayDevice->DeviceString)/sizeof(TCHAR)));
; 464  : #endif // _MULTIMON_USE_SECURE_CRT
; 465  : #endif // UNICODE
; 466  : 
; 467  :     lpDisplayDevice->StateFlags = DISPLAY_DEVICE_ATTACHED_TO_DESKTOP | DISPLAY_DEVICE_PRIMARY_DEVICE;

  00084	8b 4d 10	 mov	 ecx, DWORD PTR _lpDisplayDevice$[ebp]
  00087	c7 81 44 01 00
	00 05 00 00 00	 mov	 DWORD PTR [ecx+324], 5

; 468  : 
; 469  :     return TRUE;

  00091	b8 01 00 00 00	 mov	 eax, 1
$LN6@xEnumDispl:

; 470  : }

  00096	5d		 pop	 ebp
  00097	c2 10 00	 ret	 16			; 00000010H
_xEnumDisplayDevices@16 ENDP
_TEXT	ENDS
PUBLIC	_xEnumDisplayMonitors@16
; Function compile flags: /Odtp
;	COMDAT _xEnumDisplayMonitors@16
_TEXT	SEGMENT
tv80 = -44						; size = 4
_ptOrg$139492 = -40					; size = 8
_rcClip$139491 = -32					; size = 16
_rcLimit$ = -16						; size = 16
_hdcOptionalForPainting$ = 8				; size = 4
_lprcEnumMonitorsThatIntersect$ = 12			; size = 4
_lpfnEnumProc$ = 16					; size = 4
_dwData$ = 20						; size = 4
_xEnumDisplayMonitors@16 PROC				; COMDAT

; 377  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 2c	 sub	 esp, 44			; 0000002cH

; 378  :     RECT rcLimit;
; 379  : 
; 380  :     if (InitMultipleMonitorStubs()) {

  00006	e8 00 00 00 00	 call	 _InitMultipleMonitorStubs
  0000b	85 c0		 test	 eax, eax
  0000d	74 1b		 je	 SHORT $LN13@xEnumDispl@2

; 381  :         return g_pfnEnumDisplayMonitors(
; 382  :                 hdcOptionalForPainting,
; 383  :                 lprcEnumMonitorsThatIntersect,
; 384  :                 lpfnEnumProc,
; 385  :                 dwData);

  0000f	8b 45 14	 mov	 eax, DWORD PTR _dwData$[ebp]
  00012	50		 push	 eax
  00013	8b 4d 10	 mov	 ecx, DWORD PTR _lpfnEnumProc$[ebp]
  00016	51		 push	 ecx
  00017	8b 55 0c	 mov	 edx, DWORD PTR _lprcEnumMonitorsThatIntersect$[ebp]
  0001a	52		 push	 edx
  0001b	8b 45 08	 mov	 eax, DWORD PTR _hdcOptionalForPainting$[ebp]
  0001e	50		 push	 eax
  0001f	ff 15 00 00 00
	00		 call	 DWORD PTR _g_pfnEnumDisplayMonitors
  00025	e9 ff 00 00 00	 jmp	 $LN14@xEnumDispl@2
$LN13@xEnumDispl@2:

; 386  :     }
; 387  : 
; 388  :     if (!lpfnEnumProc)

  0002a	83 7d 10 00	 cmp	 DWORD PTR _lpfnEnumProc$[ebp], 0
  0002e	75 07		 jne	 SHORT $LN12@xEnumDispl@2

; 389  :         return FALSE;

  00030	33 c0		 xor	 eax, eax
  00032	e9 f2 00 00 00	 jmp	 $LN14@xEnumDispl@2
$LN12@xEnumDispl@2:

; 390  : 
; 391  :     rcLimit.left   = 0;

  00037	c7 45 f0 00 00
	00 00		 mov	 DWORD PTR _rcLimit$[ebp], 0

; 392  :     rcLimit.top    = 0;

  0003e	c7 45 f4 00 00
	00 00		 mov	 DWORD PTR _rcLimit$[ebp+4], 0

; 393  :     rcLimit.right  = GetSystemMetrics(SM_CXSCREEN);

  00045	6a 00		 push	 0
  00047	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetSystemMetrics@4
  0004d	89 45 f8	 mov	 DWORD PTR _rcLimit$[ebp+8], eax

; 394  :     rcLimit.bottom = GetSystemMetrics(SM_CYSCREEN);

  00050	6a 01		 push	 1
  00052	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetSystemMetrics@4
  00058	89 45 fc	 mov	 DWORD PTR _rcLimit$[ebp+12], eax

; 395  : 
; 396  :     if (hdcOptionalForPainting)

  0005b	83 7d 08 00	 cmp	 DWORD PTR _hdcOptionalForPainting$[ebp], 0
  0005f	0f 84 8d 00 00
	00		 je	 $LN11@xEnumDispl@2

; 397  :     {
; 398  :         RECT    rcClip;
; 399  :         POINT   ptOrg;
; 400  : 
; 401  :         switch (GetClipBox(hdcOptionalForPainting, &rcClip))

  00065	8d 4d e0	 lea	 ecx, DWORD PTR _rcClip$139491[ebp]
  00068	51		 push	 ecx
  00069	8b 55 08	 mov	 edx, DWORD PTR _hdcOptionalForPainting$[ebp]
  0006c	52		 push	 edx
  0006d	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetClipBox@8
  00073	89 45 d4	 mov	 DWORD PTR tv80[ebp], eax
  00076	83 7d d4 00	 cmp	 DWORD PTR tv80[ebp], 0
  0007a	74 70		 je	 SHORT $LN3@xEnumDispl@2
  0007c	83 7d d4 01	 cmp	 DWORD PTR tv80[ebp], 1
  00080	74 63		 je	 SHORT $LN4@xEnumDispl@2

; 402  :         {
; 403  :         default:
; 404  :             if (!GetDCOrgEx(hdcOptionalForPainting, &ptOrg))

  00082	8d 45 d8	 lea	 eax, DWORD PTR _ptOrg$139492[ebp]
  00085	50		 push	 eax
  00086	8b 4d 08	 mov	 ecx, DWORD PTR _hdcOptionalForPainting$[ebp]
  00089	51		 push	 ecx
  0008a	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetDCOrgEx@8
  00090	85 c0		 test	 eax, eax
  00092	75 07		 jne	 SHORT $LN7@xEnumDispl@2

; 405  :                 return FALSE;

  00094	33 c0		 xor	 eax, eax
  00096	e9 8e 00 00 00	 jmp	 $LN14@xEnumDispl@2
$LN7@xEnumDispl@2:

; 406  : 
; 407  :             OffsetRect(&rcLimit, -ptOrg.x, -ptOrg.y);

  0009b	8b 55 dc	 mov	 edx, DWORD PTR _ptOrg$139492[ebp+4]
  0009e	f7 da		 neg	 edx
  000a0	52		 push	 edx
  000a1	8b 45 d8	 mov	 eax, DWORD PTR _ptOrg$139492[ebp]
  000a4	f7 d8		 neg	 eax
  000a6	50		 push	 eax
  000a7	8d 4d f0	 lea	 ecx, DWORD PTR _rcLimit$[ebp]
  000aa	51		 push	 ecx
  000ab	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__OffsetRect@12

; 408  :             if (IntersectRect(&rcLimit, &rcLimit, &rcClip) &&
; 409  :                 (!lprcEnumMonitorsThatIntersect ||
; 410  :                      IntersectRect(&rcLimit, &rcLimit, lprcEnumMonitorsThatIntersect))) {

  000b1	8d 55 e0	 lea	 edx, DWORD PTR _rcClip$139491[ebp]
  000b4	52		 push	 edx
  000b5	8d 45 f0	 lea	 eax, DWORD PTR _rcLimit$[ebp]
  000b8	50		 push	 eax
  000b9	8d 4d f0	 lea	 ecx, DWORD PTR _rcLimit$[ebp]
  000bc	51		 push	 ecx
  000bd	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__IntersectRect@12
  000c3	85 c0		 test	 eax, eax
  000c5	74 1e		 je	 SHORT $LN4@xEnumDispl@2
  000c7	83 7d 0c 00	 cmp	 DWORD PTR _lprcEnumMonitorsThatIntersect$[ebp], 0
  000cb	74 16		 je	 SHORT $LN5@xEnumDispl@2
  000cd	8b 55 0c	 mov	 edx, DWORD PTR _lprcEnumMonitorsThatIntersect$[ebp]
  000d0	52		 push	 edx
  000d1	8d 45 f0	 lea	 eax, DWORD PTR _rcLimit$[ebp]
  000d4	50		 push	 eax
  000d5	8d 4d f0	 lea	 ecx, DWORD PTR _rcLimit$[ebp]
  000d8	51		 push	 ecx
  000d9	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__IntersectRect@12
  000df	85 c0		 test	 eax, eax
  000e1	74 02		 je	 SHORT $LN4@xEnumDispl@2
$LN5@xEnumDispl@2:

; 411  : 
; 412  :                 break;

  000e3	eb 0b		 jmp	 SHORT $LN9@xEnumDispl@2
$LN4@xEnumDispl@2:

; 413  :             }
; 414  :             //fall thru
; 415  :         case NULLREGION:
; 416  :              return TRUE;

  000e5	b8 01 00 00 00	 mov	 eax, 1
  000ea	eb 3d		 jmp	 SHORT $LN14@xEnumDispl@2
$LN3@xEnumDispl@2:

; 417  :         case ERROR:
; 418  :              return FALSE;

  000ec	33 c0		 xor	 eax, eax
  000ee	eb 39		 jmp	 SHORT $LN14@xEnumDispl@2
$LN9@xEnumDispl@2:

; 419  :         }
; 420  :     } else {

  000f0	eb 23		 jmp	 SHORT $LN2@xEnumDispl@2
$LN11@xEnumDispl@2:

; 421  :         if (    lprcEnumMonitorsThatIntersect &&
; 422  :                 !IntersectRect(&rcLimit, &rcLimit, lprcEnumMonitorsThatIntersect)) {

  000f2	83 7d 0c 00	 cmp	 DWORD PTR _lprcEnumMonitorsThatIntersect$[ebp], 0
  000f6	74 1d		 je	 SHORT $LN2@xEnumDispl@2
  000f8	8b 55 0c	 mov	 edx, DWORD PTR _lprcEnumMonitorsThatIntersect$[ebp]
  000fb	52		 push	 edx
  000fc	8d 45 f0	 lea	 eax, DWORD PTR _rcLimit$[ebp]
  000ff	50		 push	 eax
  00100	8d 4d f0	 lea	 ecx, DWORD PTR _rcLimit$[ebp]
  00103	51		 push	 ecx
  00104	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__IntersectRect@12
  0010a	85 c0		 test	 eax, eax
  0010c	75 07		 jne	 SHORT $LN2@xEnumDispl@2

; 423  : 
; 424  :             return TRUE;

  0010e	b8 01 00 00 00	 mov	 eax, 1
  00113	eb 14		 jmp	 SHORT $LN14@xEnumDispl@2
$LN2@xEnumDispl@2:

; 425  :         }
; 426  :     }
; 427  : 
; 428  :     return lpfnEnumProc(
; 429  :             xPRIMARY_MONITOR,
; 430  :             hdcOptionalForPainting,
; 431  :             &rcLimit,
; 432  :             dwData);

  00115	8b 55 14	 mov	 edx, DWORD PTR _dwData$[ebp]
  00118	52		 push	 edx
  00119	8d 45 f0	 lea	 eax, DWORD PTR _rcLimit$[ebp]
  0011c	50		 push	 eax
  0011d	8b 4d 08	 mov	 ecx, DWORD PTR _hdcOptionalForPainting$[ebp]
  00120	51		 push	 ecx
  00121	68 42 00 34 12	 push	 305397826		; 12340042H
  00126	ff 55 10	 call	 DWORD PTR _lpfnEnumProc$[ebp]
$LN14@xEnumDispl@2:

; 433  : }

  00129	8b e5		 mov	 esp, ebp
  0012b	5d		 pop	 ebp
  0012c	c2 10 00	 ret	 16			; 00000010H
_xEnumDisplayMonitors@16 ENDP
_TEXT	ENDS
PUBLIC	_xGetMonitorInfo@8
; Function compile flags: /Odtp
;	COMDAT _xGetMonitorInfo@8
_TEXT	SEGMENT
_f$139464 = -20						; size = 4
_rcWork$ = -16						; size = 16
_hMonitor$ = 8						; size = 4
_lpMonitorInfo$ = 12					; size = 4
_xGetMonitorInfo@8 PROC					; COMDAT

; 323  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 14	 sub	 esp, 20			; 00000014H

; 324  :     RECT rcWork;
; 325  : 
; 326  :     if (InitMultipleMonitorStubs())

  00006	e8 00 00 00 00	 call	 _InitMultipleMonitorStubs
  0000b	85 c0		 test	 eax, eax
  0000d	74 4c		 je	 SHORT $LN4@xGetMonito

; 327  :     {
; 328  :         BOOL f = g_pfnGetMonitorInfo(hMonitor, lpMonitorInfo);

  0000f	8b 45 0c	 mov	 eax, DWORD PTR _lpMonitorInfo$[ebp]
  00012	50		 push	 eax
  00013	8b 4d 08	 mov	 ecx, DWORD PTR _hMonitor$[ebp]
  00016	51		 push	 ecx
  00017	ff 15 00 00 00
	00		 call	 DWORD PTR _g_pfnGetMonitorInfo
  0001d	89 45 ec	 mov	 DWORD PTR _f$139464[ebp], eax

; 329  : #ifdef UNICODE
; 330  :         if (f && !g_fMultimonPlatformNT && (lpMonitorInfo->cbSize >= sizeof(MONITORINFOEX)))

  00020	83 7d ec 00	 cmp	 DWORD PTR _f$139464[ebp], 0
  00024	74 2d		 je	 SHORT $LN3@xGetMonito
  00026	83 3d 00 00 00
	00 00		 cmp	 DWORD PTR _g_fMultimonPlatformNT, 0
  0002d	75 24		 jne	 SHORT $LN3@xGetMonito
  0002f	8b 55 0c	 mov	 edx, DWORD PTR _lpMonitorInfo$[ebp]
  00032	83 3a 68	 cmp	 DWORD PTR [edx], 104	; 00000068H
  00035	72 1c		 jb	 SHORT $LN3@xGetMonito

; 331  :         { 
; 332  :             MultiByteToWideChar(CP_ACP, 0,
; 333  :                 (LPSTR)((MONITORINFOEX*)lpMonitorInfo)->szDevice, -1,
; 334  :                 ((MONITORINFOEX*)lpMonitorInfo)->szDevice, (sizeof(((MONITORINFOEX*)lpMonitorInfo)->szDevice)/sizeof(TCHAR)));

  00037	6a 20		 push	 32			; 00000020H
  00039	8b 45 0c	 mov	 eax, DWORD PTR _lpMonitorInfo$[ebp]
  0003c	83 c0 28	 add	 eax, 40			; 00000028H
  0003f	50		 push	 eax
  00040	6a ff		 push	 -1
  00042	8b 4d 0c	 mov	 ecx, DWORD PTR _lpMonitorInfo$[ebp]
  00045	83 c1 28	 add	 ecx, 40			; 00000028H
  00048	51		 push	 ecx
  00049	6a 00		 push	 0
  0004b	6a 00		 push	 0
  0004d	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__MultiByteToWideChar@24
$LN3@xGetMonito:

; 335  :         }
; 336  : #endif
; 337  :         return f;

  00053	8b 45 ec	 mov	 eax, DWORD PTR _f$139464[ebp]
  00056	e9 bd 00 00 00	 jmp	 $LN5@xGetMonito
$LN4@xGetMonito:

; 338  :     }
; 339  : 
; 340  :     if ((hMonitor == xPRIMARY_MONITOR) &&
; 341  :         lpMonitorInfo &&
; 342  :         (lpMonitorInfo->cbSize >= sizeof(MONITORINFO)) &&
; 343  :         SystemParametersInfoA(SPI_GETWORKAREA, 0, &rcWork, 0))

  0005b	81 7d 08 42 00
	34 12		 cmp	 DWORD PTR _hMonitor$[ebp], 305397826 ; 12340042H
  00062	0f 85 ae 00 00
	00		 jne	 $LN2@xGetMonito
  00068	83 7d 0c 00	 cmp	 DWORD PTR _lpMonitorInfo$[ebp], 0
  0006c	0f 84 a4 00 00
	00		 je	 $LN2@xGetMonito
  00072	8b 55 0c	 mov	 edx, DWORD PTR _lpMonitorInfo$[ebp]
  00075	83 3a 28	 cmp	 DWORD PTR [edx], 40	; 00000028H
  00078	0f 82 98 00 00
	00		 jb	 $LN2@xGetMonito
  0007e	6a 00		 push	 0
  00080	8d 45 f0	 lea	 eax, DWORD PTR _rcWork$[ebp]
  00083	50		 push	 eax
  00084	6a 00		 push	 0
  00086	6a 30		 push	 48			; 00000030H
  00088	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__SystemParametersInfoA@16
  0008e	85 c0		 test	 eax, eax
  00090	0f 84 80 00 00
	00		 je	 $LN2@xGetMonito

; 344  :     {
; 345  :         lpMonitorInfo->rcMonitor.left = 0;

  00096	8b 4d 0c	 mov	 ecx, DWORD PTR _lpMonitorInfo$[ebp]
  00099	c7 41 04 00 00
	00 00		 mov	 DWORD PTR [ecx+4], 0

; 346  :         lpMonitorInfo->rcMonitor.top  = 0;

  000a0	8b 55 0c	 mov	 edx, DWORD PTR _lpMonitorInfo$[ebp]
  000a3	c7 42 08 00 00
	00 00		 mov	 DWORD PTR [edx+8], 0

; 347  :         lpMonitorInfo->rcMonitor.right  = GetSystemMetrics(SM_CXSCREEN);

  000aa	6a 00		 push	 0
  000ac	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetSystemMetrics@4
  000b2	8b 4d 0c	 mov	 ecx, DWORD PTR _lpMonitorInfo$[ebp]
  000b5	89 41 0c	 mov	 DWORD PTR [ecx+12], eax

; 348  :         lpMonitorInfo->rcMonitor.bottom = GetSystemMetrics(SM_CYSCREEN);

  000b8	6a 01		 push	 1
  000ba	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetSystemMetrics@4
  000c0	8b 55 0c	 mov	 edx, DWORD PTR _lpMonitorInfo$[ebp]
  000c3	89 42 10	 mov	 DWORD PTR [edx+16], eax

; 349  :         lpMonitorInfo->rcWork = rcWork;

  000c6	8b 45 0c	 mov	 eax, DWORD PTR _lpMonitorInfo$[ebp]
  000c9	83 c0 14	 add	 eax, 20			; 00000014H
  000cc	8b 4d f0	 mov	 ecx, DWORD PTR _rcWork$[ebp]
  000cf	89 08		 mov	 DWORD PTR [eax], ecx
  000d1	8b 55 f4	 mov	 edx, DWORD PTR _rcWork$[ebp+4]
  000d4	89 50 04	 mov	 DWORD PTR [eax+4], edx
  000d7	8b 4d f8	 mov	 ecx, DWORD PTR _rcWork$[ebp+8]
  000da	89 48 08	 mov	 DWORD PTR [eax+8], ecx
  000dd	8b 55 fc	 mov	 edx, DWORD PTR _rcWork$[ebp+12]
  000e0	89 50 0c	 mov	 DWORD PTR [eax+12], edx

; 350  :         lpMonitorInfo->dwFlags = MONITORINFOF_PRIMARY;

  000e3	8b 45 0c	 mov	 eax, DWORD PTR _lpMonitorInfo$[ebp]
  000e6	c7 40 24 01 00
	00 00		 mov	 DWORD PTR [eax+36], 1

; 351  : 
; 352  :         if (lpMonitorInfo->cbSize >= sizeof(MONITORINFOEX))

  000ed	8b 4d 0c	 mov	 ecx, DWORD PTR _lpMonitorInfo$[ebp]
  000f0	83 39 68	 cmp	 DWORD PTR [ecx], 104	; 00000068H
  000f3	72 1a		 jb	 SHORT $LN1@xGetMonito

; 353  :         {
; 354  : #ifdef UNICODE
; 355  :             MultiByteToWideChar(CP_ACP, 0, "DISPLAY", -1, ((MONITORINFOEX*)lpMonitorInfo)->szDevice, (sizeof(((MONITORINFOEX*)lpMonitorInfo)->szDevice)/sizeof(TCHAR)));

  000f5	6a 20		 push	 32			; 00000020H
  000f7	8b 55 0c	 mov	 edx, DWORD PTR _lpMonitorInfo$[ebp]
  000fa	83 c2 28	 add	 edx, 40			; 00000028H
  000fd	52		 push	 edx
  000fe	6a ff		 push	 -1
  00100	68 00 00 00 00	 push	 OFFSET ??_C@_07JPHDIPNG@DISPLAY?$AA@
  00105	6a 00		 push	 0
  00107	6a 00		 push	 0
  00109	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__MultiByteToWideChar@24
$LN1@xGetMonito:

; 356  : #else // UNICODE
; 357  : #if _MULTIMON_USE_SECURE_CRT
; 358  :             strncpy_s(((MONITORINFOEX*)lpMonitorInfo)->szDevice, (sizeof(((MONITORINFOEX*)lpMonitorInfo)->szDevice)/sizeof(TCHAR)), TEXT("DISPLAY"), (sizeof(((MONITORINFOEX*)lpMonitorInfo)->szDevice)/sizeof(TCHAR)) - 1);
; 359  : #else
; 360  :             lstrcpyn(((MONITORINFOEX*)lpMonitorInfo)->szDevice, TEXT("DISPLAY"), (sizeof(((MONITORINFOEX*)lpMonitorInfo)->szDevice)/sizeof(TCHAR)));
; 361  : #endif // _MULTIMON_USE_SECURE_CRT
; 362  : #endif // UNICODE
; 363  :         }
; 364  : 
; 365  :         return TRUE;

  0010f	b8 01 00 00 00	 mov	 eax, 1
  00114	eb 02		 jmp	 SHORT $LN5@xGetMonito
$LN2@xGetMonito:

; 366  :     }
; 367  : 
; 368  :     return FALSE;

  00116	33 c0		 xor	 eax, eax
$LN5@xGetMonito:

; 369  : }

  00118	8b e5		 mov	 esp, ebp
  0011a	5d		 pop	 ebp
  0011b	c2 08 00	 ret	 8
_xGetMonitorInfo@8 ENDP
_TEXT	ENDS
PUBLIC	_xMonitorFromRect@8
; Function compile flags: /Odtp
;	COMDAT _xMonitorFromRect@8
_TEXT	SEGMENT
_lprcScreenCoords$ = 8					; size = 4
_dwFlags$ = 12						; size = 4
_xMonitorFromRect@8 PROC				; COMDAT

; 284  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp

; 285  :     if (InitMultipleMonitorStubs())

  00003	e8 00 00 00 00	 call	 _InitMultipleMonitorStubs
  00008	85 c0		 test	 eax, eax
  0000a	74 10		 je	 SHORT $LN3@xMonitorFr

; 286  :         return g_pfnMonitorFromRect(lprcScreenCoords, dwFlags);

  0000c	8b 45 0c	 mov	 eax, DWORD PTR _dwFlags$[ebp]
  0000f	50		 push	 eax
  00010	8b 4d 08	 mov	 ecx, DWORD PTR _lprcScreenCoords$[ebp]
  00013	51		 push	 ecx
  00014	ff 15 00 00 00
	00		 call	 DWORD PTR _g_pfnMonitorFromRect
  0001a	eb 42		 jmp	 SHORT $LN4@xMonitorFr
$LN3@xMonitorFr:

; 287  : 
; 288  :     if ((dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST)) ||
; 289  :         ((lprcScreenCoords->right > 0) &&
; 290  :         (lprcScreenCoords->bottom > 0) &&
; 291  :         (lprcScreenCoords->left < GetSystemMetrics(SM_CXSCREEN)) &&
; 292  :         (lprcScreenCoords->top < GetSystemMetrics(SM_CYSCREEN))))

  0001c	8b 55 0c	 mov	 edx, DWORD PTR _dwFlags$[ebp]
  0001f	83 e2 03	 and	 edx, 3
  00022	75 31		 jne	 SHORT $LN1@xMonitorFr
  00024	8b 45 08	 mov	 eax, DWORD PTR _lprcScreenCoords$[ebp]
  00027	83 78 08 00	 cmp	 DWORD PTR [eax+8], 0
  0002b	7e 2f		 jle	 SHORT $LN2@xMonitorFr
  0002d	8b 4d 08	 mov	 ecx, DWORD PTR _lprcScreenCoords$[ebp]
  00030	83 79 0c 00	 cmp	 DWORD PTR [ecx+12], 0
  00034	7e 26		 jle	 SHORT $LN2@xMonitorFr
  00036	6a 00		 push	 0
  00038	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetSystemMetrics@4
  0003e	8b 55 08	 mov	 edx, DWORD PTR _lprcScreenCoords$[ebp]
  00041	39 02		 cmp	 DWORD PTR [edx], eax
  00043	7d 17		 jge	 SHORT $LN2@xMonitorFr
  00045	6a 01		 push	 1
  00047	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetSystemMetrics@4
  0004d	8b 4d 08	 mov	 ecx, DWORD PTR _lprcScreenCoords$[ebp]
  00050	39 41 04	 cmp	 DWORD PTR [ecx+4], eax
  00053	7d 07		 jge	 SHORT $LN2@xMonitorFr
$LN1@xMonitorFr:

; 293  :     {
; 294  :         return xPRIMARY_MONITOR;

  00055	b8 42 00 34 12	 mov	 eax, 305397826		; 12340042H
  0005a	eb 02		 jmp	 SHORT $LN4@xMonitorFr
$LN2@xMonitorFr:

; 295  :     }
; 296  : 
; 297  :     return NULL;

  0005c	33 c0		 xor	 eax, eax
$LN4@xMonitorFr:

; 298  : }

  0005e	5d		 pop	 ebp
  0005f	c2 08 00	 ret	 8
_xMonitorFromRect@8 ENDP
_TEXT	ENDS
PUBLIC	_xMonitorFromPoint@12
; Function compile flags: /Odtp
;	COMDAT _xMonitorFromPoint@12
_TEXT	SEGMENT
_ptScreenCoords$ = 8					; size = 8
_dwFlags$ = 16						; size = 4
_xMonitorFromPoint@12 PROC				; COMDAT

; 266  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp

; 267  :     if (InitMultipleMonitorStubs())

  00003	e8 00 00 00 00	 call	 _InitMultipleMonitorStubs
  00008	85 c0		 test	 eax, eax
  0000a	74 14		 je	 SHORT $LN3@xMonitorFr@2

; 268  :         return g_pfnMonitorFromPoint(ptScreenCoords, dwFlags);

  0000c	8b 45 10	 mov	 eax, DWORD PTR _dwFlags$[ebp]
  0000f	50		 push	 eax
  00010	8b 4d 0c	 mov	 ecx, DWORD PTR _ptScreenCoords$[ebp+4]
  00013	51		 push	 ecx
  00014	8b 55 08	 mov	 edx, DWORD PTR _ptScreenCoords$[ebp]
  00017	52		 push	 edx
  00018	ff 15 00 00 00
	00		 call	 DWORD PTR _g_pfnMonitorFromPoint
  0001e	eb 37		 jmp	 SHORT $LN4@xMonitorFr@2
$LN3@xMonitorFr@2:

; 269  : 
; 270  :     if ((dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST)) ||
; 271  :         ((ptScreenCoords.x >= 0) &&
; 272  :         (ptScreenCoords.x < GetSystemMetrics(SM_CXSCREEN)) &&
; 273  :         (ptScreenCoords.y >= 0) &&
; 274  :         (ptScreenCoords.y < GetSystemMetrics(SM_CYSCREEN))))

  00020	8b 45 10	 mov	 eax, DWORD PTR _dwFlags$[ebp]
  00023	83 e0 03	 and	 eax, 3
  00026	75 26		 jne	 SHORT $LN1@xMonitorFr@2
  00028	83 7d 08 00	 cmp	 DWORD PTR _ptScreenCoords$[ebp], 0
  0002c	7c 27		 jl	 SHORT $LN2@xMonitorFr@2
  0002e	6a 00		 push	 0
  00030	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetSystemMetrics@4
  00036	39 45 08	 cmp	 DWORD PTR _ptScreenCoords$[ebp], eax
  00039	7d 1a		 jge	 SHORT $LN2@xMonitorFr@2
  0003b	83 7d 0c 00	 cmp	 DWORD PTR _ptScreenCoords$[ebp+4], 0
  0003f	7c 14		 jl	 SHORT $LN2@xMonitorFr@2
  00041	6a 01		 push	 1
  00043	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetSystemMetrics@4
  00049	39 45 0c	 cmp	 DWORD PTR _ptScreenCoords$[ebp+4], eax
  0004c	7d 07		 jge	 SHORT $LN2@xMonitorFr@2
$LN1@xMonitorFr@2:

; 275  :     {
; 276  :         return xPRIMARY_MONITOR;

  0004e	b8 42 00 34 12	 mov	 eax, 305397826		; 12340042H
  00053	eb 02		 jmp	 SHORT $LN4@xMonitorFr@2
$LN2@xMonitorFr@2:

; 277  :     }
; 278  : 
; 279  :     return NULL;

  00055	33 c0		 xor	 eax, eax
$LN4@xMonitorFr@2:

; 280  : }

  00057	5d		 pop	 ebp
  00058	c2 0c 00	 ret	 12			; 0000000cH
_xMonitorFromPoint@12 ENDP
_TEXT	ENDS
PUBLIC	_xGetSystemMetrics@4
; Function compile flags: /Odtp
;	COMDAT _xGetSystemMetrics@4
_TEXT	SEGMENT
tv68 = -4						; size = 4
_nIndex$ = 8						; size = 4
_xGetSystemMetrics@4 PROC				; COMDAT

; 236  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx

; 237  :     if (InitMultipleMonitorStubs())

  00004	e8 00 00 00 00	 call	 _InitMultipleMonitorStubs
  00009	85 c0		 test	 eax, eax
  0000b	74 0c		 je	 SHORT $LN7@xGetSystem

; 238  :         return g_pfnGetSystemMetrics(nIndex);

  0000d	8b 45 08	 mov	 eax, DWORD PTR _nIndex$[ebp]
  00010	50		 push	 eax
  00011	ff 15 00 00 00
	00		 call	 DWORD PTR _g_pfnGetSystemMetrics
  00017	eb 44		 jmp	 SHORT $LN8@xGetSystem
$LN7@xGetSystem:

; 239  : 
; 240  :     switch (nIndex)

  00019	8b 4d 08	 mov	 ecx, DWORD PTR _nIndex$[ebp]
  0001c	89 4d fc	 mov	 DWORD PTR tv68[ebp], ecx
  0001f	8b 55 fc	 mov	 edx, DWORD PTR tv68[ebp]
  00022	83 ea 4c	 sub	 edx, 76			; 0000004cH
  00025	89 55 fc	 mov	 DWORD PTR tv68[ebp], edx
  00028	83 7d fc 05	 cmp	 DWORD PTR tv68[ebp], 5
  0002c	77 25		 ja	 SHORT $LN5@xGetSystem
  0002e	8b 45 fc	 mov	 eax, DWORD PTR tv68[ebp]
  00031	ff 24 85 00 00
	00 00		 jmp	 DWORD PTR $LN10@xGetSystem[eax*4]
$LN4@xGetSystem:

; 241  :     {
; 242  :     case SM_CMONITORS:
; 243  :     case SM_SAMEDISPLAYFORMAT:
; 244  :         return 1;

  00038	b8 01 00 00 00	 mov	 eax, 1
  0003d	eb 1e		 jmp	 SHORT $LN8@xGetSystem
$LN3@xGetSystem:

; 245  : 
; 246  :     case SM_XVIRTUALSCREEN:
; 247  :     case SM_YVIRTUALSCREEN:
; 248  :         return 0;

  0003f	33 c0		 xor	 eax, eax
  00041	eb 1a		 jmp	 SHORT $LN8@xGetSystem
$LN2@xGetSystem:

; 249  : 
; 250  :     case SM_CXVIRTUALSCREEN:
; 251  :         nIndex = SM_CXSCREEN;

  00043	c7 45 08 00 00
	00 00		 mov	 DWORD PTR _nIndex$[ebp], 0

; 252  :         break;

  0004a	eb 07		 jmp	 SHORT $LN5@xGetSystem
$LN1@xGetSystem:

; 253  : 
; 254  :     case SM_CYVIRTUALSCREEN:
; 255  :         nIndex = SM_CYSCREEN;

  0004c	c7 45 08 01 00
	00 00		 mov	 DWORD PTR _nIndex$[ebp], 1
$LN5@xGetSystem:

; 256  :         break;
; 257  :     }
; 258  : 
; 259  :     return GetSystemMetrics(nIndex);

  00053	8b 4d 08	 mov	 ecx, DWORD PTR _nIndex$[ebp]
  00056	51		 push	 ecx
  00057	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetSystemMetrics@4
$LN8@xGetSystem:

; 260  : }

  0005d	8b e5		 mov	 esp, ebp
  0005f	5d		 pop	 ebp
  00060	c2 04 00	 ret	 4
  00063	90		 npad	 1
$LN10@xGetSystem:
  00064	00 00 00 00	 DD	 $LN3@xGetSystem
  00068	00 00 00 00	 DD	 $LN3@xGetSystem
  0006c	00 00 00 00	 DD	 $LN2@xGetSystem
  00070	00 00 00 00	 DD	 $LN1@xGetSystem
  00074	00 00 00 00	 DD	 $LN4@xGetSystem
  00078	00 00 00 00	 DD	 $LN4@xGetSystem
_xGetSystemMetrics@4 ENDP
PUBLIC	_xMonitorFromWindow@8
; Function compile flags: /Odtp
;	COMDAT _xMonitorFromWindow@8
_TEXT	SEGMENT
tv80 = -48						; size = 4
_wp$ = -44						; size = 44
_hWnd$ = 8						; size = 4
_dwFlags$ = 12						; size = 4
_xMonitorFromWindow@8 PROC				; COMDAT

; 302  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 30	 sub	 esp, 48			; 00000030H

; 303  :     WINDOWPLACEMENT wp;
; 304  : 
; 305  :     if (InitMultipleMonitorStubs())

  00006	e8 00 00 00 00	 call	 _InitMultipleMonitorStubs
  0000b	85 c0		 test	 eax, eax
  0000d	74 10		 je	 SHORT $LN3@xMonitorFr@3

; 306  :         return g_pfnMonitorFromWindow(hWnd, dwFlags);

  0000f	8b 45 0c	 mov	 eax, DWORD PTR _dwFlags$[ebp]
  00012	50		 push	 eax
  00013	8b 4d 08	 mov	 ecx, DWORD PTR _hWnd$[ebp]
  00016	51		 push	 ecx
  00017	ff 15 00 00 00
	00		 call	 DWORD PTR _g_pfnMonitorFromWindow
  0001d	eb 58		 jmp	 SHORT $LN4@xMonitorFr@3
$LN3@xMonitorFr@3:

; 307  : 
; 308  :     if (dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST))

  0001f	8b 55 0c	 mov	 edx, DWORD PTR _dwFlags$[ebp]
  00022	83 e2 03	 and	 edx, 3
  00025	74 07		 je	 SHORT $LN2@xMonitorFr@3

; 309  :         return xPRIMARY_MONITOR;

  00027	b8 42 00 34 12	 mov	 eax, 305397826		; 12340042H
  0002c	eb 49		 jmp	 SHORT $LN4@xMonitorFr@3
$LN2@xMonitorFr@3:

; 310  : 
; 311  :     if (IsIconic(hWnd) ?
; 312  :             GetWindowPlacement(hWnd, &wp) :
; 313  :             GetWindowRect(hWnd, &wp.rcNormalPosition)) {

  0002e	8b 45 08	 mov	 eax, DWORD PTR _hWnd$[ebp]
  00031	50		 push	 eax
  00032	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__IsIconic@4
  00038	85 c0		 test	 eax, eax
  0003a	74 13		 je	 SHORT $LN6@xMonitorFr@3
  0003c	8d 4d d4	 lea	 ecx, DWORD PTR _wp$[ebp]
  0003f	51		 push	 ecx
  00040	8b 55 08	 mov	 edx, DWORD PTR _hWnd$[ebp]
  00043	52		 push	 edx
  00044	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetWindowPlacement@8
  0004a	89 45 d0	 mov	 DWORD PTR tv80[ebp], eax
  0004d	eb 11		 jmp	 SHORT $LN7@xMonitorFr@3
$LN6@xMonitorFr@3:
  0004f	8d 45 f0	 lea	 eax, DWORD PTR _wp$[ebp+28]
  00052	50		 push	 eax
  00053	8b 4d 08	 mov	 ecx, DWORD PTR _hWnd$[ebp]
  00056	51		 push	 ecx
  00057	ff 15 00 00 00
	00		 call	 DWORD PTR __imp__GetWindowRect@8
  0005d	89 45 d0	 mov	 DWORD PTR tv80[ebp], eax
$LN7@xMonitorFr@3:
  00060	83 7d d0 00	 cmp	 DWORD PTR tv80[ebp], 0
  00064	74 0f		 je	 SHORT $LN1@xMonitorFr@3

; 314  : 
; 315  :         return xMonitorFromRect(&wp.rcNormalPosition, dwFlags);

  00066	8b 55 0c	 mov	 edx, DWORD PTR _dwFlags$[ebp]
  00069	52		 push	 edx
  0006a	8d 45 f0	 lea	 eax, DWORD PTR _wp$[ebp+28]
  0006d	50		 push	 eax
  0006e	e8 00 00 00 00	 call	 _xMonitorFromRect@8
  00073	eb 02		 jmp	 SHORT $LN4@xMonitorFr@3
$LN1@xMonitorFr@3:

; 316  :     }
; 317  : 
; 318  :     return NULL;

  00075	33 c0		 xor	 eax, eax
$LN4@xMonitorFr@3:

; 319  : }

  00077	8b e5		 mov	 esp, ebp
  00079	5d		 pop	 ebp
  0007a	c2 08 00	 ret	 8
_xMonitorFromWindow@8 ENDP
END
