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

	TITLE	D:\Works\Corpsms_2010\SmsCenter\Release_Unicode\MailCoder.obj
	.686P
	.XMM
	include listing.inc
	.model	flat

INCLUDELIB LIBCMT
INCLUDELIB OLDNAMES

PUBLIC	?m_LineWidth@CMailCoder@@2IA			; CMailCoder::m_LineWidth
PUBLIC	?BASE64_ENCODE_TABLE@CMailCoder@@2QBDB		; CMailCoder::BASE64_ENCODE_TABLE
PUBLIC	?BASE64_DECODE_TABLE@CMailCoder@@2QBIB		; CMailCoder::BASE64_DECODE_TABLE
PUBLIC	?QUOTED_ENCODE_TABLE@CMailCoder@@2QBEB		; CMailCoder::QUOTED_ENCODE_TABLE
CONST	SEGMENT
?BASE64_ENCODE_TABLE@CMailCoder@@2QBDB DB 041H		; CMailCoder::BASE64_ENCODE_TABLE
	DB	042H
	DB	043H
	DB	044H
	DB	045H
	DB	046H
	DB	047H
	DB	048H
	DB	049H
	DB	04aH
	DB	04bH
	DB	04cH
	DB	04dH
	DB	04eH
	DB	04fH
	DB	050H
	DB	051H
	DB	052H
	DB	053H
	DB	054H
	DB	055H
	DB	056H
	DB	057H
	DB	058H
	DB	059H
	DB	05aH
	DB	061H
	DB	062H
	DB	063H
	DB	064H
	DB	065H
	DB	066H
	DB	067H
	DB	068H
	DB	069H
	DB	06aH
	DB	06bH
	DB	06cH
	DB	06dH
	DB	06eH
	DB	06fH
	DB	070H
	DB	071H
	DB	072H
	DB	073H
	DB	074H
	DB	075H
	DB	076H
	DB	077H
	DB	078H
	DB	079H
	DB	07aH
	DB	030H
	DB	031H
	DB	032H
	DB	033H
	DB	034H
	DB	035H
	DB	036H
	DB	037H
	DB	038H
	DB	039H
	DB	02bH
	DB	02fH
?BASE64_DECODE_TABLE@CMailCoder@@2QBIB DD 0ffH		; CMailCoder::BASE64_DECODE_TABLE
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	03eH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	03fH
	DD	034H
	DD	035H
	DD	036H
	DD	037H
	DD	038H
	DD	039H
	DD	03aH
	DD	03bH
	DD	03cH
	DD	03dH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	00H
	DD	01H
	DD	02H
	DD	03H
	DD	04H
	DD	05H
	DD	06H
	DD	07H
	DD	08H
	DD	09H
	DD	0aH
	DD	0bH
	DD	0cH
	DD	0dH
	DD	0eH
	DD	0fH
	DD	010H
	DD	011H
	DD	012H
	DD	013H
	DD	014H
	DD	015H
	DD	016H
	DD	017H
	DD	018H
	DD	019H
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	01aH
	DD	01bH
	DD	01cH
	DD	01dH
	DD	01eH
	DD	01fH
	DD	020H
	DD	021H
	DD	022H
	DD	023H
	DD	024H
	DD	025H
	DD	026H
	DD	027H
	DD	028H
	DD	029H
	DD	02aH
	DD	02bH
	DD	02cH
	DD	02dH
	DD	02eH
	DD	02fH
	DD	030H
	DD	031H
	DD	032H
	DD	033H
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
	DD	0ffH
?QUOTED_ENCODE_TABLE@CMailCoder@@2QBEB DB 0ffH		; CMailCoder::QUOTED_ENCODE_TABLE
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0aH
	DB	0ffH
	DB	0ffH
	DB	0dH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	021H
	DB	022H
	DB	023H
	DB	024H
	DB	025H
	DB	026H
	DB	027H
	DB	028H
	DB	029H
	DB	02aH
	DB	02bH
	DB	02cH
	DB	02dH
	DB	02eH
	DB	02fH
	DB	030H
	DB	031H
	DB	032H
	DB	033H
	DB	034H
	DB	035H
	DB	036H
	DB	037H
	DB	038H
	DB	039H
	DB	03aH
	DB	03bH
	DB	03cH
	DB	0ffH
	DB	03eH
	DB	03fH
	DB	040H
	DB	041H
	DB	042H
	DB	043H
	DB	044H
	DB	045H
	DB	046H
	DB	047H
	DB	048H
	DB	049H
	DB	04aH
	DB	04bH
	DB	04cH
	DB	04dH
	DB	04eH
	DB	04fH
	DB	050H
	DB	051H
	DB	052H
	DB	053H
	DB	054H
	DB	055H
	DB	056H
	DB	057H
	DB	058H
	DB	059H
	DB	05aH
	DB	05bH
	DB	05cH
	DB	05dH
	DB	05eH
	DB	05fH
	DB	060H
	DB	061H
	DB	062H
	DB	063H
	DB	064H
	DB	065H
	DB	066H
	DB	067H
	DB	068H
	DB	069H
	DB	06aH
	DB	06bH
	DB	06cH
	DB	06dH
	DB	06eH
	DB	06fH
	DB	070H
	DB	071H
	DB	072H
	DB	073H
	DB	074H
	DB	075H
	DB	076H
	DB	077H
	DB	078H
	DB	079H
	DB	07aH
	DB	07bH
	DB	07cH
	DB	07dH
	DB	07eH
	DB	07fH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
	DB	0ffH
CONST	ENDS
_DATA	SEGMENT
?m_LineWidth@CMailCoder@@2IA DD 04cH			; CMailCoder::m_LineWidth
_DATA	ENDS
PUBLIC	?__empty_global_delete@@YAXPAX@Z		; __empty_global_delete
PUBLIC	?__empty_global_delete@@YAXPAXI@Z		; __empty_global_delete
PUBLIC	?__empty_global_delete@@YAXPAXW4align_val_t@std@@@Z ; __empty_global_delete
PUBLIC	?__empty_global_delete@@YAXPAXIW4align_val_t@std@@@Z ; __empty_global_delete
PUBLIC	?DecToHex@CMailCoder@@CAEE@Z			; CMailCoder::DecToHex
PUBLIC	?HexToDec@CMailCoder@@CAEE@Z			; CMailCoder::HexToDec
PUBLIC	?FoundChar@CMailCoder@@QAEHPAD0J@Z		; CMailCoder::FoundChar
PUBLIC	?email_decode@CMailCoder@@QAEHPADI0@Z		; CMailCoder::email_decode
PUBLIC	?Base64EncodeSize@CMailCoder@@SAHH@Z		; CMailCoder::Base64EncodeSize
PUBLIC	?Base64DecodeSize@CMailCoder@@SAHH@Z		; CMailCoder::Base64DecodeSize
PUBLIC	?UUEncodeSize@CMailCoder@@SAHH@Z		; CMailCoder::UUEncodeSize
PUBLIC	?UUDecodeSize@CMailCoder@@SAHH@Z		; CMailCoder::UUDecodeSize
PUBLIC	?QuotedEncodeSize@CMailCoder@@SAHH@Z		; CMailCoder::QuotedEncodeSize
PUBLIC	?base64_encode@CMailCoder@@SAHPADI0@Z		; CMailCoder::base64_encode
PUBLIC	?base64_decode@CMailCoder@@SAHPADI0@Z		; CMailCoder::base64_decode
PUBLIC	?UU_encode@CMailCoder@@SAHPADI0@Z		; CMailCoder::UU_encode
PUBLIC	?UU_decode@CMailCoder@@SAHPADI0@Z		; CMailCoder::UU_decode
PUBLIC	?quoted_encode@CMailCoder@@SAHPADI0@Z		; CMailCoder::quoted_encode
PUBLIC	?quoted_decode@CMailCoder@@SAHPADI0@Z		; CMailCoder::quoted_decode
PUBLIC	??_C@_02HENDHKBC@?$DN?$DP@			; `string'
PUBLIC	??_C@_03FNDDLLIG@?$DPB?$DP@			; `string'
PUBLIC	??_C@_02EFGBMMPO@?$DP?$DN@			; `string'
PUBLIC	??_C@_03EDFDKGKP@?$DPQ?$DP@			; `string'
EXTRN	___report_rangecheckfailure:PROC
EXTRN	_memcpy:PROC
EXTRN	_memset:PROC
EXTRN	_strcmp:PROC
EXTRN	_strlen:PROC
EXTRN	_strncpy:PROC
EXTRN	@__security_check_cookie@4:PROC
EXTRN	__chkstk:PROC
EXTRN	___security_cookie:DWORD
;	COMDAT ??_C@_03EDFDKGKP@?$DPQ?$DP@
CONST	SEGMENT
??_C@_03EDFDKGKP@?$DPQ?$DP@ DB '?Q?', 00H		; `string'
CONST	ENDS
;	COMDAT ??_C@_02EFGBMMPO@?$DP?$DN@
CONST	SEGMENT
??_C@_02EFGBMMPO@?$DP?$DN@ DB '?=', 00H			; `string'
CONST	ENDS
;	COMDAT ??_C@_03FNDDLLIG@?$DPB?$DP@
CONST	SEGMENT
??_C@_03FNDDLLIG@?$DPB?$DP@ DB '?B?', 00H		; `string'
CONST	ENDS
;	COMDAT ??_C@_02HENDHKBC@?$DN?$DP@
CONST	SEGMENT
??_C@_02HENDHKBC@?$DN?$DP@ DB '=?', 00H			; `string'
CONST	ENDS
;	COMDAT voltbl
voltbl	SEGMENT
_volmd	DB	014H
	DB	0ebH
voltbl	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?quoted_decode@CMailCoder@@SAHPADI0@Z
_TEXT	SEGMENT
tv87 = -81						; size = 1
tv82 = -81						; size = 1
tv73 = -81						; size = 1
_pDestOrg$ = -16					; size = 4
_InLimitPtr$ = -12					; size = 4
_C$ = -8						; size = 2
_nB$ = -2						; size = 1
_nA$ = -1						; size = 1
_pSrc$ = 8						; size = 4
_nSize$ = 12						; size = 4
_pDest$ = 16						; size = 4
?quoted_decode@CMailCoder@@SAHPADI0@Z PROC		; CMailCoder::quoted_decode, COMDAT

; 447  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 54	 sub	 esp, 84			; 00000054H
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi

; 448  : 	if ((pSrc == NULL) || (pDest == NULL) || (nSize <= 0)) return 0;

  00009	83 7d 08 00	 cmp	 DWORD PTR _pSrc$[ebp], 0
  0000d	74 0c		 je	 SHORT $LN5@quoted_dec
  0000f	83 7d 10 00	 cmp	 DWORD PTR _pDest$[ebp], 0
  00013	74 06		 je	 SHORT $LN5@quoted_dec
  00015	83 7d 0c 00	 cmp	 DWORD PTR _nSize$[ebp], 0
  00019	77 07		 ja	 SHORT $LN4@quoted_dec
$LN5@quoted_dec:
  0001b	33 c0		 xor	 eax, eax
  0001d	e9 17 01 00 00	 jmp	 $LN1@quoted_dec
$LN4@quoted_dec:

; 449  : 				
; 450  : 	unsigned char nA, nB;
; 451  : 	char C[2]; //��ʱ�Ķ�����
; 452  : 				
; 453  : 	char *InLimitPtr= pSrc + nSize;

  00022	8b 45 08	 mov	 eax, DWORD PTR _pSrc$[ebp]
  00025	03 45 0c	 add	 eax, DWORD PTR _nSize$[ebp]
  00028	89 45 f4	 mov	 DWORD PTR _InLimitPtr$[ebp], eax

; 454  : 	char *pDestOrg = pDest;

  0002b	8b 45 10	 mov	 eax, DWORD PTR _pDest$[ebp]
  0002e	89 45 f0	 mov	 DWORD PTR _pDestOrg$[ebp], eax
$LN2@quoted_dec:

; 455  : 				
; 456  : 	while (pSrc < InLimitPtr)

  00031	8b 45 08	 mov	 eax, DWORD PTR _pSrc$[ebp]
  00034	3b 45 f4	 cmp	 eax, DWORD PTR _InLimitPtr$[ebp]
  00037	0f 83 f6 00 00
	00		 jae	 $LN3@quoted_dec

; 457  : 	{
; 458  : 		C[0] = *pSrc++; //��ȡ��һ�ַ�

  0003d	8b 45 08	 mov	 eax, DWORD PTR _pSrc$[ebp]
  00040	8a 08		 mov	 cl, BYTE PTR [eax]
  00042	88 4d af	 mov	 BYTE PTR tv73[ebp], cl
  00045	8b 55 08	 mov	 edx, DWORD PTR _pSrc$[ebp]
  00048	83 c2 01	 add	 edx, 1
  0004b	89 55 08	 mov	 DWORD PTR _pSrc$[ebp], edx
  0004e	b8 01 00 00 00	 mov	 eax, 1
  00053	6b c8 00	 imul	 ecx, eax, 0
  00056	8a 55 af	 mov	 dl, BYTE PTR tv73[ebp]
  00059	88 54 0d f8	 mov	 BYTE PTR _C$[ebp+ecx], dl

; 459  : 		if (C[0] == '=') //��������Ǿ��������

  0005d	b8 01 00 00 00	 mov	 eax, 1
  00062	6b c8 00	 imul	 ecx, eax, 0
  00065	0f be 54 0d f8	 movsx	 edx, BYTE PTR _C$[ebp+ecx]
  0006a	83 fa 3d	 cmp	 edx, 61			; 0000003dH
  0006d	0f 85 a1 00 00
	00		 jne	 $LN6@quoted_dec

; 460  : 		{
; 461  : 			C[0] = *pSrc++;  //ȡ�����������ַ�

  00073	8b 45 08	 mov	 eax, DWORD PTR _pSrc$[ebp]
  00076	8a 08		 mov	 cl, BYTE PTR [eax]
  00078	88 4d af	 mov	 BYTE PTR tv82[ebp], cl
  0007b	8b 55 08	 mov	 edx, DWORD PTR _pSrc$[ebp]
  0007e	83 c2 01	 add	 edx, 1
  00081	89 55 08	 mov	 DWORD PTR _pSrc$[ebp], edx
  00084	b8 01 00 00 00	 mov	 eax, 1
  00089	6b c8 00	 imul	 ecx, eax, 0
  0008c	8a 55 af	 mov	 dl, BYTE PTR tv82[ebp]
  0008f	88 54 0d f8	 mov	 BYTE PTR _C$[ebp+ecx], dl

; 462  : 			C[1] = *pSrc++;

  00093	8b 45 08	 mov	 eax, DWORD PTR _pSrc$[ebp]
  00096	8a 08		 mov	 cl, BYTE PTR [eax]
  00098	88 4d af	 mov	 BYTE PTR tv87[ebp], cl
  0009b	8b 55 08	 mov	 edx, DWORD PTR _pSrc$[ebp]
  0009e	83 c2 01	 add	 edx, 1
  000a1	89 55 08	 mov	 DWORD PTR _pSrc$[ebp], edx
  000a4	b8 01 00 00 00	 mov	 eax, 1
  000a9	c1 e0 00	 shl	 eax, 0
  000ac	8a 4d af	 mov	 cl, BYTE PTR tv87[ebp]
  000af	88 4c 05 f8	 mov	 BYTE PTR _C$[ebp+eax], cl

; 463  : 
; 464  : 			if (C[0] != '\r')

  000b3	b8 01 00 00 00	 mov	 eax, 1
  000b8	6b c8 00	 imul	 ecx, eax, 0
  000bb	0f be 54 0d f8	 movsx	 edx, BYTE PTR _C$[ebp+ecx]
  000c0	83 fa 0d	 cmp	 edx, 13			; 0000000dH
  000c3	74 4d		 je	 SHORT $LN8@quoted_dec

; 465  : 			{
; 466  : 				nA = HexToDec(C[0]); //����任

  000c5	b8 01 00 00 00	 mov	 eax, 1
  000ca	6b c8 00	 imul	 ecx, eax, 0
  000cd	0f b6 54 0d f8	 movzx	 edx, BYTE PTR _C$[ebp+ecx]
  000d2	52		 push	 edx
  000d3	e8 00 00 00 00	 call	 ?HexToDec@CMailCoder@@CAEE@Z ; CMailCoder::HexToDec
  000d8	83 c4 04	 add	 esp, 4
  000db	88 45 ff	 mov	 BYTE PTR _nA$[ebp], al

; 467  : 				nB = HexToDec(C[1]);

  000de	b8 01 00 00 00	 mov	 eax, 1
  000e3	c1 e0 00	 shl	 eax, 0
  000e6	0f b6 4c 05 f8	 movzx	 ecx, BYTE PTR _C$[ebp+eax]
  000eb	51		 push	 ecx
  000ec	e8 00 00 00 00	 call	 ?HexToDec@CMailCoder@@CAEE@Z ; CMailCoder::HexToDec
  000f1	83 c4 04	 add	 esp, 4
  000f4	88 45 fe	 mov	 BYTE PTR _nB$[ebp], al

; 468  : 				*pDest++ = (nA << 4) + nB;

  000f7	0f b6 45 ff	 movzx	 eax, BYTE PTR _nA$[ebp]
  000fb	c1 e0 04	 shl	 eax, 4
  000fe	0f b6 4d fe	 movzx	 ecx, BYTE PTR _nB$[ebp]
  00102	03 c1		 add	 eax, ecx
  00104	8b 55 10	 mov	 edx, DWORD PTR _pDest$[ebp]
  00107	88 02		 mov	 BYTE PTR [edx], al
  00109	8b 45 10	 mov	 eax, DWORD PTR _pDest$[ebp]
  0010c	83 c0 01	 add	 eax, 1
  0010f	89 45 10	 mov	 DWORD PTR _pDest$[ebp], eax
$LN8@quoted_dec:

; 469  : 			}
; 470  : 		}

  00112	eb 1a		 jmp	 SHORT $LN7@quoted_dec
$LN6@quoted_dec:

; 471  : 		else //����ֱ�����
; 472  : 		{
; 473  : 			*pDest++ = C[0];

  00114	b8 01 00 00 00	 mov	 eax, 1
  00119	6b c8 00	 imul	 ecx, eax, 0
  0011c	8b 55 10	 mov	 edx, DWORD PTR _pDest$[ebp]
  0011f	8a 44 0d f8	 mov	 al, BYTE PTR _C$[ebp+ecx]
  00123	88 02		 mov	 BYTE PTR [edx], al
  00125	8b 4d 10	 mov	 ecx, DWORD PTR _pDest$[ebp]
  00128	83 c1 01	 add	 ecx, 1
  0012b	89 4d 10	 mov	 DWORD PTR _pDest$[ebp], ecx
$LN7@quoted_dec:

; 474  : 		}
; 475  : 	}

  0012e	e9 fe fe ff ff	 jmp	 $LN2@quoted_dec
$LN3@quoted_dec:

; 476  : 	return (unsigned int)(pDest - pDestOrg);

  00133	8b 45 10	 mov	 eax, DWORD PTR _pDest$[ebp]
  00136	2b 45 f0	 sub	 eax, DWORD PTR _pDestOrg$[ebp]
$LN1@quoted_dec:

; 477  : }

  00139	5f		 pop	 edi
  0013a	5e		 pop	 esi
  0013b	5b		 pop	 ebx
  0013c	8b e5		 mov	 esp, ebp
  0013e	5d		 pop	 ebp
  0013f	c3		 ret	 0
?quoted_decode@CMailCoder@@SAHPADI0@Z ENDP		; CMailCoder::quoted_decode
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?quoted_encode@CMailCoder@@SAHPADI0@Z
_TEXT	SEGMENT
tv73 = -85						; size = 1
_OutPtr$ = -20						; size = 4
_InLimitPtr$ = -16					; size = 4
_InPtr$ = -12						; size = 4
_B$ = -5						; size = 1
_Len$ = -4						; size = 4
_pSrc$ = 8						; size = 4
_nSize$ = 12						; size = 4
_pDest$ = 16						; size = 4
?quoted_encode@CMailCoder@@SAHPADI0@Z PROC		; CMailCoder::quoted_encode, COMDAT

; 401  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 58	 sub	 esp, 88			; 00000058H
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi

; 402  : 	unsigned int Len;
; 403  : 	unsigned char B; //��ʱ�Ķ�����
; 404  : 	char *InPtr, *InLimitPtr;
; 405  : 	char *OutPtr;
; 406  : 			
; 407  : 	if ((pSrc == NULL) || (pDest == NULL) || (nSize <= 0)) return 0;

  00009	83 7d 08 00	 cmp	 DWORD PTR _pSrc$[ebp], 0
  0000d	74 0c		 je	 SHORT $LN7@quoted_enc
  0000f	83 7d 10 00	 cmp	 DWORD PTR _pDest$[ebp], 0
  00013	74 06		 je	 SHORT $LN7@quoted_enc
  00015	83 7d 0c 00	 cmp	 DWORD PTR _nSize$[ebp], 0
  00019	77 07		 ja	 SHORT $LN6@quoted_enc
$LN7@quoted_enc:
  0001b	33 c0		 xor	 eax, eax
  0001d	e9 2b 01 00 00	 jmp	 $LN1@quoted_enc
$LN6@quoted_enc:

; 408  : 			
; 409  : 	InPtr = pSrc;

  00022	8b 45 08	 mov	 eax, DWORD PTR _pSrc$[ebp]
  00025	89 45 f4	 mov	 DWORD PTR _InPtr$[ebp], eax

; 410  : 	InLimitPtr= InPtr + nSize;

  00028	8b 45 f4	 mov	 eax, DWORD PTR _InPtr$[ebp]
  0002b	03 45 0c	 add	 eax, DWORD PTR _nSize$[ebp]
  0002e	89 45 f0	 mov	 DWORD PTR _InLimitPtr$[ebp], eax

; 411  : 	OutPtr = pDest;

  00031	8b 45 10	 mov	 eax, DWORD PTR _pDest$[ebp]
  00034	89 45 ec	 mov	 DWORD PTR _OutPtr$[ebp], eax
$LN2@quoted_enc:

; 412  : 				
; 413  : 	while (InPtr < InLimitPtr)

  00037	8b 45 f4	 mov	 eax, DWORD PTR _InPtr$[ebp]
  0003a	3b 45 f0	 cmp	 eax, DWORD PTR _InLimitPtr$[ebp]
  0003d	0f 83 fe 00 00
	00		 jae	 $LN3@quoted_enc

; 414  : 	{
; 415  : 		Len = 0;

  00043	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR _Len$[ebp], 0
$LN4@quoted_enc:

; 416  : 		while ((InPtr < InLimitPtr) && (Len < m_LineWidth))

  0004a	8b 45 f4	 mov	 eax, DWORD PTR _InPtr$[ebp]
  0004d	3b 45 f0	 cmp	 eax, DWORD PTR _InLimitPtr$[ebp]
  00050	0f 83 ae 00 00
	00		 jae	 $LN5@quoted_enc
  00056	8b 45 fc	 mov	 eax, DWORD PTR _Len$[ebp]
  00059	3b 05 00 00 00
	00		 cmp	 eax, DWORD PTR ?m_LineWidth@CMailCoder@@2IA ; CMailCoder::m_LineWidth
  0005f	0f 83 9f 00 00
	00		 jae	 $LN5@quoted_enc

; 417  : 		{
; 418  : 			B = *InPtr++;

  00065	8b 45 f4	 mov	 eax, DWORD PTR _InPtr$[ebp]
  00068	8a 08		 mov	 cl, BYTE PTR [eax]
  0006a	88 4d ab	 mov	 BYTE PTR tv73[ebp], cl
  0006d	8b 55 f4	 mov	 edx, DWORD PTR _InPtr$[ebp]
  00070	83 c2 01	 add	 edx, 1
  00073	89 55 f4	 mov	 DWORD PTR _InPtr$[ebp], edx
  00076	8a 45 ab	 mov	 al, BYTE PTR tv73[ebp]
  00079	88 45 fb	 mov	 BYTE PTR _B$[ebp], al

; 419  : 			if (QUOTED_ENCODE_TABLE[ B ]  == 255)

  0007c	0f b6 45 fb	 movzx	 eax, BYTE PTR _B$[ebp]
  00080	0f b6 88 00 00
	00 00		 movzx	 ecx, BYTE PTR ?QUOTED_ENCODE_TABLE@CMailCoder@@2QBEB[eax]
  00087	81 f9 ff 00 00
	00		 cmp	 ecx, 255		; 000000ffH
  0008d	75 56		 jne	 SHORT $LN8@quoted_enc

; 420  : 			{
; 421  : 				*OutPtr++ = '=';

  0008f	8b 45 ec	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  00092	c6 00 3d	 mov	 BYTE PTR [eax], 61	; 0000003dH
  00095	8b 4d ec	 mov	 ecx, DWORD PTR _OutPtr$[ebp]
  00098	83 c1 01	 add	 ecx, 1
  0009b	89 4d ec	 mov	 DWORD PTR _OutPtr$[ebp], ecx

; 422  : 				*OutPtr++ = DecToHex(B >> 4);

  0009e	0f b6 45 fb	 movzx	 eax, BYTE PTR _B$[ebp]
  000a2	c1 f8 04	 sar	 eax, 4
  000a5	50		 push	 eax
  000a6	e8 00 00 00 00	 call	 ?DecToHex@CMailCoder@@CAEE@Z ; CMailCoder::DecToHex
  000ab	83 c4 04	 add	 esp, 4
  000ae	8b 4d ec	 mov	 ecx, DWORD PTR _OutPtr$[ebp]
  000b1	88 01		 mov	 BYTE PTR [ecx], al
  000b3	8b 55 ec	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  000b6	83 c2 01	 add	 edx, 1
  000b9	89 55 ec	 mov	 DWORD PTR _OutPtr$[ebp], edx

; 423  : 				*OutPtr++ = DecToHex(B & 0x0f);

  000bc	0f b6 45 fb	 movzx	 eax, BYTE PTR _B$[ebp]
  000c0	83 e0 0f	 and	 eax, 15			; 0000000fH
  000c3	50		 push	 eax
  000c4	e8 00 00 00 00	 call	 ?DecToHex@CMailCoder@@CAEE@Z ; CMailCoder::DecToHex
  000c9	83 c4 04	 add	 esp, 4
  000cc	8b 4d ec	 mov	 ecx, DWORD PTR _OutPtr$[ebp]
  000cf	88 01		 mov	 BYTE PTR [ecx], al
  000d1	8b 55 ec	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  000d4	83 c2 01	 add	 edx, 1
  000d7	89 55 ec	 mov	 DWORD PTR _OutPtr$[ebp], edx

; 424  : 				Len+=3;

  000da	8b 45 fc	 mov	 eax, DWORD PTR _Len$[ebp]
  000dd	83 c0 03	 add	 eax, 3
  000e0	89 45 fc	 mov	 DWORD PTR _Len$[ebp], eax

; 425  : 			}

  000e3	eb 1a		 jmp	 SHORT $LN9@quoted_enc
$LN8@quoted_enc:

; 426  : 			else
; 427  : 			{
; 428  : 				*OutPtr++ = B;

  000e5	8b 45 ec	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  000e8	8a 4d fb	 mov	 cl, BYTE PTR _B$[ebp]
  000eb	88 08		 mov	 BYTE PTR [eax], cl
  000ed	8b 55 ec	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  000f0	83 c2 01	 add	 edx, 1
  000f3	89 55 ec	 mov	 DWORD PTR _OutPtr$[ebp], edx

; 429  : 				Len++;

  000f6	8b 45 fc	 mov	 eax, DWORD PTR _Len$[ebp]
  000f9	83 c0 01	 add	 eax, 1
  000fc	89 45 fc	 mov	 DWORD PTR _Len$[ebp], eax
$LN9@quoted_enc:

; 430  : 			}
; 431  : 		}

  000ff	e9 46 ff ff ff	 jmp	 $LN4@quoted_enc
$LN5@quoted_enc:

; 432  : 		if (Len >= m_LineWidth)

  00104	8b 45 fc	 mov	 eax, DWORD PTR _Len$[ebp]
  00107	3b 05 00 00 00
	00		 cmp	 eax, DWORD PTR ?m_LineWidth@CMailCoder@@2IA ; CMailCoder::m_LineWidth
  0010d	72 2d		 jb	 SHORT $LN10@quoted_enc

; 433  : 		{
; 434  : 			*OutPtr++ = '=';

  0010f	8b 45 ec	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  00112	c6 00 3d	 mov	 BYTE PTR [eax], 61	; 0000003dH
  00115	8b 4d ec	 mov	 ecx, DWORD PTR _OutPtr$[ebp]
  00118	83 c1 01	 add	 ecx, 1
  0011b	89 4d ec	 mov	 DWORD PTR _OutPtr$[ebp], ecx

; 435  : 			*OutPtr++ = '\r'; //��������

  0011e	8b 45 ec	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  00121	c6 00 0d	 mov	 BYTE PTR [eax], 13	; 0000000dH
  00124	8b 4d ec	 mov	 ecx, DWORD PTR _OutPtr$[ebp]
  00127	83 c1 01	 add	 ecx, 1
  0012a	89 4d ec	 mov	 DWORD PTR _OutPtr$[ebp], ecx

; 436  : 			*OutPtr++ = '\n';

  0012d	8b 45 ec	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  00130	c6 00 0a	 mov	 BYTE PTR [eax], 10	; 0000000aH
  00133	8b 4d ec	 mov	 ecx, DWORD PTR _OutPtr$[ebp]
  00136	83 c1 01	 add	 ecx, 1
  00139	89 4d ec	 mov	 DWORD PTR _OutPtr$[ebp], ecx
$LN10@quoted_enc:

; 437  : 		}
; 438  : 	}

  0013c	e9 f6 fe ff ff	 jmp	 $LN2@quoted_enc
$LN3@quoted_enc:

; 439  : 	*OutPtr = '\0';

  00141	8b 45 ec	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  00144	c6 00 00	 mov	 BYTE PTR [eax], 0

; 440  : 	return (unsigned int) (OutPtr - pDest);

  00147	8b 45 ec	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  0014a	2b 45 10	 sub	 eax, DWORD PTR _pDest$[ebp]
$LN1@quoted_enc:

; 441  : }

  0014d	5f		 pop	 edi
  0014e	5e		 pop	 esi
  0014f	5b		 pop	 ebx
  00150	8b e5		 mov	 esp, ebp
  00152	5d		 pop	 ebp
  00153	c3		 ret	 0
?quoted_encode@CMailCoder@@SAHPADI0@Z ENDP		; CMailCoder::quoted_encode
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?UU_decode@CMailCoder@@SAHPADI0@Z
_TEXT	SEGMENT
tv74 = -93						; size = 1
_OutPtr$ = -28						; size = 4
_InLimitPtr$ = -24					; size = 4
_InPtr$ = -20						; size = 4
_Index$ = -16						; size = 4
_CurrIndex$ = -12					; size = 4
_Tmp$ = -5						; size = 1
_C$ = -4						; size = 4
_pSrc$ = 8						; size = 4
_nSize$ = 12						; size = 4
_pDest$ = 16						; size = 4
?UU_decode@CMailCoder@@SAHPADI0@Z PROC			; CMailCoder::UU_decode, COMDAT

; 341  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 60	 sub	 esp, 96			; 00000060H
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi

; 342  : 	char C[4]; //��ʱ�Ķ�����
; 343  : 	char Tmp;
; 344  : 	int CurrIndex, Index;
; 345  : 	char *InPtr, *InLimitPtr;
; 346  : 	char *OutPtr;
; 347  : 		
; 348  : 	if ((pSrc == NULL) || (pDest == NULL) || (nSize <= 0)) return 0;

  00009	83 7d 08 00	 cmp	 DWORD PTR _pSrc$[ebp], 0
  0000d	74 0c		 je	 SHORT $LN8@UU_decode
  0000f	83 7d 10 00	 cmp	 DWORD PTR _pDest$[ebp], 0
  00013	74 06		 je	 SHORT $LN8@UU_decode
  00015	83 7d 0c 00	 cmp	 DWORD PTR _nSize$[ebp], 0
  00019	77 07		 ja	 SHORT $LN7@UU_decode
$LN8@UU_decode:
  0001b	33 c0		 xor	 eax, eax
  0001d	e9 67 01 00 00	 jmp	 $LN1@UU_decode
$LN7@UU_decode:

; 349  : 		
; 350  : 	CurrIndex = 0;

  00022	c7 45 f4 00 00
	00 00		 mov	 DWORD PTR _CurrIndex$[ebp], 0

; 351  : 				
; 352  : 	InPtr = pSrc;

  00029	8b 45 08	 mov	 eax, DWORD PTR _pSrc$[ebp]
  0002c	89 45 ec	 mov	 DWORD PTR _InPtr$[ebp], eax

; 353  : 	InLimitPtr= InPtr + nSize;

  0002f	8b 45 ec	 mov	 eax, DWORD PTR _InPtr$[ebp]
  00032	03 45 0c	 add	 eax, DWORD PTR _nSize$[ebp]
  00035	89 45 e8	 mov	 DWORD PTR _InLimitPtr$[ebp], eax

; 354  : 	OutPtr = pDest;

  00038	8b 45 10	 mov	 eax, DWORD PTR _pDest$[ebp]
  0003b	89 45 e4	 mov	 DWORD PTR _OutPtr$[ebp], eax
$LN2@UU_decode:

; 355  : 				
; 356  : 	while (InPtr != InLimitPtr) //��ȡ4���ַ�

  0003e	8b 45 ec	 mov	 eax, DWORD PTR _InPtr$[ebp]
  00041	3b 45 e8	 cmp	 eax, DWORD PTR _InLimitPtr$[ebp]
  00044	0f 84 39 01 00
	00		 je	 $LN3@UU_decode

; 357  : 	{
; 358  : 		memset(C, 0, sizeof(C));

  0004a	6a 04		 push	 4
  0004c	6a 00		 push	 0
  0004e	8d 45 fc	 lea	 eax, DWORD PTR _C$[ebp]
  00051	50		 push	 eax
  00052	e8 00 00 00 00	 call	 _memset
  00057	83 c4 0c	 add	 esp, 12			; 0000000cH

; 359  : 		Index = 0;

  0005a	c7 45 f0 00 00
	00 00		 mov	 DWORD PTR _Index$[ebp], 0
$LN6@UU_decode:

; 360  : 		do
; 361  : 		{
; 362  : 			Tmp = *InPtr++;

  00061	8b 45 ec	 mov	 eax, DWORD PTR _InPtr$[ebp]
  00064	8a 08		 mov	 cl, BYTE PTR [eax]
  00066	88 4d a3	 mov	 BYTE PTR tv74[ebp], cl
  00069	8b 55 ec	 mov	 edx, DWORD PTR _InPtr$[ebp]
  0006c	83 c2 01	 add	 edx, 1
  0006f	89 55 ec	 mov	 DWORD PTR _InPtr$[ebp], edx
  00072	8a 45 a3	 mov	 al, BYTE PTR tv74[ebp]
  00075	88 45 fb	 mov	 BYTE PTR _Tmp$[ebp], al

; 363  : 			if (Tmp == 0x60) 

  00078	0f be 45 fb	 movsx	 eax, BYTE PTR _Tmp$[ebp]
  0007c	83 f8 60	 cmp	 eax, 96			; 00000060H
  0007f	75 06		 jne	 SHORT $LN9@UU_decode

; 364  : 			{
; 365  : 				Tmp = 0x20;       //Ϊ�˼���OutLook Express

  00081	c6 45 fb 20	 mov	 BYTE PTR _Tmp$[ebp], 32	; 00000020H

; 366  : 			}

  00085	eb 19		 jmp	 SHORT $LN10@UU_decode
$LN9@UU_decode:

; 367  : 			else if (Tmp =='\r')  //�׸���ĸ������

  00087	0f be 45 fb	 movsx	 eax, BYTE PTR _Tmp$[ebp]
  0008b	83 f8 0d	 cmp	 eax, 13			; 0000000dH
  0008e	75 10		 jne	 SHORT $LN10@UU_decode

; 368  : 			{
; 369  : 				InPtr++;

  00090	8b 45 ec	 mov	 eax, DWORD PTR _InPtr$[ebp]
  00093	83 c0 01	 add	 eax, 1
  00096	89 45 ec	 mov	 DWORD PTR _InPtr$[ebp], eax

; 370  : 				CurrIndex = 0;

  00099	c7 45 f4 00 00
	00 00		 mov	 DWORD PTR _CurrIndex$[ebp], 0
$LN10@UU_decode:

; 371  : 			}
; 372  : 			
; 373  : 			if ((Tmp > 0x20) || ( CurrIndex > 0 ))

  000a0	0f be 45 fb	 movsx	 eax, BYTE PTR _Tmp$[ebp]
  000a4	83 f8 20	 cmp	 eax, 32			; 00000020H
  000a7	7f 06		 jg	 SHORT $LN13@UU_decode
  000a9	83 7d f4 00	 cmp	 DWORD PTR _CurrIndex$[ebp], 0
  000ad	7e 2c		 jle	 SHORT $LN4@UU_decode
$LN13@UU_decode:

; 374  : 			{
; 375  : 				Tmp = Tmp - 0x20;

  000af	0f be 45 fb	 movsx	 eax, BYTE PTR _Tmp$[ebp]
  000b3	83 e8 20	 sub	 eax, 32			; 00000020H
  000b6	88 45 fb	 mov	 BYTE PTR _Tmp$[ebp], al

; 376  : 				if (CurrIndex == 0) 

  000b9	83 7d f4 00	 cmp	 DWORD PTR _CurrIndex$[ebp], 0
  000bd	75 09		 jne	 SHORT $LN14@UU_decode

; 377  : 				{
; 378  : 					CurrIndex = Tmp;

  000bf	0f be 45 fb	 movsx	 eax, BYTE PTR _Tmp$[ebp]
  000c3	89 45 f4	 mov	 DWORD PTR _CurrIndex$[ebp], eax

; 379  : 				}

  000c6	eb 13		 jmp	 SHORT $LN4@UU_decode
$LN14@UU_decode:

; 380  : 				else
; 381  : 				{
; 382  : 					C[Index] = Tmp;  // ��������׷���ַ�

  000c8	8b 45 f0	 mov	 eax, DWORD PTR _Index$[ebp]
  000cb	8a 4d fb	 mov	 cl, BYTE PTR _Tmp$[ebp]
  000ce	88 4c 05 fc	 mov	 BYTE PTR _C$[ebp+eax], cl

; 383  : 					Index++;

  000d2	8b 45 f0	 mov	 eax, DWORD PTR _Index$[ebp]
  000d5	83 c0 01	 add	 eax, 1
  000d8	89 45 f0	 mov	 DWORD PTR _Index$[ebp], eax
$LN4@UU_decode:

; 384  : 				}
; 385  : 			}
; 386  : 		}
; 387  : 		while ((InPtr < InLimitPtr) && (Index < sizeof(C)));

  000db	8b 45 ec	 mov	 eax, DWORD PTR _InPtr$[ebp]
  000de	3b 45 e8	 cmp	 eax, DWORD PTR _InLimitPtr$[ebp]
  000e1	73 0a		 jae	 SHORT $LN5@UU_decode
  000e3	83 7d f0 04	 cmp	 DWORD PTR _Index$[ebp], 4
  000e7	0f 82 74 ff ff
	ff		 jb	 $LN6@UU_decode
$LN5@UU_decode:

; 388  : 					
; 389  : 		OutPtr[0] = (char) ((C[0] << 2) + (C[1] >> 4));

  000ed	b8 01 00 00 00	 mov	 eax, 1
  000f2	6b c8 00	 imul	 ecx, eax, 0
  000f5	0f be 54 0d fc	 movsx	 edx, BYTE PTR _C$[ebp+ecx]
  000fa	b8 01 00 00 00	 mov	 eax, 1
  000ff	c1 e0 00	 shl	 eax, 0
  00102	0f be 4c 05 fc	 movsx	 ecx, BYTE PTR _C$[ebp+eax]
  00107	c1 f9 04	 sar	 ecx, 4
  0010a	8d 14 91	 lea	 edx, DWORD PTR [ecx+edx*4]
  0010d	b8 01 00 00 00	 mov	 eax, 1
  00112	6b c8 00	 imul	 ecx, eax, 0
  00115	8b 45 e4	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  00118	88 14 08	 mov	 BYTE PTR [eax+ecx], dl

; 390  : 		OutPtr[1] = (char) ((C[1] << 4) + (C[2] >> 2));

  0011b	b8 01 00 00 00	 mov	 eax, 1
  00120	c1 e0 00	 shl	 eax, 0
  00123	0f be 4c 05 fc	 movsx	 ecx, BYTE PTR _C$[ebp+eax]
  00128	c1 e1 04	 shl	 ecx, 4
  0012b	ba 01 00 00 00	 mov	 edx, 1
  00130	d1 e2		 shl	 edx, 1
  00132	0f be 44 15 fc	 movsx	 eax, BYTE PTR _C$[ebp+edx]
  00137	c1 f8 02	 sar	 eax, 2
  0013a	03 c8		 add	 ecx, eax
  0013c	ba 01 00 00 00	 mov	 edx, 1
  00141	c1 e2 00	 shl	 edx, 0
  00144	8b 45 e4	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  00147	88 0c 10	 mov	 BYTE PTR [eax+edx], cl

; 391  : 		OutPtr[2] = (char) ((C[2] << 6) + C[3]);

  0014a	b8 01 00 00 00	 mov	 eax, 1
  0014f	d1 e0		 shl	 eax, 1
  00151	0f be 4c 05 fc	 movsx	 ecx, BYTE PTR _C$[ebp+eax]
  00156	c1 e1 06	 shl	 ecx, 6
  00159	ba 01 00 00 00	 mov	 edx, 1
  0015e	6b c2 03	 imul	 eax, edx, 3
  00161	0f be 54 05 fc	 movsx	 edx, BYTE PTR _C$[ebp+eax]
  00166	03 ca		 add	 ecx, edx
  00168	b8 01 00 00 00	 mov	 eax, 1
  0016d	d1 e0		 shl	 eax, 1
  0016f	8b 55 e4	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  00172	88 0c 02	 mov	 BYTE PTR [edx+eax], cl

; 392  : 		OutPtr+=3; //������ʼλ��

  00175	8b 45 e4	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  00178	83 c0 03	 add	 eax, 3
  0017b	89 45 e4	 mov	 DWORD PTR _OutPtr$[ebp], eax

; 393  : 	}

  0017e	e9 bb fe ff ff	 jmp	 $LN2@UU_decode
$LN3@UU_decode:

; 394  : 	return (unsigned int)OutPtr - (unsigned int)pDest;

  00183	8b 45 e4	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  00186	2b 45 10	 sub	 eax, DWORD PTR _pDest$[ebp]
$LN1@UU_decode:

; 395  : }

  00189	5f		 pop	 edi
  0018a	5e		 pop	 esi
  0018b	5b		 pop	 ebx
  0018c	8b e5		 mov	 esp, ebp
  0018e	5d		 pop	 ebp
  0018f	c3		 ret	 0
?UU_decode@CMailCoder@@SAHPADI0@Z ENDP			; CMailCoder::UU_decode
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?UU_encode@CMailCoder@@SAHPADI0@Z
_TEXT	SEGMENT
tv79 = -93						; size = 1
_i$1 = -28						; size = 4
_OutPtr$ = -24						; size = 4
_InLimitPtr$ = -20					; size = 4
_InPtr$ = -16						; size = 4
_B$ = -12						; size = 3
_Len$ = -8						; size = 4
_lByteBufferSpace$ = -4					; size = 4
_pSrc$ = 8						; size = 4
_nSize$ = 12						; size = 4
_pDest$ = 16						; size = 4
?UU_encode@CMailCoder@@SAHPADI0@Z PROC			; CMailCoder::UU_encode, COMDAT

; 285  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 60	 sub	 esp, 96			; 00000060H
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi

; 286  : 	if ((pSrc == NULL) || (pDest == NULL) || (nSize <= 0)) return 0;

  00009	83 7d 08 00	 cmp	 DWORD PTR _pSrc$[ebp], 0
  0000d	74 0c		 je	 SHORT $LN13@UU_encode
  0000f	83 7d 10 00	 cmp	 DWORD PTR _pDest$[ebp], 0
  00013	74 06		 je	 SHORT $LN13@UU_encode
  00015	83 7d 0c 00	 cmp	 DWORD PTR _nSize$[ebp], 0
  00019	77 07		 ja	 SHORT $LN12@UU_encode
$LN13@UU_encode:
  0001b	33 c0		 xor	 eax, eax
  0001d	e9 d9 01 00 00	 jmp	 $LN1@UU_encode
$LN12@UU_encode:

; 287  : 				
; 288  : 	unsigned int lByteBufferSpace, Len;
; 289  : 	unsigned char B[3]; //��ʱ�Ķ�����
; 290  : 	char *InPtr, *InLimitPtr;
; 291  : 	char *OutPtr;
; 292  : 			
; 293  : 	InPtr = pSrc;

  00022	8b 45 08	 mov	 eax, DWORD PTR _pSrc$[ebp]
  00025	89 45 f0	 mov	 DWORD PTR _InPtr$[ebp], eax

; 294  : 	InLimitPtr= InPtr + nSize;

  00028	8b 45 f0	 mov	 eax, DWORD PTR _InPtr$[ebp]
  0002b	03 45 0c	 add	 eax, DWORD PTR _nSize$[ebp]
  0002e	89 45 ec	 mov	 DWORD PTR _InLimitPtr$[ebp], eax

; 295  : 	OutPtr = pDest;

  00031	8b 45 10	 mov	 eax, DWORD PTR _pDest$[ebp]
  00034	89 45 e8	 mov	 DWORD PTR _OutPtr$[ebp], eax
$LN2@UU_encode:

; 296  : 				
; 297  : 	while (InPtr < InLimitPtr)

  00037	8b 45 f0	 mov	 eax, DWORD PTR _InPtr$[ebp]
  0003a	3b 45 ec	 cmp	 eax, DWORD PTR _InLimitPtr$[ebp]
  0003d	0f 83 b2 01 00
	00		 jae	 $LN3@UU_encode

; 298  : 	{
; 299  : 		Len = 0;

  00043	c7 45 f8 00 00
	00 00		 mov	 DWORD PTR _Len$[ebp], 0
$LN4@UU_encode:

; 300  : 					
; 301  : 		while ((InPtr < InLimitPtr) && (Len < m_LineWidth))

  0004a	8b 45 f0	 mov	 eax, DWORD PTR _InPtr$[ebp]
  0004d	3b 45 ec	 cmp	 eax, DWORD PTR _InLimitPtr$[ebp]
  00050	0f 83 7c 01 00
	00		 jae	 $LN5@UU_encode
  00056	8b 45 f8	 mov	 eax, DWORD PTR _Len$[ebp]
  00059	3b 05 00 00 00
	00		 cmp	 eax, DWORD PTR ?m_LineWidth@CMailCoder@@2IA ; CMailCoder::m_LineWidth
  0005f	0f 83 6d 01 00
	00		 jae	 $LN5@UU_encode

; 302  : 		{
; 303  : 			lByteBufferSpace = (unsigned int) InLimitPtr - (unsigned int) InPtr;

  00065	8b 45 ec	 mov	 eax, DWORD PTR _InLimitPtr$[ebp]
  00068	2b 45 f0	 sub	 eax, DWORD PTR _InPtr$[ebp]
  0006b	89 45 fc	 mov	 DWORD PTR _lByteBufferSpace$[ebp], eax

; 304  : 			if (lByteBufferSpace > 3) lByteBufferSpace = 3; //����

  0006e	83 7d fc 03	 cmp	 DWORD PTR _lByteBufferSpace$[ebp], 3
  00072	76 07		 jbe	 SHORT $LN14@UU_encode
  00074	c7 45 fc 03 00
	00 00		 mov	 DWORD PTR _lByteBufferSpace$[ebp], 3
$LN14@UU_encode:

; 305  : 			//ȡֵ
; 306  : 			for (unsigned int i = 0; i < lByteBufferSpace; i++ )

  0007b	c7 45 e4 00 00
	00 00		 mov	 DWORD PTR _i$1[ebp], 0
  00082	eb 09		 jmp	 SHORT $LN8@UU_encode
$LN6@UU_encode:
  00084	8b 45 e4	 mov	 eax, DWORD PTR _i$1[ebp]
  00087	83 c0 01	 add	 eax, 1
  0008a	89 45 e4	 mov	 DWORD PTR _i$1[ebp], eax
$LN8@UU_encode:
  0008d	8b 45 e4	 mov	 eax, DWORD PTR _i$1[ebp]
  00090	3b 45 fc	 cmp	 eax, DWORD PTR _lByteBufferSpace$[ebp]
  00093	73 1d		 jae	 SHORT $LN7@UU_encode

; 307  : 			{
; 308  : 				B[i] = *InPtr++;

  00095	8b 45 f0	 mov	 eax, DWORD PTR _InPtr$[ebp]
  00098	8a 08		 mov	 cl, BYTE PTR [eax]
  0009a	88 4d a3	 mov	 BYTE PTR tv79[ebp], cl
  0009d	8b 55 f0	 mov	 edx, DWORD PTR _InPtr$[ebp]
  000a0	83 c2 01	 add	 edx, 1
  000a3	89 55 f0	 mov	 DWORD PTR _InPtr$[ebp], edx
  000a6	8b 45 e4	 mov	 eax, DWORD PTR _i$1[ebp]
  000a9	8a 4d a3	 mov	 cl, BYTE PTR tv79[ebp]
  000ac	88 4c 05 f4	 mov	 BYTE PTR _B$[ebp+eax], cl

; 309  : 			}

  000b0	eb d2		 jmp	 SHORT $LN6@UU_encode
$LN7@UU_encode:

; 310  : 			if (Len == 0)

  000b2	83 7d f8 00	 cmp	 DWORD PTR _Len$[ebp], 0
  000b6	75 18		 jne	 SHORT $LN15@UU_encode

; 311  : 			{
; 312  : 				*OutPtr++ = 'M';

  000b8	8b 45 e8	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  000bb	c6 00 4d	 mov	 BYTE PTR [eax], 77	; 0000004dH
  000be	8b 4d e8	 mov	 ecx, DWORD PTR _OutPtr$[ebp]
  000c1	83 c1 01	 add	 ecx, 1
  000c4	89 4d e8	 mov	 DWORD PTR _OutPtr$[ebp], ecx

; 313  : 				Len++;

  000c7	8b 45 f8	 mov	 eax, DWORD PTR _Len$[ebp]
  000ca	83 c0 01	 add	 eax, 1
  000cd	89 45 f8	 mov	 DWORD PTR _Len$[ebp], eax
$LN15@UU_encode:

; 314  : 			}
; 315  : 			//��������
; 316  : 			OutPtr[0] = B[0] >> 2;

  000d0	b8 01 00 00 00	 mov	 eax, 1
  000d5	6b c8 00	 imul	 ecx, eax, 0
  000d8	0f b6 54 0d f4	 movzx	 edx, BYTE PTR _B$[ebp+ecx]
  000dd	c1 fa 02	 sar	 edx, 2
  000e0	b8 01 00 00 00	 mov	 eax, 1
  000e5	6b c8 00	 imul	 ecx, eax, 0
  000e8	8b 45 e8	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  000eb	88 14 08	 mov	 BYTE PTR [eax+ecx], dl

; 317  : 			OutPtr[1] = (unsigned int) (B[0] << 4 & 0x30) + (unsigned int) (B[1] >> 4 & 0x0F);

  000ee	b8 01 00 00 00	 mov	 eax, 1
  000f3	6b c8 00	 imul	 ecx, eax, 0
  000f6	0f b6 54 0d f4	 movzx	 edx, BYTE PTR _B$[ebp+ecx]
  000fb	c1 e2 04	 shl	 edx, 4
  000fe	83 e2 30	 and	 edx, 48			; 00000030H
  00101	b8 01 00 00 00	 mov	 eax, 1
  00106	c1 e0 00	 shl	 eax, 0
  00109	0f b6 4c 05 f4	 movzx	 ecx, BYTE PTR _B$[ebp+eax]
  0010e	c1 f9 04	 sar	 ecx, 4
  00111	83 e1 0f	 and	 ecx, 15			; 0000000fH
  00114	03 d1		 add	 edx, ecx
  00116	b8 01 00 00 00	 mov	 eax, 1
  0011b	c1 e0 00	 shl	 eax, 0
  0011e	8b 4d e8	 mov	 ecx, DWORD PTR _OutPtr$[ebp]
  00121	88 14 01	 mov	 BYTE PTR [ecx+eax], dl

; 318  : 			OutPtr[2] = (unsigned int) (B[1] << 2 & 0x3C) + (unsigned int) (B[2] >> 6 & 0x03);

  00124	b8 01 00 00 00	 mov	 eax, 1
  00129	c1 e0 00	 shl	 eax, 0
  0012c	0f b6 4c 05 f4	 movzx	 ecx, BYTE PTR _B$[ebp+eax]
  00131	c1 e1 02	 shl	 ecx, 2
  00134	83 e1 3c	 and	 ecx, 60			; 0000003cH
  00137	ba 01 00 00 00	 mov	 edx, 1
  0013c	d1 e2		 shl	 edx, 1
  0013e	0f b6 44 15 f4	 movzx	 eax, BYTE PTR _B$[ebp+edx]
  00143	c1 f8 06	 sar	 eax, 6
  00146	83 e0 03	 and	 eax, 3
  00149	03 c8		 add	 ecx, eax
  0014b	ba 01 00 00 00	 mov	 edx, 1
  00150	d1 e2		 shl	 edx, 1
  00152	8b 45 e8	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  00155	88 0c 10	 mov	 BYTE PTR [eax+edx], cl

; 319  : 			OutPtr[3] = B[2] & 0x3F;

  00158	b8 01 00 00 00	 mov	 eax, 1
  0015d	d1 e0		 shl	 eax, 1
  0015f	0f b6 4c 05 f4	 movzx	 ecx, BYTE PTR _B$[ebp+eax]
  00164	83 e1 3f	 and	 ecx, 63			; 0000003fH
  00167	ba 01 00 00 00	 mov	 edx, 1
  0016c	6b c2 03	 imul	 eax, edx, 3
  0016f	8b 55 e8	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  00172	88 0c 02	 mov	 BYTE PTR [edx+eax], cl

; 320  : 			for (i = 0; i < 4; i++)

  00175	c7 45 e4 00 00
	00 00		 mov	 DWORD PTR _i$1[ebp], 0
  0017c	eb 09		 jmp	 SHORT $LN11@UU_encode
$LN9@UU_encode:
  0017e	8b 45 e4	 mov	 eax, DWORD PTR _i$1[ebp]
  00181	83 c0 01	 add	 eax, 1
  00184	89 45 e4	 mov	 DWORD PTR _i$1[ebp], eax
$LN11@UU_encode:
  00187	83 7d e4 04	 cmp	 DWORD PTR _i$1[ebp], 4
  0018b	73 2e		 jae	 SHORT $LN10@UU_encode

; 321  : 			{
; 322  : 				if (OutPtr[i] == NULL)

  0018d	8b 45 e8	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  00190	03 45 e4	 add	 eax, DWORD PTR _i$1[ebp]
  00193	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  00196	85 c9		 test	 ecx, ecx
  00198	75 0b		 jne	 SHORT $LN16@UU_encode

; 323  : 					OutPtr[i] = '`';//(unsigned char) (OutPtr[i] + 0x60);

  0019a	8b 45 e8	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  0019d	03 45 e4	 add	 eax, DWORD PTR _i$1[ebp]
  001a0	c6 00 60	 mov	 BYTE PTR [eax], 96	; 00000060H
  001a3	eb 14		 jmp	 SHORT $LN17@UU_encode
$LN16@UU_encode:

; 324  : 				else 
; 325  : 					OutPtr[i] = ' ' + OutPtr[i];//(unsigned char) (OutPtr[i] + 0x20);

  001a5	8b 45 e8	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  001a8	03 45 e4	 add	 eax, DWORD PTR _i$1[ebp]
  001ab	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  001ae	83 c1 20	 add	 ecx, 32			; 00000020H
  001b1	8b 55 e8	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  001b4	03 55 e4	 add	 edx, DWORD PTR _i$1[ebp]
  001b7	88 0a		 mov	 BYTE PTR [edx], cl
$LN17@UU_encode:

; 326  : 			}	

  001b9	eb c3		 jmp	 SHORT $LN9@UU_encode
$LN10@UU_encode:

; 327  : 			OutPtr+=4;

  001bb	8b 45 e8	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  001be	83 c0 04	 add	 eax, 4
  001c1	89 45 e8	 mov	 DWORD PTR _OutPtr$[ebp], eax

; 328  : 			Len+=4;

  001c4	8b 45 f8	 mov	 eax, DWORD PTR _Len$[ebp]
  001c7	83 c0 04	 add	 eax, 4
  001ca	89 45 f8	 mov	 DWORD PTR _Len$[ebp], eax

; 329  : 		}

  001cd	e9 78 fe ff ff	 jmp	 $LN4@UU_encode
$LN5@UU_encode:

; 330  : 					
; 331  : 		*OutPtr++ = '\r'; //���ûس�

  001d2	8b 45 e8	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  001d5	c6 00 0d	 mov	 BYTE PTR [eax], 13	; 0000000dH
  001d8	8b 4d e8	 mov	 ecx, DWORD PTR _OutPtr$[ebp]
  001db	83 c1 01	 add	 ecx, 1
  001de	89 4d e8	 mov	 DWORD PTR _OutPtr$[ebp], ecx

; 332  : 		*OutPtr++ = '\n';

  001e1	8b 45 e8	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  001e4	c6 00 0a	 mov	 BYTE PTR [eax], 10	; 0000000aH
  001e7	8b 4d e8	 mov	 ecx, DWORD PTR _OutPtr$[ebp]
  001ea	83 c1 01	 add	 ecx, 1
  001ed	89 4d e8	 mov	 DWORD PTR _OutPtr$[ebp], ecx

; 333  : 	}

  001f0	e9 42 fe ff ff	 jmp	 $LN2@UU_encode
$LN3@UU_encode:

; 334  : 	return (unsigned int) (OutPtr - pDest);

  001f5	8b 45 e8	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  001f8	2b 45 10	 sub	 eax, DWORD PTR _pDest$[ebp]
$LN1@UU_encode:

; 335  : }

  001fb	5f		 pop	 edi
  001fc	5e		 pop	 esi
  001fd	5b		 pop	 ebx
  001fe	8b e5		 mov	 esp, ebp
  00200	5d		 pop	 ebp
  00201	c3		 ret	 0
?UU_encode@CMailCoder@@SAHPADI0@Z ENDP			; CMailCoder::UU_encode
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?base64_decode@CMailCoder@@SAHPADI0@Z
_TEXT	SEGMENT
tv88 = -96						; size = 4
_OutPtr$ = -28						; size = 4
_InLimitPtr$ = -24					; size = 4
_InPtr$ = -20						; size = 4
_reallen$ = -16						; size = 4
_C$ = -12						; size = 4
_lByteBufferSpace$ = -8					; size = 4
_lByteBuffer$ = -4					; size = 4
_pSrc$ = 8						; size = 4
_nSize$ = 12						; size = 4
_pDest$ = 16						; size = 4
?base64_decode@CMailCoder@@SAHPADI0@Z PROC		; CMailCoder::base64_decode, COMDAT

; 229  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 60	 sub	 esp, 96			; 00000060H
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi

; 230  : 	if ((pSrc == NULL) || (pDest == NULL) || (nSize <= 0)) return 0;

  00009	83 7d 08 00	 cmp	 DWORD PTR _pSrc$[ebp], 0
  0000d	74 0c		 je	 SHORT $LN7@base64_dec
  0000f	83 7d 10 00	 cmp	 DWORD PTR _pDest$[ebp], 0
  00013	74 06		 je	 SHORT $LN7@base64_dec
  00015	83 7d 0c 00	 cmp	 DWORD PTR _nSize$[ebp], 0
  00019	77 07		 ja	 SHORT $LN6@base64_dec
$LN7@base64_dec:
  0001b	33 c0		 xor	 eax, eax
  0001d	e9 50 01 00 00	 jmp	 $LN1@base64_dec
$LN6@base64_dec:

; 231  : 			
; 232  : 	unsigned int lByteBuffer, lByteBufferSpace;
; 233  : 	unsigned int C; //��ʱ�Ķ�����
; 234  : 	int reallen;
; 235  : 	char *InPtr, *InLimitPtr;
; 236  : 	char *OutPtr;
; 237  : 				
; 238  : 	lByteBuffer = 0; lByteBufferSpace = 4;

  00022	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR _lByteBuffer$[ebp], 0
  00029	c7 45 f8 04 00
	00 00		 mov	 DWORD PTR _lByteBufferSpace$[ebp], 4

; 239  : 				
; 240  : 	InPtr = pSrc;

  00030	8b 45 08	 mov	 eax, DWORD PTR _pSrc$[ebp]
  00033	89 45 ec	 mov	 DWORD PTR _InPtr$[ebp], eax

; 241  : 	InLimitPtr= InPtr + nSize;

  00036	8b 45 ec	 mov	 eax, DWORD PTR _InPtr$[ebp]
  00039	03 45 0c	 add	 eax, DWORD PTR _nSize$[ebp]
  0003c	89 45 e8	 mov	 DWORD PTR _InLimitPtr$[ebp], eax

; 242  : 	OutPtr = pDest;

  0003f	8b 45 10	 mov	 eax, DWORD PTR _pDest$[ebp]
  00042	89 45 e4	 mov	 DWORD PTR _OutPtr$[ebp], eax
$LN2@base64_dec:

; 243  : 				
; 244  : 	while (InPtr != InLimitPtr)

  00045	8b 45 ec	 mov	 eax, DWORD PTR _InPtr$[ebp]
  00048	3b 45 e8	 cmp	 eax, DWORD PTR _InLimitPtr$[ebp]
  0004b	0f 84 a3 00 00
	00		 je	 $LN3@base64_dec

; 245  : 	{
; 246  : 		C = BASE64_DECODE_TABLE[*InPtr]; // Read from InputBuffer.

  00051	8b 45 ec	 mov	 eax, DWORD PTR _InPtr$[ebp]
  00054	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  00057	8b 14 8d 00 00
	00 00		 mov	 edx, DWORD PTR ?BASE64_DECODE_TABLE@CMailCoder@@2QBIB[ecx*4]
  0005e	89 55 f4	 mov	 DWORD PTR _C$[ebp], edx

; 247  : 		InPtr++;

  00061	8b 45 ec	 mov	 eax, DWORD PTR _InPtr$[ebp]
  00064	83 c0 01	 add	 eax, 1
  00067	89 45 ec	 mov	 DWORD PTR _InPtr$[ebp], eax

; 248  : 		if (C == 0xFF) continue; //����255�Ƿ��ַ�

  0006a	81 7d f4 ff 00
	00 00		 cmp	 DWORD PTR _C$[ebp], 255	; 000000ffH
  00071	75 02		 jne	 SHORT $LN8@base64_dec
  00073	eb d0		 jmp	 SHORT $LN2@base64_dec
$LN8@base64_dec:

; 249  : 		lByteBuffer = lByteBuffer << 6 ;

  00075	8b 45 fc	 mov	 eax, DWORD PTR _lByteBuffer$[ebp]
  00078	c1 e0 06	 shl	 eax, 6
  0007b	89 45 fc	 mov	 DWORD PTR _lByteBuffer$[ebp], eax

; 250  : 		lByteBuffer = lByteBuffer | C ;

  0007e	8b 45 fc	 mov	 eax, DWORD PTR _lByteBuffer$[ebp]
  00081	0b 45 f4	 or	 eax, DWORD PTR _C$[ebp]
  00084	89 45 fc	 mov	 DWORD PTR _lByteBuffer$[ebp], eax

; 251  : 		lByteBufferSpace--;

  00087	8b 45 f8	 mov	 eax, DWORD PTR _lByteBufferSpace$[ebp]
  0008a	83 e8 01	 sub	 eax, 1
  0008d	89 45 f8	 mov	 DWORD PTR _lByteBufferSpace$[ebp], eax

; 252  : 		if (lByteBufferSpace != 0) continue; //һ�ζ���4���ֽ�

  00090	74 02		 je	 SHORT $LN9@base64_dec
  00092	eb b1		 jmp	 SHORT $LN2@base64_dec
$LN9@base64_dec:

; 253  : 		//����д��3���ֽڵ�����
; 254  : 		OutPtr[2] = lByteBuffer;

  00094	b8 01 00 00 00	 mov	 eax, 1
  00099	d1 e0		 shl	 eax, 1
  0009b	8b 4d e4	 mov	 ecx, DWORD PTR _OutPtr$[ebp]
  0009e	8a 55 fc	 mov	 dl, BYTE PTR _lByteBuffer$[ebp]
  000a1	88 14 01	 mov	 BYTE PTR [ecx+eax], dl

; 255  : 		lByteBuffer = lByteBuffer >> 8;

  000a4	8b 45 fc	 mov	 eax, DWORD PTR _lByteBuffer$[ebp]
  000a7	c1 e8 08	 shr	 eax, 8
  000aa	89 45 fc	 mov	 DWORD PTR _lByteBuffer$[ebp], eax

; 256  : 		OutPtr[1] = lByteBuffer;

  000ad	b8 01 00 00 00	 mov	 eax, 1
  000b2	c1 e0 00	 shl	 eax, 0
  000b5	8b 4d e4	 mov	 ecx, DWORD PTR _OutPtr$[ebp]
  000b8	8a 55 fc	 mov	 dl, BYTE PTR _lByteBuffer$[ebp]
  000bb	88 14 01	 mov	 BYTE PTR [ecx+eax], dl

; 257  : 		lByteBuffer = lByteBuffer >> 8;

  000be	8b 45 fc	 mov	 eax, DWORD PTR _lByteBuffer$[ebp]
  000c1	c1 e8 08	 shr	 eax, 8
  000c4	89 45 fc	 mov	 DWORD PTR _lByteBuffer$[ebp], eax

; 258  : 		OutPtr[0] = lByteBuffer;

  000c7	b8 01 00 00 00	 mov	 eax, 1
  000cc	6b c8 00	 imul	 ecx, eax, 0
  000cf	8b 55 e4	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  000d2	8a 45 fc	 mov	 al, BYTE PTR _lByteBuffer$[ebp]
  000d5	88 04 0a	 mov	 BYTE PTR [edx+ecx], al

; 259  : 		//׼��д���3λ
; 260  : 		OutPtr+= 3; lByteBuffer = 0; lByteBufferSpace = 4;

  000d8	8b 45 e4	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  000db	83 c0 03	 add	 eax, 3
  000de	89 45 e4	 mov	 DWORD PTR _OutPtr$[ebp], eax
  000e1	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR _lByteBuffer$[ebp], 0
  000e8	c7 45 f8 04 00
	00 00		 mov	 DWORD PTR _lByteBufferSpace$[ebp], 4

; 261  : 	}

  000ef	e9 51 ff ff ff	 jmp	 $LN2@base64_dec
$LN3@base64_dec:

; 262  : 	reallen = (unsigned int)OutPtr - (unsigned int)pDest;

  000f4	8b 45 e4	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  000f7	2b 45 10	 sub	 eax, DWORD PTR _pDest$[ebp]
  000fa	89 45 f0	 mov	 DWORD PTR _reallen$[ebp], eax

; 263  : 	//����β�� ����ʵ�ʳ���
; 264  : 	switch (lByteBufferSpace)

  000fd	8b 45 f8	 mov	 eax, DWORD PTR _lByteBufferSpace$[ebp]
  00100	89 45 a0	 mov	 DWORD PTR tv88[ebp], eax
  00103	83 7d a0 01	 cmp	 DWORD PTR tv88[ebp], 1
  00107	74 08		 je	 SHORT $LN10@base64_dec
  00109	83 7d a0 02	 cmp	 DWORD PTR tv88[ebp], 2
  0010d	74 3e		 je	 SHORT $LN11@base64_dec
  0010f	eb 5e		 jmp	 SHORT $LN12@base64_dec
$LN10@base64_dec:

; 265  : 	{
; 266  : 		case 1:
; 267  : 			lByteBuffer = lByteBuffer >> 2;

  00111	8b 45 fc	 mov	 eax, DWORD PTR _lByteBuffer$[ebp]
  00114	c1 e8 02	 shr	 eax, 2
  00117	89 45 fc	 mov	 DWORD PTR _lByteBuffer$[ebp], eax

; 268  : 			OutPtr[1] = lByteBuffer;

  0011a	b8 01 00 00 00	 mov	 eax, 1
  0011f	c1 e0 00	 shl	 eax, 0
  00122	8b 4d e4	 mov	 ecx, DWORD PTR _OutPtr$[ebp]
  00125	8a 55 fc	 mov	 dl, BYTE PTR _lByteBuffer$[ebp]
  00128	88 14 01	 mov	 BYTE PTR [ecx+eax], dl

; 269  : 			lByteBuffer = lByteBuffer >> 8;

  0012b	8b 45 fc	 mov	 eax, DWORD PTR _lByteBuffer$[ebp]
  0012e	c1 e8 08	 shr	 eax, 8
  00131	89 45 fc	 mov	 DWORD PTR _lByteBuffer$[ebp], eax

; 270  : 			OutPtr[0] = lByteBuffer;

  00134	b8 01 00 00 00	 mov	 eax, 1
  00139	6b c8 00	 imul	 ecx, eax, 0
  0013c	8b 55 e4	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  0013f	8a 45 fc	 mov	 al, BYTE PTR _lByteBuffer$[ebp]
  00142	88 04 0a	 mov	 BYTE PTR [edx+ecx], al

; 271  : 			return reallen + 2;

  00145	8b 45 f0	 mov	 eax, DWORD PTR _reallen$[ebp]
  00148	83 c0 02	 add	 eax, 2
  0014b	eb 25		 jmp	 SHORT $LN1@base64_dec
$LN11@base64_dec:

; 272  : 		case 2:
; 273  : 			lByteBuffer = lByteBuffer >> 4;

  0014d	8b 45 fc	 mov	 eax, DWORD PTR _lByteBuffer$[ebp]
  00150	c1 e8 04	 shr	 eax, 4
  00153	89 45 fc	 mov	 DWORD PTR _lByteBuffer$[ebp], eax

; 274  : 			OutPtr[0] = lByteBuffer;

  00156	b8 01 00 00 00	 mov	 eax, 1
  0015b	6b c8 00	 imul	 ecx, eax, 0
  0015e	8b 55 e4	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  00161	8a 45 fc	 mov	 al, BYTE PTR _lByteBuffer$[ebp]
  00164	88 04 0a	 mov	 BYTE PTR [edx+ecx], al

; 275  : 			return reallen + 1;

  00167	8b 45 f0	 mov	 eax, DWORD PTR _reallen$[ebp]
  0016a	83 c0 01	 add	 eax, 1
  0016d	eb 03		 jmp	 SHORT $LN1@base64_dec
$LN12@base64_dec:

; 276  : 		default:
; 277  : 			return reallen;

  0016f	8b 45 f0	 mov	 eax, DWORD PTR _reallen$[ebp]
$LN1@base64_dec:

; 278  : 	}
; 279  : }

  00172	5f		 pop	 edi
  00173	5e		 pop	 esi
  00174	5b		 pop	 ebx
  00175	8b e5		 mov	 esp, ebp
  00177	5d		 pop	 ebp
  00178	c3		 ret	 0
?base64_decode@CMailCoder@@SAHPADI0@Z ENDP		; CMailCoder::base64_decode
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?base64_encode@CMailCoder@@SAHPADI0@Z
_TEXT	SEGMENT
tv169 = -92						; size = 4
tv148 = -92						; size = 4
tv87 = -92						; size = 4
tv81 = -92						; size = 4
tv75 = -92						; size = 4
_OutPtr$ = -24						; size = 4
_pInLimitPtr$ = -20					; size = 4
_pInPtr$ = -16						; size = 4
_Len$ = -12						; size = 4
_iInMax3$ = -8						; size = 4
_iB$ = -4						; size = 4
_pSrc$ = 8						; size = 4
_nSize$ = 12						; size = 4
_pDest$ = 16						; size = 4
?base64_encode@CMailCoder@@SAHPADI0@Z PROC		; CMailCoder::base64_encode, COMDAT

; 153  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 5c	 sub	 esp, 92			; 0000005cH
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi

; 154  : 	if ((pSrc == NULL) || (nSize <= 0)) return 0;

  00009	83 7d 08 00	 cmp	 DWORD PTR _pSrc$[ebp], 0
  0000d	74 06		 je	 SHORT $LN9@base64_enc
  0000f	83 7d 0c 00	 cmp	 DWORD PTR _nSize$[ebp], 0
  00013	77 07		 ja	 SHORT $LN8@base64_enc
$LN9@base64_enc:
  00015	33 c0		 xor	 eax, eax
  00017	e9 ba 02 00 00	 jmp	 $LN1@base64_enc
$LN8@base64_enc:

; 155  : 		
; 156  : 	unsigned int iB, iInMax3, Len;
; 157  : 	char *pInPtr, *pInLimitPtr;
; 158  : 	char *OutPtr ;
; 159  : 			
; 160  : 	pInPtr = pSrc;

  0001c	8b 45 08	 mov	 eax, DWORD PTR _pSrc$[ebp]
  0001f	89 45 f0	 mov	 DWORD PTR _pInPtr$[ebp], eax

; 161  : 	iInMax3 = nSize / 3 * 3;

  00022	8b 45 0c	 mov	 eax, DWORD PTR _nSize$[ebp]
  00025	33 d2		 xor	 edx, edx
  00027	b9 03 00 00 00	 mov	 ecx, 3
  0002c	f7 f1		 div	 ecx
  0002e	6b d0 03	 imul	 edx, eax, 3
  00031	89 55 f8	 mov	 DWORD PTR _iInMax3$[ebp], edx

; 162  : 	OutPtr = pDest;

  00034	8b 45 10	 mov	 eax, DWORD PTR _pDest$[ebp]
  00037	89 45 e8	 mov	 DWORD PTR _OutPtr$[ebp], eax

; 163  : 	pInLimitPtr = pInPtr + iInMax3;

  0003a	8b 45 f0	 mov	 eax, DWORD PTR _pInPtr$[ebp]
  0003d	03 45 f8	 add	 eax, DWORD PTR _iInMax3$[ebp]
  00040	89 45 ec	 mov	 DWORD PTR _pInLimitPtr$[ebp], eax
$LN2@base64_enc:

; 164  : 				
; 165  : 	while (pInPtr != pInLimitPtr)

  00043	8b 45 f0	 mov	 eax, DWORD PTR _pInPtr$[ebp]
  00046	3b 45 ec	 cmp	 eax, DWORD PTR _pInLimitPtr$[ebp]
  00049	0f 84 46 01 00
	00		 je	 $LN3@base64_enc

; 166  : 	{
; 167  : 		Len = 0;

  0004f	c7 45 f4 00 00
	00 00		 mov	 DWORD PTR _Len$[ebp], 0
$LN4@base64_enc:

; 168  : 		while ((Len < m_LineWidth) && (pInPtr != pInLimitPtr))

  00056	8b 45 f4	 mov	 eax, DWORD PTR _Len$[ebp]
  00059	3b 05 00 00 00
	00		 cmp	 eax, DWORD PTR ?m_LineWidth@CMailCoder@@2IA ; CMailCoder::m_LineWidth
  0005f	0f 83 02 01 00
	00		 jae	 $LN5@base64_enc
  00065	8b 45 f0	 mov	 eax, DWORD PTR _pInPtr$[ebp]
  00068	3b 45 ec	 cmp	 eax, DWORD PTR _pInLimitPtr$[ebp]
  0006b	0f 84 f6 00 00
	00		 je	 $LN5@base64_enc

; 169  : 		{
; 170  : 			iB = (unsigned char) *pInPtr++;

  00071	8b 45 f0	 mov	 eax, DWORD PTR _pInPtr$[ebp]
  00074	0f b6 08	 movzx	 ecx, BYTE PTR [eax]
  00077	89 4d a4	 mov	 DWORD PTR tv75[ebp], ecx
  0007a	8b 55 f0	 mov	 edx, DWORD PTR _pInPtr$[ebp]
  0007d	83 c2 01	 add	 edx, 1
  00080	89 55 f0	 mov	 DWORD PTR _pInPtr$[ebp], edx
  00083	8b 45 a4	 mov	 eax, DWORD PTR tv75[ebp]
  00086	89 45 fc	 mov	 DWORD PTR _iB$[ebp], eax

; 171  : 			iB = iB << 8;

  00089	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  0008c	c1 e0 08	 shl	 eax, 8
  0008f	89 45 fc	 mov	 DWORD PTR _iB$[ebp], eax

; 172  : 				
; 173  : 			iB = iB | (unsigned char) *pInPtr++;

  00092	8b 45 f0	 mov	 eax, DWORD PTR _pInPtr$[ebp]
  00095	0f b6 08	 movzx	 ecx, BYTE PTR [eax]
  00098	0b 4d fc	 or	 ecx, DWORD PTR _iB$[ebp]
  0009b	89 4d a4	 mov	 DWORD PTR tv81[ebp], ecx
  0009e	8b 55 f0	 mov	 edx, DWORD PTR _pInPtr$[ebp]
  000a1	83 c2 01	 add	 edx, 1
  000a4	89 55 f0	 mov	 DWORD PTR _pInPtr$[ebp], edx
  000a7	8b 45 a4	 mov	 eax, DWORD PTR tv81[ebp]
  000aa	89 45 fc	 mov	 DWORD PTR _iB$[ebp], eax

; 174  : 			iB = iB << 8;

  000ad	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  000b0	c1 e0 08	 shl	 eax, 8
  000b3	89 45 fc	 mov	 DWORD PTR _iB$[ebp], eax

; 175  : 						
; 176  : 			iB = iB | (unsigned char) *pInPtr++;

  000b6	8b 45 f0	 mov	 eax, DWORD PTR _pInPtr$[ebp]
  000b9	0f b6 08	 movzx	 ecx, BYTE PTR [eax]
  000bc	0b 4d fc	 or	 ecx, DWORD PTR _iB$[ebp]
  000bf	89 4d a4	 mov	 DWORD PTR tv87[ebp], ecx
  000c2	8b 55 f0	 mov	 edx, DWORD PTR _pInPtr$[ebp]
  000c5	83 c2 01	 add	 edx, 1
  000c8	89 55 f0	 mov	 DWORD PTR _pInPtr$[ebp], edx
  000cb	8b 45 a4	 mov	 eax, DWORD PTR tv87[ebp]
  000ce	89 45 fc	 mov	 DWORD PTR _iB$[ebp], eax

; 177  : 						
; 178  : 			//��4 byte������������
; 179  : 			OutPtr[3] = BASE64_ENCODE_TABLE[iB & 0x3F];

  000d1	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  000d4	83 e0 3f	 and	 eax, 63			; 0000003fH
  000d7	b9 01 00 00 00	 mov	 ecx, 1
  000dc	6b d1 03	 imul	 edx, ecx, 3
  000df	8b 4d e8	 mov	 ecx, DWORD PTR _OutPtr$[ebp]
  000e2	8a 80 00 00 00
	00		 mov	 al, BYTE PTR ?BASE64_ENCODE_TABLE@CMailCoder@@2QBDB[eax]
  000e8	88 04 11	 mov	 BYTE PTR [ecx+edx], al

; 180  : 			iB = iB >> 6;

  000eb	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  000ee	c1 e8 06	 shr	 eax, 6
  000f1	89 45 fc	 mov	 DWORD PTR _iB$[ebp], eax

; 181  : 			OutPtr[2] = BASE64_ENCODE_TABLE[iB & 0x3F];

  000f4	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  000f7	83 e0 3f	 and	 eax, 63			; 0000003fH
  000fa	b9 01 00 00 00	 mov	 ecx, 1
  000ff	d1 e1		 shl	 ecx, 1
  00101	8b 55 e8	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  00104	8a 80 00 00 00
	00		 mov	 al, BYTE PTR ?BASE64_ENCODE_TABLE@CMailCoder@@2QBDB[eax]
  0010a	88 04 0a	 mov	 BYTE PTR [edx+ecx], al

; 182  : 			iB = iB >> 6;

  0010d	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  00110	c1 e8 06	 shr	 eax, 6
  00113	89 45 fc	 mov	 DWORD PTR _iB$[ebp], eax

; 183  : 			OutPtr[1] = BASE64_ENCODE_TABLE[iB & 0x3F];

  00116	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  00119	83 e0 3f	 and	 eax, 63			; 0000003fH
  0011c	b9 01 00 00 00	 mov	 ecx, 1
  00121	c1 e1 00	 shl	 ecx, 0
  00124	8b 55 e8	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  00127	8a 80 00 00 00
	00		 mov	 al, BYTE PTR ?BASE64_ENCODE_TABLE@CMailCoder@@2QBDB[eax]
  0012d	88 04 0a	 mov	 BYTE PTR [edx+ecx], al

; 184  : 			iB = iB >> 6;

  00130	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  00133	c1 e8 06	 shr	 eax, 6
  00136	89 45 fc	 mov	 DWORD PTR _iB$[ebp], eax

; 185  : 			OutPtr[0] = BASE64_ENCODE_TABLE[iB];

  00139	b8 01 00 00 00	 mov	 eax, 1
  0013e	6b c8 00	 imul	 ecx, eax, 0
  00141	8b 55 e8	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  00144	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  00147	8a 80 00 00 00
	00		 mov	 al, BYTE PTR ?BASE64_ENCODE_TABLE@CMailCoder@@2QBDB[eax]
  0014d	88 04 0a	 mov	 BYTE PTR [edx+ecx], al

; 186  : 			OutPtr+=4;

  00150	8b 45 e8	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  00153	83 c0 04	 add	 eax, 4
  00156	89 45 e8	 mov	 DWORD PTR _OutPtr$[ebp], eax

; 187  : 			Len+=4;

  00159	8b 45 f4	 mov	 eax, DWORD PTR _Len$[ebp]
  0015c	83 c0 04	 add	 eax, 4
  0015f	89 45 f4	 mov	 DWORD PTR _Len$[ebp], eax

; 188  : 		}

  00162	e9 ef fe ff ff	 jmp	 $LN4@base64_enc
$LN5@base64_enc:

; 189  : 		if (Len >= m_LineWidth)

  00167	8b 45 f4	 mov	 eax, DWORD PTR _Len$[ebp]
  0016a	3b 05 00 00 00
	00		 cmp	 eax, DWORD PTR ?m_LineWidth@CMailCoder@@2IA ; CMailCoder::m_LineWidth
  00170	72 1e		 jb	 SHORT $LN10@base64_enc

; 190  : 		{
; 191  : 			*OutPtr++ = '\r'; //���ϻس����з�

  00172	8b 45 e8	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  00175	c6 00 0d	 mov	 BYTE PTR [eax], 13	; 0000000dH
  00178	8b 4d e8	 mov	 ecx, DWORD PTR _OutPtr$[ebp]
  0017b	83 c1 01	 add	 ecx, 1
  0017e	89 4d e8	 mov	 DWORD PTR _OutPtr$[ebp], ecx

; 192  : 			*OutPtr++ = '\n';

  00181	8b 45 e8	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  00184	c6 00 0a	 mov	 BYTE PTR [eax], 10	; 0000000aH
  00187	8b 4d e8	 mov	 ecx, DWORD PTR _OutPtr$[ebp]
  0018a	83 c1 01	 add	 ecx, 1
  0018d	89 4d e8	 mov	 DWORD PTR _OutPtr$[ebp], ecx
$LN10@base64_enc:

; 193  : 		}
; 194  : 	}

  00190	e9 ae fe ff ff	 jmp	 $LN2@base64_enc
$LN3@base64_enc:

; 195  : 	//�����
; 196  : 	switch (nSize - iInMax3)

  00195	8b 45 0c	 mov	 eax, DWORD PTR _nSize$[ebp]
  00198	2b 45 f8	 sub	 eax, DWORD PTR _iInMax3$[ebp]
  0019b	89 45 a4	 mov	 DWORD PTR tv148[ebp], eax
  0019e	83 7d a4 01	 cmp	 DWORD PTR tv148[ebp], 1
  001a2	74 0b		 je	 SHORT $LN11@base64_enc
  001a4	83 7d a4 02	 cmp	 DWORD PTR tv148[ebp], 2
  001a8	74 7c		 je	 SHORT $LN12@base64_enc
  001aa	e9 21 01 00 00	 jmp	 $LN6@base64_enc
$LN11@base64_enc:

; 197  : 	{
; 198  : 		case 1:
; 199  : 			iB = (unsigned char) *pInPtr;

  001af	8b 45 f0	 mov	 eax, DWORD PTR _pInPtr$[ebp]
  001b2	0f b6 08	 movzx	 ecx, BYTE PTR [eax]
  001b5	89 4d fc	 mov	 DWORD PTR _iB$[ebp], ecx

; 200  : 			iB = iB << 4;

  001b8	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  001bb	c1 e0 04	 shl	 eax, 4
  001be	89 45 fc	 mov	 DWORD PTR _iB$[ebp], eax

; 201  : 			OutPtr[1] = BASE64_ENCODE_TABLE[iB & 0x3F];

  001c1	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  001c4	83 e0 3f	 and	 eax, 63			; 0000003fH
  001c7	b9 01 00 00 00	 mov	 ecx, 1
  001cc	c1 e1 00	 shl	 ecx, 0
  001cf	8b 55 e8	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  001d2	8a 80 00 00 00
	00		 mov	 al, BYTE PTR ?BASE64_ENCODE_TABLE@CMailCoder@@2QBDB[eax]
  001d8	88 04 0a	 mov	 BYTE PTR [edx+ecx], al

; 202  : 			iB = iB >> 6;

  001db	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  001de	c1 e8 06	 shr	 eax, 6
  001e1	89 45 fc	 mov	 DWORD PTR _iB$[ebp], eax

; 203  : 			OutPtr[0] = BASE64_ENCODE_TABLE[iB];

  001e4	b8 01 00 00 00	 mov	 eax, 1
  001e9	6b c8 00	 imul	 ecx, eax, 0
  001ec	8b 55 e8	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  001ef	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  001f2	8a 80 00 00 00
	00		 mov	 al, BYTE PTR ?BASE64_ENCODE_TABLE@CMailCoder@@2QBDB[eax]
  001f8	88 04 0a	 mov	 BYTE PTR [edx+ecx], al

; 204  : 			OutPtr[2] = '='; //��'='Ҳ����64�����ʣ�ಿ��

  001fb	b8 01 00 00 00	 mov	 eax, 1
  00200	d1 e0		 shl	 eax, 1
  00202	8b 4d e8	 mov	 ecx, DWORD PTR _OutPtr$[ebp]
  00205	c6 04 01 3d	 mov	 BYTE PTR [ecx+eax], 61	; 0000003dH

; 205  : 			OutPtr[3] = '=';

  00209	b8 01 00 00 00	 mov	 eax, 1
  0020e	6b c8 03	 imul	 ecx, eax, 3
  00211	8b 55 e8	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  00214	c6 04 0a 3d	 mov	 BYTE PTR [edx+ecx], 61	; 0000003dH

; 206  : 			OutPtr+=4;

  00218	8b 45 e8	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  0021b	83 c0 04	 add	 eax, 4
  0021e	89 45 e8	 mov	 DWORD PTR _OutPtr$[ebp], eax

; 207  : 			break;

  00221	e9 aa 00 00 00	 jmp	 $LN6@base64_enc
$LN12@base64_enc:

; 208  : 		case 2:
; 209  : 			iB = (unsigned char) *pInPtr++;

  00226	8b 45 f0	 mov	 eax, DWORD PTR _pInPtr$[ebp]
  00229	0f b6 08	 movzx	 ecx, BYTE PTR [eax]
  0022c	89 4d a4	 mov	 DWORD PTR tv169[ebp], ecx
  0022f	8b 55 f0	 mov	 edx, DWORD PTR _pInPtr$[ebp]
  00232	83 c2 01	 add	 edx, 1
  00235	89 55 f0	 mov	 DWORD PTR _pInPtr$[ebp], edx
  00238	8b 45 a4	 mov	 eax, DWORD PTR tv169[ebp]
  0023b	89 45 fc	 mov	 DWORD PTR _iB$[ebp], eax

; 210  : 			iB = iB << 8;

  0023e	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  00241	c1 e0 08	 shl	 eax, 8
  00244	89 45 fc	 mov	 DWORD PTR _iB$[ebp], eax

; 211  : 			iB = iB | (unsigned char) *pInPtr;

  00247	8b 45 f0	 mov	 eax, DWORD PTR _pInPtr$[ebp]
  0024a	0f b6 08	 movzx	 ecx, BYTE PTR [eax]
  0024d	0b 4d fc	 or	 ecx, DWORD PTR _iB$[ebp]
  00250	89 4d fc	 mov	 DWORD PTR _iB$[ebp], ecx

; 212  : 			iB = iB << 2;

  00253	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  00256	c1 e0 02	 shl	 eax, 2
  00259	89 45 fc	 mov	 DWORD PTR _iB$[ebp], eax

; 213  : 			OutPtr[2] = BASE64_ENCODE_TABLE[iB & 0x3F];

  0025c	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  0025f	83 e0 3f	 and	 eax, 63			; 0000003fH
  00262	b9 01 00 00 00	 mov	 ecx, 1
  00267	d1 e1		 shl	 ecx, 1
  00269	8b 55 e8	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  0026c	8a 80 00 00 00
	00		 mov	 al, BYTE PTR ?BASE64_ENCODE_TABLE@CMailCoder@@2QBDB[eax]
  00272	88 04 0a	 mov	 BYTE PTR [edx+ecx], al

; 214  : 			iB = iB >> 6;

  00275	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  00278	c1 e8 06	 shr	 eax, 6
  0027b	89 45 fc	 mov	 DWORD PTR _iB$[ebp], eax

; 215  : 			OutPtr[1] = BASE64_ENCODE_TABLE[iB & 0x3F];

  0027e	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  00281	83 e0 3f	 and	 eax, 63			; 0000003fH
  00284	b9 01 00 00 00	 mov	 ecx, 1
  00289	c1 e1 00	 shl	 ecx, 0
  0028c	8b 55 e8	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  0028f	8a 80 00 00 00
	00		 mov	 al, BYTE PTR ?BASE64_ENCODE_TABLE@CMailCoder@@2QBDB[eax]
  00295	88 04 0a	 mov	 BYTE PTR [edx+ecx], al

; 216  : 			iB = iB >> 6;

  00298	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  0029b	c1 e8 06	 shr	 eax, 6
  0029e	89 45 fc	 mov	 DWORD PTR _iB$[ebp], eax

; 217  : 			OutPtr[0] = BASE64_ENCODE_TABLE[iB];

  002a1	b8 01 00 00 00	 mov	 eax, 1
  002a6	6b c8 00	 imul	 ecx, eax, 0
  002a9	8b 55 e8	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  002ac	8b 45 fc	 mov	 eax, DWORD PTR _iB$[ebp]
  002af	8a 80 00 00 00
	00		 mov	 al, BYTE PTR ?BASE64_ENCODE_TABLE@CMailCoder@@2QBDB[eax]
  002b5	88 04 0a	 mov	 BYTE PTR [edx+ecx], al

; 218  : 			OutPtr[3] = '='; // Fill remaining byte.

  002b8	b8 01 00 00 00	 mov	 eax, 1
  002bd	6b c8 03	 imul	 ecx, eax, 3
  002c0	8b 55 e8	 mov	 edx, DWORD PTR _OutPtr$[ebp]
  002c3	c6 04 0a 3d	 mov	 BYTE PTR [edx+ecx], 61	; 0000003dH

; 219  : 			OutPtr+=4;

  002c7	8b 45 e8	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  002ca	83 c0 04	 add	 eax, 4
  002cd	89 45 e8	 mov	 DWORD PTR _OutPtr$[ebp], eax
$LN6@base64_enc:

; 220  : 			break;
; 221  : 	}
; 222  : 	return (unsigned int) (OutPtr - pDest);

  002d0	8b 45 e8	 mov	 eax, DWORD PTR _OutPtr$[ebp]
  002d3	2b 45 10	 sub	 eax, DWORD PTR _pDest$[ebp]
$LN1@base64_enc:

; 223  : }

  002d6	5f		 pop	 edi
  002d7	5e		 pop	 esi
  002d8	5b		 pop	 ebx
  002d9	8b e5		 mov	 esp, ebp
  002db	5d		 pop	 ebp
  002dc	c3		 ret	 0
?base64_encode@CMailCoder@@SAHPADI0@Z ENDP		; CMailCoder::base64_encode
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?QuotedEncodeSize@CMailCoder@@SAHH@Z
_TEXT	SEGMENT
_nCR$ = -8						; size = 4
_nSize$ = -4						; size = 4
_iSize$ = 8						; size = 4
?QuotedEncodeSize@CMailCoder@@SAHH@Z PROC		; CMailCoder::QuotedEncodeSize, COMDAT

; 142  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 48	 sub	 esp, 72			; 00000048H
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi

; 143  : 	int nSize = iSize * 3 + 1;

  00009	6b 45 08 03	 imul	 eax, DWORD PTR _iSize$[ebp], 3
  0000d	83 c0 01	 add	 eax, 1
  00010	89 45 fc	 mov	 DWORD PTR _nSize$[ebp], eax

; 144  : 	int nCR = nSize / m_LineWidth;

  00013	8b 45 fc	 mov	 eax, DWORD PTR _nSize$[ebp]
  00016	33 d2		 xor	 edx, edx
  00018	f7 35 00 00 00
	00		 div	 DWORD PTR ?m_LineWidth@CMailCoder@@2IA ; CMailCoder::m_LineWidth
  0001e	89 45 f8	 mov	 DWORD PTR _nCR$[ebp], eax

; 145  : 	nSize+= nCR * 3;

  00021	6b 45 f8 03	 imul	 eax, DWORD PTR _nCR$[ebp], 3
  00025	03 45 fc	 add	 eax, DWORD PTR _nSize$[ebp]
  00028	89 45 fc	 mov	 DWORD PTR _nSize$[ebp], eax

; 146  : 	return nSize;

  0002b	8b 45 fc	 mov	 eax, DWORD PTR _nSize$[ebp]

; 147  : }

  0002e	5f		 pop	 edi
  0002f	5e		 pop	 esi
  00030	5b		 pop	 ebx
  00031	8b e5		 mov	 esp, ebp
  00033	5d		 pop	 ebp
  00034	c3		 ret	 0
?QuotedEncodeSize@CMailCoder@@SAHH@Z ENDP		; CMailCoder::QuotedEncodeSize
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?UUDecodeSize@CMailCoder@@SAHH@Z
_TEXT	SEGMENT
_iSize$ = 8						; size = 4
?UUDecodeSize@CMailCoder@@SAHH@Z PROC			; CMailCoder::UUDecodeSize, COMDAT

; 134  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 40	 sub	 esp, 64			; 00000040H
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi

; 135  : 	return (iSize + 3) / 4 * 3;

  00009	8b 45 08	 mov	 eax, DWORD PTR _iSize$[ebp]
  0000c	83 c0 03	 add	 eax, 3
  0000f	99		 cdq
  00010	83 e2 03	 and	 edx, 3
  00013	03 c2		 add	 eax, edx
  00015	c1 f8 02	 sar	 eax, 2
  00018	6b c0 03	 imul	 eax, eax, 3

; 136  : }

  0001b	5f		 pop	 edi
  0001c	5e		 pop	 esi
  0001d	5b		 pop	 ebx
  0001e	8b e5		 mov	 esp, ebp
  00020	5d		 pop	 ebp
  00021	c3		 ret	 0
?UUDecodeSize@CMailCoder@@SAHH@Z ENDP			; CMailCoder::UUDecodeSize
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?UUEncodeSize@CMailCoder@@SAHH@Z
_TEXT	SEGMENT
_nCR$ = -8						; size = 4
_nSize$ = -4						; size = 4
_iSize$ = 8						; size = 4
?UUEncodeSize@CMailCoder@@SAHH@Z PROC			; CMailCoder::UUEncodeSize, COMDAT

; 122  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 48	 sub	 esp, 72			; 00000048H
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi

; 123  : 	int nSize, nCR;
; 124  : 	nSize = (iSize + 2) / 3 * 4 ;

  00009	8b 45 08	 mov	 eax, DWORD PTR _iSize$[ebp]
  0000c	83 c0 02	 add	 eax, 2
  0000f	99		 cdq
  00010	b9 03 00 00 00	 mov	 ecx, 3
  00015	f7 f9		 idiv	 ecx
  00017	c1 e0 02	 shl	 eax, 2
  0001a	89 45 fc	 mov	 DWORD PTR _nSize$[ebp], eax

; 125  : 	nCR = nSize / m_LineWidth + 2; //����س�����

  0001d	8b 45 fc	 mov	 eax, DWORD PTR _nSize$[ebp]
  00020	33 d2		 xor	 edx, edx
  00022	f7 35 00 00 00
	00		 div	 DWORD PTR ?m_LineWidth@CMailCoder@@2IA ; CMailCoder::m_LineWidth
  00028	83 c0 02	 add	 eax, 2
  0002b	89 45 f8	 mov	 DWORD PTR _nCR$[ebp], eax

; 126  : 	nSize+= nCR * 3 + 2;

  0002e	6b 45 f8 03	 imul	 eax, DWORD PTR _nCR$[ebp], 3
  00032	8b 4d fc	 mov	 ecx, DWORD PTR _nSize$[ebp]
  00035	8d 54 01 02	 lea	 edx, DWORD PTR [ecx+eax+2]
  00039	89 55 fc	 mov	 DWORD PTR _nSize$[ebp], edx

; 127  : 	return nSize;

  0003c	8b 45 fc	 mov	 eax, DWORD PTR _nSize$[ebp]

; 128  : }

  0003f	5f		 pop	 edi
  00040	5e		 pop	 esi
  00041	5b		 pop	 ebx
  00042	8b e5		 mov	 esp, ebp
  00044	5d		 pop	 ebp
  00045	c3		 ret	 0
?UUEncodeSize@CMailCoder@@SAHH@Z ENDP			; CMailCoder::UUEncodeSize
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?Base64DecodeSize@CMailCoder@@SAHH@Z
_TEXT	SEGMENT
_iSize$ = 8						; size = 4
?Base64DecodeSize@CMailCoder@@SAHH@Z PROC		; CMailCoder::Base64DecodeSize, COMDAT

; 114  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 40	 sub	 esp, 64			; 00000040H
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi

; 115  : 	return (iSize + 3) / 4 * 3;

  00009	8b 45 08	 mov	 eax, DWORD PTR _iSize$[ebp]
  0000c	83 c0 03	 add	 eax, 3
  0000f	99		 cdq
  00010	83 e2 03	 and	 edx, 3
  00013	03 c2		 add	 eax, edx
  00015	c1 f8 02	 sar	 eax, 2
  00018	6b c0 03	 imul	 eax, eax, 3

; 116  : }

  0001b	5f		 pop	 edi
  0001c	5e		 pop	 esi
  0001d	5b		 pop	 ebx
  0001e	8b e5		 mov	 esp, ebp
  00020	5d		 pop	 ebp
  00021	c3		 ret	 0
?Base64DecodeSize@CMailCoder@@SAHH@Z ENDP		; CMailCoder::Base64DecodeSize
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?Base64EncodeSize@CMailCoder@@SAHH@Z
_TEXT	SEGMENT
_nCR$ = -8						; size = 4
_nSize$ = -4						; size = 4
_iSize$ = 8						; size = 4
?Base64EncodeSize@CMailCoder@@SAHH@Z PROC		; CMailCoder::Base64EncodeSize, COMDAT

; 102  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 48	 sub	 esp, 72			; 00000048H
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi

; 103  : 	int nSize, nCR;
; 104  : 	nSize = (iSize + 2) / 3 * 4 ;

  00009	8b 45 08	 mov	 eax, DWORD PTR _iSize$[ebp]
  0000c	83 c0 02	 add	 eax, 2
  0000f	99		 cdq
  00010	b9 03 00 00 00	 mov	 ecx, 3
  00015	f7 f9		 idiv	 ecx
  00017	c1 e0 02	 shl	 eax, 2
  0001a	89 45 fc	 mov	 DWORD PTR _nSize$[ebp], eax

; 105  : 	nCR = nSize / m_LineWidth; //����س�����

  0001d	8b 45 fc	 mov	 eax, DWORD PTR _nSize$[ebp]
  00020	33 d2		 xor	 edx, edx
  00022	f7 35 00 00 00
	00		 div	 DWORD PTR ?m_LineWidth@CMailCoder@@2IA ; CMailCoder::m_LineWidth
  00028	89 45 f8	 mov	 DWORD PTR _nCR$[ebp], eax

; 106  : 	nSize+= nCR * 2;

  0002b	8b 45 f8	 mov	 eax, DWORD PTR _nCR$[ebp]
  0002e	8b 4d fc	 mov	 ecx, DWORD PTR _nSize$[ebp]
  00031	8d 14 41	 lea	 edx, DWORD PTR [ecx+eax*2]
  00034	89 55 fc	 mov	 DWORD PTR _nSize$[ebp], edx

; 107  : 	return nSize;

  00037	8b 45 fc	 mov	 eax, DWORD PTR _nSize$[ebp]

; 108  : }

  0003a	5f		 pop	 edi
  0003b	5e		 pop	 esi
  0003c	5b		 pop	 ebx
  0003d	8b e5		 mov	 esp, ebp
  0003f	5d		 pop	 ebp
  00040	c3		 ret	 0
?Base64EncodeSize@CMailCoder@@SAHH@Z ENDP		; CMailCoder::Base64EncodeSize
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?email_decode@CMailCoder@@QAEHPADI0@Z
_TEXT	SEGMENT
_iRet$1 = -44						; size = 4
_iEnd$2 = -40						; size = 4
_iRet$3 = -36						; size = 4
_iEnd$4 = -32						; size = 4
_iStart$5 = -28						; size = 4
_iStart2$6 = -24					; size = 4
_iDestLen$ = -20					; size = 4
_iSrc2Len$ = -16					; size = 4
_pSrc2$ = -12						; size = 4
_iSize$ = -8						; size = 4
_this$ = -4						; size = 4
_pSrc$ = 8						; size = 4
_nSize$ = 12						; size = 4
_pDest$ = 16						; size = 4
?email_decode@CMailCoder@@QAEHPADI0@Z PROC		; CMailCoder::email_decode, COMDAT
; _this$ = ecx

; 499  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 6c	 sub	 esp, 108		; 0000006cH
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi
  00009	89 4d fc	 mov	 DWORD PTR _this$[ebp], ecx

; 500  : 	int iSize=0;

  0000c	c7 45 f8 00 00
	00 00		 mov	 DWORD PTR _iSize$[ebp], 0

; 501  : 	char * pSrc2=pSrc;

  00013	8b 45 08	 mov	 eax, DWORD PTR _pSrc$[ebp]
  00016	89 45 f4	 mov	 DWORD PTR _pSrc2$[ebp], eax

; 502  : 	int    iSrc2Len=0;

  00019	c7 45 f0 00 00
	00 00		 mov	 DWORD PTR _iSrc2Len$[ebp], 0

; 503  : 	int    iDestLen=0;

  00020	c7 45 ec 00 00
	00 00		 mov	 DWORD PTR _iDestLen$[ebp], 0
$LN2@email_deco:

; 504  : 	while ( true )

  00027	b8 01 00 00 00	 mov	 eax, 1
  0002c	85 c0		 test	 eax, eax
  0002e	0f 84 46 01 00
	00		 je	 $LN3@email_deco

; 505  : 	{
; 506  : 		int iStart2 = FoundChar(pSrc2,"=?"); 

  00034	6a 00		 push	 0
  00036	68 00 00 00 00	 push	 OFFSET ??_C@_02HENDHKBC@?$DN?$DP@
  0003b	8b 45 f4	 mov	 eax, DWORD PTR _pSrc2$[ebp]
  0003e	50		 push	 eax
  0003f	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  00042	e8 00 00 00 00	 call	 ?FoundChar@CMailCoder@@QAEHPAD0J@Z ; CMailCoder::FoundChar
  00047	89 45 e8	 mov	 DWORD PTR _iStart2$6[ebp], eax

; 507  : 		if ( iStart2 >= 0 )

  0004a	83 7d e8 00	 cmp	 DWORD PTR _iStart2$6[ebp], 0
  0004e	0f 8c 1f 01 00
	00		 jl	 $LN4@email_deco

; 508  : 		{
; 509  : 			strncpy(pDest+iDestLen,pSrc2,iStart2);

  00054	8b 45 e8	 mov	 eax, DWORD PTR _iStart2$6[ebp]
  00057	50		 push	 eax
  00058	8b 4d f4	 mov	 ecx, DWORD PTR _pSrc2$[ebp]
  0005b	51		 push	 ecx
  0005c	8b 55 10	 mov	 edx, DWORD PTR _pDest$[ebp]
  0005f	03 55 ec	 add	 edx, DWORD PTR _iDestLen$[ebp]
  00062	52		 push	 edx
  00063	e8 00 00 00 00	 call	 _strncpy
  00068	83 c4 0c	 add	 esp, 12			; 0000000cH

; 510  : 			iDestLen +=iStart2;

  0006b	8b 45 ec	 mov	 eax, DWORD PTR _iDestLen$[ebp]
  0006e	03 45 e8	 add	 eax, DWORD PTR _iStart2$6[ebp]
  00071	89 45 ec	 mov	 DWORD PTR _iDestLen$[ebp], eax

; 511  : 			pSrc2+=iStart2+2; //=?Ϊ2���ֽ�

  00074	8b 45 e8	 mov	 eax, DWORD PTR _iStart2$6[ebp]
  00077	8b 4d f4	 mov	 ecx, DWORD PTR _pSrc2$[ebp]
  0007a	8d 54 01 02	 lea	 edx, DWORD PTR [ecx+eax+2]
  0007e	89 55 f4	 mov	 DWORD PTR _pSrc2$[ebp], edx

; 512  : 			int iStart = FoundChar(pSrc2,"?B?");

  00081	6a 00		 push	 0
  00083	68 00 00 00 00	 push	 OFFSET ??_C@_03FNDDLLIG@?$DPB?$DP@
  00088	8b 45 f4	 mov	 eax, DWORD PTR _pSrc2$[ebp]
  0008b	50		 push	 eax
  0008c	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  0008f	e8 00 00 00 00	 call	 ?FoundChar@CMailCoder@@QAEHPAD0J@Z ; CMailCoder::FoundChar
  00094	89 45 e4	 mov	 DWORD PTR _iStart$5[ebp], eax

; 513  : 			if ( iStart > 0 )

  00097	83 7d e4 00	 cmp	 DWORD PTR _iStart$5[ebp], 0
  0009b	7e 5b		 jle	 SHORT $LN6@email_deco

; 514  : 			{
; 515  : 				//iStart += 3; //?B?Ϊ3���ֽ�
; 516  : 				pSrc2=pSrc2+iStart+3; //?B?Ϊ3���ֽ�

  0009d	8b 45 e4	 mov	 eax, DWORD PTR _iStart$5[ebp]
  000a0	8b 4d f4	 mov	 ecx, DWORD PTR _pSrc2$[ebp]
  000a3	8d 54 01 03	 lea	 edx, DWORD PTR [ecx+eax+3]
  000a7	89 55 f4	 mov	 DWORD PTR _pSrc2$[ebp], edx

; 517  : 				int iEnd = FoundChar(pSrc2,"?=");

  000aa	6a 00		 push	 0
  000ac	68 00 00 00 00	 push	 OFFSET ??_C@_02EFGBMMPO@?$DP?$DN@
  000b1	8b 45 f4	 mov	 eax, DWORD PTR _pSrc2$[ebp]
  000b4	50		 push	 eax
  000b5	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  000b8	e8 00 00 00 00	 call	 ?FoundChar@CMailCoder@@QAEHPAD0J@Z ; CMailCoder::FoundChar
  000bd	89 45 e0	 mov	 DWORD PTR _iEnd$4[ebp], eax

; 518  : 				if ( iEnd > 1 )

  000c0	83 7d e0 01	 cmp	 DWORD PTR _iEnd$4[ebp], 1
  000c4	7e 30		 jle	 SHORT $LN8@email_deco

; 519  : 				{
; 520  : 					int iRet = base64_decode(pSrc2,iEnd,pDest+iDestLen);

  000c6	8b 45 10	 mov	 eax, DWORD PTR _pDest$[ebp]
  000c9	03 45 ec	 add	 eax, DWORD PTR _iDestLen$[ebp]
  000cc	50		 push	 eax
  000cd	8b 4d e0	 mov	 ecx, DWORD PTR _iEnd$4[ebp]
  000d0	51		 push	 ecx
  000d1	8b 55 f4	 mov	 edx, DWORD PTR _pSrc2$[ebp]
  000d4	52		 push	 edx
  000d5	e8 00 00 00 00	 call	 ?base64_decode@CMailCoder@@SAHPADI0@Z ; CMailCoder::base64_decode
  000da	83 c4 0c	 add	 esp, 12			; 0000000cH
  000dd	89 45 dc	 mov	 DWORD PTR _iRet$3[ebp], eax

; 521  : 					pSrc2 += iEnd+2;  //"?="�������ֽ�

  000e0	8b 45 e0	 mov	 eax, DWORD PTR _iEnd$4[ebp]
  000e3	8b 4d f4	 mov	 ecx, DWORD PTR _pSrc2$[ebp]
  000e6	8d 54 01 02	 lea	 edx, DWORD PTR [ecx+eax+2]
  000ea	89 55 f4	 mov	 DWORD PTR _pSrc2$[ebp], edx

; 522  : 					iDestLen += iRet;

  000ed	8b 45 ec	 mov	 eax, DWORD PTR _iDestLen$[ebp]
  000f0	03 45 dc	 add	 eax, DWORD PTR _iRet$3[ebp]
  000f3	89 45 ec	 mov	 DWORD PTR _iDestLen$[ebp], eax
$LN8@email_deco:

; 523  : 				}
; 524  : 			}

  000f6	eb 79		 jmp	 SHORT $LN7@email_deco
$LN6@email_deco:

; 525  : 			else
; 526  : 			{
; 527  : 				iStart = FoundChar(pSrc2,"?Q?");

  000f8	6a 00		 push	 0
  000fa	68 00 00 00 00	 push	 OFFSET ??_C@_03EDFDKGKP@?$DPQ?$DP@
  000ff	8b 45 f4	 mov	 eax, DWORD PTR _pSrc2$[ebp]
  00102	50		 push	 eax
  00103	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  00106	e8 00 00 00 00	 call	 ?FoundChar@CMailCoder@@QAEHPAD0J@Z ; CMailCoder::FoundChar
  0010b	89 45 e4	 mov	 DWORD PTR _iStart$5[ebp], eax

; 528  : 				if ( iStart > 0 )

  0010e	83 7d e4 00	 cmp	 DWORD PTR _iStart$5[ebp], 0
  00112	7e 5b		 jle	 SHORT $LN9@email_deco

; 529  : 				{
; 530  : 					pSrc2=pSrc2+iStart+3; //?B?Ϊ3���ֽ�

  00114	8b 45 e4	 mov	 eax, DWORD PTR _iStart$5[ebp]
  00117	8b 4d f4	 mov	 ecx, DWORD PTR _pSrc2$[ebp]
  0011a	8d 54 01 03	 lea	 edx, DWORD PTR [ecx+eax+3]
  0011e	89 55 f4	 mov	 DWORD PTR _pSrc2$[ebp], edx

; 531  : 					int iEnd = FoundChar(pSrc2,"?=");

  00121	6a 00		 push	 0
  00123	68 00 00 00 00	 push	 OFFSET ??_C@_02EFGBMMPO@?$DP?$DN@
  00128	8b 45 f4	 mov	 eax, DWORD PTR _pSrc2$[ebp]
  0012b	50		 push	 eax
  0012c	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  0012f	e8 00 00 00 00	 call	 ?FoundChar@CMailCoder@@QAEHPAD0J@Z ; CMailCoder::FoundChar
  00134	89 45 d8	 mov	 DWORD PTR _iEnd$2[ebp], eax

; 532  : 					if ( iEnd > 1 )

  00137	83 7d d8 01	 cmp	 DWORD PTR _iEnd$2[ebp], 1
  0013b	7e 30		 jle	 SHORT $LN11@email_deco

; 533  : 					{
; 534  : 						int iRet = quoted_decode(pSrc2,iEnd,pDest+iDestLen);

  0013d	8b 45 10	 mov	 eax, DWORD PTR _pDest$[ebp]
  00140	03 45 ec	 add	 eax, DWORD PTR _iDestLen$[ebp]
  00143	50		 push	 eax
  00144	8b 4d d8	 mov	 ecx, DWORD PTR _iEnd$2[ebp]
  00147	51		 push	 ecx
  00148	8b 55 f4	 mov	 edx, DWORD PTR _pSrc2$[ebp]
  0014b	52		 push	 edx
  0014c	e8 00 00 00 00	 call	 ?quoted_decode@CMailCoder@@SAHPADI0@Z ; CMailCoder::quoted_decode
  00151	83 c4 0c	 add	 esp, 12			; 0000000cH
  00154	89 45 d4	 mov	 DWORD PTR _iRet$1[ebp], eax

; 535  : 						pSrc2 += iEnd+2;  //"?="�������ֽ�

  00157	8b 45 d8	 mov	 eax, DWORD PTR _iEnd$2[ebp]
  0015a	8b 4d f4	 mov	 ecx, DWORD PTR _pSrc2$[ebp]
  0015d	8d 54 01 02	 lea	 edx, DWORD PTR [ecx+eax+2]
  00161	89 55 f4	 mov	 DWORD PTR _pSrc2$[ebp], edx

; 536  : 						iDestLen += iRet;

  00164	8b 45 ec	 mov	 eax, DWORD PTR _iDestLen$[ebp]
  00167	03 45 d4	 add	 eax, DWORD PTR _iRet$1[ebp]
  0016a	89 45 ec	 mov	 DWORD PTR _iDestLen$[ebp], eax
$LN11@email_deco:

; 537  : 					}
; 538  : 				}

  0016d	eb 02		 jmp	 SHORT $LN7@email_deco
$LN9@email_deco:

; 539  : 				else
; 540  : 				{
; 541  : 					break;

  0016f	eb 09		 jmp	 SHORT $LN3@email_deco
$LN7@email_deco:

; 542  : 				}
; 543  : 			}
; 544  : 		}

  00171	eb 02		 jmp	 SHORT $LN5@email_deco
$LN4@email_deco:

; 545  : 		else
; 546  : 		{
; 547  : 			break;

  00173	eb 05		 jmp	 SHORT $LN3@email_deco
$LN5@email_deco:

; 548  : 		}
; 549  : 	}

  00175	e9 ad fe ff ff	 jmp	 $LN2@email_deco
$LN3@email_deco:

; 550  : 	strncpy( pDest+iDestLen,pSrc+(pSrc2-pSrc),nSize-(pSrc2-pSrc) );  //������������

  0017a	8b 45 f4	 mov	 eax, DWORD PTR _pSrc2$[ebp]
  0017d	2b 45 08	 sub	 eax, DWORD PTR _pSrc$[ebp]
  00180	8b 4d 0c	 mov	 ecx, DWORD PTR _nSize$[ebp]
  00183	2b c8		 sub	 ecx, eax
  00185	51		 push	 ecx
  00186	8b 55 f4	 mov	 edx, DWORD PTR _pSrc2$[ebp]
  00189	52		 push	 edx
  0018a	8b 45 10	 mov	 eax, DWORD PTR _pDest$[ebp]
  0018d	03 45 ec	 add	 eax, DWORD PTR _iDestLen$[ebp]
  00190	50		 push	 eax
  00191	e8 00 00 00 00	 call	 _strncpy
  00196	83 c4 0c	 add	 esp, 12			; 0000000cH

; 551  : 
; 552  : 	return nSize;

  00199	8b 45 0c	 mov	 eax, DWORD PTR _nSize$[ebp]

; 553  : }

  0019c	5f		 pop	 edi
  0019d	5e		 pop	 esi
  0019e	5b		 pop	 ebx
  0019f	8b e5		 mov	 esp, ebp
  001a1	5d		 pop	 ebp
  001a2	c2 0c 00	 ret	 12			; 0000000cH
?email_decode@CMailCoder@@QAEHPADI0@Z ENDP		; CMailCoder::email_decode
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?FoundChar@CMailCoder@@QAEHPAD0J@Z
_TEXT	SEGMENT
$T1 = -4632						; size = 4
_i$2 = -4116						; size = 4
_j$ = -4112						; size = 4
_lLen2$ = -4108						; size = 4
_pComp$ = -4104						; size = 4096
_this$ = -8						; size = 4
__$ArrayPad$ = -4					; size = 4
_szSrc$ = 8						; size = 4
_pEx$ = 12						; size = 4
_lLen$ = 16						; size = 4
?FoundChar@CMailCoder@@QAEHPAD0J@Z PROC			; CMailCoder::FoundChar, COMDAT
; _this$ = ecx

; 556  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	b8 18 12 00 00	 mov	 eax, 4632		; 00001218H
  00008	e8 00 00 00 00	 call	 __chkstk
  0000d	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  00012	33 c5		 xor	 eax, ebp
  00014	89 45 fc	 mov	 DWORD PTR __$ArrayPad$[ebp], eax
  00017	53		 push	 ebx
  00018	56		 push	 esi
  00019	57		 push	 edi
  0001a	89 4d f8	 mov	 DWORD PTR _this$[ebp], ecx

; 557  : 	char pComp[4096];
; 558  : 	if ( lLen == 0 ) //���ûָ�����ȣ���ȡԭ�ַ�������

  0001d	83 7d 10 00	 cmp	 DWORD PTR _lLen$[ebp], 0
  00021	75 0f		 jne	 SHORT $LN5@FoundChar

; 559  : 		 lLen = strlen( szSrc );

  00023	8b 45 08	 mov	 eax, DWORD PTR _szSrc$[ebp]
  00026	50		 push	 eax
  00027	e8 00 00 00 00	 call	 _strlen
  0002c	83 c4 04	 add	 esp, 4
  0002f	89 45 10	 mov	 DWORD PTR _lLen$[ebp], eax
$LN5@FoundChar:

; 560  : 	long lLen2= strlen( pEx );

  00032	8b 45 0c	 mov	 eax, DWORD PTR _pEx$[ebp]
  00035	50		 push	 eax
  00036	e8 00 00 00 00	 call	 _strlen
  0003b	83 c4 04	 add	 esp, 4
  0003e	89 85 f4 ef ff
	ff		 mov	 DWORD PTR _lLen2$[ebp], eax

; 561  : 	int  j =0;

  00044	c7 85 f0 ef ff
	ff 00 00 00 00	 mov	 DWORD PTR _j$[ebp], 0

; 562  : 	for ( int i =0 ; i< lLen ; i++ )

  0004e	c7 85 ec ef ff
	ff 00 00 00 00	 mov	 DWORD PTR _i$2[ebp], 0
  00058	eb 0f		 jmp	 SHORT $LN4@FoundChar
$LN2@FoundChar:
  0005a	8b 85 ec ef ff
	ff		 mov	 eax, DWORD PTR _i$2[ebp]
  00060	83 c0 01	 add	 eax, 1
  00063	89 85 ec ef ff
	ff		 mov	 DWORD PTR _i$2[ebp], eax
$LN4@FoundChar:
  00069	8b 85 ec ef ff
	ff		 mov	 eax, DWORD PTR _i$2[ebp]
  0006f	3b 45 10	 cmp	 eax, DWORD PTR _lLen$[ebp]
  00072	7d 71		 jge	 SHORT $LN3@FoundChar

; 563  : 	{
; 564  : 		memcpy( pComp , szSrc+i , lLen2 );

  00074	8b 85 f4 ef ff
	ff		 mov	 eax, DWORD PTR _lLen2$[ebp]
  0007a	50		 push	 eax
  0007b	8b 4d 08	 mov	 ecx, DWORD PTR _szSrc$[ebp]
  0007e	03 8d ec ef ff
	ff		 add	 ecx, DWORD PTR _i$2[ebp]
  00084	51		 push	 ecx
  00085	8d 95 f8 ef ff
	ff		 lea	 edx, DWORD PTR _pComp$[ebp]
  0008b	52		 push	 edx
  0008c	e8 00 00 00 00	 call	 _memcpy
  00091	83 c4 0c	 add	 esp, 12			; 0000000cH

; 565  : 		pComp[lLen2] = 0;

  00094	8b 85 f4 ef ff
	ff		 mov	 eax, DWORD PTR _lLen2$[ebp]
  0009a	89 85 e8 ed ff
	ff		 mov	 DWORD PTR $T1[ebp], eax
  000a0	81 bd e8 ed ff
	ff 00 10 00 00	 cmp	 DWORD PTR $T1[ebp], 4096 ; 00001000H
  000aa	73 02		 jae	 SHORT $LN8@FoundChar
  000ac	eb 05		 jmp	 SHORT $LN9@FoundChar
$LN8@FoundChar:
  000ae	e8 00 00 00 00	 call	 ___report_rangecheckfailure
$LN9@FoundChar:
  000b3	8b 8d e8 ed ff
	ff		 mov	 ecx, DWORD PTR $T1[ebp]
  000b9	c6 84 0d f8 ef
	ff ff 00	 mov	 BYTE PTR _pComp$[ebp+ecx], 0

; 566  : 		if (!strcmp( pComp , pEx ) )

  000c1	8b 45 0c	 mov	 eax, DWORD PTR _pEx$[ebp]
  000c4	50		 push	 eax
  000c5	8d 8d f8 ef ff
	ff		 lea	 ecx, DWORD PTR _pComp$[ebp]
  000cb	51		 push	 ecx
  000cc	e8 00 00 00 00	 call	 _strcmp
  000d1	83 c4 08	 add	 esp, 8
  000d4	85 c0		 test	 eax, eax
  000d6	75 08		 jne	 SHORT $LN6@FoundChar

; 567  : 		{
; 568  : 			return i;

  000d8	8b 85 ec ef ff
	ff		 mov	 eax, DWORD PTR _i$2[ebp]
  000de	eb 08		 jmp	 SHORT $LN7@FoundChar
$LN6@FoundChar:

; 569  : 		}
; 570  : 	}

  000e0	e9 75 ff ff ff	 jmp	 $LN2@FoundChar
$LN3@FoundChar:

; 571  : 	return -1;

  000e5	83 c8 ff	 or	 eax, -1
$LN7@FoundChar:

; 572  : }

  000e8	5f		 pop	 edi
  000e9	5e		 pop	 esi
  000ea	5b		 pop	 ebx
  000eb	8b 4d fc	 mov	 ecx, DWORD PTR __$ArrayPad$[ebp]
  000ee	33 cd		 xor	 ecx, ebp
  000f0	e8 00 00 00 00	 call	 @__security_check_cookie@4
  000f5	8b e5		 mov	 esp, ebp
  000f7	5d		 pop	 ebp
  000f8	c2 0c 00	 ret	 12			; 0000000cH
?FoundChar@CMailCoder@@QAEHPAD0J@Z ENDP			; CMailCoder::FoundChar
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?HexToDec@CMailCoder@@CAEE@Z
_TEXT	SEGMENT
tv71 = -68						; size = 4
_C$ = 8							; size = 1
?HexToDec@CMailCoder@@CAEE@Z PROC			; CMailCoder::HexToDec, COMDAT

; 491  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 44	 sub	 esp, 68			; 00000044H
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi

; 492  : 	return C <= '9' ? C - '0' : C - 'A' + 10;

  00009	0f b6 45 08	 movzx	 eax, BYTE PTR _C$[ebp]
  0000d	83 f8 39	 cmp	 eax, 57			; 00000039H
  00010	7f 0c		 jg	 SHORT $LN3@HexToDec
  00012	0f b6 4d 08	 movzx	 ecx, BYTE PTR _C$[ebp]
  00016	83 e9 30	 sub	 ecx, 48			; 00000030H
  00019	89 4d bc	 mov	 DWORD PTR tv71[ebp], ecx
  0001c	eb 0a		 jmp	 SHORT $LN4@HexToDec
$LN3@HexToDec:
  0001e	0f b6 55 08	 movzx	 edx, BYTE PTR _C$[ebp]
  00022	83 ea 37	 sub	 edx, 55			; 00000037H
  00025	89 55 bc	 mov	 DWORD PTR tv71[ebp], edx
$LN4@HexToDec:
  00028	8a 45 bc	 mov	 al, BYTE PTR tv71[ebp]

; 493  : }

  0002b	5f		 pop	 edi
  0002c	5e		 pop	 esi
  0002d	5b		 pop	 ebx
  0002e	8b e5		 mov	 esp, ebp
  00030	5d		 pop	 ebp
  00031	c3		 ret	 0
?HexToDec@CMailCoder@@CAEE@Z ENDP			; CMailCoder::HexToDec
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?DecToHex@CMailCoder@@CAEE@Z
_TEXT	SEGMENT
tv71 = -68						; size = 4
_B$ = 8							; size = 1
?DecToHex@CMailCoder@@CAEE@Z PROC			; CMailCoder::DecToHex, COMDAT

; 483  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 44	 sub	 esp, 68			; 00000044H
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi

; 484  : 	return B < 10 ? '0' + B:'A' + B - 10;

  00009	0f b6 45 08	 movzx	 eax, BYTE PTR _B$[ebp]
  0000d	83 f8 0a	 cmp	 eax, 10			; 0000000aH
  00010	7d 0c		 jge	 SHORT $LN3@DecToHex
  00012	0f b6 4d 08	 movzx	 ecx, BYTE PTR _B$[ebp]
  00016	83 c1 30	 add	 ecx, 48			; 00000030H
  00019	89 4d bc	 mov	 DWORD PTR tv71[ebp], ecx
  0001c	eb 0a		 jmp	 SHORT $LN4@DecToHex
$LN3@DecToHex:
  0001e	0f b6 55 08	 movzx	 edx, BYTE PTR _B$[ebp]
  00022	83 c2 37	 add	 edx, 55			; 00000037H
  00025	89 55 bc	 mov	 DWORD PTR tv71[ebp], edx
$LN4@DecToHex:
  00028	8a 45 bc	 mov	 al, BYTE PTR tv71[ebp]

; 485  : }

  0002b	5f		 pop	 edi
  0002c	5e		 pop	 esi
  0002d	5b		 pop	 ebx
  0002e	8b e5		 mov	 esp, ebp
  00030	5d		 pop	 ebp
  00031	c3		 ret	 0
?DecToHex@CMailCoder@@CAEE@Z ENDP			; CMailCoder::DecToHex
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?__empty_global_delete@@YAXPAXIW4align_val_t@std@@@Z
_TEXT	SEGMENT
___formal$ = 8						; size = 4
___formal$ = 12						; size = 4
___formal$ = 16						; size = 4
?__empty_global_delete@@YAXPAXIW4align_val_t@std@@@Z PROC ; __empty_global_delete, COMDAT

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 40	 sub	 esp, 64			; 00000040H
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi
  00009	5f		 pop	 edi
  0000a	5e		 pop	 esi
  0000b	5b		 pop	 ebx
  0000c	8b e5		 mov	 esp, ebp
  0000e	5d		 pop	 ebp
  0000f	c3		 ret	 0
?__empty_global_delete@@YAXPAXIW4align_val_t@std@@@Z ENDP ; __empty_global_delete
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?__empty_global_delete@@YAXPAXW4align_val_t@std@@@Z
_TEXT	SEGMENT
___formal$ = 8						; size = 4
___formal$ = 12						; size = 4
?__empty_global_delete@@YAXPAXW4align_val_t@std@@@Z PROC ; __empty_global_delete, COMDAT

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 40	 sub	 esp, 64			; 00000040H
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi
  00009	5f		 pop	 edi
  0000a	5e		 pop	 esi
  0000b	5b		 pop	 ebx
  0000c	8b e5		 mov	 esp, ebp
  0000e	5d		 pop	 ebp
  0000f	c3		 ret	 0
?__empty_global_delete@@YAXPAXW4align_val_t@std@@@Z ENDP ; __empty_global_delete
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?__empty_global_delete@@YAXPAXI@Z
_TEXT	SEGMENT
___formal$ = 8						; size = 4
___formal$ = 12						; size = 4
?__empty_global_delete@@YAXPAXI@Z PROC			; __empty_global_delete, COMDAT

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 40	 sub	 esp, 64			; 00000040H
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi
  00009	5f		 pop	 edi
  0000a	5e		 pop	 esi
  0000b	5b		 pop	 ebx
  0000c	8b e5		 mov	 esp, ebp
  0000e	5d		 pop	 ebp
  0000f	c3		 ret	 0
?__empty_global_delete@@YAXPAXI@Z ENDP			; __empty_global_delete
_TEXT	ENDS
; Function compile flags: /Odtp /ZI
; File D:\Works\Corpsms_2010\public\Pop3\MailCoder.cpp
;	COMDAT ?__empty_global_delete@@YAXPAX@Z
_TEXT	SEGMENT
___formal$ = 8						; size = 4
?__empty_global_delete@@YAXPAX@Z PROC			; __empty_global_delete, COMDAT

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 40	 sub	 esp, 64			; 00000040H
  00006	53		 push	 ebx
  00007	56		 push	 esi
  00008	57		 push	 edi
  00009	5f		 pop	 edi
  0000a	5e		 pop	 esi
  0000b	5b		 pop	 ebx
  0000c	8b e5		 mov	 esp, ebp
  0000e	5d		 pop	 ebp
  0000f	c3		 ret	 0
?__empty_global_delete@@YAXPAX@Z ENDP			; __empty_global_delete
_TEXT	ENDS
END