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

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

INCLUDELIB OLDNAMES

PUBLIC	?m_DecodeTable@CVTCommon@@0PAEA			; CVTCommon::m_DecodeTable
PUBLIC	?m_DecodeTableInitialized@CVTCommon@@0HA	; CVTCommon::m_DecodeTableInitialized
PUBLIC	?m_RegionCodepage@CVTCommon@@0PAY07W4eVTCodepage@@A ; CVTCommon::m_RegionCodepage
?m_DecodeTable@CVTCommon@@0PAEA DB 0100H DUP (?)	; CVTCommon::m_DecodeTable
?m_DecodeTableInitialized@CVTCommon@@0HA DD 01H DUP (?)	; CVTCommon::m_DecodeTableInitialized
?m_RegionCodepage@CVTCommon@@0PAY07W4eVTCodepage@@A DD 00H ; CVTCommon::m_RegionCodepage
	DD	01H
	DD	02H
	DD	03H
	DD	04H
	DD	05H
	DD	06H
	DD	0ffffffffH
	DD	07H
	DD	0fffffffeH
	DD	0fffffffeH
	DD	0fffffffeH
	DD	0fffffffeH
	DD	0ffffffffH
	DD	0fffffffeH
	DD	0ffffffffH
	DD	0fffffffeH
	DD	0fffffffeH
	DD	0fffffffeH
	DD	08H
	DD	0fffffffeH
	DD	0fffffffeH
	DD	0fffffffeH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	09H
	DD	0ffffffffH
	DD	0aH
	DD	0bH
	DD	0cH
	DD	0dH
	DD	0fffffffeH
	DD	0fffffffeH
	DD	0eH
	DD	0fH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	08H
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	010H
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	011H
	DD	012H
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	013H
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	0ffffffffH
	DD	014H
	DD	0ffffffffH
	DD	013H
PUBLIC	?HasFlashElementProc@CVTCommon@@CAEPAU_VTPage@@GPAGGEEPAX@Z ; CVTCommon::HasFlashElementProc
; Function compile flags: /Odtp
; File c:\develop\dscaler423a\dscaler\vtcommon.cpp
;	COMDAT ?HasFlashElementProc@CVTCommon@@CAEPAU_VTPage@@GPAGGEEPAX@Z
_TEXT	SEGMENT
___formal$ = 8						; size = 4
___formal$ = 12						; size = 2
_lpFlags$ = 16						; size = 4
___formal$ = 20						; size = 2
_uChar$ = 24						; size = 1
_uMode$ = 28						; size = 1
___formal$ = 32						; size = 4
?HasFlashElementProc@CVTCommon@@CAEPAU_VTPage@@GPAGGEEPAX@Z PROC ; CVTCommon::HasFlashElementProc, COMDAT

; 892  : {

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

; 893  :     if ((uMode & VTMODE_FLASH) != 0)

  00003	0f b6 45 1c	 movzx	 eax, BYTE PTR _uMode$[ebp]
  00007	83 e0 04	 and	 eax, 4
  0000a	74 0d		 je	 SHORT $LN2@HasFlashEl

; 894  :     {
; 895  :         if (uChar > 0x20)

  0000c	0f b6 4d 18	 movzx	 ecx, BYTE PTR _uChar$[ebp]
  00010	83 f9 20	 cmp	 ecx, 32			; 00000020H
  00013	7e 04		 jle	 SHORT $LN2@HasFlashEl

; 896  :         {
; 897  :             return PARSE_STOPPAGE;

  00015	b0 02		 mov	 al, 2
  00017	eb 02		 jmp	 SHORT $LN3@HasFlashEl
$LN2@HasFlashEl:

; 898  :         }
; 899  :     }
; 900  :     return PARSE_CONTINUE;

  00019	32 c0		 xor	 al, al
$LN3@HasFlashEl:

; 901  : }

  0001b	5d		 pop	 ebp
  0001c	c3		 ret	 0
?HasFlashElementProc@CVTCommon@@CAEPAU_VTPage@@GPAGGEEPAX@Z ENDP ; CVTCommon::HasFlashElementProc
_TEXT	ENDS
PUBLIC	?ParseEmptyLine@CVTCommon@@CAEPAU_VTPage@@EPAGP6AE0G1GEEPAX@Z2@Z ; CVTCommon::ParseEmptyLine
; Function compile flags: /Odtp
;	COMDAT ?ParseEmptyLine@CVTCommon@@CAEPAU_VTPage@@EPAGP6AE0G1GEEPAX@Z2@Z
_TEXT	SEGMENT
_nCol$139915 = -9					; size = 1
_wColour$ = -8						; size = 2
_uResult$ = -4						; size = 4
_pPage$ = 8						; size = 4
_nRow$ = 12						; size = 1
_lpFlags$ = 16						; size = 4
_fnParseProc$ = 20					; size = 4
_lpParam$ = 24						; size = 4
?ParseEmptyLine@CVTCommon@@CAEPAU_VTPage@@EPAGP6AE0G1GEEPAX@Z2@Z PROC ; CVTCommon::ParseEmptyLine, COMDAT

; 861  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 0c	 sub	 esp, 12			; 0000000cH

; 862  :     LONG uResult = PARSE_CONTINUE;

  00006	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR _uResult$[ebp], 0

; 863  : 
; 864  :     WORD wColour = MAKEWORD(VTCOLOR_WHITE, VTCOLOR_BLACK);

  0000d	b8 07 00 00 00	 mov	 eax, 7
  00012	66 89 45 f8	 mov	 WORD PTR _wColour$[ebp], ax

; 865  : 
; 866  :     if ((pPage->wControlBits & VTCONTROL_NEWSFLASH) != 0 ||
; 867  :         (pPage->wControlBits & VTCONTROL_SUBTITLE) != 0)

  00016	8b 4d 08	 mov	 ecx, DWORD PTR _pPage$[ebp]
  00019	0f b7 51 04	 movzx	 edx, WORD PTR [ecx+4]
  0001d	83 e2 10	 and	 edx, 16			; 00000010H
  00020	75 0c		 jne	 SHORT $LN8@ParseEmpty
  00022	8b 45 08	 mov	 eax, DWORD PTR _pPage$[ebp]
  00025	0f b7 48 04	 movzx	 ecx, WORD PTR [eax+4]
  00029	83 e1 20	 and	 ecx, 32			; 00000020H
  0002c	74 1c		 je	 SHORT $LN9@ParseEmpty
$LN8@ParseEmpty:

; 868  :     {
; 869  :         if (nRow != 0 || (*lpFlags & PARSE_FORCEHEADER) == 0)

  0002e	0f b6 55 0c	 movzx	 edx, BYTE PTR _nRow$[ebp]
  00032	85 d2		 test	 edx, edx
  00034	75 0b		 jne	 SHORT $LN6@ParseEmpty
  00036	8b 45 10	 mov	 eax, DWORD PTR _lpFlags$[ebp]
  00039	0f b7 08	 movzx	 ecx, WORD PTR [eax]
  0003c	83 e1 04	 and	 ecx, 4
  0003f	75 09		 jne	 SHORT $LN9@ParseEmpty
$LN6@ParseEmpty:

; 870  :         {
; 871  :             wColour = MAKEWORD(VTCOLOR_WHITE, VTCOLOR_NONE);

  00041	ba 07 08 00 00	 mov	 edx, 2055		; 00000807H
  00046	66 89 55 f8	 mov	 WORD PTR _wColour$[ebp], dx
$LN9@ParseEmpty:

; 872  :         }
; 873  :     }
; 874  : 
; 875  :     for(BYTE nCol = 0; nCol < 40; nCol++)

  0004a	c6 45 f7 00	 mov	 BYTE PTR _nCol$139915[ebp], 0
  0004e	eb 08		 jmp	 SHORT $LN5@ParseEmpty
$LN4@ParseEmpty:
  00050	8a 45 f7	 mov	 al, BYTE PTR _nCol$139915[ebp]
  00053	04 01		 add	 al, 1
  00055	88 45 f7	 mov	 BYTE PTR _nCol$139915[ebp], al
$LN5@ParseEmpty:
  00058	0f b6 4d f7	 movzx	 ecx, BYTE PTR _nCol$139915[ebp]
  0005c	83 f9 28	 cmp	 ecx, 40			; 00000028H
  0005f	7d 51		 jge	 SHORT $LN3@ParseEmpty

; 876  :     {
; 877  :         uResult = (fnParseProc)(pPage, MAKEWORD(nRow, nCol), lpFlags,
; 878  :                                 wColour, 0x20, 0x00, lpParam);

  00061	8b 55 18	 mov	 edx, DWORD PTR _lpParam$[ebp]
  00064	52		 push	 edx
  00065	6a 00		 push	 0
  00067	6a 20		 push	 32			; 00000020H
  00069	0f b7 45 f8	 movzx	 eax, WORD PTR _wColour$[ebp]
  0006d	50		 push	 eax
  0006e	8b 4d 10	 mov	 ecx, DWORD PTR _lpFlags$[ebp]
  00071	51		 push	 ecx
  00072	0f b6 55 0c	 movzx	 edx, BYTE PTR _nRow$[ebp]
  00076	81 e2 ff 00 00
	00		 and	 edx, 255		; 000000ffH
  0007c	0f b6 c2	 movzx	 eax, dl
  0007f	0f b6 4d f7	 movzx	 ecx, BYTE PTR _nCol$139915[ebp]
  00083	81 e1 ff 00 00
	00		 and	 ecx, 255		; 000000ffH
  00089	0f b6 d1	 movzx	 edx, cl
  0008c	c1 e2 08	 shl	 edx, 8
  0008f	0b c2		 or	 eax, edx
  00091	50		 push	 eax
  00092	8b 45 08	 mov	 eax, DWORD PTR _pPage$[ebp]
  00095	50		 push	 eax
  00096	ff 55 14	 call	 DWORD PTR _fnParseProc$[ebp]
  00099	83 c4 1c	 add	 esp, 28			; 0000001cH
  0009c	0f b6 c8	 movzx	 ecx, al
  0009f	89 4d fc	 mov	 DWORD PTR _uResult$[ebp], ecx

; 879  : 
; 880  :         if (uResult == PARSE_STOPLINE || uResult == PARSE_STOPPAGE)

  000a2	83 7d fc 01	 cmp	 DWORD PTR _uResult$[ebp], 1
  000a6	74 06		 je	 SHORT $LN1@ParseEmpty
  000a8	83 7d fc 02	 cmp	 DWORD PTR _uResult$[ebp], 2
  000ac	75 02		 jne	 SHORT $LN2@ParseEmpty
$LN1@ParseEmpty:

; 881  :         {
; 882  :             break;

  000ae	eb 02		 jmp	 SHORT $LN3@ParseEmpty
$LN2@ParseEmpty:

; 883  :         }
; 884  :     }

  000b0	eb 9e		 jmp	 SHORT $LN4@ParseEmpty
$LN3@ParseEmpty:

; 885  : 
; 886  :     return (BYTE)uResult;

  000b2	8a 45 fc	 mov	 al, BYTE PTR _uResult$[ebp]

; 887  : }

  000b5	8b e5		 mov	 esp, ebp
  000b7	5d		 pop	 ebp
  000b8	c3		 ret	 0
?ParseEmptyLine@CVTCommon@@CAEPAU_VTPage@@EPAGP6AE0G1GEEPAX@Z2@Z ENDP ; CVTCommon::ParseEmptyLine
_TEXT	ENDS
PUBLIC	?CheckLineParsable@CVTCommon@@CAEPAU_VTPage@@EPAG@Z ; CVTCommon::CheckLineParsable
; Function compile flags: /Odtp
;	COMDAT ?CheckLineParsable@CVTCommon@@CAEPAU_VTPage@@EPAG@Z
_TEXT	SEGMENT
_uCheckResult$ = -1					; size = 1
_pPage$ = 8						; size = 4
_nRow$ = 12						; size = 1
_lpFlags$ = 16						; size = 4
?CheckLineParsable@CVTCommon@@CAEPAU_VTPage@@EPAG@Z PROC ; CVTCommon::CheckLineParsable, COMDAT

; 783  : {

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

; 784  :     if ((*lpFlags & PARSE_EMPTYLINE) != 0)

  00004	8b 45 10	 mov	 eax, DWORD PTR _lpFlags$[ebp]
  00007	0f b7 08	 movzx	 ecx, WORD PTR [eax]
  0000a	81 e1 80 00 00
	00		 and	 ecx, 128		; 00000080H
  00010	74 07		 je	 SHORT $LN19@CheckLineP

; 785  :     {
; 786  :         return PARSE_NODATA;

  00012	b0 03		 mov	 al, 3
  00014	e9 f5 00 00 00	 jmp	 $LN20@CheckLineP
$LN19@CheckLineP:

; 787  :     }
; 788  : 
; 789  :     if (nRow == 0 && (*lpFlags & PARSE_FORCEHEADER) != 0)

  00019	0f b6 55 0c	 movzx	 edx, BYTE PTR _nRow$[ebp]
  0001d	85 d2		 test	 edx, edx
  0001f	75 26		 jne	 SHORT $LN18@CheckLineP
  00021	8b 45 10	 mov	 eax, DWORD PTR _lpFlags$[ebp]
  00024	0f b7 08	 movzx	 ecx, WORD PTR [eax]
  00027	83 e1 04	 and	 ecx, 4
  0002a	74 1b		 je	 SHORT $LN18@CheckLineP

; 790  :     {
; 791  :         if ((pPage->LineState[nRow] & CACHESTATE_HASDATA) != 0)

  0002c	0f b6 55 0c	 movzx	 edx, BYTE PTR _nRow$[ebp]
  00030	8b 45 08	 mov	 eax, DWORD PTR _pPage$[ebp]
  00033	0f b6 8c 10 16
	04 00 00	 movzx	 ecx, BYTE PTR [eax+edx+1046]
  0003b	83 e1 01	 and	 ecx, 1
  0003e	74 07		 je	 SHORT $LN18@CheckLineP

; 792  :         {
; 793  :             return PARSE_CONTINUE;

  00040	32 c0		 xor	 al, al
  00042	e9 c7 00 00 00	 jmp	 $LN20@CheckLineP
$LN18@CheckLineP:

; 794  :         }
; 795  :     }
; 796  : 
; 797  :     // Check if the caller wants updated rows only
; 798  :     if ((*lpFlags & PARSE_UPDATEDONLY) != 0)

  00047	8b 55 10	 mov	 edx, DWORD PTR _lpFlags$[ebp]
  0004a	0f b7 02	 movzx	 eax, WORD PTR [edx]
  0004d	83 e0 02	 and	 eax, 2
  00050	74 1b		 je	 SHORT $LN16@CheckLineP

; 799  :     {
; 800  :         if ((pPage->LineState[nRow] & CACHESTATE_UPDATED) == 0)

  00052	0f b6 4d 0c	 movzx	 ecx, BYTE PTR _nRow$[ebp]
  00056	8b 55 08	 mov	 edx, DWORD PTR _pPage$[ebp]
  00059	0f b6 84 0a 16
	04 00 00	 movzx	 eax, BYTE PTR [edx+ecx+1046]
  00061	83 e0 02	 and	 eax, 2
  00064	75 07		 jne	 SHORT $LN16@CheckLineP

; 801  :         {
; 802  :             return PARSE_NOTUPDATED;

  00066	b0 08		 mov	 al, 8
  00068	e9 a1 00 00 00	 jmp	 $LN20@CheckLineP
$LN16@CheckLineP:

; 803  :         }
; 804  :     }
; 805  : 
; 806  :     BYTE uCheckResult = PARSE_CONTINUE;

  0006d	c6 45 ff 00	 mov	 BYTE PTR _uCheckResult$[ebp], 0

; 807  : 
; 808  :     // If this row has no data
; 809  :     if ((pPage->LineState[nRow] & CACHESTATE_HASDATA) == 0)

  00071	0f b6 4d 0c	 movzx	 ecx, BYTE PTR _nRow$[ebp]
  00075	8b 55 08	 mov	 edx, DWORD PTR _pPage$[ebp]
  00078	0f b6 84 0a 16
	04 00 00	 movzx	 eax, BYTE PTR [edx+ecx+1046]
  00080	83 e0 01	 and	 eax, 1
  00083	75 06		 jne	 SHORT $LN14@CheckLineP

; 810  :     {
; 811  :         uCheckResult = PARSE_NODATA;

  00085	c6 45 ff 03	 mov	 BYTE PTR _uCheckResult$[ebp], 3
  00089	eb 62		 jmp	 SHORT $LN13@CheckLineP
$LN14@CheckLineP:

; 812  :     }
; 813  :     // If this row has data and is the header row
; 814  :     else if (nRow == 0)

  0008b	0f b6 4d 0c	 movzx	 ecx, BYTE PTR _nRow$[ebp]
  0008f	85 c9		 test	 ecx, ecx
  00091	75 12		 jne	 SHORT $LN12@CheckLineP

; 815  :     {
; 816  :         if ((pPage->wControlBits & VTCONTROL_SUPRESSHEADER) != 0)

  00093	8b 55 08	 mov	 edx, DWORD PTR _pPage$[ebp]
  00096	0f b7 42 04	 movzx	 eax, WORD PTR [edx+4]
  0009a	83 e0 40	 and	 eax, 64			; 00000040H
  0009d	74 04		 je	 SHORT $LN11@CheckLineP

; 817  :         {
; 818  :             uCheckResult = PARSE_SUPPRESSHEADER;

  0009f	c6 45 ff 04	 mov	 BYTE PTR _uCheckResult$[ebp], 4
$LN11@CheckLineP:

; 819  :         }
; 820  :     }

  000a3	eb 48		 jmp	 SHORT $LN13@CheckLineP
$LN12@CheckLineP:

; 821  :     // If this row has data and is the commentary row
; 822  :     else if (nRow == 24)

  000a5	0f b6 4d 0c	 movzx	 ecx, BYTE PTR _nRow$[ebp]
  000a9	83 f9 18	 cmp	 ecx, 24			; 00000018H
  000ac	75 12		 jne	 SHORT $LN9@CheckLineP

; 823  :     {
; 824  :         if (pPage->bShowRow24 == FALSE)

  000ae	8b 55 08	 mov	 edx, DWORD PTR _pPage$[ebp]
  000b1	83 ba 50 04 00
	00 00		 cmp	 DWORD PTR [edx+1104], 0
  000b8	75 04		 jne	 SHORT $LN8@CheckLineP

; 825  :         {
; 826  :             uCheckResult = PARSE_ROW24HIDDEN;

  000ba	c6 45 ff 06	 mov	 BYTE PTR _uCheckResult$[ebp], 6
$LN8@CheckLineP:

; 827  :         }
; 828  :     }

  000be	eb 2d		 jmp	 SHORT $LN13@CheckLineP
$LN9@CheckLineP:

; 829  :     // If this row has data and is the keywords row
; 830  :     else if (nRow == 25)

  000c0	0f b6 45 0c	 movzx	 eax, BYTE PTR _nRow$[ebp]
  000c4	83 f8 19	 cmp	 eax, 25			; 00000019H
  000c7	75 11		 jne	 SHORT $LN6@CheckLineP

; 831  :     {
; 832  :         if ((*lpFlags & PARSE_ALSOKEYWORDS) == 0)

  000c9	8b 4d 10	 mov	 ecx, DWORD PTR _lpFlags$[ebp]
  000cc	0f b7 11	 movzx	 edx, WORD PTR [ecx]
  000cf	83 e2 10	 and	 edx, 16			; 00000010H
  000d2	75 04		 jne	 SHORT $LN5@CheckLineP

; 833  :         {
; 834  :             // Has data only flag doesn't affect his row
; 835  :             return PARSE_SKIPKEYWORDS;

  000d4	b0 07		 mov	 al, 7
  000d6	eb 36		 jmp	 SHORT $LN20@CheckLineP
$LN5@CheckLineP:

; 836  :         }
; 837  :     }
; 838  :     // For all other rows
; 839  :     else

  000d8	eb 13		 jmp	 SHORT $LN13@CheckLineP
$LN6@CheckLineP:

; 840  :     {
; 841  :         if ((pPage->wControlBits & VTCONTROL_INHIBITDISP) != 0)

  000da	8b 45 08	 mov	 eax, DWORD PTR _pPage$[ebp]
  000dd	0f b7 48 04	 movzx	 ecx, WORD PTR [eax+4]
  000e1	81 e1 00 02 00
	00		 and	 ecx, 512		; 00000200H
  000e7	74 04		 je	 SHORT $LN13@CheckLineP

; 842  :         {
; 843  :             uCheckResult = PARSE_INHIBITDISP;

  000e9	c6 45 ff 05	 mov	 BYTE PTR _uCheckResult$[ebp], 5
$LN13@CheckLineP:

; 844  :         }
; 845  :     }
; 846  : 
; 847  :     if (uCheckResult != PARSE_CONTINUE)

  000ed	0f b6 55 ff	 movzx	 edx, BYTE PTR _uCheckResult$[ebp]
  000f1	85 d2		 test	 edx, edx
  000f3	74 16		 je	 SHORT $LN2@CheckLineP

; 848  :     {
; 849  :         if ((*lpFlags & PARSE_HASDATAONLY) == 0)

  000f5	8b 45 10	 mov	 eax, DWORD PTR _lpFlags$[ebp]
  000f8	0f b7 08	 movzx	 ecx, WORD PTR [eax]
  000fb	83 e1 01	 and	 ecx, 1
  000fe	75 0b		 jne	 SHORT $LN2@CheckLineP

; 850  :         {
; 851  :             *lpFlags = PARSE_EMPTYLINE;

  00100	ba 80 00 00 00	 mov	 edx, 128		; 00000080H
  00105	8b 45 10	 mov	 eax, DWORD PTR _lpFlags$[ebp]
  00108	66 89 10	 mov	 WORD PTR [eax], dx
$LN2@CheckLineP:

; 852  :         }
; 853  :     }
; 854  : 
; 855  :     return uCheckResult;

  0010b	8a 45 ff	 mov	 al, BYTE PTR _uCheckResult$[ebp]
$LN20@CheckLineP:

; 856  : }

  0010e	8b e5		 mov	 esp, ebp
  00110	5d		 pop	 ebp
  00111	c3		 ret	 0
?CheckLineParsable@CVTCommon@@CAEPAU_VTPage@@EPAG@Z ENDP ; CVTCommon::CheckLineParsable
_TEXT	ENDS
PUBLIC	?GetRegionCodepage@CVTCommon@@SA?AW4eVTCodepage@@W4eVTRegion@@EH@Z ; CVTCommon::GetRegionCodepage
; Function compile flags: /Odtp
;	COMDAT ?GetRegionCodepage@CVTCommon@@SA?AW4eVTCodepage@@W4eVTRegion@@EH@Z
_TEXT	SEGMENT
_i$139736 = -8						; size = 4
_Codepage$ = -4						; size = 4
_VTRegion$ = 8						; size = 4
_uCharacterSubsetCode$ = 12				; size = 1
_bCorrectMissing$ = 16					; size = 4
?GetRegionCodepage@CVTCommon@@SA?AW4eVTCodepage@@W4eVTRegion@@EH@Z PROC ; CVTCommon::GetRegionCodepage, COMDAT

; 350  : {

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

; 351  :     if (uCharacterSubsetCode > 0x07)

  00006	0f b6 45 0c	 movzx	 eax, BYTE PTR _uCharacterSubsetCode$[ebp]
  0000a	83 f8 07	 cmp	 eax, 7
  0000d	7e 04		 jle	 SHORT $LN7@GetRegionC

; 352  :     {
; 353  :         return VTCODEPAGE_ENGLISH;

  0000f	33 c0		 xor	 eax, eax
  00011	eb 73		 jmp	 SHORT $LN8@GetRegionC
$LN7@GetRegionC:

; 354  :     }
; 355  : 
; 356  :     eVTCodepage Codepage = m_RegionCodepage[VTRegion][uCharacterSubsetCode];

  00013	8b 4d 08	 mov	 ecx, DWORD PTR _VTRegion$[ebp]
  00016	c1 e1 05	 shl	 ecx, 5
  00019	0f b6 55 0c	 movzx	 edx, BYTE PTR _uCharacterSubsetCode$[ebp]
  0001d	8b 84 91 00 00
	00 00		 mov	 eax, DWORD PTR ?m_RegionCodepage@CVTCommon@@0PAY07W4eVTCodepage@@A[ecx+edx*4]
  00024	89 45 fc	 mov	 DWORD PTR _Codepage$[ebp], eax

; 357  : 
; 358  :     // Same indicates it's the same as the first
; 359  :     if (Codepage == VTCODEPAGE_SAME)

  00027	83 7d fc fe	 cmp	 DWORD PTR _Codepage$[ebp], -2 ; fffffffeH
  0002b	75 0e		 jne	 SHORT $LN6@GetRegionC

; 360  :     {
; 361  :         Codepage = m_RegionCodepage[VTREGION_DEFAULT][uCharacterSubsetCode];

  0002d	0f b6 4d 0c	 movzx	 ecx, BYTE PTR _uCharacterSubsetCode$[ebp]
  00031	8b 14 8d 00 00
	00 00		 mov	 edx, DWORD PTR ?m_RegionCodepage@CVTCommon@@0PAY07W4eVTCodepage@@A[ecx*4]
  00038	89 55 fc	 mov	 DWORD PTR _Codepage$[ebp], edx
$LN6@GetRegionC:

; 362  :     }
; 363  : 
; 364  :     // If it's none, the region is wrong.  Pick the
; 365  :     // first valid one we come accross
; 366  :     if (bCorrectMissing != FALSE && Codepage == VTCODEPAGE_NONE)

  0003b	83 7d 10 00	 cmp	 DWORD PTR _bCorrectMissing$[ebp], 0
  0003f	74 42		 je	 SHORT $LN5@GetRegionC
  00041	83 7d fc ff	 cmp	 DWORD PTR _Codepage$[ebp], -1
  00045	75 3c		 jne	 SHORT $LN5@GetRegionC

; 367  :     {
; 368  :         for (int i = VTREGION_DEFAULT; i < VTREGION_LASTONE; i++)

  00047	c7 45 f8 00 00
	00 00		 mov	 DWORD PTR _i$139736[ebp], 0
  0004e	eb 09		 jmp	 SHORT $LN4@GetRegionC
$LN3@GetRegionC:
  00050	8b 45 f8	 mov	 eax, DWORD PTR _i$139736[ebp]
  00053	83 c0 01	 add	 eax, 1
  00056	89 45 f8	 mov	 DWORD PTR _i$139736[ebp], eax
$LN4@GetRegionC:
  00059	83 7d f8 0b	 cmp	 DWORD PTR _i$139736[ebp], 11 ; 0000000bH
  0005d	7d 24		 jge	 SHORT $LN5@GetRegionC

; 369  :         {
; 370  :             Codepage = m_RegionCodepage[i][uCharacterSubsetCode];

  0005f	8b 4d f8	 mov	 ecx, DWORD PTR _i$139736[ebp]
  00062	c1 e1 05	 shl	 ecx, 5
  00065	0f b6 55 0c	 movzx	 edx, BYTE PTR _uCharacterSubsetCode$[ebp]
  00069	8b 84 91 00 00
	00 00		 mov	 eax, DWORD PTR ?m_RegionCodepage@CVTCommon@@0PAY07W4eVTCodepage@@A[ecx+edx*4]
  00070	89 45 fc	 mov	 DWORD PTR _Codepage$[ebp], eax

; 371  : 
; 372  :             if (Codepage != VTCODEPAGE_NONE &&
; 373  :                 Codepage != VTCODEPAGE_SAME)

  00073	83 7d fc ff	 cmp	 DWORD PTR _Codepage$[ebp], -1
  00077	74 08		 je	 SHORT $LN1@GetRegionC
  00079	83 7d fc fe	 cmp	 DWORD PTR _Codepage$[ebp], -2 ; fffffffeH
  0007d	74 02		 je	 SHORT $LN1@GetRegionC

; 374  :             {
; 375  :                 break;

  0007f	eb 02		 jmp	 SHORT $LN5@GetRegionC
$LN1@GetRegionC:

; 376  :             }
; 377  :         }

  00081	eb cd		 jmp	 SHORT $LN3@GetRegionC
$LN5@GetRegionC:

; 378  :     }
; 379  : 
; 380  :     return Codepage;

  00083	8b 45 fc	 mov	 eax, DWORD PTR _Codepage$[ebp]
$LN8@GetRegionC:

; 381  : }

  00086	8b e5		 mov	 esp, ebp
  00088	5d		 pop	 ebp
  00089	c3		 ret	 0
?GetRegionCodepage@CVTCommon@@SA?AW4eVTCodepage@@W4eVTRegion@@EH@Z ENDP ; CVTCommon::GetRegionCodepage
_TEXT	ENDS
PUBLIC	?HasDoubleElement@CVTCommon@@SAHPAU_VTPage@@E@Z	; CVTCommon::HasDoubleElement
; Function compile flags: /Odtp
;	COMDAT ?HasDoubleElement@CVTCommon@@SAHPAU_VTPage@@E@Z
_TEXT	SEGMENT
_nCol$139717 = -1					; size = 1
_pPage$ = 8						; size = 4
_nRow$ = 12						; size = 1
?HasDoubleElement@CVTCommon@@SAHPAU_VTPage@@E@Z PROC	; CVTCommon::HasDoubleElement, COMDAT

; 321  : {

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

; 322  :     if ((pPage->LineState[nRow] & CACHESTATE_HASDATA) == 0)

  00004	0f b6 45 0c	 movzx	 eax, BYTE PTR _nRow$[ebp]
  00008	8b 4d 08	 mov	 ecx, DWORD PTR _pPage$[ebp]
  0000b	0f b6 94 01 16
	04 00 00	 movzx	 edx, BYTE PTR [ecx+eax+1046]
  00013	83 e2 01	 and	 edx, 1
  00016	75 04		 jne	 SHORT $LN5@HasDoubleE

; 323  :     {
; 324  :         return FALSE;

  00018	33 c0		 xor	 eax, eax
  0001a	eb 40		 jmp	 SHORT $LN6@HasDoubleE
$LN5@HasDoubleE:

; 325  :     }
; 326  : 
; 327  :     for (BYTE nCol = 0; nCol < 40; nCol++)

  0001c	c6 45 ff 00	 mov	 BYTE PTR _nCol$139717[ebp], 0
  00020	eb 08		 jmp	 SHORT $LN4@HasDoubleE
$LN3@HasDoubleE:
  00022	8a 45 ff	 mov	 al, BYTE PTR _nCol$139717[ebp]
  00025	04 01		 add	 al, 1
  00027	88 45 ff	 mov	 BYTE PTR _nCol$139717[ebp], al
$LN4@HasDoubleE:
  0002a	0f b6 4d ff	 movzx	 ecx, BYTE PTR _nCol$139717[ebp]
  0002e	83 f9 28	 cmp	 ecx, 40			; 00000028H
  00031	7d 27		 jge	 SHORT $LN2@HasDoubleE

; 328  :     {
; 329  :         if ((pPage->Frame[nRow][nCol] & 0x7F) == 0x0D)

  00033	0f b6 55 0c	 movzx	 edx, BYTE PTR _nRow$[ebp]
  00037	6b d2 28	 imul	 edx, 40			; 00000028H
  0003a	8b 45 08	 mov	 eax, DWORD PTR _pPage$[ebp]
  0003d	8d 4c 10 06	 lea	 ecx, DWORD PTR [eax+edx+6]
  00041	0f b6 55 ff	 movzx	 edx, BYTE PTR _nCol$139717[ebp]
  00045	0f b6 04 11	 movzx	 eax, BYTE PTR [ecx+edx]
  00049	83 e0 7f	 and	 eax, 127		; 0000007fH
  0004c	83 f8 0d	 cmp	 eax, 13			; 0000000dH
  0004f	75 07		 jne	 SHORT $LN1@HasDoubleE

; 330  :         {
; 331  :             return TRUE;

  00051	b8 01 00 00 00	 mov	 eax, 1
  00056	eb 04		 jmp	 SHORT $LN6@HasDoubleE
$LN1@HasDoubleE:

; 332  :         }
; 333  :     }

  00058	eb c8		 jmp	 SHORT $LN3@HasDoubleE
$LN2@HasDoubleE:

; 334  :     return FALSE;

  0005a	33 c0		 xor	 eax, eax
$LN6@HasDoubleE:

; 335  : }

  0005c	8b e5		 mov	 esp, ebp
  0005e	5d		 pop	 ebp
  0005f	c3		 ret	 0
?HasDoubleElement@CVTCommon@@SAHPAU_VTPage@@E@Z ENDP	; CVTCommon::HasDoubleElement
_TEXT	ENDS
PUBLIC	?IsBoxedOnlyPage@CVTCommon@@SAHPAU_VTPage@@@Z	; CVTCommon::IsBoxedOnlyPage
; Function compile flags: /Odtp
;	COMDAT ?IsBoxedOnlyPage@CVTCommon@@SAHPAU_VTPage@@@Z
_TEXT	SEGMENT
_pPage$ = 8						; size = 4
?IsBoxedOnlyPage@CVTCommon@@SAHPAU_VTPage@@@Z PROC	; CVTCommon::IsBoxedOnlyPage, COMDAT

; 308  : {

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

; 309  :     // If newsflash or subtitle is set, only boxed text
; 310  :     // is to be displayed
; 311  :     if ((pPage->wControlBits & VTCONTROL_NEWSFLASH) != 0 ||
; 312  :         (pPage->wControlBits & VTCONTROL_SUBTITLE) != 0)

  00003	8b 45 08	 mov	 eax, DWORD PTR _pPage$[ebp]
  00006	0f b7 48 04	 movzx	 ecx, WORD PTR [eax+4]
  0000a	83 e1 10	 and	 ecx, 16			; 00000010H
  0000d	75 0c		 jne	 SHORT $LN1@IsBoxedOnl
  0000f	8b 55 08	 mov	 edx, DWORD PTR _pPage$[ebp]
  00012	0f b7 42 04	 movzx	 eax, WORD PTR [edx+4]
  00016	83 e0 20	 and	 eax, 32			; 00000020H
  00019	74 07		 je	 SHORT $LN2@IsBoxedOnl
$LN1@IsBoxedOnl:

; 313  :     {
; 314  :         return TRUE;

  0001b	b8 01 00 00 00	 mov	 eax, 1
  00020	eb 02		 jmp	 SHORT $LN3@IsBoxedOnl
$LN2@IsBoxedOnl:

; 315  :     }
; 316  :     return FALSE;

  00022	33 c0		 xor	 eax, eax
$LN3@IsBoxedOnl:

; 317  : }

  00024	5d		 pop	 ebp
  00025	c3		 ret	 0
?IsBoxedOnlyPage@CVTCommon@@SAHPAU_VTPage@@@Z ENDP	; CVTCommon::IsBoxedOnlyPage
_TEXT	ENDS
PUBLIC	?IsNonVisiblePage@CVTCommon@@SAHG@Z		; CVTCommon::IsNonVisiblePage
; Function compile flags: /Odtp
;	COMDAT ?IsNonVisiblePage@CVTCommon@@SAHG@Z
_TEXT	SEGMENT
_wPageHex$ = 8						; size = 2
?IsNonVisiblePage@CVTCommon@@SAHG@Z PROC		; CVTCommon::IsNonVisiblePage, COMDAT

; 290  : {

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

; 291  :     if ((wPageHex & 0xFF00) < 0x0100 ||
; 292  :         (wPageHex & 0xFF00) > 0x0800)

  00003	0f b7 45 08	 movzx	 eax, WORD PTR _wPageHex$[ebp]
  00007	25 00 ff 00 00	 and	 eax, 65280		; 0000ff00H
  0000c	3d 00 01 00 00	 cmp	 eax, 256		; 00000100H
  00011	7c 12		 jl	 SHORT $LN3@IsNonVisib
  00013	0f b7 4d 08	 movzx	 ecx, WORD PTR _wPageHex$[ebp]
  00017	81 e1 00 ff 00
	00		 and	 ecx, 65280		; 0000ff00H
  0001d	81 f9 00 08 00
	00		 cmp	 ecx, 2048		; 00000800H
  00023	7e 04		 jle	 SHORT $LN4@IsNonVisib
$LN3@IsNonVisib:

; 293  :     {
; 294  :         return FALSE;

  00025	33 c0		 xor	 eax, eax
  00027	eb 27		 jmp	 SHORT $LN5@IsNonVisib
$LN4@IsNonVisib:

; 295  :     }
; 296  : 
; 297  :     if ((wPageHex & 0x00F0) >= 0x00A0 ||
; 298  :         (wPageHex & 0x000F) >= 0x000A)

  00029	0f b7 55 08	 movzx	 edx, WORD PTR _wPageHex$[ebp]
  0002d	81 e2 f0 00 00
	00		 and	 edx, 240		; 000000f0H
  00033	81 fa a0 00 00
	00		 cmp	 edx, 160		; 000000a0H
  00039	7d 0c		 jge	 SHORT $LN1@IsNonVisib
  0003b	0f b7 45 08	 movzx	 eax, WORD PTR _wPageHex$[ebp]
  0003f	83 e0 0f	 and	 eax, 15			; 0000000fH
  00042	83 f8 0a	 cmp	 eax, 10			; 0000000aH
  00045	7c 07		 jl	 SHORT $LN2@IsNonVisib
$LN1@IsNonVisib:

; 299  :     {
; 300  :         return TRUE;

  00047	b8 01 00 00 00	 mov	 eax, 1
  0004c	eb 02		 jmp	 SHORT $LN5@IsNonVisib
$LN2@IsNonVisib:

; 301  :     }
; 302  : 
; 303  :     return FALSE;

  0004e	33 c0		 xor	 eax, eax
$LN5@IsNonVisib:

; 304  : }

  00050	5d		 pop	 ebp
  00051	c3		 ret	 0
?IsNonVisiblePage@CVTCommon@@SAHG@Z ENDP		; CVTCommon::IsNonVisiblePage
_TEXT	ENDS
PUBLIC	?InitializeDecodeTable@CVTCommon@@CAXXZ		; CVTCommon::InitializeDecodeTable
; Function compile flags: /Odtp
;	COMDAT ?InitializeDecodeTable@CVTCommon@@CAXXZ
_TEXT	SEGMENT
_Data$ = -6						; size = 1
_Parity$ = -5						; size = 1
_i$ = -4						; size = 4
?InitializeDecodeTable@CVTCommon@@CAXXZ PROC		; CVTCommon::InitializeDecodeTable, COMDAT

; 238  : {

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

; 239  :     BYTE Parity;
; 240  :     BYTE Data;
; 241  :     int i;
; 242  : 
; 243  :     // Create the Odd Parity checker
; 244  :     for (i = 0; i < 256; i++)

  00006	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR _i$[ebp], 0
  0000d	eb 09		 jmp	 SHORT $LN8@Initialize@2
$LN7@Initialize@2:
  0000f	8b 45 fc	 mov	 eax, DWORD PTR _i$[ebp]
  00012	83 c0 01	 add	 eax, 1
  00015	89 45 fc	 mov	 DWORD PTR _i$[ebp], eax
$LN8@Initialize@2:
  00018	81 7d fc 00 01
	00 00		 cmp	 DWORD PTR _i$[ebp], 256	; 00000100H
  0001f	7d 47		 jge	 SHORT $LN6@Initialize@2

; 245  :     {
; 246  :         Parity = i ^ (i >> 4);

  00021	8b 4d fc	 mov	 ecx, DWORD PTR _i$[ebp]
  00024	c1 f9 04	 sar	 ecx, 4
  00027	33 4d fc	 xor	 ecx, DWORD PTR _i$[ebp]
  0002a	88 4d fb	 mov	 BYTE PTR _Parity$[ebp], cl

; 247  :         Parity ^= Parity >> 2;

  0002d	0f b6 55 fb	 movzx	 edx, BYTE PTR _Parity$[ebp]
  00031	c1 fa 02	 sar	 edx, 2
  00034	0f b6 45 fb	 movzx	 eax, BYTE PTR _Parity$[ebp]
  00038	33 c2		 xor	 eax, edx
  0003a	88 45 fb	 mov	 BYTE PTR _Parity$[ebp], al

; 248  :         Parity ^= Parity >> 1;

  0003d	0f b6 4d fb	 movzx	 ecx, BYTE PTR _Parity$[ebp]
  00041	d1 f9		 sar	 ecx, 1
  00043	0f b6 55 fb	 movzx	 edx, BYTE PTR _Parity$[ebp]
  00047	33 d1		 xor	 edx, ecx
  00049	88 55 fb	 mov	 BYTE PTR _Parity$[ebp], dl

; 249  : 
; 250  :         m_DecodeTable[i] = (Parity & 1) ? 0 : DECODE_PARITY_BIT;

  0004c	0f b6 45 fb	 movzx	 eax, BYTE PTR _Parity$[ebp]
  00050	83 e0 01	 and	 eax, 1
  00053	f7 d8		 neg	 eax
  00055	1b c0		 sbb	 eax, eax
  00057	83 e0 e0	 and	 eax, -32		; ffffffe0H
  0005a	83 c0 20	 add	 eax, 32			; 00000020H
  0005d	8b 4d fc	 mov	 ecx, DWORD PTR _i$[ebp]
  00060	88 81 00 00 00
	00		 mov	 BYTE PTR ?m_DecodeTable@CVTCommon@@0PAEA[ecx], al

; 251  :     }

  00066	eb a7		 jmp	 SHORT $LN7@Initialize@2
$LN6@Initialize@2:

; 252  : 
; 253  :     // Create the Hamming 8/4 decoder
; 254  :     for (i = 0; i < 256; i++)

  00068	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR _i$[ebp], 0
  0006f	eb 09		 jmp	 SHORT $LN5@Initialize@2
$LN4@Initialize@2:
  00071	8b 55 fc	 mov	 edx, DWORD PTR _i$[ebp]
  00074	83 c2 01	 add	 edx, 1
  00077	89 55 fc	 mov	 DWORD PTR _i$[ebp], edx
$LN5@Initialize@2:
  0007a	81 7d fc 00 01
	00 00		 cmp	 DWORD PTR _i$[ebp], 256	; 00000100H
  00081	0f 8d 28 01 00
	00		 jge	 $LN3@Initialize@2

; 255  :     {
; 256  :         Parity = 0x80;

  00087	c6 45 fb 80	 mov	 BYTE PTR _Parity$[ebp], 128 ; 00000080H

; 257  :         Parity >>= ((m_DecodeTable[i & 0xA3] & DECODE_PARITY_BIT) != 0) * 1;

  0008b	8b 45 fc	 mov	 eax, DWORD PTR _i$[ebp]
  0008e	25 a3 00 00 00	 and	 eax, 163		; 000000a3H
  00093	0f b6 88 00 00
	00 00		 movzx	 ecx, BYTE PTR ?m_DecodeTable@CVTCommon@@0PAEA[eax]
  0009a	83 e1 20	 and	 ecx, 32			; 00000020H
  0009d	f7 d9		 neg	 ecx
  0009f	1b c9		 sbb	 ecx, ecx
  000a1	f7 d9		 neg	 ecx
  000a3	8a 55 fb	 mov	 dl, BYTE PTR _Parity$[ebp]
  000a6	d2 ea		 shr	 dl, cl
  000a8	88 55 fb	 mov	 BYTE PTR _Parity$[ebp], dl

; 258  :         Parity >>= ((m_DecodeTable[i & 0x8E] & DECODE_PARITY_BIT) != 0) * 2;

  000ab	8b 45 fc	 mov	 eax, DWORD PTR _i$[ebp]
  000ae	25 8e 00 00 00	 and	 eax, 142		; 0000008eH
  000b3	0f b6 88 00 00
	00 00		 movzx	 ecx, BYTE PTR ?m_DecodeTable@CVTCommon@@0PAEA[eax]
  000ba	83 e1 20	 and	 ecx, 32			; 00000020H
  000bd	f7 d9		 neg	 ecx
  000bf	1b c9		 sbb	 ecx, ecx
  000c1	f7 d9		 neg	 ecx
  000c3	d1 e1		 shl	 ecx, 1
  000c5	8a 55 fb	 mov	 dl, BYTE PTR _Parity$[ebp]
  000c8	d2 ea		 shr	 dl, cl
  000ca	88 55 fb	 mov	 BYTE PTR _Parity$[ebp], dl

; 259  :         Parity >>= ((m_DecodeTable[i & 0x3A] & DECODE_PARITY_BIT) != 0) * 4;

  000cd	8b 45 fc	 mov	 eax, DWORD PTR _i$[ebp]
  000d0	83 e0 3a	 and	 eax, 58			; 0000003aH
  000d3	0f b6 88 00 00
	00 00		 movzx	 ecx, BYTE PTR ?m_DecodeTable@CVTCommon@@0PAEA[eax]
  000da	83 e1 20	 and	 ecx, 32			; 00000020H
  000dd	f7 d9		 neg	 ecx
  000df	1b c9		 sbb	 ecx, ecx
  000e1	f7 d9		 neg	 ecx
  000e3	c1 e1 02	 shl	 ecx, 2
  000e6	8a 55 fb	 mov	 dl, BYTE PTR _Parity$[ebp]
  000e9	d2 ea		 shr	 dl, cl
  000eb	88 55 fb	 mov	 BYTE PTR _Parity$[ebp], dl

; 260  : 
; 261  :         if ((Parity != 0x80) && (m_DecodeTable[i] & DECODE_PARITY_BIT) == 0)

  000ee	0f b6 45 fb	 movzx	 eax, BYTE PTR _Parity$[ebp]
  000f2	3d 80 00 00 00	 cmp	 eax, 128		; 00000080H
  000f7	74 2a		 je	 SHORT $LN2@Initialize@2
  000f9	8b 4d fc	 mov	 ecx, DWORD PTR _i$[ebp]
  000fc	0f b6 91 00 00
	00 00		 movzx	 edx, BYTE PTR ?m_DecodeTable@CVTCommon@@0PAEA[ecx]
  00103	83 e2 20	 and	 edx, 32			; 00000020H
  00106	75 1b		 jne	 SHORT $LN2@Initialize@2

; 262  :         {
; 263  :             // Double bit error
; 264  :             m_DecodeTable[i] |= DECODE_8_4_ERROR | DECODE_8_4_RESULT;

  00108	8b 45 fc	 mov	 eax, DWORD PTR _i$[ebp]
  0010b	0f b6 88 00 00
	00 00		 movzx	 ecx, BYTE PTR ?m_DecodeTable@CVTCommon@@0PAEA[eax]
  00112	83 c9 1f	 or	 ecx, 31			; 0000001fH
  00115	8b 55 fc	 mov	 edx, DWORD PTR _i$[ebp]
  00118	88 8a 00 00 00
	00		 mov	 BYTE PTR ?m_DecodeTable@CVTCommon@@0PAEA[edx], cl

; 265  :             continue;

  0011e	e9 4e ff ff ff	 jmp	 $LN4@Initialize@2
$LN2@Initialize@2:

; 266  :         }
; 267  : 
; 268  :         if (Parity >> 3)

  00123	0f b6 45 fb	 movzx	 eax, BYTE PTR _Parity$[ebp]
  00127	c1 f8 03	 sar	 eax, 3
  0012a	85 c0		 test	 eax, eax
  0012c	74 12		 je	 SHORT $LN1@Initialize@2

; 269  :         {
; 270  :             Parity &= 0x10;

  0012e	0f b6 4d fb	 movzx	 ecx, BYTE PTR _Parity$[ebp]
  00132	83 e1 10	 and	 ecx, 16			; 00000010H
  00135	88 4d fb	 mov	 BYTE PTR _Parity$[ebp], cl

; 271  :             Parity >>= 1;

  00138	8a 55 fb	 mov	 dl, BYTE PTR _Parity$[ebp]
  0013b	d0 ea		 shr	 dl, 1
  0013d	88 55 fb	 mov	 BYTE PTR _Parity$[ebp], dl
$LN1@Initialize@2:

; 272  :         }
; 273  : 
; 274  :         Data = (i & (1 << 1)) >> 1;

  00140	8b 45 fc	 mov	 eax, DWORD PTR _i$[ebp]
  00143	83 e0 02	 and	 eax, 2
  00146	d1 f8		 sar	 eax, 1
  00148	88 45 fa	 mov	 BYTE PTR _Data$[ebp], al

; 275  :         Data |= (i & (1 << 3)) >> 2;

  0014b	8b 4d fc	 mov	 ecx, DWORD PTR _i$[ebp]
  0014e	83 e1 08	 and	 ecx, 8
  00151	c1 f9 02	 sar	 ecx, 2
  00154	0f b6 55 fa	 movzx	 edx, BYTE PTR _Data$[ebp]
  00158	0b d1		 or	 edx, ecx
  0015a	88 55 fa	 mov	 BYTE PTR _Data$[ebp], dl

; 276  :         Data |= (i & (1 << 5)) >> 3;

  0015d	8b 45 fc	 mov	 eax, DWORD PTR _i$[ebp]
  00160	83 e0 20	 and	 eax, 32			; 00000020H
  00163	c1 f8 03	 sar	 eax, 3
  00166	0f b6 4d fa	 movzx	 ecx, BYTE PTR _Data$[ebp]
  0016a	0b c8		 or	 ecx, eax
  0016c	88 4d fa	 mov	 BYTE PTR _Data$[ebp], cl

; 277  :         Data |= (i & (1 << 7)) >> 4;

  0016f	8b 55 fc	 mov	 edx, DWORD PTR _i$[ebp]
  00172	81 e2 80 00 00
	00		 and	 edx, 128		; 00000080H
  00178	c1 fa 04	 sar	 edx, 4
  0017b	0f b6 45 fa	 movzx	 eax, BYTE PTR _Data$[ebp]
  0017f	0b c2		 or	 eax, edx
  00181	88 45 fa	 mov	 BYTE PTR _Data$[ebp], al

; 278  : 
; 279  :         // Correct an incorrect bit
; 280  :         Data ^= Parity;

  00184	0f b6 4d fb	 movzx	 ecx, BYTE PTR _Parity$[ebp]
  00188	0f b6 55 fa	 movzx	 edx, BYTE PTR _Data$[ebp]
  0018c	33 d1		 xor	 edx, ecx
  0018e	88 55 fa	 mov	 BYTE PTR _Data$[ebp], dl

; 281  : 
; 282  :         m_DecodeTable[i] |= Data;

  00191	0f b6 45 fa	 movzx	 eax, BYTE PTR _Data$[ebp]
  00195	8b 4d fc	 mov	 ecx, DWORD PTR _i$[ebp]
  00198	0f b6 91 00 00
	00 00		 movzx	 edx, BYTE PTR ?m_DecodeTable@CVTCommon@@0PAEA[ecx]
  0019f	0b d0		 or	 edx, eax
  001a1	8b 45 fc	 mov	 eax, DWORD PTR _i$[ebp]
  001a4	88 90 00 00 00
	00		 mov	 BYTE PTR ?m_DecodeTable@CVTCommon@@0PAEA[eax], dl

; 283  :     }

  001aa	e9 c2 fe ff ff	 jmp	 $LN4@Initialize@2
$LN3@Initialize@2:

; 284  : 
; 285  :     m_DecodeTableInitialized = TRUE;

  001af	c7 05 00 00 00
	00 01 00 00 00	 mov	 DWORD PTR ?m_DecodeTableInitialized@CVTCommon@@0HA, 1 ; CVTCommon::m_DecodeTableInitialized

; 286  : }

  001b9	8b e5		 mov	 esp, ebp
  001bb	5d		 pop	 ebp
  001bc	c3		 ret	 0
?InitializeDecodeTable@CVTCommon@@CAXXZ ENDP		; CVTCommon::InitializeDecodeTable
_TEXT	ENDS
PUBLIC	?Unham84@CVTCommon@@SAEEPAH@Z			; CVTCommon::Unham84
; Function compile flags: /Odtp
;	COMDAT ?Unham84@CVTCommon@@SAEEPAH@Z
_TEXT	SEGMENT
_Byte$ = 8						; size = 1
_Error$ = 12						; size = 4
?Unham84@CVTCommon@@SAEEPAH@Z PROC			; CVTCommon::Unham84, COMDAT

; 131  : {

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

; 132  :     if (m_DecodeTable[Byte] & DECODE_8_4_ERROR)

  00003	0f b6 45 08	 movzx	 eax, BYTE PTR _Byte$[ebp]
  00007	0f b6 88 00 00
	00 00		 movzx	 ecx, BYTE PTR ?m_DecodeTable@CVTCommon@@0PAEA[eax]
  0000e	83 e1 10	 and	 ecx, 16			; 00000010H
  00011	74 09		 je	 SHORT $LN1@Unham84

; 133  :     {
; 134  :         *Error = TRUE;

  00013	8b 55 0c	 mov	 edx, DWORD PTR _Error$[ebp]
  00016	c7 02 01 00 00
	00		 mov	 DWORD PTR [edx], 1
$LN1@Unham84:

; 135  :     }
; 136  : 
; 137  :     return m_DecodeTable[Byte] & DECODE_8_4_RESULT;

  0001c	0f b6 45 08	 movzx	 eax, BYTE PTR _Byte$[ebp]
  00020	0f b6 80 00 00
	00 00		 movzx	 eax, BYTE PTR ?m_DecodeTable@CVTCommon@@0PAEA[eax]
  00027	83 e0 0f	 and	 eax, 15			; 0000000fH

; 138  : }

  0002a	5d		 pop	 ebp
  0002b	c3		 ret	 0
?Unham84@CVTCommon@@SAEEPAH@Z ENDP			; CVTCommon::Unham84
_TEXT	ENDS
PUBLIC	?Unham84@CVTCommon@@SAEPAEPAH@Z			; CVTCommon::Unham84
; Function compile flags: /Odtp
;	COMDAT ?Unham84@CVTCommon@@SAEPAEPAH@Z
_TEXT	SEGMENT
_pByte$ = 8						; size = 4
_Error$ = 12						; size = 4
?Unham84@CVTCommon@@SAEPAEPAH@Z PROC			; CVTCommon::Unham84, COMDAT

; 125  : {

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

; 126  :     return Unham84(*pByte, Error);

  00003	8b 45 0c	 mov	 eax, DWORD PTR _Error$[ebp]
  00006	50		 push	 eax
  00007	8b 4d 08	 mov	 ecx, DWORD PTR _pByte$[ebp]
  0000a	0f b6 11	 movzx	 edx, BYTE PTR [ecx]
  0000d	52		 push	 edx
  0000e	e8 00 00 00 00	 call	 ?Unham84@CVTCommon@@SAEEPAH@Z ; CVTCommon::Unham84
  00013	83 c4 08	 add	 esp, 8

; 127  : }

  00016	5d		 pop	 ebp
  00017	c3		 ret	 0
?Unham84@CVTCommon@@SAEPAEPAH@Z ENDP			; CVTCommon::Unham84
_TEXT	ENDS
PUBLIC	?Parity@CVTCommon@@CAEE@Z			; CVTCommon::Parity
; Function compile flags: /Odtp
;	COMDAT ?Parity@CVTCommon@@CAEE@Z
_TEXT	SEGMENT
_Byte$ = 8						; size = 1
?Parity@CVTCommon@@CAEE@Z PROC				; CVTCommon::Parity, COMDAT

; 97   : {

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

; 98   :     return (m_DecodeTable[Byte] & DECODE_PARITY_BIT) != 0;

  00003	0f b6 45 08	 movzx	 eax, BYTE PTR _Byte$[ebp]
  00007	0f b6 88 00 00
	00 00		 movzx	 ecx, BYTE PTR ?m_DecodeTable@CVTCommon@@0PAEA[eax]
  0000e	83 e1 20	 and	 ecx, 32			; 00000020H
  00011	0f 95 c0	 setne	 al

; 99   : }

  00014	5d		 pop	 ebp
  00015	c3		 ret	 0
?Parity@CVTCommon@@CAEE@Z ENDP				; CVTCommon::Parity
_TEXT	ENDS
PUBLIC	?ReverseBits@CVTCommon@@SAEE@Z			; CVTCommon::ReverseBits
; Function compile flags: /Odtp
;	COMDAT ?ReverseBits@CVTCommon@@SAEE@Z
_TEXT	SEGMENT
_Byte$ = 8						; size = 1
?ReverseBits@CVTCommon@@SAEE@Z PROC			; CVTCommon::ReverseBits, COMDAT

; 86   : {

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

; 87   :     Byte = (Byte & 0x0F) << 4 | (Byte & 0xF0) >> 4;

  00003	0f b6 45 08	 movzx	 eax, BYTE PTR _Byte$[ebp]
  00007	83 e0 0f	 and	 eax, 15			; 0000000fH
  0000a	c1 e0 04	 shl	 eax, 4
  0000d	0f b6 4d 08	 movzx	 ecx, BYTE PTR _Byte$[ebp]
  00011	81 e1 f0 00 00
	00		 and	 ecx, 240		; 000000f0H
  00017	c1 f9 04	 sar	 ecx, 4
  0001a	0b c1		 or	 eax, ecx
  0001c	88 45 08	 mov	 BYTE PTR _Byte$[ebp], al

; 88   :     Byte = (Byte & 0x33) << 2 | (Byte & 0xCC) >> 2;

  0001f	0f b6 55 08	 movzx	 edx, BYTE PTR _Byte$[ebp]
  00023	83 e2 33	 and	 edx, 51			; 00000033H
  00026	c1 e2 02	 shl	 edx, 2
  00029	0f b6 45 08	 movzx	 eax, BYTE PTR _Byte$[ebp]
  0002d	25 cc 00 00 00	 and	 eax, 204		; 000000ccH
  00032	c1 f8 02	 sar	 eax, 2
  00035	0b d0		 or	 edx, eax
  00037	88 55 08	 mov	 BYTE PTR _Byte$[ebp], dl

; 89   :     Byte = (Byte & 0x55) << 1 | (Byte & 0xAA) >> 1;

  0003a	0f b6 4d 08	 movzx	 ecx, BYTE PTR _Byte$[ebp]
  0003e	83 e1 55	 and	 ecx, 85			; 00000055H
  00041	d1 e1		 shl	 ecx, 1
  00043	0f b6 55 08	 movzx	 edx, BYTE PTR _Byte$[ebp]
  00047	81 e2 aa 00 00
	00		 and	 edx, 170		; 000000aaH
  0004d	d1 fa		 sar	 edx, 1
  0004f	0b ca		 or	 ecx, edx
  00051	88 4d 08	 mov	 BYTE PTR _Byte$[ebp], cl

; 90   : 
; 91   :     return Byte;

  00054	8a 45 08	 mov	 al, BYTE PTR _Byte$[ebp]

; 92   : }

  00057	5d		 pop	 ebp
  00058	c3		 ret	 0
?ReverseBits@CVTCommon@@SAEE@Z ENDP			; CVTCommon::ReverseBits
_TEXT	ENDS
PUBLIC	??1CVTCommon@@QAE@XZ				; CVTCommon::~CVTCommon
; Function compile flags: /Odtp
;	COMDAT ??1CVTCommon@@QAE@XZ
_TEXT	SEGMENT
_this$ = -4						; size = 4
??1CVTCommon@@QAE@XZ PROC				; CVTCommon::~CVTCommon, COMDAT
; _this$ = ecx

; 80   : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
  00004	89 4d fc	 mov	 DWORD PTR _this$[ebp], ecx

; 81   : }

  00007	8b e5		 mov	 esp, ebp
  00009	5d		 pop	 ebp
  0000a	c3		 ret	 0
??1CVTCommon@@QAE@XZ ENDP				; CVTCommon::~CVTCommon
_TEXT	ENDS
PUBLIC	??0CVTCommon@@QAE@XZ				; CVTCommon::CVTCommon
; Function compile flags: /Odtp
;	COMDAT ??0CVTCommon@@QAE@XZ
_TEXT	SEGMENT
_this$ = -4						; size = 4
??0CVTCommon@@QAE@XZ PROC				; CVTCommon::CVTCommon, COMDAT
; _this$ = ecx

; 71   : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
  00004	89 4d fc	 mov	 DWORD PTR _this$[ebp], ecx

; 72   :     if (m_DecodeTableInitialized == FALSE)

  00007	83 3d 00 00 00
	00 00		 cmp	 DWORD PTR ?m_DecodeTableInitialized@CVTCommon@@0HA, 0 ; CVTCommon::m_DecodeTableInitialized
  0000e	75 05		 jne	 SHORT $LN2@CVTCommon

; 73   :     {
; 74   :         InitializeDecodeTable();

  00010	e8 00 00 00 00	 call	 ?InitializeDecodeTable@CVTCommon@@CAXXZ ; CVTCommon::InitializeDecodeTable
$LN2@CVTCommon:

; 75   :     }
; 76   : }

  00015	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  00018	8b e5		 mov	 esp, ebp
  0001a	5d		 pop	 ebp
  0001b	c3		 ret	 0
??0CVTCommon@@QAE@XZ ENDP				; CVTCommon::CVTCommon
PUBLIC	?ParseLineElements@CVTCommon@@SAEPAU_VTPage@@EPAGP6AE0G1GEEPAX@Z2@Z ; CVTCommon::ParseLineElements
; Function compile flags: /Odtp
;	COMDAT ?ParseLineElements@CVTCommon@@SAEPAU_VTPage@@EPAGP6AE0G1GEEPAX@Z2@Z
_TEXT	SEGMENT
tv212 = -36						; size = 4
_nCol$139808 = -31					; size = 1
_nConsecutiveDoubles$139790 = -30			; size = 1
_DisplayColour$ = -29					; size = 1
_HeldGraphChar$ = -28					; size = 1
_DisplayModes$ = -27					; size = 1
_Background$ = -26					; size = 1
_nLastUnboxPos$ = -25					; size = 1
_bHeldGraphSeparated$ = -24				; size = 4
_DisplayChar$ = -19					; size = 1
_SetAfterModes$ = -18					; size = 1
_nLastBoxPos$ = -17					; size = 1
_uResult$ = -16						; size = 4
_DisplayBkColour$ = -10					; size = 1
_DisplayRow$ = -9					; size = 1
_bBoxedElementsOnly$ = -8				; size = 4
_SetAfterColour$ = -1					; size = 1
_pPage$ = 8						; size = 4
_nRow$ = 12						; size = 1
_lpFlags$ = 16						; size = 4
_fnParseProc$ = 20					; size = 4
_lpParam$ = 24						; size = 4
?ParseLineElements@CVTCommon@@SAEPAU_VTPage@@EPAGP6AE0G1GEEPAX@Z2@Z PROC ; CVTCommon::ParseLineElements, COMDAT

; 497  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 24	 sub	 esp, 36			; 00000024H

; 498  :     BYTE DisplayChar;
; 499  :     BYTE DisplayModes;
; 500  :     BYTE DisplayColour;
; 501  :     BYTE DisplayBkColour;
; 502  :     BYTE DisplayRow;
; 503  :     BYTE SetAfterModes;
; 504  :     BYTE SetAfterColour;
; 505  :     BYTE Background;
; 506  :     BYTE nLastBoxPos;
; 507  :     BYTE nLastUnboxPos;
; 508  :     BYTE HeldGraphChar;
; 509  :     BOOL bHeldGraphSeparated = FALSE;

  00006	c7 45 e8 00 00
	00 00		 mov	 DWORD PTR _bHeldGraphSeparated$[ebp], 0

; 510  :     BOOL bBoxedElementsOnly = FALSE;

  0000d	c7 45 f8 00 00
	00 00		 mov	 DWORD PTR _bBoxedElementsOnly$[ebp], 0

; 511  :     LONG uResult;
; 512  : 
; 513  :     if ((*lpFlags & PARSE_DOUBLEREPEAT) != 0)

  00014	8b 45 10	 mov	 eax, DWORD PTR _lpFlags$[ebp]
  00017	0f b7 08	 movzx	 ecx, WORD PTR [eax]
  0001a	83 e1 40	 and	 ecx, 64			; 00000040H
  0001d	74 19		 je	 SHORT $LN63@ParseLineE

; 514  :     {
; 515  :         if (nRow < 1 || nRow >= 23)

  0001f	0f b6 55 0c	 movzx	 edx, BYTE PTR _nRow$[ebp]
  00023	83 fa 01	 cmp	 edx, 1
  00026	7c 09		 jl	 SHORT $LN61@ParseLineE
  00028	0f b6 45 0c	 movzx	 eax, BYTE PTR _nRow$[ebp]
  0002c	83 f8 17	 cmp	 eax, 23			; 00000017H
  0002f	7c 07		 jl	 SHORT $LN63@ParseLineE
$LN61@ParseLineE:

; 516  :         {
; 517  :             // Programming error
; 518  :             _ASSERTE(FALSE);
; 519  :             return PARSE_CONFIGERROR;

  00031	b0 0a		 mov	 al, 10			; 0000000aH
  00033	e9 e8 04 00 00	 jmp	 $LN64@ParseLineE
$LN63@ParseLineE:

; 520  :         }
; 521  :     }
; 522  : 
; 523  :     // Check if we are to look for doubles in the previous row
; 524  :     if ((*lpFlags & PARSE_SKIPDOUBLECHECK) == 0 && nRow > 1 && nRow <= 23)

  00038	8b 4d 10	 mov	 ecx, DWORD PTR _lpFlags$[ebp]
  0003b	0f b7 11	 movzx	 edx, WORD PTR [ecx]
  0003e	83 e2 20	 and	 edx, 32			; 00000020H
  00041	0f 85 e6 00 00
	00		 jne	 $LN60@ParseLineE
  00047	0f b6 45 0c	 movzx	 eax, BYTE PTR _nRow$[ebp]
  0004b	83 f8 01	 cmp	 eax, 1
  0004e	0f 8e d9 00 00
	00		 jle	 $LN60@ParseLineE
  00054	0f b6 4d 0c	 movzx	 ecx, BYTE PTR _nRow$[ebp]
  00058	83 f9 17	 cmp	 ecx, 23			; 00000017H
  0005b	0f 8f cc 00 00
	00		 jg	 $LN60@ParseLineE

; 525  :     {
; 526  :         // Check if the previous line had a double
; 527  :         if (HasDoubleElement(pPage, nRow - 1))

  00061	0f b6 55 0c	 movzx	 edx, BYTE PTR _nRow$[ebp]
  00065	83 ea 01	 sub	 edx, 1
  00068	52		 push	 edx
  00069	8b 45 08	 mov	 eax, DWORD PTR _pPage$[ebp]
  0006c	50		 push	 eax
  0006d	e8 00 00 00 00	 call	 ?HasDoubleElement@CVTCommon@@SAHPAU_VTPage@@E@Z ; CVTCommon::HasDoubleElement
  00072	83 c4 08	 add	 esp, 8
  00075	85 c0		 test	 eax, eax
  00077	0f 84 b0 00 00
	00		 je	 $LN60@ParseLineE

; 528  :         {
; 529  :             // Check that this isn't already a double repeated
; 530  :             if ((*lpFlags & PARSE_DOUBLEREPEAT) != 0)

  0007d	8b 4d 10	 mov	 ecx, DWORD PTR _lpFlags$[ebp]
  00080	0f b7 11	 movzx	 edx, WORD PTR [ecx]
  00083	83 e2 40	 and	 edx, 64			; 00000040H
  00086	74 71		 je	 SHORT $LN58@ParseLineE

; 531  :             {
; 532  :                 BYTE nConsecutiveDoubles = 1;

  00088	c6 45 e2 01	 mov	 BYTE PTR _nConsecutiveDoubles$139790[ebp], 1

; 533  : 
; 534  :                 // There are problematic doubles in the page
; 535  :                 for (DisplayRow = nRow - 2; DisplayRow >= 1 &&

  0008c	0f b6 45 0c	 movzx	 eax, BYTE PTR _nRow$[ebp]
  00090	83 e8 02	 sub	 eax, 2
  00093	88 45 f7	 mov	 BYTE PTR _DisplayRow$[ebp], al

; 536  :                     HasDoubleElement(pPage, DisplayRow); DisplayRow--)

  00096	eb 09		 jmp	 SHORT $LN57@ParseLineE
$LN56@ParseLineE:
  00098	8a 4d f7	 mov	 cl, BYTE PTR _DisplayRow$[ebp]
  0009b	80 e9 01	 sub	 cl, 1
  0009e	88 4d f7	 mov	 BYTE PTR _DisplayRow$[ebp], cl
$LN57@ParseLineE:
  000a1	0f b6 55 f7	 movzx	 edx, BYTE PTR _DisplayRow$[ebp]
  000a5	83 fa 01	 cmp	 edx, 1
  000a8	7c 20		 jl	 SHORT $LN55@ParseLineE
  000aa	0f b6 45 f7	 movzx	 eax, BYTE PTR _DisplayRow$[ebp]
  000ae	50		 push	 eax
  000af	8b 4d 08	 mov	 ecx, DWORD PTR _pPage$[ebp]
  000b2	51		 push	 ecx
  000b3	e8 00 00 00 00	 call	 ?HasDoubleElement@CVTCommon@@SAHPAU_VTPage@@E@Z ; CVTCommon::HasDoubleElement
  000b8	83 c4 08	 add	 esp, 8
  000bb	85 c0		 test	 eax, eax
  000bd	74 0b		 je	 SHORT $LN55@ParseLineE

; 537  :                 {
; 538  :                     nConsecutiveDoubles++;

  000bf	8a 55 e2	 mov	 dl, BYTE PTR _nConsecutiveDoubles$139790[ebp]
  000c2	80 c2 01	 add	 dl, 1
  000c5	88 55 e2	 mov	 BYTE PTR _nConsecutiveDoubles$139790[ebp], dl

; 539  :                 }

  000c8	eb ce		 jmp	 SHORT $LN56@ParseLineE
$LN55@ParseLineE:

; 540  : 
; 541  :                 // Check if this double repeat is valid
; 542  :                 if ((nConsecutiveDoubles % 2) == 1)

  000ca	0f b6 45 e2	 movzx	 eax, BYTE PTR _nConsecutiveDoubles$139790[ebp]
  000ce	25 01 00 00 80	 and	 eax, -2147483647	; 80000001H
  000d3	79 05		 jns	 SHORT $LN67@ParseLineE
  000d5	48		 dec	 eax
  000d6	83 c8 fe	 or	 eax, -2			; fffffffeH
  000d9	40		 inc	 eax
$LN67@ParseLineE:
  000da	83 f8 01	 cmp	 eax, 1
  000dd	75 18		 jne	 SHORT $LN53@ParseLineE

; 543  :                 {
; 544  :                     // This row is invalid, so the double repeat
; 545  :                     // is also invalid.  Redo the next row line
; 546  :                     // as a non-repeat
; 547  :                     *lpFlags &= ~PARSE_DOUBLEREPEAT;

  000df	8b 4d 10	 mov	 ecx, DWORD PTR _lpFlags$[ebp]
  000e2	0f b7 11	 movzx	 edx, WORD PTR [ecx]
  000e5	83 e2 bf	 and	 edx, -65		; ffffffbfH
  000e8	8b 45 10	 mov	 eax, DWORD PTR _lpFlags$[ebp]
  000eb	66 89 10	 mov	 WORD PTR [eax], dx

; 548  :                     nRow++;

  000ee	8a 4d 0c	 mov	 cl, BYTE PTR _nRow$[ebp]
  000f1	80 c1 01	 add	 cl, 1
  000f4	88 4d 0c	 mov	 BYTE PTR _nRow$[ebp], cl
$LN53@ParseLineE:

; 549  :                 }
; 550  :                 else
; 551  :                 {
; 552  :                     // Ignore the double on the previous line
; 553  :                     // and continue repeating the double on
; 554  :                     // this line as the next row line.
; 555  :                 }
; 556  :             }
; 557  :             else

  000f7	eb 34		 jmp	 SHORT $LN60@ParseLineE
$LN58@ParseLineE:

; 558  :             {
; 559  :                 // Repeat the previous as this line
; 560  :                 *lpFlags |= PARSE_DOUBLEREPEAT;

  000f9	8b 55 10	 mov	 edx, DWORD PTR _lpFlags$[ebp]
  000fc	0f b7 02	 movzx	 eax, WORD PTR [edx]
  000ff	83 c8 40	 or	 eax, 64			; 00000040H
  00102	8b 4d 10	 mov	 ecx, DWORD PTR _lpFlags$[ebp]
  00105	66 89 01	 mov	 WORD PTR [ecx], ax

; 561  :                 return ParseLineElements(pPage, nRow - 1, lpFlags,
; 562  :                                          fnParseProc, lpParam);

  00108	8b 55 18	 mov	 edx, DWORD PTR _lpParam$[ebp]
  0010b	52		 push	 edx
  0010c	8b 45 14	 mov	 eax, DWORD PTR _fnParseProc$[ebp]
  0010f	50		 push	 eax
  00110	8b 4d 10	 mov	 ecx, DWORD PTR _lpFlags$[ebp]
  00113	51		 push	 ecx
  00114	0f b6 55 0c	 movzx	 edx, BYTE PTR _nRow$[ebp]
  00118	83 ea 01	 sub	 edx, 1
  0011b	52		 push	 edx
  0011c	8b 45 08	 mov	 eax, DWORD PTR _pPage$[ebp]
  0011f	50		 push	 eax
  00120	e8 00 00 00 00	 call	 ?ParseLineElements@CVTCommon@@SAEPAU_VTPage@@EPAGP6AE0G1GEEPAX@Z2@Z ; CVTCommon::ParseLineElements
  00125	83 c4 14	 add	 esp, 20			; 00000014H
  00128	e9 f3 03 00 00	 jmp	 $LN64@ParseLineE
$LN60@ParseLineE:

; 563  :             }
; 564  :         }
; 565  :     }
; 566  : 
; 567  :     // If this row is a repeat, the actual row is the one below
; 568  :     if ((*lpFlags & PARSE_DOUBLEREPEAT) != 0)

  0012d	8b 4d 10	 mov	 ecx, DWORD PTR _lpFlags$[ebp]
  00130	0f b7 11	 movzx	 edx, WORD PTR [ecx]
  00133	83 e2 40	 and	 edx, 64			; 00000040H
  00136	74 1e		 je	 SHORT $LN51@ParseLineE

; 569  :     {
; 570  :         if ((*lpFlags & PARSE_REPEATDOUBLE) == 0)

  00138	8b 45 10	 mov	 eax, DWORD PTR _lpFlags$[ebp]
  0013b	0f b7 08	 movzx	 ecx, WORD PTR [eax]
  0013e	83 e1 08	 and	 ecx, 8
  00141	75 07		 jne	 SHORT $LN50@ParseLineE

; 571  :         {
; 572  :             return PARSE_DOUBLESKIP;

  00143	b0 09		 mov	 al, 9
  00145	e9 d6 03 00 00	 jmp	 $LN64@ParseLineE
$LN50@ParseLineE:

; 573  :         }
; 574  : 
; 575  :         DisplayRow = nRow + 1;

  0014a	0f b6 55 0c	 movzx	 edx, BYTE PTR _nRow$[ebp]
  0014e	83 c2 01	 add	 edx, 1
  00151	88 55 f7	 mov	 BYTE PTR _DisplayRow$[ebp], dl

; 576  :     }
; 577  :     else

  00154	eb 06		 jmp	 SHORT $LN49@ParseLineE
$LN51@ParseLineE:

; 578  :     {
; 579  :         DisplayRow = nRow;

  00156	8a 45 0c	 mov	 al, BYTE PTR _nRow$[ebp]
  00159	88 45 f7	 mov	 BYTE PTR _DisplayRow$[ebp], al
$LN49@ParseLineE:

; 580  :     }
; 581  : 
; 582  :     // Check if we need to process this line
; 583  :     uResult = CheckLineParsable(pPage, nRow, lpFlags);

  0015c	8b 4d 10	 mov	 ecx, DWORD PTR _lpFlags$[ebp]
  0015f	51		 push	 ecx
  00160	0f b6 55 0c	 movzx	 edx, BYTE PTR _nRow$[ebp]
  00164	52		 push	 edx
  00165	8b 45 08	 mov	 eax, DWORD PTR _pPage$[ebp]
  00168	50		 push	 eax
  00169	e8 00 00 00 00	 call	 ?CheckLineParsable@CVTCommon@@CAEPAU_VTPage@@EPAG@Z ; CVTCommon::CheckLineParsable
  0016e	83 c4 0c	 add	 esp, 12			; 0000000cH
  00171	0f b6 c8	 movzx	 ecx, al
  00174	89 4d f0	 mov	 DWORD PTR _uResult$[ebp], ecx

; 584  : 
; 585  :     if (uResult != PARSE_CONTINUE)

  00177	83 7d f0 00	 cmp	 DWORD PTR _uResult$[ebp], 0
  0017b	74 37		 je	 SHORT $LN48@ParseLineE

; 586  :     {
; 587  :         if ((*lpFlags & PARSE_EMPTYLINE) != 0)

  0017d	8b 55 10	 mov	 edx, DWORD PTR _lpFlags$[ebp]
  00180	0f b7 02	 movzx	 eax, WORD PTR [edx]
  00183	25 80 00 00 00	 and	 eax, 128		; 00000080H
  00188	74 22		 je	 SHORT $LN47@ParseLineE

; 588  :         {
; 589  :             return ParseEmptyLine(pPage, nRow, lpFlags, fnParseProc, lpParam);

  0018a	8b 4d 18	 mov	 ecx, DWORD PTR _lpParam$[ebp]
  0018d	51		 push	 ecx
  0018e	8b 55 14	 mov	 edx, DWORD PTR _fnParseProc$[ebp]
  00191	52		 push	 edx
  00192	8b 45 10	 mov	 eax, DWORD PTR _lpFlags$[ebp]
  00195	50		 push	 eax
  00196	0f b6 4d 0c	 movzx	 ecx, BYTE PTR _nRow$[ebp]
  0019a	51		 push	 ecx
  0019b	8b 55 08	 mov	 edx, DWORD PTR _pPage$[ebp]
  0019e	52		 push	 edx
  0019f	e8 00 00 00 00	 call	 ?ParseEmptyLine@CVTCommon@@CAEPAU_VTPage@@EPAGP6AE0G1GEEPAX@Z2@Z ; CVTCommon::ParseEmptyLine
  001a4	83 c4 14	 add	 esp, 20			; 00000014H
  001a7	e9 74 03 00 00	 jmp	 $LN64@ParseLineE
$LN47@ParseLineE:

; 590  :         }
; 591  :         return (BYTE)uResult;

  001ac	8a 45 f0	 mov	 al, BYTE PTR _uResult$[ebp]
  001af	e9 6c 03 00 00	 jmp	 $LN64@ParseLineE
$LN48@ParseLineE:

; 592  :     }
; 593  : 
; 594  :     if (nRow != 25)

  001b4	0f b6 45 0c	 movzx	 eax, BYTE PTR _nRow$[ebp]
  001b8	83 f8 19	 cmp	 eax, 25			; 00000019H
  001bb	74 32		 je	 SHORT $LN46@ParseLineE

; 595  :     {
; 596  :         // If newsflash or subtitle is set, only boxed elements
; 597  :         // should be displayed
; 598  :         if ((pPage->wControlBits & VTCONTROL_NEWSFLASH) != 0 ||
; 599  :             (pPage->wControlBits & VTCONTROL_SUBTITLE) != 0)

  001bd	8b 4d 08	 mov	 ecx, DWORD PTR _pPage$[ebp]
  001c0	0f b7 51 04	 movzx	 edx, WORD PTR [ecx+4]
  001c4	83 e2 10	 and	 edx, 16			; 00000010H
  001c7	75 0c		 jne	 SHORT $LN44@ParseLineE
  001c9	8b 45 08	 mov	 eax, DWORD PTR _pPage$[ebp]
  001cc	0f b7 48 04	 movzx	 ecx, WORD PTR [eax+4]
  001d0	83 e1 20	 and	 ecx, 32			; 00000020H
  001d3	74 1a		 je	 SHORT $LN46@ParseLineE
$LN44@ParseLineE:

; 600  :         {
; 601  :             // Ignore if force header is on
; 602  :             if (nRow != 0 || (*lpFlags & PARSE_FORCEHEADER) == 0)

  001d5	0f b6 55 0c	 movzx	 edx, BYTE PTR _nRow$[ebp]
  001d9	85 d2		 test	 edx, edx
  001db	75 0b		 jne	 SHORT $LN42@ParseLineE
  001dd	8b 45 10	 mov	 eax, DWORD PTR _lpFlags$[ebp]
  001e0	0f b7 08	 movzx	 ecx, WORD PTR [eax]
  001e3	83 e1 04	 and	 ecx, 4
  001e6	75 07		 jne	 SHORT $LN46@ParseLineE
$LN42@ParseLineE:

; 603  :             {
; 604  :                 bBoxedElementsOnly = TRUE;

  001e8	c7 45 f8 01 00
	00 00		 mov	 DWORD PTR _bBoxedElementsOnly$[ebp], 1
$LN46@ParseLineE:

; 605  :             }
; 606  :         }
; 607  :     }
; 608  : 
; 609  :     DisplayModes = 0;

  001ef	c6 45 e5 00	 mov	 BYTE PTR _DisplayModes$[ebp], 0

; 610  :     DisplayColour = VTCOLOR_WHITE;

  001f3	c6 45 e3 07	 mov	 BYTE PTR _DisplayColour$[ebp], 7

; 611  :     Background = VTCOLOR_BLACK;

  001f7	c6 45 e6 00	 mov	 BYTE PTR _Background$[ebp], 0

; 612  :     HeldGraphChar = 0x20;

  001fb	c6 45 e4 20	 mov	 BYTE PTR _HeldGraphChar$[ebp], 32 ; 00000020H

; 613  : 
; 614  :     nLastBoxPos = 40;

  001ff	c6 45 ef 28	 mov	 BYTE PTR _nLastBoxPos$[ebp], 40 ; 00000028H

; 615  :     nLastUnboxPos = 40;

  00203	c6 45 e7 28	 mov	 BYTE PTR _nLastUnboxPos$[ebp], 40 ; 00000028H

; 616  : 
; 617  :     for(BYTE nCol = 0; nCol < 40; nCol++)

  00207	c6 45 e1 00	 mov	 BYTE PTR _nCol$139808[ebp], 0
  0020b	eb 09		 jmp	 SHORT $LN41@ParseLineE
$LN40@ParseLineE:
  0020d	8a 55 e1	 mov	 dl, BYTE PTR _nCol$139808[ebp]
  00210	80 c2 01	 add	 dl, 1
  00213	88 55 e1	 mov	 BYTE PTR _nCol$139808[ebp], dl
$LN41@ParseLineE:
  00216	0f b6 45 e1	 movzx	 eax, BYTE PTR _nCol$139808[ebp]
  0021a	83 f8 28	 cmp	 eax, 40			; 00000028H
  0021d	0f 8d fa 02 00
	00		 jge	 $LN39@ParseLineE

; 618  :     {
; 619  :         SetAfterModes = 0;

  00223	c6 45 ee 00	 mov	 BYTE PTR _SetAfterModes$[ebp], 0

; 620  :         SetAfterColour = DisplayColour;

  00227	8a 4d e3	 mov	 cl, BYTE PTR _DisplayColour$[ebp]
  0022a	88 4d ff	 mov	 BYTE PTR _SetAfterColour$[ebp], cl

; 621  : 
; 622  :         DisplayChar = pPage->Frame[nRow][nCol] & 0x7F;

  0022d	0f b6 55 0c	 movzx	 edx, BYTE PTR _nRow$[ebp]
  00231	6b d2 28	 imul	 edx, 40			; 00000028H
  00234	8b 45 08	 mov	 eax, DWORD PTR _pPage$[ebp]
  00237	8d 4c 10 06	 lea	 ecx, DWORD PTR [eax+edx+6]
  0023b	0f b6 55 e1	 movzx	 edx, BYTE PTR _nCol$139808[ebp]
  0023f	0f b6 04 11	 movzx	 eax, BYTE PTR [ecx+edx]
  00243	83 e0 7f	 and	 eax, 127		; 0000007fH
  00246	88 45 ed	 mov	 BYTE PTR _DisplayChar$[ebp], al

; 623  : 
; 624  :         // Remember the most recent graphics character
; 625  :         if ((DisplayModes & VTMODE_GRAPHICS) && (DisplayChar & 0x20))

  00249	0f b6 4d e5	 movzx	 ecx, BYTE PTR _DisplayModes$[ebp]
  0024d	83 e1 01	 and	 ecx, 1
  00250	74 19		 je	 SHORT $LN38@ParseLineE
  00252	0f b6 55 ed	 movzx	 edx, BYTE PTR _DisplayChar$[ebp]
  00256	83 e2 20	 and	 edx, 32			; 00000020H
  00259	74 10		 je	 SHORT $LN38@ParseLineE

; 626  :         {
; 627  :             HeldGraphChar = DisplayChar;

  0025b	8a 45 ed	 mov	 al, BYTE PTR _DisplayChar$[ebp]
  0025e	88 45 e4	 mov	 BYTE PTR _HeldGraphChar$[ebp], al

; 628  :             bHeldGraphSeparated = (DisplayModes & VTMODE_SEPARATED);

  00261	0f b6 4d e5	 movzx	 ecx, BYTE PTR _DisplayModes$[ebp]
  00265	83 e1 02	 and	 ecx, 2
  00268	89 4d e8	 mov	 DWORD PTR _bHeldGraphSeparated$[ebp], ecx
$LN38@ParseLineE:

; 629  :         }
; 630  : 
; 631  :         // Check if the character is a control character
; 632  :         if (DisplayChar < 0x20)

  0026b	0f b6 55 ed	 movzx	 edx, BYTE PTR _DisplayChar$[ebp]
  0026f	83 fa 20	 cmp	 edx, 32			; 00000020H
  00272	0f 8d e6 01 00
	00		 jge	 $LN37@ParseLineE

; 633  :         {
; 634  :             switch(DisplayChar)

  00278	0f b6 45 ed	 movzx	 eax, BYTE PTR _DisplayChar$[ebp]
  0027c	89 45 dc	 mov	 DWORD PTR tv212[ebp], eax
  0027f	83 7d dc 1f	 cmp	 DWORD PTR tv212[ebp], 31 ; 0000001fH
  00283	0f 87 93 01 00
	00		 ja	 $LN35@ParseLineE
  00289	8b 4d dc	 mov	 ecx, DWORD PTR tv212[ebp]
  0028c	0f b6 91 00 00
	00 00		 movzx	 edx, BYTE PTR $LN66@ParseLineE[ecx]
  00293	ff 24 95 00 00
	00 00		 jmp	 DWORD PTR $LN68@ParseLineE[edx*4]
$LN34@ParseLineE:

; 635  :             {
; 636  :             case 0x00:  // NUL (reserved) (2.5+: Alpha Black)
; 637  :                 // Workaround to 1.x vs 2.5+ conflict
; 638  :                 if (Background == 0)

  0029a	0f b6 45 e6	 movzx	 eax, BYTE PTR _Background$[ebp]
  0029e	85 c0		 test	 eax, eax
  002a0	75 05		 jne	 SHORT $LN32@ParseLineE

; 639  :                 {
; 640  :                     break;

  002a2	e9 75 01 00 00	 jmp	 $LN35@ParseLineE
$LN32@ParseLineE:

; 641  :                 }
; 642  :             case 0x01:  // Alpha Red
; 643  :             case 0x02:  // Alpha Green
; 644  :             case 0x03:  // Alpha Yellow
; 645  :             case 0x04:  // Alpha Blue
; 646  :             case 0x05:  // Alpha Magenta
; 647  :             case 0x06:  // Alpha Cyan
; 648  :             case 0x07:  // Alpha White
; 649  :                 SetAfterColour = DisplayChar;

  002a7	8a 4d ed	 mov	 cl, BYTE PTR _DisplayChar$[ebp]
  002aa	88 4d ff	 mov	 BYTE PTR _SetAfterColour$[ebp], cl

; 650  :                 SetAfterModes |= (DisplayModes & VTMODE_GRAPHICS);

  002ad	0f b6 55 e5	 movzx	 edx, BYTE PTR _DisplayModes$[ebp]
  002b1	83 e2 01	 and	 edx, 1
  002b4	0f b6 45 ee	 movzx	 eax, BYTE PTR _SetAfterModes$[ebp]
  002b8	0b c2		 or	 eax, edx
  002ba	88 45 ee	 mov	 BYTE PTR _SetAfterModes$[ebp], al

; 651  :                 SetAfterModes |= (DisplayModes & VTMODE_CONCEAL);

  002bd	0f b6 4d e5	 movzx	 ecx, BYTE PTR _DisplayModes$[ebp]
  002c1	83 e1 08	 and	 ecx, 8
  002c4	0f b6 55 ee	 movzx	 edx, BYTE PTR _SetAfterModes$[ebp]
  002c8	0b d1		 or	 edx, ecx
  002ca	88 55 ee	 mov	 BYTE PTR _SetAfterModes$[ebp], dl

; 652  :                 break;

  002cd	e9 4a 01 00 00	 jmp	 $LN35@ParseLineE
$LN31@ParseLineE:

; 653  :             case 0x08:  // Flash
; 654  :                 SetAfterModes |= (DisplayModes & VTMODE_FLASH ^ VTMODE_FLASH);

  002d2	0f b6 45 e5	 movzx	 eax, BYTE PTR _DisplayModes$[ebp]
  002d6	83 e0 04	 and	 eax, 4
  002d9	83 f0 04	 xor	 eax, 4
  002dc	0f b6 4d ee	 movzx	 ecx, BYTE PTR _SetAfterModes$[ebp]
  002e0	0b c8		 or	 ecx, eax
  002e2	88 4d ee	 mov	 BYTE PTR _SetAfterModes$[ebp], cl

; 655  :                 break;

  002e5	e9 32 01 00 00	 jmp	 $LN35@ParseLineE
$LN30@ParseLineE:

; 656  :             case 0x09:  // Steady (immediate)
; 657  :                 DisplayModes &= ~VTMODE_FLASH;

  002ea	0f b6 55 e5	 movzx	 edx, BYTE PTR _DisplayModes$[ebp]
  002ee	83 e2 fb	 and	 edx, -5			; fffffffbH
  002f1	88 55 e5	 mov	 BYTE PTR _DisplayModes$[ebp], dl

; 658  :                 break;

  002f4	e9 23 01 00 00	 jmp	 $LN35@ParseLineE
$LN29@ParseLineE:

; 659  :             case 0x0a:  // Unboxed (immediate on 2nd)
; 660  :                 if (nCol == (nLastUnboxPos + 1))

  002f9	0f b6 45 e1	 movzx	 eax, BYTE PTR _nCol$139808[ebp]
  002fd	0f b6 4d e7	 movzx	 ecx, BYTE PTR _nLastUnboxPos$[ebp]
  00301	83 c1 01	 add	 ecx, 1
  00304	3b c1		 cmp	 eax, ecx
  00306	75 0c		 jne	 SHORT $LN28@ParseLineE

; 661  :                 {
; 662  :                     DisplayModes &= ~VTMODE_BOXED;

  00308	0f b6 55 e5	 movzx	 edx, BYTE PTR _DisplayModes$[ebp]
  0030c	83 e2 ef	 and	 edx, -17		; ffffffefH
  0030f	88 55 e5	 mov	 BYTE PTR _DisplayModes$[ebp], dl

; 663  :                 }
; 664  :                 else

  00312	eb 06		 jmp	 SHORT $LN27@ParseLineE
$LN28@ParseLineE:

; 665  :                 {
; 666  :                     nLastUnboxPos = nCol;

  00314	8a 45 e1	 mov	 al, BYTE PTR _nCol$139808[ebp]
  00317	88 45 e7	 mov	 BYTE PTR _nLastUnboxPos$[ebp], al
$LN27@ParseLineE:

; 667  :                 }
; 668  :                 break;

  0031a	e9 fd 00 00 00	 jmp	 $LN35@ParseLineE
$LN26@ParseLineE:

; 669  :             case 0x0b:  // Boxed (immediate on 2nd)
; 670  :                 if (nCol == (nLastBoxPos + 1))

  0031f	0f b6 4d e1	 movzx	 ecx, BYTE PTR _nCol$139808[ebp]
  00323	0f b6 55 ef	 movzx	 edx, BYTE PTR _nLastBoxPos$[ebp]
  00327	83 c2 01	 add	 edx, 1
  0032a	3b ca		 cmp	 ecx, edx
  0032c	75 0c		 jne	 SHORT $LN25@ParseLineE

; 671  :                 {
; 672  :                     DisplayModes |= VTMODE_BOXED;

  0032e	0f b6 45 e5	 movzx	 eax, BYTE PTR _DisplayModes$[ebp]
  00332	83 c8 10	 or	 eax, 16			; 00000010H
  00335	88 45 e5	 mov	 BYTE PTR _DisplayModes$[ebp], al

; 673  :                 }
; 674  :                 else

  00338	eb 06		 jmp	 SHORT $LN24@ParseLineE
$LN25@ParseLineE:

; 675  :                 {
; 676  :                     nLastBoxPos = nCol;

  0033a	8a 4d e1	 mov	 cl, BYTE PTR _nCol$139808[ebp]
  0033d	88 4d ef	 mov	 BYTE PTR _nLastBoxPos$[ebp], cl
$LN24@ParseLineE:

; 677  :                 }
; 678  :                 break;

  00340	e9 d7 00 00 00	 jmp	 $LN35@ParseLineE
$LN23@ParseLineE:

; 679  :             case 0x0c:  // Normal Height (immediate)
; 680  :                 DisplayModes &= ~VTMODE_DOUBLE;

  00345	0f b6 55 e5	 movzx	 edx, BYTE PTR _DisplayModes$[ebp]
  00349	83 e2 df	 and	 edx, -33		; ffffffdfH
  0034c	88 55 e5	 mov	 BYTE PTR _DisplayModes$[ebp], dl

; 681  :                 break;

  0034f	e9 c8 00 00 00	 jmp	 $LN35@ParseLineE
$LN22@ParseLineE:

; 682  :             case 0x0d:  // Double Height
; 683  :                 // Double on rows 0, 23, 24, 25 not permitted
; 684  :                 if (nRow > 0 && nRow < 23)

  00354	0f b6 45 0c	 movzx	 eax, BYTE PTR _nRow$[ebp]
  00358	85 c0		 test	 eax, eax
  0035a	7e 2d		 jle	 SHORT $LN21@ParseLineE
  0035c	0f b6 4d 0c	 movzx	 ecx, BYTE PTR _nRow$[ebp]
  00360	83 f9 17	 cmp	 ecx, 23			; 00000017H
  00363	7d 24		 jge	 SHORT $LN21@ParseLineE

; 685  :                 {
; 686  :                     *lpFlags |= PARSE_DOUBLEHEIGHT;

  00365	8b 55 10	 mov	 edx, DWORD PTR _lpFlags$[ebp]
  00368	0f b7 02	 movzx	 eax, WORD PTR [edx]
  0036b	0d 00 01 00 00	 or	 eax, 256		; 00000100H
  00370	8b 4d 10	 mov	 ecx, DWORD PTR _lpFlags$[ebp]
  00373	66 89 01	 mov	 WORD PTR [ecx], ax

; 687  :                     SetAfterModes |= (DisplayModes & VTMODE_DOUBLE ^ VTMODE_DOUBLE);

  00376	0f b6 55 e5	 movzx	 edx, BYTE PTR _DisplayModes$[ebp]
  0037a	83 e2 20	 and	 edx, 32			; 00000020H
  0037d	83 f2 20	 xor	 edx, 32			; 00000020H
  00380	0f b6 45 ee	 movzx	 eax, BYTE PTR _SetAfterModes$[ebp]
  00384	0b c2		 or	 eax, edx
  00386	88 45 ee	 mov	 BYTE PTR _SetAfterModes$[ebp], al
$LN21@ParseLineE:

; 688  :                 }
; 689  :                 break;

  00389	e9 8e 00 00 00	 jmp	 $LN35@ParseLineE

; 690  :             case 0x0e:  // Shift Out (reserved)
; 691  :             case 0x0f:  // Shift In (reserved
; 692  :                 break;

  0038e	e9 89 00 00 00	 jmp	 $LN35@ParseLineE
$LN19@ParseLineE:

; 693  :             case 0x10:  // DLE (reserved) (2.5+: Graphics Black)
; 694  :                 // Workaround to 1.x vs 2.5+ conflict
; 695  :                 if (Background == 0)

  00393	0f b6 4d e6	 movzx	 ecx, BYTE PTR _Background$[ebp]
  00397	85 c9		 test	 ecx, ecx
  00399	75 02		 jne	 SHORT $LN17@ParseLineE

; 696  :                 {
; 697  :                     break;

  0039b	eb 7f		 jmp	 SHORT $LN35@ParseLineE
$LN17@ParseLineE:

; 698  :                 }
; 699  :             case 0x11:  // Graphics Red
; 700  :             case 0x12:  // Graphics Green
; 701  :             case 0x13:  // Graphics Yellow
; 702  :             case 0x14:  // Graphics Blue
; 703  :             case 0x15:  // Graphics Magenta
; 704  :             case 0x16:  // Graphics Cyan
; 705  :             case 0x17:  // Graphics White
; 706  :                 SetAfterColour = DisplayChar - 0x10;

  0039d	0f b6 55 ed	 movzx	 edx, BYTE PTR _DisplayChar$[ebp]
  003a1	83 ea 10	 sub	 edx, 16			; 00000010H
  003a4	88 55 ff	 mov	 BYTE PTR _SetAfterColour$[ebp], dl

; 707  :                 SetAfterModes |= (DisplayModes & VTMODE_GRAPHICS ^ VTMODE_GRAPHICS);

  003a7	0f b6 45 e5	 movzx	 eax, BYTE PTR _DisplayModes$[ebp]
  003ab	83 e0 01	 and	 eax, 1
  003ae	83 f0 01	 xor	 eax, 1
  003b1	0f b6 4d ee	 movzx	 ecx, BYTE PTR _SetAfterModes$[ebp]
  003b5	0b c8		 or	 ecx, eax
  003b7	88 4d ee	 mov	 BYTE PTR _SetAfterModes$[ebp], cl

; 708  :                 SetAfterModes |= (DisplayModes & VTMODE_CONCEAL);

  003ba	0f b6 55 e5	 movzx	 edx, BYTE PTR _DisplayModes$[ebp]
  003be	83 e2 08	 and	 edx, 8
  003c1	0f b6 45 ee	 movzx	 eax, BYTE PTR _SetAfterModes$[ebp]
  003c5	0b c2		 or	 eax, edx
  003c7	88 45 ee	 mov	 BYTE PTR _SetAfterModes$[ebp], al

; 709  :                 break;

  003ca	eb 50		 jmp	 SHORT $LN35@ParseLineE
$LN16@ParseLineE:

; 710  :             case 0x18:  // Conceal (immediate)
; 711  :                 DisplayModes |= VTMODE_CONCEAL;

  003cc	0f b6 4d e5	 movzx	 ecx, BYTE PTR _DisplayModes$[ebp]
  003d0	83 c9 08	 or	 ecx, 8
  003d3	88 4d e5	 mov	 BYTE PTR _DisplayModes$[ebp], cl

; 712  :                 break;

  003d6	eb 44		 jmp	 SHORT $LN35@ParseLineE
$LN15@ParseLineE:

; 713  :             case 0x19:  // Contiguous Graphics (either)
; 714  :                 DisplayModes &= ~VTMODE_SEPARATED;

  003d8	0f b6 55 e5	 movzx	 edx, BYTE PTR _DisplayModes$[ebp]
  003dc	83 e2 fd	 and	 edx, -3			; fffffffdH
  003df	88 55 e5	 mov	 BYTE PTR _DisplayModes$[ebp], dl

; 715  :                 break;

  003e2	eb 38		 jmp	 SHORT $LN35@ParseLineE
$LN14@ParseLineE:

; 716  :             case 0x1a:  // Separated Graphics (either)
; 717  :                 DisplayModes |= VTMODE_SEPARATED;

  003e4	0f b6 45 e5	 movzx	 eax, BYTE PTR _DisplayModes$[ebp]
  003e8	83 c8 02	 or	 eax, 2
  003eb	88 45 e5	 mov	 BYTE PTR _DisplayModes$[ebp], al

; 718  :                 break;

  003ee	eb 2c		 jmp	 SHORT $LN35@ParseLineE

; 719  :             case 0x1b:  // ESC (reserved)
; 720  :                 break;

  003f0	eb 2a		 jmp	 SHORT $LN35@ParseLineE
$LN12@ParseLineE:

; 721  :             case 0x1c:  // Black Background (immediate)
; 722  :                 Background = VTCOLOR_BLACK;

  003f2	c6 45 e6 00	 mov	 BYTE PTR _Background$[ebp], 0

; 723  :                 break;

  003f6	eb 24		 jmp	 SHORT $LN35@ParseLineE
$LN11@ParseLineE:

; 724  :             case 0x1d:  // New Background (immediate)
; 725  :                 Background = DisplayColour;

  003f8	8a 4d e3	 mov	 cl, BYTE PTR _DisplayColour$[ebp]
  003fb	88 4d e6	 mov	 BYTE PTR _Background$[ebp], cl

; 726  :                 break;

  003fe	eb 1c		 jmp	 SHORT $LN35@ParseLineE
$LN10@ParseLineE:

; 727  :             case 0x1e:  // Hold Graphics (immediate)
; 728  :                 DisplayModes |= VTMODE_HOLD;

  00400	0f b6 55 e5	 movzx	 edx, BYTE PTR _DisplayModes$[ebp]
  00404	83 ca 40	 or	 edx, 64			; 00000040H
  00407	88 55 e5	 mov	 BYTE PTR _DisplayModes$[ebp], dl

; 729  :                 break;

  0040a	eb 10		 jmp	 SHORT $LN35@ParseLineE
$LN9@ParseLineE:

; 730  :             case 0x1f:  // Release Graphics
; 731  :                 SetAfterModes |= (DisplayModes & VTMODE_HOLD);

  0040c	0f b6 45 e5	 movzx	 eax, BYTE PTR _DisplayModes$[ebp]
  00410	83 e0 40	 and	 eax, 64			; 00000040H
  00413	0f b6 4d ee	 movzx	 ecx, BYTE PTR _SetAfterModes$[ebp]
  00417	0b c8		 or	 ecx, eax
  00419	88 4d ee	 mov	 BYTE PTR _SetAfterModes$[ebp], cl
$LN35@ParseLineE:

; 732  :                 break;
; 733  :             }
; 734  : 
; 735  :             DisplayChar = 0x20;

  0041c	c6 45 ed 20	 mov	 BYTE PTR _DisplayChar$[ebp], 32 ; 00000020H

; 736  : 
; 737  :             if ((DisplayModes & VTMODE_HOLD) != 0)

  00420	0f b6 55 e5	 movzx	 edx, BYTE PTR _DisplayModes$[ebp]
  00424	83 e2 40	 and	 edx, 64			; 00000040H
  00427	74 35		 je	 SHORT $LN37@ParseLineE

; 738  :             {
; 739  :                 DisplayChar = HeldGraphChar;

  00429	8a 45 e4	 mov	 al, BYTE PTR _HeldGraphChar$[ebp]
  0042c	88 45 ed	 mov	 BYTE PTR _DisplayChar$[ebp], al

; 740  :                 if (!bHeldGraphSeparated != !(DisplayModes & VTMODE_SEPARATED))

  0042f	33 c9		 xor	 ecx, ecx
  00431	83 7d e8 00	 cmp	 DWORD PTR _bHeldGraphSeparated$[ebp], 0
  00435	0f 94 c1	 sete	 cl
  00438	0f b6 55 e5	 movzx	 edx, BYTE PTR _DisplayModes$[ebp]
  0043c	83 e2 02	 and	 edx, 2
  0043f	f7 da		 neg	 edx
  00441	1b d2		 sbb	 edx, edx
  00443	83 c2 01	 add	 edx, 1
  00446	3b ca		 cmp	 ecx, edx
  00448	74 14		 je	 SHORT $LN37@ParseLineE

; 741  :                 {
; 742  :                     DisplayModes ^= VTMODE_SEPARATED;

  0044a	0f b6 45 e5	 movzx	 eax, BYTE PTR _DisplayModes$[ebp]
  0044e	83 f0 02	 xor	 eax, 2
  00451	88 45 e5	 mov	 BYTE PTR _DisplayModes$[ebp], al

; 743  :                     SetAfterModes ^= VTMODE_SEPARATED;

  00454	0f b6 4d ee	 movzx	 ecx, BYTE PTR _SetAfterModes$[ebp]
  00458	83 f1 02	 xor	 ecx, 2
  0045b	88 4d ee	 mov	 BYTE PTR _SetAfterModes$[ebp], cl
$LN37@ParseLineE:

; 744  :                 }
; 745  :             }
; 746  :         }
; 747  : 
; 748  :         if ((bBoxedElementsOnly != FALSE) && !(DisplayModes & VTMODE_BOXED))

  0045e	83 7d f8 00	 cmp	 DWORD PTR _bBoxedElementsOnly$[ebp], 0
  00462	74 17		 je	 SHORT $LN6@ParseLineE
  00464	0f b6 55 e5	 movzx	 edx, BYTE PTR _DisplayModes$[ebp]
  00468	83 e2 10	 and	 edx, 16			; 00000010H
  0046b	75 0e		 jne	 SHORT $LN6@ParseLineE

; 749  :         {
; 750  :             DisplayChar = 0x20;

  0046d	c6 45 ed 20	 mov	 BYTE PTR _DisplayChar$[ebp], 32 ; 00000020H

; 751  :             DisplayColour = VTCOLOR_NONE;

  00471	c6 45 e3 08	 mov	 BYTE PTR _DisplayColour$[ebp], 8

; 752  :             DisplayBkColour = VTCOLOR_NONE;

  00475	c6 45 f6 08	 mov	 BYTE PTR _DisplayBkColour$[ebp], 8

; 753  :         }
; 754  :         else

  00479	eb 06		 jmp	 SHORT $LN5@ParseLineE
$LN6@ParseLineE:

; 755  :         {
; 756  :             DisplayBkColour = Background;

  0047b	8a 45 e6	 mov	 al, BYTE PTR _Background$[ebp]
  0047e	88 45 f6	 mov	 BYTE PTR _DisplayBkColour$[ebp], al
$LN5@ParseLineE:

; 757  :         }
; 758  : 
; 759  :         // Call the callback function
; 760  :         uResult = (fnParseProc)(pPage, MAKEWORD(DisplayRow, nCol), lpFlags,
; 761  :                                 MAKEWORD(DisplayColour, DisplayBkColour),
; 762  :                                 DisplayChar, DisplayModes, lpParam);

  00481	8b 4d 18	 mov	 ecx, DWORD PTR _lpParam$[ebp]
  00484	51		 push	 ecx
  00485	0f b6 55 e5	 movzx	 edx, BYTE PTR _DisplayModes$[ebp]
  00489	52		 push	 edx
  0048a	0f b6 45 ed	 movzx	 eax, BYTE PTR _DisplayChar$[ebp]
  0048e	50		 push	 eax
  0048f	0f b6 4d e3	 movzx	 ecx, BYTE PTR _DisplayColour$[ebp]
  00493	81 e1 ff 00 00
	00		 and	 ecx, 255		; 000000ffH
  00499	0f b6 d1	 movzx	 edx, cl
  0049c	0f b6 45 f6	 movzx	 eax, BYTE PTR _DisplayBkColour$[ebp]
  004a0	25 ff 00 00 00	 and	 eax, 255		; 000000ffH
  004a5	0f b6 c8	 movzx	 ecx, al
  004a8	c1 e1 08	 shl	 ecx, 8
  004ab	0b d1		 or	 edx, ecx
  004ad	52		 push	 edx
  004ae	8b 55 10	 mov	 edx, DWORD PTR _lpFlags$[ebp]
  004b1	52		 push	 edx
  004b2	0f b6 45 f7	 movzx	 eax, BYTE PTR _DisplayRow$[ebp]
  004b6	25 ff 00 00 00	 and	 eax, 255		; 000000ffH
  004bb	0f b6 c8	 movzx	 ecx, al
  004be	0f b6 55 e1	 movzx	 edx, BYTE PTR _nCol$139808[ebp]
  004c2	81 e2 ff 00 00
	00		 and	 edx, 255		; 000000ffH
  004c8	0f b6 c2	 movzx	 eax, dl
  004cb	c1 e0 08	 shl	 eax, 8
  004ce	0b c8		 or	 ecx, eax
  004d0	51		 push	 ecx
  004d1	8b 4d 08	 mov	 ecx, DWORD PTR _pPage$[ebp]
  004d4	51		 push	 ecx
  004d5	ff 55 14	 call	 DWORD PTR _fnParseProc$[ebp]
  004d8	83 c4 1c	 add	 esp, 28			; 0000001cH
  004db	0f b6 d0	 movzx	 edx, al
  004de	89 55 f0	 mov	 DWORD PTR _uResult$[ebp], edx

; 763  : 
; 764  :         if (uResult == PARSE_STOPLINE || uResult == PARSE_STOPPAGE)

  004e1	83 7d f0 01	 cmp	 DWORD PTR _uResult$[ebp], 1
  004e5	74 06		 je	 SHORT $LN3@ParseLineE
  004e7	83 7d f0 02	 cmp	 DWORD PTR _uResult$[ebp], 2
  004eb	75 02		 jne	 SHORT $LN4@ParseLineE
$LN3@ParseLineE:

; 765  :         {
; 766  :             break;

  004ed	eb 2e		 jmp	 SHORT $LN39@ParseLineE
$LN4@ParseLineE:

; 767  :         }
; 768  : 
; 769  :         DisplayModes ^= SetAfterModes;

  004ef	0f b6 45 ee	 movzx	 eax, BYTE PTR _SetAfterModes$[ebp]
  004f3	0f b6 4d e5	 movzx	 ecx, BYTE PTR _DisplayModes$[ebp]
  004f7	33 c8		 xor	 ecx, eax
  004f9	88 4d e5	 mov	 BYTE PTR _DisplayModes$[ebp], cl

; 770  :         DisplayColour = SetAfterColour;

  004fc	8a 55 ff	 mov	 dl, BYTE PTR _SetAfterColour$[ebp]
  004ff	88 55 e3	 mov	 BYTE PTR _DisplayColour$[ebp], dl

; 771  : 
; 772  :         // Forget the last graph character if one of these changed
; 773  :         if (SetAfterModes & VTMODE_GRAPHICS || SetAfterModes & VTMODE_DOUBLE)

  00502	0f b6 45 ee	 movzx	 eax, BYTE PTR _SetAfterModes$[ebp]
  00506	83 e0 01	 and	 eax, 1
  00509	75 09		 jne	 SHORT $LN1@ParseLineE
  0050b	0f b6 4d ee	 movzx	 ecx, BYTE PTR _SetAfterModes$[ebp]
  0050f	83 e1 20	 and	 ecx, 32			; 00000020H
  00512	74 04		 je	 SHORT $LN2@ParseLineE
$LN1@ParseLineE:

; 774  :         {
; 775  :             HeldGraphChar = 0x20;

  00514	c6 45 e4 20	 mov	 BYTE PTR _HeldGraphChar$[ebp], 32 ; 00000020H
$LN2@ParseLineE:

; 776  :         }
; 777  :     }

  00518	e9 f0 fc ff ff	 jmp	 $LN40@ParseLineE
$LN39@ParseLineE:

; 778  :     return (BYTE)uResult;

  0051d	8a 45 f0	 mov	 al, BYTE PTR _uResult$[ebp]
$LN64@ParseLineE:

; 779  : }

  00520	8b e5		 mov	 esp, ebp
  00522	5d		 pop	 ebp
  00523	c3		 ret	 0
$LN68@ParseLineE:
  00524	00 00 00 00	 DD	 $LN34@ParseLineE
  00528	00 00 00 00	 DD	 $LN32@ParseLineE
  0052c	00 00 00 00	 DD	 $LN31@ParseLineE
  00530	00 00 00 00	 DD	 $LN30@ParseLineE
  00534	00 00 00 00	 DD	 $LN29@ParseLineE
  00538	00 00 00 00	 DD	 $LN26@ParseLineE
  0053c	00 00 00 00	 DD	 $LN23@ParseLineE
  00540	00 00 00 00	 DD	 $LN22@ParseLineE
  00544	00 00 00 00	 DD	 $LN19@ParseLineE
  00548	00 00 00 00	 DD	 $LN17@ParseLineE
  0054c	00 00 00 00	 DD	 $LN16@ParseLineE
  00550	00 00 00 00	 DD	 $LN15@ParseLineE
  00554	00 00 00 00	 DD	 $LN14@ParseLineE
  00558	00 00 00 00	 DD	 $LN12@ParseLineE
  0055c	00 00 00 00	 DD	 $LN11@ParseLineE
  00560	00 00 00 00	 DD	 $LN10@ParseLineE
  00564	00 00 00 00	 DD	 $LN9@ParseLineE
  00568	00 00 00 00	 DD	 $LN35@ParseLineE
$LN66@ParseLineE:
  0056c	00		 DB	 0
  0056d	01		 DB	 1
  0056e	01		 DB	 1
  0056f	01		 DB	 1
  00570	01		 DB	 1
  00571	01		 DB	 1
  00572	01		 DB	 1
  00573	01		 DB	 1
  00574	02		 DB	 2
  00575	03		 DB	 3
  00576	04		 DB	 4
  00577	05		 DB	 5
  00578	06		 DB	 6
  00579	07		 DB	 7
  0057a	11		 DB	 17			; 00000011H
  0057b	11		 DB	 17			; 00000011H
  0057c	08		 DB	 8
  0057d	09		 DB	 9
  0057e	09		 DB	 9
  0057f	09		 DB	 9
  00580	09		 DB	 9
  00581	09		 DB	 9
  00582	09		 DB	 9
  00583	09		 DB	 9
  00584	0a		 DB	 10			; 0000000aH
  00585	0b		 DB	 11			; 0000000bH
  00586	0c		 DB	 12			; 0000000cH
  00587	11		 DB	 17			; 00000011H
  00588	0d		 DB	 13			; 0000000dH
  00589	0e		 DB	 14			; 0000000eH
  0058a	0f		 DB	 15			; 0000000fH
  0058b	10		 DB	 16			; 00000010H
?ParseLineElements@CVTCommon@@SAEPAU_VTPage@@EPAGP6AE0G1GEEPAX@Z2@Z ENDP ; CVTCommon::ParseLineElements
_TEXT	ENDS
PUBLIC	?ParsePageElements@CVTCommon@@SAEPAU_VTPage@@PAGP6AE0G1GEEPAX@Z2@Z ; CVTCommon::ParsePageElements
; Function compile flags: /Odtp
;	COMDAT ?ParsePageElements@CVTCommon@@SAEPAU_VTPage@@PAGP6AE0G1GEEPAX@Z2@Z
_TEXT	SEGMENT
_nRow$139752 = -13					; size = 1
_wFlags$ = -12						; size = 2
_LastRow$ = -5						; size = 1
_uResult$ = -4						; size = 4
_pPage$ = 8						; size = 4
_lpFlags$ = 12						; size = 4
_fnParseProc$ = 16					; size = 4
_lpParam$ = 20						; size = 4
?ParsePageElements@CVTCommon@@SAEPAU_VTPage@@PAGP6AE0G1GEEPAX@Z2@Z PROC ; CVTCommon::ParsePageElements, COMDAT

; 437  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 10	 sub	 esp, 16			; 00000010H

; 438  :     BYTE LastRow;
; 439  :     LONG uResult = PARSE_CONTINUE;

  00006	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR _uResult$[ebp], 0

; 440  :     WORD wFlags = *lpFlags;

  0000d	8b 45 0c	 mov	 eax, DWORD PTR _lpFlags$[ebp]
  00010	66 8b 08	 mov	 cx, WORD PTR [eax]
  00013	66 89 4d f4	 mov	 WORD PTR _wFlags$[ebp], cx

; 441  : 
; 442  :     if ((*lpFlags & PARSE_ALSOKEYWORDS) != 0)

  00017	8b 55 0c	 mov	 edx, DWORD PTR _lpFlags$[ebp]
  0001a	0f b7 02	 movzx	 eax, WORD PTR [edx]
  0001d	83 e0 10	 and	 eax, 16			; 00000010H
  00020	74 06		 je	 SHORT $LN10@ParsePageE

; 443  :     {
; 444  :         LastRow = 25;

  00022	c6 45 fb 19	 mov	 BYTE PTR _LastRow$[ebp], 25 ; 00000019H

; 445  :     }
; 446  :     else

  00026	eb 04		 jmp	 SHORT $LN9@ParsePageE
$LN10@ParsePageE:

; 447  :     {
; 448  :         LastRow = 24;

  00028	c6 45 fb 18	 mov	 BYTE PTR _LastRow$[ebp], 24 ; 00000018H
$LN9@ParsePageE:

; 449  :     }
; 450  : 
; 451  :     *lpFlags &= ~(PARSE_DOUBLEHEIGHT | PARSE_DOUBLEREPEAT);

  0002c	8b 4d 0c	 mov	 ecx, DWORD PTR _lpFlags$[ebp]
  0002f	0f b7 11	 movzx	 edx, WORD PTR [ecx]
  00032	81 e2 bf fe ff
	ff		 and	 edx, -321		; fffffebfH
  00038	8b 45 0c	 mov	 eax, DWORD PTR _lpFlags$[ebp]
  0003b	66 89 10	 mov	 WORD PTR [eax], dx

; 452  : 
; 453  :     // Loop through the rows
; 454  :     for (BYTE nRow = 0; nRow <= LastRow; nRow++)

  0003e	c6 45 f3 00	 mov	 BYTE PTR _nRow$139752[ebp], 0
  00042	eb 09		 jmp	 SHORT $LN8@ParsePageE
$LN7@ParsePageE:
  00044	8a 4d f3	 mov	 cl, BYTE PTR _nRow$139752[ebp]
  00047	80 c1 01	 add	 cl, 1
  0004a	88 4d f3	 mov	 BYTE PTR _nRow$139752[ebp], cl
$LN8@ParsePageE:
  0004d	0f b6 55 f3	 movzx	 edx, BYTE PTR _nRow$139752[ebp]
  00051	0f b6 45 fb	 movzx	 eax, BYTE PTR _LastRow$[ebp]
  00055	3b d0		 cmp	 edx, eax
  00057	0f 8f cb 00 00
	00		 jg	 $LN6@ParsePageE

; 455  :     {
; 456  :         wFlags = *lpFlags | PARSE_SKIPDOUBLECHECK;

  0005d	8b 4d 0c	 mov	 ecx, DWORD PTR _lpFlags$[ebp]
  00060	0f b7 11	 movzx	 edx, WORD PTR [ecx]
  00063	83 ca 20	 or	 edx, 32			; 00000020H
  00066	66 89 55 f4	 mov	 WORD PTR _wFlags$[ebp], dx

; 457  : 
; 458  :         // Call the line elements parser
; 459  :         if ((uResult = ParseLineElements(pPage, nRow, &wFlags,
; 460  :             fnParseProc, lpParam)) == PARSE_STOPPAGE)

  0006a	8b 45 14	 mov	 eax, DWORD PTR _lpParam$[ebp]
  0006d	50		 push	 eax
  0006e	8b 4d 10	 mov	 ecx, DWORD PTR _fnParseProc$[ebp]
  00071	51		 push	 ecx
  00072	8d 55 f4	 lea	 edx, DWORD PTR _wFlags$[ebp]
  00075	52		 push	 edx
  00076	0f b6 45 f3	 movzx	 eax, BYTE PTR _nRow$139752[ebp]
  0007a	50		 push	 eax
  0007b	8b 4d 08	 mov	 ecx, DWORD PTR _pPage$[ebp]
  0007e	51		 push	 ecx
  0007f	e8 00 00 00 00	 call	 ?ParseLineElements@CVTCommon@@SAEPAU_VTPage@@EPAGP6AE0G1GEEPAX@Z2@Z ; CVTCommon::ParseLineElements
  00084	83 c4 14	 add	 esp, 20			; 00000014H
  00087	0f b6 d0	 movzx	 edx, al
  0008a	89 55 fc	 mov	 DWORD PTR _uResult$[ebp], edx
  0008d	83 7d fc 02	 cmp	 DWORD PTR _uResult$[ebp], 2
  00091	75 05		 jne	 SHORT $LN5@ParsePageE

; 461  :         {
; 462  :             break;

  00093	e9 90 00 00 00	 jmp	 $LN6@ParsePageE
$LN5@ParsePageE:

; 463  :         }
; 464  : 
; 465  :         if (uResult == PARSE_NOTUPDATED)

  00098	83 7d fc 08	 cmp	 DWORD PTR _uResult$[ebp], 8
  0009c	75 35		 jne	 SHORT $LN4@ParsePageE

; 466  :         {
; 467  :             // The line was not updated so the necessary double
; 468  :             // check was not performed.  Do it here.
; 469  :             if (nRow >= 1 && nRow < 23 && HasDoubleElement(pPage, nRow))

  0009e	0f b6 45 f3	 movzx	 eax, BYTE PTR _nRow$139752[ebp]
  000a2	83 f8 01	 cmp	 eax, 1
  000a5	7c 2c		 jl	 SHORT $LN4@ParsePageE
  000a7	0f b6 4d f3	 movzx	 ecx, BYTE PTR _nRow$139752[ebp]
  000ab	83 f9 17	 cmp	 ecx, 23			; 00000017H
  000ae	7d 23		 jge	 SHORT $LN4@ParsePageE
  000b0	0f b6 55 f3	 movzx	 edx, BYTE PTR _nRow$139752[ebp]
  000b4	52		 push	 edx
  000b5	8b 45 08	 mov	 eax, DWORD PTR _pPage$[ebp]
  000b8	50		 push	 eax
  000b9	e8 00 00 00 00	 call	 ?HasDoubleElement@CVTCommon@@SAHPAU_VTPage@@E@Z ; CVTCommon::HasDoubleElement
  000be	83 c4 08	 add	 esp, 8
  000c1	85 c0		 test	 eax, eax
  000c3	74 0e		 je	 SHORT $LN4@ParsePageE

; 470  :             {
; 471  :                 wFlags |= PARSE_DOUBLEHEIGHT;

  000c5	0f b7 4d f4	 movzx	 ecx, WORD PTR _wFlags$[ebp]
  000c9	81 c9 00 01 00
	00		 or	 ecx, 256		; 00000100H
  000cf	66 89 4d f4	 mov	 WORD PTR _wFlags$[ebp], cx
$LN4@ParsePageE:

; 472  :             }
; 473  :         }
; 474  : 
; 475  :         if ((wFlags & PARSE_DOUBLEHEIGHT) != 0)

  000d3	0f b7 55 f4	 movzx	 edx, WORD PTR _wFlags$[ebp]
  000d7	81 e2 00 01 00
	00		 and	 edx, 256		; 00000100H
  000dd	74 44		 je	 SHORT $LN2@ParsePageE

; 476  :         {
; 477  :             wFlags = *lpFlags | PARSE_DOUBLEREPEAT | PARSE_SKIPDOUBLECHECK;

  000df	8b 45 0c	 mov	 eax, DWORD PTR _lpFlags$[ebp]
  000e2	0f b7 08	 movzx	 ecx, WORD PTR [eax]
  000e5	83 c9 40	 or	 ecx, 64			; 00000040H
  000e8	83 c9 20	 or	 ecx, 32			; 00000020H
  000eb	66 89 4d f4	 mov	 WORD PTR _wFlags$[ebp], cx

; 478  : 
; 479  :             // Call the line parser again for the repeat
; 480  :             if ((uResult = ParseLineElements(pPage, nRow, &wFlags,
; 481  :                 fnParseProc, lpParam)) == PARSE_STOPPAGE)

  000ef	8b 55 14	 mov	 edx, DWORD PTR _lpParam$[ebp]
  000f2	52		 push	 edx
  000f3	8b 45 10	 mov	 eax, DWORD PTR _fnParseProc$[ebp]
  000f6	50		 push	 eax
  000f7	8d 4d f4	 lea	 ecx, DWORD PTR _wFlags$[ebp]
  000fa	51		 push	 ecx
  000fb	0f b6 55 f3	 movzx	 edx, BYTE PTR _nRow$139752[ebp]
  000ff	52		 push	 edx
  00100	8b 45 08	 mov	 eax, DWORD PTR _pPage$[ebp]
  00103	50		 push	 eax
  00104	e8 00 00 00 00	 call	 ?ParseLineElements@CVTCommon@@SAEPAU_VTPage@@EPAGP6AE0G1GEEPAX@Z2@Z ; CVTCommon::ParseLineElements
  00109	83 c4 14	 add	 esp, 20			; 00000014H
  0010c	0f b6 c8	 movzx	 ecx, al
  0010f	89 4d fc	 mov	 DWORD PTR _uResult$[ebp], ecx
  00112	83 7d fc 02	 cmp	 DWORD PTR _uResult$[ebp], 2
  00116	75 02		 jne	 SHORT $LN1@ParsePageE

; 482  :             {
; 483  :                 break;

  00118	eb 0e		 jmp	 SHORT $LN6@ParsePageE
$LN1@ParsePageE:

; 484  :             }
; 485  :             nRow++;

  0011a	8a 55 f3	 mov	 dl, BYTE PTR _nRow$139752[ebp]
  0011d	80 c2 01	 add	 dl, 1
  00120	88 55 f3	 mov	 BYTE PTR _nRow$139752[ebp], dl
$LN2@ParsePageE:

; 486  :         }
; 487  :     }

  00123	e9 1c ff ff ff	 jmp	 $LN7@ParsePageE
$LN6@ParsePageE:

; 488  : 
; 489  :     *lpFlags = wFlags;

  00128	8b 45 0c	 mov	 eax, DWORD PTR _lpFlags$[ebp]
  0012b	66 8b 4d f4	 mov	 cx, WORD PTR _wFlags$[ebp]
  0012f	66 89 08	 mov	 WORD PTR [eax], cx

; 490  : 
; 491  :     return (BYTE)uResult;

  00132	8a 45 fc	 mov	 al, BYTE PTR _uResult$[ebp]

; 492  : }

  00135	8b e5		 mov	 esp, ebp
  00137	5d		 pop	 ebp
  00138	c3		 ret	 0
?ParsePageElements@CVTCommon@@SAEPAU_VTPage@@PAGP6AE0G1GEEPAX@Z2@Z ENDP ; CVTCommon::ParsePageElements
_TEXT	ENDS
PUBLIC	?HasFlashElement@CVTCommon@@SAHPAU_VTPage@@@Z	; CVTCommon::HasFlashElement
; Function compile flags: /Odtp
;	COMDAT ?HasFlashElement@CVTCommon@@SAHPAU_VTPage@@@Z
_TEXT	SEGMENT
_wFlags$ = -4						; size = 2
_pPage$ = 8						; size = 4
?HasFlashElement@CVTCommon@@SAHPAU_VTPage@@@Z PROC	; CVTCommon::HasFlashElement, COMDAT

; 339  : {

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

; 340  :     WORD wFlags = PARSE_HASDATAONLY;

  00004	b8 01 00 00 00	 mov	 eax, 1
  00009	66 89 45 fc	 mov	 WORD PTR _wFlags$[ebp], ax

; 341  : 
; 342  :     return ParsePageElements(pPage, &wFlags,
; 343  :         (TParserCallback*)HasFlashElementProc, NULL) == PARSE_STOPPAGE;

  0000d	6a 00		 push	 0
  0000f	68 00 00 00 00	 push	 OFFSET ?HasFlashElementProc@CVTCommon@@CAEPAU_VTPage@@GPAGGEEPAX@Z ; CVTCommon::HasFlashElementProc
  00014	8d 4d fc	 lea	 ecx, DWORD PTR _wFlags$[ebp]
  00017	51		 push	 ecx
  00018	8b 55 08	 mov	 edx, DWORD PTR _pPage$[ebp]
  0001b	52		 push	 edx
  0001c	e8 00 00 00 00	 call	 ?ParsePageElements@CVTCommon@@SAEPAU_VTPage@@PAGP6AE0G1GEEPAX@Z2@Z ; CVTCommon::ParsePageElements
  00021	83 c4 10	 add	 esp, 16			; 00000010H
  00024	0f b6 c0	 movzx	 eax, al
  00027	33 c9		 xor	 ecx, ecx
  00029	83 f8 02	 cmp	 eax, 2
  0002c	0f 94 c1	 sete	 cl
  0002f	8b c1		 mov	 eax, ecx

; 344  : }

  00031	8b e5		 mov	 esp, ebp
  00033	5d		 pop	 ebp
  00034	c3		 ret	 0
?HasFlashElement@CVTCommon@@SAHPAU_VTPage@@@Z ENDP	; CVTCommon::HasFlashElement
_TEXT	ENDS
PUBLIC	?Unham2418@CVTCommon@@SAKQAEPAH@Z		; CVTCommon::Unham2418
; Function compile flags: /Odtp
;	COMDAT ?Unham2418@CVTCommon@@SAKQAEPAH@Z
_TEXT	SEGMENT
tv224 = -16						; size = 4
_b1$ = -9						; size = 1
_Data$ = -8						; size = 4
_Syndrome$ = -3						; size = 1
_b3$ = -2						; size = 1
_b2$ = -1						; size = 1
_Byte$ = 8						; size = 4
_Error$ = 12						; size = 4
?Unham2418@CVTCommon@@SAKQAEPAH@Z PROC			; CVTCommon::Unham2418, COMDAT

; 164  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 10	 sub	 esp, 16			; 00000010H
  00006	56		 push	 esi

; 165  :     BYTE b1, b2, b3;
; 166  :     BYTE Syndrome = 0;

  00007	c6 45 fd 00	 mov	 BYTE PTR _Syndrome$[ebp], 0

; 167  :     DWORD Data = 0UL;

  0000b	c7 45 f8 00 00
	00 00		 mov	 DWORD PTR _Data$[ebp], 0

; 168  : 
; 169  :     b1 = Byte[0];

  00012	8b 45 08	 mov	 eax, DWORD PTR _Byte$[ebp]
  00015	8a 08		 mov	 cl, BYTE PTR [eax]
  00017	88 4d f7	 mov	 BYTE PTR _b1$[ebp], cl

; 170  :     b2 = Byte[1];

  0001a	8b 55 08	 mov	 edx, DWORD PTR _Byte$[ebp]
  0001d	8a 42 01	 mov	 al, BYTE PTR [edx+1]
  00020	88 45 ff	 mov	 BYTE PTR _b2$[ebp], al

; 171  :     b3 = Byte[2];

  00023	8b 4d 08	 mov	 ecx, DWORD PTR _Byte$[ebp]
  00026	8a 51 02	 mov	 dl, BYTE PTR [ecx+2]
  00029	88 55 fe	 mov	 BYTE PTR _b3$[ebp], dl

; 172  : 
; 173  :     Syndrome += (Parity(b1 & 0x55) ^ Parity(b2 & 0x55) ^ Parity(b3 & 0x55)) * 0x01;

  0002c	0f b6 45 f7	 movzx	 eax, BYTE PTR _b1$[ebp]
  00030	83 e0 55	 and	 eax, 85			; 00000055H
  00033	50		 push	 eax
  00034	e8 00 00 00 00	 call	 ?Parity@CVTCommon@@CAEE@Z ; CVTCommon::Parity
  00039	83 c4 04	 add	 esp, 4
  0003c	0f b6 f0	 movzx	 esi, al
  0003f	0f b6 4d ff	 movzx	 ecx, BYTE PTR _b2$[ebp]
  00043	83 e1 55	 and	 ecx, 85			; 00000055H
  00046	51		 push	 ecx
  00047	e8 00 00 00 00	 call	 ?Parity@CVTCommon@@CAEE@Z ; CVTCommon::Parity
  0004c	83 c4 04	 add	 esp, 4
  0004f	0f b6 d0	 movzx	 edx, al
  00052	33 f2		 xor	 esi, edx
  00054	0f b6 45 fe	 movzx	 eax, BYTE PTR _b3$[ebp]
  00058	83 e0 55	 and	 eax, 85			; 00000055H
  0005b	50		 push	 eax
  0005c	e8 00 00 00 00	 call	 ?Parity@CVTCommon@@CAEE@Z ; CVTCommon::Parity
  00061	83 c4 04	 add	 esp, 4
  00064	0f b6 c8	 movzx	 ecx, al
  00067	33 f1		 xor	 esi, ecx
  00069	0f b6 55 fd	 movzx	 edx, BYTE PTR _Syndrome$[ebp]
  0006d	03 d6		 add	 edx, esi
  0006f	88 55 fd	 mov	 BYTE PTR _Syndrome$[ebp], dl

; 174  :     Syndrome += (Parity(b1 & 0x66) ^ Parity(b2 & 0x66) ^ Parity(b3 & 0x66)) * 0x02;

  00072	0f b6 45 f7	 movzx	 eax, BYTE PTR _b1$[ebp]
  00076	83 e0 66	 and	 eax, 102		; 00000066H
  00079	50		 push	 eax
  0007a	e8 00 00 00 00	 call	 ?Parity@CVTCommon@@CAEE@Z ; CVTCommon::Parity
  0007f	83 c4 04	 add	 esp, 4
  00082	0f b6 f0	 movzx	 esi, al
  00085	0f b6 4d ff	 movzx	 ecx, BYTE PTR _b2$[ebp]
  00089	83 e1 66	 and	 ecx, 102		; 00000066H
  0008c	51		 push	 ecx
  0008d	e8 00 00 00 00	 call	 ?Parity@CVTCommon@@CAEE@Z ; CVTCommon::Parity
  00092	83 c4 04	 add	 esp, 4
  00095	0f b6 d0	 movzx	 edx, al
  00098	33 f2		 xor	 esi, edx
  0009a	0f b6 45 fe	 movzx	 eax, BYTE PTR _b3$[ebp]
  0009e	83 e0 66	 and	 eax, 102		; 00000066H
  000a1	50		 push	 eax
  000a2	e8 00 00 00 00	 call	 ?Parity@CVTCommon@@CAEE@Z ; CVTCommon::Parity
  000a7	83 c4 04	 add	 esp, 4
  000aa	0f b6 c8	 movzx	 ecx, al
  000ad	33 f1		 xor	 esi, ecx
  000af	0f b6 55 fd	 movzx	 edx, BYTE PTR _Syndrome$[ebp]
  000b3	8d 04 72	 lea	 eax, DWORD PTR [edx+esi*2]
  000b6	88 45 fd	 mov	 BYTE PTR _Syndrome$[ebp], al

; 175  :     Syndrome += (Parity(b1 & 0x78) ^ Parity(b2 & 0x78) ^ Parity(b3 & 0x78)) * 0x04;

  000b9	0f b6 4d f7	 movzx	 ecx, BYTE PTR _b1$[ebp]
  000bd	83 e1 78	 and	 ecx, 120		; 00000078H
  000c0	51		 push	 ecx
  000c1	e8 00 00 00 00	 call	 ?Parity@CVTCommon@@CAEE@Z ; CVTCommon::Parity
  000c6	83 c4 04	 add	 esp, 4
  000c9	0f b6 f0	 movzx	 esi, al
  000cc	0f b6 55 ff	 movzx	 edx, BYTE PTR _b2$[ebp]
  000d0	83 e2 78	 and	 edx, 120		; 00000078H
  000d3	52		 push	 edx
  000d4	e8 00 00 00 00	 call	 ?Parity@CVTCommon@@CAEE@Z ; CVTCommon::Parity
  000d9	83 c4 04	 add	 esp, 4
  000dc	0f b6 c0	 movzx	 eax, al
  000df	33 f0		 xor	 esi, eax
  000e1	0f b6 4d fe	 movzx	 ecx, BYTE PTR _b3$[ebp]
  000e5	83 e1 78	 and	 ecx, 120		; 00000078H
  000e8	51		 push	 ecx
  000e9	e8 00 00 00 00	 call	 ?Parity@CVTCommon@@CAEE@Z ; CVTCommon::Parity
  000ee	83 c4 04	 add	 esp, 4
  000f1	0f b6 d0	 movzx	 edx, al
  000f4	33 f2		 xor	 esi, edx
  000f6	0f b6 45 fd	 movzx	 eax, BYTE PTR _Syndrome$[ebp]
  000fa	8d 0c b0	 lea	 ecx, DWORD PTR [eax+esi*4]
  000fd	88 4d fd	 mov	 BYTE PTR _Syndrome$[ebp], cl

; 176  :     Syndrome += (Parity(b1 & 0x80) ^ Parity(b2 & 0x7F)) * 0x08;

  00100	0f b6 55 f7	 movzx	 edx, BYTE PTR _b1$[ebp]
  00104	81 e2 80 00 00
	00		 and	 edx, 128		; 00000080H
  0010a	52		 push	 edx
  0010b	e8 00 00 00 00	 call	 ?Parity@CVTCommon@@CAEE@Z ; CVTCommon::Parity
  00110	83 c4 04	 add	 esp, 4
  00113	0f b6 f0	 movzx	 esi, al
  00116	0f b6 45 ff	 movzx	 eax, BYTE PTR _b2$[ebp]
  0011a	83 e0 7f	 and	 eax, 127		; 0000007fH
  0011d	50		 push	 eax
  0011e	e8 00 00 00 00	 call	 ?Parity@CVTCommon@@CAEE@Z ; CVTCommon::Parity
  00123	83 c4 04	 add	 esp, 4
  00126	0f b6 c8	 movzx	 ecx, al
  00129	33 f1		 xor	 esi, ecx
  0012b	0f b6 55 fd	 movzx	 edx, BYTE PTR _Syndrome$[ebp]
  0012f	8d 04 f2	 lea	 eax, DWORD PTR [edx+esi*8]
  00132	88 45 fd	 mov	 BYTE PTR _Syndrome$[ebp], al

; 177  :     Syndrome += (Parity(b2 & 0x80) ^ Parity(b3 & 0x7F)) * 0x10;

  00135	0f b6 4d ff	 movzx	 ecx, BYTE PTR _b2$[ebp]
  00139	81 e1 80 00 00
	00		 and	 ecx, 128		; 00000080H
  0013f	51		 push	 ecx
  00140	e8 00 00 00 00	 call	 ?Parity@CVTCommon@@CAEE@Z ; CVTCommon::Parity
  00145	83 c4 04	 add	 esp, 4
  00148	0f b6 f0	 movzx	 esi, al
  0014b	0f b6 55 fe	 movzx	 edx, BYTE PTR _b3$[ebp]
  0014f	83 e2 7f	 and	 edx, 127		; 0000007fH
  00152	52		 push	 edx
  00153	e8 00 00 00 00	 call	 ?Parity@CVTCommon@@CAEE@Z ; CVTCommon::Parity
  00158	83 c4 04	 add	 esp, 4
  0015b	0f b6 c0	 movzx	 eax, al
  0015e	33 f0		 xor	 esi, eax
  00160	c1 e6 04	 shl	 esi, 4
  00163	0f b6 4d fd	 movzx	 ecx, BYTE PTR _Syndrome$[ebp]
  00167	03 ce		 add	 ecx, esi
  00169	88 4d fd	 mov	 BYTE PTR _Syndrome$[ebp], cl

; 178  : 
; 179  :     if (Syndrome != 0 && (Parity(b1) ^ Parity(b2) ^ Parity(b3)) == 0)

  0016c	0f b6 55 fd	 movzx	 edx, BYTE PTR _Syndrome$[ebp]
  00170	85 d2		 test	 edx, edx
  00172	74 44		 je	 SHORT $LN10@Unham2418
  00174	0f b6 45 f7	 movzx	 eax, BYTE PTR _b1$[ebp]
  00178	50		 push	 eax
  00179	e8 00 00 00 00	 call	 ?Parity@CVTCommon@@CAEE@Z ; CVTCommon::Parity
  0017e	83 c4 04	 add	 esp, 4
  00181	0f b6 f0	 movzx	 esi, al
  00184	0f b6 4d ff	 movzx	 ecx, BYTE PTR _b2$[ebp]
  00188	51		 push	 ecx
  00189	e8 00 00 00 00	 call	 ?Parity@CVTCommon@@CAEE@Z ; CVTCommon::Parity
  0018e	83 c4 04	 add	 esp, 4
  00191	0f b6 d0	 movzx	 edx, al
  00194	33 f2		 xor	 esi, edx
  00196	0f b6 45 fe	 movzx	 eax, BYTE PTR _b3$[ebp]
  0019a	50		 push	 eax
  0019b	e8 00 00 00 00	 call	 ?Parity@CVTCommon@@CAEE@Z ; CVTCommon::Parity
  001a0	83 c4 04	 add	 esp, 4
  001a3	0f b6 c8	 movzx	 ecx, al
  001a6	33 f1		 xor	 esi, ecx
  001a8	75 0e		 jne	 SHORT $LN10@Unham2418

; 180  :     {
; 181  :         // Double error
; 182  :         *Error = TRUE;

  001aa	8b 55 0c	 mov	 edx, DWORD PTR _Error$[ebp]
  001ad	c7 02 01 00 00
	00		 mov	 DWORD PTR [edx], 1
  001b3	e9 ed 00 00 00	 jmp	 $LN9@Unham2418
$LN10@Unham2418:

; 183  :     }
; 184  :     else if (Syndrome > 24)

  001b8	0f b6 45 fd	 movzx	 eax, BYTE PTR _Syndrome$[ebp]
  001bc	83 f8 18	 cmp	 eax, 24			; 00000018H
  001bf	7e 0e		 jle	 SHORT $LN8@Unham2418

; 185  :     {
; 186  :         // Error
; 187  :         *Error = TRUE;

  001c1	8b 4d 0c	 mov	 ecx, DWORD PTR _Error$[ebp]
  001c4	c7 01 01 00 00
	00		 mov	 DWORD PTR [ecx], 1

; 188  :     }
; 189  :     else

  001ca	e9 d6 00 00 00	 jmp	 $LN9@Unham2418
$LN8@Unham2418:

; 190  :     {
; 191  :         Syndrome--;

  001cf	8a 55 fd	 mov	 dl, BYTE PTR _Syndrome$[ebp]
  001d2	80 ea 01	 sub	 dl, 1
  001d5	88 55 fd	 mov	 BYTE PTR _Syndrome$[ebp], dl

; 192  :         switch ((BYTE) (Syndrome / 8))

  001d8	0f b6 45 fd	 movzx	 eax, BYTE PTR _Syndrome$[ebp]
  001dc	99		 cdq
  001dd	83 e2 07	 and	 edx, 7
  001e0	03 c2		 add	 eax, edx
  001e2	c1 f8 03	 sar	 eax, 3
  001e5	88 45 f0	 mov	 BYTE PTR tv224[ebp], al
  001e8	80 7d f0 00	 cmp	 BYTE PTR tv224[ebp], 0
  001ec	74 0e		 je	 SHORT $LN4@Unham2418
  001ee	80 7d f0 02	 cmp	 BYTE PTR tv224[ebp], 2
  001f2	74 2d		 je	 SHORT $LN3@Unham2418
  001f4	80 7d f0 03	 cmp	 BYTE PTR tv224[ebp], 3
  001f8	74 4a		 je	 SHORT $LN2@Unham2418
  001fa	eb 69		 jmp	 SHORT $LN5@Unham2418
$LN4@Unham2418:

; 193  :         {
; 194  :         case 0:
; 195  :             b1 ^= (1 << (Syndrome % 8));

  001fc	0f b6 45 fd	 movzx	 eax, BYTE PTR _Syndrome$[ebp]
  00200	8b c8		 mov	 ecx, eax
  00202	81 e1 07 00 00
	80		 and	 ecx, -2147483641	; 80000007H
  00208	79 05		 jns	 SHORT $LN13@Unham2418
  0020a	49		 dec	 ecx
  0020b	83 c9 f8	 or	 ecx, -8			; fffffff8H
  0020e	41		 inc	 ecx
$LN13@Unham2418:
  0020f	ba 01 00 00 00	 mov	 edx, 1
  00214	d3 e2		 shl	 edx, cl
  00216	0f b6 45 f7	 movzx	 eax, BYTE PTR _b1$[ebp]
  0021a	33 c2		 xor	 eax, edx
  0021c	88 45 f7	 mov	 BYTE PTR _b1$[ebp], al

; 196  :             break;

  0021f	eb 44		 jmp	 SHORT $LN5@Unham2418
$LN3@Unham2418:

; 197  :         case 2:
; 198  :             b2 ^= (1 << (Syndrome % 8));

  00221	0f b6 4d fd	 movzx	 ecx, BYTE PTR _Syndrome$[ebp]
  00225	81 e1 07 00 00
	80		 and	 ecx, -2147483641	; 80000007H
  0022b	79 05		 jns	 SHORT $LN14@Unham2418
  0022d	49		 dec	 ecx
  0022e	83 c9 f8	 or	 ecx, -8			; fffffff8H
  00231	41		 inc	 ecx
$LN14@Unham2418:
  00232	ba 01 00 00 00	 mov	 edx, 1
  00237	d3 e2		 shl	 edx, cl
  00239	0f b6 45 ff	 movzx	 eax, BYTE PTR _b2$[ebp]
  0023d	33 c2		 xor	 eax, edx
  0023f	88 45 ff	 mov	 BYTE PTR _b2$[ebp], al

; 199  :             break;

  00242	eb 21		 jmp	 SHORT $LN5@Unham2418
$LN2@Unham2418:

; 200  :         case 3:
; 201  :             b3 ^= (1 << (Syndrome % 8));

  00244	0f b6 4d fd	 movzx	 ecx, BYTE PTR _Syndrome$[ebp]
  00248	81 e1 07 00 00
	80		 and	 ecx, -2147483641	; 80000007H
  0024e	79 05		 jns	 SHORT $LN15@Unham2418
  00250	49		 dec	 ecx
  00251	83 c9 f8	 or	 ecx, -8			; fffffff8H
  00254	41		 inc	 ecx
$LN15@Unham2418:
  00255	ba 01 00 00 00	 mov	 edx, 1
  0025a	d3 e2		 shl	 edx, cl
  0025c	0f b6 45 fe	 movzx	 eax, BYTE PTR _b3$[ebp]
  00260	33 c2		 xor	 eax, edx
  00262	88 45 fe	 mov	 BYTE PTR _b3$[ebp], al
$LN5@Unham2418:

; 202  :             break;
; 203  :         default:
; 204  :             break;
; 205  :         }
; 206  : 
; 207  :         Data |= (b3 & 0x7F) << 11;

  00265	0f b6 4d fe	 movzx	 ecx, BYTE PTR _b3$[ebp]
  00269	83 e1 7f	 and	 ecx, 127		; 0000007fH
  0026c	c1 e1 0b	 shl	 ecx, 11			; 0000000bH
  0026f	0b 4d f8	 or	 ecx, DWORD PTR _Data$[ebp]
  00272	89 4d f8	 mov	 DWORD PTR _Data$[ebp], ecx

; 208  :         Data |= (b2 & 0x7F) << 4;

  00275	0f b6 55 ff	 movzx	 edx, BYTE PTR _b2$[ebp]
  00279	83 e2 7f	 and	 edx, 127		; 0000007fH
  0027c	c1 e2 04	 shl	 edx, 4
  0027f	0b 55 f8	 or	 edx, DWORD PTR _Data$[ebp]
  00282	89 55 f8	 mov	 DWORD PTR _Data$[ebp], edx

; 209  :         Data |= (b1 & 0x70) >> 3;

  00285	0f b6 45 f7	 movzx	 eax, BYTE PTR _b1$[ebp]
  00289	83 e0 70	 and	 eax, 112		; 00000070H
  0028c	c1 f8 03	 sar	 eax, 3
  0028f	0b 45 f8	 or	 eax, DWORD PTR _Data$[ebp]
  00292	89 45 f8	 mov	 DWORD PTR _Data$[ebp], eax

; 210  :         Data |= (b1 & 0x04) >> 2;

  00295	0f b6 4d f7	 movzx	 ecx, BYTE PTR _b1$[ebp]
  00299	83 e1 04	 and	 ecx, 4
  0029c	c1 f9 02	 sar	 ecx, 2
  0029f	0b 4d f8	 or	 ecx, DWORD PTR _Data$[ebp]
  002a2	89 4d f8	 mov	 DWORD PTR _Data$[ebp], ecx
$LN9@Unham2418:

; 211  :     }
; 212  : 
; 213  :     return Data;

  002a5	8b 45 f8	 mov	 eax, DWORD PTR _Data$[ebp]

; 214  : }

  002a8	5e		 pop	 esi
  002a9	8b e5		 mov	 esp, ebp
  002ab	5d		 pop	 ebp
  002ac	c3		 ret	 0
?Unham2418@CVTCommon@@SAKQAEPAH@Z ENDP			; CVTCommon::Unham2418
_TEXT	ENDS
PUBLIC	?UnhamTwo84_MSBF@CVTCommon@@SAEQAEPAH@Z		; CVTCommon::UnhamTwo84_MSBF
; Function compile flags: /Odtp
;	COMDAT ?UnhamTwo84_MSBF@CVTCommon@@SAEQAEPAH@Z
_TEXT	SEGMENT
_Result$ = -1						; size = 1
_Byte$ = 8						; size = 4
_Error$ = 12						; size = 4
?UnhamTwo84_MSBF@CVTCommon@@SAEQAEPAH@Z PROC		; CVTCommon::UnhamTwo84_MSBF, COMDAT

; 153  : {

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

; 154  :     BYTE Result;
; 155  : 
; 156  :     Result = Unham84(Byte[0], Error) << 4;

  00004	8b 45 0c	 mov	 eax, DWORD PTR _Error$[ebp]
  00007	50		 push	 eax
  00008	8b 4d 08	 mov	 ecx, DWORD PTR _Byte$[ebp]
  0000b	0f b6 11	 movzx	 edx, BYTE PTR [ecx]
  0000e	52		 push	 edx
  0000f	e8 00 00 00 00	 call	 ?Unham84@CVTCommon@@SAEEPAH@Z ; CVTCommon::Unham84
  00014	83 c4 08	 add	 esp, 8
  00017	0f b6 c0	 movzx	 eax, al
  0001a	c1 e0 04	 shl	 eax, 4
  0001d	88 45 ff	 mov	 BYTE PTR _Result$[ebp], al

; 157  :     Result |= Unham84(Byte[1], Error);

  00020	8b 4d 0c	 mov	 ecx, DWORD PTR _Error$[ebp]
  00023	51		 push	 ecx
  00024	8b 55 08	 mov	 edx, DWORD PTR _Byte$[ebp]
  00027	0f b6 42 01	 movzx	 eax, BYTE PTR [edx+1]
  0002b	50		 push	 eax
  0002c	e8 00 00 00 00	 call	 ?Unham84@CVTCommon@@SAEEPAH@Z ; CVTCommon::Unham84
  00031	83 c4 08	 add	 esp, 8
  00034	0f b6 c8	 movzx	 ecx, al
  00037	0f b6 55 ff	 movzx	 edx, BYTE PTR _Result$[ebp]
  0003b	0b d1		 or	 edx, ecx
  0003d	88 55 ff	 mov	 BYTE PTR _Result$[ebp], dl

; 158  : 
; 159  :     return Result;

  00040	8a 45 ff	 mov	 al, BYTE PTR _Result$[ebp]

; 160  : }

  00043	8b e5		 mov	 esp, ebp
  00045	5d		 pop	 ebp
  00046	c3		 ret	 0
?UnhamTwo84_MSBF@CVTCommon@@SAEQAEPAH@Z ENDP		; CVTCommon::UnhamTwo84_MSBF
_TEXT	ENDS
PUBLIC	?UnhamTwo84_LSBF@CVTCommon@@SAEQAEPAH@Z		; CVTCommon::UnhamTwo84_LSBF
; Function compile flags: /Odtp
;	COMDAT ?UnhamTwo84_LSBF@CVTCommon@@SAEQAEPAH@Z
_TEXT	SEGMENT
_Result$ = -1						; size = 1
_Byte$ = 8						; size = 4
_Error$ = 12						; size = 4
?UnhamTwo84_LSBF@CVTCommon@@SAEQAEPAH@Z PROC		; CVTCommon::UnhamTwo84_LSBF, COMDAT

; 142  : {

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

; 143  :     BYTE Result;
; 144  : 
; 145  :     Result = Unham84(Byte[0], Error);

  00004	8b 45 0c	 mov	 eax, DWORD PTR _Error$[ebp]
  00007	50		 push	 eax
  00008	8b 4d 08	 mov	 ecx, DWORD PTR _Byte$[ebp]
  0000b	0f b6 11	 movzx	 edx, BYTE PTR [ecx]
  0000e	52		 push	 edx
  0000f	e8 00 00 00 00	 call	 ?Unham84@CVTCommon@@SAEEPAH@Z ; CVTCommon::Unham84
  00014	83 c4 08	 add	 esp, 8
  00017	88 45 ff	 mov	 BYTE PTR _Result$[ebp], al

; 146  :     Result |= Unham84(Byte[1], Error) << 4;

  0001a	8b 45 0c	 mov	 eax, DWORD PTR _Error$[ebp]
  0001d	50		 push	 eax
  0001e	8b 4d 08	 mov	 ecx, DWORD PTR _Byte$[ebp]
  00021	0f b6 51 01	 movzx	 edx, BYTE PTR [ecx+1]
  00025	52		 push	 edx
  00026	e8 00 00 00 00	 call	 ?Unham84@CVTCommon@@SAEEPAH@Z ; CVTCommon::Unham84
  0002b	83 c4 08	 add	 esp, 8
  0002e	0f b6 c0	 movzx	 eax, al
  00031	c1 e0 04	 shl	 eax, 4
  00034	0f b6 4d ff	 movzx	 ecx, BYTE PTR _Result$[ebp]
  00038	0b c8		 or	 ecx, eax
  0003a	88 4d ff	 mov	 BYTE PTR _Result$[ebp], cl

; 147  : 
; 148  :     return Result;

  0003d	8a 45 ff	 mov	 al, BYTE PTR _Result$[ebp]

; 149  : }

  00040	8b e5		 mov	 esp, ebp
  00042	5d		 pop	 ebp
  00043	c3		 ret	 0
?UnhamTwo84_LSBF@CVTCommon@@SAEQAEPAH@Z ENDP		; CVTCommon::UnhamTwo84_LSBF
_TEXT	ENDS
PUBLIC	?CheckParity@CVTCommon@@SAHPAEKH@Z		; CVTCommon::CheckParity
; Function compile flags: /Odtp
;	COMDAT ?CheckParity@CVTCommon@@SAHPAEKH@Z
_TEXT	SEGMENT
_i$139624 = -8						; size = 4
_ErrorFree$ = -4					; size = 4
_Data$ = 8						; size = 4
_Length$ = 12						; size = 4
_bStripParityBits$ = 16					; size = 4
?CheckParity@CVTCommon@@SAHPAEKH@Z PROC			; CVTCommon::CheckParity, COMDAT

; 104  : {

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

; 105  :     BOOL ErrorFree = TRUE;

  00006	c7 45 fc 01 00
	00 00		 mov	 DWORD PTR _ErrorFree$[ebp], 1

; 106  : 
; 107  :     for (ULONG i(0); i < Length; i++)

  0000d	c7 45 f8 00 00
	00 00		 mov	 DWORD PTR _i$139624[ebp], 0
  00014	eb 09		 jmp	 SHORT $LN5@CheckParit
$LN4@CheckParit:
  00016	8b 45 f8	 mov	 eax, DWORD PTR _i$139624[ebp]
  00019	83 c0 01	 add	 eax, 1
  0001c	89 45 f8	 mov	 DWORD PTR _i$139624[ebp], eax
$LN5@CheckParit:
  0001f	8b 4d f8	 mov	 ecx, DWORD PTR _i$139624[ebp]
  00022	3b 4d 0c	 cmp	 ecx, DWORD PTR _Length$[ebp]
  00025	73 3c		 jae	 SHORT $LN3@CheckParit

; 108  :     {
; 109  :         if (Parity(Data[i]) != 0)

  00027	8b 55 08	 mov	 edx, DWORD PTR _Data$[ebp]
  0002a	03 55 f8	 add	 edx, DWORD PTR _i$139624[ebp]
  0002d	0f b6 02	 movzx	 eax, BYTE PTR [edx]
  00030	50		 push	 eax
  00031	e8 00 00 00 00	 call	 ?Parity@CVTCommon@@CAEE@Z ; CVTCommon::Parity
  00036	83 c4 04	 add	 esp, 4
  00039	0f b6 c8	 movzx	 ecx, al
  0003c	85 c9		 test	 ecx, ecx
  0003e	74 07		 je	 SHORT $LN2@CheckParit

; 110  :         {
; 111  :             ErrorFree = FALSE;

  00040	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR _ErrorFree$[ebp], 0
$LN2@CheckParit:

; 112  :         }
; 113  : 
; 114  :         if (bStripParityBits != FALSE)

  00047	83 7d 10 00	 cmp	 DWORD PTR _bStripParityBits$[ebp], 0
  0004b	74 14		 je	 SHORT $LN1@CheckParit

; 115  :         {
; 116  :             Data[i] &= 0x7F;

  0004d	8b 55 08	 mov	 edx, DWORD PTR _Data$[ebp]
  00050	03 55 f8	 add	 edx, DWORD PTR _i$139624[ebp]
  00053	0f b6 02	 movzx	 eax, BYTE PTR [edx]
  00056	83 e0 7f	 and	 eax, 127		; 0000007fH
  00059	8b 4d 08	 mov	 ecx, DWORD PTR _Data$[ebp]
  0005c	03 4d f8	 add	 ecx, DWORD PTR _i$139624[ebp]
  0005f	88 01		 mov	 BYTE PTR [ecx], al
$LN1@CheckParit:

; 117  :         }
; 118  :     }

  00061	eb b3		 jmp	 SHORT $LN4@CheckParit
$LN3@CheckParit:

; 119  : 
; 120  :     return ErrorFree;

  00063	8b 45 fc	 mov	 eax, DWORD PTR _ErrorFree$[ebp]

; 121  : }

  00066	8b e5		 mov	 esp, ebp
  00068	5d		 pop	 ebp
  00069	c3		 ret	 0
?CheckParity@CVTCommon@@SAHPAEKH@Z ENDP			; CVTCommon::CheckParity
PUBLIC	?Unham2418@CVTCommon@@SAXPAE0EPAH@Z		; CVTCommon::Unham2418
; Function compile flags: /Odtp
;	COMDAT ?Unham2418@CVTCommon@@SAXPAE0EPAH@Z
_TEXT	SEGMENT
_Data$ = -12						; size = 4
_BitsLeft$ = -8						; size = 4
_i$ = -4						; size = 4
_Source$ = 8						; size = 4
_Dest$ = 12						; size = 4
_BitOffset$ = 16					; size = 1
_Error$ = 20						; size = 4
?Unham2418@CVTCommon@@SAXPAE0EPAH@Z PROC		; CVTCommon::Unham2418, COMDAT

; 218  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 0c	 sub	 esp, 12			; 0000000cH
  00006	56		 push	 esi

; 219  :     // Zero out the destination
; 220  :     int BitsLeft;
; 221  :     int i(0);

  00007	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR _i$[ebp], 0

; 222  :     for (BitsLeft = BitOffset; BitsLeft > 0; BitsLeft -= 8, i++)

  0000e	0f b6 45 10	 movzx	 eax, BYTE PTR _BitOffset$[ebp]
  00012	89 45 f8	 mov	 DWORD PTR _BitsLeft$[ebp], eax
  00015	eb 12		 jmp	 SHORT $LN6@Unham2418@2
$LN5@Unham2418@2:
  00017	8b 4d f8	 mov	 ecx, DWORD PTR _BitsLeft$[ebp]
  0001a	83 e9 08	 sub	 ecx, 8
  0001d	89 4d f8	 mov	 DWORD PTR _BitsLeft$[ebp], ecx
  00020	8b 55 fc	 mov	 edx, DWORD PTR _i$[ebp]
  00023	83 c2 01	 add	 edx, 1
  00026	89 55 fc	 mov	 DWORD PTR _i$[ebp], edx
$LN6@Unham2418@2:
  00029	83 7d f8 00	 cmp	 DWORD PTR _BitsLeft$[ebp], 0
  0002d	7e 21		 jle	 SHORT $LN4@Unham2418@2

; 223  :     {
; 224  :         Dest[i] &= ~(0xff << BitsLeft);

  0002f	b8 ff 00 00 00	 mov	 eax, 255		; 000000ffH
  00034	8b 4d f8	 mov	 ecx, DWORD PTR _BitsLeft$[ebp]
  00037	d3 e0		 shl	 eax, cl
  00039	f7 d0		 not	 eax
  0003b	8b 4d 0c	 mov	 ecx, DWORD PTR _Dest$[ebp]
  0003e	03 4d fc	 add	 ecx, DWORD PTR _i$[ebp]
  00041	0f b6 11	 movzx	 edx, BYTE PTR [ecx]
  00044	23 d0		 and	 edx, eax
  00046	8b 45 0c	 mov	 eax, DWORD PTR _Dest$[ebp]
  00049	03 45 fc	 add	 eax, DWORD PTR _i$[ebp]
  0004c	88 10		 mov	 BYTE PTR [eax], dl

; 225  :     }

  0004e	eb c7		 jmp	 SHORT $LN5@Unham2418@2
$LN4@Unham2418@2:

; 226  :     for (BitsLeft += 18; BitsLeft > 0; BitsLeft -= 8, i++)

  00050	8b 4d f8	 mov	 ecx, DWORD PTR _BitsLeft$[ebp]
  00053	83 c1 12	 add	 ecx, 18			; 00000012H
  00056	89 4d f8	 mov	 DWORD PTR _BitsLeft$[ebp], ecx
  00059	eb 12		 jmp	 SHORT $LN3@Unham2418@2
$LN2@Unham2418@2:
  0005b	8b 55 f8	 mov	 edx, DWORD PTR _BitsLeft$[ebp]
  0005e	83 ea 08	 sub	 edx, 8
  00061	89 55 f8	 mov	 DWORD PTR _BitsLeft$[ebp], edx
  00064	8b 45 fc	 mov	 eax, DWORD PTR _i$[ebp]
  00067	83 c0 01	 add	 eax, 1
  0006a	89 45 fc	 mov	 DWORD PTR _i$[ebp], eax
$LN3@Unham2418@2:
  0006d	83 7d f8 00	 cmp	 DWORD PTR _BitsLeft$[ebp], 0
  00071	7e 1f		 jle	 SHORT $LN1@Unham2418@2

; 227  :     {
; 228  :         Dest[i] &= (0xff << BitsLeft);

  00073	ba ff 00 00 00	 mov	 edx, 255		; 000000ffH
  00078	8b 4d f8	 mov	 ecx, DWORD PTR _BitsLeft$[ebp]
  0007b	d3 e2		 shl	 edx, cl
  0007d	8b 45 0c	 mov	 eax, DWORD PTR _Dest$[ebp]
  00080	03 45 fc	 add	 eax, DWORD PTR _i$[ebp]
  00083	0f b6 08	 movzx	 ecx, BYTE PTR [eax]
  00086	23 ca		 and	 ecx, edx
  00088	8b 55 0c	 mov	 edx, DWORD PTR _Dest$[ebp]
  0008b	03 55 fc	 add	 edx, DWORD PTR _i$[ebp]
  0008e	88 0a		 mov	 BYTE PTR [edx], cl

; 229  :     }

  00090	eb c9		 jmp	 SHORT $LN2@Unham2418@2
$LN1@Unham2418@2:

; 230  : 
; 231  :     DWORD Data = Unham2418(Source, Error);

  00092	8b 45 14	 mov	 eax, DWORD PTR _Error$[ebp]
  00095	50		 push	 eax
  00096	8b 4d 08	 mov	 ecx, DWORD PTR _Source$[ebp]
  00099	51		 push	 ecx
  0009a	e8 00 00 00 00	 call	 ?Unham2418@CVTCommon@@SAKQAEPAH@Z ; CVTCommon::Unham2418
  0009f	83 c4 08	 add	 esp, 8
  000a2	89 45 f4	 mov	 DWORD PTR _Data$[ebp], eax

; 232  : 
; 233  :     *((DWORD*)&Dest[BitOffset / 8]) |= (Data << (BitOffset % 8));

  000a5	0f b6 45 10	 movzx	 eax, BYTE PTR _BitOffset$[ebp]
  000a9	99		 cdq
  000aa	83 e2 07	 and	 edx, 7
  000ad	03 c2		 add	 eax, edx
  000af	c1 f8 03	 sar	 eax, 3
  000b2	0f b6 55 10	 movzx	 edx, BYTE PTR _BitOffset$[ebp]
  000b6	8b ca		 mov	 ecx, edx
  000b8	81 e1 07 00 00
	80		 and	 ecx, -2147483641	; 80000007H
  000be	79 05		 jns	 SHORT $LN9@Unham2418@2
  000c0	49		 dec	 ecx
  000c1	83 c9 f8	 or	 ecx, -8			; fffffff8H
  000c4	41		 inc	 ecx
$LN9@Unham2418@2:
  000c5	8b 75 f4	 mov	 esi, DWORD PTR _Data$[ebp]
  000c8	d3 e6		 shl	 esi, cl
  000ca	8b 4d 0c	 mov	 ecx, DWORD PTR _Dest$[ebp]
  000cd	0b 34 01	 or	 esi, DWORD PTR [ecx+eax]
  000d0	0f b6 45 10	 movzx	 eax, BYTE PTR _BitOffset$[ebp]
  000d4	99		 cdq
  000d5	83 e2 07	 and	 edx, 7
  000d8	03 c2		 add	 eax, edx
  000da	c1 f8 03	 sar	 eax, 3
  000dd	8b 55 0c	 mov	 edx, DWORD PTR _Dest$[ebp]
  000e0	89 34 02	 mov	 DWORD PTR [edx+eax], esi

; 234  : }

  000e3	5e		 pop	 esi
  000e4	8b e5		 mov	 esp, ebp
  000e6	5d		 pop	 ebp
  000e7	c3		 ret	 0
?Unham2418@CVTCommon@@SAXPAE0EPAH@Z ENDP		; CVTCommon::Unham2418
END
