Warning! We are currently in recovery mode. The complete archive is not available.

Sample details: 35ccad8f934831454ffe1f7cf155cd4b --

Hashes
MD5: 35ccad8f934831454ffe1f7cf155cd4b
SHA1: 9a3d51dcb4ad49ca5769c1fef33038430ff10586
SHA256: 82912fbb3df9952a5db118573fc7cd7772cce0260292b3c7d34b27fe914d7c34
SSDEEP: 3072:3ghTTu+r+D8ppXMPC42rLz0c5i7KYAUV3qEe0WfmPqVztapghPwUYJwA4zJbQWLx:a2jUO9eEHAzw6
Details
File Type: BSD
Yara Hits
CuckooSandbox/embedded_win_api | YRP/domain | YRP/contentis_base64 |
Source
http://103.68.190.250/Sources//Advance/BJWJ/Builds/BOT_PLUG/Objs/Release/Strings.cod
Strings
		; Listing generated by Microsoft (R) Optimizing Compiler Version 15.00.30729.01 
	TITLE	e:\Projects\progs\Petrosjan\BJWJ\Source\Core\Strings.cpp
	.686P
	include listing.inc
	.model	flat
INCLUDELIB LIBCMT
INCLUDELIB OLDNAMES
PUBLIC	??_7TBotObject@@6B@				; TBotObject::`vftable'
PUBLIC	??1TBotObject@@UAE@XZ				; TBotObject::~TBotObject
EXTRN	??_ETBotObject@@UAEPAXI@Z:PROC			; TBotObject::`vector deleting destructor'
;	COMDAT ??_7TBotObject@@6B@
; File e:\projects\progs\petrosjan\bjwj\source\core\getapi.h
CONST	SEGMENT
??_7TBotObject@@6B@ DD FLAT:??_ETBotObject@@UAEPAXI@Z	; TBotObject::`vftable'
; Function compile flags: /Ogspy
CONST	ENDS
;	COMDAT ??1TBotObject@@UAE@XZ
_TEXT	SEGMENT
??1TBotObject@@UAE@XZ PROC				; TBotObject::~TBotObject, COMDAT
; _this$ = ecx
; 883  : 	virtual ~TBotObject() {}
  00000	c7 01 00 00 00
	00		 mov	 DWORD PTR [ecx], OFFSET ??_7TBotObject@@6B@
  00006	c3		 ret	 0
??1TBotObject@@UAE@XZ ENDP				; TBotObject::~TBotObject
_TEXT	ENDS
EXTRN	??3TBotObject@@SAXPAX@Z:PROC			; TBotObject::operator delete
; Function compile flags: /Ogspy
;	COMDAT ??_GTBotObject@@UAEPAXI@Z
_TEXT	SEGMENT
___flags$ = 8						; size = 4
??_GTBotObject@@UAEPAXI@Z PROC				; TBotObject::`scalar deleting destructor', COMDAT
; _this$ = ecx
  00000	f6 44 24 04 01	 test	 BYTE PTR ___flags$[esp-4], 1
  00005	56		 push	 esi
  00006	8b f1		 mov	 esi, ecx
  00008	c7 06 00 00 00
	00		 mov	 DWORD PTR [esi], OFFSET ??_7TBotObject@@6B@
  0000e	74 07		 je	 SHORT $LN1@scalar
  00010	56		 push	 esi
  00011	e8 00 00 00 00	 call	 ??3TBotObject@@SAXPAX@Z	; TBotObject::operator delete
  00016	59		 pop	 ecx
$LN1@scalar:
  00017	8b c6		 mov	 eax, esi
  00019	5e		 pop	 esi
  0001a	c2 04 00	 ret	 4
??_GTBotObject@@UAEPAXI@Z ENDP				; TBotObject::`scalar deleting destructor'
_TEXT	ENDS
PUBLIC	?WC_IsMask@@YA_NPBD@Z				; WC_IsMask
; Function compile flags: /Ogspy
; File e:\projects\progs\petrosjan\bjwj\source\core\strwildcmp.cpp
;	COMDAT ?WC_IsMask@@YA_NPBD@Z
_TEXT	SEGMENT
_Mask$ = 8						; size = 4
?WC_IsMask@@YA_NPBD@Z PROC				; WC_IsMask, COMDAT
; 130  : 	// 
; 131  : 	// 
; 132  : 	return *Mask == '*';
  00000	8b 4c 24 04	 mov	 ecx, DWORD PTR _Mask$[esp-4]
  00004	33 c0		 xor	 eax, eax
  00006	80 39 2a	 cmp	 BYTE PTR [ecx], 42	; 0000002aH
  00009	0f 94 c0	 sete	 al
; 133  : }
  0000c	c3		 ret	 0
?WC_IsMask@@YA_NPBD@Z ENDP				; WC_IsMask
_TEXT	ENDS
PUBLIC	?WC_ProcessMask@@YAXAAUWILD_CMP_REC@@@Z		; WC_ProcessMask
; Function compile flags: /Ogspy
;	COMDAT ?WC_ProcessMask@@YAXAAUWILD_CMP_REC@@@Z
_TEXT	SEGMENT
_WCR$ = 8						; size = 4
?WC_ProcessMask@@YAXAAUWILD_CMP_REC@@@Z PROC		; WC_ProcessMask, COMDAT
; 138  : 	// 
; 139  : 	WCR.LastCharIsMask = true;
  00000	8b 44 24 04	 mov	 eax, DWORD PTR _WCR$[esp-4]
; 140  : 
; 141  : 	// 
; 142  : 	if (!WCR.Start) WCR.Start = WCR.Buffer;
  00004	33 d2		 xor	 edx, edx
  00006	c6 40 10 01	 mov	 BYTE PTR [eax+16], 1
  0000a	39 50 08	 cmp	 DWORD PTR [eax+8], edx
  0000d	75 06		 jne	 SHORT $LN2@WC_Process
  0000f	8b 48 04	 mov	 ecx, DWORD PTR [eax+4]
  00012	89 48 08	 mov	 DWORD PTR [eax+8], ecx
$LN2@WC_Process:
; 143  : 
; 144  : 	// 
; 145  : 	// 
; 146  : 	// "
; 147  : 	// 
: "test_test*"
; 148  : 	WCR.End = NULL;
; 149  : 
; 150  : 	// 
; 151  : 	// 
; 152  : 	if (*(WCR.Mask + 1) == 0)
  00015	8b 08		 mov	 ecx, DWORD PTR [eax]
  00017	41		 inc	 ecx
  00018	89 50 0c	 mov	 DWORD PTR [eax+12], edx
  0001b	38 11		 cmp	 BYTE PTR [ecx], dl
  0001d	75 07		 jne	 SHORT $LN1@WC_Process
; 153  : 		WCR.Result = 1;
  0001f	c7 40 14 01 00
	00 00		 mov	 DWORD PTR [eax+20], 1
$LN1@WC_Process:
; 154  : 
; 155  : 	WCR.Mask++;
  00026	89 08		 mov	 DWORD PTR [eax], ecx
; 156  : }
  00028	c3		 ret	 0
?WC_ProcessMask@@YAXAAUWILD_CMP_REC@@@Z ENDP		; WC_ProcessMask
_TEXT	ENDS
PUBLIC	?WC_IsLB@@YA_NPADAAE@Z				; WC_IsLB
; Function compile flags: /Ogspy
;	COMDAT ?WC_IsLB@@YA_NPADAAE@Z
_TEXT	SEGMENT
_S$ = 8							; size = 4
_Size$ = 12						; size = 4
_r$ = 15						; size = 1
?WC_IsLB@@YA_NPADAAE@Z PROC				; WC_IsLB, COMDAT
; 161  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
; 162  : 	Size = 0;
  00003	8b 45 0c	 mov	 eax, DWORD PTR _Size$[ebp]
; 163  : 	bool r = false;
; 164  : 	bool n = false;
; 165  : 
; 166  : 	for (; *S != 0; S++)
  00006	8b 55 08	 mov	 edx, DWORD PTR _S$[ebp]
  00009	53		 push	 ebx
  0000a	c6 00 00	 mov	 BYTE PTR [eax], 0
  0000d	c6 45 0f 00	 mov	 BYTE PTR _r$[ebp], 0
  00011	32 db		 xor	 bl, bl
  00013	eb 1f		 jmp	 SHORT $LN17@WC_IsLB
$LL9@WC_IsLB:
; 167  : 	{
; 168  : 		if (*S == '\r')
  00015	80 f9 0d	 cmp	 cl, 13			; 0000000dH
  00018	75 0c		 jne	 SHORT $LN6@WC_IsLB
; 169  : 		{
; 170  : 			if (r) break;
  0001a	80 7d 0f 00	 cmp	 BYTE PTR _r$[ebp], 0
  0001e	75 1a		 jne	 SHORT $LN13@WC_IsLB
; 171  : 			r = true;
  00020	c6 45 0f 01	 mov	 BYTE PTR _r$[ebp], 1
; 172  :             Size++;
; 173  : 		}
; 174  : 		else
  00024	eb 0b		 jmp	 SHORT $LN18@WC_IsLB
$LN6@WC_IsLB:
; 175  : 		if (*S == '\n')
  00026	80 f9 0a	 cmp	 cl, 10			; 0000000aH
  00029	75 0f		 jne	 SHORT $LN13@WC_IsLB
; 176  : 		{
; 177  : 			if (n) break;
  0002b	84 db		 test	 bl, bl
  0002d	75 0b		 jne	 SHORT $LN13@WC_IsLB
; 178  : 			n = true;
  0002f	fe c3		 inc	 bl
$LN18@WC_IsLB:
; 179  : 			Size++;
  00031	fe 00		 inc	 BYTE PTR [eax]
  00033	42		 inc	 edx
$LN17@WC_IsLB:
  00034	8a 0a		 mov	 cl, BYTE PTR [edx]
  00036	84 c9		 test	 cl, cl
  00038	75 db		 jne	 SHORT $LL9@WC_IsLB
$LN13@WC_IsLB:
; 180  :         }
; 181  : 		else
; 182  : 			break;
; 183  : 	}
; 184  : 
; 185  : 	return Size != 0;
  0003a	33 c9		 xor	 ecx, ecx
  0003c	38 08		 cmp	 BYTE PTR [eax], cl
  0003e	5b		 pop	 ebx
  0003f	0f 95 c1	 setne	 cl
  00042	8a c1		 mov	 al, cl
; 186  : }
  00044	5d		 pop	 ebp
  00045	c3		 ret	 0
?WC_IsLB@@YA_NPADAAE@Z ENDP				; WC_IsLB
_TEXT	ENDS
PUBLIC	?WC_CompareChars@@YA_NAAPAD0@Z			; WC_CompareChars
; Function compile flags: /Ogspy
;	COMDAT ?WC_CompareChars@@YA_NAAPAD0@Z
_TEXT	SEGMENT
_CS2$ = -2						; size = 1
_CS1$ = -1						; size = 1
_S1$ = 8						; size = 4
_S2$ = 12						; size = 4
?WC_CompareChars@@YA_NAAPAD0@Z PROC			; WC_CompareChars, COMDAT
; 192  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
  00004	53		 push	 ebx
; 193  : 	// 
; 194  : 	// 
; 195  : 	// 
 Windows 
; 196  : 	// Linux 
; 197  : 	// 
. \r\n 
; 198  : 	// 
; 199  : 
; 200  : 	bool Result = false;
; 201  : 	BYTE CS1 = 0;
; 202  : 	BYTE CS2 = 0;
; 203  : 
; 204  : 	if (WC_IsLB(S1, CS1))
  00005	8b 5d 08	 mov	 ebx, DWORD PTR _S1$[ebp]
  00008	56		 push	 esi
  00009	8b 33		 mov	 esi, DWORD PTR [ebx]
  0000b	57		 push	 edi
  0000c	8d 45 ff	 lea	 eax, DWORD PTR _CS1$[ebp]
  0000f	50		 push	 eax
  00010	56		 push	 esi
  00011	c6 45 ff 00	 mov	 BYTE PTR _CS1$[ebp], 0
  00015	c6 45 fe 00	 mov	 BYTE PTR _CS2$[ebp], 0
  00019	e8 00 00 00 00	 call	 ?WC_IsLB@@YA_NPADAAE@Z	; WC_IsLB
; 205  : 		Result = WC_IsLB(S2, CS2); // 
  0001e	8b 7d 0c	 mov	 edi, DWORD PTR _S2$[ebp]
  00021	59		 pop	 ecx
  00022	59		 pop	 ecx
  00023	84 c0		 test	 al, al
  00025	74 0f		 je	 SHORT $LN3@WC_Compare
  00027	8d 45 fe	 lea	 eax, DWORD PTR _CS2$[ebp]
  0002a	50		 push	 eax
  0002b	ff 37		 push	 DWORD PTR [edi]
  0002d	e8 00 00 00 00	 call	 ?WC_IsLB@@YA_NPADAAE@Z	; WC_IsLB
  00032	59		 pop	 ecx
  00033	59		 pop	 ecx
; 206  : 	else
  00034	eb 09		 jmp	 SHORT $LN2@WC_Compare
$LN3@WC_Compare:
; 207  : 		Result = *S1 == *S2;       // 
  00036	8b 07		 mov	 eax, DWORD PTR [edi]
  00038	8a 0e		 mov	 cl, BYTE PTR [esi]
  0003a	3a 08		 cmp	 cl, BYTE PTR [eax]
  0003c	0f 94 c0	 sete	 al
$LN2@WC_Compare:
; 208  : 
; 209  : 	if (Result)
  0003f	84 c0		 test	 al, al
  00041	74 24		 je	 SHORT $LN1@WC_Compare
; 210  : 	{
; 211  : 		S1 += (CS1) ? CS1 : 1;
  00043	80 7d ff 00	 cmp	 BYTE PTR _CS1$[ebp], 0
  00047	74 06		 je	 SHORT $LN6@WC_Compare
  00049	0f b6 4d ff	 movzx	 ecx, BYTE PTR _CS1$[ebp]
  0004d	eb 03		 jmp	 SHORT $LN7@WC_Compare
$LN6@WC_Compare:
  0004f	33 c9		 xor	 ecx, ecx
  00051	41		 inc	 ecx
$LN7@WC_Compare:
  00052	03 f1		 add	 esi, ecx
; 212  : 		S2 += (CS2) ? CS2 : 1;
  00054	80 7d fe 00	 cmp	 BYTE PTR _CS2$[ebp], 0
  00058	89 33		 mov	 DWORD PTR [ebx], esi
  0005a	74 06		 je	 SHORT $LN8@WC_Compare
  0005c	0f b6 4d fe	 movzx	 ecx, BYTE PTR _CS2$[ebp]
  00060	eb 03		 jmp	 SHORT $LN9@WC_Compare
$LN8@WC_Compare:
  00062	33 c9		 xor	 ecx, ecx
  00064	41		 inc	 ecx
$LN9@WC_Compare:
  00065	01 0f		 add	 DWORD PTR [edi], ecx
$LN1@WC_Compare:
  00067	5f		 pop	 edi
  00068	5e		 pop	 esi
  00069	5b		 pop	 ebx
; 213  :     }
; 214  : 
; 215  : 	return Result;
; 216  : }
  0006a	c9		 leave
  0006b	c3		 ret	 0
?WC_CompareChars@@YA_NAAPAD0@Z ENDP			; WC_CompareChars
_TEXT	ENDS
PUBLIC	?WC_CompareLine@@YAXAAUWILD_CMP_REC@@@Z		; WC_CompareLine
; Function compile flags: /Ogspy
;	COMDAT ?WC_CompareLine@@YAXAAUWILD_CMP_REC@@@Z
_TEXT	SEGMENT
_M$64817 = -4						; size = 4
_B$64818 = 8						; size = 4
_WCR$ = 8						; size = 4
?WC_CompareLine@@YAXAAUWILD_CMP_REC@@@Z PROC		; WC_CompareLine, COMDAT
; 221  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
  00004	53		 push	 ebx
  00005	56		 push	 esi
; 222  : 	// 
; 223  : 
; 224  : 	// 
; 225  : 	// 
; 226  : 	// 
; 227  : 	// 
; 228  : 	bool SM = true;//WCR.LastCharIsMask;
; 229  : 
; 230  : 	WCR.LastCharIsMask = false;
  00006	8b 75 08	 mov	 esi, DWORD PTR _WCR$[ebp]
; 231  : 
; 232  : 	bool EOL  = false;
; 233  : 
; 234  : 	while(*WCR.Buffer)
  00009	8b 46 04	 mov	 eax, DWORD PTR [esi+4]
  0000c	57		 push	 edi
  0000d	c6 46 10 00	 mov	 BYTE PTR [esi+16], 0
  00011	eb 4e		 jmp	 SHORT $LN27@WC_Compare@2
$LL11@WC_Compare@2:
; 235  : 	{
; 236  : 		// 
; 237  : 		PCHAR M = WCR.Mask;
  00013	8b 06		 mov	 eax, DWORD PTR [esi]
; 238  : 		PCHAR B = WCR.Buffer;
  00015	8b 7e 04	 mov	 edi, DWORD PTR [esi+4]
  00018	89 45 fc	 mov	 DWORD PTR _M$64817[ebp], eax
  0001b	8b c7		 mov	 eax, edi
  0001d	89 45 08	 mov	 DWORD PTR _B$64818[ebp], eax
$LL9@WC_Compare@2:
; 239  : 
; 240  : 		while (1)
; 241  : 		{
; 242  : 			// 
; 243  : 			EOL = (*M == 0 || WC_IsMask(M));
  00020	8b 4d fc	 mov	 ecx, DWORD PTR _M$64817[ebp]
  00023	8a 09		 mov	 cl, BYTE PTR [ecx]
  00025	84 c9		 test	 cl, cl
  00027	74 09		 je	 SHORT $LN14@WC_Compare@2
  00029	80 f9 2a	 cmp	 cl, 42			; 0000002aH
  0002c	74 04		 je	 SHORT $LN14@WC_Compare@2
  0002e	32 db		 xor	 bl, bl
  00030	eb 02		 jmp	 SHORT $LN15@WC_Compare@2
$LN14@WC_Compare@2:
  00032	b3 01		 mov	 bl, 1
$LN15@WC_Compare@2:
; 244  : 
; 245  : 			// 
; 246  : 			// 
; 247  : 			// 
; 248  : 			if (*B == 0 || EOL || !WC_CompareChars(B, M))
  00034	80 38 00	 cmp	 BYTE PTR [eax], 0
  00037	74 1a		 je	 SHORT $LN20@WC_Compare@2
  00039	84 db		 test	 bl, bl
  0003b	75 2b		 jne	 SHORT $LN26@WC_Compare@2
  0003d	8d 45 fc	 lea	 eax, DWORD PTR _M$64817[ebp]
  00040	50		 push	 eax
  00041	8d 45 08	 lea	 eax, DWORD PTR _B$64818[ebp]
  00044	50		 push	 eax
  00045	e8 00 00 00 00	 call	 ?WC_CompareChars@@YA_NAAPAD0@Z ; WC_CompareChars
  0004a	59		 pop	 ecx
  0004b	84 c0		 test	 al, al
  0004d	8b 45 08	 mov	 eax, DWORD PTR _B$64818[ebp]
  00050	59		 pop	 ecx
  00051	75 cd		 jne	 SHORT $LL9@WC_Compare@2
$LN20@WC_Compare@2:
; 249  : 				break;
; 250  : 		}
; 251  : 
; 252  : 		// 
; 253  : 		// 
; 254  : 		if (EOL)
  00053	84 db		 test	 bl, bl
  00055	75 11		 jne	 SHORT $LN26@WC_Compare@2
; 261  : 			break;
; 262  :         }
; 263  : 
; 264  : 		// 
; 265  : 		// 
; 266  : 		if (!SM || *B == 0) break;
  00057	38 18		 cmp	 BYTE PTR [eax], bl
  00059	74 27		 je	 SHORT $LN24@WC_Compare@2
; 267  : 
; 268  : 		// 
; 269  : 		WCR.Buffer++;
  0005b	47		 inc	 edi
  0005c	89 7e 04	 mov	 DWORD PTR [esi+4], edi
  0005f	8b c7		 mov	 eax, edi
$LN27@WC_Compare@2:
; 231  : 
; 232  : 	bool EOL  = false;
; 233  : 
; 234  : 	while(*WCR.Buffer)
  00061	80 38 00	 cmp	 BYTE PTR [eax], 0
  00064	75 ad		 jne	 SHORT $LL11@WC_Compare@2
; 261  : 			break;
; 262  :         }
; 263  : 
; 264  : 		// 
; 265  : 		// 
; 266  : 		if (!SM || *B == 0) break;
  00066	eb 1a		 jmp	 SHORT $LN24@WC_Compare@2
$LN26@WC_Compare@2:
; 255  : 		{
; 256  : 			// 
; 257  : 			if(!WCR.Start) WCR.Start = WCR.Buffer;
  00068	83 7e 08 00	 cmp	 DWORD PTR [esi+8], 0
  0006c	75 05		 jne	 SHORT $LN4@WC_Compare@2
  0006e	8b cf		 mov	 ecx, edi
  00070	89 4e 08	 mov	 DWORD PTR [esi+8], ecx
$LN4@WC_Compare@2:
; 258  : 			WCR.Buffer = B;
  00073	89 46 04	 mov	 DWORD PTR [esi+4], eax
; 259  : 			WCR.End    = B;
  00076	89 46 0c	 mov	 DWORD PTR [esi+12], eax
; 260  : 			WCR.Mask   = M;
  00079	8b 45 fc	 mov	 eax, DWORD PTR _M$64817[ebp]
  0007c	89 06		 mov	 DWORD PTR [esi], eax
; 270  :     }
; 271  : 
; 272  : 	// 
; 273  : 	// 
; 274  : 	if (!EOL)
  0007e	84 db		 test	 bl, bl
  00080	75 04		 jne	 SHORT $LN1@WC_Compare@2
$LN24@WC_Compare@2:
; 275  : 		WCR.Result = -1;
  00082	83 4e 14 ff	 or	 DWORD PTR [esi+20], -1
$LN1@WC_Compare@2:
  00086	5f		 pop	 edi
  00087	5e		 pop	 esi
  00088	5b		 pop	 ebx
; 276  : }
  00089	c9		 leave
  0008a	c3		 ret	 0
?WC_CompareLine@@YAXAAUWILD_CMP_REC@@@Z ENDP		; WC_CompareLine
_TEXT	ENDS
PUBLIC	?m_lstrncmp@@YGHPBD0H@Z				; m_lstrncmp
; Function compile flags: /Ogspy
; File e:\projects\progs\petrosjan\bjwj\source\core\strings.cpp
;	COMDAT ?m_lstrncmp@@YGHPBD0H@Z
_TEXT	SEGMENT
_Str1$ = 8						; size = 4
_Str2$ = 12						; size = 4
_nlen$ = 16						; size = 4
?m_lstrncmp@@YGHPBD0H@Z PROC				; m_lstrncmp, COMDAT
; 13   : {
  00000	56		 push	 esi
; 14   : 	if (!Str1 || !Str2) return -1;
  00001	8b 74 24 08	 mov	 esi, DWORD PTR _Str1$[esp]
  00005	85 f6		 test	 esi, esi
  00007	74 2f		 je	 SHORT $LN5@m_lstrncmp
  00009	8b 44 24 0c	 mov	 eax, DWORD PTR _Str2$[esp]
  0000d	85 c0		 test	 eax, eax
  0000f	74 27		 je	 SHORT $LN5@m_lstrncmp
; 15   : 
; 16   : 	for (int i = 0; i < nlen; i++, Str1++, Str2++)
  00011	33 c9		 xor	 ecx, ecx
  00013	39 4c 24 10	 cmp	 DWORD PTR _nlen$[esp], ecx
  00017	7e 0f		 jle	 SHORT $LN2@m_lstrncmp
$LL4@m_lstrncmp:
; 17   : 		if (*Str1 != *Str2) return 1;
  00019	8a 16		 mov	 dl, BYTE PTR [esi]
  0001b	3a 10		 cmp	 dl, BYTE PTR [eax]
  0001d	75 14		 jne	 SHORT $LN10@m_lstrncmp
  0001f	41		 inc	 ecx
  00020	46		 inc	 esi
  00021	40		 inc	 eax
  00022	3b 4c 24 10	 cmp	 ecx, DWORD PTR _nlen$[esp]
  00026	7c f1		 jl	 SHORT $LL4@m_lstrncmp
$LN2@m_lstrncmp:
; 18   : 	return (*Str2) ? 1 : 0;
  00028	33 c9		 xor	 ecx, ecx
  0002a	38 08		 cmp	 BYTE PTR [eax], cl
  0002c	0f 95 c1	 setne	 cl
  0002f	8b c1		 mov	 eax, ecx
  00031	eb 08		 jmp	 SHORT $LN7@m_lstrncmp
$LN10@m_lstrncmp:
; 17   : 		if (*Str1 != *Str2) return 1;
  00033	33 c0		 xor	 eax, eax
  00035	40		 inc	 eax
  00036	eb 03		 jmp	 SHORT $LN7@m_lstrncmp
$LN5@m_lstrncmp:
; 14   : 	if (!Str1 || !Str2) return -1;
  00038	83 c8 ff	 or	 eax, -1
$LN7@m_lstrncmp:
  0003b	5e		 pop	 esi
; 19   : }
  0003c	c2 0c 00	 ret	 12			; 0000000cH
?m_lstrncmp@@YGHPBD0H@Z ENDP				; m_lstrncmp
_TEXT	ENDS
PUBLIC	?m_strtok_s@@YGPADPADPBDPAPAD@Z			; m_strtok_s
; Function compile flags: /Ogspy
;	COMDAT ?m_strtok_s@@YGPADPADPBDPAPAD@Z
_TEXT	SEGMENT
_token$ = 8						; size = 4
_String$ = 8						; size = 4
_Control$ = 12						; size = 4
_Context$ = 16						; size = 4
?m_strtok_s@@YGPADPADPBDPAPAD@Z PROC			; m_strtok_s, COMDAT
; 87   : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
; 88   :     char *token;
; 89   :     const char *ctl;
; 90   : 
; 91   :     if ( !String )
  00003	8b 4d 08	 mov	 ecx, DWORD PTR _String$[ebp]
  00006	85 c9		 test	 ecx, ecx
  00008	75 05		 jne	 SHORT $LN30@m_strtok_s
; 92   :     {
; 93   :         String = *Context;
  0000a	8b 45 10	 mov	 eax, DWORD PTR _Context$[ebp]
  0000d	8b 08		 mov	 ecx, DWORD PTR [eax]
$LN30@m_strtok_s:
; 94   :     }
; 95   : 
; 96   :     for ( ; *String != 0 ; String++ )
  0000f	8a 01		 mov	 al, BYTE PTR [ecx]
  00011	53		 push	 ebx
  00012	56		 push	 esi
  00013	57		 push	 edi
  00014	8b 7d 0c	 mov	 edi, DWORD PTR _Control$[ebp]
  00017	84 c0		 test	 al, al
  00019	74 21		 je	 SHORT $LN24@m_strtok_s
  0001b	8a 1f		 mov	 bl, BYTE PTR [edi]
$LL16@m_strtok_s:
; 97   :     {
; 98   :         for ( ctl = Control; *ctl != 0 && *ctl != *String; ctl++ );
  0001d	8b f7		 mov	 esi, edi
  0001f	84 db		 test	 bl, bl
  00021	74 0d		 je	 SHORT $LN31@m_strtok_s
  00023	8a d3		 mov	 dl, bl
$LL13@m_strtok_s:
  00025	3a d0		 cmp	 dl, al
  00027	74 07		 je	 SHORT $LN31@m_strtok_s
  00029	46		 inc	 esi
  0002a	8a 16		 mov	 dl, BYTE PTR [esi]
  0002c	84 d2		 test	 dl, dl
  0002e	75 f5		 jne	 SHORT $LL13@m_strtok_s
$LN31@m_strtok_s:
; 99   : 
; 100  :         if ( *ctl == 0 )
  00030	80 3e 00	 cmp	 BYTE PTR [esi], 0
  00033	74 07		 je	 SHORT $LN24@m_strtok_s
  00035	41		 inc	 ecx
  00036	8a 01		 mov	 al, BYTE PTR [ecx]
  00038	84 c0		 test	 al, al
  0003a	75 e1		 jne	 SHORT $LL16@m_strtok_s
$LN24@m_strtok_s:
; 101  :         {
; 102  :             break;
; 103  :         }
; 104  :     }
; 105  :     
; 106  : 	token = String;
; 107  : 
; 108  :     for ( ; *String != 0 ; String++)
  0003c	80 39 00	 cmp	 BYTE PTR [ecx], 0
  0003f	89 4d 08	 mov	 DWORD PTR _token$[ebp], ecx
  00042	74 28		 je	 SHORT $LN7@m_strtok_s
  00044	8a 1f		 mov	 bl, BYTE PTR [edi]
$LL9@m_strtok_s:
; 109  :     {
; 110  :         for ( ctl = Control; *ctl != 0 && *ctl != *String; ctl++ );
  00046	8b f7		 mov	 esi, edi
  00048	84 db		 test	 bl, bl
  0004a	74 0f		 je	 SHORT $LN32@m_strtok_s
  0004c	8a 11		 mov	 dl, BYTE PTR [ecx]
  0004e	8a c3		 mov	 al, bl
$LL6@m_strtok_s:
  00050	3a c2		 cmp	 al, dl
  00052	74 07		 je	 SHORT $LN32@m_strtok_s
  00054	46		 inc	 esi
  00055	8a 06		 mov	 al, BYTE PTR [esi]
  00057	84 c0		 test	 al, al
  00059	75 f5		 jne	 SHORT $LL6@m_strtok_s
$LN32@m_strtok_s:
; 111  : 
; 112  :         if ( *ctl != 0 )
  0005b	80 3e 00	 cmp	 BYTE PTR [esi], 0
  0005e	75 08		 jne	 SHORT $LN25@m_strtok_s
  00060	41		 inc	 ecx
  00061	80 39 00	 cmp	 BYTE PTR [ecx], 0
  00064	75 e0		 jne	 SHORT $LL9@m_strtok_s
  00066	eb 04		 jmp	 SHORT $LN7@m_strtok_s
$LN25@m_strtok_s:
; 113  :         {
; 114  :             *String++ = 0;
  00068	c6 01 00	 mov	 BYTE PTR [ecx], 0
  0006b	41		 inc	 ecx
$LN7@m_strtok_s:
; 115  :             break;
; 116  :         }
; 117  :     }
; 118  :     
; 119  : 	*Context = String;
  0006c	8b 45 10	 mov	 eax, DWORD PTR _Context$[ebp]
  0006f	89 08		 mov	 DWORD PTR [eax], ecx
; 120  : 
; 121  :     if ( token == String )
  00071	8b 45 08	 mov	 eax, DWORD PTR _token$[ebp]
  00074	2b c1		 sub	 eax, ecx
  00076	f7 d8		 neg	 eax
  00078	5f		 pop	 edi
  00079	1b c0		 sbb	 eax, eax
  0007b	23 45 08	 and	 eax, DWORD PTR _token$[ebp]
  0007e	5e		 pop	 esi
  0007f	5b		 pop	 ebx
; 122  :     {
; 123  :         return NULL;
; 124  :     }
; 125  :     else
; 126  :     {
; 127  :         return token;
; 128  :     }
; 129  : }
  00080	5d		 pop	 ebp
  00081	c2 0c 00	 ret	 12			; 0000000cH
?m_strtok_s@@YGPADPADPBDPAPAD@Z ENDP			; m_strtok_s
_TEXT	ENDS
PUBLIC	?m_isspace@@YGHD@Z				; m_isspace
; Function compile flags: /Ogspy
;	COMDAT ?m_isspace@@YGHD@Z
_TEXT	SEGMENT
_x$ = 8							; size = 1
?m_isspace@@YGHD@Z PROC					; m_isspace, COMDAT
; 134  : 	return ( x == ' ' );
  00000	33 c0		 xor	 eax, eax
  00002	80 7c 24 04 20	 cmp	 BYTE PTR _x$[esp-4], 32	; 00000020H
  00007	0f 94 c0	 sete	 al
; 135  : }
  0000a	c2 04 00	 ret	 4
?m_isspace@@YGHD@Z ENDP					; m_isspace
_TEXT	ENDS
PUBLIC	?m_isdigit@@YGHD@Z				; m_isdigit
; Function compile flags: /Ogspy
;	COMDAT ?m_isdigit@@YGHD@Z
_TEXT	SEGMENT
_x$ = 8							; size = 1
?m_isdigit@@YGHD@Z PROC					; m_isdigit, COMDAT
; 140  : 	return ( ( x >= '0' ) && ( x <= '9' ) );
  00000	0f b6 44 24 04	 movzx	 eax, BYTE PTR _x$[esp-4]
  00005	2c 30		 sub	 al, 48			; 00000030H
  00007	b1 09		 mov	 cl, 9
  00009	3a c8		 cmp	 cl, al
  0000b	1b c0		 sbb	 eax, eax
  0000d	40		 inc	 eax
; 141  : }
  0000e	c2 04 00	 ret	 4
?m_isdigit@@YGHD@Z ENDP					; m_isdigit
_TEXT	ENDS
PUBLIC	?m_atol@@YGJPBD@Z				; m_atol
; Function compile flags: /Ogspy
;	COMDAT ?m_atol@@YGJPBD@Z
_TEXT	SEGMENT
_nptr$ = 8						; size = 4
?m_atol@@YGJPBD@Z PROC					; m_atol, COMDAT
; 146  : 	if ( !nptr )
  00000	8b 4c 24 04	 mov	 ecx, DWORD PTR _nptr$[esp-4]
  00004	85 c9		 test	 ecx, ecx
  00006	75 05		 jne	 SHORT $LN23@m_atol
; 147  : 		return 0;
  00008	33 c0		 xor	 eax, eax
  0000a	eb 3e		 jmp	 SHORT $LN1@m_atol
$LL8@m_atol:
; 154  : 	{
; 155  : 		++nptr;
  0000c	41		 inc	 ecx
$LN23@m_atol:
; 148  : 
; 149  : 	int c;              
; 150  : 	long total;         
; 151  : 	int sign;           
; 152  : 	
; 153  : 	while ( m_isspace( (int)(unsigned char)*nptr ) )
  0000d	80 39 20	 cmp	 BYTE PTR [ecx], 32	; 00000020H
  00010	74 fa		 je	 SHORT $LL8@m_atol
; 156  : 	}
; 157  : 	
; 158  : 	c = (int)(unsigned char)*nptr++;
  00012	0f b6 11	 movzx	 edx, BYTE PTR [ecx]
  00015	56		 push	 esi
  00016	41		 inc	 ecx
  00017	57		 push	 edi
; 159  : 
; 160  : 	sign = c;
  00018	8b fa		 mov	 edi, edx
; 161  : 
; 162  : 	if ( c == '-' || c == '+' )
  0001a	83 fa 2d	 cmp	 edx, 45			; 0000002dH
  0001d	74 05		 je	 SHORT $LN5@m_atol
  0001f	83 fa 2b	 cmp	 edx, 43			; 0000002bH
  00022	75 04		 jne	 SHORT $LN6@m_atol
$LN5@m_atol:
; 163  : 	{
; 164  : 		c = (int)(unsigned char)*nptr++;
  00024	0f b6 11	 movzx	 edx, BYTE PTR [ecx]
  00027	41		 inc	 ecx
$LN6@m_atol:
; 165  : 	}
; 166  : 	
; 167  : 	total = 0;
  00028	33 f6		 xor	 esi, esi
$LL4@m_atol:
; 168  : 	
; 169  : 	while ( m_isdigit( c ) )
  0002a	8a c2		 mov	 al, dl
  0002c	2c 30		 sub	 al, 48			; 00000030H
  0002e	3c 09		 cmp	 al, 9
  00030	77 0d		 ja	 SHORT $LN16@m_atol
; 170  : 	{
; 171  : 		total = 10 * total + ( c - '0' );     
  00032	6b f6 0a	 imul	 esi, 10			; 0000000aH
  00035	8d 74 16 d0	 lea	 esi, DWORD PTR [esi+edx-48]
; 172  : 		c = (int)(unsigned char)*nptr++;    
  00039	0f b6 11	 movzx	 edx, BYTE PTR [ecx]
  0003c	41		 inc	 ecx
; 173  : 	}
  0003d	eb eb		 jmp	 SHORT $LL4@m_atol
; 168  : 	
; 169  : 	while ( m_isdigit( c ) )
$LN16@m_atol:
; 174  : 	
; 175  : 	if ( sign == '-' )
; 176  : 	{
; 177  : 		return -total;
  0003f	8b c6		 mov	 eax, esi
  00041	83 ff 2d	 cmp	 edi, 45			; 0000002dH
  00044	75 02		 jne	 SHORT $LN22@m_atol
  00046	f7 d8		 neg	 eax
$LN22@m_atol:
  00048	5f		 pop	 edi
  00049	5e		 pop	 esi
$LN1@m_atol:
; 178  : 	}
; 179  : 	else
; 180  : 	{
; 181  : 		return total;   
; 182  : 	}
; 183  : }
  0004a	c2 04 00	 ret	 4
?m_atol@@YGJPBD@Z ENDP					; m_atol
_TEXT	ENDS
PUBLIC	?m_atoi@@YAHPBD@Z				; m_atoi
; Function compile flags: /Ogspy
;	COMDAT ?m_atoi@@YAHPBD@Z
_TEXT	SEGMENT
_nptr$ = 8						; size = 4
?m_atoi@@YAHPBD@Z PROC					; m_atoi, COMDAT
; 188  : 	return (int)m_atol(nptr);
  00000	ff 74 24 04	 push	 DWORD PTR _nptr$[esp-4]
  00004	e8 00 00 00 00	 call	 ?m_atol@@YGJPBD@Z	; m_atol
; 189  : }
  00009	c3		 ret	 0
?m_atoi@@YAHPBD@Z ENDP					; m_atoi
_TEXT	ENDS
PUBLIC	?m_wcslen@@YGKPB_W@Z				; m_wcslen
; Function compile flags: /Ogspy
;	COMDAT ?m_wcslen@@YGKPB_W@Z
_TEXT	SEGMENT
_String$ = 8						; size = 4
?m_wcslen@@YGKPB_W@Z PROC				; m_wcslen, COMDAT
; 382  : 	if ( !String )
  00000	8b 4c 24 04	 mov	 ecx, DWORD PTR _String$[esp-4]
  00004	85 c9		 test	 ecx, ecx
  00006	75 04		 jne	 SHORT $LN3@m_wcslen
; 383  : 	{
; 384  : 		return 0;
  00008	33 c0		 xor	 eax, eax
  0000a	eb 14		 jmp	 SHORT $LN4@m_wcslen
$LN3@m_wcslen:
; 385  : 	}
; 386  : 
; 387  : 	wchar_t* p = (wchar_t *)String;
; 388  : 
; 389  : 	for( ; *p != 0; )
  0000c	66 83 39 00	 cmp	 WORD PTR [ecx], 0
  00010	8b c1		 mov	 eax, ecx
  00012	74 08		 je	 SHORT $LN1@m_wcslen
$LL2@m_wcslen:
; 390  : 	{
; 391  : 		p++;
  00014	40		 inc	 eax
  00015	40		 inc	 eax
  00016	66 83 38 00	 cmp	 WORD PTR [eax], 0
  0001a	75 f8		 jne	 SHORT $LL2@m_wcslen
$LN1@m_wcslen:
; 392  : 	}
; 393  : 
; 394  : 	return p - String;
  0001c	2b c1		 sub	 eax, ecx
  0001e	d1 f8		 sar	 eax, 1
$LN4@m_wcslen:
; 395  : }
  00020	c2 04 00	 ret	 4
?m_wcslen@@YGKPB_W@Z ENDP				; m_wcslen
_TEXT	ENDS
PUBLIC	?m_wcsncpy@@YAPA_WPA_W0K@Z			; m_wcsncpy
; Function compile flags: /Ogspy
;	COMDAT ?m_wcsncpy@@YAPA_WPA_W0K@Z
_TEXT	SEGMENT
_dest$ = 8						; size = 4
_src$ = 12						; size = 4
_n$ = 16						; size = 4
?m_wcsncpy@@YAPA_WPA_W0K@Z PROC				; m_wcsncpy, COMDAT
; 400  : 	if ( !dest || !src )
  00000	8b 44 24 04	 mov	 eax, DWORD PTR _dest$[esp-4]
  00004	85 c0		 test	 eax, eax
  00006	74 25		 je	 SHORT $LN4@m_wcsncpy
  00008	8b 54 24 08	 mov	 edx, DWORD PTR _src$[esp-4]
  0000c	85 d2		 test	 edx, edx
  0000e	74 1d		 je	 SHORT $LN4@m_wcsncpy
  00010	56		 push	 esi
; 403  : 	}
; 404  : 
; 405  : 	for ( ULONG i = 0; i < n; i++ ) 
  00011	8b 74 24 10	 mov	 esi, DWORD PTR _n$[esp]
  00015	85 f6		 test	 esi, esi
  00017	76 12		 jbe	 SHORT $LN1@m_wcsncpy
  00019	8b c8		 mov	 ecx, eax
  0001b	2b d0		 sub	 edx, eax
  0001d	57		 push	 edi
$LL3@m_wcsncpy:
; 406  :     {
; 407  : 	   dest[i] = src[i];
  0001e	66 8b 3c 0a	 mov	 di, WORD PTR [edx+ecx]
  00022	66 89 39	 mov	 WORD PTR [ecx], di
  00025	41		 inc	 ecx
  00026	41		 inc	 ecx
  00027	4e		 dec	 esi
  00028	75 f4		 jne	 SHORT $LL3@m_wcsncpy
  0002a	5f		 pop	 edi
$LN1@m_wcsncpy:
  0002b	5e		 pop	 esi
; 408  :     }
; 409  : 
; 410  :     return dest;
; 411  : }
  0002c	c3		 ret	 0
$LN4@m_wcsncpy:
; 401  : 	{
; 402  : 		return NULL;
  0002d	33 c0		 xor	 eax, eax
; 408  :     }
; 409  : 
; 410  :     return dest;
; 411  : }
  0002f	c3		 ret	 0
?m_wcsncpy@@YAPA_WPA_W0K@Z ENDP				; m_wcsncpy
_TEXT	ENDS
PUBLIC	?m_wcsncmp@@YA_NPA_W0I@Z			; m_wcsncmp
; Function compile flags: /Ogspy
;	COMDAT ?m_wcsncmp@@YA_NPA_W0I@Z
_TEXT	SEGMENT
_s1$ = 8						; size = 4
_s2$ = 12						; size = 4
_iMaxLen$ = 16						; size = 4
?m_wcsncmp@@YA_NPA_W0I@Z PROC				; m_wcsncmp, COMDAT
; 414  : {
  00000	56		 push	 esi
; 415  : 	if ( !s1 || !s2 )
  00001	8b 74 24 08	 mov	 esi, DWORD PTR _s1$[esp]
  00005	57		 push	 edi
  00006	85 f6		 test	 esi, esi
  00008	74 31		 je	 SHORT $LN7@m_wcsncmp
  0000a	8b 44 24 10	 mov	 eax, DWORD PTR _s2$[esp+4]
  0000e	85 c0		 test	 eax, eax
  00010	74 29		 je	 SHORT $LN7@m_wcsncmp
; 418  : 	}
; 419  : 
; 420  : 	for ( size_t i = 0; i < iMaxLen; i++ )
  00012	33 ff		 xor	 edi, edi
  00014	39 7c 24 14	 cmp	 DWORD PTR _iMaxLen$[esp+4], edi
  00018	76 21		 jbe	 SHORT $LN7@m_wcsncmp
  0001a	2b f0		 sub	 esi, eax
$LL6@m_wcsncmp:
; 421  : 	{
; 422  : 		if ( !s1[i] || !s2[i] )
  0001c	0f b7 0c 06	 movzx	 ecx, WORD PTR [esi+eax]
  00020	66 85 c9	 test	 cx, cx
  00023	74 1b		 je	 SHORT $LN2@m_wcsncmp
  00025	0f b7 10	 movzx	 edx, WORD PTR [eax]
  00028	66 85 d2	 test	 dx, dx
  0002b	74 13		 je	 SHORT $LN2@m_wcsncmp
; 425  : 		}
; 426  : 
; 427  : 		if ( s1[i] != s2[i] )
  0002d	66 3b ca	 cmp	 cx, dx
  00030	75 0e		 jne	 SHORT $LN2@m_wcsncmp
  00032	47		 inc	 edi
  00033	40		 inc	 eax
  00034	40		 inc	 eax
  00035	3b 7c 24 14	 cmp	 edi, DWORD PTR _iMaxLen$[esp+4]
  00039	72 e1		 jb	 SHORT $LL6@m_wcsncmp
$LN7@m_wcsncmp:
; 416  : 	{
; 417  : 		return false;
  0003b	32 c0		 xor	 al, al
$LN9@m_wcsncmp:
  0003d	5f		 pop	 edi
  0003e	5e		 pop	 esi
; 428  : 		{
; 429  : 			return true;
; 430  : 		}
; 431  : 	}
; 432  : 
; 433  : 	return false;
; 434  : }
  0003f	c3		 ret	 0
$LN2@m_wcsncmp:
; 423  : 		{
; 424  : 			return true;
  00040	b0 01		 mov	 al, 1
  00042	eb f9		 jmp	 SHORT $LN9@m_wcsncmp
?m_wcsncmp@@YA_NPA_W0I@Z ENDP				; m_wcsncmp
_TEXT	ENDS
PUBLIC	?m_wcscpy@@YAPA_WPA_WH0@Z			; m_wcscpy
; Function compile flags: /Ogspy
;	COMDAT ?m_wcscpy@@YAPA_WPA_WH0@Z
_TEXT	SEGMENT
_dest$ = 8						; size = 4
_c_dest$ = 12						; size = 4
_src$ = 16						; size = 4
?m_wcscpy@@YAPA_WPA_WH0@Z PROC				; m_wcscpy, COMDAT
; 437  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
; 438  : 	if( src == 0 )
  00003	8b 4d 10	 mov	 ecx, DWORD PTR _src$[ebp]
; 439  : 	{
; 440  : 		if( dest && c_dest > 0 ) dest[0] = 0;
  00006	8b 45 08	 mov	 eax, DWORD PTR _dest$[ebp]
  00009	53		 push	 ebx
  0000a	33 db		 xor	 ebx, ebx
  0000c	3b cb		 cmp	 ecx, ebx
  0000e	75 10		 jne	 SHORT $LN6@m_wcscpy
  00010	3b c3		 cmp	 eax, ebx
  00012	74 39		 je	 SHORT $LN3@m_wcscpy
  00014	39 5d 0c	 cmp	 DWORD PTR _c_dest$[ebp], ebx
  00017	7e 34		 jle	 SHORT $LN3@m_wcscpy
  00019	33 c9		 xor	 ecx, ecx
  0001b	66 89 08	 mov	 WORD PTR [eax], cx
; 441  : 	}
; 442  : 	else
  0001e	eb 2d		 jmp	 SHORT $LN3@m_wcscpy
$LN6@m_wcscpy:
; 443  : 		if( dest )
  00020	3b c3		 cmp	 eax, ebx
  00022	74 29		 je	 SHORT $LN3@m_wcscpy
  00024	57		 push	 edi
; 444  : 		{
; 445  : 			int i = 0;
; 446  : 			while( i < c_dest - 1 && src[i] )
  00025	8b 7d 0c	 mov	 edi, DWORD PTR _c_dest$[ebp]
  00028	4f		 dec	 edi
  00029	3b fb		 cmp	 edi, ebx
  0002b	7e 19		 jle	 SHORT $LN1@m_wcscpy
  0002d	56		 push	 esi
  0002e	8b f0		 mov	 esi, eax
  00030	2b f1		 sub	 esi, ecx
$LL2@m_wcscpy:
  00032	0f b7 11	 movzx	 edx, WORD PTR [ecx]
  00035	66 85 d2	 test	 dx, dx
  00038	74 0b		 je	 SHORT $LN11@m_wcscpy
; 447  : 			{
; 448  : 				dest[i] = src[i];
  0003a	66 89 14 0e	 mov	 WORD PTR [esi+ecx], dx
; 449  : 				i++;
  0003e	43		 inc	 ebx
  0003f	41		 inc	 ecx
  00040	41		 inc	 ecx
  00041	3b df		 cmp	 ebx, edi
  00043	7c ed		 jl	 SHORT $LL2@m_wcscpy
$LN11@m_wcscpy:
  00045	5e		 pop	 esi
$LN1@m_wcscpy:
; 450  : 			}
; 451  : 			dest[i] = 0;
  00046	33 c9		 xor	 ecx, ecx
  00048	66 89 0c 58	 mov	 WORD PTR [eax+ebx*2], cx
  0004c	5f		 pop	 edi
$LN3@m_wcscpy:
  0004d	5b		 pop	 ebx
; 452  : 		}
; 453  : 	return dest;
; 454  : }
  0004e	5d		 pop	 ebp
  0004f	c3		 ret	 0
?m_wcscpy@@YAPA_WPA_WH0@Z ENDP				; m_wcscpy
_TEXT	ENDS
PUBLIC	?m_wcslwr@@YAPA_WPA_W@Z				; m_wcslwr
; Function compile flags: /Ogspy
;	COMDAT ?m_wcslwr@@YAPA_WPA_W@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?m_wcslwr@@YAPA_WPA_W@Z PROC				; m_wcslwr, COMDAT
; 458  : 	if ( !Str )
  00000	8b 54 24 04	 mov	 edx, DWORD PTR _Str$[esp-4]
  00004	85 d2		 test	 edx, edx
  00006	75 03		 jne	 SHORT $LN5@m_wcslwr
; 459  : 	{
; 460  : 		return NULL;
  00008	33 c0		 xor	 eax, eax
; 474  : }
  0000a	c3		 ret	 0
$LN5@m_wcslwr:
  0000b	56		 push	 esi
; 461  : 	}
; 462  : 
; 463  :     wchar_t *Pos = Str;
; 464  : 
; 465  :     for ( ; Str <= ( Pos + m_wcslen( Pos ) ); Str++ )
  0000c	52		 push	 edx
  0000d	8b f2		 mov	 esi, edx
  0000f	e8 00 00 00 00	 call	 ?m_wcslen@@YGKPB_W@Z	; m_wcslen
  00014	8d 04 42	 lea	 eax, DWORD PTR [edx+eax*2]
  00017	eb 20		 jmp	 SHORT $LN10@m_wcslwr
$LL4@m_wcslwr:
; 466  :     {		
; 467  :         if ( ( *Str >= 'A' ) && ( *Str <= 'Z' ) ) 
  00019	0f b7 02	 movzx	 eax, WORD PTR [edx]
  0001c	66 83 f8 41	 cmp	 ax, 65			; 00000041H
  00020	72 0c		 jb	 SHORT $LN3@m_wcslwr
  00022	66 83 f8 5a	 cmp	 ax, 90			; 0000005aH
  00026	77 06		 ja	 SHORT $LN3@m_wcslwr
; 468  : 		{
; 469  : 			*Str = *Str + ('a'-'A');
  00028	83 c0 20	 add	 eax, 32			; 00000020H
  0002b	66 89 02	 mov	 WORD PTR [edx], ax
$LN3@m_wcslwr:
  0002e	42		 inc	 edx
  0002f	56		 push	 esi
  00030	42		 inc	 edx
  00031	e8 00 00 00 00	 call	 ?m_wcslen@@YGKPB_W@Z	; m_wcslen
  00036	8d 04 46	 lea	 eax, DWORD PTR [esi+eax*2]
$LN10@m_wcslwr:
; 461  : 	}
; 462  : 
; 463  :     wchar_t *Pos = Str;
; 464  : 
; 465  :     for ( ; Str <= ( Pos + m_wcslen( Pos ) ); Str++ )
  00039	3b d0		 cmp	 edx, eax
  0003b	76 dc		 jbe	 SHORT $LL4@m_wcslwr
; 470  : 		}
; 471  :     }
; 472  : 
; 473  :     return Pos;
  0003d	8b c6		 mov	 eax, esi
  0003f	5e		 pop	 esi
; 474  : }
  00040	c3		 ret	 0
?m_wcslwr@@YAPA_WPA_W@Z ENDP				; m_wcslwr
_TEXT	ENDS
PUBLIC	?m_wcsstr@@YGPB_WPB_W0@Z			; m_wcsstr
; Function compile flags: /Ogspy
;	COMDAT ?m_wcsstr@@YGPB_WPB_W0@Z
_TEXT	SEGMENT
_sslen$ = -4						; size = 4
_s$ = 8							; size = 4
__Str$ = 8						; size = 4
__SubStr$ = 12						; size = 4
?m_wcsstr@@YGPB_WPB_W0@Z PROC				; m_wcsstr, COMDAT
; 477  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
; 478  : 	if( !_Str || !_SubStr )
  00004	83 7d 08 00	 cmp	 DWORD PTR __Str$[ebp], 0
  00008	53		 push	 ebx
  00009	56		 push	 esi
  0000a	57		 push	 edi
  0000b	74 5d		 je	 SHORT $LN12@m_wcsstr
  0000d	83 7d 0c 00	 cmp	 DWORD PTR __SubStr$[ebp], 0
  00011	74 57		 je	 SHORT $LN12@m_wcsstr
; 480  : 
; 481  : 	int f = 1;
; 482  : 	int s;
; 483  : 
; 484  : 	size_t sslen = m_wcslen(_SubStr);
  00013	ff 75 0c	 push	 DWORD PTR __SubStr$[ebp]
  00016	e8 00 00 00 00	 call	 ?m_wcslen@@YGKPB_W@Z	; m_wcslen
  0001b	8b 4d 0c	 mov	 ecx, DWORD PTR __SubStr$[ebp]
  0001e	89 45 fc	 mov	 DWORD PTR _sslen$[ebp], eax
; 485  : 
; 486  : 	for ( const wchar_t* p = (const wchar_t*)_Str; f;  p++ )
  00021	8b 45 08	 mov	 eax, DWORD PTR __Str$[ebp]
  00024	2b c8		 sub	 ecx, eax
$LL11@m_wcsstr:
; 487  : 	{
; 488  : 		const wchar_t* k = (const wchar_t*)_SubStr;
; 489  : 
; 490  : 		if ( *p == 0 )
  00026	0f b7 30	 movzx	 esi, WORD PTR [eax]
  00029	66 85 f6	 test	 si, si
  0002c	74 3c		 je	 SHORT $LN12@m_wcsstr
; 491  : 		{
; 492  : 			break;
; 493  : 		}
; 494  : 
; 495  : 		if ( *k == 0 )
  0002e	8b 55 0c	 mov	 edx, DWORD PTR __SubStr$[ebp]
  00031	0f b7 12	 movzx	 edx, WORD PTR [edx]
  00034	66 85 d2	 test	 dx, dx
  00037	74 31		 je	 SHORT $LN12@m_wcsstr
; 496  : 		{
; 497  : 			break;
; 498  : 		}
; 499  : 
; 500  : 		if ( *p == *k )
  00039	66 3b f2	 cmp	 si, dx
  0003c	75 26		 jne	 SHORT $LN10@m_wcsstr
; 501  : 		{
; 502  : 			const wchar_t* p1 = p;
; 503  : 			const wchar_t* k1 = k;
; 504  : 
; 505  : 			s = 0;
  0003e	83 65 08 00	 and	 DWORD PTR _s$[ebp], 0
  00042	8b d0		 mov	 edx, eax
$LL5@m_wcsstr:
; 506  : 
; 507  : 			for( ; true;  )
; 508  : 			{
; 509  : 				if( *p1 == *k1 )
  00044	0f b7 32	 movzx	 esi, WORD PTR [edx]
  00047	0f b7 3c 11	 movzx	 edi, WORD PTR [ecx+edx]
  0004b	66 3b f7	 cmp	 si, di
  0004e	75 03		 jne	 SHORT $LN3@m_wcsstr
; 510  : 				{
; 511  : 					s++;
  00050	ff 45 08	 inc	 DWORD PTR _s$[ebp]
$LN3@m_wcsstr:
; 512  : 				}
; 513  : 
; 514  : 				if( s == (int)sslen )
  00053	8b 5d fc	 mov	 ebx, DWORD PTR _sslen$[ebp]
  00056	39 5d 08	 cmp	 DWORD PTR _s$[ebp], ebx
  00059	74 11		 je	 SHORT $LN14@m_wcsstr
; 515  : 				{
; 516  : 					return p;
; 517  : 				}
; 518  : 
; 519  : 				if( *p1 != *k1 )
  0005b	66 3b f7	 cmp	 si, di
  0005e	75 04		 jne	 SHORT $LN10@m_wcsstr
; 520  : 				{
; 521  : 					break;
; 522  : 				}
; 523  : 
; 524  : 				p1++;
  00060	42		 inc	 edx
  00061	42		 inc	 edx
; 525  : 				k1++;
; 526  : 			}
  00062	eb e0		 jmp	 SHORT $LL5@m_wcsstr
$LN10@m_wcsstr:
; 485  : 
; 486  : 	for ( const wchar_t* p = (const wchar_t*)_Str; f;  p++ )
  00064	40		 inc	 eax
  00065	40		 inc	 eax
  00066	49		 dec	 ecx
  00067	49		 dec	 ecx
  00068	eb bc		 jmp	 SHORT $LL11@m_wcsstr
$LN12@m_wcsstr:
; 479  : 		return NULL;
  0006a	33 c0		 xor	 eax, eax
$LN14@m_wcsstr:
  0006c	5f		 pop	 edi
  0006d	5e		 pop	 esi
  0006e	5b		 pop	 ebx
; 527  : 
; 528  : 		}
; 529  : 	}
; 530  : 
; 531  : 	return NULL;
; 532  : }
  0006f	c9		 leave
  00070	c2 08 00	 ret	 8
?m_wcsstr@@YGPB_WPB_W0@Z ENDP				; m_wcsstr
_TEXT	ENDS
PUBLIC	?MakeHead@STRHEAD@@YAPAEPAEKKE@Z		; STRHEAD::MakeHead
EXTRN	?m_memset@@YAXPBXEI@Z:PROC			; m_memset
; Function compile flags: /Ogspy
;	COMDAT ?MakeHead@STRHEAD@@YAPAEPAEKKE@Z
_TEXT	SEGMENT
_Buf$ = 8						; size = 4
_BufSize$ = 12						; size = 4
_Length$ = 16						; size = 4
_CharSize$ = 20						; size = 1
?MakeHead@STRHEAD@@YAPAEPAEKKE@Z PROC			; STRHEAD::MakeHead, COMDAT
; 624  : 		// 
; 625  : 		LPBYTE Res = Buf + HeadSize;
  00000	8b 44 24 04	 mov	 eax, DWORD PTR _Buf$[esp-4]
; 626  : 		PHead H = (PHead)Buf;
; 627  : 
; 628  : 		H->Signature = StrSignature;
; 629  : 		H->BufSize = BufSize;
  00004	8b 4c 24 08	 mov	 ecx, DWORD PTR _BufSize$[esp-4]
  00008	89 48 04	 mov	 DWORD PTR [eax+4], ecx
; 630  : 		H->Length = Length;
  0000b	8b 4c 24 0c	 mov	 ecx, DWORD PTR _Length$[esp-4]
  0000f	56		 push	 esi
  00010	8d 70 0c	 lea	 esi, DWORD PTR [eax+12]
  00013	c7 00 53 4d 53
	54		 mov	 DWORD PTR [eax], 1414745427 ; 54534d53H
  00019	89 48 08	 mov	 DWORD PTR [eax+8], ecx
; 631  : 
; 632  : 		m_memset((Res + Length*CharSize), 0, CharSize);
  0001c	0f b6 44 24 14	 movzx	 eax, BYTE PTR _CharSize$[esp]
  00021	50		 push	 eax
  00022	0f af c1	 imul	 eax, ecx
  00025	03 c6		 add	 eax, esi
  00027	6a 00		 push	 0
  00029	50		 push	 eax
  0002a	e8 00 00 00 00	 call	 ?m_memset@@YAXPBXEI@Z	; m_memset
  0002f	83 c4 0c	 add	 esp, 12			; 0000000cH
; 633  : 		return Res;
  00032	8b c6		 mov	 eax, esi
  00034	5e		 pop	 esi
; 634  : 	}
  00035	c3		 ret	 0
?MakeHead@STRHEAD@@YAPAEPAEKKE@Z ENDP			; STRHEAD::MakeHead
_TEXT	ENDS
PUBLIC	?CheckSignature@STRHEAD@@YA_NPAX@Z		; STRHEAD::CheckSignature
; Function compile flags: /Ogspy
;	COMDAT ?CheckSignature@STRHEAD@@YA_NPAX@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?CheckSignature@STRHEAD@@YA_NPAX@Z PROC			; STRHEAD::CheckSignature, COMDAT
; 641  : 		if (Str == NULL) return false;
  00000	8b 44 24 04	 mov	 eax, DWORD PTR _Str$[esp-4]
  00004	85 c0		 test	 eax, eax
  00006	75 03		 jne	 SHORT $LN1@CheckSigna
  00008	32 c0		 xor	 al, al
; 643  :     }
  0000a	c3		 ret	 0
$LN1@CheckSigna:
; 642  : 		return StrHead(Str)->Signature == StrSignature;
  0000b	33 c9		 xor	 ecx, ecx
  0000d	81 78 f4 53 4d
	53 54		 cmp	 DWORD PTR [eax-12], 1414745427 ; 54534d53H
  00014	0f 94 c1	 sete	 cl
  00017	8a c1		 mov	 al, cl
; 643  :     }
  00019	c3		 ret	 0
?CheckSignature@STRHEAD@@YA_NPAX@Z ENDP			; STRHEAD::CheckSignature
_TEXT	ENDS
PUBLIC	?GetBufferSize@STRHEAD@@YAKPAD@Z		; STRHEAD::GetBufferSize
; Function compile flags: /Ogspy
;	COMDAT ?GetBufferSize@STRHEAD@@YAKPAD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?GetBufferSize@STRHEAD@@YAKPAD@Z PROC			; STRHEAD::GetBufferSize, COMDAT
; 649  : 		return StrHead(Str)->BufSize;
  00000	8b 44 24 04	 mov	 eax, DWORD PTR _Str$[esp-4]
  00004	8b 40 f8	 mov	 eax, DWORD PTR [eax-8]
; 650  : 	}
  00007	c3		 ret	 0
?GetBufferSize@STRHEAD@@YAKPAD@Z ENDP			; STRHEAD::GetBufferSize
_TEXT	ENDS
PUBLIC	?GetLength@STRHEAD@@YAKPAD@Z			; STRHEAD::GetLength
; Function compile flags: /Ogspy
;	COMDAT ?GetLength@STRHEAD@@YAKPAD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?GetLength@STRHEAD@@YAKPAD@Z PROC			; STRHEAD::GetLength, COMDAT
; 654  :     	return StrHead(Str)->Length;
  00000	8b 44 24 04	 mov	 eax, DWORD PTR _Str$[esp-4]
  00004	8b 40 fc	 mov	 eax, DWORD PTR [eax-4]
; 655  : 	}
  00007	c3		 ret	 0
?GetLength@STRHEAD@@YAKPAD@Z ENDP			; STRHEAD::GetLength
_TEXT	ENDS
PUBLIC	?SetLength@STRHEAD@@YAXPADK@Z			; STRHEAD::SetLength
; Function compile flags: /Ogspy
;	COMDAT ?SetLength@STRHEAD@@YAXPADK@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_Length$ = 12						; size = 4
?SetLength@STRHEAD@@YAXPADK@Z PROC			; STRHEAD::SetLength, COMDAT
; 659  : 		StrHead(Str)->Length = Length;
  00000	8b 44 24 08	 mov	 eax, DWORD PTR _Length$[esp-4]
  00004	8b 4c 24 04	 mov	 ecx, DWORD PTR _Str$[esp-4]
  00008	89 41 fc	 mov	 DWORD PTR [ecx-4], eax
; 660  : 		*(Str + Length) = 0;
  0000b	c6 04 01 00	 mov	 BYTE PTR [ecx+eax], 0
; 661  :     }
  0000f	c3		 ret	 0
?SetLength@STRHEAD@@YAXPADK@Z ENDP			; STRHEAD::SetLength
_TEXT	ENDS
PUBLIC	?Alloc@STR@@YAPADK@Z				; STR::Alloc
EXTRN	?Alloc@HEAP@@YAPAXK@Z:PROC			; HEAP::Alloc
; Function compile flags: /Ogspy
;	COMDAT ?Alloc@STR@@YAPADK@Z
_TEXT	SEGMENT
_StrLen$ = 8						; size = 4
?Alloc@STR@@YAPADK@Z PROC				; STR::Alloc, COMDAT
; 669  : {
  00000	56		 push	 esi
; 670  : 	// 
 StrLen. 
; 671  : 	// 
 StrLen + 1 (
; 672  : 
; 673  : 	if (StrLen == 0) return NULL;
  00001	8b 74 24 08	 mov	 esi, DWORD PTR _StrLen$[esp]
  00005	85 f6		 test	 esi, esi
  00007	75 04		 jne	 SHORT $LN2@Alloc
$LN5@Alloc:
  00009	33 c0		 xor	 eax, eax
  0000b	5e		 pop	 esi
; 679  : }
  0000c	c3		 ret	 0
$LN2@Alloc:
; 674  : 
; 675  : 	PCHAR Str = (PCHAR)HEAP::Alloc(StrLen + STRHEAD::HeadSize + 1);
  0000d	8d 46 0d	 lea	 eax, DWORD PTR [esi+13]
  00010	50		 push	 eax
  00011	e8 00 00 00 00	 call	 ?Alloc@HEAP@@YAPAXK@Z	; HEAP::Alloc
  00016	59		 pop	 ecx
; 676  : 	if (Str == NULL) return NULL;
  00017	85 c0		 test	 eax, eax
  00019	74 ee		 je	 SHORT $LN5@Alloc
; 677  : 
; 678  : 	return (PCHAR)STRHEAD::MakeHead((LPBYTE)Str, StrLen, StrLen);
  0001b	6a 01		 push	 1
  0001d	56		 push	 esi
  0001e	56		 push	 esi
  0001f	50		 push	 eax
  00020	e8 00 00 00 00	 call	 ?MakeHead@STRHEAD@@YAPAEPAEKKE@Z ; STRHEAD::MakeHead
  00025	83 c4 10	 add	 esp, 16			; 00000010H
  00028	5e		 pop	 esi
; 679  : }
  00029	c3		 ret	 0
?Alloc@STR@@YAPADK@Z ENDP				; STR::Alloc
_TEXT	ENDS
PUBLIC	?Free@STR@@YAXPAD@Z				; STR::Free
EXTRN	?Free@HEAP@@YAXPAX@Z:PROC			; HEAP::Free
; Function compile flags: /Ogspy
;	COMDAT ?Free@STR@@YAXPAD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?Free@STR@@YAXPAD@Z PROC				; STR::Free, COMDAT
; 716  :     // 
; 717  : 	// 
 STR::New
; 718  :     if (STRHEAD::CheckSignature(Str))
  00000	8b 54 24 04	 mov	 edx, DWORD PTR _Str$[esp-4]
  00004	52		 push	 edx
  00005	e8 00 00 00 00	 call	 ?CheckSignature@STRHEAD@@YA_NPAX@Z ; STRHEAD::CheckSignature
  0000a	59		 pop	 ecx
  0000b	84 c0		 test	 al, al
  0000d	74 0a		 je	 SHORT $LN1@Free
; 719  : 		HEAP::Free(Str - STRHEAD::HeadSize);
  0000f	83 c2 f4	 add	 edx, -12		; fffffff4H
  00012	52		 push	 edx
  00013	e8 00 00 00 00	 call	 ?Free@HEAP@@YAXPAX@Z	; HEAP::Free
  00018	59		 pop	 ecx
$LN1@Free:
; 720  : }
  00019	c3		 ret	 0
?Free@STR@@YAXPAD@Z ENDP				; STR::Free
_TEXT	ENDS
PUBLIC	?Free2@STR@@YAXAAPAD@Z				; STR::Free2
; Function compile flags: /Ogspy
;	COMDAT ?Free2@STR@@YAXAAPAD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?Free2@STR@@YAXAAPAD@Z PROC				; STR::Free2, COMDAT
; 723  : {
  00000	56		 push	 esi
; 724  : 	// 
; 725  : 	STR::Free(Str);
  00001	8b 74 24 08	 mov	 esi, DWORD PTR _Str$[esp]
  00005	ff 36		 push	 DWORD PTR [esi]
  00007	e8 00 00 00 00	 call	 ?Free@STR@@YAXPAD@Z	; STR::Free
; 726  : 	Str = NULL;
  0000c	83 26 00	 and	 DWORD PTR [esi], 0
  0000f	59		 pop	 ecx
  00010	5e		 pop	 esi
; 727  : }
  00011	c3		 ret	 0
?Free2@STR@@YAXAAPAD@Z ENDP				; STR::Free2
_TEXT	ENDS
PUBLIC	?StrSetLength@@YAXAAPADK@Z			; StrSetLength
EXTRN	?m_memcpy@@YAPAXPAXPBXH@Z:PROC			; m_memcpy
; Function compile flags: /Ogspy
;	COMDAT ?StrSetLength@@YAXAAPADK@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_NewLength$ = 12					; size = 4
?StrSetLength@@YAXAAPADK@Z PROC				; StrSetLength, COMDAT
; 817  : {
  00000	53		 push	 ebx
; 818  : 	// 
; 819  : 	// 
 STR::New
; 820  : 
; 821  : 	// 
; 822  : 	// 
; 823  : 
; 824  : 	if (!STRHEAD::CheckSignature(Str) || STRHEAD::GetBufferSize(Str) == NewLength)
  00001	8b 5c 24 08	 mov	 ebx, DWORD PTR _Str$[esp]
  00005	8b 13		 mov	 edx, DWORD PTR [ebx]
  00007	52		 push	 edx
  00008	e8 00 00 00 00	 call	 ?CheckSignature@STRHEAD@@YA_NPAX@Z ; STRHEAD::CheckSignature
  0000d	59		 pop	 ecx
  0000e	84 c0		 test	 al, al
  00010	74 40		 je	 SHORT $LN2@StrSetLeng
  00012	8b 44 24 0c	 mov	 eax, DWORD PTR _NewLength$[esp]
  00016	39 42 f8	 cmp	 DWORD PTR [edx-8], eax
  00019	74 37		 je	 SHORT $LN2@StrSetLeng
  0001b	56		 push	 esi
  0001c	57		 push	 edi
; 825  : 		return;
; 826  : 
; 827  : 	PCHAR New = STR::Alloc(NewLength);
  0001d	50		 push	 eax
  0001e	e8 00 00 00 00	 call	 ?Alloc@STR@@YAPADK@Z	; STR::Alloc
  00023	8b f8		 mov	 edi, eax
; 828  : 	DWORD Size = STRHEAD::GetLength(Str);
  00025	8b 03		 mov	 eax, DWORD PTR [ebx]
  00027	8b 70 fc	 mov	 esi, DWORD PTR [eax-4]
  0002a	59		 pop	 ecx
; 829  : 	if (NewLength < Size)
  0002b	39 74 24 14	 cmp	 DWORD PTR _NewLength$[esp+8], esi
  0002f	73 04		 jae	 SHORT $LN1@StrSetLeng
; 830  : 		Size = NewLength;
  00031	8b 74 24 14	 mov	 esi, DWORD PTR _NewLength$[esp+8]
$LN1@StrSetLeng:
; 831  : 	m_memcpy(New, Str, Size);
  00035	56		 push	 esi
  00036	50		 push	 eax
  00037	57		 push	 edi
  00038	e8 00 00 00 00	 call	 ?m_memcpy@@YAPAXPAXPBXH@Z ; m_memcpy
; 832  : 	STRHEAD::SetLength(New, Size);
  0003d	89 77 fc	 mov	 DWORD PTR [edi-4], esi
  00040	c6 04 3e 00	 mov	 BYTE PTR [esi+edi], 0
; 833  : 	STR::Free(Str);
  00044	ff 33		 push	 DWORD PTR [ebx]
  00046	e8 00 00 00 00	 call	 ?Free@STR@@YAXPAD@Z	; STR::Free
  0004b	83 c4 10	 add	 esp, 16			; 00000010H
; 834  : 	Str = New;
  0004e	89 3b		 mov	 DWORD PTR [ebx], edi
  00050	5f		 pop	 edi
  00051	5e		 pop	 esi
$LN2@StrSetLeng:
  00052	5b		 pop	 ebx
; 835  : }
  00053	c3		 ret	 0
?StrSetLength@@YAXAAPADK@Z ENDP				; StrSetLength
_TEXT	ENDS
PUBLIC	?IsEmpty@STR@@YA_NQAD@Z				; STR::IsEmpty
; Function compile flags: /Ogspy
;	COMDAT ?IsEmpty@STR@@YA_NQAD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?IsEmpty@STR@@YA_NQAD@Z PROC				; STR::IsEmpty, COMDAT
; 840  : 	// 
; 841  : 	// 
; 842  : 	return (Str == NULL || *Str == 0);
  00000	8b 44 24 04	 mov	 eax, DWORD PTR _Str$[esp-4]
  00004	85 c0		 test	 eax, eax
  00006	74 08		 je	 SHORT $LN3@IsEmpty
  00008	80 38 00	 cmp	 BYTE PTR [eax], 0
  0000b	74 03		 je	 SHORT $LN3@IsEmpty
  0000d	33 c0		 xor	 eax, eax
; 843  : }
  0000f	c3		 ret	 0
$LN3@IsEmpty:
; 840  : 	// 
; 841  : 	// 
; 842  : 	return (Str == NULL || *Str == 0);
  00010	33 c0		 xor	 eax, eax
  00012	40		 inc	 eax
; 843  : }
  00013	c3		 ret	 0
?IsEmpty@STR@@YA_NQAD@Z ENDP				; STR::IsEmpty
_TEXT	ENDS
PUBLIC	?__LongToString@@YAXKPADAAH@Z			; __LongToString
; Function compile flags: /Ogspy
;	COMDAT ?__LongToString@@YAXKPADAAH@Z
_TEXT	SEGMENT
_num$ = 8						; size = 4
_Str$ = 12						; size = 4
_n$ = 16						; size = 4
?__LongToString@@YAXKPADAAH@Z PROC			; __LongToString, COMDAT
; 849  : 	// 
; 850  : 
; 851  : 	// 
; 852  : 	// 
; 853  : 	// 
; 854  : 	if (!n)
  00000	8b 4c 24 0c	 mov	 ecx, DWORD PTR _n$[esp-4]
  00004	53		 push	 ebx
  00005	56		 push	 esi
  00006	33 db		 xor	 ebx, ebx
  00008	57		 push	 edi
  00009	8b 7c 24 10	 mov	 edi, DWORD PTR _num$[esp+8]
  0000d	39 19		 cmp	 DWORD PTR [ecx], ebx
  0000f	75 23		 jne	 SHORT $LN16@LongToStri
; 855  : 	{
; 856  : 		if (!num)
  00011	3b fb		 cmp	 edi, ebx
  00013	75 08		 jne	 SHORT $LN9@LongToStri
; 857  : 			n = 1;
  00015	c7 01 01 00 00
	00		 mov	 DWORD PTR [ecx], 1
; 858  : 		else
  0001b	eb 17		 jmp	 SHORT $LN16@LongToStri
$LN9@LongToStri:
; 859  : 			for (int j = 1; num/j !=0; j *= 10) n++;
  0001d	33 f6		 xor	 esi, esi
  0001f	46		 inc	 esi
  00020	3b fb		 cmp	 edi, ebx
  00022	74 10		 je	 SHORT $LN16@LongToStri
$LL7@LongToStri:
  00024	6b f6 0a	 imul	 esi, 10			; 0000000aH
  00027	33 d2		 xor	 edx, edx
  00029	8b c7		 mov	 eax, edi
  0002b	f7 f6		 div	 esi
  0002d	43		 inc	 ebx
  0002e	85 c0		 test	 eax, eax
  00030	75 f2		 jne	 SHORT $LL7@LongToStri
  00032	89 19		 mov	 DWORD PTR [ecx], ebx
$LN16@LongToStri:
; 860  :     }
; 861  : 
; 862  :     // 
; 863  : 	if (!Str) return;
  00034	8b 74 24 14	 mov	 esi, DWORD PTR _Str$[esp+8]
  00038	85 f6		 test	 esi, esi
  0003a	74 1d		 je	 SHORT $LN1@LongToStri
; 864  : 
; 865  : 	// 
; 866  : 	int i = 1;
  0003c	33 db		 xor	 ebx, ebx
  0003e	43		 inc	 ebx
$LL3@LongToStri:
; 867  : 	int d = 0;
; 868  : 
; 869  : 	do
; 870  : 	{
; 871  : 		d = num % 10;
  0003f	8b c7		 mov	 eax, edi
  00041	33 d2		 xor	 edx, edx
  00043	6a 0a		 push	 10			; 0000000aH
  00045	5f		 pop	 edi
  00046	f7 f7		 div	 edi
; 872  : 		num /= 10;
  00048	8b f8		 mov	 edi, eax
; 873  : 		Str[n-i]=(char)(d+48);
  0004a	8b 01		 mov	 eax, DWORD PTR [ecx]
  0004c	80 c2 30	 add	 dl, 48			; 00000030H
  0004f	2b c3		 sub	 eax, ebx
; 874  : 		i++;
  00051	43		 inc	 ebx
  00052	88 14 30	 mov	 BYTE PTR [eax+esi], dl
; 875  : 	}
; 876  : 	while(num != 0);
  00055	85 ff		 test	 edi, edi
  00057	75 e6		 jne	 SHORT $LL3@LongToStri
$LN1@LongToStri:
  00059	5f		 pop	 edi
  0005a	5e		 pop	 esi
  0005b	5b		 pop	 ebx
; 877  : }
  0005c	c3		 ret	 0
?__LongToString@@YAXKPADAAH@Z ENDP			; __LongToString
_TEXT	ENDS
PUBLIC	?Copy@STR@@YAXPAD0KK@Z				; STR::Copy
; Function compile flags: /Ogspy
;	COMDAT ?Copy@STR@@YAXPAD0KK@Z
_TEXT	SEGMENT
_Source$ = 8						; size = 4
_Destination$ = 12					; size = 4
_Position$ = 16						; size = 4
_Count$ = 20						; size = 4
?Copy@STR@@YAXPAD0KK@Z PROC				; STR::Copy, COMDAT
; 975  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
; 976  : 	// 
 Position 
 Source Count 
; 977  : 	// 
 Destination
; 978  : 	if (Source == NULL || Destination == NULL)
  00003	8b 45 08	 mov	 eax, DWORD PTR _Source$[ebp]
  00006	85 c0		 test	 eax, eax
  00008	74 1a		 je	 SHORT $LN1@Copy
  0000a	83 7d 0c 00	 cmp	 DWORD PTR _Destination$[ebp], 0
  0000e	74 14		 je	 SHORT $LN1@Copy
; 979  : 		return;
; 980  : 	m_memcpy(Destination, Source + Position, Count);
  00010	8b 4d 10	 mov	 ecx, DWORD PTR _Position$[ebp]
  00013	ff 75 14	 push	 DWORD PTR _Count$[ebp]
  00016	03 c1		 add	 eax, ecx
  00018	50		 push	 eax
  00019	ff 75 0c	 push	 DWORD PTR _Destination$[ebp]
  0001c	e8 00 00 00 00	 call	 ?m_memcpy@@YAPAXPAXPBXH@Z ; m_memcpy
  00021	83 c4 0c	 add	 esp, 12			; 0000000cH
$LN1@Copy:
; 981  : }
  00024	5d		 pop	 ebp
  00025	c3		 ret	 0
?Copy@STR@@YAXPAD0KK@Z ENDP				; STR::Copy
_TEXT	ENDS
PUBLIC	?ScanEnd@STR@@YAPADPADD@Z			; STR::ScanEnd
; Function compile flags: /Ogspy
;	COMDAT ?ScanEnd@STR@@YAPADPADD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_C$ = 12						; size = 1
?ScanEnd@STR@@YAPADPADD@Z PROC				; STR::ScanEnd, COMDAT
; 1036 : 	// 
; 1037 : 	if (Str == NULL)
  00000	8b 4c 24 04	 mov	 ecx, DWORD PTR _Str$[esp-4]
; 1038 : 		return NULL;
  00004	33 c0		 xor	 eax, eax
  00006	85 c9		 test	 ecx, ecx
  00008	74 15		 je	 SHORT $LN6@ScanEnd
; 1039 : 
; 1040 : 	PCHAR Res = NULL;
; 1041 : 
; 1042 : 	for (PCHAR Tmp = Str; *Tmp != 0; Tmp++)
  0000a	8b d1		 mov	 edx, ecx
  0000c	8a 09		 mov	 cl, BYTE PTR [ecx]
  0000e	eb 0b		 jmp	 SHORT $LN10@ScanEnd
$LL4@ScanEnd:
; 1043 : 		if (*Tmp == C) Res = Tmp;
  00010	3a 4c 24 08	 cmp	 cl, BYTE PTR _C$[esp-4]
  00014	75 02		 jne	 SHORT $LN3@ScanEnd
  00016	8b c2		 mov	 eax, edx
$LN3@ScanEnd:
; 1039 : 
; 1040 : 	PCHAR Res = NULL;
; 1041 : 
; 1042 : 	for (PCHAR Tmp = Str; *Tmp != 0; Tmp++)
  00018	42		 inc	 edx
  00019	8a 0a		 mov	 cl, BYTE PTR [edx]
$LN10@ScanEnd:
  0001b	84 c9		 test	 cl, cl
  0001d	75 f1		 jne	 SHORT $LL4@ScanEnd
$LN6@ScanEnd:
; 1044 : 
; 1045 : 	return Res;
; 1046 : }
  0001f	c3		 ret	 0
?ScanEnd@STR@@YAPADPADD@Z ENDP				; STR::ScanEnd
_TEXT	ENDS
PUBLIC	?IsStrEnd@@YA_NPADKK@Z				; IsStrEnd
; Function compile flags: /Ogspy
;	COMDAT ?IsStrEnd@@YA_NPADKK@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_Len$ = 12						; size = 4
_Pos$ = 16						; size = 4
?IsStrEnd@@YA_NPADKK@Z PROC				; IsStrEnd, COMDAT
; 1057 : 	if (Len != 0)
  00000	8b 44 24 08	 mov	 eax, DWORD PTR _Len$[esp-4]
  00004	85 c0		 test	 eax, eax
  00006	74 08		 je	 SHORT $LN2@IsStrEnd
; 1058 : 		return Pos >= Len;
  00008	39 44 24 0c	 cmp	 DWORD PTR _Pos$[esp-4], eax
  0000c	1b c0		 sbb	 eax, eax
  0000e	40		 inc	 eax
; 1061 : }
  0000f	c3		 ret	 0
$LN2@IsStrEnd:
; 1059 : 	else
; 1060 :         return *Str == 0;
  00010	8b 4c 24 04	 mov	 ecx, DWORD PTR _Str$[esp-4]
  00014	33 c0		 xor	 eax, eax
  00016	38 01		 cmp	 BYTE PTR [ecx], al
  00018	0f 94 c0	 sete	 al
; 1061 : }
  0001b	c3		 ret	 0
?IsStrEnd@@YA_NPADKK@Z ENDP				; IsStrEnd
_TEXT	ENDS
PUBLIC	?StrToInt@@YAHPAD@Z				; StrToInt
; Function compile flags: /Ogspy
;	COMDAT ?StrToInt@@YAHPAD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?StrToInt@@YAHPAD@Z PROC				; StrToInt, COMDAT
; 1170 : 	return (int)m_atol(Str);
  00000	ff 74 24 04	 push	 DWORD PTR _Str$[esp-4]
  00004	e8 00 00 00 00	 call	 ?m_atol@@YGJPBD@Z	; m_atol
; 1171 : }
  00009	c3		 ret	 0
?StrToInt@@YAHPAD@Z ENDP				; StrToInt
_TEXT	ENDS
PUBLIC	?StrLowerCase@@YAXPAD@Z				; StrLowerCase
; Function compile flags: /Ogspy
;	COMDAT ?StrLowerCase@@YAXPAD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?StrLowerCase@@YAXPAD@Z PROC				; StrLowerCase, COMDAT
; 1176 : 	// 
; 1177 : 	if (Str == NULL)
  00000	8b 4c 24 04	 mov	 ecx, DWORD PTR _Str$[esp-4]
  00004	85 c9		 test	 ecx, ecx
  00006	74 16		 je	 SHORT $LN2@StrLowerCa
  00008	eb 0f		 jmp	 SHORT $LN9@StrLowerCa
$LL3@StrLowerCa:
; 1183 : 	{
; 1184 :         if ((*Pos >= 'A')  &&  (*Pos <= 'Z'))
  0000a	8a 01		 mov	 al, BYTE PTR [ecx]
  0000c	3c 41		 cmp	 al, 65			; 00000041H
  0000e	7c 08		 jl	 SHORT $LN1@StrLowerCa
  00010	3c 5a		 cmp	 al, 90			; 0000005aH
  00012	7f 04		 jg	 SHORT $LN1@StrLowerCa
; 1185 : 			*Pos = *Pos + ('a'-'A');
  00014	04 20		 add	 al, 32			; 00000020H
  00016	88 01		 mov	 BYTE PTR [ecx], al
$LN1@StrLowerCa:
; 1186 : 		Pos++;
  00018	41		 inc	 ecx
$LN9@StrLowerCa:
; 1178 : 		return;
; 1179 : 
; 1180 : 	PCHAR Pos = Str;
; 1181 : 
; 1182 : 	while (*Pos != 0)
  00019	80 39 00	 cmp	 BYTE PTR [ecx], 0
  0001c	75 ec		 jne	 SHORT $LL3@StrLowerCa
$LN2@StrLowerCa:
; 1187 :     }
; 1188 : }
  0001e	c3		 ret	 0
?StrLowerCase@@YAXPAD@Z ENDP				; StrLowerCase
_TEXT	ENDS
PUBLIC	?StrSame@@YA_NPAD0_NK@Z				; StrSame
; Function compile flags: /Ogspy
;	COMDAT ?StrSame@@YA_NPAD0_NK@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_ToSame$ = 12						; size = 4
_CaseSensetive$ = 16					; size = 1
_StrEndPosition$ = 20					; size = 4
?StrSame@@YA_NPAD0_NK@Z PROC				; StrSame, COMDAT
; 1212 : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
; 1213 : 	// 
 ToSame.
; 1214 : 	// CaseSensetive 
; 1215 : 	// 
 StrEndPosrition 
; 1216 : 	// 
 StrEndPosrition 
; 1217 : 
; 1218 : 	if (Str == NULL || ToSame == NULL)
  00003	8b 45 08	 mov	 eax, DWORD PTR _Str$[ebp]
  00006	53		 push	 ebx
  00007	33 db		 xor	 ebx, ebx
  00009	56		 push	 esi
  0000a	57		 push	 edi
  0000b	3b c3		 cmp	 eax, ebx
  0000d	74 64		 je	 SHORT $LN8@StrSame
  0000f	8b 75 0c	 mov	 esi, DWORD PTR _ToSame$[ebp]
  00012	3b f3		 cmp	 esi, ebx
  00014	74 5d		 je	 SHORT $LN8@StrSame
; 1220 : 
; 1221 :     DWORD Pos = 1;
  00016	33 ff		 xor	 edi, edi
  00018	47		 inc	 edi
  00019	eb 3a		 jmp	 SHORT $LN20@StrSame
$LL7@StrSame:
; 1222 : 	PCHAR S1 = Str;
; 1223 : 	PCHAR S2 = ToSame;
; 1224 : 
; 1225 : 	char C1;
; 1226 : 	char C2;
; 1227 : 
; 1228 : 	while (*S1 != 0 && S2 != 0)
  0001b	3b f3		 cmp	 esi, ebx
  0001d	74 3a		 je	 SHORT $LN6@StrSame
; 1229 : 	{
; 1230 : 		C1 = *S1;
  0001f	8a 10		 mov	 dl, BYTE PTR [eax]
; 1231 : 		C2 = *S2;
  00021	8a 0e		 mov	 cl, BYTE PTR [esi]
; 1232 : 
; 1233 : 		if (!CaseSensetive)
  00023	38 5d 10	 cmp	 BYTE PTR _CaseSensetive$[ebp], bl
  00026	75 1c		 jne	 SHORT $LN3@StrSame
; 1234 : 		{
; 1235 : 			LowerChar(C1);
  00028	8a da		 mov	 bl, dl
  0002a	80 eb 41	 sub	 bl, 65			; 00000041H
  0002d	80 fb 19	 cmp	 bl, 25			; 00000019H
  00030	77 03		 ja	 SHORT $LN4@StrSame
  00032	80 c2 20	 add	 dl, 32			; 00000020H
$LN4@StrSame:
; 1236 : 			LowerChar(C2);
  00035	8a d9		 mov	 bl, cl
  00037	80 eb 41	 sub	 bl, 65			; 00000041H
  0003a	80 fb 19	 cmp	 bl, 25			; 00000019H
  0003d	77 03		 ja	 SHORT $LN18@StrSame
  0003f	80 c1 20	 add	 cl, 32			; 00000020H
$LN18@StrSame:
  00042	33 db		 xor	 ebx, ebx
$LN3@StrSame:
; 1237 : 		}
; 1238 : 
; 1239 : 		if (C1 != C2) return false;
  00044	3a d1		 cmp	 dl, cl
  00046	75 2b		 jne	 SHORT $LN8@StrSame
; 1240 : 
; 1241 : 		S1++;
  00048	40		 inc	 eax
; 1242 : 		S2++;
  00049	46		 inc	 esi
; 1243 : 		if (StrEndPosition != 0 && Pos >= StrEndPosition)
  0004a	39 5d 14	 cmp	 DWORD PTR _StrEndPosition$[ebp], ebx
  0004d	74 05		 je	 SHORT $LN1@StrSame
  0004f	3b 7d 14	 cmp	 edi, DWORD PTR _StrEndPosition$[ebp]
  00052	73 12		 jae	 SHORT $LN16@StrSame
$LN1@StrSame:
; 1245 : 		Pos++;
  00054	47		 inc	 edi
$LN20@StrSame:
; 1222 : 	PCHAR S1 = Str;
; 1223 : 	PCHAR S2 = ToSame;
; 1224 : 
; 1225 : 	char C1;
; 1226 : 	char C2;
; 1227 : 
; 1228 : 	while (*S1 != 0 && S2 != 0)
  00055	38 18		 cmp	 BYTE PTR [eax], bl
  00057	75 c2		 jne	 SHORT $LL7@StrSame
$LN6@StrSame:
; 1246 : 	}
; 1247 :     return *S1 == 0 && *S2 == 0;
  00059	38 18		 cmp	 BYTE PTR [eax], bl
  0005b	75 12		 jne	 SHORT $LN12@StrSame
  0005d	38 1e		 cmp	 BYTE PTR [esi], bl
  0005f	75 0e		 jne	 SHORT $LN12@StrSame
  00061	33 c0		 xor	 eax, eax
  00063	40		 inc	 eax
  00064	eb 0f		 jmp	 SHORT $LN10@StrSame
$LN16@StrSame:
; 1244 : 			return *S2 == 0;
  00066	33 c0		 xor	 eax, eax
  00068	38 1e		 cmp	 BYTE PTR [esi], bl
  0006a	0f 94 c0	 sete	 al
  0006d	eb 06		 jmp	 SHORT $LN10@StrSame
$LN12@StrSame:
; 1246 : 	}
; 1247 :     return *S1 == 0 && *S2 == 0;
  0006f	33 c0		 xor	 eax, eax
  00071	eb 02		 jmp	 SHORT $LN10@StrSame
$LN8@StrSame:
; 1219 : 		return false;
  00073	32 c0		 xor	 al, al
$LN10@StrSame:
  00075	5f		 pop	 edi
  00076	5e		 pop	 esi
  00077	5b		 pop	 ebx
; 1248 : }
  00078	5d		 pop	 ebp
  00079	c3		 ret	 0
?StrSame@@YA_NPAD0_NK@Z ENDP				; StrSame
_TEXT	ENDS
PUBLIC	?IgnoreSpaces@STR@@YAPADQAD@Z			; STR::IgnoreSpaces
; Function compile flags: /Ogspy
;	COMDAT ?IgnoreSpaces@STR@@YAPADQAD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?IgnoreSpaces@STR@@YAPADQAD@Z PROC			; STR::IgnoreSpaces, COMDAT
; 1253 : 	// 
; 1254 : 	// 
; 1255 : 	PCHAR S = (PCHAR) Str;
  00000	8b 44 24 04	 mov	 eax, DWORD PTR _Str$[esp-4]
; 1256 : 	while ((*S != 0) && (*S == ' ' || *S == 9)) S++;
  00004	eb 0b		 jmp	 SHORT $LN9@IgnoreSpac
$LL3@IgnoreSpac:
  00006	80 f9 20	 cmp	 cl, 32			; 00000020H
  00009	74 05		 je	 SHORT $LN1@IgnoreSpac
  0000b	80 f9 09	 cmp	 cl, 9
  0000e	75 07		 jne	 SHORT $LN2@IgnoreSpac
$LN1@IgnoreSpac:
  00010	40		 inc	 eax
$LN9@IgnoreSpac:
  00011	8a 08		 mov	 cl, BYTE PTR [eax]
  00013	84 c9		 test	 cl, cl
  00015	75 ef		 jne	 SHORT $LL3@IgnoreSpac
$LN2@IgnoreSpac:
; 1257 : 	return S;
; 1258 : }
  00017	c3		 ret	 0
?IgnoreSpaces@STR@@YAPADQAD@Z ENDP			; STR::IgnoreSpaces
_TEXT	ENDS
PUBLIC	?GotoNextLine@STR@@YAPADPADK@Z			; STR::GotoNextLine
; Function compile flags: /Ogspy
;	COMDAT ?GotoNextLine@STR@@YAPADPADK@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_StrSize$ = 12						; size = 4
?GotoNextLine@STR@@YAPADPADK@Z PROC			; STR::GotoNextLine, COMDAT
; 1298 : {
  00000	56		 push	 esi
; 1299 : 	// 
; 1300 : 	// 
; 1301 : 	if (Str == NULL)
  00001	8b 74 24 08	 mov	 esi, DWORD PTR _Str$[esp]
  00005	57		 push	 edi
  00006	33 ff		 xor	 edi, edi
  00008	3b f7		 cmp	 esi, edi
  0000a	75 04		 jne	 SHORT $LN8@GotoNextLi
; 1302 : 		return NULL;
  0000c	33 c0		 xor	 eax, eax
  0000e	eb 42		 jmp	 SHORT $LN9@GotoNextLi
$LN8@GotoNextLi:
  00010	53		 push	 ebx
; 1303 : 	DWORD Pos;
; 1304 : 	PCHAR Tmp = Str;
; 1305 : 
; 1306 : 	for (Pos = 0; !IsStrEnd(Tmp, StrSize, Pos) && *Tmp != 10 && *Tmp != 13; Pos++, Tmp++);
  00011	8b 5c 24 14	 mov	 ebx, DWORD PTR _StrSize$[esp+8]
  00015	eb 0c		 jmp	 SHORT $LN16@GotoNextLi
$LL7@GotoNextLi:
  00017	8a 06		 mov	 al, BYTE PTR [esi]
  00019	3c 0a		 cmp	 al, 10			; 0000000aH
  0001b	74 23		 je	 SHORT $LN5@GotoNextLi
  0001d	3c 0d		 cmp	 al, 13			; 0000000dH
  0001f	74 1f		 je	 SHORT $LN5@GotoNextLi
  00021	47		 inc	 edi
  00022	46		 inc	 esi
$LN16@GotoNextLi:
  00023	57		 push	 edi
  00024	53		 push	 ebx
  00025	56		 push	 esi
  00026	e8 00 00 00 00	 call	 ?IsStrEnd@@YA_NPADKK@Z	; IsStrEnd
  0002b	83 c4 0c	 add	 esp, 12			; 0000000cH
  0002e	84 c0		 test	 al, al
  00030	74 e5		 je	 SHORT $LL7@GotoNextLi
; 1307 : 
; 1308 : 	for (; !IsStrEnd(Tmp, StrSize, Pos) && (*Tmp == 10 || *Tmp == 13); Pos++, Tmp++);
  00032	eb 0c		 jmp	 SHORT $LN5@GotoNextLi
$LL4@GotoNextLi:
  00034	8a 06		 mov	 al, BYTE PTR [esi]
  00036	3c 0a		 cmp	 al, 10			; 0000000aH
  00038	74 04		 je	 SHORT $LN3@GotoNextLi
  0003a	3c 0d		 cmp	 al, 13			; 0000000dH
  0003c	75 11		 jne	 SHORT $LN2@GotoNextLi
$LN3@GotoNextLi:
  0003e	47		 inc	 edi
  0003f	46		 inc	 esi
$LN5@GotoNextLi:
  00040	57		 push	 edi
  00041	53		 push	 ebx
  00042	56		 push	 esi
  00043	e8 00 00 00 00	 call	 ?IsStrEnd@@YA_NPADKK@Z	; IsStrEnd
  00048	83 c4 0c	 add	 esp, 12			; 0000000cH
  0004b	84 c0		 test	 al, al
  0004d	74 e5		 je	 SHORT $LL4@GotoNextLi
$LN2@GotoNextLi:
; 1309 : 
; 1310 : 	return Tmp;
  0004f	8b c6		 mov	 eax, esi
  00051	5b		 pop	 ebx
$LN9@GotoNextLi:
  00052	5f		 pop	 edi
  00053	5e		 pop	 esi
; 1311 : }
  00054	c3		 ret	 0
?GotoNextLine@STR@@YAPADPADK@Z ENDP			; STR::GotoNextLine
_TEXT	ENDS
PUBLIC	?HexToDWORD@STR@@YAKPAD@Z			; STR::HexToDWORD
; Function compile flags: /Ogspy
;	COMDAT ?HexToDWORD@STR@@YAKPAD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?HexToDWORD@STR@@YAKPAD@Z PROC				; STR::HexToDWORD, COMDAT
; 1316 : 	if (STR::IsEmpty(Str))
  00000	8b 54 24 04	 mov	 edx, DWORD PTR _Str$[esp-4]
  00004	52		 push	 edx
  00005	e8 00 00 00 00	 call	 ?IsEmpty@STR@@YA_NQAD@Z	; STR::IsEmpty
  0000a	83 c4 04	 add	 esp, 4
  0000d	84 c0		 test	 al, al
  0000f	74 03		 je	 SHORT $LN10@HexToDWORD
; 1317 : 		return 0;
  00011	33 c0		 xor	 eax, eax
; 1344 : }
  00013	c3		 ret	 0
$LN10@HexToDWORD:
  00014	56		 push	 esi
; 1318 : 
; 1319 : 	DWORD v = 0;
  00015	33 f6		 xor	 esi, esi
; 1320 : 	if(Str[0] == '0' && Str[1] == 'x') Str += 2;
  00017	80 3a 30	 cmp	 BYTE PTR [edx], 48	; 00000030H
  0001a	75 08		 jne	 SHORT $LL8@HexToDWORD
  0001c	80 7a 01 78	 cmp	 BYTE PTR [edx+1], 120	; 00000078H
  00020	75 02		 jne	 SHORT $LL8@HexToDWORD
  00022	42		 inc	 edx
  00023	42		 inc	 edx
$LL8@HexToDWORD:
; 1321 : 	for(;;)
; 1322 : 	{
; 1323 : 		char c = *Str;
  00024	8a 0a		 mov	 cl, BYTE PTR [edx]
; 1324 : 		if(c >= '0' && c <= '9')
  00026	8a c1		 mov	 al, cl
  00028	2c 30		 sub	 al, 48			; 00000030H
  0002a	3c 09		 cmp	 al, 9
  0002c	77 0c		 ja	 SHORT $LN6@HexToDWORD
; 1325 : 		{
; 1326 : 		  v *= 16;
; 1327 : 		  v += c - '0';
  0002e	0f be c1	 movsx	 eax, cl
  00031	c1 e6 04	 shl	 esi, 4
  00034	8d 74 06 d0	 lea	 esi, DWORD PTR [esi+eax-48]
; 1328 : 		}
; 1329 : 		else
  00038	eb 26		 jmp	 SHORT $LN1@HexToDWORD
$LN6@HexToDWORD:
; 1330 : 		if(c >= 'A' && c <= 'F')
  0003a	8a c1		 mov	 al, cl
  0003c	2c 41		 sub	 al, 65			; 00000041H
  0003e	3c 05		 cmp	 al, 5
  00040	77 0c		 ja	 SHORT $LN4@HexToDWORD
; 1331 : 		{
; 1332 : 		  v *= 16;
; 1333 : 		  v += c - 'A' + 0xA;
  00042	0f be c1	 movsx	 eax, cl
  00045	c1 e6 04	 shl	 esi, 4
  00048	8d 74 06 c9	 lea	 esi, DWORD PTR [esi+eax-55]
  0004c	eb 12		 jmp	 SHORT $LN1@HexToDWORD
$LN4@HexToDWORD:
; 1334 : 		}
; 1335 : 		else if(c >= 'a' && c <= 'f')\
  0004e	8a c1		 mov	 al, cl
  00050	2c 61		 sub	 al, 97			; 00000061H
  00052	3c 05		 cmp	 al, 5
  00054	77 0d		 ja	 SHORT $LN2@HexToDWORD
; 1336 : 		{
; 1337 : 		  v *= 16;
; 1338 : 		  v += c - 'a' + 0xA;
  00056	0f be c1	 movsx	 eax, cl
  00059	c1 e6 04	 shl	 esi, 4
  0005c	8d 74 06 a9	 lea	 esi, DWORD PTR [esi+eax-87]
$LN1@HexToDWORD:
; 1339 : 		}
; 1340 : 		else break;
; 1341 : 		Str++;
  00060	42		 inc	 edx
; 1342 : 	}
  00061	eb c1		 jmp	 SHORT $LL8@HexToDWORD
$LN2@HexToDWORD:
; 1343 : 	return v;
  00063	8b c6		 mov	 eax, esi
  00065	5e		 pop	 esi
; 1344 : }
  00066	c3		 ret	 0
?HexToDWORD@STR@@YAKPAD@Z ENDP				; STR::HexToDWORD
_TEXT	ENDS
PUBLIC	?ToDWORD@STR@@YAKPBD@Z				; STR::ToDWORD
; Function compile flags: /Ogspy
;	COMDAT ?ToDWORD@STR@@YAKPBD@Z
_TEXT	SEGMENT
_s$ = 8							; size = 4
?ToDWORD@STR@@YAKPBD@Z PROC				; STR::ToDWORD, COMDAT
; 1347 : {
  00000	56		 push	 esi
; 1348 : 	DWORD d = 0;
; 1349 : 	if( !STR::IsEmpty( (PCHAR)s ) )
  00001	ff 74 24 08	 push	 DWORD PTR _s$[esp]
  00005	33 f6		 xor	 esi, esi
  00007	e8 00 00 00 00	 call	 ?IsEmpty@STR@@YA_NQAD@Z	; STR::IsEmpty
  0000c	83 c4 04	 add	 esp, 4
  0000f	84 c0		 test	 al, al
  00011	75 27		 jne	 SHORT $LN9@ToDWORD
; 1350 : 	{
; 1351 : 		s = STR::IgnoreSpaces( (PCHAR)s );
  00013	ff 74 24 08	 push	 DWORD PTR _s$[esp]
  00017	e8 00 00 00 00	 call	 ?IgnoreSpaces@STR@@YAPADQAD@Z ; STR::IgnoreSpaces
  0001c	59		 pop	 ecx
; 1352 : 		for(; *s != 0 && m_isdigit(*s); s++ )
  0001d	eb 15		 jmp	 SHORT $LN15@ToDWORD
$LL3@ToDWORD:
  0001f	8a d1		 mov	 dl, cl
  00021	80 ea 30	 sub	 dl, 48			; 00000030H
  00024	80 fa 09	 cmp	 dl, 9
  00027	77 11		 ja	 SHORT $LN9@ToDWORD
; 1353 : 		{
; 1354 : 			d *= 10;
  00029	6b f6 0a	 imul	 esi, 10			; 0000000aH
; 1355 : 			d += *s - '0';
  0002c	0f be c9	 movsx	 ecx, cl
  0002f	8d 74 0e d0	 lea	 esi, DWORD PTR [esi+ecx-48]
  00033	40		 inc	 eax
$LN15@ToDWORD:
  00034	8a 08		 mov	 cl, BYTE PTR [eax]
  00036	84 c9		 test	 cl, cl
  00038	75 e5		 jne	 SHORT $LL3@ToDWORD
; 1352 : 		for(; *s != 0 && m_isdigit(*s); s++ )
$LN9@ToDWORD:
; 1356 : 		}
; 1357 : 	}
; 1358 : 	return d;
  0003a	8b c6		 mov	 eax, esi
  0003c	5e		 pop	 esi
; 1359 : }
  0003d	c3		 ret	 0
?ToDWORD@STR@@YAKPBD@Z ENDP				; STR::ToDWORD
_TEXT	ENDS
PUBLIC	?IsLinuxStr@STR@@YA_NPAD@Z			; STR::IsLinuxStr
; Function compile flags: /Ogspy
;	COMDAT ?IsLinuxStr@STR@@YA_NPAD@Z
_TEXT	SEGMENT
_S$ = 8							; size = 4
?IsLinuxStr@STR@@YA_NPAD@Z PROC				; STR::IsLinuxStr, COMDAT
; 1428 : 	// 
; 1429 : 	// 
; 1430 : 
; 1431 : 	if (STR::IsEmpty(S))
  00000	8b 4c 24 04	 mov	 ecx, DWORD PTR _S$[esp-4]
  00004	51		 push	 ecx
  00005	e8 00 00 00 00	 call	 ?IsEmpty@STR@@YA_NQAD@Z	; STR::IsEmpty
  0000a	83 c4 04	 add	 esp, 4
  0000d	84 c0		 test	 al, al
  0000f	74 03		 je	 SHORT $LN8@IsLinuxStr
; 1432 :     	return false;
  00011	32 c0		 xor	 al, al
; 1458 : }
  00013	c3		 ret	 0
$LN8@IsLinuxStr:
; 1433 : 
; 1434 : 	BYTE Result = true;
; 1435 : 
; 1436 : 	// 
; 1437 :     BYTE Count = 0;
; 1438 : 	for (; *S != 0; S++)
  00014	8a 01		 mov	 al, BYTE PTR [ecx]
  00016	32 d2		 xor	 dl, dl
  00018	84 c0		 test	 al, al
  0001a	74 20		 je	 SHORT $LN11@IsLinuxStr
$LL7@IsLinuxStr:
; 1439 : 	{
; 1440 : 
; 1441 : 		if (*S == '\n')
  0001c	3c 0a		 cmp	 al, 10			; 0000000aH
  0001e	75 09		 jne	 SHORT $LN4@IsLinuxStr
; 1442 : 		{
; 1443 : 			// 
; 1444 : 			// 3 
; 1445 : 			Count++;
  00020	fe c2		 inc	 dl
; 1446 : 			if (Count >= 3)
  00022	80 fa 03	 cmp	 dl, 3
  00025	73 0d		 jae	 SHORT $LN17@IsLinuxStr
; 1447 : 				break;
; 1448 : 		}
; 1449 : 		else
  00027	eb 04		 jmp	 SHORT $LN6@IsLinuxStr
$LN4@IsLinuxStr:
; 1450 : 		if (*S == '\r')
  00029	3c 0d		 cmp	 al, 13			; 0000000dH
  0002b	74 0f		 je	 SHORT $LN11@IsLinuxStr
$LN6@IsLinuxStr:
; 1433 : 
; 1434 : 	BYTE Result = true;
; 1435 : 
; 1436 : 	// 
; 1437 :     BYTE Count = 0;
; 1438 : 	for (; *S != 0; S++)
  0002d	41		 inc	 ecx
  0002e	8a 01		 mov	 al, BYTE PTR [ecx]
  00030	84 c0		 test	 al, al
  00032	75 e8		 jne	 SHORT $LL7@IsLinuxStr
$LN17@IsLinuxStr:
; 1451 : 		{
; 1452 : 			Result = false;
; 1453 : 			break;
; 1454 : 		}
; 1455 : 	}
; 1456 : 
; 1457 : 	return Result && Count > 0;
  00034	84 d2		 test	 dl, dl
  00036	76 04		 jbe	 SHORT $LN11@IsLinuxStr
  00038	33 c0		 xor	 eax, eax
  0003a	40		 inc	 eax
; 1458 : }
  0003b	c3		 ret	 0
$LN11@IsLinuxStr:
; 1451 : 		{
; 1452 : 			Result = false;
; 1453 : 			break;
; 1454 : 		}
; 1455 : 	}
; 1456 : 
; 1457 : 	return Result && Count > 0;
  0003c	33 c0		 xor	 eax, eax
; 1458 : }
  0003e	c3		 ret	 0
?IsLinuxStr@STR@@YA_NPAD@Z ENDP				; STR::IsLinuxStr
_TEXT	ENDS
PUBLIC	?Alloc@WSTR@@YAPA_WK@Z				; WSTR::Alloc
; Function compile flags: /Ogspy
;	COMDAT ?Alloc@WSTR@@YAPA_WK@Z
_TEXT	SEGMENT
_StrLen$ = 8						; size = 4
?Alloc@WSTR@@YAPA_WK@Z PROC				; WSTR::Alloc, COMDAT
; 1493 : {
  00000	56		 push	 esi
; 1494 : 	if (StrLen == 0) return NULL;
  00001	8b 74 24 08	 mov	 esi, DWORD PTR _StrLen$[esp]
  00005	85 f6		 test	 esi, esi
  00007	75 04		 jne	 SHORT $LN2@Alloc@2
$LN5@Alloc@2:
  00009	33 c0		 xor	 eax, eax
  0000b	5e		 pop	 esi
; 1500 : }
  0000c	c3		 ret	 0
$LN2@Alloc@2:
; 1495 : 
; 1496 : 	PWCHAR Str = (PWCHAR)HEAP::Alloc(StrLen*sizeof(WCHAR) + STRHEAD::HeadSize + sizeof(WCHAR));
  0000d	8d 44 36 0e	 lea	 eax, DWORD PTR [esi+esi+14]
  00011	50		 push	 eax
  00012	e8 00 00 00 00	 call	 ?Alloc@HEAP@@YAPAXK@Z	; HEAP::Alloc
  00017	59		 pop	 ecx
; 1497 : 	if (Str == NULL) return NULL;
  00018	85 c0		 test	 eax, eax
  0001a	74 ed		 je	 SHORT $LN5@Alloc@2
; 1498 : 
; 1499 : 	return (PWCHAR)STRHEAD::MakeHead((LPBYTE)Str, StrLen, StrLen, sizeof(WCHAR));
  0001c	6a 02		 push	 2
  0001e	56		 push	 esi
  0001f	56		 push	 esi
  00020	50		 push	 eax
  00021	e8 00 00 00 00	 call	 ?MakeHead@STRHEAD@@YAPAEPAEKKE@Z ; STRHEAD::MakeHead
  00026	83 c4 10	 add	 esp, 16			; 00000010H
  00029	5e		 pop	 esi
; 1500 : }
  0002a	c3		 ret	 0
?Alloc@WSTR@@YAPA_WK@Z ENDP				; WSTR::Alloc
_TEXT	ENDS
PUBLIC	?Free@WSTR@@YAXPA_W@Z				; WSTR::Free
; Function compile flags: /Ogspy
;	COMDAT ?Free@WSTR@@YAXPA_W@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?Free@WSTR@@YAXPA_W@Z PROC				; WSTR::Free, COMDAT
; 1526 : 	// 
; 1527 : 	// 
 Alloc 
; 1528 : 	if (STRHEAD::CheckSignature(Str))
  00000	8b 54 24 04	 mov	 edx, DWORD PTR _Str$[esp-4]
  00004	52		 push	 edx
  00005	e8 00 00 00 00	 call	 ?CheckSignature@STRHEAD@@YA_NPAX@Z ; STRHEAD::CheckSignature
  0000a	59		 pop	 ecx
  0000b	84 c0		 test	 al, al
  0000d	74 0a		 je	 SHORT $LN1@Free@2
; 1529 : 		HEAP::Free((LPBYTE)Str - STRHEAD::HeadSize);
  0000f	83 c2 f4	 add	 edx, -12		; fffffff4H
  00012	52		 push	 edx
  00013	e8 00 00 00 00	 call	 ?Free@HEAP@@YAXPAX@Z	; HEAP::Free
  00018	59		 pop	 ecx
$LN1@Free@2:
; 1530 : }
  00019	c3		 ret	 0
?Free@WSTR@@YAXPA_W@Z ENDP				; WSTR::Free
_TEXT	ENDS
PUBLIC	?CalcLength@WSTR@@YAKPA_W@Z			; WSTR::CalcLength
; Function compile flags: /Ogspy
;	COMDAT ?CalcLength@WSTR@@YAKPA_W@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?CalcLength@WSTR@@YAKPA_W@Z PROC			; WSTR::CalcLength, COMDAT
; 1536 : 	// 
; 1537 : 	if (Str == NULL) return 0;
  00000	8b 4c 24 04	 mov	 ecx, DWORD PTR _Str$[esp-4]
  00004	33 c0		 xor	 eax, eax
  00006	85 c9		 test	 ecx, ecx
  00008	74 0e		 je	 SHORT $LN5@CalcLength
; 1538 : 
; 1539 : 	/* TODO :
; 1540 : 	
 PWCHAR*/
; 1541 : 
; 1542 :     DWORD Len = 0;
; 1543 : 	for (PWCHAR Tmp = Str; *Tmp != 0; Tmp++) Len++;
  0000a	66 39 01	 cmp	 WORD PTR [ecx], ax
  0000d	74 09		 je	 SHORT $LN5@CalcLength
$LL3@CalcLength:
  0000f	40		 inc	 eax
  00010	41		 inc	 ecx
  00011	41		 inc	 ecx
  00012	66 83 39 00	 cmp	 WORD PTR [ecx], 0
  00016	75 f7		 jne	 SHORT $LL3@CalcLength
$LN5@CalcLength:
; 1544 : 
; 1545 : 	return Len;
; 1546 : }
  00018	c3		 ret	 0
?CalcLength@WSTR@@YAKPA_W@Z ENDP			; WSTR::CalcLength
_TEXT	ENDS
PUBLIC	?IsEmpty@WSTR@@YA_NPA_W@Z			; WSTR::IsEmpty
; Function compile flags: /Ogspy
;	COMDAT ?IsEmpty@WSTR@@YA_NPA_W@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?IsEmpty@WSTR@@YA_NPA_W@Z PROC				; WSTR::IsEmpty, COMDAT
; 1551 : 	// 
; 1552 : 	return Str == NULL || *Str == 0;
  00000	8b 44 24 04	 mov	 eax, DWORD PTR _Str$[esp-4]
  00004	85 c0		 test	 eax, eax
  00006	74 09		 je	 SHORT $LN3@IsEmpty@2
  00008	66 83 38 00	 cmp	 WORD PTR [eax], 0
  0000c	74 03		 je	 SHORT $LN3@IsEmpty@2
  0000e	33 c0		 xor	 eax, eax
; 1553 : }
  00010	c3		 ret	 0
$LN3@IsEmpty@2:
; 1551 : 	// 
; 1552 : 	return Str == NULL || *Str == 0;
  00011	33 c0		 xor	 eax, eax
  00013	40		 inc	 eax
; 1553 : }
  00014	c3		 ret	 0
?IsEmpty@WSTR@@YA_NPA_W@Z ENDP				; WSTR::IsEmpty
_TEXT	ENDS
PUBLIC	?End@WSTR@@YAPA_WPA_W@Z				; WSTR::End
; Function compile flags: /Ogspy
;	COMDAT ?End@WSTR@@YAPA_WPA_W@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?End@WSTR@@YAPA_WPA_W@Z PROC				; WSTR::End, COMDAT
; 1577 : 	// 
; 1578 : 	if (Str != NULL)
  00000	8b 44 24 04	 mov	 eax, DWORD PTR _Str$[esp-4]
  00004	85 c0		 test	 eax, eax
  00006	74 0a		 je	 SHORT $LN1@End
  00008	eb 02		 jmp	 SHORT $LN9@End
$LL3@End:
; 1579 : 		for (; *Str != 0; Str++);
  0000a	40		 inc	 eax
  0000b	40		 inc	 eax
$LN9@End:
  0000c	66 83 38 00	 cmp	 WORD PTR [eax], 0
  00010	75 f8		 jne	 SHORT $LL3@End
$LN1@End:
; 1580 :     return Str;
; 1581 : }
  00012	c3		 ret	 0
?End@WSTR@@YAPA_WPA_W@Z ENDP				; WSTR::End
_TEXT	ENDS
PUBLIC	?ScanEnd@WSTR@@YAPA_WPA_W_W@Z			; WSTR::ScanEnd
; Function compile flags: /Ogspy
;	COMDAT ?ScanEnd@WSTR@@YAPA_WPA_W_W@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_C$ = 12						; size = 2
?ScanEnd@WSTR@@YAPA_WPA_W_W@Z PROC			; WSTR::ScanEnd, COMDAT
; 1587 : 	// 
; 1588 : 	if (Str == NULL) return NULL;
  00000	8b 4c 24 04	 mov	 ecx, DWORD PTR _Str$[esp-4]
  00004	33 c0		 xor	 eax, eax
  00006	85 c9		 test	 ecx, ecx
  00008	74 20		 je	 SHORT $LN6@ScanEnd@2
; 1589 : 
; 1590 : 	PWCHAR Res = NULL;
; 1591 : 
; 1592 : 	for (PWCHAR Tmp = Str; *Tmp != 0; Tmp++)
  0000a	8b d1		 mov	 edx, ecx
  0000c	0f b7 09	 movzx	 ecx, WORD PTR [ecx]
  0000f	66 85 c9	 test	 cx, cx
  00012	74 16		 je	 SHORT $LN6@ScanEnd@2
  00014	0f b7 c9	 movzx	 ecx, cx
$LL4@ScanEnd@2:
; 1593 : 		if (*Tmp == C) Res = Tmp;
  00017	66 3b 4c 24 08	 cmp	 cx, WORD PTR _C$[esp-4]
  0001c	75 02		 jne	 SHORT $LN3@ScanEnd@2
  0001e	8b c2		 mov	 eax, edx
$LN3@ScanEnd@2:
; 1589 : 
; 1590 : 	PWCHAR Res = NULL;
; 1591 : 
; 1592 : 	for (PWCHAR Tmp = Str; *Tmp != 0; Tmp++)
  00020	42		 inc	 edx
  00021	42		 inc	 edx
  00022	0f b7 0a	 movzx	 ecx, WORD PTR [edx]
  00025	66 85 c9	 test	 cx, cx
  00028	75 ed		 jne	 SHORT $LL4@ScanEnd@2
$LN6@ScanEnd@2:
; 1594 : 
; 1595 : 	return Res;
; 1596 : }
  0002a	c3		 ret	 0
?ScanEnd@WSTR@@YAPA_WPA_W_W@Z ENDP			; WSTR::ScanEnd
_TEXT	ENDS
PUBLIC	?DecryptStr@@YGPADPAD0@Z			; DecryptStr
; Function compile flags: /Ogspy
;	COMDAT ?DecryptStr@@YGPADPAD0@Z
_TEXT	SEGMENT
_String$ = 8						; size = 4
_OutString$ = 12					; size = 4
?DecryptStr@@YGPADPAD0@Z PROC				; DecryptStr, COMDAT
; 1657 : 	if (!String) return NULL;
  00000	33 d2		 xor	 edx, edx
  00002	39 54 24 04	 cmp	 DWORD PTR _String$[esp-4], edx
  00006	75 04		 jne	 SHORT $LN4@DecryptStr
  00008	33 c0		 xor	 eax, eax
  0000a	eb 26		 jmp	 SHORT $LN5@DecryptStr
$LN4@DecryptStr:
; 1658 : 	PCHAR Res = (OutString) ? OutString : String;
  0000c	8b 44 24 08	 mov	 eax, DWORD PTR _OutString$[esp-4]
  00010	3b c2		 cmp	 eax, edx
  00012	75 04		 jne	 SHORT $LN8@DecryptStr
  00014	8b 44 24 04	 mov	 eax, DWORD PTR _String$[esp-4]
$LN8@DecryptStr:
; 1659 : 	for (PCHAR Tmp = Res; *Tmp; Tmp++)
  00018	8b c8		 mov	 ecx, eax
  0001a	38 10		 cmp	 BYTE PTR [eax], dl
  0001c	74 14		 je	 SHORT $LN5@DecryptStr
  0001e	53		 push	 ebx
$LL3@DecryptStr:
; 1660 : 	{
; 1661 : 		*Tmp -= 16;
  0001f	8a 19		 mov	 bl, BYTE PTR [ecx]
  00021	80 eb 10	 sub	 bl, 16			; 00000010H
; 1662 : 		*Tmp ^= 5;
  00024	80 f3 05	 xor	 bl, 5
; 1663 : 		*Tmp += 16;
  00027	80 c3 10	 add	 bl, 16			; 00000010H
  0002a	88 19		 mov	 BYTE PTR [ecx], bl
  0002c	41		 inc	 ecx
  0002d	38 11		 cmp	 BYTE PTR [ecx], dl
  0002f	75 ee		 jne	 SHORT $LL3@DecryptStr
  00031	5b		 pop	 ebx
$LN5@DecryptStr:
; 1664 : 	}
; 1665 : 	return Res;
; 1666 : }
  00032	c2 08 00	 ret	 8
?DecryptStr@@YGPADPAD0@Z ENDP				; DecryptStr
_TEXT	ENDS
PUBLIC	??0TBotObject@@QAE@XZ				; TBotObject::TBotObject
; Function compile flags: /Ogspy
;	COMDAT ??0TBotObject@@QAE@XZ
_TEXT	SEGMENT
??0TBotObject@@QAE@XZ PROC				; TBotObject::TBotObject, COMDAT
; _this$ = ecx
  00000	8b c1		 mov	 eax, ecx
  00002	c7 00 00 00 00
	00		 mov	 DWORD PTR [eax], OFFSET ??_7TBotObject@@6B@
  00008	c3		 ret	 0
??0TBotObject@@QAE@XZ ENDP				; TBotObject::TBotObject
_TEXT	ENDS
PUBLIC	??_7?$TString@D@@6B@				; TString<char>::`vftable'
PUBLIC	??0?$TString@D@@QAE@XZ				; TString<char>::TString<char>
EXTRN	??_E?$TString@D@@UAEPAXI@Z:PROC			; TString<char>::`vector deleting destructor'
;	COMDAT ??_7?$TString@D@@6B@
CONST	SEGMENT
??_7?$TString@D@@6B@ DD FLAT:??_E?$TString@D@@UAEPAXI@Z	; TString<char>::`vftable'
; Function compile flags: /Ogspy
; File e:\projects\progs\petrosjan\bjwj\source\core\strings.h
CONST	ENDS
;	COMDAT ??0?$TString@D@@QAE@XZ
_TEXT	SEGMENT
??0?$TString@D@@QAE@XZ PROC				; TString<char>::TString<char>, COMDAT
; _this$ = ecx
; 415  : 	TString() : Data(0) {};
  00000	8b c1		 mov	 eax, ecx
  00002	83 60 04 00	 and	 DWORD PTR [eax+4], 0
  00006	c7 00 00 00 00
	00		 mov	 DWORD PTR [eax], OFFSET ??_7?$TString@D@@6B@
  0000c	c3		 ret	 0
??0?$TString@D@@QAE@XZ ENDP				; TString<char>::TString<char>
_TEXT	ENDS
PUBLIC	??_C@_11LOCGONAA@?$AA?$AA@			; `string'
PUBLIC	?t_str@?$TString@D@@QBEPADXZ			; TString<char>::t_str
;	COMDAT ??_C@_11LOCGONAA@?$AA?$AA@
; File e:\projects\progs\petrosjan\bjwj\source\core\strimplementation.cpp
CONST	SEGMENT
??_C@_11LOCGONAA@?$AA?$AA@ DB 00H, 00H			; `string'
; Function compile flags: /Ogspy
CONST	ENDS
;	COMDAT ?t_str@?$TString@D@@QBEPADXZ
_TEXT	SEGMENT
?t_str@?$TString@D@@QBEPADXZ PROC			; TString<char>::t_str, COMDAT
; _this$ = ecx
; 701  : 	// 
; 702  : 	// 
; 703  : 	// 
; 704  : 	return (Data)? Data : (TChar*)L"";
  00000	8b 41 04	 mov	 eax, DWORD PTR [ecx+4]
  00003	85 c0		 test	 eax, eax
  00005	75 05		 jne	 SHORT $LN4@t_str
  00007	b8 00 00 00 00	 mov	 eax, OFFSET ??_C@_11LOCGONAA@?$AA?$AA@
$LN4@t_str:
; 705  : }
  0000c	c3		 ret	 0
?t_str@?$TString@D@@QBEPADXZ ENDP			; TString<char>::t_str
_TEXT	ENDS
PUBLIC	?IsEmpty@?$STRUTILS@D@@SA_NPBD@Z		; STRUTILS<char>::IsEmpty
; Function compile flags: /Ogspy
;	COMDAT ?IsEmpty@?$STRUTILS@D@@SA_NPBD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?IsEmpty@?$STRUTILS@D@@SA_NPBD@Z PROC			; STRUTILS<char>::IsEmpty, COMDAT
; 20   : 	return Str == NULL || *Str == 0;
  00000	8b 44 24 04	 mov	 eax, DWORD PTR _Str$[esp-4]
  00004	85 c0		 test	 eax, eax
  00006	74 08		 je	 SHORT $LN3@IsEmpty@3
  00008	80 38 00	 cmp	 BYTE PTR [eax], 0
  0000b	74 03		 je	 SHORT $LN3@IsEmpty@3
  0000d	33 c0		 xor	 eax, eax
; 21   : }
  0000f	c3		 ret	 0
$LN3@IsEmpty@3:
; 20   : 	return Str == NULL || *Str == 0;
  00010	33 c0		 xor	 eax, eax
  00012	40		 inc	 eax
; 21   : }
  00013	c3		 ret	 0
?IsEmpty@?$STRUTILS@D@@SA_NPBD@Z ENDP			; STRUTILS<char>::IsEmpty
_TEXT	ENDS
PUBLIC	?Length@?$STRUTILS@D@@SAKPBD@Z			; STRUTILS<char>::Length
; Function compile flags: /Ogspy
;	COMDAT ?Length@?$STRUTILS@D@@SAKPBD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?Length@?$STRUTILS@D@@SAKPBD@Z PROC			; STRUTILS<char>::Length, COMDAT
; 27   : 	// 
; 28   : 	DWORD Len = 0;
; 29   : 	if (Str != NULL)
  00000	8b 4c 24 04	 mov	 ecx, DWORD PTR _Str$[esp-4]
  00004	33 c0		 xor	 eax, eax
  00006	85 c9		 test	 ecx, ecx
  00008	74 0b		 je	 SHORT $LN7@Length
; 30   : 		while (*Str++) Len++;
  0000a	38 01		 cmp	 BYTE PTR [ecx], al
  0000c	74 07		 je	 SHORT $LN7@Length
$LL2@Length:
  0000e	41		 inc	 ecx
  0000f	40		 inc	 eax
  00010	80 39 00	 cmp	 BYTE PTR [ecx], 0
  00013	75 f9		 jne	 SHORT $LL2@Length
$LN7@Length:
; 31   : 
; 32   : 	return Len;
; 33   : }
  00015	c3		 ret	 0
?Length@?$STRUTILS@D@@SAKPBD@Z ENDP			; STRUTILS<char>::Length
_TEXT	ENDS
PUBLIC	?Hash@?$STRUTILS@D@@SAKPBDK_N@Z			; STRUTILS<char>::Hash
; Function compile flags: /Ogspy
;	COMDAT ?Hash@?$STRUTILS@D@@SAKPBDK_N@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_Len$ = 12						; size = 4
_LowerCase$ = 16					; size = 1
?Hash@?$STRUTILS@D@@SAKPBDK_N@Z PROC			; STRUTILS<char>::Hash, COMDAT
; 287  : 	// 
; 288  : 	// Str - 
; 289  : 	// Len - 
; 290  : 	// LowerCase - 
; 291  : 
; 292  : 	if (Str == NULL) return (DWORD)-1; // 
  00000	8b 54 24 04	 mov	 edx, DWORD PTR _Str$[esp-4]
  00004	85 d2		 test	 edx, edx
  00006	75 04		 jne	 SHORT $LN7@Hash
  00008	83 c8 ff	 or	 eax, -1
; 305  : }
  0000b	c3		 ret	 0
$LN7@Hash:
  0000c	56		 push	 esi
  0000d	57		 push	 edi
; 293  : 
; 294  : 	DWORD H = 0;
  0000e	33 f6		 xor	 esi, esi
; 295  : 
; 296  : 	for (DWORD i = 0; *Str != 0 && (Len == 0 || i < Len); Str++, i++)
  00010	33 ff		 xor	 edi, edi
  00012	eb 29		 jmp	 SHORT $LN13@Hash
$LL6@Hash:
  00014	83 7c 24 10 00	 cmp	 DWORD PTR _Len$[esp+4], 0
  00019	74 06		 je	 SHORT $LN3@Hash
  0001b	3b 7c 24 10	 cmp	 edi, DWORD PTR _Len$[esp+4]
  0001f	73 22		 jae	 SHORT $LN4@Hash
$LN3@Hash:
; 297  : 	{
; 298  : 		TChar Ch = *Str;
; 299  : 		if (LowerCase) LowerChar(Ch);
  00021	80 7c 24 14 00	 cmp	 BYTE PTR _LowerCase$[esp+4], 0
  00026	74 0b		 je	 SHORT $LN1@Hash
  00028	8a c1		 mov	 al, cl
  0002a	2c 41		 sub	 al, 65			; 00000041H
  0002c	3c 19		 cmp	 al, 25			; 00000019H
  0002e	77 03		 ja	 SHORT $LN1@Hash
  00030	80 c1 20	 add	 cl, 32			; 00000020H
$LN1@Hash:
; 300  : 		H = (( H << 7 ) & (DWORD)( -1 ) ) | ( H >> ( 32 - 7 ));
; 301  : 		H = H ^ Ch;
  00033	0f be c1	 movsx	 eax, cl
  00036	c1 c6 07	 rol	 esi, 7
  00039	33 f0		 xor	 esi, eax
  0003b	42		 inc	 edx
  0003c	47		 inc	 edi
$LN13@Hash:
  0003d	8a 0a		 mov	 cl, BYTE PTR [edx]
  0003f	84 c9		 test	 cl, cl
  00041	75 d1		 jne	 SHORT $LL6@Hash
$LN4@Hash:
  00043	5f		 pop	 edi
; 302  : 	}
; 303  : 
; 304  : 	return H;
  00044	8b c6		 mov	 eax, esi
  00046	5e		 pop	 esi
; 305  : }
  00047	c3		 ret	 0
?Hash@?$STRUTILS@D@@SAKPBDK_N@Z ENDP			; STRUTILS<char>::Hash
_TEXT	ENDS
PUBLIC	?Scan@?$STRUTILS@D@@SAPADPBDD@Z			; STRUTILS<char>::Scan
; Function compile flags: /Ogspy
;	COMDAT ?Scan@?$STRUTILS@D@@SAPADPBDD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_Char$ = 12						; size = 1
?Scan@?$STRUTILS@D@@SAPADPBDD@Z PROC			; STRUTILS<char>::Scan, COMDAT
; 317  : 	if (Str != NULL)
  00000	8b 44 24 04	 mov	 eax, DWORD PTR _Str$[esp-4]
  00004	85 c0		 test	 eax, eax
  00006	74 0f		 je	 SHORT $LN2@Scan
; 318  : 		while (*Str != 0)
  00008	eb 07		 jmp	 SHORT $LN11@Scan
$LL3@Scan:
; 319  : 		{
; 320  : 			if (*Str == Char) return (TChar*)Str;
  0000a	3a 4c 24 08	 cmp	 cl, BYTE PTR _Char$[esp-4]
  0000e	74 09		 je	 SHORT $LN5@Scan
; 321  : 			Str++;
  00010	40		 inc	 eax
$LN11@Scan:
; 318  : 		while (*Str != 0)
  00011	8a 08		 mov	 cl, BYTE PTR [eax]
  00013	84 c9		 test	 cl, cl
  00015	75 f3		 jne	 SHORT $LL3@Scan
$LN2@Scan:
; 322  : 		}
; 323  : 	return NULL;
  00017	33 c0		 xor	 eax, eax
$LN5@Scan:
; 324  : }
  00019	c3		 ret	 0
?Scan@?$STRUTILS@D@@SAPADPBDD@Z ENDP			; STRUTILS<char>::Scan
_TEXT	ENDS
PUBLIC	?End@?$STRUTILS@D@@SAPADPBD@Z			; STRUTILS<char>::End
; Function compile flags: /Ogspy
;	COMDAT ?End@?$STRUTILS@D@@SAPADPBD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?End@?$STRUTILS@D@@SAPADPBD@Z PROC			; STRUTILS<char>::End, COMDAT
; 330  : 	if (Str)
  00000	8b 44 24 04	 mov	 eax, DWORD PTR _Str$[esp-4]
  00004	85 c0		 test	 eax, eax
  00006	74 08		 je	 SHORT $LN1@End@2
  00008	eb 01		 jmp	 SHORT $LN8@End@2
$LL2@End@2:
; 331  : 		while (*Str) Str++;
  0000a	40		 inc	 eax
$LN8@End@2:
  0000b	80 38 00	 cmp	 BYTE PTR [eax], 0
  0000e	75 fa		 jne	 SHORT $LL2@End@2
$LN1@End@2:
; 332  : 	return (TChar*)Str;
; 333  : }
  00010	c3		 ret	 0
?End@?$STRUTILS@D@@SAPADPBD@Z ENDP			; STRUTILS<char>::End
_TEXT	ENDS
PUBLIC	?LongToString@?$STRUTILS@D@@SAXKPADAAH@Z	; STRUTILS<char>::LongToString
; Function compile flags: /Ogspy
;	COMDAT ?LongToString@?$STRUTILS@D@@SAXKPADAAH@Z
_TEXT	SEGMENT
_num$ = 8						; size = 4
_Str$ = 12						; size = 4
_n$ = 16						; size = 4
?LongToString@?$STRUTILS@D@@SAXKPADAAH@Z PROC		; STRUTILS<char>::LongToString, COMDAT
; 344  : 	// 
; 345  : 	// 
; 346  : 	// 
; 347  : 	if (!n)
  00000	8b 4c 24 0c	 mov	 ecx, DWORD PTR _n$[esp-4]
  00004	53		 push	 ebx
  00005	56		 push	 esi
  00006	33 db		 xor	 ebx, ebx
  00008	57		 push	 edi
  00009	8b 7c 24 10	 mov	 edi, DWORD PTR _num$[esp+8]
  0000d	39 19		 cmp	 DWORD PTR [ecx], ebx
  0000f	75 23		 jne	 SHORT $LN16@LongToStri@2
; 348  : 	{
; 349  : 		if (!num)
  00011	3b fb		 cmp	 edi, ebx
  00013	75 08		 jne	 SHORT $LN9@LongToStri@2
; 350  : 			n = 1;
  00015	c7 01 01 00 00
	00		 mov	 DWORD PTR [ecx], 1
; 351  : 		else
  0001b	eb 17		 jmp	 SHORT $LN16@LongToStri@2
$LN9@LongToStri@2:
; 352  : 			for (int j = 1; num/j !=0; j *= 10) n++;
  0001d	33 f6		 xor	 esi, esi
  0001f	46		 inc	 esi
  00020	3b fb		 cmp	 edi, ebx
  00022	74 10		 je	 SHORT $LN16@LongToStri@2
$LL7@LongToStri@2:
  00024	6b f6 0a	 imul	 esi, 10			; 0000000aH
  00027	33 d2		 xor	 edx, edx
  00029	8b c7		 mov	 eax, edi
  0002b	f7 f6		 div	 esi
  0002d	43		 inc	 ebx
  0002e	85 c0		 test	 eax, eax
  00030	75 f2		 jne	 SHORT $LL7@LongToStri@2
  00032	89 19		 mov	 DWORD PTR [ecx], ebx
$LN16@LongToStri@2:
; 353  :     }
; 354  : 
; 355  :     // 
; 356  : 	if (!Str) return;
  00034	8b 74 24 14	 mov	 esi, DWORD PTR _Str$[esp+8]
  00038	85 f6		 test	 esi, esi
  0003a	74 1d		 je	 SHORT $LN1@LongToStri@2
; 357  : 
; 358  : 	// 
; 359  : 	int i = 1;
  0003c	33 db		 xor	 ebx, ebx
  0003e	43		 inc	 ebx
$LL3@LongToStri@2:
; 360  : 	int d = 0;
; 361  : 	do
; 362  : 	{
; 363  : 		d = num % 10;
  0003f	8b c7		 mov	 eax, edi
  00041	33 d2		 xor	 edx, edx
  00043	6a 0a		 push	 10			; 0000000aH
  00045	5f		 pop	 edi
  00046	f7 f7		 div	 edi
; 364  : 		num /= 10;
  00048	8b f8		 mov	 edi, eax
; 365  : 		Str[n-i]=(char)(d+48);
  0004a	8b 01		 mov	 eax, DWORD PTR [ecx]
  0004c	80 c2 30	 add	 dl, 48			; 00000030H
  0004f	2b c3		 sub	 eax, ebx
; 366  : 		i++;
  00051	43		 inc	 ebx
  00052	88 14 30	 mov	 BYTE PTR [eax+esi], dl
; 367  : 	}
; 368  : 	while(num != 0);
  00055	85 ff		 test	 edi, edi
  00057	75 e6		 jne	 SHORT $LL3@LongToStri@2
$LN1@LongToStri@2:
  00059	5f		 pop	 edi
  0005a	5e		 pop	 esi
  0005b	5b		 pop	 ebx
; 369  : }
  0005c	c3		 ret	 0
?LongToString@?$STRUTILS@D@@SAXKPADAAH@Z ENDP		; STRUTILS<char>::LongToString
_TEXT	ENDS
PUBLIC	??$pushargEx@$00$0CMKBLFOG@$0HO@PADPBD@@YAPAXPADPBD@Z ; pushargEx<1,748795366,126,char *,char const *>
EXTRN	?GetProcAddressEx2@@YAPAXPADKKH@Z:PROC		; GetProcAddressEx2
; Function compile flags: /Ogspy
; File e:\projects\progs\petrosjan\bjwj\source\core\getapi.h
;	COMDAT ??$pushargEx@$00$0CMKBLFOG@$0HO@PADPBD@@YAPAXPADPBD@Z
_TEXT	SEGMENT
_a1$ = 8						; size = 4
_a2$ = 12						; size = 4
??$pushargEx@$00$0CMKBLFOG@$0HO@PADPBD@@YAPAXPADPBD@Z PROC ; pushargEx<1,748795366,126,char *,char const *>, COMDAT
; 108  : 	typedef LPVOID (WINAPI *newfunc)(A, B);
; 109  : 	newfunc func = (newfunc)GetProcAddressEx2( NULL, h, hash, CacheIndex );
  00000	6a 7e		 push	 126			; 0000007eH
  00002	68 e6 b5 a1 2c	 push	 748795366		; 2ca1b5e6H
  00007	6a 01		 push	 1
  00009	6a 00		 push	 0
  0000b	e8 00 00 00 00	 call	 ?GetProcAddressEx2@@YAPAXPADKKH@Z ; GetProcAddressEx2
  00010	83 c4 10	 add	 esp, 16			; 00000010H
; 110  : 	return func(a1,a2);
  00013	ff 74 24 08	 push	 DWORD PTR _a2$[esp-4]
  00017	ff 74 24 08	 push	 DWORD PTR _a1$[esp]
  0001b	ff d0		 call	 eax
; 111  : }
  0001d	c3		 ret	 0
??$pushargEx@$00$0CMKBLFOG@$0HO@PADPBD@@YAPAXPADPBD@Z ENDP ; pushargEx<1,748795366,126,char *,char const *>
_TEXT	ENDS
PUBLIC	??$pushargEx@$00$0CMKCLHOG@$0HM@PBDPBD@@YAPAXPBD0@Z ; pushargEx<1,748861414,124,char const *,char const *>
; Function compile flags: /Ogspy
;	COMDAT ??$pushargEx@$00$0CMKCLHOG@$0HM@PBDPBD@@YAPAXPBD0@Z
_TEXT	SEGMENT
_a1$ = 8						; size = 4
_a2$ = 12						; size = 4
??$pushargEx@$00$0CMKCLHOG@$0HM@PBDPBD@@YAPAXPBD0@Z PROC ; pushargEx<1,748861414,124,char const *,char const *>, COMDAT
; 108  : 	typedef LPVOID (WINAPI *newfunc)(A, B);
; 109  : 	newfunc func = (newfunc)GetProcAddressEx2( NULL, h, hash, CacheIndex );
  00000	6a 7c		 push	 124			; 0000007cH
  00002	68 e6 b7 a2 2c	 push	 748861414		; 2ca2b7e6H
  00007	6a 01		 push	 1
  00009	6a 00		 push	 0
  0000b	e8 00 00 00 00	 call	 ?GetProcAddressEx2@@YAPAXPADKKH@Z ; GetProcAddressEx2
  00010	83 c4 10	 add	 esp, 16			; 00000010H
; 110  : 	return func(a1,a2);
  00013	ff 74 24 08	 push	 DWORD PTR _a2$[esp-4]
  00017	ff 74 24 08	 push	 DWORD PTR _a1$[esp]
  0001b	ff d0		 call	 eax
; 111  : }
  0001d	c3		 ret	 0
??$pushargEx@$00$0CMKCLHOG@$0HM@PBDPBD@@YAPAXPBD0@Z ENDP ; pushargEx<1,748861414,124,char const *,char const *>
_TEXT	ENDS
PUBLIC	??$pushargEx@$00$0CMKFPDGG@$0IA@PADPBD@@YAPAXPADPBD@Z ; pushargEx<1,749073254,128,char *,char const *>
; Function compile flags: /Ogspy
;	COMDAT ??$pushargEx@$00$0CMKFPDGG@$0IA@PADPBD@@YAPAXPADPBD@Z
_TEXT	SEGMENT
_a1$ = 8						; size = 4
_a2$ = 12						; size = 4
??$pushargEx@$00$0CMKFPDGG@$0IA@PADPBD@@YAPAXPADPBD@Z PROC ; pushargEx<1,749073254,128,char *,char const *>, COMDAT
; 108  : 	typedef LPVOID (WINAPI *newfunc)(A, B);
; 109  : 	newfunc func = (newfunc)GetProcAddressEx2( NULL, h, hash, CacheIndex );
  00000	68 80 00 00 00	 push	 128			; 00000080H
  00005	68 66 f3 a5 2c	 push	 749073254		; 2ca5f366H
  0000a	6a 01		 push	 1
  0000c	6a 00		 push	 0
  0000e	e8 00 00 00 00	 call	 ?GetProcAddressEx2@@YAPAXPADKKH@Z ; GetProcAddressEx2
  00013	83 c4 10	 add	 esp, 16			; 00000010H
; 110  : 	return func(a1,a2);
  00016	ff 74 24 08	 push	 DWORD PTR _a2$[esp-4]
  0001a	ff 74 24 08	 push	 DWORD PTR _a1$[esp]
  0001e	ff d0		 call	 eax
; 111  : }
  00020	c3		 ret	 0
??$pushargEx@$00$0CMKFPDGG@$0IA@PADPBD@@YAPAXPADPBD@Z ENDP ; pushargEx<1,749073254,128,char *,char const *>
_TEXT	ENDS
PUBLIC	??$pushargEx@$00$0FKKHOHAL@$0DB@HHPADKHH@@YAPAXHHPADKHH@Z ; pushargEx<1,1520953099,49,int,int,char *,unsigned long,int,int>
; Function compile flags: /Ogspy
;	COMDAT ??$pushargEx@$00$0FKKHOHAL@$0DB@HHPADKHH@@YAPAXHHPADKHH@Z
_TEXT	SEGMENT
_a1$ = 8						; size = 4
_a2$ = 12						; size = 4
_a3$ = 16						; size = 4
_a4$ = 20						; size = 4
_a5$ = 24						; size = 4
_a6$ = 28						; size = 4
??$pushargEx@$00$0FKKHOHAL@$0DB@HHPADKHH@@YAPAXHHPADKHH@Z PROC ; pushargEx<1,1520953099,49,int,int,char *,unsigned long,int,int>, COMDAT
; 139  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
; 140  : 	typedef LPVOID (WINAPI *newfunc)(A, B, C, D, E, F);
; 141  : 	newfunc func = (newfunc)GetProcAddressEx2( NULL, h, hash, CacheIndex );
  00003	6a 31		 push	 49			; 00000031H
  00005	68 0b e7 a7 5a	 push	 1520953099		; 5aa7e70bH
  0000a	6a 01		 push	 1
  0000c	6a 00		 push	 0
  0000e	e8 00 00 00 00	 call	 ?GetProcAddressEx2@@YAPAXPADKKH@Z ; GetProcAddressEx2
  00013	83 c4 10	 add	 esp, 16			; 00000010H
; 142  : 	return func(a1, a2, a3, a4, a5, a6);
  00016	ff 75 1c	 push	 DWORD PTR _a6$[ebp]
  00019	ff 75 18	 push	 DWORD PTR _a5$[ebp]
  0001c	ff 75 14	 push	 DWORD PTR _a4$[ebp]
  0001f	ff 75 10	 push	 DWORD PTR _a3$[ebp]
  00022	ff 75 0c	 push	 DWORD PTR _a2$[ebp]
  00025	ff 75 08	 push	 DWORD PTR _a1$[ebp]
  00028	ff d0		 call	 eax
; 143  : }
  0002a	5d		 pop	 ebp
  0002b	c3		 ret	 0
??$pushargEx@$00$0FKKHOHAL@$0DB@HHPADKHH@@YAPAXHHPADKHH@Z ENDP ; pushargEx<1,1520953099,49,int,int,char *,unsigned long,int,int>
_TEXT	ENDS
PUBLIC	??$pushargEx@$00$0FKKHOHAL@$0DB@HHPADHPA_WH@@YAPAXHHPADHPA_WH@Z ; pushargEx<1,1520953099,49,int,int,char *,int,wchar_t *,int>
; Function compile flags: /Ogspy
;	COMDAT ??$pushargEx@$00$0FKKHOHAL@$0DB@HHPADHPA_WH@@YAPAXHHPADHPA_WH@Z
_TEXT	SEGMENT
_a1$ = 8						; size = 4
_a2$ = 12						; size = 4
_a3$ = 16						; size = 4
_a4$ = 20						; size = 4
_a5$ = 24						; size = 4
_a6$ = 28						; size = 4
??$pushargEx@$00$0FKKHOHAL@$0DB@HHPADHPA_WH@@YAPAXHHPADHPA_WH@Z PROC ; pushargEx<1,1520953099,49,int,int,char *,int,wchar_t *,int>, COMDAT
; 139  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
; 140  : 	typedef LPVOID (WINAPI *newfunc)(A, B, C, D, E, F);
; 141  : 	newfunc func = (newfunc)GetProcAddressEx2( NULL, h, hash, CacheIndex );
  00003	6a 31		 push	 49			; 00000031H
  00005	68 0b e7 a7 5a	 push	 1520953099		; 5aa7e70bH
  0000a	6a 01		 push	 1
  0000c	6a 00		 push	 0
  0000e	e8 00 00 00 00	 call	 ?GetProcAddressEx2@@YAPAXPADKKH@Z ; GetProcAddressEx2
  00013	83 c4 10	 add	 esp, 16			; 00000010H
; 142  : 	return func(a1, a2, a3, a4, a5, a6);
  00016	ff 75 1c	 push	 DWORD PTR _a6$[ebp]
  00019	ff 75 18	 push	 DWORD PTR _a5$[ebp]
  0001c	ff 75 14	 push	 DWORD PTR _a4$[ebp]
  0001f	ff 75 10	 push	 DWORD PTR _a3$[ebp]
  00022	ff 75 0c	 push	 DWORD PTR _a2$[ebp]
  00025	ff 75 08	 push	 DWORD PTR _a1$[ebp]
  00028	ff d0		 call	 eax
; 143  : }
  0002a	5d		 pop	 ebp
  0002b	c3		 ret	 0
??$pushargEx@$00$0FKKHOHAL@$0DB@HHPADHPA_WH@@YAPAXHHPADHPA_WH@Z ENDP ; pushargEx<1,1520953099,49,int,int,char *,int,wchar_t *,int>
_TEXT	ENDS
PUBLIC	??$pushargEx@$00$0FKKHOHAL@$0DB@HHPBDHHH@@YAPAXHHPBDHHH@Z ; pushargEx<1,1520953099,49,int,int,char const *,int,int,int>
; Function compile flags: /Ogspy
;	COMDAT ??$pushargEx@$00$0FKKHOHAL@$0DB@HHPBDHHH@@YAPAXHHPBDHHH@Z
_TEXT	SEGMENT
_a1$ = 8						; size = 4
_a2$ = 12						; size = 4
_a3$ = 16						; size = 4
_a4$ = 20						; size = 4
_a5$ = 24						; size = 4
_a6$ = 28						; size = 4
??$pushargEx@$00$0FKKHOHAL@$0DB@HHPBDHHH@@YAPAXHHPBDHHH@Z PROC ; pushargEx<1,1520953099,49,int,int,char const *,int,int,int>, COMDAT
; 139  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
; 140  : 	typedef LPVOID (WINAPI *newfunc)(A, B, C, D, E, F);
; 141  : 	newfunc func = (newfunc)GetProcAddressEx2( NULL, h, hash, CacheIndex );
  00003	6a 31		 push	 49			; 00000031H
  00005	68 0b e7 a7 5a	 push	 1520953099		; 5aa7e70bH
  0000a	6a 01		 push	 1
  0000c	6a 00		 push	 0
  0000e	e8 00 00 00 00	 call	 ?GetProcAddressEx2@@YAPAXPADKKH@Z ; GetProcAddressEx2
  00013	83 c4 10	 add	 esp, 16			; 00000010H
; 142  : 	return func(a1, a2, a3, a4, a5, a6);
  00016	ff 75 1c	 push	 DWORD PTR _a6$[ebp]
  00019	ff 75 18	 push	 DWORD PTR _a5$[ebp]
  0001c	ff 75 14	 push	 DWORD PTR _a4$[ebp]
  0001f	ff 75 10	 push	 DWORD PTR _a3$[ebp]
  00022	ff 75 0c	 push	 DWORD PTR _a2$[ebp]
  00025	ff 75 08	 push	 DWORD PTR _a1$[ebp]
  00028	ff d0		 call	 eax
; 143  : }
  0002a	5d		 pop	 ebp
  0002b	c3		 ret	 0
??$pushargEx@$00$0FKKHOHAL@$0DB@HHPBDHHH@@YAPAXHHPBDHHH@Z ENDP ; pushargEx<1,1520953099,49,int,int,char const *,int,int,int>
_TEXT	ENDS
PUBLIC	??$pushargEx@$00$0FKKHOHAL@$0DB@HHPBDHPA_WH@@YAPAXHHPBDHPA_WH@Z ; pushargEx<1,1520953099,49,int,int,char const *,int,wchar_t *,int>
; Function compile flags: /Ogspy
;	COMDAT ??$pushargEx@$00$0FKKHOHAL@$0DB@HHPBDHPA_WH@@YAPAXHHPBDHPA_WH@Z
_TEXT	SEGMENT
_a1$ = 8						; size = 4
_a2$ = 12						; size = 4
_a3$ = 16						; size = 4
_a4$ = 20						; size = 4
_a5$ = 24						; size = 4
_a6$ = 28						; size = 4
??$pushargEx@$00$0FKKHOHAL@$0DB@HHPBDHPA_WH@@YAPAXHHPBDHPA_WH@Z PROC ; pushargEx<1,1520953099,49,int,int,char const *,int,wchar_t *,int>, COMDAT
; 139  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
; 140  : 	typedef LPVOID (WINAPI *newfunc)(A, B, C, D, E, F);
; 141  : 	newfunc func = (newfunc)GetProcAddressEx2( NULL, h, hash, CacheIndex );
  00003	6a 31		 push	 49			; 00000031H
  00005	68 0b e7 a7 5a	 push	 1520953099		; 5aa7e70bH
  0000a	6a 01		 push	 1
  0000c	6a 00		 push	 0
  0000e	e8 00 00 00 00	 call	 ?GetProcAddressEx2@@YAPAXPADKKH@Z ; GetProcAddressEx2
  00013	83 c4 10	 add	 esp, 16			; 00000010H
; 142  : 	return func(a1, a2, a3, a4, a5, a6);
  00016	ff 75 1c	 push	 DWORD PTR _a6$[ebp]
  00019	ff 75 18	 push	 DWORD PTR _a5$[ebp]
  0001c	ff 75 14	 push	 DWORD PTR _a4$[ebp]
  0001f	ff 75 10	 push	 DWORD PTR _a3$[ebp]
  00022	ff 75 0c	 push	 DWORD PTR _a2$[ebp]
  00025	ff 75 08	 push	 DWORD PTR _a1$[ebp]
  00028	ff d0		 call	 eax
; 143  : }
  0002a	5d		 pop	 ebp
  0002b	c3		 ret	 0
??$pushargEx@$00$0FKKHOHAL@$0DB@HHPBDHPA_WH@@YAPAXHHPBDHPA_WH@Z ENDP ; pushargEx<1,1520953099,49,int,int,char const *,int,wchar_t *,int>
_TEXT	ENDS
PUBLIC	??$pushargEx@$00$0OHEPFHOO@$0DA@HHPA_WHHHHH@@YAPAXHHPA_WHHHHH@Z ; pushargEx<1,3880736750,48,int,int,wchar_t *,int,int,int,int,int>
; Function compile flags: /Ogspy
;	COMDAT ??$pushargEx@$00$0OHEPFHOO@$0DA@HHPA_WHHHHH@@YAPAXHHPA_WHHHHH@Z
_TEXT	SEGMENT
_a1$ = 8						; size = 4
_a2$ = 12						; size = 4
_a3$ = 16						; size = 4
_a4$ = 20						; size = 4
_a5$ = 24						; size = 4
_a6$ = 28						; size = 4
_a7$ = 32						; size = 4
_a8$ = 36						; size = 4
??$pushargEx@$00$0OHEPFHOO@$0DA@HHPA_WHHHHH@@YAPAXHHPA_WHHHHH@Z PROC ; pushargEx<1,3880736750,48,int,int,wchar_t *,int,int,int,int,int>, COMDAT
; 155  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
; 156  : 	typedef LPVOID (WINAPI *newfunc)(A, B, C, D, E, F, G, H);
; 157  : 	newfunc func = (newfunc)GetProcAddressEx2( NULL, h, hash, CacheIndex );
  00003	6a 30		 push	 48			; 00000030H
  00005	68 ee 57 4f e7	 push	 -414230546		; e74f57eeH
  0000a	6a 01		 push	 1
  0000c	6a 00		 push	 0
  0000e	e8 00 00 00 00	 call	 ?GetProcAddressEx2@@YAPAXPADKKH@Z ; GetProcAddressEx2
  00013	83 c4 10	 add	 esp, 16			; 00000010H
; 158  : 	return func(a1, a2, a3, a4, a5, a6, a7, a8);
  00016	ff 75 24	 push	 DWORD PTR _a8$[ebp]
  00019	ff 75 20	 push	 DWORD PTR _a7$[ebp]
  0001c	ff 75 1c	 push	 DWORD PTR _a6$[ebp]
  0001f	ff 75 18	 push	 DWORD PTR _a5$[ebp]
  00022	ff 75 14	 push	 DWORD PTR _a4$[ebp]
  00025	ff 75 10	 push	 DWORD PTR _a3$[ebp]
  00028	ff 75 0c	 push	 DWORD PTR _a2$[ebp]
  0002b	ff 75 08	 push	 DWORD PTR _a1$[ebp]
  0002e	ff d0		 call	 eax
; 159  : }
  00030	5d		 pop	 ebp
  00031	c3		 ret	 0
??$pushargEx@$00$0OHEPFHOO@$0DA@HHPA_WHHHHH@@YAPAXHHPA_WHHHHH@Z ENDP ; pushargEx<1,3880736750,48,int,int,wchar_t *,int,int,int,int,int>
_TEXT	ENDS
PUBLIC	??$pushargEx@$00$0OHEPFHOO@$0DA@HHPA_WHPADHHH@@YAPAXHHPA_WHPADHHH@Z ; pushargEx<1,3880736750,48,int,int,wchar_t *,int,char *,int,int,int>
; Function compile flags: /Ogspy
;	COMDAT ??$pushargEx@$00$0OHEPFHOO@$0DA@HHPA_WHPADHHH@@YAPAXHHPA_WHPADHHH@Z
_TEXT	SEGMENT
_a1$ = 8						; size = 4
_a2$ = 12						; size = 4
_a3$ = 16						; size = 4
_a4$ = 20						; size = 4
_a5$ = 24						; size = 4
_a6$ = 28						; size = 4
_a7$ = 32						; size = 4
_a8$ = 36						; size = 4
??$pushargEx@$00$0OHEPFHOO@$0DA@HHPA_WHPADHHH@@YAPAXHHPA_WHPADHHH@Z PROC ; pushargEx<1,3880736750,48,int,int,wchar_t *,int,char *,int,int,int>, COMDAT
; 155  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
; 156  : 	typedef LPVOID (WINAPI *newfunc)(A, B, C, D, E, F, G, H);
; 157  : 	newfunc func = (newfunc)GetProcAddressEx2( NULL, h, hash, CacheIndex );
  00003	6a 30		 push	 48			; 00000030H
  00005	68 ee 57 4f e7	 push	 -414230546		; e74f57eeH
  0000a	6a 01		 push	 1
  0000c	6a 00		 push	 0
  0000e	e8 00 00 00 00	 call	 ?GetProcAddressEx2@@YAPAXPADKKH@Z ; GetProcAddressEx2
  00013	83 c4 10	 add	 esp, 16			; 00000010H
; 158  : 	return func(a1, a2, a3, a4, a5, a6, a7, a8);
  00016	ff 75 24	 push	 DWORD PTR _a8$[ebp]
  00019	ff 75 20	 push	 DWORD PTR _a7$[ebp]
  0001c	ff 75 1c	 push	 DWORD PTR _a6$[ebp]
  0001f	ff 75 18	 push	 DWORD PTR _a5$[ebp]
  00022	ff 75 14	 push	 DWORD PTR _a4$[ebp]
  00025	ff 75 10	 push	 DWORD PTR _a3$[ebp]
  00028	ff 75 0c	 push	 DWORD PTR _a2$[ebp]
  0002b	ff 75 08	 push	 DWORD PTR _a1$[ebp]
  0002e	ff d0		 call	 eax
; 159  : }
  00030	5d		 pop	 ebp
  00031	c3		 ret	 0
??$pushargEx@$00$0OHEPFHOO@$0DA@HHPA_WHPADHHH@@YAPAXHHPA_WHPADHHH@Z ENDP ; pushargEx<1,3880736750,48,int,int,wchar_t *,int,char *,int,int,int>
_TEXT	ENDS
PUBLIC	?Length@?$STRUTILS@_W@@SAKPB_W@Z		; STRUTILS<wchar_t>::Length
; Function compile flags: /Ogspy
; File e:\projects\progs\petrosjan\bjwj\source\core\strimplementation.cpp
;	COMDAT ?Length@?$STRUTILS@_W@@SAKPB_W@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?Length@?$STRUTILS@_W@@SAKPB_W@Z PROC			; STRUTILS<wchar_t>::Length, COMDAT
; 27   : 	// 
; 28   : 	DWORD Len = 0;
; 29   : 	if (Str != NULL)
  00000	8b 4c 24 04	 mov	 ecx, DWORD PTR _Str$[esp-4]
  00004	33 c0		 xor	 eax, eax
  00006	85 c9		 test	 ecx, ecx
  00008	74 0e		 je	 SHORT $LN7@Length@2
; 30   : 		while (*Str++) Len++;
  0000a	66 39 01	 cmp	 WORD PTR [ecx], ax
  0000d	74 09		 je	 SHORT $LN7@Length@2
$LL2@Length@2:
  0000f	41		 inc	 ecx
  00010	41		 inc	 ecx
  00011	40		 inc	 eax
  00012	66 83 39 00	 cmp	 WORD PTR [ecx], 0
  00016	75 f7		 jne	 SHORT $LL2@Length@2
$LN7@Length@2:
; 31   : 
; 32   : 	return Len;
; 33   : }
  00018	c3		 ret	 0
?Length@?$STRUTILS@_W@@SAKPB_W@Z ENDP			; STRUTILS<wchar_t>::Length
_TEXT	ENDS
PUBLIC	?Hash@?$STRUTILS@_W@@SAKPB_WK_N@Z		; STRUTILS<wchar_t>::Hash
; Function compile flags: /Ogspy
;	COMDAT ?Hash@?$STRUTILS@_W@@SAKPB_WK_N@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_Len$ = 12						; size = 4
_LowerCase$ = 16					; size = 1
?Hash@?$STRUTILS@_W@@SAKPB_WK_N@Z PROC			; STRUTILS<wchar_t>::Hash, COMDAT
; 287  : 	// 
; 288  : 	// Str - 
; 289  : 	// Len - 
; 290  : 	// LowerCase - 
; 291  : 
; 292  : 	if (Str == NULL) return (DWORD)-1; // 
  00000	8b 54 24 04	 mov	 edx, DWORD PTR _Str$[esp-4]
  00004	85 d2		 test	 edx, edx
  00006	75 04		 jne	 SHORT $LN7@Hash@2
  00008	83 c8 ff	 or	 eax, -1
; 302  : 	}
; 303  : 
; 304  : 	return H;
; 305  : }
  0000b	c3		 ret	 0
$LN7@Hash@2:
; 293  : 
; 294  : 	DWORD H = 0;
; 295  : 
; 296  : 	for (DWORD i = 0; *Str != 0 && (Len == 0 || i < Len); Str++, i++)
  0000c	0f b7 0a	 movzx	 ecx, WORD PTR [edx]
  0000f	56		 push	 esi
  00010	33 c0		 xor	 eax, eax
  00012	33 f6		 xor	 esi, esi
  00014	66 85 c9	 test	 cx, cx
  00017	74 38		 je	 SHORT $LN4@Hash@2
  00019	57		 push	 edi
$LL6@Hash@2:
  0001a	83 7c 24 10 00	 cmp	 DWORD PTR _Len$[esp+4], 0
  0001f	74 06		 je	 SHORT $LN3@Hash@2
  00021	3b 74 24 10	 cmp	 esi, DWORD PTR _Len$[esp+4]
  00025	73 29		 jae	 SHORT $LN12@Hash@2
$LN3@Hash@2:
; 297  : 	{
; 298  : 		TChar Ch = *Str;
; 299  : 		if (LowerCase) LowerChar(Ch);
  00027	80 7c 24 14 00	 cmp	 BYTE PTR _LowerCase$[esp+4], 0
  0002c	0f b7 c9	 movzx	 ecx, cx
  0002f	74 0c		 je	 SHORT $LN1@Hash@2
  00031	8d 79 bf	 lea	 edi, DWORD PTR [ecx-65]
  00034	66 83 ff 19	 cmp	 di, 25			; 00000019H
  00038	77 03		 ja	 SHORT $LN1@Hash@2
  0003a	83 c1 20	 add	 ecx, 32			; 00000020H
$LN1@Hash@2:
; 300  : 		H = (( H << 7 ) & (DWORD)( -1 ) ) | ( H >> ( 32 - 7 ));
; 301  : 		H = H ^ Ch;
  0003d	0f b7 c9	 movzx	 ecx, cx
  00040	c1 c0 07	 rol	 eax, 7
  00043	33 c1		 xor	 eax, ecx
  00045	42		 inc	 edx
  00046	42		 inc	 edx
  00047	0f b7 0a	 movzx	 ecx, WORD PTR [edx]
  0004a	46		 inc	 esi
  0004b	66 85 c9	 test	 cx, cx
  0004e	75 ca		 jne	 SHORT $LL6@Hash@2
$LN12@Hash@2:
  00050	5f		 pop	 edi
$LN4@Hash@2:
  00051	5e		 pop	 esi
; 302  : 	}
; 303  : 
; 304  : 	return H;
; 305  : }
  00052	c3		 ret	 0
?Hash@?$STRUTILS@_W@@SAKPB_WK_N@Z ENDP			; STRUTILS<wchar_t>::Hash
_TEXT	ENDS
PUBLIC	??$pushargEx@$02$0GLDKPAOM@$0BFK@PADPADPAD@@YAPAXPAD00@Z ; pushargEx<3,1799024876,346,char *,char *,char *>
; Function compile flags: /Ogspy
; File e:\projects\progs\petrosjan\bjwj\source\core\getapi.h
;	COMDAT ??$pushargEx@$02$0GLDKPAOM@$0BFK@PADPADPAD@@YAPAXPAD00@Z
_TEXT	SEGMENT
_a1$ = 8						; size = 4
_a2$ = 12						; size = 4
_a3$ = 16						; size = 4
??$pushargEx@$02$0GLDKPAOM@$0BFK@PADPADPAD@@YAPAXPAD00@Z PROC ; pushargEx<3,1799024876,346,char *,char *,char *>, COMDAT
; 116  : 	typedef LPVOID (WINAPI *newfunc)(A, B, C);
; 117  : 	newfunc func = (newfunc)GetProcAddressEx2( NULL, h, hash, CacheIndex );
  00000	68 5a 01 00 00	 push	 346			; 0000015aH
  00005	68 ec f0 3a 6b	 push	 1799024876		; 6b3af0ecH
  0000a	6a 03		 push	 3
  0000c	6a 00		 push	 0
  0000e	e8 00 00 00 00	 call	 ?GetProcAddressEx2@@YAPAXPADKKH@Z ; GetProcAddressEx2
  00013	83 c4 10	 add	 esp, 16			; 00000010H
; 118  : 	return func(a1,a2,a3);
  00016	ff 74 24 0c	 push	 DWORD PTR _a3$[esp-4]
  0001a	ff 74 24 0c	 push	 DWORD PTR _a2$[esp]
  0001e	ff 74 24 0c	 push	 DWORD PTR _a1$[esp+4]
  00022	ff d0		 call	 eax
; 119  : }
  00024	c3		 ret	 0
??$pushargEx@$02$0GLDKPAOM@$0BFK@PADPADPAD@@YAPAXPAD00@Z ENDP ; pushargEx<3,1799024876,346,char *,char *,char *>
_TEXT	ENDS
PUBLIC	??$pushargEx@$02$0FPNKBIHB@$0BFG@PADK@@YAPAXPADK@Z ; pushargEx<3,1608128625,342,char *,unsigned long>
; Function compile flags: /Ogspy
;	COMDAT ??$pushargEx@$02$0FPNKBIHB@$0BFG@PADK@@YAPAXPADK@Z
_TEXT	SEGMENT
_a1$ = 8						; size = 4
_a2$ = 12						; size = 4
??$pushargEx@$02$0FPNKBIHB@$0BFG@PADK@@YAPAXPADK@Z PROC	; pushargEx<3,1608128625,342,char *,unsigned long>, COMDAT
; 108  : 	typedef LPVOID (WINAPI *newfunc)(A, B);
; 109  : 	newfunc func = (newfunc)GetProcAddressEx2( NULL, h, hash, CacheIndex );
  00000	68 56 01 00 00	 push	 342			; 00000156H
  00005	68 71 18 da 5f	 push	 1608128625		; 5fda1871H
  0000a	6a 03		 push	 3
  0000c	6a 00		 push	 0
  0000e	e8 00 00 00 00	 call	 ?GetProcAddressEx2@@YAPAXPADKKH@Z ; GetProcAddressEx2
  00013	83 c4 10	 add	 esp, 16			; 00000010H
; 110  : 	return func(a1,a2);
  00016	ff 74 24 08	 push	 DWORD PTR _a2$[esp-4]
  0001a	ff 74 24 08	 push	 DWORD PTR _a1$[esp]
  0001e	ff d0		 call	 eax
; 111  : }
  00020	c3		 ret	 0
??$pushargEx@$02$0FPNKBIHB@$0BFG@PADK@@YAPAXPADK@Z ENDP	; pushargEx<3,1608128625,342,char *,unsigned long>
_TEXT	ENDS
PUBLIC	??$pushargEx@$00$0OHEPFHOO@$0DA@HHPB_WKPADKHH@@YAPAXHHPB_WKPADKHH@Z ; pushargEx<1,3880736750,48,int,int,wchar_t const *,unsigned long,char *,unsigned long,int,int>
; Function compile flags: /Ogspy
;	COMDAT ??$pushargEx@$00$0OHEPFHOO@$0DA@HHPB_WKPADKHH@@YAPAXHHPB_WKPADKHH@Z
_TEXT	SEGMENT
_a1$ = 8						; size = 4
_a2$ = 12						; size = 4
_a3$ = 16						; size = 4
_a4$ = 20						; size = 4
_a5$ = 24						; size = 4
_a6$ = 28						; size = 4
_a7$ = 32						; size = 4
_a8$ = 36						; size = 4
??$pushargEx@$00$0OHEPFHOO@$0DA@HHPB_WKPADKHH@@YAPAXHHPB_WKPADKHH@Z PROC ; pushargEx<1,3880736750,48,int,int,wchar_t const *,unsigned long,char *,unsigned long,int,int>, COMDAT
; 155  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
; 156  : 	typedef LPVOID (WINAPI *newfunc)(A, B, C, D, E, F, G, H);
; 157  : 	newfunc func = (newfunc)GetProcAddressEx2( NULL, h, hash, CacheIndex );
  00003	6a 30		 push	 48			; 00000030H
  00005	68 ee 57 4f e7	 push	 -414230546		; e74f57eeH
  0000a	6a 01		 push	 1
  0000c	6a 00		 push	 0
  0000e	e8 00 00 00 00	 call	 ?GetProcAddressEx2@@YAPAXPADKKH@Z ; GetProcAddressEx2
  00013	83 c4 10	 add	 esp, 16			; 00000010H
; 158  : 	return func(a1, a2, a3, a4, a5, a6, a7, a8);
  00016	ff 75 24	 push	 DWORD PTR _a8$[ebp]
  00019	ff 75 20	 push	 DWORD PTR _a7$[ebp]
  0001c	ff 75 1c	 push	 DWORD PTR _a6$[ebp]
  0001f	ff 75 18	 push	 DWORD PTR _a5$[ebp]
  00022	ff 75 14	 push	 DWORD PTR _a4$[ebp]
  00025	ff 75 10	 push	 DWORD PTR _a3$[ebp]
  00028	ff 75 0c	 push	 DWORD PTR _a2$[ebp]
  0002b	ff 75 08	 push	 DWORD PTR _a1$[ebp]
  0002e	ff d0		 call	 eax
; 159  : }
  00030	5d		 pop	 ebp
  00031	c3		 ret	 0
??$pushargEx@$00$0OHEPFHOO@$0DA@HHPB_WKPADKHH@@YAPAXHHPB_WKPADKHH@Z ENDP ; pushargEx<1,3880736750,48,int,int,wchar_t const *,unsigned long,char *,unsigned long,int,int>
_TEXT	ENDS
PUBLIC	??$GetRec@D@STRBUF@@YAAAUTStrRec@0@PAD@Z	; STRBUF::GetRec<char>
; Function compile flags: /Ogspy
; File e:\projects\progs\petrosjan\bjwj\source\core\strimplementation.cpp
;	COMDAT ??$GetRec@D@STRBUF@@YAAAUTStrRec@0@PAD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
??$GetRec@D@STRBUF@@YAAAUTStrRec@0@PAD@Z PROC		; STRBUF::GetRec<char>, COMDAT
; 442  : 	// 
; 443  : 	TStrRec* R = (TStrRec*)Str;
; 444  :     return R[-1];
  00000	8b 44 24 04	 mov	 eax, DWORD PTR _Str$[esp-4]
  00004	83 c0 f4	 add	 eax, -12		; fffffff4H
; 445  : }
  00007	c3		 ret	 0
??$GetRec@D@STRBUF@@YAAAUTStrRec@0@PAD@Z ENDP		; STRBUF::GetRec<char>
_TEXT	ENDS
PUBLIC	??$Alloc@D@STRBUF@@YAPADK@Z			; STRBUF::Alloc<char>
; Function compile flags: /Ogspy
;	COMDAT ??$Alloc@D@STRBUF@@YAPADK@Z
_TEXT	SEGMENT
_Size$ = 8						; size = 4
??$Alloc@D@STRBUF@@YAPADK@Z PROC			; STRBUF::Alloc<char>, COMDAT
; 379  : 	// 
 Size 
; 380  : 	// 
; 381  : 	if (Size == 0) return NULL;
  00000	8b 44 24 04	 mov	 eax, DWORD PTR _Size$[esp-4]
  00004	85 c0		 test	 eax, eax
  00006	75 01		 jne	 SHORT $LN2@Alloc@3
; 396  : 	return (TChar*)Buf;
; 397  : }
  00008	c3		 ret	 0
$LN2@Alloc@3:
; 382  : 
; 383  : 	#ifdef USE_BLOCKS_STRINGS
; 384  :         Size = ((Size / STRING_BLOCK_SIZE) + 1) * STRING_BLOCK_SIZE;
  00009	c1 e8 05	 shr	 eax, 5
  0000c	40		 inc	 eax
  0000d	c1 e0 05	 shl	 eax, 5
  00010	56		 push	 esi
  00011	8b f0		 mov	 esi, eax
; 385  : 	#endif
; 386  : 
; 387  : 	DWORD BufSize = (Size + 1) * sizeof(TChar) + sizeof(TStrRec);
  00013	8d 46 0d	 lea	 eax, DWORD PTR [esi+13]
; 388  : 	TStrRec* Buf = (TStrRec*)HEAP::Alloc(BufSize);
  00016	50		 push	 eax
  00017	e8 00 00 00 00	 call	 ?Alloc@HEAP@@YAPAXK@Z	; HEAP::Alloc
  0001c	59		 pop	 ecx
; 389  : 	if (Buf == NULL) return NULL;
  0001d	85 c0		 test	 eax, eax
  0001f	75 02		 jne	 SHORT $LN1@Alloc@3
  00021	5e		 pop	 esi
; 396  : 	return (TChar*)Buf;
; 397  : }
  00022	c3		 ret	 0
$LN1@Alloc@3:
; 390  : 
; 391  : 	Buf->Size     = Size;
; 392  : 	Buf->Length   = 0;
  00023	83 60 04 00	 and	 DWORD PTR [eax+4], 0
  00027	89 30		 mov	 DWORD PTR [eax], esi
; 393  : 	Buf->RefCount = 1;
  00029	c7 40 08 01 00
	00 00		 mov	 DWORD PTR [eax+8], 1
; 394  : 
; 395  : 	Buf++;
  00030	83 c0 0c	 add	 eax, 12			; 0000000cH
  00033	5e		 pop	 esi
; 396  : 	return (TChar*)Buf;
; 397  : }
  00034	c3		 ret	 0
??$Alloc@D@STRBUF@@YAPADK@Z ENDP			; STRBUF::Alloc<char>
_TEXT	ENDS
PUBLIC	?CompareEx@?$STRUTILS@D@@SAHPBD0K@Z		; STRUTILS<char>::CompareEx
; Function compile flags: /Ogspy
;	COMDAT ?CompareEx@?$STRUTILS@D@@SAHPBD0K@Z
_TEXT	SEGMENT
_Str1$ = 8						; size = 4
_Str2$ = 12						; size = 4
_CmpLen$ = 16						; size = 4
?CompareEx@?$STRUTILS@D@@SAHPBD0K@Z PROC		; STRUTILS<char>::CompareEx, COMDAT
; 73   : 	// 
; 74   : 
; 75   : 	if (Str1 == NULL || Str2 == NULL)
  00000	8b 54 24 04	 mov	 edx, DWORD PTR _Str1$[esp-4]
  00004	85 d2		 test	 edx, edx
  00006	74 08		 je	 SHORT $LN11@CompareEx
  00008	8b 4c 24 08	 mov	 ecx, DWORD PTR _Str2$[esp-4]
  0000c	85 c9		 test	 ecx, ecx
  0000e	75 0a		 jne	 SHORT $LN20@CompareEx
$LN11@CompareEx:
; 76   : 		return -1;
  00010	83 c8 ff	 or	 eax, -1
; 111  :     }
; 112  : }
  00013	c3		 ret	 0
$LL10@CompareEx:
; 101  : 				R = 1;
; 102  : 			else
; 103  : 				R = -1;
; 104  : 			return R;
; 105  : 		}
; 106  : 
; 107  : 		if (*S2 == 0) return 0;
  00014	84 c0		 test	 al, al
  00016	74 28		 je	 SHORT $LN17@CompareEx
; 108  : 
; 109  : 		S1++;
  00018	42		 inc	 edx
; 110  : 		S2++;
  00019	41		 inc	 ecx
$LN20@CompareEx:
  0001a	8a 01		 mov	 al, BYTE PTR [ecx]
  0001c	38 02		 cmp	 BYTE PTR [edx], al
  0001e	74 f4		 je	 SHORT $LL10@CompareEx
; 77   : 
; 78   : 	const TChar* S1 = Str1;
; 79   : 	const TChar* S2 = Str2;
; 80   :     DWORD Pos = 0;
; 81   : 	while(1)
; 82   : 	{
; 83   : 		Pos++;
; 84   : 
; 85   : 
; 86   : 
; 87   : 		if (*S1 != *S2)
; 88   : 		{
; 89   : 			int R;
; 90   : 			if (CmpLen)
  00020	83 7c 24 0c 00	 cmp	 DWORD PTR _CmpLen$[esp-4], 0
  00025	74 09		 je	 SHORT $LN7@CompareEx
; 91   : 			{
; 92   : 				// 
; 93   : 				// 0 
; 94   : 				if (*S2 == 0)
  00027	33 c0		 xor	 eax, eax
  00029	38 01		 cmp	 BYTE PTR [ecx], al
  0002b	0f 94 c0	 sete	 al
  0002e	48		 dec	 eax
; 111  :     }
; 112  : }
  0002f	c3		 ret	 0
$LN7@CompareEx:
; 95   : 					R = 0;
; 96   : 				else
; 97   : 					R = -1;
; 98   : 			}
; 99   : 			else
; 100  : 			if (*S1 > *S2)
  00030	8a 02		 mov	 al, BYTE PTR [edx]
  00032	33 d2		 xor	 edx, edx
  00034	3a 01		 cmp	 al, BYTE PTR [ecx]
  00036	0f 9f c2	 setg	 dl
  00039	8d 54 12 ff	 lea	 edx, DWORD PTR [edx+edx-1]
  0003d	8b c2		 mov	 eax, edx
; 111  :     }
; 112  : }
  0003f	c3		 ret	 0
$LN17@CompareEx:
; 101  : 				R = 1;
; 102  : 			else
; 103  : 				R = -1;
; 104  : 			return R;
; 105  : 		}
; 106  : 
; 107  : 		if (*S2 == 0) return 0;
  00040	33 c0		 xor	 eax, eax
; 111  :     }
; 112  : }
  00042	c3		 ret	 0
?CompareEx@?$STRUTILS@D@@SAHPBD0K@Z ENDP		; STRUTILS<char>::CompareEx
_TEXT	ENDS
PUBLIC	?WildCmp@@YA_NPBD0PAK11@Z			; WildCmp
; Function compile flags: /Ogspy
; File e:\projects\progs\petrosjan\bjwj\source\core\strwildcmp.cpp
;	COMDAT ?WildCmp@@YA_NPBD0PAK11@Z
_TEXT	SEGMENT
_WCR$ = -24						; size = 24
_Buffer$ = 8						; size = 4
_Mask$ = 12						; size = 4
_StartPos$ = 16						; size = 4
_EndPos$ = 20						; size = 4
_SubStrLen$ = 24					; size = 4
?WildCmp@@YA_NPBD0PAK11@Z PROC				; WildCmp, COMDAT
; 282  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
; 283  : 	// 
; 284  : 	if (StartPos)  *StartPos  = 0;
  00003	8b 45 10	 mov	 eax, DWORD PTR _StartPos$[ebp]
  00006	83 ec 18	 sub	 esp, 24			; 00000018H
  00009	53		 push	 ebx
  0000a	33 db		 xor	 ebx, ebx
  0000c	56		 push	 esi
  0000d	3b c3		 cmp	 eax, ebx
  0000f	74 02		 je	 SHORT $LN16@WildCmp
  00011	89 18		 mov	 DWORD PTR [eax], ebx
$LN16@WildCmp:
; 285  : 	if (EndPos)    *EndPos    = 0;
  00013	8b 45 14	 mov	 eax, DWORD PTR _EndPos$[ebp]
  00016	3b c3		 cmp	 eax, ebx
  00018	74 02		 je	 SHORT $LN15@WildCmp
  0001a	89 18		 mov	 DWORD PTR [eax], ebx
$LN15@WildCmp:
; 286  : 	if (SubStrLen) *SubStrLen = 0;
  0001c	8b 45 18	 mov	 eax, DWORD PTR _SubStrLen$[ebp]
  0001f	3b c3		 cmp	 eax, ebx
  00021	74 02		 je	 SHORT $LN14@WildCmp
  00023	89 18		 mov	 DWORD PTR [eax], ebx
$LN14@WildCmp:
; 287  : 
; 288  : 	if(STRA::IsEmpty(Mask))
  00025	8b 75 0c	 mov	 esi, DWORD PTR _Mask$[ebp]
  00028	56		 push	 esi
  00029	e8 00 00 00 00	 call	 ?IsEmpty@?$STRUTILS@D@@SA_NPBD@Z ; STRUTILS<char>::IsEmpty
  0002e	59		 pop	 ecx
  0002f	84 c0		 test	 al, al
  00031	74 0e		 je	 SHORT $LN13@WildCmp
; 289  : 		return STRA::IsEmpty(Buffer);
  00033	ff 75 08	 push	 DWORD PTR _Buffer$[ebp]
  00036	e8 00 00 00 00	 call	 ?IsEmpty@?$STRUTILS@D@@SA_NPBD@Z ; STRUTILS<char>::IsEmpty
  0003b	59		 pop	 ecx
  0003c	e9 aa 00 00 00	 jmp	 $LN17@WildCmp
$LN13@WildCmp:
  00041	57		 push	 edi
; 290  : 
; 291  : 	if(STRA::IsEmpty(Buffer))
  00042	8b 7d 08	 mov	 edi, DWORD PTR _Buffer$[ebp]
  00045	57		 push	 edi
  00046	e8 00 00 00 00	 call	 ?IsEmpty@?$STRUTILS@D@@SA_NPBD@Z ; STRUTILS<char>::IsEmpty
  0004b	59		 pop	 ecx
  0004c	84 c0		 test	 al, al
  0004e	74 07		 je	 SHORT $LN12@WildCmp
; 292  : 		return false;
  00050	32 c0		 xor	 al, al
  00052	e9 93 00 00 00	 jmp	 $LN26@WildCmp
$LN12@WildCmp:
; 293  : 
; 294  : 
; 295  : 	// 
; 296  : 	TWCR WCR;
; 297  : 	ClearStruct(WCR);
  00057	6a 18		 push	 24			; 00000018H
  00059	8d 45 e8	 lea	 eax, DWORD PTR _WCR$[ebp]
  0005c	53		 push	 ebx
  0005d	50		 push	 eax
  0005e	e8 00 00 00 00	 call	 ?m_memset@@YAXPBXEI@Z	; m_memset
; 298  : 
; 299  : 	WCR.Mask   = (PCHAR)Mask;
  00063	8b c6		 mov	 eax, esi
  00065	83 c4 0c	 add	 esp, 12			; 0000000cH
  00068	89 45 e8	 mov	 DWORD PTR _WCR$[ebp], eax
; 300  :     WCR.Buffer = (PCHAR)Buffer;
  0006b	89 7d ec	 mov	 DWORD PTR _WCR$[ebp+4], edi
; 301  : 
; 302  : 
; 303  : 	// 
; 304  : 	while (*WCR.Mask != 0 && WCR.Result == 0)
  0006e	38 1e		 cmp	 BYTE PTR [esi], bl
  00070	74 22		 je	 SHORT $LN22@WildCmp
$LL11@WildCmp:
  00072	39 5d fc	 cmp	 DWORD PTR _WCR$[ebp+20], ebx
  00075	75 1d		 jne	 SHORT $LN22@WildCmp
; 305  : 	{
; 306  : 		// 
; 307  : 		if (WC_IsMask(WCR.Mask))
  00077	80 38 2a	 cmp	 BYTE PTR [eax], 42	; 0000002aH
; 308  : 			WC_ProcessMask(WCR);
  0007a	8d 45 e8	 lea	 eax, DWORD PTR _WCR$[ebp]
  0007d	50		 push	 eax
  0007e	75 07		 jne	 SHORT $LN9@WildCmp
  00080	e8 00 00 00 00	 call	 ?WC_ProcessMask@@YAXAAUWILD_CMP_REC@@@Z ; WC_ProcessMask
; 309  : 		else
  00085	eb 05		 jmp	 SHORT $LN27@WildCmp
$LN9@WildCmp:
; 310  : 			WC_CompareLine(WCR);
  00087	e8 00 00 00 00	 call	 ?WC_CompareLine@@YAXAAUWILD_CMP_REC@@@Z ; WC_CompareLine
$LN27@WildCmp:
; 301  : 
; 302  : 
; 303  : 	// 
; 304  : 	while (*WCR.Mask != 0 && WCR.Result == 0)
  0008c	8b 45 e8	 mov	 eax, DWORD PTR _WCR$[ebp]
; 310  : 			WC_CompareLine(WCR);
  0008f	59		 pop	 ecx
  00090	38 18		 cmp	 BYTE PTR [eax], bl
  00092	75 de		 jne	 SHORT $LL11@WildCmp
$LN22@WildCmp:
; 311  : 	}
; 312  : 
; 313  : 	// 
; 314  : 	// 
; 315  : 	if (*WCR.Mask == 0)
  00094	33 f6		 xor	 esi, esi
  00096	46		 inc	 esi
  00097	38 18		 cmp	 BYTE PTR [eax], bl
  00099	75 03		 jne	 SHORT $LN25@WildCmp
; 316  : 		WCR.Result = 1;
  0009b	89 75 fc	 mov	 DWORD PTR _WCR$[ebp+20], esi
$LN25@WildCmp:
; 317  : 
; 318  : 	// 
; 319  : 	if (WCR.Result == 1)
  0009e	39 75 fc	 cmp	 DWORD PTR _WCR$[ebp+20], esi
  000a1	75 3f		 jne	 SHORT $LN1@WildCmp
; 320  : 	{
; 321  : 		if (!WCR.End && (EndPos || SubStrLen))
  000a3	8b 45 f4	 mov	 eax, DWORD PTR _WCR$[ebp+12]
  000a6	3b c3		 cmp	 eax, ebx
  000a8	75 11		 jne	 SHORT $LN24@WildCmp
  000aa	39 5d 14	 cmp	 DWORD PTR _EndPos$[ebp], ebx
  000ad	75 05		 jne	 SHORT $LN23@WildCmp
  000af	39 5d 18	 cmp	 DWORD PTR _SubStrLen$[ebp], ebx
  000b2	74 07		 je	 SHORT $LN24@WildCmp
$LN23@WildCmp:
; 322  : 			WCR.End = STRA::End(Buffer);
  000b4	57		 push	 edi
  000b5	e8 00 00 00 00	 call	 ?End@?$STRUTILS@D@@SAPADPBD@Z ; STRUTILS<char>::End
  000ba	59		 pop	 ecx
$LN24@WildCmp:
; 323  : 
; 324  : 		if (StartPos)  *StartPos  = WCR.Start - Buffer;
  000bb	8b 4d 10	 mov	 ecx, DWORD PTR _StartPos$[ebp]
  000be	3b cb		 cmp	 ecx, ebx
  000c0	74 07		 je	 SHORT $LN3@WildCmp
  000c2	8b 55 f0	 mov	 edx, DWORD PTR _WCR$[ebp+8]
  000c5	2b d7		 sub	 edx, edi
  000c7	89 11		 mov	 DWORD PTR [ecx], edx
$LN3@WildCmp:
; 325  : 		if (EndPos)    *EndPos    = WCR.End - Buffer;
  000c9	8b 4d 14	 mov	 ecx, DWORD PTR _EndPos$[ebp]
  000cc	3b cb		 cmp	 ecx, ebx
  000ce	74 06		 je	 SHORT $LN2@WildCmp
  000d0	8b d0		 mov	 edx, eax
  000d2	2b d7		 sub	 edx, edi
  000d4	89 11		 mov	 DWORD PTR [ecx], edx
$LN2@WildCmp:
; 326  : 		if (SubStrLen) *SubStrLen = WCR.End - WCR.Start;
  000d6	8b 4d 18	 mov	 ecx, DWORD PTR _SubStrLen$[ebp]
  000d9	3b cb		 cmp	 ecx, ebx
  000db	74 05		 je	 SHORT $LN1@WildCmp
  000dd	2b 45 f0	 sub	 eax, DWORD PTR _WCR$[ebp+8]
  000e0	89 01		 mov	 DWORD PTR [ecx], eax
$LN1@WildCmp:
; 327  : 	}
; 328  : 
; 329  : 	return WCR.Result == 1;
  000e2	33 c0		 xor	 eax, eax
  000e4	39 75 fc	 cmp	 DWORD PTR _WCR$[ebp+20], esi
  000e7	0f 94 c0	 sete	 al
$LN26@WildCmp:
  000ea	5f		 pop	 edi
$LN17@WildCmp:
  000eb	5e		 pop	 esi
  000ec	5b		 pop	 ebx
; 330  : }
  000ed	c9		 leave
  000ee	c3		 ret	 0
?WildCmp@@YA_NPBD0PAK11@Z ENDP				; WildCmp
_TEXT	ENDS
PUBLIC	?WildCmp@@YA_NPBD0@Z				; WildCmp
; Function compile flags: /Ogspy
;	COMDAT ?WildCmp@@YA_NPBD0@Z
_TEXT	SEGMENT
_S$ = -12						; size = 4
_E$ = -8						; size = 4
_L$ = -4						; size = 4
_Buffer$ = 8						; size = 4
_Mask$ = 12						; size = 4
?WildCmp@@YA_NPBD0@Z PROC				; WildCmp, COMDAT
; 335  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 0c	 sub	 esp, 12			; 0000000cH
; 336  : 	DWORD S;
; 337  : 	DWORD E;
; 338  : 	DWORD L;
; 339  : 	return WildCmp(Buffer, Mask, &S, &E, &L);
  00006	8d 45 fc	 lea	 eax, DWORD PTR _L$[ebp]
  00009	50		 push	 eax
  0000a	8d 45 f8	 lea	 eax, DWORD PTR _E$[ebp]
  0000d	50		 push	 eax
  0000e	8d 45 f4	 lea	 eax, DWORD PTR _S$[ebp]
  00011	50		 push	 eax
  00012	ff 75 0c	 push	 DWORD PTR _Mask$[ebp]
  00015	ff 75 08	 push	 DWORD PTR _Buffer$[ebp]
  00018	e8 00 00 00 00	 call	 ?WildCmp@@YA_NPBD0PAK11@Z ; WildCmp
  0001d	83 c4 14	 add	 esp, 20			; 00000014H
; 340  : }
  00020	c9		 leave
  00021	c3		 ret	 0
?WildCmp@@YA_NPBD0@Z ENDP				; WildCmp
_TEXT	ENDS
PUBLIC	?m_lstrlen@@YGKPBD@Z				; m_lstrlen
; Function compile flags: /Ogspy
; File e:\projects\progs\petrosjan\bjwj\source\core\strings.cpp
;	COMDAT ?m_lstrlen@@YGKPBD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?m_lstrlen@@YGKPBD@Z PROC				; m_lstrlen, COMDAT
; 24   : 	return STRA::Length(Str);
  00000	ff 74 24 04	 push	 DWORD PTR _Str$[esp-4]
  00004	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  00009	59		 pop	 ecx
; 25   : } 
  0000a	c2 04 00	 ret	 4
?m_lstrlen@@YGKPBD@Z ENDP				; m_lstrlen
_TEXT	ENDS
PUBLIC	?m_lstrcat@@YGXPADPBD@Z				; m_lstrcat
; Function compile flags: /Ogspy
;	COMDAT ?m_lstrcat@@YGXPADPBD@Z
_TEXT	SEGMENT
_szBuf$ = 8						; size = 4
_szStr$ = 12						; size = 4
?m_lstrcat@@YGXPADPBD@Z PROC				; m_lstrcat, COMDAT
; 30   : 	plstrcatA(szBuf, szStr);
  00000	ff 74 24 08	 push	 DWORD PTR _szStr$[esp-4]
  00004	ff 74 24 08	 push	 DWORD PTR _szBuf$[esp]
  00008	e8 00 00 00 00	 call	 ??$pushargEx@$00$0CMKBLFOG@$0HO@PADPBD@@YAPAXPADPBD@Z ; pushargEx<1,748795366,126,char *,char const *>
  0000d	59		 pop	 ecx
  0000e	59		 pop	 ecx
; 31   : } 
  0000f	c2 08 00	 ret	 8
?m_lstrcat@@YGXPADPBD@Z ENDP				; m_lstrcat
_TEXT	ENDS
PUBLIC	?m_lstrcmp@@YGKPBD0@Z				; m_lstrcmp
; Function compile flags: /Ogspy
;	COMDAT ?m_lstrcmp@@YGKPBD0@Z
_TEXT	SEGMENT
_szStr1$ = 8						; size = 4
_szStr2$ = 12						; size = 4
?m_lstrcmp@@YGKPBD0@Z PROC				; m_lstrcmp, COMDAT
; 36   : 	return (DWORD)plstrcmpA(szStr1, szStr2);
  00000	ff 74 24 08	 push	 DWORD PTR _szStr2$[esp-4]
  00004	ff 74 24 08	 push	 DWORD PTR _szStr1$[esp]
  00008	e8 00 00 00 00	 call	 ??$pushargEx@$00$0CMKCLHOG@$0HM@PBDPBD@@YAPAXPBD0@Z ; pushargEx<1,748861414,124,char const *,char const *>
  0000d	59		 pop	 ecx
  0000e	59		 pop	 ecx
; 37   : } 
  0000f	c2 08 00	 ret	 8
?m_lstrcmp@@YGKPBD0@Z ENDP				; m_lstrcmp
_TEXT	ENDS
PUBLIC	?m_lstrcpy@@YGXPADPBD@Z				; m_lstrcpy
; Function compile flags: /Ogspy
;	COMDAT ?m_lstrcpy@@YGXPADPBD@Z
_TEXT	SEGMENT
_szBuf$ = 8						; size = 4
_szStr$ = 12						; size = 4
?m_lstrcpy@@YGXPADPBD@Z PROC				; m_lstrcpy, COMDAT
; 42   : 	plstrcpyA(szBuf, szStr); 
  00000	ff 74 24 08	 push	 DWORD PTR _szStr$[esp-4]
  00004	ff 74 24 08	 push	 DWORD PTR _szBuf$[esp]
  00008	e8 00 00 00 00	 call	 ??$pushargEx@$00$0CMKFPDGG@$0IA@PADPBD@@YAPAXPADPBD@Z ; pushargEx<1,749073254,128,char *,char const *>
  0000d	59		 pop	 ecx
  0000e	59		 pop	 ecx
; 43   : } 
  0000f	c2 08 00	 ret	 8
?m_lstrcpy@@YGXPADPBD@Z ENDP				; m_lstrcpy
_TEXT	ENDS
PUBLIC	?m_lstrlwr@@YGXPAD@Z				; m_lstrlwr
; Function compile flags: /Ogspy
;	COMDAT ?m_lstrlwr@@YGXPAD@Z
_TEXT	SEGMENT
_str$ = 8						; size = 4
?m_lstrlwr@@YGXPAD@Z PROC				; m_lstrlwr, COMDAT
; 47   : {
  00000	56		 push	 esi
; 48   : 	if ( !str )
  00001	8b 74 24 08	 mov	 esi, DWORD PTR _str$[esp]
  00005	85 f6		 test	 esi, esi
  00007	74 25		 je	 SHORT $LN2@m_lstrlwr
; 49   : 	{
; 50   : 		return;
; 51   : 	}
; 52   : 
; 53   : 	int n = m_lstrlen( str );
  00009	56		 push	 esi
  0000a	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
; 54   : 	
; 55   : 	for(int i = 0; i < n; i++ )
  0000f	33 d2		 xor	 edx, edx
  00011	59		 pop	 ecx
  00012	85 c0		 test	 eax, eax
  00014	7e 18		 jle	 SHORT $LN2@m_lstrlwr
$LL4@m_lstrlwr:
; 56   : 	{
; 57   : 		if ( str[i] >= 65 && str[i] <= 90 )
  00016	8a 0c 32	 mov	 cl, BYTE PTR [edx+esi]
  00019	80 f9 41	 cmp	 cl, 65			; 00000041H
  0001c	7c 0b		 jl	 SHORT $LN3@m_lstrlwr
  0001e	80 f9 5a	 cmp	 cl, 90			; 0000005aH
  00021	7f 06		 jg	 SHORT $LN3@m_lstrlwr
; 58   : 		{
; 59   : 			str[i] += 32;
  00023	80 c1 20	 add	 cl, 32			; 00000020H
  00026	88 0c 32	 mov	 BYTE PTR [edx+esi], cl
$LN3@m_lstrlwr:
  00029	42		 inc	 edx
  0002a	3b d0		 cmp	 edx, eax
  0002c	7c e8		 jl	 SHORT $LL4@m_lstrlwr
$LN2@m_lstrlwr:
  0002e	5e		 pop	 esi
; 60   : 		}
; 61   : 	}
; 62   : }
  0002f	c2 04 00	 ret	 4
?m_lstrlwr@@YGXPAD@Z ENDP				; m_lstrlwr
_TEXT	ENDS
PUBLIC	?m_lstrncpy@@YG_NPADPBDK@Z			; m_lstrncpy
; Function compile flags: /Ogspy
;	COMDAT ?m_lstrncpy@@YG_NPADPBDK@Z
_TEXT	SEGMENT
_pString_src$ = 8					; size = 4
_pString_dst$ = 12					; size = 4
_len$ = 16						; size = 4
?m_lstrncpy@@YG_NPADPBDK@Z PROC				; m_lstrncpy, COMDAT
; 66   : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	56		 push	 esi
; 67   : 	if ( !pString_dst || !pString_src )
  00004	8b 75 0c	 mov	 esi, DWORD PTR _pString_dst$[ebp]
  00007	85 f6		 test	 esi, esi
  00009	74 37		 je	 SHORT $LN5@m_lstrncpy
  0000b	83 7d 08 00	 cmp	 DWORD PTR _pString_src$[ebp], 0
  0000f	74 31		 je	 SHORT $LN5@m_lstrncpy
; 70   : 	}
; 71   : 
; 72   : 	if ( m_lstrlen( (char*)pString_dst ) < len )
  00011	56		 push	 esi
  00012	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  00017	8b 55 10	 mov	 edx, DWORD PTR _len$[ebp]
  0001a	59		 pop	 ecx
  0001b	3b c2		 cmp	 eax, edx
  0001d	73 09		 jae	 SHORT $LN4@m_lstrncpy
; 73   : 	{
; 74   : 		len = m_lstrlen( (char*)pString_dst );
  0001f	56		 push	 esi
  00020	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  00025	59		 pop	 ecx
  00026	8b d0		 mov	 edx, eax
$LN4@m_lstrncpy:
; 75   : 	}
; 76   : 
; 77   : 	for ( DWORD i = 0; i < len; i++ )
  00028	85 d2		 test	 edx, edx
  0002a	76 12		 jbe	 SHORT $LN1@m_lstrncpy
  0002c	8b 45 08	 mov	 eax, DWORD PTR _pString_src$[ebp]
  0002f	8b ce		 mov	 ecx, esi
  00031	2b c8		 sub	 ecx, eax
  00033	8b f2		 mov	 esi, edx
$LL3@m_lstrncpy:
; 78   : 	{
; 79   : 		pString_src[i] = pString_dst[i];
  00035	8a 14 01	 mov	 dl, BYTE PTR [ecx+eax]
  00038	88 10		 mov	 BYTE PTR [eax], dl
  0003a	40		 inc	 eax
  0003b	4e		 dec	 esi
  0003c	75 f7		 jne	 SHORT $LL3@m_lstrncpy
$LN1@m_lstrncpy:
; 80   : 	}
; 81   : 
; 82   : 	return true;
  0003e	b0 01		 mov	 al, 1
  00040	eb 02		 jmp	 SHORT $LN7@m_lstrncpy
$LN5@m_lstrncpy:
; 68   : 	{
; 69   : 		return false;
  00042	32 c0		 xor	 al, al
$LN7@m_lstrncpy:
  00044	5e		 pop	 esi
; 83   : }
  00045	5d		 pop	 ebp
  00046	c2 0c 00	 ret	 12			; 0000000cH
?m_lstrncpy@@YG_NPADPBDK@Z ENDP				; m_lstrncpy
_TEXT	ENDS
PUBLIC	?m_strstr@@YGPADPBD0@Z				; m_strstr
; Function compile flags: /Ogspy
;	COMDAT ?m_strstr@@YGPADPBD0@Z
_TEXT	SEGMENT
_sslen$ = -4						; size = 4
_s$ = 8							; size = 4
__Str$ = 8						; size = 4
__SubStr$ = 12						; size = 4
?m_strstr@@YGPADPBD0@Z PROC				; m_strstr, COMDAT
; 192  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
; 193  : 	if( !_Str || !_SubStr )
  00004	83 7d 08 00	 cmp	 DWORD PTR __Str$[ebp], 0
  00008	53		 push	 ebx
  00009	56		 push	 esi
  0000a	57		 push	 edi
  0000b	74 52		 je	 SHORT $LN12@m_strstr
  0000d	83 7d 0c 00	 cmp	 DWORD PTR __SubStr$[ebp], 0
  00011	74 4c		 je	 SHORT $LN12@m_strstr
; 195  : 
; 196  : 	int f = 1;
; 197  : 	int s;
; 198  : 
; 199  : 	size_t sslen = m_lstrlen( (char*)_SubStr );
  00013	ff 75 0c	 push	 DWORD PTR __SubStr$[ebp]
  00016	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  0001b	59		 pop	 ecx
  0001c	8b 4d 0c	 mov	 ecx, DWORD PTR __SubStr$[ebp]
  0001f	89 45 fc	 mov	 DWORD PTR _sslen$[ebp], eax
; 200  : 
; 201  : 	for ( char* p = (char*)_Str; f;  p++ )
  00022	8b 45 08	 mov	 eax, DWORD PTR __Str$[ebp]
  00025	2b c8		 sub	 ecx, eax
$LL11@m_strstr:
; 202  : 	{
; 203  : 		char* k = (char*)_SubStr;
; 204  : 
; 205  : 		if ( *p == 0 )
  00027	8a 18		 mov	 bl, BYTE PTR [eax]
  00029	84 db		 test	 bl, bl
  0002b	74 32		 je	 SHORT $LN12@m_strstr
; 206  : 		{
; 207  : 			break;
; 208  : 		}
; 209  : 
; 210  : 		if ( *k == 0 )
  0002d	8b 55 0c	 mov	 edx, DWORD PTR __SubStr$[ebp]
  00030	8a 12		 mov	 dl, BYTE PTR [edx]
  00032	84 d2		 test	 dl, dl
  00034	74 29		 je	 SHORT $LN12@m_strstr
; 211  : 		{
; 212  : 			break;
; 213  : 		}
; 214  : 
; 215  : 		if ( *p == *k )
  00036	3a da		 cmp	 bl, dl
  00038	75 21		 jne	 SHORT $LN10@m_strstr
; 216  : 		{
; 217  : 			char* p1 = p;
; 218  : 			char* k1 = k;
; 219  : 
; 220  : 			s = 0;
  0003a	83 65 08 00	 and	 DWORD PTR _s$[ebp], 0
  0003e	8b f0		 mov	 esi, eax
$LL5@m_strstr:
; 221  : 
; 222  : 			for( ; true;  )
; 223  : 			{
; 224  : 				if( *p1 == *k1 )
  00040	8a 16		 mov	 dl, BYTE PTR [esi]
  00042	8a 1c 31	 mov	 bl, BYTE PTR [ecx+esi]
  00045	3a d3		 cmp	 dl, bl
  00047	75 03		 jne	 SHORT $LN3@m_strstr
; 225  : 				{
; 226  : 					s++;
  00049	ff 45 08	 inc	 DWORD PTR _s$[ebp]
$LN3@m_strstr:
; 227  : 				}
; 228  : 
; 229  : 				if( s == (int)sslen )
  0004c	8b 7d fc	 mov	 edi, DWORD PTR _sslen$[ebp]
  0004f	39 7d 08	 cmp	 DWORD PTR _s$[ebp], edi
  00052	74 0d		 je	 SHORT $LN14@m_strstr
; 230  : 				{
; 231  : 					return p;
; 232  : 				}
; 233  : 
; 234  : 				if( *p1 != *k1 )
  00054	3a d3		 cmp	 dl, bl
  00056	75 03		 jne	 SHORT $LN10@m_strstr
; 235  : 				{
; 236  : 					break;
; 237  : 				}
; 238  : 
; 239  : 				p1++;
  00058	46		 inc	 esi
; 240  : 				k1++;
; 241  : 			}
  00059	eb e5		 jmp	 SHORT $LL5@m_strstr
$LN10@m_strstr:
; 200  : 
; 201  : 	for ( char* p = (char*)_Str; f;  p++ )
  0005b	40		 inc	 eax
  0005c	49		 dec	 ecx
  0005d	eb c8		 jmp	 SHORT $LL11@m_strstr
$LN12@m_strstr:
; 194  : 		return NULL;
  0005f	33 c0		 xor	 eax, eax
$LN14@m_strstr:
  00061	5f		 pop	 edi
  00062	5e		 pop	 esi
  00063	5b		 pop	 ebx
; 242  : 
; 243  : 		}
; 244  : 	}
; 245  : 	return NULL;
; 246  : }
  00064	c9		 leave
  00065	c2 08 00	 ret	 8
?m_strstr@@YGPADPBD0@Z ENDP				; m_strstr
_TEXT	ENDS
PUBLIC	?m_istrstr@@YGHPBD0@Z				; m_istrstr
; Function compile flags: /Ogspy
;	COMDAT ?m_istrstr@@YGHPBD0@Z
_TEXT	SEGMENT
_j$ = 8							; size = 4
__Str$ = 8						; size = 4
_sslen$ = 12						; size = 4
__SubStr$ = 12						; size = 4
?m_istrstr@@YGHPBD0@Z PROC				; m_istrstr, COMDAT
; 249  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	53		 push	 ebx
  00004	56		 push	 esi
  00005	57		 push	 edi
; 250  : 	// 
 _SubStr 
; 251  : 	if( !_Str || !_SubStr )
  00006	8b 7d 08	 mov	 edi, DWORD PTR __Str$[ebp]
  00009	85 ff		 test	 edi, edi
  0000b	74 4d		 je	 SHORT $LN9@m_istrstr
  0000d	8b 75 0c	 mov	 esi, DWORD PTR __SubStr$[ebp]
  00010	85 f6		 test	 esi, esi
  00012	74 46		 je	 SHORT $LN9@m_istrstr
; 253  : 
; 254  : 	DWORD s;
; 255  : 	DWORD j = 0;
  00014	83 65 08 00	 and	 DWORD PTR _j$[ebp], 0
; 256  : 
; 257  :    //	size_t slen  = m_lstrlen( (char*)_Str );
; 258  : 	size_t sslen = m_lstrlen( (char*)_SubStr );
  00018	56		 push	 esi
  00019	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  0001e	59		 pop	 ecx
; 259  : 
; 260  : 	// 
; 261  : 	char *p = (char*)_Str;
; 262  : 	while (*p != 0)
  0001f	8a 0f		 mov	 cl, BYTE PTR [edi]
  00021	89 45 0c	 mov	 DWORD PTR _sslen$[ebp], eax
  00024	84 c9		 test	 cl, cl
  00026	74 32		 je	 SHORT $LN9@m_istrstr
  00028	8a 1e		 mov	 bl, BYTE PTR [esi]
  0002a	2b f7		 sub	 esi, edi
$LL8@m_istrstr:
; 263  : 	{
; 264  : 		char* k = (char*)_SubStr;
; 265  : 
; 266  : 		// 
; 267  : 		if ( *p == *k )
  0002c	3a cb		 cmp	 cl, bl
  0002e	75 1f		 jne	 SHORT $LN3@m_istrstr
; 268  : 		{
; 269  : 			char* p1 = p;
; 270  : 			char* k1 = k;
; 271  : 
; 272  : 			s = 0;
  00030	33 c0		 xor	 eax, eax
  00032	8b d7		 mov	 edx, edi
; 273  :             // 
; 274  : 			while(*p1 != 0 && *k1 != 0)
  00034	84 c9		 test	 cl, cl
  00036	74 17		 je	 SHORT $LN3@m_istrstr
$LL5@m_istrstr:
  00038	8a 0c 16	 mov	 cl, BYTE PTR [esi+edx]
  0003b	84 c9		 test	 cl, cl
  0003d	74 10		 je	 SHORT $LN3@m_istrstr
; 275  : 			{
; 276  : 				if (*p1 == *k1)
  0003f	38 0a		 cmp	 BYTE PTR [edx], cl
  00041	75 0c		 jne	 SHORT $LN3@m_istrstr
; 277  : 					s++;
  00043	40		 inc	 eax
; 278  : 				else
; 279  : 					break;
; 280  : 
; 281  : 				if (s == (DWORD)sslen)
  00044	3b 45 0c	 cmp	 eax, DWORD PTR _sslen$[ebp]
  00047	74 1b		 je	 SHORT $LN17@m_istrstr
; 283  : 
; 284  : 				p1++;
  00049	42		 inc	 edx
  0004a	80 3a 00	 cmp	 BYTE PTR [edx], 0
  0004d	75 e9		 jne	 SHORT $LL5@m_istrstr
$LN3@m_istrstr:
; 285  : 				k1++;
; 286  : 			}
; 287  : 		}
; 288  : 
; 289  : 		// 
; 290  : 		p++;
  0004f	47		 inc	 edi
  00050	8a 0f		 mov	 cl, BYTE PTR [edi]
  00052	4e		 dec	 esi
; 291  : 		j++;
  00053	ff 45 08	 inc	 DWORD PTR _j$[ebp]
  00056	84 c9		 test	 cl, cl
  00058	75 d2		 jne	 SHORT $LL8@m_istrstr
$LN9@m_istrstr:
; 252  : 		return -1;
  0005a	83 c8 ff	 or	 eax, -1
$LN11@m_istrstr:
  0005d	5f		 pop	 edi
  0005e	5e		 pop	 esi
  0005f	5b		 pop	 ebx
; 292  : 	}
; 293  : 	return -1;
; 294  : }
  00060	5d		 pop	 ebp
  00061	c2 08 00	 ret	 8
$LN17@m_istrstr:
; 282  : 					return j;
  00064	8b 45 08	 mov	 eax, DWORD PTR _j$[ebp]
  00067	eb f4		 jmp	 SHORT $LN11@m_istrstr
?m_istrstr@@YGHPBD0@Z ENDP				; m_istrstr
_TEXT	ENDS
PUBLIC	?AnsiToUnicode@@YAPA_WPADK@Z			; AnsiToUnicode
EXTRN	?MemFree@@YAXPAX@Z:PROC				; MemFree
EXTRN	?MemAlloc@@YAPAXK@Z:PROC			; MemAlloc
; Function compile flags: /Ogspy
;	COMDAT ?AnsiToUnicode@@YAPA_WPADK@Z
_TEXT	SEGMENT
_AnsiString$ = 8					; size = 4
_dwStrLen$ = 12						; size = 4
?AnsiToUnicode@@YAPA_WPADK@Z PROC			; AnsiToUnicode, COMDAT
; 322  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	53		 push	 ebx
  00004	56		 push	 esi
; 323  : 	wchar_t* res = 0;
; 324  : 	// 
; 325  : 	if( dwStrLen == 0 ) dwStrLen = -1;
  00005	33 f6		 xor	 esi, esi
  00007	39 75 0c	 cmp	 DWORD PTR _dwStrLen$[ebp], esi
  0000a	75 04		 jne	 SHORT $LN4@AnsiToUnic
  0000c	83 4d 0c ff	 or	 DWORD PTR _dwStrLen$[ebp], -1
$LN4@AnsiToUnic:
; 326  : 	int resLen = (int)pMultiByteToWideChar( CP_ACP, 0, AnsiString, dwStrLen, 0, 0);
  00010	56		 push	 esi
  00011	56		 push	 esi
  00012	ff 75 0c	 push	 DWORD PTR _dwStrLen$[ebp]
  00015	ff 75 08	 push	 DWORD PTR _AnsiString$[ebp]
  00018	56		 push	 esi
  00019	56		 push	 esi
  0001a	e8 00 00 00 00	 call	 ??$pushargEx@$00$0FKKHOHAL@$0DB@HHPADKHH@@YAPAXHHPADKHH@Z ; pushargEx<1,1520953099,49,int,int,char *,unsigned long,int,int>
  0001f	8b d8		 mov	 ebx, eax
  00021	83 c4 18	 add	 esp, 24			; 00000018H
; 327  : 	if( resLen == 0 ) return 0;
  00024	3b de		 cmp	 ebx, esi
  00026	75 04		 jne	 SHORT $LN3@AnsiToUnic
  00028	33 c0		 xor	 eax, eax
  0002a	eb 33		 jmp	 SHORT $LN5@AnsiToUnic
$LN3@AnsiToUnic:
  0002c	57		 push	 edi
; 328  :  	// 
; 329  : 	res = (wchar_t*)MemAlloc(resLen);
  0002d	53		 push	 ebx
  0002e	e8 00 00 00 00	 call	 ?MemAlloc@@YAPAXK@Z	; MemAlloc
  00033	8b f8		 mov	 edi, eax
  00035	59		 pop	 ecx
; 330  :  	if( res == 0 ) return 0;
  00036	3b fe		 cmp	 edi, esi
  00038	75 04		 jne	 SHORT $LN2@AnsiToUnic
  0003a	33 c0		 xor	 eax, eax
  0003c	eb 20		 jmp	 SHORT $LN7@AnsiToUnic
$LN2@AnsiToUnic:
; 331  : 	// 
; 332  : 	if( !pMultiByteToWideChar( CP_ACP, 0, AnsiString, -1, res, resLen ) )
  0003e	53		 push	 ebx
  0003f	57		 push	 edi
  00040	6a ff		 push	 -1
  00042	ff 75 08	 push	 DWORD PTR _AnsiString$[ebp]
  00045	56		 push	 esi
  00046	56		 push	 esi
  00047	e8 00 00 00 00	 call	 ??$pushargEx@$00$0FKKHOHAL@$0DB@HHPADHPA_WH@@YAPAXHHPADHPA_WH@Z ; pushargEx<1,1520953099,49,int,int,char *,int,wchar_t *,int>
  0004c	83 c4 18	 add	 esp, 24			; 00000018H
  0004f	85 c0		 test	 eax, eax
  00051	75 09		 jne	 SHORT $LN1@AnsiToUnic
; 333  : 	{
; 334  : 		MemFree(res);
  00053	57		 push	 edi
  00054	e8 00 00 00 00	 call	 ?MemFree@@YAXPAX@Z	; MemFree
  00059	59		 pop	 ecx
; 335  : 		res = 0;
  0005a	33 ff		 xor	 edi, edi
$LN1@AnsiToUnic:
; 336  : 	}
; 337  :  	return res;
  0005c	8b c7		 mov	 eax, edi
$LN7@AnsiToUnic:
  0005e	5f		 pop	 edi
$LN5@AnsiToUnic:
  0005f	5e		 pop	 esi
  00060	5b		 pop	 ebx
; 338  : }
  00061	5d		 pop	 ebp
  00062	c3		 ret	 0
?AnsiToUnicode@@YAPA_WPADK@Z ENDP			; AnsiToUnicode
_TEXT	ENDS
PUBLIC	?UTF8ToUnicode@@YAPA_WPBD@Z			; UTF8ToUnicode
; Function compile flags: /Ogspy
;	COMDAT ?UTF8ToUnicode@@YAPA_WPBD@Z
_TEXT	SEGMENT
_utf8String$ = 8					; size = 4
?UTF8ToUnicode@@YAPA_WPBD@Z PROC			; UTF8ToUnicode, COMDAT
; 341  : {
  00000	56		 push	 esi
  00001	57		 push	 edi
; 342  : 	wchar_t* res = 0;
; 343  : 	// 
; 344  : 	int resLen = (int)pMultiByteToWideChar( CP_UTF8, 0, utf8String, -1, 0, 0);
  00002	6a 00		 push	 0
  00004	6a 00		 push	 0
  00006	6a ff		 push	 -1
  00008	ff 74 24 18	 push	 DWORD PTR _utf8String$[esp+16]
  0000c	be e9 fd 00 00	 mov	 esi, 65001		; 0000fde9H
  00011	6a 00		 push	 0
  00013	56		 push	 esi
  00014	e8 00 00 00 00	 call	 ??$pushargEx@$00$0FKKHOHAL@$0DB@HHPBDHHH@@YAPAXHHPBDHHH@Z ; pushargEx<1,1520953099,49,int,int,char const *,int,int,int>
  00019	8b f8		 mov	 edi, eax
  0001b	83 c4 18	 add	 esp, 24			; 00000018H
; 345  : 	if( resLen == 0 ) return 0;
  0001e	85 ff		 test	 edi, edi
  00020	74 31		 je	 SHORT $LN4@UTF8ToUnic
$LN3@UTF8ToUnic:
  00022	53		 push	 ebx
; 346  :  	// 
; 347  : 	res = (wchar_t*)WSTR::Alloc(resLen);
  00023	57		 push	 edi
  00024	e8 00 00 00 00	 call	 ?Alloc@WSTR@@YAPA_WK@Z	; WSTR::Alloc
  00029	8b d8		 mov	 ebx, eax
  0002b	59		 pop	 ecx
; 348  :  	if( res == 0 ) return 0;
  0002c	85 db		 test	 ebx, ebx
  0002e	74 22		 je	 SHORT $LN6@UTF8ToUnic
$LN2@UTF8ToUnic:
; 349  : 	// 
; 350  : 	if( !pMultiByteToWideChar( CP_UTF8, 0, utf8String, -1, res, resLen ) )
  00030	57		 push	 edi
  00031	53		 push	 ebx
  00032	6a ff		 push	 -1
  00034	ff 74 24 1c	 push	 DWORD PTR _utf8String$[esp+20]
  00038	6a 00		 push	 0
  0003a	56		 push	 esi
  0003b	e8 00 00 00 00	 call	 ??$pushargEx@$00$0FKKHOHAL@$0DB@HHPBDHPA_WH@@YAPAXHHPBDHPA_WH@Z ; pushargEx<1,1520953099,49,int,int,char const *,int,wchar_t *,int>
  00040	83 c4 18	 add	 esp, 24			; 00000018H
  00043	85 c0		 test	 eax, eax
  00045	75 09		 jne	 SHORT $LN1@UTF8ToUnic
; 351  : 	{
; 352  : 		WSTR::Free(res);
  00047	53		 push	 ebx
  00048	e8 00 00 00 00	 call	 ?Free@WSTR@@YAXPA_W@Z	; WSTR::Free
  0004d	59		 pop	 ecx
; 353  : 		res = 0;
  0004e	33 db		 xor	 ebx, ebx
$LN1@UTF8ToUnic:
; 354  : 	}
; 355  :  	return res;
  00050	8b c3		 mov	 eax, ebx
$LN6@UTF8ToUnic:
  00052	5b		 pop	 ebx
$LN4@UTF8ToUnic:
  00053	5f		 pop	 edi
  00054	5e		 pop	 esi
; 356  : }
  00055	c3		 ret	 0
?UTF8ToUnicode@@YAPA_WPBD@Z ENDP			; UTF8ToUnicode
_TEXT	ENDS
PUBLIC	?UTF8ToAnsi@@YAPADPBD@Z				; UTF8ToAnsi
; Function compile flags: /Ogspy
;	COMDAT ?UTF8ToAnsi@@YAPADPBD@Z
_TEXT	SEGMENT
_unicodeString$ = -4					; size = 4
_utf8String$ = 8					; size = 4
?UTF8ToAnsi@@YAPADPBD@Z PROC				; UTF8ToAnsi, COMDAT
; 359  : {
  00000	51		 push	 ecx
  00001	56		 push	 esi
  00002	57		 push	 edi
; 360  : 	//
 utf8 
 unicode
; 361  : 	wchar_t* unicodeString = UTF8ToUnicode(utf8String);
  00003	ff 74 24 10	 push	 DWORD PTR _utf8String$[esp+8]
  00007	e8 00 00 00 00	 call	 ?UTF8ToUnicode@@YAPA_WPBD@Z ; UTF8ToUnicode
  0000c	8b f8		 mov	 edi, eax
; 362  : 	if( unicodeString == 0 ) return 0;
  0000e	33 f6		 xor	 esi, esi
  00010	59		 pop	 ecx
  00011	89 7c 24 08	 mov	 DWORD PTR _unicodeString$[esp+12], edi
  00015	3b fe		 cmp	 edi, esi
  00017	75 04		 jne	 SHORT $LN4@UTF8ToAnsi
  00019	33 c0		 xor	 eax, eax
  0001b	eb 64		 jmp	 SHORT $LN5@UTF8ToAnsi
$LN4@UTF8ToAnsi:
  0001d	53		 push	 ebx
; 363  : 	char* res = 0;  
; 364  : 	// 
; 365  : 	int resLen = (int)pWideCharToMultiByte( 1251, 0, unicodeString, -1, 0, 0, 0, 0 );
  0001e	6a 30		 push	 48			; 00000030H
  00020	68 ee 57 4f e7	 push	 -414230546		; e74f57eeH
  00025	6a 01		 push	 1
  00027	56		 push	 esi
  00028	e8 00 00 00 00	 call	 ?GetProcAddressEx2@@YAPAXPADKKH@Z ; GetProcAddressEx2
  0002d	83 c4 10	 add	 esp, 16			; 00000010H
  00030	56		 push	 esi
  00031	56		 push	 esi
  00032	56		 push	 esi
  00033	56		 push	 esi
  00034	6a ff		 push	 -1
  00036	57		 push	 edi
  00037	56		 push	 esi
  00038	bf e3 04 00 00	 mov	 edi, 1251		; 000004e3H
  0003d	57		 push	 edi
  0003e	ff d0		 call	 eax
  00040	8b d8		 mov	 ebx, eax
; 366  : 	if( resLen == 0 ) return 0;
  00042	3b de		 cmp	 ebx, esi
  00044	75 04		 jne	 SHORT $LN3@UTF8ToAnsi
  00046	33 c0		 xor	 eax, eax
  00048	eb 36		 jmp	 SHORT $LN9@UTF8ToAnsi
$LN3@UTF8ToAnsi:
  0004a	55		 push	 ebp
; 367  : 	// 
; 368  : 	res = STR::Alloc(resLen);
  0004b	53		 push	 ebx
  0004c	e8 00 00 00 00	 call	 ?Alloc@STR@@YAPADK@Z	; STR::Alloc
  00051	8b e8		 mov	 ebp, eax
  00053	59		 pop	 ecx
; 369  :  	if( !res ) return 0;
  00054	3b ee		 cmp	 ebp, esi
  00056	75 04		 jne	 SHORT $LN2@UTF8ToAnsi
  00058	33 c0		 xor	 eax, eax
  0005a	eb 23		 jmp	 SHORT $LN10@UTF8ToAnsi
$LN2@UTF8ToAnsi:
; 370  : 	// 
; 371  : 	if( !pWideCharToMultiByte( 1251, 0, unicodeString, -1, res, resLen, 0, 0))
  0005c	56		 push	 esi
  0005d	56		 push	 esi
  0005e	53		 push	 ebx
  0005f	55		 push	 ebp
  00060	6a ff		 push	 -1
  00062	ff 74 24 24	 push	 DWORD PTR _unicodeString$[esp+40]
  00066	56		 push	 esi
  00067	57		 push	 edi
  00068	e8 00 00 00 00	 call	 ??$pushargEx@$00$0OHEPFHOO@$0DA@HHPA_WHPADHHH@@YAPAXHHPA_WHPADHHH@Z ; pushargEx<1,3880736750,48,int,int,wchar_t *,int,char *,int,int,int>
  0006d	83 c4 20	 add	 esp, 32			; 00000020H
  00070	85 c0		 test	 eax, eax
  00072	75 09		 jne	 SHORT $LN1@UTF8ToAnsi
; 372  : 	{
; 373  : 		STR::Free(res);
  00074	55		 push	 ebp
  00075	e8 00 00 00 00	 call	 ?Free@STR@@YAXPAD@Z	; STR::Free
  0007a	59		 pop	 ecx
; 374  : 		res = 0;
  0007b	33 ed		 xor	 ebp, ebp
$LN1@UTF8ToAnsi:
; 375  : 	}
; 376  : 	return res;
  0007d	8b c5		 mov	 eax, ebp
$LN10@UTF8ToAnsi:
  0007f	5d		 pop	 ebp
$LN9@UTF8ToAnsi:
  00080	5b		 pop	 ebx
$LN5@UTF8ToAnsi:
  00081	5f		 pop	 edi
  00082	5e		 pop	 esi
; 377  : }
  00083	59		 pop	 ecx
  00084	c3		 ret	 0
?UTF8ToAnsi@@YAPADPBD@Z ENDP				; UTF8ToAnsi
_TEXT	ENDS
PUBLIC	?trimall@@YAPADPADD@Z				; trimall
; Function compile flags: /Ogspy
;	COMDAT ?trimall@@YAPADPADD@Z
_TEXT	SEGMENT
_s$ = 8							; size = 4
_c$ = 12						; size = 1
?trimall@@YAPADPADD@Z PROC				; trimall, COMDAT
; 535  : {
  00000	53		 push	 ebx
  00001	56		 push	 esi
; 536  : 	int len = m_lstrlen(s);
  00002	8b 74 24 0c	 mov	 esi, DWORD PTR _s$[esp+4]
  00006	57		 push	 edi
  00007	56		 push	 esi
  00008	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
; 537  : 	char* p1 = s;
; 538  : 	while( *p1 == c && *p1 != 0 ) p1++;
  0000d	8a 54 24 18	 mov	 dl, BYTE PTR _c$[esp+12]
  00011	59		 pop	 ecx
  00012	8a 0e		 mov	 cl, BYTE PTR [esi]
  00014	8b de		 mov	 ebx, esi
  00016	eb 07		 jmp	 SHORT $LN13@trimall
$LL4@trimall:
  00018	84 c9		 test	 cl, cl
  0001a	74 07		 je	 SHORT $LN3@trimall
  0001c	43		 inc	 ebx
  0001d	8a 0b		 mov	 cl, BYTE PTR [ebx]
$LN13@trimall:
  0001f	3a ca		 cmp	 cl, dl
  00021	74 f5		 je	 SHORT $LL4@trimall
$LN3@trimall:
; 539  : 	char* p2 = s + len - 1;
  00023	8d 44 30 ff	 lea	 eax, DWORD PTR [eax+esi-1]
  00027	eb 05		 jmp	 SHORT $LN14@trimall
$LL2@trimall:
; 540  : 	while( *p2 == c && p2 > p1 ) p2--;
  00029	3b c3		 cmp	 eax, ebx
  0002b	76 05		 jbe	 SHORT $LN1@trimall
  0002d	48		 dec	 eax
$LN14@trimall:
  0002e	38 10		 cmp	 BYTE PTR [eax], dl
  00030	74 f7		 je	 SHORT $LL2@trimall
$LN1@trimall:
; 541  : 	len = p2 - p1 + 1;
  00032	2b c3		 sub	 eax, ebx
  00034	40		 inc	 eax
  00035	8b f8		 mov	 edi, eax
; 542  : 	m_memcpy( s, p1, len );
  00037	57		 push	 edi
  00038	53		 push	 ebx
  00039	56		 push	 esi
  0003a	e8 00 00 00 00	 call	 ?m_memcpy@@YAPAXPAXPBXH@Z ; m_memcpy
  0003f	83 c4 0c	 add	 esp, 12			; 0000000cH
; 543  : 	s[len] = 0;
  00042	c6 04 37 00	 mov	 BYTE PTR [edi+esi], 0
  00046	5f		 pop	 edi
; 544  : 	return s;
  00047	8b c6		 mov	 eax, esi
  00049	5e		 pop	 esi
  0004a	5b		 pop	 ebx
; 545  : }
  0004b	c3		 ret	 0
?trimall@@YAPADPADD@Z ENDP				; trimall
_TEXT	ENDS
PUBLIC	?CompareUrl@@YA_NPBD0@Z				; CompareUrl
; Function compile flags: /Ogspy
;	COMDAT ?CompareUrl@@YA_NPBD0@Z
_TEXT	SEGMENT
_dwStart$ = -12						; size = 4
_dwEnd$ = -8						; size = 4
_dwLen$ = -4						; size = 4
_MaskUrl$ = 8						; size = 4
_Url$ = 12						; size = 4
?CompareUrl@@YA_NPBD0@Z PROC				; CompareUrl, COMDAT
; 550  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 0c	 sub	 esp, 12			; 0000000cH
; 551  : 	DWORD dwStart = 0;
; 552  : 	DWORD dwEnd	  = 0;
; 553  : 	DWORD dwLen	  = 0;
; 554  : 
; 555  : 	if (WildCmp( Url, MaskUrl, &dwStart, &dwEnd, &dwLen ) )
  00006	8d 45 fc	 lea	 eax, DWORD PTR _dwLen$[ebp]
  00009	50		 push	 eax
  0000a	8d 45 f8	 lea	 eax, DWORD PTR _dwEnd$[ebp]
  0000d	50		 push	 eax
  0000e	8d 45 f4	 lea	 eax, DWORD PTR _dwStart$[ebp]
  00011	50		 push	 eax
  00012	ff 75 08	 push	 DWORD PTR _MaskUrl$[ebp]
  00015	ff 75 0c	 push	 DWORD PTR _Url$[ebp]
  00018	e8 00 00 00 00	 call	 ?WildCmp@@YA_NPBD0PAK11@Z ; WildCmp
  0001d	83 c4 14	 add	 esp, 20			; 00000014H
  00020	84 c0		 test	 al, al
  00022	0f 95 c0	 setne	 al
; 556  : 	{
; 557  : 		return true;
; 558  : 	}
; 559  : 
; 560  : 	return false;
; 561  : }
  00025	c9		 leave
  00026	c3		 ret	 0
?CompareUrl@@YA_NPBD0@Z ENDP				; CompareUrl
_TEXT	ENDS
PUBLIC	?SafeCopyStr@@YAPADPADHPBD@Z			; SafeCopyStr
; Function compile flags: /Ogspy
;	COMDAT ?SafeCopyStr@@YAPADPADHPBD@Z
_TEXT	SEGMENT
_dst$ = 8						; size = 4
_szDst$ = 12						; size = 4
_src$ = 16						; size = 4
?SafeCopyStr@@YAPADPADHPBD@Z PROC			; SafeCopyStr, COMDAT
; 564  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	53		 push	 ebx
  00004	57		 push	 edi
; 565  : 	if( dst == 0 || szDst <= 0 ) return 0;
  00005	8b 7d 08	 mov	 edi, DWORD PTR _dst$[ebp]
  00008	85 ff		 test	 edi, edi
  0000a	74 3f		 je	 SHORT $LN3@SafeCopySt
  0000c	8b 5d 0c	 mov	 ebx, DWORD PTR _szDst$[ebp]
  0000f	85 db		 test	 ebx, ebx
  00011	7e 38		 jle	 SHORT $LN3@SafeCopySt
; 566  : 	if( src == 0 ) 
  00013	83 7d 10 00	 cmp	 DWORD PTR _src$[ebp], 0
  00017	75 07		 jne	 SHORT $LN2@SafeCopySt
; 567  : 	{
; 568  : 		dst[0] = 0;
  00019	c6 07 00	 mov	 BYTE PTR [edi], 0
; 569  : 		return dst;
  0001c	8b c7		 mov	 eax, edi
  0001e	eb 2d		 jmp	 SHORT $LN5@SafeCopySt
$LN2@SafeCopySt:
  00020	56		 push	 esi
; 570  : 	}
; 571  : 	int len = m_lstrlen(src);
  00021	ff 75 10	 push	 DWORD PTR _src$[ebp]
  00024	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  00029	8b f0		 mov	 esi, eax
; 572  : 	if( len > szDst - 1 ) len = szDst - 1;
  0002b	8d 43 ff	 lea	 eax, DWORD PTR [ebx-1]
  0002e	3b f0		 cmp	 esi, eax
  00030	59		 pop	 ecx
  00031	7e 02		 jle	 SHORT $LN1@SafeCopySt
  00033	8b f0		 mov	 esi, eax
$LN1@SafeCopySt:
; 573  : 	m_memcpy( dst, src, len );
  00035	56		 push	 esi
  00036	ff 75 10	 push	 DWORD PTR _src$[ebp]
  00039	57		 push	 edi
  0003a	e8 00 00 00 00	 call	 ?m_memcpy@@YAPAXPAXPBXH@Z ; m_memcpy
  0003f	83 c4 0c	 add	 esp, 12			; 0000000cH
; 574  : 	dst[len] = 0;
  00042	c6 04 3e 00	 mov	 BYTE PTR [esi+edi], 0
; 575  : 	return dst;
  00046	8b c7		 mov	 eax, edi
  00048	5e		 pop	 esi
  00049	eb 02		 jmp	 SHORT $LN5@SafeCopySt
$LN3@SafeCopySt:
; 565  : 	if( dst == 0 || szDst <= 0 ) return 0;
  0004b	33 c0		 xor	 eax, eax
$LN5@SafeCopySt:
  0004d	5f		 pop	 edi
  0004e	5b		 pop	 ebx
; 576  : }
  0004f	5d		 pop	 ebp
  00050	c3		 ret	 0
?SafeCopyStr@@YAPADPADHPBD@Z ENDP			; SafeCopyStr
_TEXT	ENDS
PUBLIC	?StrCalcLength@@YAKPBD@Z			; StrCalcLength
; Function compile flags: /Ogspy
;	COMDAT ?StrCalcLength@@YAKPBD@Z
_TEXT	SEGMENT
_Buf$ = 8						; size = 4
?StrCalcLength@@YAKPBD@Z PROC				; StrCalcLength, COMDAT
; 685  : 	return STRA::Length(Buf);
  00000	e9 00 00 00 00	 jmp	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
?StrCalcLength@@YAKPBD@Z ENDP				; StrCalcLength
_TEXT	ENDS
PUBLIC	?StrCalcLengthW@@YAKPB_W@Z			; StrCalcLengthW
; Function compile flags: /Ogspy
;	COMDAT ?StrCalcLengthW@@YAKPB_W@Z
_TEXT	SEGMENT
_Buf$ = 8						; size = 4
?StrCalcLengthW@@YAKPB_W@Z PROC				; StrCalcLengthW, COMDAT
; 690  : 	return STRW::Length(Buf);
  00000	e9 00 00 00 00	 jmp	 ?Length@?$STRUTILS@_W@@SAKPB_W@Z ; STRUTILS<wchar_t>::Length
?StrCalcLengthW@@YAKPB_W@Z ENDP				; StrCalcLengthW
_TEXT	ENDS
PUBLIC	?New@STR@@YAPADPADK@Z				; STR::New
; Function compile flags: /Ogspy
;	COMDAT ?New@STR@@YAPADPADK@Z
_TEXT	SEGMENT
_Source$ = 8						; size = 4
_Len$ = 12						; size = 4
?New@STR@@YAPADPADK@Z PROC				; STR::New, COMDAT
; 697  : 	// 
 Source.
; 698  : 	// Len - 
; 699  : 	//       
; 700  : 
; 701  : 	if (Source == NULL) return NULL;
  00000	83 7c 24 04 00	 cmp	 DWORD PTR _Source$[esp-4], 0
  00005	75 03		 jne	 SHORT $LN4@New
  00007	33 c0		 xor	 eax, eax
; 711  : }
  00009	c3		 ret	 0
$LN4@New:
  0000a	56		 push	 esi
; 702  : 
; 703  : 	if (Len == 0) Len = StrCalcLength(Source);
  0000b	8b 74 24 0c	 mov	 esi, DWORD PTR _Len$[esp]
  0000f	85 f6		 test	 esi, esi
  00011	75 12		 jne	 SHORT $LN2@New
  00013	ff 74 24 08	 push	 DWORD PTR _Source$[esp]
  00017	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  0001c	8b f0		 mov	 esi, eax
  0001e	59		 pop	 ecx
; 704  : 	if (Len == 0) return NULL;
  0001f	85 f6		 test	 esi, esi
  00021	75 02		 jne	 SHORT $LN2@New
  00023	5e		 pop	 esi
; 711  : }
  00024	c3		 ret	 0
$LN2@New:
  00025	57		 push	 edi
; 705  : 
; 706  : 	PCHAR Str = STR::Alloc(Len);
  00026	56		 push	 esi
  00027	e8 00 00 00 00	 call	 ?Alloc@STR@@YAPADK@Z	; STR::Alloc
  0002c	8b f8		 mov	 edi, eax
  0002e	59		 pop	 ecx
; 707  : 	if (Str != NULL)
  0002f	85 ff		 test	 edi, edi
  00031	74 0e		 je	 SHORT $LN1@New
; 708  : 		m_memcpy(Str, Source, Len);
  00033	56		 push	 esi
  00034	ff 74 24 10	 push	 DWORD PTR _Source$[esp+8]
  00038	57		 push	 edi
  00039	e8 00 00 00 00	 call	 ?m_memcpy@@YAPAXPAXPBXH@Z ; m_memcpy
  0003e	83 c4 0c	 add	 esp, 12			; 0000000cH
$LN1@New:
; 709  : 
; 710  : 	return Str;
  00041	8b c7		 mov	 eax, edi
  00043	5f		 pop	 edi
  00044	5e		 pop	 esi
; 711  : }
  00045	c3		 ret	 0
?New@STR@@YAPADPADK@Z ENDP				; STR::New
_TEXT	ENDS
PUBLIC	?Length@STR@@YAKPAD@Z				; STR::Length
; Function compile flags: /Ogspy
;	COMDAT ?Length@STR@@YAKPAD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?Length@STR@@YAKPAD@Z PROC				; STR::Length, COMDAT
; 733  : 	// 
; 734  : 	// 
 STR::New 
; 735  : 	// 
; 736  : 
; 737  : 	if (Str == NULL)
  00000	8b 54 24 04	 mov	 edx, DWORD PTR _Str$[esp-4]
  00004	85 d2		 test	 edx, edx
  00006	75 03		 jne	 SHORT $LN3@Length@3
; 738  : 		return 0;
  00008	33 c0		 xor	 eax, eax
; 744  : 
; 745  : }
  0000a	c3		 ret	 0
$LN3@Length@3:
; 739  : 
; 740  : 	if (STRHEAD::CheckSignature(Str))
  0000b	52		 push	 edx
  0000c	e8 00 00 00 00	 call	 ?CheckSignature@STRHEAD@@YA_NPAX@Z ; STRHEAD::CheckSignature
  00011	59		 pop	 ecx
  00012	84 c0		 test	 al, al
  00014	74 04		 je	 SHORT $LN2@Length@3
; 741  : 		return STRHEAD::GetLength(Str);
  00016	8b 42 fc	 mov	 eax, DWORD PTR [edx-4]
; 744  : 
; 745  : }
  00019	c3		 ret	 0
$LN2@Length@3:
; 742  : 	else
; 743  : 		return StrCalcLength(Str);
  0001a	52		 push	 edx
  0001b	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  00020	59		 pop	 ecx
; 744  : 
; 745  : }
  00021	c3		 ret	 0
?Length@STR@@YAKPAD@Z ENDP				; STR::Length
_TEXT	ENDS
PUBLIC	?UpdateLength@STR@@YAXPADK@Z			; STR::UpdateLength
; Function compile flags: /Ogspy
;	COMDAT ?UpdateLength@STR@@YAXPADK@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_RealLength$ = 12					; size = 4
?UpdateLength@STR@@YAXPADK@Z PROC			; STR::UpdateLength, COMDAT
; 749  : {
  00000	56		 push	 esi
; 750  : 	// 
; 751  : 	// !!!!
 STR::Alloc (STR::New)
; 752  : 	// 
 RealLength 
; 753  : 	// 
; 754  : 	if (!STRHEAD::CheckSignature(Str)) return;
  00001	8b 74 24 08	 mov	 esi, DWORD PTR _Str$[esp]
  00005	56		 push	 esi
  00006	e8 00 00 00 00	 call	 ?CheckSignature@STRHEAD@@YA_NPAX@Z ; STRHEAD::CheckSignature
  0000b	59		 pop	 ecx
  0000c	84 c0		 test	 al, al
  0000e	74 16		 je	 SHORT $LN7@UpdateLeng
; 755  : 	if (RealLength == 0)
  00010	8b 44 24 0c	 mov	 eax, DWORD PTR _RealLength$[esp]
  00014	85 c0		 test	 eax, eax
  00016	75 07		 jne	 SHORT $LN1@UpdateLeng
; 756  : 		RealLength = StrCalcLength(Str);
  00018	56		 push	 esi
  00019	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  0001e	59		 pop	 ecx
$LN1@UpdateLeng:
; 757  :     STRHEAD::SetLength(Str, RealLength);
  0001f	89 46 fc	 mov	 DWORD PTR [esi-4], eax
  00022	c6 04 06 00	 mov	 BYTE PTR [esi+eax], 0
$LN7@UpdateLeng:
  00026	5e		 pop	 esi
; 758  : }
  00027	c3		 ret	 0
?UpdateLength@STR@@YAXPADK@Z ENDP			; STR::UpdateLength
_TEXT	ENDS
PUBLIC	?Delete@STR@@YAXPADKKK@Z			; STR::Delete
; Function compile flags: /Ogspy
;	COMDAT ?Delete@STR@@YAXPADKKK@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_Position$ = 12						; size = 4
_Count$ = 16						; size = 4
_StrLength$ = 20					; size = 4
?Delete@STR@@YAXPADKKK@Z PROC				; STR::Delete, COMDAT
; 763  : {
  00000	53		 push	 ebx
; 764  : 	// 
 Count 
 Position 
; 765  : 	if (STR::IsEmpty(Str) || Count == 0)
  00001	8b 5c 24 08	 mov	 ebx, DWORD PTR _Str$[esp]
  00005	53		 push	 ebx
  00006	e8 00 00 00 00	 call	 ?IsEmpty@STR@@YA_NQAD@Z	; STR::IsEmpty
  0000b	83 c4 04	 add	 esp, 4
  0000e	84 c0		 test	 al, al
  00010	75 4b		 jne	 SHORT $LN5@Delete
  00012	57		 push	 edi
  00013	8b 7c 24 14	 mov	 edi, DWORD PTR _Count$[esp+4]
  00017	85 ff		 test	 edi, edi
  00019	74 41		 je	 SHORT $LN11@Delete
  0001b	56		 push	 esi
; 766  : 		return;
; 767  : 
; 768  : 	DWORD Len = StrLength;
  0001c	8b 74 24 1c	 mov	 esi, DWORD PTR _StrLength$[esp+8]
; 769  : 	if (Len == 0)
  00020	85 f6		 test	 esi, esi
  00022	75 09		 jne	 SHORT $LN4@Delete
; 770  : 		Len = StrCalcLength(Str);
  00024	53		 push	 ebx
  00025	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  0002a	59		 pop	 ecx
  0002b	8b f0		 mov	 esi, eax
$LN4@Delete:
; 771  : 	if (Position > Len) return;
  0002d	8b 4c 24 14	 mov	 ecx, DWORD PTR _Position$[esp+8]
  00031	3b ce		 cmp	 ecx, esi
  00033	77 26		 ja	 SHORT $LN12@Delete
; 772  : 	if (Count > Len - Position)
  00035	8b c6		 mov	 eax, esi
  00037	2b c1		 sub	 eax, ecx
  00039	3b f8		 cmp	 edi, eax
  0003b	76 06		 jbe	 SHORT $LN1@Delete
; 773  : 	{
; 774  : 		Count = Len - Position;
  0003d	8b f8		 mov	 edi, eax
; 775  : 		if (Count == 0) return;
  0003f	85 ff		 test	 edi, edi
  00041	74 18		 je	 SHORT $LN12@Delete
$LN1@Delete:
; 776  : 	}
; 777  : 
; 778  : 	PCHAR Ptr = Str + Position;
; 779  : 	PCHAR FromPTR = Ptr + Count;
; 780  : 	m_memcpy(Ptr, FromPTR, Len - (Position + Count));
  00043	2b c7		 sub	 eax, edi
  00045	03 cb		 add	 ecx, ebx
  00047	50		 push	 eax
  00048	8d 04 39	 lea	 eax, DWORD PTR [ecx+edi]
  0004b	50		 push	 eax
  0004c	51		 push	 ecx
  0004d	e8 00 00 00 00	 call	 ?m_memcpy@@YAPAXPAXPBXH@Z ; m_memcpy
  00052	83 c4 0c	 add	 esp, 12			; 0000000cH
; 781  : 	Ptr = Str + (Len - Count);
; 782  : 	*Ptr = 0;
  00055	2b f7		 sub	 esi, edi
  00057	c6 04 1e 00	 mov	 BYTE PTR [esi+ebx], 0
$LN12@Delete:
  0005b	5e		 pop	 esi
$LN11@Delete:
  0005c	5f		 pop	 edi
$LN5@Delete:
  0005d	5b		 pop	 ebx
; 783  : }
  0005e	c3		 ret	 0
?Delete@STR@@YAXPADKKK@Z ENDP				; STR::Delete
_TEXT	ENDS
PUBLIC	?StrLongToString@@YAPADK@Z			; StrLongToString
; Function compile flags: /Ogspy
;	COMDAT ?StrLongToString@@YAPADK@Z
_TEXT	SEGMENT
_n$ = -4						; size = 4
_num$ = 8						; size = 4
?StrLongToString@@YAPADK@Z PROC				; StrLongToString, COMDAT
; 882  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
; 883  : 	int n = 0;
  00004	83 65 fc 00	 and	 DWORD PTR _n$[ebp], 0
  00008	56		 push	 esi
; 884  : 
; 885  : 	STRA::LongToString(num, NULL, n);
  00009	8d 45 fc	 lea	 eax, DWORD PTR _n$[ebp]
  0000c	50		 push	 eax
  0000d	6a 00		 push	 0
  0000f	ff 75 08	 push	 DWORD PTR _num$[ebp]
  00012	e8 00 00 00 00	 call	 ?LongToString@?$STRUTILS@D@@SAXKPADAAH@Z ; STRUTILS<char>::LongToString
; 886  : 	PCHAR Str = STR::Alloc(n);
  00017	ff 75 fc	 push	 DWORD PTR _n$[ebp]
  0001a	e8 00 00 00 00	 call	 ?Alloc@STR@@YAPADK@Z	; STR::Alloc
  0001f	8b f0		 mov	 esi, eax
; 887  : 	STRA::LongToString(num, Str, n);
  00021	8d 45 fc	 lea	 eax, DWORD PTR _n$[ebp]
  00024	50		 push	 eax
  00025	56		 push	 esi
  00026	ff 75 08	 push	 DWORD PTR _num$[ebp]
  00029	e8 00 00 00 00	 call	 ?LongToString@?$STRUTILS@D@@SAXKPADAAH@Z ; STRUTILS<char>::LongToString
  0002e	83 c4 1c	 add	 esp, 28			; 0000001cH
; 888  : 
; 889  :     return Str;
  00031	8b c6		 mov	 eax, esi
  00033	5e		 pop	 esi
; 890  : }
  00034	c9		 leave
  00035	c3		 ret	 0
?StrLongToString@@YAPADK@Z ENDP				; StrLongToString
_TEXT	ENDS
PUBLIC	?StrConcat@@YAXAAPADPAD@Z			; StrConcat
; Function compile flags: /Ogspy
;	COMDAT ?StrConcat@@YAXAAPADPAD@Z
_TEXT	SEGMENT
_Str1Len$ = -8						; size = 4
_Str2Len$ = -4						; size = 4
_Str1$ = 8						; size = 4
_Str2$ = 12						; size = 4
?StrConcat@@YAXAAPADPAD@Z PROC				; StrConcat, COMDAT
; 900  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
  00004	51		 push	 ecx
  00005	53		 push	 ebx
  00006	56		 push	 esi
  00007	57		 push	 edi
; 901  : 	// 
; 902  : 	DWORD Str2Len = StrCalcLength(Str2);
  00008	ff 75 0c	 push	 DWORD PTR _Str2$[ebp]
  0000b	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
; 903  : 	if (!STRHEAD::CheckSignature(Str1) || Str2Len == 0)
  00010	8b 7d 08	 mov	 edi, DWORD PTR _Str1$[ebp]
  00013	8b 1f		 mov	 ebx, DWORD PTR [edi]
  00015	8b f0		 mov	 esi, eax
  00017	53		 push	 ebx
  00018	89 75 fc	 mov	 DWORD PTR _Str2Len$[ebp], esi
  0001b	e8 00 00 00 00	 call	 ?CheckSignature@STRHEAD@@YA_NPAX@Z ; STRHEAD::CheckSignature
  00020	59		 pop	 ecx
  00021	59		 pop	 ecx
  00022	84 c0		 test	 al, al
  00024	74 3b		 je	 SHORT $LN2@StrConcat
  00026	85 f6		 test	 esi, esi
  00028	74 37		 je	 SHORT $LN2@StrConcat
; 904  : 		return;
; 905  : 	DWORD Str1Len = StrCalcLength(Str1);
  0002a	53		 push	 ebx
  0002b	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
; 906  : 
; 907  : 	DWORD NewLength = Str1Len + Str2Len;
  00030	03 f0		 add	 esi, eax
  00032	59		 pop	 ecx
  00033	89 45 f8	 mov	 DWORD PTR _Str1Len$[ebp], eax
; 908  :     if (STRHEAD::GetBufferSize(Str1) < NewLength)
  00036	39 73 f8	 cmp	 DWORD PTR [ebx-8], esi
  00039	73 09		 jae	 SHORT $LN1@StrConcat
; 909  : 		StrSetLength(Str1, NewLength);
  0003b	56		 push	 esi
  0003c	57		 push	 edi
  0003d	e8 00 00 00 00	 call	 ?StrSetLength@@YAXAAPADK@Z ; StrSetLength
  00042	59		 pop	 ecx
  00043	59		 pop	 ecx
$LN1@StrConcat:
; 910  : 
; 911  : 	PCHAR Tmp = Str1 + Str1Len;
; 912  : 	m_memcpy(Tmp, Str2, Str2Len);
  00044	ff 75 fc	 push	 DWORD PTR _Str2Len$[ebp]
  00047	8b 07		 mov	 eax, DWORD PTR [edi]
  00049	03 45 f8	 add	 eax, DWORD PTR _Str1Len$[ebp]
  0004c	ff 75 0c	 push	 DWORD PTR _Str2$[ebp]
  0004f	50		 push	 eax
  00050	e8 00 00 00 00	 call	 ?m_memcpy@@YAPAXPAXPBXH@Z ; m_memcpy
; 913  : 	STRHEAD::SetLength(Str1, NewLength);
  00055	8b 07		 mov	 eax, DWORD PTR [edi]
  00057	89 70 fc	 mov	 DWORD PTR [eax-4], esi
  0005a	83 c4 0c	 add	 esp, 12			; 0000000cH
  0005d	c6 04 30 00	 mov	 BYTE PTR [eax+esi], 0
$LN2@StrConcat:
  00061	5f		 pop	 edi
  00062	5e		 pop	 esi
  00063	5b		 pop	 ebx
; 914  : }
  00064	c9		 leave
  00065	c3		 ret	 0
?StrConcat@@YAXAAPADPAD@Z ENDP				; StrConcat
_TEXT	ENDS
PUBLIC	?StrConcatArguments@@YAXAAPADKPAPAD@Z		; StrConcatArguments
; Function compile flags: /Ogspy
;	COMDAT ?StrConcatArguments@@YAXAAPADKPAPAD@Z
_TEXT	SEGMENT
_Lens$ = -96						; size = 200
_FullLen$ = 104						; size = 4
_OutStr$ = 116						; size = 4
_Count$ = 120						; size = 4
_First$ = 124						; size = 4
?StrConcatArguments@@YAXAAPADKPAPAD@Z PROC		; StrConcatArguments, COMDAT
; 918  : {
  00000	55		 push	 ebp
  00001	8d 6c 24 94	 lea	 ebp, DWORD PTR [esp-108]
  00005	81 ec cc 00 00
	00		 sub	 esp, 204		; 000000ccH
; 919  : 	//  
; 920  : 
; 921  : 	const DWORD MaxCount = 50;
; 922  : 
; 923  :     if (Count >= MaxCount) return;
  0000b	83 7d 78 32	 cmp	 DWORD PTR _Count$[ebp], 50 ; 00000032H
  0000f	0f 83 84 00 00
	00		 jae	 $LN1@StrConcatA
  00015	53		 push	 ebx
; 924  : 
; 925  : 	DWORD Lens[MaxCount];
; 926  : 	PCHAR *Current = First;
  00016	8b 5d 7c	 mov	 ebx, DWORD PTR _First$[ebp]
  00019	56		 push	 esi
; 927  : 	DWORD FullLen = StrCalcLength(OutStr);
  0001a	8b 75 74	 mov	 esi, DWORD PTR _OutStr$[ebp]
  0001d	57		 push	 edi
  0001e	ff 36		 push	 DWORD PTR [esi]
  00020	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
; 928  : 	Lens[0] = FullLen;
; 929  : 
; 930  : 	// 
; 931  : 	for (DWORD i = 1; i <= Count; i++)
  00025	33 ff		 xor	 edi, edi
  00027	47		 inc	 edi
  00028	59		 pop	 ecx
  00029	89 45 68	 mov	 DWORD PTR _FullLen$[ebp], eax
  0002c	89 45 a0	 mov	 DWORD PTR _Lens$[ebp], eax
  0002f	39 7d 78	 cmp	 DWORD PTR _Count$[ebp], edi
  00032	72 1b		 jb	 SHORT $LN7@StrConcatA
$LL9@StrConcatA:
; 932  : 	{
; 933  : 		DWORD Len = StrCalcLength(*Current);
  00034	ff 33		 push	 DWORD PTR [ebx]
  00036	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
; 934  : 		Lens[i] = Len;
; 935  : 		FullLen += Len;
  0003b	01 45 68	 add	 DWORD PTR _FullLen$[ebp], eax
; 936  : 		Current++;
  0003e	83 c3 04	 add	 ebx, 4
  00041	89 44 bd a0	 mov	 DWORD PTR _Lens$[ebp+edi*4], eax
  00045	47		 inc	 edi
  00046	59		 pop	 ecx
  00047	3b 7d 78	 cmp	 edi, DWORD PTR _Count$[ebp]
  0004a	76 e8		 jbe	 SHORT $LL9@StrConcatA
; 928  : 	Lens[0] = FullLen;
; 929  : 
; 930  : 	// 
; 931  : 	for (DWORD i = 1; i <= Count; i++)
  0004c	8b 45 68	 mov	 eax, DWORD PTR _FullLen$[ebp]
$LN7@StrConcatA:
; 937  : 	}
; 938  : 
; 939  : 	// 
; 940  : 	if (FullLen == 0) return;
  0004f	85 c0		 test	 eax, eax
  00051	74 43		 je	 SHORT $LN21@StrConcatA
; 941  : 
; 942  : 	// 
; 943  : 	if (OutStr != NULL)
  00053	83 3e 00	 cmp	 DWORD PTR [esi], 0
; 944  : 		StrSetLength(OutStr, FullLen);
  00056	50		 push	 eax
  00057	74 09		 je	 SHORT $LN5@StrConcatA
  00059	56		 push	 esi
  0005a	e8 00 00 00 00	 call	 ?StrSetLength@@YAXAAPADK@Z ; StrSetLength
  0005f	59		 pop	 ecx
; 945  : 	else
  00060	eb 07		 jmp	 SHORT $LN24@StrConcatA
$LN5@StrConcatA:
; 946  :         OutStr = STR::Alloc(FullLen);
  00062	e8 00 00 00 00	 call	 ?Alloc@STR@@YAPADK@Z	; STR::Alloc
  00067	89 06		 mov	 DWORD PTR [esi], eax
$LN24@StrConcatA:
; 947  : 
; 948  : 	// 
; 949  : 	Current = First;
; 950  : 	PCHAR Tmp = OutStr + Lens[0];
  00069	8b 36		 mov	 esi, DWORD PTR [esi]
  0006b	03 75 a0	 add	 esi, DWORD PTR _Lens$[ebp]
  0006e	8b 5d 7c	 mov	 ebx, DWORD PTR _First$[ebp]
; 951  : 	for (DWORD i = 1; i <= Count; i++)
  00071	33 ff		 xor	 edi, edi
  00073	47		 inc	 edi
  00074	59		 pop	 ecx
  00075	39 7d 78	 cmp	 DWORD PTR _Count$[ebp], edi
  00078	72 1c		 jb	 SHORT $LN21@StrConcatA
$LL3@StrConcatA:
; 952  : 	{
; 953  : 	    m_memcpy(Tmp, *Current, Lens[i]);
  0007a	ff 74 bd a0	 push	 DWORD PTR _Lens$[ebp+edi*4]
  0007e	ff 33		 push	 DWORD PTR [ebx]
  00080	56		 push	 esi
  00081	e8 00 00 00 00	 call	 ?m_memcpy@@YAPAXPAXPBXH@Z ; m_memcpy
; 954  :         Tmp += Lens[i];
  00086	03 74 bd a0	 add	 esi, DWORD PTR _Lens$[ebp+edi*4]
  0008a	83 c4 0c	 add	 esp, 12			; 0000000cH
; 955  :     	Current++;
  0008d	83 c3 04	 add	 ebx, 4
  00090	47		 inc	 edi
  00091	3b 7d 78	 cmp	 edi, DWORD PTR _Count$[ebp]
  00094	76 e4		 jbe	 SHORT $LL3@StrConcatA
$LN21@StrConcatA:
  00096	5f		 pop	 edi
  00097	5e		 pop	 esi
  00098	5b		 pop	 ebx
$LN1@StrConcatA:
; 956  : 	}
; 957  : }
  00099	83 c5 6c	 add	 ebp, 108		; 0000006cH
  0009c	c9		 leave
  0009d	c3		 ret	 0
?StrConcatArguments@@YAXAAPADKPAPAD@Z ENDP		; StrConcatArguments
_TEXT	ENDS
PUBLIC	?New@STR@@YAPADKPADZZ				; STR::New
; Function compile flags: /Ogspy
;	COMDAT ?New@STR@@YAPADKPADZZ
_TEXT	SEGMENT
_Result$ = -4						; size = 4
_Count$ = 8						; size = 4
_Str$ = 12						; size = 4
?New@STR@@YAPADKPADZZ PROC				; STR::New, COMDAT
; 962  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
; 963  : 	// 
; 964  : 	PCHAR Result = NULL;
  00004	83 65 fc 00	 and	 DWORD PTR _Result$[ebp], 0
; 965  : 	PCHAR *First = &Str;
; 966  : 
; 967  : 	StrConcatArguments(Result, Count, First);
  00008	8d 45 0c	 lea	 eax, DWORD PTR _Str$[ebp]
  0000b	50		 push	 eax
  0000c	ff 75 08	 push	 DWORD PTR _Count$[ebp]
  0000f	8d 45 fc	 lea	 eax, DWORD PTR _Result$[ebp]
  00012	50		 push	 eax
  00013	e8 00 00 00 00	 call	 ?StrConcatArguments@@YAXAAPADKPAPAD@Z ; StrConcatArguments
; 968  : 
; 969  : 	return Result;
  00018	8b 45 fc	 mov	 eax, DWORD PTR _Result$[ebp]
  0001b	83 c4 0c	 add	 esp, 12			; 0000000cH
; 970  : }
  0001e	c9		 leave
  0001f	c3		 ret	 0
?New@STR@@YAPADKPADZZ ENDP				; STR::New
_TEXT	ENDS
PUBLIC	?StrConcat@@YAXAAPADKPADZZ			; StrConcat
; Function compile flags: /Ogspy
;	COMDAT ?StrConcat@@YAXAAPADKPADZZ
_TEXT	SEGMENT
_Str1$ = 8						; size = 4
_Count$ = 12						; size = 4
_Str2$ = 16						; size = 4
?StrConcat@@YAXAAPADKPADZZ PROC				; StrConcat, COMDAT
; 986  : 	//  
; 987  : 	//  
 Str1 
; 988  : 	//  
 Str1 
; 989  : 	if (Str2 == NULL)
  00000	83 7c 24 0c 00	 cmp	 DWORD PTR _Str2$[esp-4], 0
  00005	74 27		 je	 SHORT $LN3@StrConcat@2
; 990  : 		return;
; 991  : 	if ((Str1 != NULL) && !STRHEAD::CheckSignature(Str1))
  00007	8b 54 24 04	 mov	 edx, DWORD PTR _Str1$[esp-4]
  0000b	8b 02		 mov	 eax, DWORD PTR [edx]
  0000d	85 c0		 test	 eax, eax
  0000f	74 0b		 je	 SHORT $LN1@StrConcat@2
  00011	50		 push	 eax
  00012	e8 00 00 00 00	 call	 ?CheckSignature@STRHEAD@@YA_NPAX@Z ; STRHEAD::CheckSignature
  00017	59		 pop	 ecx
  00018	84 c0		 test	 al, al
  0001a	74 12		 je	 SHORT $LN3@StrConcat@2
$LN1@StrConcat@2:
; 992  :     	return;
; 993  : 
; 994  : 	PCHAR *Args = &Str2;
; 995  : 	StrConcatArguments(Str1, Count, Args);
  0001c	8d 44 24 0c	 lea	 eax, DWORD PTR _Str2$[esp-4]
  00020	50		 push	 eax
  00021	ff 74 24 0c	 push	 DWORD PTR _Count$[esp]
  00025	52		 push	 edx
  00026	e8 00 00 00 00	 call	 ?StrConcatArguments@@YAXAAPADKPAPAD@Z ; StrConcatArguments
  0002b	83 c4 0c	 add	 esp, 12			; 0000000cH
$LN3@StrConcat@2:
; 996  : }
  0002e	c3		 ret	 0
?StrConcat@@YAXAAPADKPADZZ ENDP				; StrConcat
_TEXT	ENDS
PUBLIC	?StrCopy@@YA_NPAD0_N@Z				; StrCopy
; Function compile flags: /Ogspy
;	COMDAT ?StrCopy@@YA_NPAD0_N@Z
_TEXT	SEGMENT
_Dest$ = 8						; size = 4
_Source$ = 12						; size = 4
_UpdateLen$ = 16					; size = 1
?StrCopy@@YA_NPAD0_N@Z PROC				; StrCopy, COMDAT
; 999  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	57		 push	 edi
; 1000 : 	// 
 Source 
; 1001 : 	// 
 UpdateLen 
 Dest 
; 1002 : 	// StrAlloc, STR::New
; 1003 : 	// 
; 1004 : 
; 1005 : 	if (Dest == NULL || Source == NULL)
  00004	8b 7d 08	 mov	 edi, DWORD PTR _Dest$[ebp]
  00007	85 ff		 test	 edi, edi
  00009	74 36		 je	 SHORT $LN3@StrCopy
  0000b	83 7d 0c 00	 cmp	 DWORD PTR _Source$[ebp], 0
  0000f	74 30		 je	 SHORT $LN3@StrCopy
  00011	56		 push	 esi
; 1007 : 
; 1008 : 	DWORD Len = StrCalcLength(Source);
  00012	ff 75 0c	 push	 DWORD PTR _Source$[ebp]
  00015	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  0001a	8b f0		 mov	 esi, eax
; 1009 : 	m_memcpy(Dest, Source, Len);
  0001c	56		 push	 esi
  0001d	ff 75 0c	 push	 DWORD PTR _Source$[ebp]
  00020	57		 push	 edi
  00021	e8 00 00 00 00	 call	 ?m_memcpy@@YAPAXPAXPBXH@Z ; m_memcpy
  00026	83 c4 10	 add	 esp, 16			; 00000010H
; 1010 : 	if (UpdateLen)
  00029	80 7d 10 00	 cmp	 BYTE PTR _UpdateLen$[ebp], 0
  0002d	74 03		 je	 SHORT $LN2@StrCopy
; 1011 : 		STRHEAD::SetLength(Dest, Len);
  0002f	89 77 fc	 mov	 DWORD PTR [edi-4], esi
$LN2@StrCopy:
; 1012 : 	else
; 1013 : 		*(Dest + Len) = 0;
; 1014 : 
; 1015 :  	return Len > 0;
  00032	33 c0		 xor	 eax, eax
  00034	3b c6		 cmp	 eax, esi
  00036	1b c0		 sbb	 eax, eax
  00038	c6 04 3e 00	 mov	 BYTE PTR [esi+edi], 0
  0003c	f7 d8		 neg	 eax
  0003e	5e		 pop	 esi
  0003f	eb 02		 jmp	 SHORT $LN5@StrCopy
$LN3@StrCopy:
; 1006 : 		return false;
  00041	32 c0		 xor	 al, al
$LN5@StrCopy:
  00043	5f		 pop	 edi
; 1016 : }
  00044	5d		 pop	 ebp
  00045	c3		 ret	 0
?StrCopy@@YA_NPAD0_N@Z ENDP				; StrCopy
_TEXT	ENDS
PUBLIC	?Scan@STR@@YAPADPBDD@Z				; STR::Scan
; Function compile flags: /Ogspy
;	COMDAT ?Scan@STR@@YAPADPBDD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_C$ = 12						; size = 1
?Scan@STR@@YAPADPBDD@Z PROC				; STR::Scan, COMDAT
; 1029 : 	// 
; 1030 : 	return AnsiStr::Scan(Str, C);
  00000	e9 00 00 00 00	 jmp	 ?Scan@?$STRUTILS@D@@SAPADPBDD@Z ; STRUTILS<char>::Scan
?Scan@STR@@YAPADPBDD@Z ENDP				; STR::Scan
_TEXT	ENDS
PUBLIC	?End@STR@@YAPADPAD@Z				; STR::End
; Function compile flags: /Ogspy
;	COMDAT ?End@STR@@YAPADPAD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?End@STR@@YAPADPAD@Z PROC				; STR::End, COMDAT
; 1051 : 	return AnsiStr::End(Str);
  00000	e9 00 00 00 00	 jmp	 ?End@?$STRUTILS@D@@SAPADPBD@Z ; STRUTILS<char>::End
?End@STR@@YAPADPAD@Z ENDP				; STR::End
_TEXT	ENDS
PUBLIC	?Pos@STR@@YAHPBD0K_N@Z				; STR::Pos
; Function compile flags: /Ogspy
;	COMDAT ?Pos@STR@@YAHPBD0K_N@Z
_TEXT	SEGMENT
_sslen$ = -20						; size = 4
_j$ = -16						; size = 4
_s$ = -12						; size = 4
tv326 = -8						; size = 4
_Pos$ = -4						; size = 4
_p$ = 8							; size = 4
_Str$ = 8						; size = 4
_SubStr$ = 12						; size = 4
_StrLen$ = 16						; size = 4
_CaseSensetive$ = 20					; size = 1
?Pos@STR@@YAHPBD0K_N@Z PROC				; STR::Pos, COMDAT
; 1065 : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 14	 sub	 esp, 20			; 00000014H
  00006	53		 push	 ebx
  00007	56		 push	 esi
; 1066 : 	// 
 _SubStr 
; 1067 : 	if( !Str || !SubStr )
  00008	8b 75 08	 mov	 esi, DWORD PTR _Str$[ebp]
  0000b	33 db		 xor	 ebx, ebx
  0000d	57		 push	 edi
  0000e	3b f3		 cmp	 esi, ebx
  00010	0f 84 ff 00 00
	00		 je	 $LN15@Pos
  00016	8b 7d 0c	 mov	 edi, DWORD PTR _SubStr$[ebp]
  00019	3b fb		 cmp	 edi, ebx
  0001b	0f 84 f4 00 00
	00		 je	 $LN15@Pos
; 1069 : 
; 1070 : 	DWORD s;
; 1071 : 	DWORD j = 0;
; 1072 : 
; 1073 :    //	DWORD slen  = StrCalcLength(Str);
; 1074 : 	DWORD sslen = StrCalcLength(SubStr);
  00021	57		 push	 edi
  00022	89 5d f0	 mov	 DWORD PTR _j$[ebp], ebx
  00025	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
; 1075 : 	DWORD Pos = 0;
; 1076 : 	DWORD Pos1 = 0;
; 1077 : 	// 
; 1078 : 	char* p = (char*)Str;
; 1079 : 
; 1080 : 	while (!IsStrEnd(p, StrLen, Pos))
  0002a	53		 push	 ebx
  0002b	ff 75 10	 push	 DWORD PTR _StrLen$[ebp]
  0002e	89 45 ec	 mov	 DWORD PTR _sslen$[ebp], eax
  00031	56		 push	 esi
  00032	89 5d fc	 mov	 DWORD PTR _Pos$[ebp], ebx
  00035	89 75 08	 mov	 DWORD PTR _p$[ebp], esi
  00038	e8 00 00 00 00	 call	 ?IsStrEnd@@YA_NPADKK@Z	; IsStrEnd
  0003d	83 c4 10	 add	 esp, 16			; 00000010H
  00040	84 c0		 test	 al, al
  00042	0f 85 cd 00 00
	00		 jne	 $LN15@Pos
  00048	8b df		 mov	 ebx, edi
  0004a	89 75 f8	 mov	 DWORD PTR tv326[ebp], esi
  0004d	f7 db		 neg	 ebx
  0004f	29 7d f8	 sub	 DWORD PTR tv326[ebp], edi
  00052	eb 03		 jmp	 SHORT $LN14@Pos
$LL26@Pos:
  00054	8b 7d 0c	 mov	 edi, DWORD PTR _SubStr$[ebp]
$LN14@Pos:
; 1081 : 	{
; 1082 : 		const char* k = SubStr;
; 1083 : 
; 1084 : 
; 1085 : 		char PC = *p;
; 1086 : 		char KC = *k;
; 1087 : 
; 1088 : 		if (!CaseSensetive)
  00057	80 7d 14 00	 cmp	 BYTE PTR _CaseSensetive$[ebp], 0
  0005b	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0005e	8a 00		 mov	 al, BYTE PTR [eax]
  00060	8a 0f		 mov	 cl, BYTE PTR [edi]
  00062	75 19		 jne	 SHORT $LN10@Pos
; 1089 : 		{
; 1090 : 			LowerChar(PC);
  00064	8a d0		 mov	 dl, al
  00066	80 ea 41	 sub	 dl, 65			; 00000041H
  00069	80 fa 19	 cmp	 dl, 25			; 00000019H
  0006c	77 02		 ja	 SHORT $LN11@Pos
  0006e	04 20		 add	 al, 32			; 00000020H
$LN11@Pos:
; 1091 : 			LowerChar(KC);
  00070	8a d1		 mov	 dl, cl
  00072	80 ea 41	 sub	 dl, 65			; 00000041H
  00075	80 fa 19	 cmp	 dl, 25			; 00000019H
  00078	77 03		 ja	 SHORT $LN10@Pos
  0007a	80 c1 20	 add	 cl, 32			; 00000020H
$LN10@Pos:
; 1092 : 		}
; 1093 : 
; 1094 : 		// 
; 1095 : 		if ( PC == KC )
  0007d	3a c1		 cmp	 al, cl
  0007f	75 71		 jne	 SHORT $LN27@Pos
; 1096 : 		{
; 1097 : 			char* p1 = p;
; 1098 : 			const char* k1 = k;
; 1099 : 			Pos1 = Pos;
; 1100 : 			s = 0;
; 1101 : 			// 
; 1102 : 			while(!IsStrEnd(p1, StrLen, Pos1) && *k1 != 0)
  00081	8b 7d fc	 mov	 edi, DWORD PTR _Pos$[ebp]
  00084	83 65 f4 00	 and	 DWORD PTR _s$[ebp], 0
  00088	57		 push	 edi
  00089	ff 75 10	 push	 DWORD PTR _StrLen$[ebp]
  0008c	ff 75 08	 push	 DWORD PTR _p$[ebp]
  0008f	e8 00 00 00 00	 call	 ?IsStrEnd@@YA_NPADKK@Z	; IsStrEnd
  00094	83 c4 0c	 add	 esp, 12			; 0000000cH
  00097	84 c0		 test	 al, al
  00099	75 57		 jne	 SHORT $LN27@Pos
  0009b	8b 45 f8	 mov	 eax, DWORD PTR tv326[ebp]
  0009e	8b 75 0c	 mov	 esi, DWORD PTR _SubStr$[ebp]
  000a1	03 f8		 add	 edi, eax
$LL8@Pos:
  000a3	8a 0e		 mov	 cl, BYTE PTR [esi]
  000a5	84 c9		 test	 cl, cl
  000a7	74 49		 je	 SHORT $LN27@Pos
; 1103 : 			{
; 1104 : 
; 1105 : 				char C1 = *p1;
; 1106 : 				char C2 = *k1;
; 1107 : 
; 1108 : 				if (!CaseSensetive)
  000a9	80 7d 14 00	 cmp	 BYTE PTR _CaseSensetive$[ebp], 0
  000ad	8a 04 37	 mov	 al, BYTE PTR [edi+esi]
  000b0	75 19		 jne	 SHORT $LN4@Pos
; 1109 : 				{
; 1110 : 					LowerChar(C1);
  000b2	8a d0		 mov	 dl, al
  000b4	80 ea 41	 sub	 dl, 65			; 00000041H
  000b7	80 fa 19	 cmp	 dl, 25			; 00000019H
  000ba	77 02		 ja	 SHORT $LN5@Pos
  000bc	04 20		 add	 al, 32			; 00000020H
$LN5@Pos:
; 1111 : 					LowerChar(C2);
  000be	8a d1		 mov	 dl, cl
  000c0	80 ea 41	 sub	 dl, 65			; 00000041H
  000c3	80 fa 19	 cmp	 dl, 25			; 00000019H
  000c6	77 03		 ja	 SHORT $LN4@Pos
  000c8	80 c1 20	 add	 cl, 32			; 00000020H
$LN4@Pos:
; 1112 : 				}
; 1113 : 
; 1114 : 
; 1115 : 				if (C1 == C2)
  000cb	3a c1		 cmp	 al, cl
  000cd	75 23		 jne	 SHORT $LN27@Pos
; 1116 : 					s++;
  000cf	ff 45 f4	 inc	 DWORD PTR _s$[ebp]
; 1117 : 				else
; 1118 : 					break;
; 1119 : 
; 1120 : 				if (s == (DWORD)sslen)
  000d2	8b 45 f4	 mov	 eax, DWORD PTR _s$[ebp]
  000d5	3b 45 ec	 cmp	 eax, DWORD PTR _sslen$[ebp]
  000d8	74 43		 je	 SHORT $LN23@Pos
; 1122 : 
; 1123 : 				p1++;
  000da	46		 inc	 esi
  000db	8d 04 33	 lea	 eax, DWORD PTR [ebx+esi]
  000de	50		 push	 eax
  000df	ff 75 10	 push	 DWORD PTR _StrLen$[ebp]
  000e2	8d 04 37	 lea	 eax, DWORD PTR [edi+esi]
  000e5	50		 push	 eax
  000e6	e8 00 00 00 00	 call	 ?IsStrEnd@@YA_NPADKK@Z	; IsStrEnd
  000eb	83 c4 0c	 add	 esp, 12			; 0000000cH
  000ee	84 c0		 test	 al, al
  000f0	74 b1		 je	 SHORT $LL8@Pos
$LN27@Pos:
; 1124 : 				k1++;
; 1125 : 				Pos1++;
; 1126 : 			}
; 1127 : 		}
; 1128 : 
; 1129 : 		// 
; 1130 : 		Pos++;
  000f2	ff 45 fc	 inc	 DWORD PTR _Pos$[ebp]
  000f5	ff 75 fc	 push	 DWORD PTR _Pos$[ebp]
  000f8	43		 inc	 ebx
; 1131 : 		p++;
  000f9	ff 45 08	 inc	 DWORD PTR _p$[ebp]
  000fc	ff 75 10	 push	 DWORD PTR _StrLen$[ebp]
; 1132 : 		j++;
  000ff	ff 45 f0	 inc	 DWORD PTR _j$[ebp]
  00102	ff 75 08	 push	 DWORD PTR _p$[ebp]
  00105	e8 00 00 00 00	 call	 ?IsStrEnd@@YA_NPADKK@Z	; IsStrEnd
  0010a	83 c4 0c	 add	 esp, 12			; 0000000cH
  0010d	84 c0		 test	 al, al
  0010f	0f 84 3f ff ff
	ff		 je	 $LL26@Pos
$LN15@Pos:
; 1068 : 		return -1;
  00115	83 c8 ff	 or	 eax, -1
$LN17@Pos:
  00118	5f		 pop	 edi
  00119	5e		 pop	 esi
  0011a	5b		 pop	 ebx
; 1133 : 	}
; 1134 : 	return -1;
; 1135 : }
  0011b	c9		 leave
  0011c	c3		 ret	 0
$LN23@Pos:
; 1121 : 					return j;
  0011d	8b 45 f0	 mov	 eax, DWORD PTR _j$[ebp]
  00120	eb f6		 jmp	 SHORT $LN17@Pos
?Pos@STR@@YAHPBD0K_N@Z ENDP				; STR::Pos
_TEXT	ENDS
PUBLIC	?GetLeftStr@STR@@YAPADPAD0_N@Z			; STR::GetLeftStr
; Function compile flags: /Ogspy
;	COMDAT ?GetLeftStr@STR@@YAPADPAD0_N@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_SubStr$ = 12						; size = 4
_IncludeSubStr$ = 16					; size = 1
?GetLeftStr@STR@@YAPADPAD0_N@Z PROC			; STR::GetLeftStr, COMDAT
; 1139 : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	56		 push	 esi
; 1140 : 	// 
; 1141 : 	int Pos = STR::Pos(Str, SubStr);
  00004	6a 01		 push	 1
  00006	6a 00		 push	 0
  00008	ff 75 0c	 push	 DWORD PTR _SubStr$[ebp]
  0000b	ff 75 08	 push	 DWORD PTR _Str$[ebp]
  0000e	e8 00 00 00 00	 call	 ?Pos@STR@@YAHPBD0K_N@Z	; STR::Pos
  00013	8b f0		 mov	 esi, eax
  00015	83 c4 10	 add	 esp, 16			; 00000010H
; 1142 : 	if (Pos < 0)
  00018	85 f6		 test	 esi, esi
  0001a	7d 04		 jge	 SHORT $LN2@GetLeftStr
; 1143 : 		return NULL;
  0001c	33 c0		 xor	 eax, eax
  0001e	eb 1c		 jmp	 SHORT $LN3@GetLeftStr
$LN2@GetLeftStr:
; 1144 : 	if (IncludeSubStr)
  00020	80 7d 10 00	 cmp	 BYTE PTR _IncludeSubStr$[ebp], 0
  00024	74 0b		 je	 SHORT $LN1@GetLeftStr
; 1145 : 		Pos += StrCalcLength(SubStr);
  00026	ff 75 0c	 push	 DWORD PTR _SubStr$[ebp]
  00029	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  0002e	59		 pop	 ecx
  0002f	03 f0		 add	 esi, eax
$LN1@GetLeftStr:
; 1146 : 	return STR::New(Str, Pos);
  00031	56		 push	 esi
  00032	ff 75 08	 push	 DWORD PTR _Str$[ebp]
  00035	e8 00 00 00 00	 call	 ?New@STR@@YAPADPADK@Z	; STR::New
  0003a	59		 pop	 ecx
  0003b	59		 pop	 ecx
$LN3@GetLeftStr:
  0003c	5e		 pop	 esi
; 1147 : }
  0003d	5d		 pop	 ebp
  0003e	c3		 ret	 0
?GetLeftStr@STR@@YAPADPAD0_N@Z ENDP			; STR::GetLeftStr
_TEXT	ENDS
PUBLIC	?GetRightStr@STR@@YAPADPAD0_N@Z			; STR::GetRightStr
; Function compile flags: /Ogspy
;	COMDAT ?GetRightStr@STR@@YAPADPAD0_N@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_SubStr$ = 12						; size = 4
_IncludeSubStr$ = 16					; size = 1
?GetRightStr@STR@@YAPADPAD0_N@Z PROC			; STR::GetRightStr, COMDAT
; 1151 : {
  00000	56		 push	 esi
  00001	57		 push	 edi
; 1152 : 	// 
; 1153 : 	int Pos = STR::Pos(Str, SubStr);
  00002	8b 7c 24 0c	 mov	 edi, DWORD PTR _Str$[esp+4]
  00006	6a 01		 push	 1
  00008	6a 00		 push	 0
  0000a	ff 74 24 18	 push	 DWORD PTR _SubStr$[esp+12]
  0000e	57		 push	 edi
  0000f	e8 00 00 00 00	 call	 ?Pos@STR@@YAHPBD0K_N@Z	; STR::Pos
  00014	8b f0		 mov	 esi, eax
  00016	83 c4 10	 add	 esp, 16			; 00000010H
; 1154 : 	if (Pos < 0)
  00019	85 f6		 test	 esi, esi
  0001b	7d 04		 jge	 SHORT $LN3@GetRightSt
$LN8@GetRightSt:
; 1155 : 		return NULL;
  0001d	33 c0		 xor	 eax, eax
  0001f	eb 25		 jmp	 SHORT $LN4@GetRightSt
$LN3@GetRightSt:
; 1156 : 
; 1157 : 	if (!IncludeSubStr)
  00021	80 7c 24 14 00	 cmp	 BYTE PTR _IncludeSubStr$[esp+4], 0
  00026	75 0c		 jne	 SHORT $LN2@GetRightSt
; 1158 : 		Pos += StrCalcLength(SubStr);
  00028	ff 74 24 10	 push	 DWORD PTR _SubStr$[esp+4]
  0002c	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  00031	59		 pop	 ecx
  00032	03 f0		 add	 esi, eax
$LN2@GetRightSt:
; 1159 : 
; 1160 : 	PCHAR Tmp = Str + Pos;
  00034	8d 04 3e	 lea	 eax, DWORD PTR [esi+edi]
; 1161 : 
; 1162 : 	if (*Tmp == 0)
  00037	80 38 00	 cmp	 BYTE PTR [eax], 0
; 1163 : 		return NULL;
  0003a	74 e1		 je	 SHORT $LN8@GetRightSt
; 1164 : 	return STR::New(Tmp);
  0003c	6a 00		 push	 0
  0003e	50		 push	 eax
  0003f	e8 00 00 00 00	 call	 ?New@STR@@YAPADPADK@Z	; STR::New
  00044	59		 pop	 ecx
  00045	59		 pop	 ecx
$LN4@GetRightSt:
  00046	5f		 pop	 edi
  00047	5e		 pop	 esi
; 1165 : }
  00048	c3		 ret	 0
?GetRightStr@STR@@YAPADPAD0_N@Z ENDP			; STR::GetRightStr
_TEXT	ENDS
PUBLIC	?StrIndexOf@@YAHPAD_NK0ZZ			; StrIndexOf
; Function compile flags: /Ogspy
;	COMDAT ?StrIndexOf@@YAHPAD_NK0ZZ
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_CaseSensetive$ = 12					; size = 1
_Count$ = 16						; size = 4
_Cmp$ = 20						; size = 4
?StrIndexOf@@YAHPAD_NK0ZZ PROC				; StrIndexOf, COMDAT
; 1194 : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	53		 push	 ebx
; 1195 : 	// 
; 1196 : 	if (Str == NULL || Count == 0 || Cmp == NULL)
  00004	33 db		 xor	 ebx, ebx
  00006	56		 push	 esi
  00007	57		 push	 edi
  00008	39 5d 08	 cmp	 DWORD PTR _Str$[ebp], ebx
  0000b	74 32		 je	 SHORT $LN5@StrIndexOf
  0000d	39 5d 10	 cmp	 DWORD PTR _Count$[ebp], ebx
  00010	74 2d		 je	 SHORT $LN5@StrIndexOf
  00012	39 5d 14	 cmp	 DWORD PTR _Cmp$[ebp], ebx
  00015	74 28		 je	 SHORT $LN5@StrIndexOf
; 1198 : 	PCHAR *Cur = &Cmp;
; 1199 : 	for (DWORD i = 0; i < Count; i++)
  00017	33 ff		 xor	 edi, edi
  00019	8d 75 14	 lea	 esi, DWORD PTR _Cmp$[ebp]
  0001c	39 5d 10	 cmp	 DWORD PTR _Count$[ebp], ebx
  0001f	76 1e		 jbe	 SHORT $LN5@StrIndexOf
$LL4@StrIndexOf:
; 1200 : 	{
; 1201 : 		if (StrSame(Str, *Cur, CaseSensetive))
  00021	53		 push	 ebx
  00022	ff 75 0c	 push	 DWORD PTR _CaseSensetive$[ebp]
  00025	ff 36		 push	 DWORD PTR [esi]
  00027	ff 75 08	 push	 DWORD PTR _Str$[ebp]
  0002a	e8 00 00 00 00	 call	 ?StrSame@@YA_NPAD0_NK@Z	; StrSame
  0002f	83 c4 10	 add	 esp, 16			; 00000010H
  00032	84 c0		 test	 al, al
  00034	75 11		 jne	 SHORT $LN10@StrIndexOf
; 1203 :         Cur++;
  00036	83 c6 04	 add	 esi, 4
  00039	47		 inc	 edi
  0003a	3b 7d 10	 cmp	 edi, DWORD PTR _Count$[ebp]
  0003d	72 e2		 jb	 SHORT $LL4@StrIndexOf
$LN5@StrIndexOf:
; 1197 : 		return -1;
  0003f	83 c8 ff	 or	 eax, -1
$LN7@StrIndexOf:
  00042	5f		 pop	 edi
  00043	5e		 pop	 esi
  00044	5b		 pop	 ebx
; 1204 : 	}
; 1205 : 
; 1206 : 	return -1;
; 1207 : }
  00045	5d		 pop	 ebp
  00046	c3		 ret	 0
$LN10@StrIndexOf:
; 1202 : 			return i;
  00047	8b c7		 mov	 eax, edi
  00049	eb f7		 jmp	 SHORT $LN7@StrIndexOf
?StrIndexOf@@YAHPAD_NK0ZZ ENDP				; StrIndexOf
_TEXT	ENDS
PUBLIC	?Format@STR@@YAPADPAD0@Z			; STR::Format
; Function compile flags: /Ogspy
;	COMDAT ?Format@STR@@YAPADPAD0@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_Arguments$ = 12					; size = 4
?Format@STR@@YAPADPAD0@Z PROC				; STR::Format, COMDAT
; 1263 : 	if (STR::IsEmpty(Str)) return NULL;
  00000	ff 74 24 04	 push	 DWORD PTR _Str$[esp-4]
  00004	e8 00 00 00 00	 call	 ?IsEmpty@STR@@YA_NQAD@Z	; STR::IsEmpty
  00009	83 c4 04	 add	 esp, 4
  0000c	84 c0		 test	 al, al
  0000e	74 03		 je	 SHORT $LN1@Format
  00010	33 c0		 xor	 eax, eax
; 1273 : }
  00012	c3		 ret	 0
$LN1@Format:
  00013	56		 push	 esi
  00014	57		 push	 edi
; 1264 : 	PCHAR FullLine = STR::Alloc(StrCalcLength(Str) + 4096);
  00015	ff 74 24 0c	 push	 DWORD PTR _Str$[esp+4]
  00019	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  0001e	05 00 10 00 00	 add	 eax, 4096		; 00001000H
  00023	50		 push	 eax
  00024	e8 00 00 00 00	 call	 ?Alloc@STR@@YAPADK@Z	; STR::Alloc
; 1265 : 
; 1266 : //	va_list Arguments;
; 1267 : //	va_start(Arguments, Str);
; 1268 : 	pwvsprintfA(FullLine, Str, Arguments);
  00029	ff 74 24 18	 push	 DWORD PTR _Arguments$[esp+12]
  0002d	8b f0		 mov	 esi, eax
  0002f	ff 74 24 18	 push	 DWORD PTR _Str$[esp+16]
  00033	56		 push	 esi
  00034	e8 00 00 00 00	 call	 ??$pushargEx@$02$0GLDKPAOM@$0BFK@PADPADPAD@@YAPAXPAD00@Z ; pushargEx<3,1799024876,346,char *,char *,char *>
; 1269 : //	va_end(Arguments);
; 1270 : 	PCHAR Res = STR::New(FullLine);
  00039	6a 00		 push	 0
  0003b	56		 push	 esi
  0003c	e8 00 00 00 00	 call	 ?New@STR@@YAPADPADK@Z	; STR::New
; 1271 : 	STR::Free(FullLine);
  00041	56		 push	 esi
  00042	8b f8		 mov	 edi, eax
  00044	e8 00 00 00 00	 call	 ?Free@STR@@YAXPAD@Z	; STR::Free
  00049	83 c4 20	 add	 esp, 32			; 00000020H
; 1272 : 	return Res;
  0004c	8b c7		 mov	 eax, edi
  0004e	5f		 pop	 edi
  0004f	5e		 pop	 esi
; 1273 : }
  00050	c3		 ret	 0
?Format@STR@@YAPADPAD0@Z ENDP				; STR::Format
_TEXT	ENDS
PUBLIC	?GetLine@STR@@YAPADPADK@Z			; STR::GetLine
; Function compile flags: /Ogspy
;	COMDAT ?GetLine@STR@@YAPADPADK@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_StrSize$ = 12						; size = 4
?GetLine@STR@@YAPADPADK@Z PROC				; STR::GetLine, COMDAT
; 1277 : {
  00000	57		 push	 edi
; 1278 : 	// 
; 1279 : 	// 
 10, 13 
; 1280 : 	// 
 StrSize
; 1281 : 	if (Str == NULL)
  00001	8b 7c 24 08	 mov	 edi, DWORD PTR _Str$[esp]
  00005	85 ff		 test	 edi, edi
  00007	75 04		 jne	 SHORT $LN6@GetLine
; 1282 : 		return NULL;
  00009	33 c0		 xor	 eax, eax
  0000b	5f		 pop	 edi
; 1294 : }
  0000c	c3		 ret	 0
$LN6@GetLine:
  0000d	56		 push	 esi
; 1283 : 
; 1284 : 	DWORD Size;
; 1285 : 	PCHAR Tmp = Str;
; 1286 : 
; 1287 : 	for (Size = 0; !IsStrEnd(Tmp, StrSize, Size) && *Tmp != 10 && *Tmp != 13; Size++, Tmp++);
  0000e	33 f6		 xor	 esi, esi
  00010	56		 push	 esi
  00011	ff 74 24 14	 push	 DWORD PTR _StrSize$[esp+8]
  00015	57		 push	 edi
  00016	e8 00 00 00 00	 call	 ?IsStrEnd@@YA_NPADKK@Z	; IsStrEnd
  0001b	83 c4 0c	 add	 esp, 12			; 0000000cH
  0001e	84 c0		 test	 al, al
  00020	75 30		 jne	 SHORT $LN2@GetLine
$LL5@GetLine:
  00022	8a 04 3e	 mov	 al, BYTE PTR [esi+edi]
  00025	3c 0a		 cmp	 al, 10			; 0000000aH
  00027	74 1a		 je	 SHORT $LN3@GetLine
  00029	3c 0d		 cmp	 al, 13			; 0000000dH
  0002b	74 16		 je	 SHORT $LN3@GetLine
  0002d	46		 inc	 esi
  0002e	56		 push	 esi
  0002f	ff 74 24 14	 push	 DWORD PTR _StrSize$[esp+8]
  00033	8d 04 3e	 lea	 eax, DWORD PTR [esi+edi]
  00036	50		 push	 eax
  00037	e8 00 00 00 00	 call	 ?IsStrEnd@@YA_NPADKK@Z	; IsStrEnd
  0003c	83 c4 0c	 add	 esp, 12			; 0000000cH
  0003f	84 c0		 test	 al, al
  00041	74 df		 je	 SHORT $LL5@GetLine
$LN3@GetLine:
; 1288 : 
; 1289 : 
; 1290 : 	if (Size != 0)
  00043	85 f6		 test	 esi, esi
  00045	74 0b		 je	 SHORT $LN2@GetLine
; 1291 : 		return STR::New(Str, Size);
  00047	56		 push	 esi
  00048	57		 push	 edi
  00049	e8 00 00 00 00	 call	 ?New@STR@@YAPADPADK@Z	; STR::New
  0004e	59		 pop	 ecx
  0004f	59		 pop	 ecx
  00050	eb 02		 jmp	 SHORT $LN11@GetLine
$LN2@GetLine:
; 1292 : 	else
; 1293 : 		return NULL;
  00052	33 c0		 xor	 eax, eax
$LN11@GetLine:
  00054	5e		 pop	 esi
  00055	5f		 pop	 edi
; 1294 : }
  00056	c3		 ret	 0
?GetLine@STR@@YAPADPADK@Z ENDP				; STR::GetLine
_TEXT	ENDS
PUBLIC	?GetHash@STR@@YAKPADK_N@Z			; STR::GetHash
; Function compile flags: /Ogspy
;	COMDAT ?GetHash@STR@@YAKPADK_N@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_Len$ = 12						; size = 4
_LowerCase$ = 16					; size = 1
?GetHash@STR@@YAKPADK_N@Z PROC				; STR::GetHash, COMDAT
; 1364 :     return STRA::Hash(Str, Len, LowerCase);
  00000	e9 00 00 00 00	 jmp	 ?Hash@?$STRUTILS@D@@SAKPBDK_N@Z ; STRUTILS<char>::Hash
?GetHash@STR@@YAKPADK_N@Z ENDP				; STR::GetHash
_TEXT	ENDS
PUBLIC	?CalcDoubleZeroStrLength@STR@@YAKPAD@Z		; STR::CalcDoubleZeroStrLength
; Function compile flags: /Ogspy
;	COMDAT ?CalcDoubleZeroStrLength@STR@@YAKPAD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?CalcDoubleZeroStrLength@STR@@YAKPAD@Z PROC		; STR::CalcDoubleZeroStrLength, COMDAT
; 1392 : {
  00000	56		 push	 esi
; 1393 : 	// 
; 1394 : 	// 
; 1395 : 	// 
; 1396 : 	// 
: str0str0str00
; 1397 : 
; 1398 : 	if (IsEmpty(Str))
  00001	8b 74 24 08	 mov	 esi, DWORD PTR _Str$[esp]
  00005	56		 push	 esi
  00006	e8 00 00 00 00	 call	 ?IsEmpty@STR@@YA_NQAD@Z	; STR::IsEmpty
  0000b	83 c4 04	 add	 esp, 4
  0000e	84 c0		 test	 al, al
  00010	74 04		 je	 SHORT $LN3@CalcDouble
; 1399 : 		return 0;
  00012	33 c0		 xor	 eax, eax
  00014	5e		 pop	 esi
; 1410 : }
  00015	c3		 ret	 0
$LN3@CalcDouble:
; 1400 : 
; 1401 : 	PCHAR S = Str;
; 1402 : 	while (*S != 0)
  00016	80 3e 00	 cmp	 BYTE PTR [esi], 0
  00019	8b c6		 mov	 eax, esi
  0001b	74 0d		 je	 SHORT $LN1@CalcDouble
$LL2@CalcDouble:
; 1403 : 	{
; 1404 : 		S = End(S); // 
  0001d	50		 push	 eax
  0001e	e8 00 00 00 00	 call	 ?End@?$STRUTILS@D@@SAPADPBD@Z ; STRUTILS<char>::End
; 1405 : 		S++;        // 
  00023	40		 inc	 eax
  00024	80 38 00	 cmp	 BYTE PTR [eax], 0
  00027	59		 pop	 ecx
  00028	75 f3		 jne	 SHORT $LL2@CalcDouble
$LN1@CalcDouble:
; 1406 : 	}
; 1407 : 	S++; // 
; 1408 : 
; 1409 :     return (S - Str);
  0002a	2b c6		 sub	 eax, esi
  0002c	40		 inc	 eax
  0002d	5e		 pop	 esi
; 1410 : }
  0002e	c3		 ret	 0
?CalcDoubleZeroStrLength@STR@@YAKPAD@Z ENDP		; STR::CalcDoubleZeroStrLength
_TEXT	ENDS
PUBLIC	?AnsiLowerCase@STR@@YAXPAD@Z			; STR::AnsiLowerCase
; Function compile flags: /Ogspy
;	COMDAT ?AnsiLowerCase@STR@@YAXPAD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?AnsiLowerCase@STR@@YAXPAD@Z PROC			; STR::AnsiLowerCase, COMDAT
; 1415 : {
  00000	56		 push	 esi
; 1416 : 	// 
; 1417 : 	// 
; 1418 : 	if (STR::IsEmpty(Str))
  00001	8b 74 24 08	 mov	 esi, DWORD PTR _Str$[esp]
  00005	56		 push	 esi
  00006	e8 00 00 00 00	 call	 ?IsEmpty@STR@@YA_NQAD@Z	; STR::IsEmpty
  0000b	83 c4 04	 add	 esp, 4
  0000e	84 c0		 test	 al, al
  00010	75 10		 jne	 SHORT $LN2@AnsiLowerC
; 1419 : 		return;
; 1420 : 
; 1421 :     DWORD Len = StrCalcLength(Str);
  00012	56		 push	 esi
  00013	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
; 1422 : 	pCharLowerBuffA(Str, Len);
  00018	50		 push	 eax
  00019	56		 push	 esi
  0001a	e8 00 00 00 00	 call	 ??$pushargEx@$02$0FPNKBIHB@$0BFG@PADK@@YAPAXPADK@Z ; pushargEx<3,1608128625,342,char *,unsigned long>
  0001f	83 c4 0c	 add	 esp, 12			; 0000000cH
$LN2@AnsiLowerC:
  00022	5e		 pop	 esi
; 1423 : }
  00023	c3		 ret	 0
?AnsiLowerCase@STR@@YAXPAD@Z ENDP			; STR::AnsiLowerCase
_TEXT	ENDS
PUBLIC	?ConvertToLinuxFormat@STR@@YAPADPAD@Z		; STR::ConvertToLinuxFormat
; Function compile flags: /Ogspy
;	COMDAT ?ConvertToLinuxFormat@STR@@YAPADPAD@Z
_TEXT	SEGMENT
_S$ = 8							; size = 4
?ConvertToLinuxFormat@STR@@YAPADPAD@Z PROC		; STR::ConvertToLinuxFormat, COMDAT
; 1463 : {
  00000	57		 push	 edi
; 1464 : 	// 
; 1465 : 	// 
; 1466 : 	if (STR::IsEmpty(S))
  00001	8b 7c 24 08	 mov	 edi, DWORD PTR _S$[esp]
  00005	57		 push	 edi
  00006	e8 00 00 00 00	 call	 ?IsEmpty@STR@@YA_NQAD@Z	; STR::IsEmpty
  0000b	83 c4 04	 add	 esp, 4
  0000e	84 c0		 test	 al, al
  00010	74 04		 je	 SHORT $LN5@ConvertToL
; 1467 : 		return NULL;
  00012	33 c0		 xor	 eax, eax
  00014	5f		 pop	 edi
; 1482 : 
; 1483 : 	return Result;
; 1484 : }
  00015	c3		 ret	 0
$LN5@ConvertToL:
  00016	56		 push	 esi
; 1468 : 
; 1469 :     DWORD Len = StrCalcLength(S);
  00017	57		 push	 edi
  00018	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  0001d	8b f0		 mov	 esi, eax
; 1470 : 	PCHAR Result = STR::Alloc(Len);
  0001f	56		 push	 esi
  00020	e8 00 00 00 00	 call	 ?Alloc@STR@@YAPADK@Z	; STR::Alloc
  00025	59		 pop	 ecx
  00026	59		 pop	 ecx
; 1471 : 
; 1472 : 	PCHAR Tmp = Result;
  00027	8b c8		 mov	 ecx, eax
; 1473 : 	for (DWORD i = 0; i < Len; i++, S++)
  00029	85 f6		 test	 esi, esi
  0002b	76 0e		 jbe	 SHORT $LN2@ConvertToL
$LL4@ConvertToL:
; 1474 : 	{
; 1475 : 		if (*S == '\r')
  0002d	8a 17		 mov	 dl, BYTE PTR [edi]
  0002f	80 fa 0d	 cmp	 dl, 13			; 0000000dH
  00032	74 03		 je	 SHORT $LN3@ConvertToL
; 1476 : 			continue;
; 1477 : 
; 1478 : 		*Tmp = *S;
  00034	88 11		 mov	 BYTE PTR [ecx], dl
; 1479 : 		Tmp++;
  00036	41		 inc	 ecx
$LN3@ConvertToL:
  00037	47		 inc	 edi
  00038	4e		 dec	 esi
  00039	75 f2		 jne	 SHORT $LL4@ConvertToL
$LN2@ConvertToL:
  0003b	5e		 pop	 esi
; 1480 : 	}
; 1481 : 	*Tmp = 0;
  0003c	c6 01 00	 mov	 BYTE PTR [ecx], 0
  0003f	5f		 pop	 edi
; 1482 : 
; 1483 : 	return Result;
; 1484 : }
  00040	c3		 ret	 0
?ConvertToLinuxFormat@STR@@YAPADPAD@Z ENDP		; STR::ConvertToLinuxFormat
_TEXT	ENDS
PUBLIC	?New@WSTR@@YAPA_WPA_WK@Z			; WSTR::New
; Function compile flags: /Ogspy
;	COMDAT ?New@WSTR@@YAPA_WPA_WK@Z
_TEXT	SEGMENT
_Source$ = 8						; size = 4
_Len$ = 12						; size = 4
?New@WSTR@@YAPA_WPA_WK@Z PROC				; WSTR::New, COMDAT
; 1505 : 	// 
 Source.
; 1506 : 	// Len - 
; 1507 : 	//       
; 1508 : 
; 1509 : 	if (Source == NULL) return NULL;
  00000	83 7c 24 04 00	 cmp	 DWORD PTR _Source$[esp-4], 0
  00005	75 03		 jne	 SHORT $LN4@New@2
  00007	33 c0		 xor	 eax, eax
; 1519 : 
; 1520 : }
  00009	c3		 ret	 0
$LN4@New@2:
  0000a	56		 push	 esi
; 1510 : 
; 1511 : 	if (Len == 0) Len = CalcLength(Source);
  0000b	8b 74 24 0c	 mov	 esi, DWORD PTR _Len$[esp]
  0000f	85 f6		 test	 esi, esi
  00011	75 12		 jne	 SHORT $LN2@New@2
  00013	ff 74 24 08	 push	 DWORD PTR _Source$[esp]
  00017	e8 00 00 00 00	 call	 ?CalcLength@WSTR@@YAKPA_W@Z ; WSTR::CalcLength
  0001c	8b f0		 mov	 esi, eax
  0001e	59		 pop	 ecx
; 1512 : 	if (Len == 0) return NULL;
  0001f	85 f6		 test	 esi, esi
  00021	75 02		 jne	 SHORT $LN2@New@2
  00023	5e		 pop	 esi
; 1519 : 
; 1520 : }
  00024	c3		 ret	 0
$LN2@New@2:
  00025	57		 push	 edi
; 1513 : 
; 1514 : 	PWCHAR Str = Alloc(Len);
  00026	56		 push	 esi
  00027	e8 00 00 00 00	 call	 ?Alloc@WSTR@@YAPA_WK@Z	; WSTR::Alloc
  0002c	8b f8		 mov	 edi, eax
  0002e	59		 pop	 ecx
; 1515 : 	if (Str != NULL)
  0002f	85 ff		 test	 edi, edi
  00031	74 11		 je	 SHORT $LN1@New@2
; 1516 : 		m_memcpy(Str, Source, Len * sizeof(WCHAR));
  00033	8d 04 36	 lea	 eax, DWORD PTR [esi+esi]
  00036	50		 push	 eax
  00037	ff 74 24 10	 push	 DWORD PTR _Source$[esp+8]
  0003b	57		 push	 edi
  0003c	e8 00 00 00 00	 call	 ?m_memcpy@@YAPAXPAXPBXH@Z ; m_memcpy
  00041	83 c4 0c	 add	 esp, 12			; 0000000cH
$LN1@New@2:
; 1517 : 
; 1518 : 	return Str;
  00044	8b c7		 mov	 eax, edi
  00046	5f		 pop	 edi
  00047	5e		 pop	 esi
; 1519 : 
; 1520 : }
  00048	c3		 ret	 0
?New@WSTR@@YAPA_WPA_WK@Z ENDP				; WSTR::New
_TEXT	ENDS
PUBLIC	?ToAnsi@WSTR@@YAPADPB_WK@Z			; WSTR::ToAnsi
; Function compile flags: /Ogspy
;	COMDAT ?ToAnsi@WSTR@@YAPADPB_WK@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_Len$ = 12						; size = 4
?ToAnsi@WSTR@@YAPADPB_WK@Z PROC				; WSTR::ToAnsi, COMDAT
; 1560 : 	// 
 WideString 
 ANSI String
; 1561 : 	if (IsEmpty((PWCHAR)Str)) return NULL;
  00000	ff 74 24 04	 push	 DWORD PTR _Str$[esp-4]
  00004	e8 00 00 00 00	 call	 ?IsEmpty@WSTR@@YA_NPA_W@Z ; WSTR::IsEmpty
  00009	83 c4 04	 add	 esp, 4
  0000c	84 c0		 test	 al, al
  0000e	74 03		 je	 SHORT $LN4@ToAnsi
  00010	33 c0		 xor	 eax, eax
; 1572 : }
  00012	c3		 ret	 0
$LN4@ToAnsi:
  00013	56		 push	 esi
; 1562 : 
; 1563 : 	if (Len == 0) Len = WSTR::CalcLength((PWCHAR)Str);
  00014	8b 74 24 0c	 mov	 esi, DWORD PTR _Len$[esp]
  00018	85 f6		 test	 esi, esi
  0001a	75 12		 jne	 SHORT $LN2@ToAnsi
  0001c	ff 74 24 08	 push	 DWORD PTR _Str$[esp]
  00020	e8 00 00 00 00	 call	 ?CalcLength@WSTR@@YAKPA_W@Z ; WSTR::CalcLength
  00025	8b f0		 mov	 esi, eax
  00027	59		 pop	 ecx
; 1564 : 	if (Len == 0) return NULL;
  00028	85 f6		 test	 esi, esi
  0002a	75 02		 jne	 SHORT $LN2@ToAnsi
  0002c	5e		 pop	 esi
; 1572 : }
  0002d	c3		 ret	 0
$LN2@ToAnsi:
  0002e	53		 push	 ebx
; 1565 : 
; 1566 : 	// 
; 1567 : 	PCHAR Result = STR::Alloc(Len);
  0002f	56		 push	 esi
  00030	e8 00 00 00 00	 call	 ?Alloc@STR@@YAPADK@Z	; STR::Alloc
  00035	8b d8		 mov	 ebx, eax
  00037	59		 pop	 ecx
; 1568 : 	if (Result != NULL)
  00038	85 db		 test	 ebx, ebx
  0003a	74 1a		 je	 SHORT $LN1@ToAnsi
; 1569 : 		pWideCharToMultiByte(1251, 0, Str, Len, Result, Len, NULL, NULL);
  0003c	6a 00		 push	 0
  0003e	6a 00		 push	 0
  00040	56		 push	 esi
  00041	53		 push	 ebx
  00042	56		 push	 esi
  00043	ff 74 24 20	 push	 DWORD PTR _Str$[esp+24]
  00047	6a 00		 push	 0
  00049	68 e3 04 00 00	 push	 1251			; 000004e3H
  0004e	e8 00 00 00 00	 call	 ??$pushargEx@$00$0OHEPFHOO@$0DA@HHPB_WKPADKHH@@YAPAXHHPB_WKPADKHH@Z ; pushargEx<1,3880736750,48,int,int,wchar_t const *,unsigned long,char *,unsigned long,int,int>
  00053	83 c4 20	 add	 esp, 32			; 00000020H
$LN1@ToAnsi:
; 1570 : 
; 1571 : 	return Result;
  00056	8b c3		 mov	 eax, ebx
  00058	5b		 pop	 ebx
  00059	5e		 pop	 esi
; 1572 : }
  0005a	c3		 ret	 0
?ToAnsi@WSTR@@YAPADPB_WK@Z ENDP				; WSTR::ToAnsi
_TEXT	ENDS
PUBLIC	?GetHash@WSTR@@YAKQA_WK_N@Z			; WSTR::GetHash
; Function compile flags: /Ogspy
;	COMDAT ?GetHash@WSTR@@YAKQA_WK_N@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_Len$ = 12						; size = 4
_LowerCase$ = 16					; size = 1
?GetHash@WSTR@@YAKQA_WK_N@Z PROC			; WSTR::GetHash, COMDAT
; 1601 :     return UnicodeStr::Hash(Str, Len, LowerCase);
  00000	e9 00 00 00 00	 jmp	 ?Hash@?$STRUTILS@_W@@SAKPB_WK_N@Z ; STRUTILS<wchar_t>::Hash
?GetHash@WSTR@@YAKQA_WK_N@Z ENDP			; WSTR::GetHash
_TEXT	ENDS
PUBLIC	?IsEmpty@TStrEnum@@QAE_NXZ			; TStrEnum::IsEmpty
; Function compile flags: /Ogspy
;	COMDAT ?IsEmpty@TStrEnum@@QAE_NXZ
_TEXT	SEGMENT
?IsEmpty@TStrEnum@@QAE_NXZ PROC				; TStrEnum::IsEmpty, COMDAT
; _this$ = ecx
; 1723 : 	return AnsiStr::IsEmpty(FBuf);
  00000	ff 71 04	 push	 DWORD PTR [ecx+4]
  00003	e8 00 00 00 00	 call	 ?IsEmpty@?$STRUTILS@D@@SA_NPBD@Z ; STRUTILS<char>::IsEmpty
  00008	59		 pop	 ecx
; 1724 : }
  00009	c3		 ret	 0
?IsEmpty@TStrEnum@@QAE_NXZ ENDP				; TStrEnum::IsEmpty
_TEXT	ENDS
PUBLIC	?IsEmpty@?$TString@D@@QBE_NXZ			; TString<char>::IsEmpty
; Function compile flags: /Ogspy
; File e:\projects\progs\petrosjan\bjwj\source\core\strimplementation.cpp
;	COMDAT ?IsEmpty@?$TString@D@@QBE_NXZ
_TEXT	SEGMENT
?IsEmpty@?$TString@D@@QBE_NXZ PROC			; TString<char>::IsEmpty, COMDAT
; _this$ = ecx
; 695  : 	return STRUTILS<TChar>::IsEmpty(Data);
  00000	ff 71 04	 push	 DWORD PTR [ecx+4]
  00003	e8 00 00 00 00	 call	 ?IsEmpty@?$STRUTILS@D@@SA_NPBD@Z ; STRUTILS<char>::IsEmpty
  00008	59		 pop	 ecx
; 696  : }
  00009	c3		 ret	 0
?IsEmpty@?$TString@D@@QBE_NXZ ENDP			; TString<char>::IsEmpty
_TEXT	ENDS
PUBLIC	?Compare@?$STRUTILS@D@@SAHPBD0@Z		; STRUTILS<char>::Compare
; Function compile flags: /Ogspy
;	COMDAT ?Compare@?$STRUTILS@D@@SAHPBD0@Z
_TEXT	SEGMENT
_Str1$ = 8						; size = 4
_Str2$ = 12						; size = 4
?Compare@?$STRUTILS@D@@SAHPBD0@Z PROC			; STRUTILS<char>::Compare, COMDAT
; 117  : 	return CompareEx(Str1, Str2, 0);
  00000	6a 00		 push	 0
  00002	ff 74 24 0c	 push	 DWORD PTR _Str2$[esp]
  00006	ff 74 24 0c	 push	 DWORD PTR _Str1$[esp+4]
  0000a	e8 00 00 00 00	 call	 ?CompareEx@?$STRUTILS@D@@SAHPBD0K@Z ; STRUTILS<char>::CompareEx
  0000f	83 c4 0c	 add	 esp, 12			; 0000000cH
; 118  : }
  00012	c3		 ret	 0
?Compare@?$STRUTILS@D@@SAHPBD0@Z ENDP			; STRUTILS<char>::Compare
_TEXT	ENDS
PUBLIC	?Hash@?$STRUTILS@D@@SAKPBD@Z			; STRUTILS<char>::Hash
; Function compile flags: /Ogspy
;	COMDAT ?Hash@?$STRUTILS@D@@SAKPBD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
?Hash@?$STRUTILS@D@@SAKPBD@Z PROC			; STRUTILS<char>::Hash, COMDAT
; 310  :     return Hash(Str, 0, false);
  00000	6a 00		 push	 0
  00002	6a 00		 push	 0
  00004	ff 74 24 0c	 push	 DWORD PTR _Str$[esp+4]
  00008	e8 00 00 00 00	 call	 ?Hash@?$STRUTILS@D@@SAKPBDK_N@Z ; STRUTILS<char>::Hash
  0000d	83 c4 0c	 add	 esp, 12			; 0000000cH
; 311  : }
  00010	c3		 ret	 0
?Hash@?$STRUTILS@D@@SAKPBD@Z ENDP			; STRUTILS<char>::Hash
_TEXT	ENDS
PUBLIC	??$AddRef@D@STRBUF@@YAPADPAD@Z			; STRBUF::AddRef<char>
; Function compile flags: /Ogspy
;	COMDAT ??$AddRef@D@STRBUF@@YAPADPAD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
??$AddRef@D@STRBUF@@YAPADPAD@Z PROC			; STRBUF::AddRef<char>, COMDAT
; 417  : 	// 
; 418  : 	if (Str)
  00000	8b 44 24 04	 mov	 eax, DWORD PTR _Str$[esp-4]
  00004	85 c0		 test	 eax, eax
  00006	74 03		 je	 SHORT $LN1@AddRef
; 419  : 		GetRec(Str).RefCount++;
  00008	ff 40 fc	 inc	 DWORD PTR [eax-4]
$LN1@AddRef:
; 420  : 	return Str;
; 421  : }
  0000b	c3		 ret	 0
??$AddRef@D@STRBUF@@YAPADPAD@Z ENDP			; STRBUF::AddRef<char>
_TEXT	ENDS
PUBLIC	??$Release@D@STRBUF@@YAXAAPAD@Z			; STRBUF::Release<char>
; Function compile flags: /Ogspy
;	COMDAT ??$Release@D@STRBUF@@YAXAAPAD@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
??$Release@D@STRBUF@@YAXAAPAD@Z PROC			; STRBUF::Release<char>, COMDAT
; 401  : {
  00000	56		 push	 esi
; 402  : 	// 
; 403  : 	if (Str)
  00001	8b 74 24 08	 mov	 esi, DWORD PTR _Str$[esp]
  00005	8b 06		 mov	 eax, DWORD PTR [esi]
  00007	85 c0		 test	 eax, eax
  00009	74 12		 je	 SHORT $LN2@Release
; 404  : 	{
; 405  : 		TStrRec &R = GetRec(Str);
  0000b	83 c0 f4	 add	 eax, -12		; fffffff4H
; 406  : 		R.RefCount--;
  0000e	ff 48 08	 dec	 DWORD PTR [eax+8]
; 407  : 		if (R.RefCount == 0)
  00011	75 07		 jne	 SHORT $LN1@Release
; 408  :             HEAP::Free(&R);
  00013	50		 push	 eax
  00014	e8 00 00 00 00	 call	 ?Free@HEAP@@YAXPAX@Z	; HEAP::Free
  00019	59		 pop	 ecx
$LN1@Release:
; 409  :         Str = NULL;
  0001a	83 26 00	 and	 DWORD PTR [esi], 0
$LN2@Release:
  0001d	5e		 pop	 esi
; 410  :     }
; 411  : }
  0001e	c3		 ret	 0
??$Release@D@STRBUF@@YAXAAPAD@Z ENDP			; STRBUF::Release<char>
_TEXT	ENDS
PUBLIC	??$CreateFromStr@D@STRBUF@@YAPADPBDKK@Z		; STRBUF::CreateFromStr<char>
; Function compile flags: /Ogspy
;	COMDAT ??$CreateFromStr@D@STRBUF@@YAPADPBDKK@Z
_TEXT	SEGMENT
_Str$ = 8						; size = 4
_StrLen$ = 12						; size = 4
_ResultStrSize$ = 16					; size = 4
??$CreateFromStr@D@STRBUF@@YAPADPBDKK@Z PROC		; STRBUF::CreateFromStr<char>, COMDAT
; 457  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
; 458  : 	// 
; 459  : 	if (STRUTILS<TChar>::IsEmpty(Str))
  00003	ff 75 08	 push	 DWORD PTR _Str$[ebp]
  00006	e8 00 00 00 00	 call	 ?IsEmpty@?$STRUTILS@D@@SA_NPBD@Z ; STRUTILS<char>::IsEmpty
  0000b	59		 pop	 ecx
  0000c	84 c0		 test	 al, al
  0000e	74 04		 je	 SHORT $LN3@CreateFrom
; 460  : 		return NULL;
  00010	33 c0		 xor	 eax, eax
; 474  : }
  00012	5d		 pop	 ebp
  00013	c3		 ret	 0
$LN3@CreateFrom:
  00014	56		 push	 esi
  00015	57		 push	 edi
; 461  : 
; 462  : 	if (StrLen == 0)
  00016	8b 7d 0c	 mov	 edi, DWORD PTR _StrLen$[ebp]
  00019	85 ff		 test	 edi, edi
  0001b	75 0b		 jne	 SHORT $LN2@CreateFrom
; 463  : 		StrLen = STRUTILS<TChar>::Length(Str);
  0001d	ff 75 08	 push	 DWORD PTR _Str$[ebp]
  00020	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  00025	59		 pop	 ecx
  00026	8b f8		 mov	 edi, eax
$LN2@CreateFrom:
; 464  : 
; 465  :     DWORD ResSize = Max(StrLen, ResultStrSize);
  00028	8b 45 10	 mov	 eax, DWORD PTR _ResultStrSize$[ebp]
  0002b	3b f8		 cmp	 edi, eax
  0002d	76 02		 jbe	 SHORT $LN6@CreateFrom
  0002f	8b c7		 mov	 eax, edi
$LN6@CreateFrom:
; 466  : 	TChar* Result = Alloc<TChar>(ResSize);
  00031	50		 push	 eax
  00032	e8 00 00 00 00	 call	 ??$Alloc@D@STRBUF@@YAPADK@Z ; STRBUF::Alloc<char>
  00037	8b f0		 mov	 esi, eax
  00039	59		 pop	 ecx
; 467  : 	if (Result)
  0003a	85 f6		 test	 esi, esi
  0003c	74 10		 je	 SHORT $LN1@CreateFrom
; 468  : 	{
; 469  : 		// 
; 470  : 		m_memcpy(Result, Str, StrLen * sizeof(TChar));
  0003e	57		 push	 edi
  0003f	ff 75 08	 push	 DWORD PTR _Str$[ebp]
  00042	56		 push	 esi
  00043	e8 00 00 00 00	 call	 ?m_memcpy@@YAPAXPAXPBXH@Z ; m_memcpy
  00048	83 c4 0c	 add	 esp, 12			; 0000000cH
; 471  : 		GetRec(Result).Length = StrLen;
  0004b	89 7e f8	 mov	 DWORD PTR [esi-8], edi
$LN1@CreateFrom:
  0004e	5f		 pop	 edi
; 472  : 	}
; 473  : 	return Result;
  0004f	8b c6		 mov	 eax, esi
  00051	5e		 pop	 esi
; 474  : }
  00052	5d		 pop	 ebp
  00053	c3		 ret	 0
??$CreateFromStr@D@STRBUF@@YAPADPBDKK@Z ENDP		; STRBUF::CreateFromStr<char>
_TEXT	ENDS
PUBLIC	?GetTextBetween@@YAPADAAPADPAD1@Z		; GetTextBetween
; Function compile flags: /Ogspy
; File e:\projects\progs\petrosjan\bjwj\source\core\strings.cpp
;	COMDAT ?GetTextBetween@@YAPADAAPADPAD1@Z
_TEXT	SEGMENT
_Len$ = -12						; size = 4
_Start$ = -8						; size = 4
_End$ = -4						; size = 4
_Buffer$ = 8						; size = 4
_Before$ = 12						; size = 4
_After$ = 16						; size = 4
?GetTextBetween@@YAPADAAPADPAD1@Z PROC			; GetTextBetween, COMDAT
; 580  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 0c	 sub	 esp, 12			; 0000000cH
  00006	56		 push	 esi
  00007	57		 push	 edi
; 581  :     // 
 HTML 
 Before 
 After
; 582  : 	if (STR::IsEmpty(Before) || STR::IsEmpty(After))
  00008	ff 75 0c	 push	 DWORD PTR _Before$[ebp]
  0000b	e8 00 00 00 00	 call	 ?IsEmpty@STR@@YA_NQAD@Z	; STR::IsEmpty
  00010	83 c4 04	 add	 esp, 4
  00013	84 c0		 test	 al, al
  00015	75 6e		 jne	 SHORT $LN4@GetTextBet
  00017	ff 75 10	 push	 DWORD PTR _After$[ebp]
  0001a	e8 00 00 00 00	 call	 ?IsEmpty@STR@@YA_NQAD@Z	; STR::IsEmpty
  0001f	83 c4 04	 add	 esp, 4
  00022	84 c0		 test	 al, al
  00024	75 5f		 jne	 SHORT $LN4@GetTextBet
; 584  : 
; 585  : 	DWORD Start = 0;
; 586  : 	DWORD End   = 0;
; 587  : 	DWORD Len   = 0;
; 588  : 
; 589  : 	if (WildCmp(Buffer, Before, &Start, &End, &Len ))
  00026	8b 7d 08	 mov	 edi, DWORD PTR _Buffer$[ebp]
  00029	83 65 f8 00	 and	 DWORD PTR _Start$[ebp], 0
  0002d	83 65 fc 00	 and	 DWORD PTR _End$[ebp], 0
  00031	8d 45 f4	 lea	 eax, DWORD PTR _Len$[ebp]
  00034	50		 push	 eax
  00035	8d 45 fc	 lea	 eax, DWORD PTR _End$[ebp]
  00038	50		 push	 eax
  00039	8d 45 f8	 lea	 eax, DWORD PTR _Start$[ebp]
  0003c	50		 push	 eax
  0003d	ff 75 0c	 push	 DWORD PTR _Before$[ebp]
  00040	ff 37		 push	 DWORD PTR [edi]
  00042	e8 00 00 00 00	 call	 ?WildCmp@@YA_NPBD0PAK11@Z ; WildCmp
  00047	83 c4 14	 add	 esp, 20			; 00000014H
  0004a	84 c0		 test	 al, al
  0004c	74 37		 je	 SHORT $LN4@GetTextBet
; 590  : 	{
; 591  : 		PCHAR StartPtr = Buffer + End;
  0004e	8b 37		 mov	 esi, DWORD PTR [edi]
  00050	03 75 fc	 add	 esi, DWORD PTR _End$[ebp]
; 592  : 		if (WildCmp(StartPtr, After, &Start, &End, &Len ) )
  00053	8d 45 f4	 lea	 eax, DWORD PTR _Len$[ebp]
  00056	50		 push	 eax
  00057	8d 45 fc	 lea	 eax, DWORD PTR _End$[ebp]
  0005a	50		 push	 eax
  0005b	8d 45 f8	 lea	 eax, DWORD PTR _Start$[ebp]
  0005e	50		 push	 eax
  0005f	ff 75 10	 push	 DWORD PTR _After$[ebp]
  00062	56		 push	 esi
  00063	e8 00 00 00 00	 call	 ?WildCmp@@YA_NPBD0PAK11@Z ; WildCmp
  00068	83 c4 14	 add	 esp, 20			; 00000014H
  0006b	84 c0		 test	 al, al
  0006d	74 16		 je	 SHORT $LN4@GetTextBet
; 593  : 		{
; 594  : 			PCHAR EndPtr = StartPtr + Start;
  0006f	8b 45 f8	 mov	 eax, DWORD PTR _Start$[ebp]
  00072	03 c6		 add	 eax, esi
; 595  : 			// 
; 596  : 			Buffer = EndPtr;
  00074	89 07		 mov	 DWORD PTR [edi], eax
; 597  : 
; 598  : 			DWORD Size = EndPtr - StartPtr;
  00076	2b c6		 sub	 eax, esi
; 599  : 			if (Size > 0)
  00078	74 0b		 je	 SHORT $LN4@GetTextBet
; 600  : 				return STR::New(StartPtr, Size);
  0007a	50		 push	 eax
  0007b	56		 push	 esi
  0007c	e8 00 00 00 00	 call	 ?New@STR@@YAPADPADK@Z	; STR::New
  00081	59		 pop	 ecx
  00082	59		 pop	 ecx
  00083	eb 02		 jmp	 SHORT $LN6@GetTextBet
$LN4@GetTextBet:
; 583  : 		return NULL;
  00085	33 c0		 xor	 eax, eax
$LN6@GetTextBet:
  00087	5f		 pop	 edi
  00088	5e		 pop	 esi
; 601  : 		}
; 602  : 	}
; 603  : 	return NULL;
; 604  : }
  00089	c9		 leave
  0008a	c3		 ret	 0
?GetTextBetween@@YAPADAAPADPAD1@Z ENDP			; GetTextBetween
_TEXT	ENDS
PUBLIC	?Replace@STR@@YAPADPAD00K@Z			; STR::Replace
; Function compile flags: /Ogspy
;	COMDAT ?Replace@STR@@YAPADPAD00K@Z
_TEXT	SEGMENT
_SrcLen$ = -8						; size = 4
_DstLen$ = -4						; size = 4
_Str$ = 8						; size = 4
_SrcStr$ = 12						; size = 4
_DstStr$ = 16						; size = 4
_StrLen$ = 20						; size = 4
?Replace@STR@@YAPADPAD00K@Z PROC			; STR::Replace, COMDAT
; 787  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
  00004	51		 push	 ecx
  00005	53		 push	 ebx
  00006	56		 push	 esi
  00007	57		 push	 edi
; 788  : 	//  
 SrcStr 
; 789  : 	//  
 DstStr.
; 790  : 	//  
; 791  : 
; 792  : 	if (STR::IsEmpty(Str) || STR::IsEmpty(SrcStr)) return NULL;
  00008	ff 75 08	 push	 DWORD PTR _Str$[ebp]
  0000b	e8 00 00 00 00	 call	 ?IsEmpty@STR@@YA_NQAD@Z	; STR::IsEmpty
  00010	83 c4 04	 add	 esp, 4
  00013	84 c0		 test	 al, al
  00015	0f 85 aa 00 00
	00		 jne	 $LN4@Replace
  0001b	ff 75 0c	 push	 DWORD PTR _SrcStr$[ebp]
  0001e	e8 00 00 00 00	 call	 ?IsEmpty@STR@@YA_NQAD@Z	; STR::IsEmpty
  00023	83 c4 04	 add	 esp, 4
  00026	84 c0		 test	 al, al
  00028	0f 85 97 00 00
	00		 jne	 $LN4@Replace
; 793  : 
; 794  : 	int P = Pos(Str, SrcStr, StrLen);
  0002e	8b 75 14	 mov	 esi, DWORD PTR _StrLen$[ebp]
  00031	6a 01		 push	 1
  00033	56		 push	 esi
  00034	ff 75 0c	 push	 DWORD PTR _SrcStr$[ebp]
  00037	ff 75 08	 push	 DWORD PTR _Str$[ebp]
  0003a	e8 00 00 00 00	 call	 ?Pos@STR@@YAHPBD0K_N@Z	; STR::Pos
  0003f	8b d8		 mov	 ebx, eax
  00041	83 c4 10	 add	 esp, 16			; 00000010H
; 795  : 	if (P < 0) return NULL;
  00044	85 db		 test	 ebx, ebx
  00046	7c 7d		 jl	 SHORT $LN4@Replace
; 796  : 
; 797  : 	DWORD SrcLen = StrCalcLength(SrcStr);
  00048	ff 75 0c	 push	 DWORD PTR _SrcStr$[ebp]
  0004b	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
; 798  : 	DWORD DstLen = StrCalcLength(DstStr);
  00050	ff 75 10	 push	 DWORD PTR _DstStr$[ebp]
  00053	89 45 f8	 mov	 DWORD PTR _SrcLen$[ebp], eax
  00056	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  0005b	59		 pop	 ecx
  0005c	59		 pop	 ecx
  0005d	89 45 fc	 mov	 DWORD PTR _DstLen$[ebp], eax
; 799  : 	if (StrLen == 0)
  00060	85 f6		 test	 esi, esi
  00062	75 0b		 jne	 SHORT $LN2@Replace
; 800  : 		StrLen = StrCalcLength(Str);
  00064	ff 75 08	 push	 DWORD PTR _Str$[ebp]
  00067	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@D@@SAKPBD@Z ; STRUTILS<char>::Length
  0006c	59		 pop	 ecx
  0006d	8b f0		 mov	 esi, eax
$LN2@Replace:
; 801  : 
; 802  : 	DWORD NewLen = StrLen + (DstLen - SrcLen);
; 803  : 
; 804  : 	// 
; 805  : 	PCHAR Result = STR::Alloc(NewLen);
  0006f	8b 45 fc	 mov	 eax, DWORD PTR _DstLen$[ebp]
  00072	2b 45 f8	 sub	 eax, DWORD PTR _SrcLen$[ebp]
  00075	03 c6		 add	 eax, esi
  00077	50		 push	 eax
  00078	e8 00 00 00 00	 call	 ?Alloc@STR@@YAPADK@Z	; STR::Alloc
  0007d	8b f8		 mov	 edi, eax
  0007f	59		 pop	 ecx
; 806  : 	if (Result == NULL) return NULL;
  00080	85 ff		 test	 edi, edi
  00082	74 41		 je	 SHORT $LN4@Replace
; 807  : 
; 808  : 	Copy(Str, Result, 0, P);
  00084	53		 push	 ebx
  00085	6a 00		 push	 0
  00087	57		 push	 edi
  00088	ff 75 08	 push	 DWORD PTR _Str$[ebp]
  0008b	e8 00 00 00 00	 call	 ?Copy@STR@@YAXPAD0KK@Z	; STR::Copy
; 809  : 	Copy(DstStr, Result + P, 0, DstLen);
  00090	ff 75 fc	 push	 DWORD PTR _DstLen$[ebp]
  00093	8d 04 1f	 lea	 eax, DWORD PTR [edi+ebx]
  00096	6a 00		 push	 0
  00098	50		 push	 eax
  00099	ff 75 10	 push	 DWORD PTR _DstStr$[ebp]
  0009c	e8 00 00 00 00	 call	 ?Copy@STR@@YAXPAD0KK@Z	; STR::Copy
; 810  : 	Copy(Str + P + SrcLen, Result + P + DstLen, 0, StrLen - (P + SrcLen));
  000a1	8b 45 f8	 mov	 eax, DWORD PTR _SrcLen$[ebp]
  000a4	8b 4d fc	 mov	 ecx, DWORD PTR _DstLen$[ebp]
  000a7	2b f0		 sub	 esi, eax
  000a9	2b f3		 sub	 esi, ebx
  000ab	56		 push	 esi
  000ac	03 cf		 add	 ecx, edi
  000ae	03 c3		 add	 eax, ebx
  000b0	03 45 08	 add	 eax, DWORD PTR _Str$[ebp]
  000b3	6a 00		 push	 0
  000b5	03 cb		 add	 ecx, ebx
  000b7	51		 push	 ecx
  000b8	50		 push	 eax
  000b9	e8 00 00 00 00	 call	 ?Copy@STR@@YAXPAD0KK@Z	; STR::Copy
  000be	83 c4 30	 add	 esp, 48			; 00000030H
; 811  : 
; 812  : 	return Result;
  000c1	8b c7		 mov	 eax, edi
  000c3	eb 02		 jmp	 SHORT $LN6@Replace
$LN4@Replace:
; 788  : 	//  
 SrcStr 
; 789  : 	//  
 DstStr.
; 790  : 	//  
; 791  : 
; 792  : 	if (STR::IsEmpty(Str) || STR::IsEmpty(SrcStr)) return NULL;
  000c5	33 c0		 xor	 eax, eax
$LN6@Replace:
  000c7	5f		 pop	 edi
  000c8	5e		 pop	 esi
  000c9	5b		 pop	 ebx
; 813  : }
  000ca	c9		 leave
  000cb	c3		 ret	 0
?Replace@STR@@YAPADPAD00K@Z ENDP			; STR::Replace
_TEXT	ENDS
PUBLIC	?StrCompare@@YAHPBD0@Z				; StrCompare
; Function compile flags: /Ogspy
;	COMDAT ?StrCompare@@YAHPBD0@Z
_TEXT	SEGMENT
_Str1$ = 8						; size = 4
_Str2$ = 12						; size = 4
?StrCompare@@YAHPBD0@Z PROC				; StrCompare, COMDAT
; 1022 :     // 
; 1023 : 	return STRA::Compare(Str1, Str2);
  00000	6a 00		 push	 0
  00002	ff 74 24 0c	 push	 DWORD PTR _Str2$[esp]
  00006	ff 74 24 0c	 push	 DWORD PTR _Str1$[esp+4]
  0000a	e8 00 00 00 00	 call	 ?CompareEx@?$STRUTILS@D@@SAHPBD0K@Z ; STRUTILS<char>::CompareEx
  0000f	83 c4 0c	 add	 esp, 12			; 0000000cH
; 1024 : }
  00012	c3		 ret	 0
?StrCompare@@YAHPBD0@Z ENDP				; StrCompare
_TEXT	ENDS
PUBLIC	?Initialize@TStrEnum@@AAEXPBD_NK@Z		; TStrEnum::Initialize
; Function compile flags: /Ogspy
;	COMDAT ?Initialize@TStrEnum@@AAEXPBD_NK@Z
_TEXT	SEGMENT
_Buffer$ = 8						; size = 4
_Encrypted$ = 12					; size = 1
_EmptyBufHash$ = 16					; size = 4
?Initialize@TStrEnum@@AAEXPBD_NK@Z PROC			; TStrEnum::Initialize, COMDAT
; _this$ = ecx
; 1685 : {
  00000	53		 push	 ebx
  00001	56		 push	 esi
  00002	57		 push	 edi
; 1686 : 	FBuf = (PCHAR)Buffer;
  00003	8b 7c 24 10	 mov	 edi, DWORD PTR _Buffer$[esp+8]
  00007	8b f1		 mov	 esi, ecx
; 1687 : 
; 1688 : 	if (AnsiStr::IsEmpty(FBuf) || (EmptyBufHash &&  AnsiStr::Hash(FBuf) == EmptyBufHash))
  00009	57		 push	 edi
  0000a	89 7e 04	 mov	 DWORD PTR [esi+4], edi
  0000d	e8 00 00 00 00	 call	 ?IsEmpty@?$STRUTILS@D@@SA_NPBD@Z ; STRUTILS<char>::IsEmpty
  00012	33 db		 xor	 ebx, ebx
  00014	59		 pop	 ecx
  00015	84 c0		 test	 al, al
  00017	75 17		 jne	 SHORT $LN1@Initialize
  00019	39 5c 24 18	 cmp	 DWORD PTR _EmptyBufHash$[esp+8], ebx
  0001d	74 14		 je	 SHORT $LN2@Initialize
  0001f	53		 push	 ebx
  00020	53		 push	 ebx
  00021	57		 push	 edi
  00022	e8 00 00 00 00	 call	 ?Hash@?$STRUTILS@D@@SAKPBDK_N@Z ; STRUTILS<char>::Hash
  00027	83 c4 0c	 add	 esp, 12			; 0000000cH
  0002a	3b 44 24 18	 cmp	 eax, DWORD PTR _EmptyBufHash$[esp+8]
  0002e	75 03		 jne	 SHORT $LN2@Initialize
$LN1@Initialize:
; 1689 : 		FBuf = NULL;
  00030	89 5e 04	 mov	 DWORD PTR [esi+4], ebx
$LN2@Initialize:
; 1690 : 
; 1691 : 	FEncrypted = Encrypted;
  00033	8a 44 24 14	 mov	 al, BYTE PTR _Encrypted$[esp+8]
  00037	5f		 pop	 edi
; 1692 : 	FCurrent   = NULL;
  00038	89 5e 0c	 mov	 DWORD PTR [esi+12], ebx
  0003b	88 46 08	 mov	 BYTE PTR [esi+8], al
  0003e	5e		 pop	 esi
  0003f	5b		 pop	 ebx
; 1693 : }
  00040	c2 0c 00	 ret	 12			; 0000000cH
?Initialize@TStrEnum@@AAEXPBD_NK@Z ENDP			; TStrEnum::Initialize
_TEXT	ENDS
PUBLIC	??0?$TString@D@@QAE@ABV0@@Z			; TString<char>::TString<char>
; Function compile flags: /Ogspy
; File e:\projects\progs\petrosjan\bjwj\source\core\strimplementation.cpp
;	COMDAT ??0?$TString@D@@QAE@ABV0@@Z
_TEXT	SEGMENT
_src$ = 8						; size = 4
??0?$TString@D@@QAE@ABV0@@Z PROC			; TString<char>::TString<char>, COMDAT
; _this$ = ecx
; 661  : 	Data = STRBUF::AddRef<TChar>(src.Data);
  00000	8b 44 24 04	 mov	 eax, DWORD PTR _src$[esp-4]
  00004	56		 push	 esi
  00005	8b f1		 mov	 esi, ecx
  00007	c7 06 00 00 00
	00		 mov	 DWORD PTR [esi], OFFSET ??_7?$TString@D@@6B@
  0000d	ff 70 04	 push	 DWORD PTR [eax+4]
  00010	e8 00 00 00 00	 call	 ??$AddRef@D@STRBUF@@YAPADPAD@Z ; STRBUF::AddRef<char>
  00015	89 46 04	 mov	 DWORD PTR [esi+4], eax
  00018	59		 pop	 ecx
; 662  : }
  00019	8b c6		 mov	 eax, esi
  0001b	5e		 pop	 esi
  0001c	c2 04 00	 ret	 4
??0?$TString@D@@QAE@ABV0@@Z ENDP			; TString<char>::TString<char>
_TEXT	ENDS
PUBLIC	??1?$TString@D@@UAE@XZ				; TString<char>::~TString<char>
; Function compile flags: /Ogspy
;	COMDAT ??1?$TString@D@@UAE@XZ
_TEXT	SEGMENT
??1?$TString@D@@UAE@XZ PROC				; TString<char>::~TString<char>, COMDAT
; _this$ = ecx
; 676  : {
  00000	56		 push	 esi
  00001	8b f1		 mov	 esi, ecx
; 677  : 	STRBUF::Release<TChar>(Data);
  00003	8d 46 04	 lea	 eax, DWORD PTR [esi+4]
  00006	50		 push	 eax
  00007	c7 06 00 00 00
	00		 mov	 DWORD PTR [esi], OFFSET ??_7?$TString@D@@6B@
  0000d	e8 00 00 00 00	 call	 ??$Release@D@STRBUF@@YAXAAPAD@Z ; STRBUF::Release<char>
  00012	59		 pop	 ecx
; 678  : }
  00013	c7 06 00 00 00
	00		 mov	 DWORD PTR [esi], OFFSET ??_7TBotObject@@6B@
  00019	5e		 pop	 esi
  0001a	c3		 ret	 0
??1?$TString@D@@UAE@XZ ENDP				; TString<char>::~TString<char>
_TEXT	ENDS
PUBLIC	?SetLength@?$TString@D@@QAEXK@Z			; TString<char>::SetLength
; Function compile flags: /Ogspy
;	COMDAT ?SetLength@?$TString@D@@QAEXK@Z
_TEXT	SEGMENT
_Tmp$66135 = 8						; size = 4
_NewLength$ = 8						; size = 4
?SetLength@?$TString@D@@QAEXK@Z PROC			; TString<char>::SetLength, COMDAT
; _this$ = ecx
; 800  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	56		 push	 esi
  00004	57		 push	 edi
; 801  : 	// 
; 802  : 	if (NewLength == 0)
  00005	8b 7d 08	 mov	 edi, DWORD PTR _NewLength$[ebp]
  00008	8b f1		 mov	 esi, ecx
  0000a	85 ff		 test	 edi, edi
  0000c	75 0c		 jne	 SHORT $LN6@SetLength
; 803  : 		STRBUF::Release<TChar>(Data);
  0000e	83 c6 04	 add	 esi, 4
  00011	56		 push	 esi
  00012	e8 00 00 00 00	 call	 ??$Release@D@STRBUF@@YAXAAPAD@Z ; STRBUF::Release<char>
  00017	59		 pop	 ecx
; 804  : 	else
  00018	eb 47		 jmp	 SHORT $LN5@SetLength
$LN6@SetLength:
; 805  : 	{
; 806  : 		if (Data)
  0001a	8b 46 04	 mov	 eax, DWORD PTR [esi+4]
  0001d	85 c0		 test	 eax, eax
  0001f	74 30		 je	 SHORT $LN4@SetLength
; 807  : 		{
; 808  : 			STRBUF::TStrRec &Rec = STRBUF::GetRec<TChar>(Data);
; 809  : 
; 810  : 			if (Rec.RefCount > 1 || Rec.Size < NewLength)
  00021	83 78 fc 01	 cmp	 DWORD PTR [eax-4], 1
  00025	77 05		 ja	 SHORT $LN2@SetLength
  00027	39 78 f4	 cmp	 DWORD PTR [eax-12], edi
  0002a	73 1c		 jae	 SHORT $LN3@SetLength
$LN2@SetLength:
; 811  : 			{
; 812  : 				TChar* Tmp = Data;
; 813  : 				Data = STRBUF::CreateFromStr<TChar>(Tmp, Rec.Length, NewLength);
  0002c	57		 push	 edi
  0002d	ff 70 f8	 push	 DWORD PTR [eax-8]
  00030	89 45 08	 mov	 DWORD PTR _Tmp$66135[ebp], eax
  00033	50		 push	 eax
  00034	e8 00 00 00 00	 call	 ??$CreateFromStr@D@STRBUF@@YAPADPBDKK@Z ; STRBUF::CreateFromStr<char>
  00039	89 46 04	 mov	 DWORD PTR [esi+4], eax
; 814  : 				STRBUF::Release<TChar>(Tmp);
  0003c	8d 45 08	 lea	 eax, DWORD PTR _Tmp$66135[ebp]
  0003f	50		 push	 eax
  00040	e8 00 00 00 00	 call	 ??$Release@D@STRBUF@@YAXAAPAD@Z ; STRBUF::Release<char>
  00045	83 c4 10	 add	 esp, 16			; 00000010H
$LN3@SetLength:
; 815  : 			}
; 816  : 			*(Data + NewLength) = 0;
  00048	8b 46 04	 mov	 eax, DWORD PTR [esi+4]
  0004b	c6 04 07 00	 mov	 BYTE PTR [edi+eax], 0
; 817  : 		}
; 818  : 		else
  0004f	eb 0a		 jmp	 SHORT $LN1@SetLength
$LN4@SetLength:
; 819  : 			Data = STRBUF::Alloc<TChar>(NewLength);
  00051	57		 push	 edi
  00052	e8 00 00 00 00	 call	 ??$Alloc@D@STRBUF@@YAPADK@Z ; STRBUF::Alloc<char>
  00057	59		 pop	 ecx
  00058	89 46 04	 mov	 DWORD PTR [esi+4], eax
$LN1@SetLength:
; 820  : 
; 821  :         STRBUF::GetRec<TChar>(Data).Length = NewLength;
  0005b	8b 46 04	 mov	 eax, DWORD PTR [esi+4]
  0005e	89 78 f8	 mov	 DWORD PTR [eax-8], edi
$LN5@SetLength:
  00061	5f		 pop	 edi
  00062	5e		 pop	 esi
; 822  : 	}
; 823  : }
  00063	5d		 pop	 ebp
  00064	c2 04 00	 ret	 4
?SetLength@?$TString@D@@QAEXK@Z ENDP			; TString<char>::SetLength
_TEXT	ENDS
PUBLIC	?LongToStr@?$TString@D@@QAEAAV1@K@Z		; TString<char>::LongToStr
; Function compile flags: /Ogspy
;	COMDAT ?LongToStr@?$TString@D@@QAEAAV1@K@Z
_TEXT	SEGMENT
_n$ = -4						; size = 4
_num$ = 8						; size = 4
?LongToStr@?$TString@D@@QAEAAV1@K@Z PROC		; TString<char>::LongToStr, COMDAT
; _this$ = ecx
; 863  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
  00004	56		 push	 esi
  00005	57		 push	 edi
  00006	8b f9		 mov	 edi, ecx
; 864  : 	STRBUF::Release<TChar>(Data);
  00008	8d 77 04	 lea	 esi, DWORD PTR [edi+4]
  0000b	56		 push	 esi
  0000c	e8 00 00 00 00	 call	 ??$Release@D@STRBUF@@YAXAAPAD@Z ; STRBUF::Release<char>
; 865  : 	int n = 0;
  00011	83 65 fc 00	 and	 DWORD PTR _n$[ebp], 0
; 866  : 	STRUTILS<TChar>::LongToString(num, NULL, n);
  00015	8d 45 fc	 lea	 eax, DWORD PTR _n$[ebp]
  00018	50		 push	 eax
  00019	6a 00		 push	 0
  0001b	ff 75 08	 push	 DWORD PTR _num$[ebp]
  0001e	e8 00 00 00 00	 call	 ?LongToString@?$STRUTILS@D@@SAXKPADAAH@Z ; STRUTILS<char>::LongToString
  00023	83 c4 10	 add	 esp, 16			; 00000010H
; 867  : 	SetLength(n);
  00026	ff 75 fc	 push	 DWORD PTR _n$[ebp]
  00029	8b cf		 mov	 ecx, edi
  0002b	e8 00 00 00 00	 call	 ?SetLength@?$TString@D@@QAEXK@Z ; TString<char>::SetLength
; 868  : 	STRUTILS<TChar>::LongToString(num, Data, n);
  00030	8d 45 fc	 lea	 eax, DWORD PTR _n$[ebp]
  00033	50		 push	 eax
  00034	ff 36		 push	 DWORD PTR [esi]
  00036	ff 75 08	 push	 DWORD PTR _num$[ebp]
  00039	e8 00 00 00 00	 call	 ?LongToString@?$STRUTILS@D@@SAXKPADAAH@Z ; STRUTILS<char>::LongToString
  0003e	83 c4 0c	 add	 esp, 12			; 0000000cH
; 869  : 	return *this;
  00041	8b c7		 mov	 eax, edi
  00043	5f		 pop	 edi
  00044	5e		 pop	 esi
; 870  : }
  00045	c9		 leave
  00046	c2 04 00	 ret	 4
?LongToStr@?$TString@D@@QAEAAV1@K@Z ENDP		; TString<char>::LongToStr
_TEXT	ENDS
PUBLIC	??4?$TString@D@@QAEAAV0@PBD@Z			; TString<char>::operator=
; Function compile flags: /Ogspy
;	COMDAT ??4?$TString@D@@QAEAAV0@PBD@Z
_TEXT	SEGMENT
_Source$ = 8						; size = 4
??4?$TString@D@@QAEAAV0@PBD@Z PROC			; TString<char>::operator=, COMDAT
; _this$ = ecx
; 914  : {
  00000	56		 push	 esi
  00001	57		 push	 edi
  00002	8b f9		 mov	 edi, ecx
; 915  : 	STRBUF::Release<TChar>(Data);
  00004	8d 77 04	 lea	 esi, DWORD PTR [edi+4]
  00007	56		 push	 esi
  00008	e8 00 00 00 00	 call	 ??$Release@D@STRBUF@@YAXAAPAD@Z ; STRBUF::Release<char>
; 916  : 	Data = STRBUF::CreateFromStr<TChar>(Source, 0, 0);
  0000d	6a 00		 push	 0
  0000f	6a 00		 push	 0
  00011	ff 74 24 18	 push	 DWORD PTR _Source$[esp+16]
  00015	e8 00 00 00 00	 call	 ??$CreateFromStr@D@STRBUF@@YAPADPBDKK@Z ; STRBUF::CreateFromStr<char>
  0001a	83 c4 10	 add	 esp, 16			; 00000010H
  0001d	89 06		 mov	 DWORD PTR [esi], eax
; 917  : 	return *this;
  0001f	8b c7		 mov	 eax, edi
  00021	5f		 pop	 edi
  00022	5e		 pop	 esi
; 918  : }
  00023	c2 04 00	 ret	 4
??4?$TString@D@@QAEAAV0@PBD@Z ENDP			; TString<char>::operator=
_TEXT	ENDS
PUBLIC	?LongToStr@@YA?AV?$TString@D@@K@Z		; LongToStr
; Function compile flags: /Ogspy
; File e:\projects\progs\petrosjan\bjwj\source\core\strings.cpp
;	COMDAT ?LongToStr@@YA?AV?$TString@D@@K@Z
_TEXT	SEGMENT
$T67309 = -8						; size = 8
___$ReturnUdt$ = 8					; size = 4
_num$ = 12						; size = 4
?LongToStr@@YA?AV?$TString@D@@K@Z PROC			; LongToStr, COMDAT
; 894  : {
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
  00004	51		 push	 ecx
; 895  : 	return string().LongToStr(num);
  00005	ff 75 0c	 push	 DWORD PTR _num$[ebp]
  00008	83 65 fc 00	 and	 DWORD PTR $T67309[ebp+4], 0
  0000c	8d 4d f8	 lea	 ecx, DWORD PTR $T67309[ebp]
  0000f	c7 45 f8 00 00
	00 00		 mov	 DWORD PTR $T67309[ebp], OFFSET ??_7?$TString@D@@6B@
  00016	e8 00 00 00 00	 call	 ?LongToStr@?$TString@D@@QAEAAV1@K@Z ; TString<char>::LongToStr
  0001b	8b 4d 08	 mov	 ecx, DWORD PTR ___$ReturnUdt$[ebp]
  0001e	50		 push	 eax
  0001f	e8 00 00 00 00	 call	 ??0?$TString@D@@QAE@ABV0@@Z ; TString<char>::TString<char>
  00024	8d 4d f8	 lea	 ecx, DWORD PTR $T67309[ebp]
  00027	e8 00 00 00 00	 call	 ??1?$TString@D@@UAE@XZ	; TString<char>::~TString<char>
  0002c	8b 45 08	 mov	 eax, DWORD PTR ___$ReturnUdt$[ebp]
; 896  : }
  0002f	c9		 leave
  00030	c3		 ret	 0
?LongToStr@@YA?AV?$TString@D@@K@Z ENDP			; LongToStr
_TEXT	ENDS
PUBLIC	?UnicodeToAnsi@@YA?AV?$TString@D@@PB_WK@Z	; UnicodeToAnsi
; Function compile flags: /Ogspy
;	COMDAT ?UnicodeToAnsi@@YA?AV?$TString@D@@PB_WK@Z
_TEXT	SEGMENT
___$ReturnUdt$ = 8					; size = 4
_Str$ = 12						; size = 4
_Len$ = 16						; size = 4
?UnicodeToAnsi@@YA?AV?$TString@D@@PB_WK@Z PROC		; UnicodeToAnsi, COMDAT
; 1632 : {
  00000	56		 push	 esi
; 1633 : 	string Result;
  00001	8b 74 24 08	 mov	 esi, DWORD PTR ___$ReturnUdt$[esp]
  00005	83 66 04 00	 and	 DWORD PTR [esi+4], 0
  00009	57		 push	 edi
; 1634 : 
; 1635 : 	if (!Len) Len = STRW::Length(Str);
  0000a	8b 7c 24 14	 mov	 edi, DWORD PTR _Len$[esp+4]
  0000e	c7 06 00 00 00
	00		 mov	 DWORD PTR [esi], OFFSET ??_7?$TString@D@@6B@
  00014	85 ff		 test	 edi, edi
  00016	75 10		 jne	 SHORT $LN9@UnicodeToA
  00018	ff 74 24 10	 push	 DWORD PTR _Str$[esp+4]
  0001c	e8 00 00 00 00	 call	 ?Length@?$STRUTILS@_W@@SAKPB_W@Z ; STRUTILS<wchar_t>::Length
  00021	8b f8		 mov	 edi, eax
  00023	59		 pop	 ecx
; 1636 : 
; 1637 : 	if (Len)
  00024	85 ff		 test	 edi, edi
  00026	74 29		 je	 SHORT $LN1@UnicodeToA
$LN9@UnicodeToA:
; 1638 : 	{
; 1639 : 		// 
; 1640 : 		Result.SetLength(Len);
  00028	57		 push	 edi
  00029	8b ce		 mov	 ecx, esi
  0002b	e8 00 00 00 00	 call	 ?SetLength@?$TString@D@@QAEXK@Z ; TString<char>::SetLength
; 1641 : 		pWideCharToMultiByte(1251, 0, Str, Len, Result.t_str(), Len, NULL, NULL);
  00030	6a 00		 push	 0
  00032	6a 00		 push	 0
  00034	57		 push	 edi
  00035	8b ce		 mov	 ecx, esi
  00037	e8 00 00 00 00	 call	 ?t_str@?$TString@D@@QBEPADXZ ; TString<char>::t_str
  0003c	50		 push	 eax
  0003d	57		 push	 edi
  0003e	ff 74 24 24	 push	 DWORD PTR _Str$[esp+24]
  00042	6a 00		 push	 0
  00044	68 e3 04 00 00	 push	 1251			; 000004e3H
  00049	e8 00 00 00 00	 call	 ??$pushargEx@$00$0OHEPFHOO@$0DA@HHPB_WKPADKHH@@YAPAXHHPB_WKPADKHH@Z ; pushargEx<1,3880736750,48,int,int,wchar_t const *,unsigned long,char *,unsigned long,int,int>
  0004e	83 c4 20	 add	 esp, 32			; 00000020H
$LN1@UnicodeToA:
  00051	5f		 pop	 edi
; 1642 :     }
; 1643 : 
; 1644 : 	return Result;
  00052	8b c6		 mov	 eax, esi
  00054	5e		 pop	 esi
; 1645 : }
  00055	c3		 ret	 0
?UnicodeToAnsi@@YA?AV?$TString@D@@PB_WK@Z ENDP		; UnicodeToAnsi
_TEXT	ENDS
PUBLIC	??_7TStrEnum@@6B@				; TStrEnum::`vftable'
PUBLIC	??0TStrEnum@@QAE@PBD_NK@Z			; TStrEnum::TStrEnum
EXTRN	??_ETStrEnum@@UAEPAXI@Z:PROC			; TStrEnum::`vector deleting destructor'
;	COMDAT ??_7TStrEnum@@6B@
CONST	SEGMENT
??_7TStrEnum@@6B@ DD FLAT:??_ETStrEnum@@UAEPAXI@Z	; TStrEnum::`vftable'
; Function compile flags: /Ogspy
CONST	ENDS
;	COMDAT ??0TStrEnum@@QAE@PBD_NK@Z
_TEXT	SEGMENT
_Buffer$ = 8						; size = 4
_Encrypted$ = 12					; size = 1
_EmptyBufHash$ = 16					; size = 4
??0TStrEnum@@QAE@PBD_NK@Z PROC				; TStrEnum::TStrEnum, COMDAT
; _this$ = ecx
; 1673 : {
  00000	56		 push	 esi
; 1674 : 	Initialize(Buffer, Encrypted, EmptyBufHash);
  00001	ff 74 24 10	 push	 DWORD PTR _EmptyBufHash$[esp]
  00005	8b f1		 mov	 esi, ecx
  00007	ff 74 24 10	 push	 DWORD PTR _Encrypted$[esp+4]
  0000b	c7 06 00 00 00
	00		 mov	 DWORD PTR [esi], OFFSET ??_7TStrEnum@@6B@
  00011	ff 74 24 10	 push	 DWORD PTR _Buffer$[esp+8]
  00015	83 66 14 00	 and	 DWORD PTR [esi+20], 0
  00019	c7 46 10 00 00
	00 00		 mov	 DWORD PTR [esi+16], OFFSET ??_7?$TString@D@@6B@
  00020	e8 00 00 00 00	 call	 ?Initialize@TStrEnum@@AAEXPBD_NK@Z ; TStrEnum::Initialize
; 1675 : }
  00025	8b c6		 mov	 eax, esi
  00027	5e		 pop	 esi
  00028	c2 0c 00	 ret	 12			; 0000000cH
??0TStrEnum@@QAE@PBD_NK@Z ENDP				; TStrEnum::TStrEnum
_TEXT	ENDS
PUBLIC	??1TStrEnum@@UAE@XZ				; TStrEnum::~TStrEnum
; Function compile flags: /Ogspy
;	COMDAT ??1TStrEnum@@UAE@XZ
_TEXT	SEGMENT
??1TStrEnum@@UAE@XZ PROC				; TStrEnum::~TStrEnum, COMDAT
; _this$ = ecx
  00000	56		 push	 esi
  00001	8b f1		 mov	 esi, ecx
  00003	8d 4e 10	 lea	 ecx, DWORD PTR [esi+16]
  00006	e8 00 00 00 00	 call	 ??1?$TString@D@@UAE@XZ	; TString<char>::~TString<char>
  0000b	c7 06 00 00 00
	00		 mov	 DWORD PTR [esi], OFFSET ??_7TBotObject@@6B@
  00011	5e		 pop	 esi
  00012	c3		 ret	 0
??1TStrEnum@@UAE@XZ ENDP				; TStrEnum::~TStrEnum
_TEXT	ENDS
PUBLIC	??0TStrEnum@@QAE@PBD@Z				; TStrEnum::TStrEnum
; Function compile flags: /Ogspy
;	COMDAT ??0TStrEnum@@QAE@PBD@Z
_TEXT	SEGMENT
_Buffer$ = 8						; size = 4
??0TStrEnum@@QAE@PBD@Z PROC				; TStrEnum::TStrEnum, COMDAT
; _this$ = ecx
; 1679 : {
  00000	56		 push	 esi
  00001	33 c0		 xor	 eax, eax
; 1680 : 	Initialize(Buffer, false, 0);
  00003	50		 push	 eax
  00004	8b f1		 mov	 esi, ecx
  00006	50		 push	 eax
  00007	ff 74 24 10	 push	 DWORD PTR _Buffer$[esp+8]
  0000b	c7 06 00 00 00
	00		 mov	 DWORD PTR [esi], OFFSET ??_7TStrEnum@@6B@
  00011	c7 46 10 00 00
	00 00		 mov	 DWORD PTR [esi+16], OFFSET ??_7?$TString@D@@6B@
  00018	89 46 14	 mov	 DWORD PTR [esi+20], eax
  0001b	e8 00 00 00 00	 call	 ?Initialize@TStrEnum@@AAEXPBD_NK@Z ; TStrEnum::Initialize
; 1681 : }
  00020	8b c6		 mov	 eax, esi
  00022	5e		 pop	 esi
  00023	c2 04 00	 ret	 4
??0TStrEnum@@QAE@PBD@Z ENDP				; TStrEnum::TStrEnum
_TEXT	ENDS
PUBLIC	?Next@TStrEnum@@QAE_NXZ				; TStrEnum::Next
; Function compile flags: /Ogspy
;	COMDAT ?Next@TStrEnum@@QAE_NXZ
_TEXT	SEGMENT
?Next@TStrEnum@@QAE_NXZ PROC				; TStrEnum::Next, COMDAT
; _this$ = ecx
; 1697 : {
  00000	56		 push	 esi
  00001	8b f1		 mov	 esi, ecx
; 1698 : 	// 
; 1699 : 	if (FBuf)
  00003	8b 46 04	 mov	 eax, DWORD PTR [esi+4]
  00006	85 c0		 test	 eax, eax
  00008	74 46		 je	 SHORT $LN1@Next
; 1700 : 	{
; 1701 :         // 
; 1702 : 		if (FCurrent)
  0000a	8b 4e 0c	 mov	 ecx, DWORD PTR [esi+12]
  0000d	85 c9		 test	 ecx, ecx
  0000f	74 08		 je	 SHORT $LN3@Next
; 1703 : 		{
; 1704 : 			FCurrent = AnsiStr::End(FCurrent);
  00011	51		 push	 ecx
  00012	e8 00 00 00 00	 call	 ?End@?$STRUTILS@D@@SAPADPBD@Z ; STRUTILS<char>::End
  00017	59		 pop	 ecx
; 1705 : 			FCurrent++;
  00018	40		 inc	 eax
$LN3@Next:
  00019	57		 push	 edi
; 1706 : 		}
; 1707 : 		else
; 1708 : 			FCurrent = FBuf;
; 1709 : 
; 1710 : 		FLine = FCurrent;
  0001a	8d 7e 10	 lea	 edi, DWORD PTR [esi+16]
  0001d	50		 push	 eax
  0001e	8b cf		 mov	 ecx, edi
  00020	89 46 0c	 mov	 DWORD PTR [esi+12], eax
  00023	e8 00 00 00 00	 call	 ??4?$TString@D@@QAEAAV0@PBD@Z ; TString<char>::operator=
; 1711 : 
; 1712 :         // 
; 1713 : 		if (!FLine.IsEmpty() && FEncrypted)
  00028	ff 76 14	 push	 DWORD PTR [esi+20]
  0002b	e8 00 00 00 00	 call	 ?IsEmpty@?$STRUTILS@D@@SA_NPBD@Z ; STRUTILS<char>::IsEmpty
  00030	59		 pop	 ecx
  00031	84 c0		 test	 al, al
  00033	75 1a		 jne	 SHORT $LN11@Next
  00035	38 46 08	 cmp	 BYTE PTR [esi+8], al
  00038	74 15		 je	 SHORT $LN11@Next
; 1714 :         	DecryptStr(FLine.t_str(), FLine.t_str());
  0003a	8b cf		 mov	 ecx, edi
  0003c	e8 00 00 00 00	 call	 ?t_str@?$TString@D@@QBEPADXZ ; TString<char>::t_str
  00041	50		 push	 eax
  00042	8b cf		 mov	 ecx, edi
  00044	e8 00 00 00 00	 call	 ?t_str@?$TString@D@@QBEPADXZ ; TString<char>::t_str
  00049	50		 push	 eax
  0004a	e8 00 00 00 00	 call	 ?DecryptStr@@YGPADPAD0@Z ; DecryptStr
$LN11@Next:
  0004f	5f		 pop	 edi
$LN1@Next:
; 1715 : 	}
; 1716 : 
; 1717 : 	return FCurrent && *FCurrent;
  00050	8b 76 0c	 mov	 esi, DWORD PTR [esi+12]
  00053	85 f6		 test	 esi, esi
  00055	74 0a		 je	 SHORT $LN7@Next
  00057	80 3e 00	 cmp	 BYTE PTR [esi], 0
  0005a	74 05		 je	 SHORT $LN7@Next
  0005c	33 c0		 xor	 eax, eax
  0005e	40		 inc	 eax
  0005f	5e		 pop	 esi
; 1718 : }
  00060	c3		 ret	 0
$LN7@Next:
; 1715 : 	}
; 1716 : 
; 1717 : 	return FCurrent && *FCurrent;
  00061	33 c0		 xor	 eax, eax
  00063	5e		 pop	 esi
; 1718 : }
  00064	c3		 ret	 0
?Next@TStrEnum@@QAE_NXZ ENDP				; TStrEnum::Next
; Function compile flags: /Ogspy
_TEXT	ENDS
;	COMDAT ??_G?$TString@D@@UAEPAXI@Z
_TEXT	SEGMENT
___flags$ = 8						; size = 4
??_G?$TString@D@@UAEPAXI@Z PROC				; TString<char>::`scalar deleting destructor', COMDAT
; _this$ = ecx
  00000	56		 push	 esi
  00001	8b f1		 mov	 esi, ecx
  00003	e8 00 00 00 00	 call	 ??1?$TString@D@@UAE@XZ	; TString<char>::~TString<char>
  00008	f6 44 24 08 01	 test	 BYTE PTR ___flags$[esp], 1
  0000d	74 07		 je	 SHORT $LN1@scalar@2
  0000f	56		 push	 esi
  00010	e8 00 00 00 00	 call	 ??3TBotObject@@SAXPAX@Z	; TBotObject::operator delete
  00015	59		 pop	 ecx
$LN1@scalar@2:
  00016	8b c6		 mov	 eax, esi
  00018	5e		 pop	 esi
  00019	c2 04 00	 ret	 4
??_G?$TString@D@@UAEPAXI@Z ENDP				; TString<char>::`scalar deleting destructor'
; Function compile flags: /Ogspy
_TEXT	ENDS
;	COMDAT ??_GTStrEnum@@UAEPAXI@Z
_TEXT	SEGMENT
___flags$ = 8						; size = 4
??_GTStrEnum@@UAEPAXI@Z PROC				; TStrEnum::`scalar deleting destructor', COMDAT
; _this$ = ecx
  00000	56		 push	 esi
  00001	8b f1		 mov	 esi, ecx
  00003	e8 00 00 00 00	 call	 ??1TStrEnum@@UAE@XZ
  00008	f6 44 24 08 01	 test	 BYTE PTR ___flags$[esp], 1
  0000d	74 07		 je	 SHORT $LN1@scalar@3
  0000f	56		 push	 esi
  00010	e8 00 00 00 00	 call	 ??3TBotObject@@SAXPAX@Z	; TBotObject::operator delete
  00015	59		 pop	 ecx
$LN1@scalar@3:
  00016	8b c6		 mov	 eax, esi
  00018	5e		 pop	 esi
  00019	c2 04 00	 ret	 4
??_GTStrEnum@@UAEPAXI@Z ENDP				; TStrEnum::`scalar deleting destructor'
_TEXT	ENDS