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

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

INCLUDELIB OLDNAMES

PUBLIC	??_C@_15IABLJNFO@?$AA?6?$AA?6?$AA?$AA@		; `string'
EXTRN	_realloc:PROC
;	COMDAT ??_C@_15IABLJNFO@?$AA?6?$AA?6?$AA?$AA@
CONST	SEGMENT
??_C@_15IABLJNFO@?$AA?6?$AA?6?$AA?$AA@ DB 0aH, 00H, 0aH, 00H, 00H, 00H ; `string'
_szStringVal DD	FLAT:??_C@_13HADIAKP@?$AAS?$AA?$AA@
_szDwordVal DD	FLAT:??_C@_13MKMNOPIJ@?$AAD?$AA?$AA@
_szBinaryVal DD	FLAT:??_C@_13OPKGLAFF@?$AAB?$AA?$AA@
_szValToken DD	FLAT:??_C@_17LLMMEOJD@?$AAV?$AAa?$AAl?$AA?$AA@
_szForceRemove DD FLAT:??_C@_1BI@JFAIJMHL@?$AAF?$AAo?$AAr?$AAc?$AAe?$AAR?$AAe?$AAm?$AAo?$AAv?$AAe?$AA?$AA@
_szNoRemove DD	FLAT:??_C@_1BC@GCKHIPE@?$AAN?$AAo?$AAR?$AAe?$AAm?$AAo?$AAv?$AAe?$AA?$AA@
_szDelete DD	FLAT:??_C@_1O@JDLOHAN@?$AAD?$AAe?$AAl?$AAe?$AAt?$AAe?$AA?$AA@
	ORG $+1
_XmlCData_UtfLetterRange2 DD 0c0H
	DD	0d6H
	DD	0d8H
	DD	0f6H
	DD	0f8H
	DD	0ffH
	DD	0100H
	DD	0131H
	DD	0134H
	DD	013eH
	DD	0141H
	DD	0148H
	DD	014aH
	DD	017eH
	DD	0180H
	DD	01c3H
	DD	01cdH
	DD	01f0H
	DD	01f4H
	DD	01f5H
	DD	01faH
	DD	0217H
	DD	0250H
	DD	02a8H
	DD	02bbH
	DD	02c1H
	DD	0386H
	DD	0386H
	DD	0388H
	DD	038aH
	DD	038cH
	DD	038cH
	DD	038eH
	DD	03a1H
	DD	03a3H
	DD	03ceH
	DD	03d0H
	DD	03d6H
	DD	03daH
	DD	03daH
	DD	03dcH
	DD	03dcH
	DD	03deH
	DD	03deH
	DD	03e0H
	DD	03e0H
	DD	03e2H
	DD	03f3H
	DD	0401H
	DD	040cH
	DD	040eH
	DD	044fH
	DD	0451H
	DD	045cH
	DD	045eH
	DD	0481H
	DD	0490H
	DD	04c4H
	DD	04c7H
	DD	04c8H
	DD	04cbH
	DD	04ccH
	DD	04d0H
	DD	04ebH
	DD	04eeH
	DD	04f5H
	DD	04f8H
	DD	04f9H
	DD	0531H
	DD	0556H
	DD	0559H
	DD	0559H
	DD	0561H
	DD	0586H
	DD	05d0H
	DD	05eaH
	DD	05f0H
	DD	05f2H
	DD	0621H
	DD	063aH
	DD	0641H
	DD	064aH
	DD	0671H
	DD	06b7H
	DD	06baH
	DD	06beH
	DD	06c0H
	DD	06ceH
	DD	06d0H
	DD	06d3H
	DD	06d5H
	DD	06d5H
	DD	06e5H
	DD	06e6H
_XmlCData_UtfLetterRange3 DD 0905H
	DD	0939H
	DD	093dH
	DD	093dH
	DD	0958H
	DD	0961H
	DD	0985H
	DD	098cH
	DD	098fH
	DD	0990H
	DD	0993H
	DD	09a8H
	DD	09aaH
	DD	09b0H
	DD	09b2H
	DD	09b2H
	DD	09b6H
	DD	09b9H
	DD	09dcH
	DD	09ddH
	DD	09dfH
	DD	09e1H
	DD	09f0H
	DD	09f1H
	DD	0a05H
	DD	0a0aH
	DD	0a0fH
	DD	0a10H
	DD	0a13H
	DD	0a28H
	DD	0a2aH
	DD	0a30H
	DD	0a32H
	DD	0a33H
	DD	0a35H
	DD	0a36H
	DD	0a38H
	DD	0a39H
	DD	0a59H
	DD	0a5cH
	DD	0a5eH
	DD	0a5eH
	DD	0a72H
	DD	0a74H
	DD	0a85H
	DD	0a8bH
	DD	0a8dH
	DD	0a8dH
	DD	0a8fH
	DD	0a91H
	DD	0a93H
	DD	0aa8H
	DD	0aaaH
	DD	0ab0H
	DD	0ab2H
	DD	0ab3H
	DD	0ab5H
	DD	0ab9H
	DD	0abdH
	DD	0abdH
	DD	0ae0H
	DD	0ae0H
	DD	0b05H
	DD	0b0cH
	DD	0b0fH
	DD	0b10H
	DD	0b13H
	DD	0b28H
	DD	0b2aH
	DD	0b30H
	DD	0b32H
	DD	0b33H
	DD	0b36H
	DD	0b39H
	DD	0b3dH
	DD	0b3dH
	DD	0b5cH
	DD	0b5dH
	DD	0b5fH
	DD	0b61H
	DD	0b85H
	DD	0b8aH
	DD	0b8eH
	DD	0b90H
	DD	0b92H
	DD	0b95H
	DD	0b99H
	DD	0b9aH
	DD	0b9cH
	DD	0b9cH
	DD	0b9eH
	DD	0b9fH
	DD	0ba3H
	DD	0ba4H
	DD	0ba8H
	DD	0baaH
	DD	0baeH
	DD	0bb5H
	DD	0bb7H
	DD	0bb9H
	DD	0c05H
	DD	0c0cH
	DD	0c0eH
	DD	0c10H
	DD	0c12H
	DD	0c28H
	DD	0c2aH
	DD	0c33H
	DD	0c35H
	DD	0c39H
	DD	0c60H
	DD	0c61H
	DD	0c85H
	DD	0c8cH
	DD	0c8eH
	DD	0c90H
	DD	0c92H
	DD	0ca8H
	DD	0caaH
	DD	0cb3H
	DD	0cb5H
	DD	0cb9H
	DD	0cdeH
	DD	0cdeH
	DD	0ce0H
	DD	0ce1H
	DD	0d05H
	DD	0d0cH
	DD	0d0eH
	DD	0d10H
	DD	0d12H
	DD	0d28H
	DD	0d2aH
	DD	0d39H
	DD	0d60H
	DD	0d61H
	DD	0e01H
	DD	0e2eH
	DD	0e30H
	DD	0e30H
	DD	0e32H
	DD	0e33H
	DD	0e40H
	DD	0e45H
	DD	0e81H
	DD	0e82H
	DD	0e84H
	DD	0e84H
	DD	0e87H
	DD	0e88H
	DD	0e8aH
	DD	0e8aH
	DD	0e8dH
	DD	0e8dH
	DD	0e94H
	DD	0e97H
	DD	0e99H
	DD	0e9fH
	DD	0ea1H
	DD	0ea3H
	DD	0ea5H
	DD	0ea5H
	DD	0ea7H
	DD	0ea7H
	DD	0eaaH
	DD	0eabH
	DD	0eadH
	DD	0eaeH
	DD	0eb0H
	DD	0eb0H
	DD	0eb2H
	DD	0eb3H
	DD	0ebdH
	DD	0ebdH
	DD	0ec0H
	DD	0ec4H
	DD	0f40H
	DD	0f47H
	DD	0f49H
	DD	0f69H
	DD	010a0H
	DD	010c5H
	DD	010d0H
	DD	010f6H
	DD	01100H
	DD	01100H
	DD	01102H
	DD	01103H
	DD	01105H
	DD	01107H
	DD	01109H
	DD	01109H
	DD	0110bH
	DD	0110cH
	DD	0110eH
	DD	01112H
	DD	0113cH
	DD	0113cH
	DD	0113eH
	DD	0113eH
	DD	01140H
	DD	01140H
	DD	0114cH
	DD	0114cH
	DD	0114eH
	DD	0114eH
	DD	01150H
	DD	01150H
	DD	01154H
	DD	01155H
	DD	01159H
	DD	01159H
	DD	0115fH
	DD	01161H
	DD	01163H
	DD	01163H
	DD	01165H
	DD	01165H
	DD	01167H
	DD	01167H
	DD	01169H
	DD	01169H
	DD	0116dH
	DD	0116eH
	DD	01172H
	DD	01173H
	DD	01175H
	DD	01175H
	DD	0119eH
	DD	0119eH
	DD	011a8H
	DD	011a8H
	DD	011abH
	DD	011abH
	DD	011aeH
	DD	011afH
	DD	011b7H
	DD	011b8H
	DD	011baH
	DD	011baH
	DD	011bcH
	DD	011c2H
	DD	011ebH
	DD	011ebH
	DD	011f0H
	DD	011f0H
	DD	011f9H
	DD	011f9H
	DD	01e00H
	DD	01e9bH
	DD	01ea0H
	DD	01ef9H
	DD	01f00H
	DD	01f15H
	DD	01f18H
	DD	01f1dH
	DD	01f20H
	DD	01f45H
	DD	01f48H
	DD	01f4dH
	DD	01f50H
	DD	01f57H
	DD	01f59H
	DD	01f59H
	DD	01f5bH
	DD	01f5bH
	DD	01f5dH
	DD	01f5dH
	DD	01f5fH
	DD	01f7dH
	DD	01f80H
	DD	01fb4H
	DD	01fb6H
	DD	01fbcH
	DD	01fbeH
	DD	01fbeH
	DD	01fc2H
	DD	01fc4H
	DD	01fc6H
	DD	01fccH
	DD	01fd0H
	DD	01fd3H
	DD	01fd6H
	DD	01fdbH
	DD	01fe0H
	DD	01fecH
	DD	01ff2H
	DD	01ff4H
	DD	01ff6H
	DD	01ffcH
	DD	02126H
	DD	02126H
	DD	0212aH
	DD	0212bH
	DD	0212eH
	DD	0212eH
	DD	02180H
	DD	02182H
	DD	03007H
	DD	03007H
	DD	03021H
	DD	03029H
	DD	03041H
	DD	03094H
	DD	030a1H
	DD	030faH
	DD	03105H
	DD	0312cH
	DD	04e00H
	DD	09fa5H
	DD	0ac00H
	DD	0d7a3H
_XmlCData_UtfDigiCombExtRange2 DD 02d0H
	DD	02d0H
	DD	02d1H
	DD	02d1H
	DD	0300H
	DD	0345H
	DD	0360H
	DD	0361H
	DD	0387H
	DD	0387H
	DD	0483H
	DD	0486H
	DD	0591H
	DD	05a1H
	DD	05a3H
	DD	05b9H
	DD	05bbH
	DD	05bdH
	DD	05bfH
	DD	05bfH
	DD	05c1H
	DD	05c2H
	DD	05c4H
	DD	05c4H
	DD	0640H
	DD	0640H
	DD	064bH
	DD	0652H
	DD	0660H
	DD	0669H
	DD	0670H
	DD	0670H
	DD	06d6H
	DD	06dcH
	DD	06ddH
	DD	06dfH
	DD	06e0H
	DD	06e4H
	DD	06e7H
	DD	06e8H
	DD	06eaH
	DD	06edH
	DD	06f0H
	DD	06f9H
_XmlCData_UtfDigiCombExtRange3 DD 0901H
	DD	0903H
	DD	093cH
	DD	093cH
	DD	093eH
	DD	094cH
	DD	094dH
	DD	094dH
	DD	0951H
	DD	0954H
	DD	0962H
	DD	0963H
	DD	0966H
	DD	096fH
	DD	0981H
	DD	0983H
	DD	09bcH
	DD	09bcH
	DD	09beH
	DD	09beH
	DD	09bfH
	DD	09bfH
	DD	09c0H
	DD	09c4H
	DD	09c7H
	DD	09c8H
	DD	09cbH
	DD	09cdH
	DD	09d7H
	DD	09d7H
	DD	09e2H
	DD	09e3H
	DD	09e6H
	DD	09efH
	DD	0a02H
	DD	0a02H
	DD	0a3cH
	DD	0a3cH
	DD	0a3eH
	DD	0a3eH
	DD	0a3fH
	DD	0a3fH
	DD	0a40H
	DD	0a42H
	DD	0a47H
	DD	0a48H
	DD	0a4bH
	DD	0a4dH
	DD	0a66H
	DD	0a6fH
	DD	0a70H
	DD	0a71H
	DD	0a81H
	DD	0a83H
	DD	0abcH
	DD	0abcH
	DD	0abeH
	DD	0ac5H
	DD	0ac7H
	DD	0ac9H
	DD	0acbH
	DD	0acdH
	DD	0ae6H
	DD	0aefH
	DD	0b01H
	DD	0b03H
	DD	0b3cH
	DD	0b3cH
	DD	0b3eH
	DD	0b43H
	DD	0b47H
	DD	0b48H
	DD	0b4bH
	DD	0b4dH
	DD	0b56H
	DD	0b57H
	DD	0b66H
	DD	0b6fH
	DD	0b82H
	DD	0b83H
	DD	0bbeH
	DD	0bc2H
	DD	0bc6H
	DD	0bc8H
	DD	0bcaH
	DD	0bcdH
	DD	0bd7H
	DD	0bd7H
	DD	0be7H
	DD	0befH
	DD	0c01H
	DD	0c03H
	DD	0c3eH
	DD	0c44H
	DD	0c46H
	DD	0c48H
	DD	0c4aH
	DD	0c4dH
	DD	0c55H
	DD	0c56H
	DD	0c66H
	DD	0c6fH
	DD	0c82H
	DD	0c83H
	DD	0cbeH
	DD	0cc4H
	DD	0cc6H
	DD	0cc8H
	DD	0ccaH
	DD	0ccdH
	DD	0cd5H
	DD	0cd6H
	DD	0ce6H
	DD	0cefH
	DD	0d02H
	DD	0d03H
	DD	0d3eH
	DD	0d43H
	DD	0d46H
	DD	0d48H
	DD	0d4aH
	DD	0d4dH
	DD	0d57H
	DD	0d57H
	DD	0d66H
	DD	0d6fH
	DD	0e31H
	DD	0e31H
	DD	0e34H
	DD	0e3aH
	DD	0e46H
	DD	0e46H
	DD	0e47H
	DD	0e4eH
	DD	0e50H
	DD	0e59H
	DD	0eb1H
	DD	0eb1H
	DD	0eb4H
	DD	0eb9H
	DD	0ebbH
	DD	0ebcH
	DD	0ec6H
	DD	0ec6H
	DD	0ec8H
	DD	0ecdH
	DD	0ed0H
	DD	0ed9H
	DD	0f18H
	DD	0f19H
	DD	0f20H
	DD	0f29H
	DD	0f35H
	DD	0f35H
	DD	0f37H
	DD	0f37H
	DD	0f39H
	DD	0f39H
	DD	0f3eH
	DD	0f3eH
	DD	0f3fH
	DD	0f3fH
	DD	0f71H
	DD	0f84H
	DD	0f86H
	DD	0f8bH
	DD	0f90H
	DD	0f95H
	DD	0f97H
	DD	0f97H
	DD	0f99H
	DD	0fadH
	DD	0fb1H
	DD	0fb7H
	DD	0fb9H
	DD	0fb9H
	DD	020d0H
	DD	020dcH
	DD	020e1H
	DD	020e1H
	DD	03005H
	DD	03005H
	DD	0302aH
	DD	0302fH
	DD	03031H
	DD	03035H
	DD	03099H
	DD	03099H
	DD	0309aH
	DD	0309aH
	DD	0309dH
	DD	0309eH
	DD	030fcH
	DD	030feH
__bad_alloc_Message DD FLAT:??_C@_0P@GHFPNOJB@bad?5allocation?$AA@
; Function compile flags: /Odtp
; File c:\develop\dscaler423a\dscaler\xml_cdata.cpp
;	COMDAT ?XmlCdata_SearchUtfCodeRange@@YAEIPBUXML_CDATA_UTF_RANGE@@I@Z
_TEXT	SEGMENT
tv74 = -14						; size = 1
_result$ = -13						; size = 1
_idx$ = -12						; size = 4
_highIdx$ = -8						; size = 4
_lowIdx$ = -4						; size = 4
_code$ = 8						; size = 4
_pRange$ = 12						; size = 4
_count$ = 16						; size = 4
?XmlCdata_SearchUtfCodeRange@@YAEIPBUXML_CDATA_UTF_RANGE@@I@Z PROC ; XmlCdata_SearchUtfCodeRange, COMDAT

; 699  : {

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

; 700  :    uint  lowIdx  = 0;

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

; 701  :    uint  highIdx = count - 1;

  0000d	8b 45 10	 mov	 eax, DWORD PTR _count$[ebp]
  00010	83 e8 01	 sub	 eax, 1
  00013	89 45 f8	 mov	 DWORD PTR _highIdx$[ebp], eax

; 702  :    uint  idx;
; 703  :    Bool  result = FALSE;

  00016	c6 45 f3 00	 mov	 BYTE PTR _result$[ebp], 0
$LN8@XmlCdata_S:

; 704  : 
; 705  :    //assert(count > 0);
; 706  : 
; 707  :    while (1)

  0001a	b9 01 00 00 00	 mov	 ecx, 1
  0001f	85 c9		 test	 ecx, ecx
  00021	0f 84 88 00 00
	00		 je	 $LN7@XmlCdata_S

; 708  :    {
; 709  :       if (lowIdx == highIdx)

  00027	8b 55 fc	 mov	 edx, DWORD PTR _lowIdx$[ebp]
  0002a	3b 55 f8	 cmp	 edx, DWORD PTR _highIdx$[ebp]
  0002d	75 37		 jne	 SHORT $LN6@XmlCdata_S

; 710  :       {
; 711  :          idx = lowIdx;

  0002f	8b 45 fc	 mov	 eax, DWORD PTR _lowIdx$[ebp]
  00032	89 45 f4	 mov	 DWORD PTR _idx$[ebp], eax

; 712  :          result = ((code >= pRange[idx].low) && (code <= pRange[idx].high));

  00035	8b 4d f4	 mov	 ecx, DWORD PTR _idx$[ebp]
  00038	8b 55 0c	 mov	 edx, DWORD PTR _pRange$[ebp]
  0003b	8b 45 08	 mov	 eax, DWORD PTR _code$[ebp]
  0003e	3b 04 ca	 cmp	 eax, DWORD PTR [edx+ecx*8]
  00041	72 15		 jb	 SHORT $LN11@XmlCdata_S
  00043	8b 4d f4	 mov	 ecx, DWORD PTR _idx$[ebp]
  00046	8b 55 0c	 mov	 edx, DWORD PTR _pRange$[ebp]
  00049	8b 45 08	 mov	 eax, DWORD PTR _code$[ebp]
  0004c	3b 44 ca 04	 cmp	 eax, DWORD PTR [edx+ecx*8+4]
  00050	77 06		 ja	 SHORT $LN11@XmlCdata_S
  00052	c6 45 f2 01	 mov	 BYTE PTR tv74[ebp], 1
  00056	eb 04		 jmp	 SHORT $LN12@XmlCdata_S
$LN11@XmlCdata_S:
  00058	c6 45 f2 00	 mov	 BYTE PTR tv74[ebp], 0
$LN12@XmlCdata_S:
  0005c	8a 4d f2	 mov	 cl, BYTE PTR tv74[ebp]
  0005f	88 4d f3	 mov	 BYTE PTR _result$[ebp], cl

; 713  :          break;

  00062	eb 4b		 jmp	 SHORT $LN7@XmlCdata_S

; 714  :       }
; 715  :       else

  00064	eb 44		 jmp	 SHORT $LN5@XmlCdata_S
$LN6@XmlCdata_S:

; 716  :       {
; 717  :          idx = (lowIdx + highIdx) / 2;

  00066	8b 55 fc	 mov	 edx, DWORD PTR _lowIdx$[ebp]
  00069	03 55 f8	 add	 edx, DWORD PTR _highIdx$[ebp]
  0006c	d1 ea		 shr	 edx, 1
  0006e	89 55 f4	 mov	 DWORD PTR _idx$[ebp], edx

; 718  :          if (code < pRange[idx].low)

  00071	8b 45 f4	 mov	 eax, DWORD PTR _idx$[ebp]
  00074	8b 4d 0c	 mov	 ecx, DWORD PTR _pRange$[ebp]
  00077	8b 55 08	 mov	 edx, DWORD PTR _code$[ebp]
  0007a	3b 14 c1	 cmp	 edx, DWORD PTR [ecx+eax*8]
  0007d	73 0b		 jae	 SHORT $LN4@XmlCdata_S

; 719  :          {
; 720  :             highIdx = idx - 1;

  0007f	8b 45 f4	 mov	 eax, DWORD PTR _idx$[ebp]
  00082	83 e8 01	 sub	 eax, 1
  00085	89 45 f8	 mov	 DWORD PTR _highIdx$[ebp], eax
  00088	eb 20		 jmp	 SHORT $LN5@XmlCdata_S
$LN4@XmlCdata_S:

; 721  :          }
; 722  :          else if (code > pRange[idx].high)

  0008a	8b 4d f4	 mov	 ecx, DWORD PTR _idx$[ebp]
  0008d	8b 55 0c	 mov	 edx, DWORD PTR _pRange$[ebp]
  00090	8b 45 08	 mov	 eax, DWORD PTR _code$[ebp]
  00093	3b 44 ca 04	 cmp	 eax, DWORD PTR [edx+ecx*8+4]
  00097	76 0b		 jbe	 SHORT $LN2@XmlCdata_S

; 723  :          {
; 724  :             lowIdx = idx + 1;

  00099	8b 4d f4	 mov	 ecx, DWORD PTR _idx$[ebp]
  0009c	83 c1 01	 add	 ecx, 1
  0009f	89 4d fc	 mov	 DWORD PTR _lowIdx$[ebp], ecx

; 725  :          }
; 726  :          else

  000a2	eb 06		 jmp	 SHORT $LN5@XmlCdata_S
$LN2@XmlCdata_S:

; 727  :          {
; 728  :             result = TRUE;

  000a4	c6 45 f3 01	 mov	 BYTE PTR _result$[ebp], 1

; 729  :             break;

  000a8	eb 05		 jmp	 SHORT $LN7@XmlCdata_S
$LN5@XmlCdata_S:

; 730  :          }
; 731  :       }
; 732  :    }

  000aa	e9 6b ff ff ff	 jmp	 $LN8@XmlCdata_S
$LN7@XmlCdata_S:

; 733  : 
; 734  :    return result;

  000af	8a 45 f3	 mov	 al, BYTE PTR _result$[ebp]

; 735  : }

  000b2	8b e5		 mov	 esp, ebp
  000b4	5d		 pop	 ebp
  000b5	c3		 ret	 0
?XmlCdata_SearchUtfCodeRange@@YAEIPBUXML_CDATA_UTF_RANGE@@I@Z ENDP ; XmlCdata_SearchUtfCodeRange
_TEXT	ENDS
PUBLIC	?XmlCdata_CheckUtf8@@YAEPB_W@Z			; XmlCdata_CheckUtf8
; Function compile flags: /Odtp
;	COMDAT ?XmlCdata_CheckUtf8@@YAEPB_W@Z
_TEXT	SEGMENT
tv82 = -28						; size = 4
_c4$ = -24						; size = 2
_result$ = -17						; size = 1
_c2$ = -16						; size = 2
_c1$ = -12						; size = 2
_code$ = -8						; size = 4
_c3$ = -4						; size = 2
_pStr$ = 8						; size = 4
?XmlCdata_CheckUtf8@@YAEPB_W@Z PROC			; XmlCdata_CheckUtf8, COMDAT

; 502  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 1c	 sub	 esp, 28			; 0000001cH

; 503  :    TCHAR c1, c2, c3, c4;
; 504  :    uint code;
; 505  :    Bool result = TRUE;

  00006	c6 45 ef 01	 mov	 BYTE PTR _result$[ebp], 1

; 506  : 
; 507  :    if (pStr != NULL)

  0000a	83 7d 08 00	 cmp	 DWORD PTR _pStr$[ebp], 0
  0000e	0f 84 19 02 00
	00		 je	 $LN25@XmlCdata_C
$LN24@XmlCdata_C:

; 508  :    {
; 509  :       while ( ((c1 = *(pStr++)) != 0) && result )

  00014	8b 45 08	 mov	 eax, DWORD PTR _pStr$[ebp]
  00017	66 8b 08	 mov	 cx, WORD PTR [eax]
  0001a	66 89 4d f4	 mov	 WORD PTR _c1$[ebp], cx
  0001e	0f b7 55 f4	 movzx	 edx, WORD PTR _c1$[ebp]
  00022	8b 45 08	 mov	 eax, DWORD PTR _pStr$[ebp]
  00025	83 c0 02	 add	 eax, 2
  00028	89 45 08	 mov	 DWORD PTR _pStr$[ebp], eax
  0002b	85 d2		 test	 edx, edx
  0002d	0f 84 fa 01 00
	00		 je	 $LN25@XmlCdata_C
  00033	0f b6 4d ef	 movzx	 ecx, BYTE PTR _result$[ebp]
  00037	85 c9		 test	 ecx, ecx
  00039	0f 84 ee 01 00
	00		 je	 $LN25@XmlCdata_C

; 510  :       {
; 511  :          if (c1 < 0x80)

  0003f	0f b7 55 f4	 movzx	 edx, WORD PTR _c1$[ebp]
  00043	81 fa 80 00 00
	00		 cmp	 edx, 128		; 00000080H
  00049	7d 2d		 jge	 SHORT $LN22@XmlCdata_C

; 512  :          {
; 513  :             if (c1 < 0x20)

  0004b	0f b7 45 f4	 movzx	 eax, WORD PTR _c1$[ebp]
  0004f	83 f8 20	 cmp	 eax, 32			; 00000020H
  00052	7d 1f		 jge	 SHORT $LN21@XmlCdata_C

; 514  :             {
; 515  :                if ((c1 != 0x09) && (c1 != 0x0A) && (c1 != 0x0D))

  00054	0f b7 4d f4	 movzx	 ecx, WORD PTR _c1$[ebp]
  00058	83 f9 09	 cmp	 ecx, 9
  0005b	74 16		 je	 SHORT $LN21@XmlCdata_C
  0005d	0f b7 55 f4	 movzx	 edx, WORD PTR _c1$[ebp]
  00061	83 fa 0a	 cmp	 edx, 10			; 0000000aH
  00064	74 0d		 je	 SHORT $LN21@XmlCdata_C
  00066	0f b7 45 f4	 movzx	 eax, WORD PTR _c1$[ebp]
  0006a	83 f8 0d	 cmp	 eax, 13			; 0000000dH
  0006d	74 04		 je	 SHORT $LN21@XmlCdata_C

; 516  :                {
; 517  :                   dprintf1(_T("XmlCdata-CheckUtf8: invalid control code 0x%02X\n"), c1);
; 518  :                   result = FALSE;

  0006f	c6 45 ef 00	 mov	 BYTE PTR _result$[ebp], 0
$LN21@XmlCdata_C:

; 519  :                }
; 520  :             }
; 521  :             // else: ASCII range already checked by scanner
; 522  :          }
; 523  :          else

  00073	e9 b0 01 00 00	 jmp	 $LN19@XmlCdata_C
$LN22@XmlCdata_C:

; 524  :          {
; 525  :             switch (c1 >> 4)

  00078	0f b7 4d f4	 movzx	 ecx, WORD PTR _c1$[ebp]
  0007c	c1 f9 04	 sar	 ecx, 4
  0007f	89 4d e4	 mov	 DWORD PTR tv82[ebp], ecx
  00082	8b 55 e4	 mov	 edx, DWORD PTR tv82[ebp]
  00085	83 ea 0c	 sub	 edx, 12			; 0000000cH
  00088	89 55 e4	 mov	 DWORD PTR tv82[ebp], edx
  0008b	83 7d e4 03	 cmp	 DWORD PTR tv82[ebp], 3
  0008f	0f 87 8f 01 00
	00		 ja	 $LN1@XmlCdata_C
  00095	8b 45 e4	 mov	 eax, DWORD PTR tv82[ebp]
  00098	ff 24 85 00 00
	00 00		 jmp	 DWORD PTR $LN28@XmlCdata_C[eax*4]
$LN16@XmlCdata_C:

; 526  :             {
; 527  :                case 0xC:  // 2-byte code
; 528  :                case 0xD:
; 529  :                   c2 = *pStr++;

  0009f	8b 4d 08	 mov	 ecx, DWORD PTR _pStr$[ebp]
  000a2	66 8b 11	 mov	 dx, WORD PTR [ecx]
  000a5	66 89 55 f0	 mov	 WORD PTR _c2$[ebp], dx
  000a9	8b 45 08	 mov	 eax, DWORD PTR _pStr$[ebp]
  000ac	83 c0 02	 add	 eax, 2
  000af	89 45 08	 mov	 DWORD PTR _pStr$[ebp], eax

; 530  :                   if ((c2 & ~0x3F) == 0x80)

  000b2	0f b7 4d f0	 movzx	 ecx, WORD PTR _c2$[ebp]
  000b6	83 e1 c0	 and	 ecx, -64		; ffffffc0H
  000b9	81 f9 80 00 00
	00		 cmp	 ecx, 128		; 00000080H
  000bf	75 02		 jne	 SHORT $LN15@XmlCdata_C

; 531  :                   {
; 532  :                      // all codes in range 0x80..0x7FF are acceptable
; 533  :                   }
; 534  :                   else

  000c1	eb 04		 jmp	 SHORT $LN14@XmlCdata_C
$LN15@XmlCdata_C:

; 535  :                   {
; 536  :                      dprintf2(_T("XmlCdata-CheckUtf8: sequence error in 2-byte code: 0x%02X,%02X\n"), c1, c2);
; 537  :                      result = FALSE;

  000c3	c6 45 ef 00	 mov	 BYTE PTR _result$[ebp], 0
$LN14@XmlCdata_C:

; 538  :                   }
; 539  :                   break;

  000c7	e9 5c 01 00 00	 jmp	 $LN19@XmlCdata_C
$LN13@XmlCdata_C:

; 540  : 
; 541  :                case 0xE:  // 3-byte code: range 0x0800..0xFFFF
; 542  :                   if ( (((c2 = *(pStr++)) & ~0x3Fu) == 0x80) &&
; 543  :                        (((c3 = *(pStr++)) & ~0x3Fu) == 0x80) )

  000cc	8b 55 08	 mov	 edx, DWORD PTR _pStr$[ebp]
  000cf	66 8b 02	 mov	 ax, WORD PTR [edx]
  000d2	66 89 45 f0	 mov	 WORD PTR _c2$[ebp], ax
  000d6	0f b7 4d f0	 movzx	 ecx, WORD PTR _c2$[ebp]
  000da	83 e1 c0	 and	 ecx, -64		; ffffffc0H
  000dd	8b 55 08	 mov	 edx, DWORD PTR _pStr$[ebp]
  000e0	83 c2 02	 add	 edx, 2
  000e3	89 55 08	 mov	 DWORD PTR _pStr$[ebp], edx
  000e6	81 f9 80 00 00
	00		 cmp	 ecx, 128		; 00000080H
  000ec	75 65		 jne	 SHORT $LN12@XmlCdata_C
  000ee	8b 45 08	 mov	 eax, DWORD PTR _pStr$[ebp]
  000f1	66 8b 08	 mov	 cx, WORD PTR [eax]
  000f4	66 89 4d fc	 mov	 WORD PTR _c3$[ebp], cx
  000f8	0f b7 55 fc	 movzx	 edx, WORD PTR _c3$[ebp]
  000fc	83 e2 c0	 and	 edx, -64		; ffffffc0H
  000ff	8b 45 08	 mov	 eax, DWORD PTR _pStr$[ebp]
  00102	83 c0 02	 add	 eax, 2
  00105	89 45 08	 mov	 DWORD PTR _pStr$[ebp], eax
  00108	81 fa 80 00 00
	00		 cmp	 edx, 128		; 00000080H
  0010e	75 43		 jne	 SHORT $LN12@XmlCdata_C

; 544  :                   {
; 545  :                      code = ((c1 & 0x0F) << (2*6)) | ((c2 & 0x3F) << 6) | (c3 & 0x3F);

  00110	0f b7 4d f4	 movzx	 ecx, WORD PTR _c1$[ebp]
  00114	83 e1 0f	 and	 ecx, 15			; 0000000fH
  00117	c1 e1 0c	 shl	 ecx, 12			; 0000000cH
  0011a	0f b7 55 f0	 movzx	 edx, WORD PTR _c2$[ebp]
  0011e	83 e2 3f	 and	 edx, 63			; 0000003fH
  00121	c1 e2 06	 shl	 edx, 6
  00124	0b ca		 or	 ecx, edx
  00126	0f b7 45 fc	 movzx	 eax, WORD PTR _c3$[ebp]
  0012a	83 e0 3f	 and	 eax, 63			; 0000003fH
  0012d	0b c8		 or	 ecx, eax
  0012f	89 4d f8	 mov	 DWORD PTR _code$[ebp], ecx

; 546  : 
; 547  :                      if ( ((code >= 0xD800) && (code < 0xE000)) || (code >= 0xFFFE) )

  00132	81 7d f8 00 d8
	00 00		 cmp	 DWORD PTR _code$[ebp], 55296 ; 0000d800H
  00139	72 09		 jb	 SHORT $LN9@XmlCdata_C
  0013b	81 7d f8 00 e0
	00 00		 cmp	 DWORD PTR _code$[ebp], 57344 ; 0000e000H
  00142	72 09		 jb	 SHORT $LN10@XmlCdata_C
$LN9@XmlCdata_C:
  00144	81 7d f8 fe ff
	00 00		 cmp	 DWORD PTR _code$[ebp], 65534 ; 0000fffeH
  0014b	72 04		 jb	 SHORT $LN11@XmlCdata_C
$LN10@XmlCdata_C:

; 548  :                      {
; 549  :                         dprintf4(_T("XmlCdata-CheckUtf8: invalid code: 0x%X (3-byte 0x%02X,%02X,%02X)\n"), code, c1, c2, c3);
; 550  :                         result = FALSE;

  0014d	c6 45 ef 00	 mov	 BYTE PTR _result$[ebp], 0
$LN11@XmlCdata_C:

; 551  :                      }
; 552  :                   }
; 553  :                   else

  00151	eb 04		 jmp	 SHORT $LN8@XmlCdata_C
$LN12@XmlCdata_C:

; 554  :                   {
; 555  :                      dprintf2(_T("XmlCdata-CheckUtf8: sequence error in 3-byte code: 0x%02X,%02X,...\n"), c1, c2);
; 556  :                      result = FALSE;

  00153	c6 45 ef 00	 mov	 BYTE PTR _result$[ebp], 0
$LN8@XmlCdata_C:

; 557  :                   }
; 558  :                   break;

  00157	e9 cc 00 00 00	 jmp	 $LN19@XmlCdata_C
$LN7@XmlCdata_C:

; 559  : 
; 560  :                case 0xF:  // 4 or more byte: code >= 0x10000
; 561  :                   if ((c1 & 0xF8) == 0xF0)

  0015c	0f b7 4d f4	 movzx	 ecx, WORD PTR _c1$[ebp]
  00160	81 e1 f8 00 00
	00		 and	 ecx, 248		; 000000f8H
  00166	81 f9 f0 00 00
	00		 cmp	 ecx, 240		; 000000f0H
  0016c	0f 85 ac 00 00
	00		 jne	 $LN6@XmlCdata_C

; 562  :                   {
; 563  :                      if ( (((c2 = *(pStr++)) & ~0x3Fu) == 0x80) &&
; 564  :                           (((c3 = *(pStr++)) & ~0x3Fu) == 0x80) &&
; 565  :                           (((c4 = *(pStr++)) & ~0x3Fu) == 0x80) )

  00172	8b 55 08	 mov	 edx, DWORD PTR _pStr$[ebp]
  00175	66 8b 02	 mov	 ax, WORD PTR [edx]
  00178	66 89 45 f0	 mov	 WORD PTR _c2$[ebp], ax
  0017c	0f b7 4d f0	 movzx	 ecx, WORD PTR _c2$[ebp]
  00180	83 e1 c0	 and	 ecx, -64		; ffffffc0H
  00183	8b 55 08	 mov	 edx, DWORD PTR _pStr$[ebp]
  00186	83 c2 02	 add	 edx, 2
  00189	89 55 08	 mov	 DWORD PTR _pStr$[ebp], edx
  0018c	81 f9 80 00 00
	00		 cmp	 ecx, 128		; 00000080H
  00192	0f 85 80 00 00
	00		 jne	 $LN5@XmlCdata_C
  00198	8b 45 08	 mov	 eax, DWORD PTR _pStr$[ebp]
  0019b	66 8b 08	 mov	 cx, WORD PTR [eax]
  0019e	66 89 4d fc	 mov	 WORD PTR _c3$[ebp], cx
  001a2	0f b7 55 fc	 movzx	 edx, WORD PTR _c3$[ebp]
  001a6	83 e2 c0	 and	 edx, -64		; ffffffc0H
  001a9	8b 45 08	 mov	 eax, DWORD PTR _pStr$[ebp]
  001ac	83 c0 02	 add	 eax, 2
  001af	89 45 08	 mov	 DWORD PTR _pStr$[ebp], eax
  001b2	81 fa 80 00 00
	00		 cmp	 edx, 128		; 00000080H
  001b8	75 5e		 jne	 SHORT $LN5@XmlCdata_C
  001ba	8b 4d 08	 mov	 ecx, DWORD PTR _pStr$[ebp]
  001bd	66 8b 11	 mov	 dx, WORD PTR [ecx]
  001c0	66 89 55 e8	 mov	 WORD PTR _c4$[ebp], dx
  001c4	0f b7 45 e8	 movzx	 eax, WORD PTR _c4$[ebp]
  001c8	83 e0 c0	 and	 eax, -64		; ffffffc0H
  001cb	8b 4d 08	 mov	 ecx, DWORD PTR _pStr$[ebp]
  001ce	83 c1 02	 add	 ecx, 2
  001d1	89 4d 08	 mov	 DWORD PTR _pStr$[ebp], ecx
  001d4	3d 80 00 00 00	 cmp	 eax, 128		; 00000080H
  001d9	75 3d		 jne	 SHORT $LN5@XmlCdata_C

; 566  :                      {
; 567  :                         code = ((c1 & 0x07) << (3*6)) | ((c2 & 0x3F) << (2*6)) |
; 568  :                                ((c3 & 0x3F) << 6) | (c4 & 0x3F);

  001db	0f b7 55 f4	 movzx	 edx, WORD PTR _c1$[ebp]
  001df	83 e2 07	 and	 edx, 7
  001e2	c1 e2 12	 shl	 edx, 18			; 00000012H
  001e5	0f b7 45 f0	 movzx	 eax, WORD PTR _c2$[ebp]
  001e9	83 e0 3f	 and	 eax, 63			; 0000003fH
  001ec	c1 e0 0c	 shl	 eax, 12			; 0000000cH
  001ef	0b d0		 or	 edx, eax
  001f1	0f b7 4d fc	 movzx	 ecx, WORD PTR _c3$[ebp]
  001f5	83 e1 3f	 and	 ecx, 63			; 0000003fH
  001f8	c1 e1 06	 shl	 ecx, 6
  001fb	0b d1		 or	 edx, ecx
  001fd	0f b7 45 e8	 movzx	 eax, WORD PTR _c4$[ebp]
  00201	83 e0 3f	 and	 eax, 63			; 0000003fH
  00204	0b d0		 or	 edx, eax
  00206	89 55 f8	 mov	 DWORD PTR _code$[ebp], edx

; 569  : 
; 570  :                         if (code > 0x10FFFF)

  00209	81 7d f8 ff ff
	10 00		 cmp	 DWORD PTR _code$[ebp], 1114111 ; 0010ffffH
  00210	76 04		 jbe	 SHORT $LN4@XmlCdata_C

; 571  :                         {
; 572  :                            dprintf5(_T("XmlCdata-CheckUtf8: invalid code: 0x%X (4-byte 0x%02X,%02X,%02X,%02X)\n"), code, c1, c2, c3, c4);
; 573  :                            result = FALSE;

  00212	c6 45 ef 00	 mov	 BYTE PTR _result$[ebp], 0
$LN4@XmlCdata_C:

; 574  :                         }
; 575  :                      }
; 576  :                      else

  00216	eb 04		 jmp	 SHORT $LN3@XmlCdata_C
$LN5@XmlCdata_C:

; 577  :                      {
; 578  :                         dprintf2(_T("XmlCdata-CheckUtf8: sequence error in 4-byte code: 0x%02X,%02X,...\n"), c1, c2);
; 579  :                         result = FALSE;

  00218	c6 45 ef 00	 mov	 BYTE PTR _result$[ebp], 0
$LN3@XmlCdata_C:

; 580  :                      }
; 581  :                   }
; 582  :                   else

  0021c	eb 04		 jmp	 SHORT $LN2@XmlCdata_C
$LN6@XmlCdata_C:

; 583  :                   {
; 584  :                      dprintf1(_T("XmlCdata-CheckUtf8: >= 5-byte code: invalid in XML: 0x%02X\n"), c1);
; 585  :                      result = FALSE;  // 5 or more bytes

  0021e	c6 45 ef 00	 mov	 BYTE PTR _result$[ebp], 0
$LN2@XmlCdata_C:

; 586  :                   }
; 587  :                   break;

  00222	eb 04		 jmp	 SHORT $LN19@XmlCdata_C
$LN1@XmlCdata_C:

; 588  : 
; 589  :                default:  // sequence error
; 590  :                   result = FALSE;

  00224	c6 45 ef 00	 mov	 BYTE PTR _result$[ebp], 0
$LN19@XmlCdata_C:

; 591  :                   break;
; 592  :             }
; 593  :          }
; 594  :       }

  00228	e9 e7 fd ff ff	 jmp	 $LN24@XmlCdata_C
$LN25@XmlCdata_C:

; 595  :    }
; 596  :    return result;

  0022d	8a 45 ef	 mov	 al, BYTE PTR _result$[ebp]

; 597  : }

  00230	8b e5		 mov	 esp, ebp
  00232	5d		 pop	 ebp
  00233	c3		 ret	 0
$LN28@XmlCdata_C:
  00234	00 00 00 00	 DD	 $LN16@XmlCdata_C
  00238	00 00 00 00	 DD	 $LN16@XmlCdata_C
  0023c	00 00 00 00	 DD	 $LN13@XmlCdata_C
  00240	00 00 00 00	 DD	 $LN7@XmlCdata_C
?XmlCdata_CheckUtf8@@YAEPB_W@Z ENDP			; XmlCdata_CheckUtf8
_TEXT	ENDS
PUBLIC	?XmlCdata_CheckLatin1Name@@YAEPB_WE@Z		; XmlCdata_CheckLatin1Name
; Function compile flags: /Odtp
;	COMDAT ?XmlCdata_CheckLatin1Name@@YAEPB_WE@Z
_TEXT	SEGMENT
_result$ = -5						; size = 1
_code$ = -4						; size = 2
_pStr$ = 8						; size = 4
_isNmtoken$ = 12					; size = 1
?XmlCdata_CheckLatin1Name@@YAEPB_WE@Z PROC		; XmlCdata_CheckLatin1Name, COMDAT

; 448  : {

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

; 449  :    TCHAR code;
; 450  :    Bool result = TRUE;

  00006	c6 45 fb 01	 mov	 BYTE PTR _result$[ebp], 1

; 451  : 
; 452  :    if (pStr != NULL)

  0000a	83 7d 08 00	 cmp	 DWORD PTR _pStr$[ebp], 0
  0000e	0f 84 a7 00 00
	00		 je	 $LN12@XmlCdata_C@2
$LN11@XmlCdata_C@2:

; 453  :    {
; 454  :       while ( (code = *(pStr++)) != 0 )

  00014	8b 45 08	 mov	 eax, DWORD PTR _pStr$[ebp]
  00017	66 8b 08	 mov	 cx, WORD PTR [eax]
  0001a	66 89 4d fc	 mov	 WORD PTR _code$[ebp], cx
  0001e	0f b7 55 fc	 movzx	 edx, WORD PTR _code$[ebp]
  00022	8b 45 08	 mov	 eax, DWORD PTR _pStr$[ebp]
  00025	83 c0 02	 add	 eax, 2
  00028	89 45 08	 mov	 DWORD PTR _pStr$[ebp], eax
  0002b	85 d2		 test	 edx, edx
  0002d	0f 84 88 00 00
	00		 je	 $LN12@XmlCdata_C@2

; 455  :       {
; 456  :          if (code < 0x80)

  00033	0f b7 4d fc	 movzx	 ecx, WORD PTR _code$[ebp]
  00037	81 f9 80 00 00
	00		 cmp	 ecx, 128		; 00000080H
  0003d	7d 2c		 jge	 SHORT $LN9@XmlCdata_C@2

; 457  :          {
; 458  :             if (code < 0x20)

  0003f	0f b7 55 fc	 movzx	 edx, WORD PTR _code$[ebp]
  00043	83 fa 20	 cmp	 edx, 32			; 00000020H
  00046	7d 21		 jge	 SHORT $LN8@XmlCdata_C@2

; 459  :             {
; 460  :                if ((code != 0x09) && (code != 0x0A) && (code != 0x0D))

  00048	0f b7 45 fc	 movzx	 eax, WORD PTR _code$[ebp]
  0004c	83 f8 09	 cmp	 eax, 9
  0004f	74 18		 je	 SHORT $LN8@XmlCdata_C@2
  00051	0f b7 4d fc	 movzx	 ecx, WORD PTR _code$[ebp]
  00055	83 f9 0a	 cmp	 ecx, 10			; 0000000aH
  00058	74 0f		 je	 SHORT $LN8@XmlCdata_C@2
  0005a	0f b7 55 fc	 movzx	 edx, WORD PTR _code$[ebp]
  0005e	83 fa 0d	 cmp	 edx, 13			; 0000000dH
  00061	74 06		 je	 SHORT $LN8@XmlCdata_C@2

; 461  :                {
; 462  :                   result = FALSE;

  00063	c6 45 fb 00	 mov	 BYTE PTR _result$[ebp], 0

; 463  :                   break;

  00067	eb 52		 jmp	 SHORT $LN12@XmlCdata_C@2
$LN8@XmlCdata_C@2:

; 464  :                }
; 465  :             }
; 466  :             // else: ASCII range already checked by scanner
; 467  :          }
; 468  :          else //if (code >= 0x80)

  00069	eb 47		 jmp	 SHORT $LN6@XmlCdata_C@2
$LN9@XmlCdata_C@2:

; 469  :          {
; 470  :             // [#x00C0-#x00D6] | [#x00D8-#x00F6] | [#x00F8-#x00FF]
; 471  :             if (code >= 0xc0)

  0006b	0f b7 45 fc	 movzx	 eax, WORD PTR _code$[ebp]
  0006f	3d c0 00 00 00	 cmp	 eax, 192		; 000000c0H
  00074	7c 20		 jl	 SHORT $LN5@XmlCdata_C@2

; 472  :             {
; 473  :                if ((code == 0xD7) && (code == 0xF7))

  00076	0f b7 4d fc	 movzx	 ecx, WORD PTR _code$[ebp]
  0007a	81 f9 d7 00 00
	00		 cmp	 ecx, 215		; 000000d7H
  00080	75 12		 jne	 SHORT $LN4@XmlCdata_C@2
  00082	0f b7 55 fc	 movzx	 edx, WORD PTR _code$[ebp]
  00086	81 fa f7 00 00
	00		 cmp	 edx, 247		; 000000f7H
  0008c	75 06		 jne	 SHORT $LN4@XmlCdata_C@2

; 474  :                {
; 475  :                   result = FALSE;

  0008e	c6 45 fb 00	 mov	 BYTE PTR _result$[ebp], 0

; 476  :                   break;

  00092	eb 27		 jmp	 SHORT $LN12@XmlCdata_C@2
$LN4@XmlCdata_C@2:

; 477  :                }
; 478  :             }

  00094	eb 1c		 jmp	 SHORT $LN6@XmlCdata_C@2
$LN5@XmlCdata_C@2:

; 479  :             else if (isNmtoken && (code == 0xB7))

  00096	0f b6 45 0c	 movzx	 eax, BYTE PTR _isNmtoken$[ebp]
  0009a	85 c0		 test	 eax, eax
  0009c	74 0e		 je	 SHORT $LN2@XmlCdata_C@2
  0009e	0f b7 4d fc	 movzx	 ecx, WORD PTR _code$[ebp]
  000a2	81 f9 b7 00 00
	00		 cmp	 ecx, 183		; 000000b7H
  000a8	75 02		 jne	 SHORT $LN2@XmlCdata_C@2

; 480  :             {
; 481  :                // extender: OK
; 482  :             }
; 483  :             else

  000aa	eb 06		 jmp	 SHORT $LN6@XmlCdata_C@2
$LN2@XmlCdata_C@2:

; 484  :             {
; 485  :                result = FALSE;

  000ac	c6 45 fb 00	 mov	 BYTE PTR _result$[ebp], 0

; 486  :                break;

  000b0	eb 09		 jmp	 SHORT $LN12@XmlCdata_C@2
$LN6@XmlCdata_C@2:

; 487  :             }
; 488  :          }
; 489  :          isNmtoken = TRUE;

  000b2	c6 45 0c 01	 mov	 BYTE PTR _isNmtoken$[ebp], 1

; 490  :       }

  000b6	e9 59 ff ff ff	 jmp	 $LN11@XmlCdata_C@2
$LN12@XmlCdata_C@2:

; 491  :    }
; 492  :    return result;

  000bb	8a 45 fb	 mov	 al, BYTE PTR _result$[ebp]

; 493  : }

  000be	8b e5		 mov	 esp, ebp
  000c0	5d		 pop	 ebp
  000c1	c3		 ret	 0
?XmlCdata_CheckLatin1Name@@YAEPB_WE@Z ENDP		; XmlCdata_CheckLatin1Name
_TEXT	ENDS
PUBLIC	?XmlCdata_CheckLatin1@@YAEPB_W@Z		; XmlCdata_CheckLatin1
; Function compile flags: /Odtp
;	COMDAT ?XmlCdata_CheckLatin1@@YAEPB_W@Z
_TEXT	SEGMENT
_result$ = -5						; size = 1
_code$ = -4						; size = 2
_pStr$ = 8						; size = 4
?XmlCdata_CheckLatin1@@YAEPB_W@Z PROC			; XmlCdata_CheckLatin1, COMDAT

; 419  : {

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

; 420  :    TCHAR code;
; 421  :    Bool result = TRUE;

  00006	c6 45 fb 01	 mov	 BYTE PTR _result$[ebp], 1

; 422  : 
; 423  :    if (pStr != NULL)

  0000a	83 7d 08 00	 cmp	 DWORD PTR _pStr$[ebp], 0
  0000e	74 47		 je	 SHORT $LN5@XmlCdata_C@3
$LN4@XmlCdata_C@3:

; 424  :    {
; 425  :       while ( (code = *(pStr++)) != 0 )

  00010	8b 45 08	 mov	 eax, DWORD PTR _pStr$[ebp]
  00013	66 8b 08	 mov	 cx, WORD PTR [eax]
  00016	66 89 4d fc	 mov	 WORD PTR _code$[ebp], cx
  0001a	0f b7 55 fc	 movzx	 edx, WORD PTR _code$[ebp]
  0001e	8b 45 08	 mov	 eax, DWORD PTR _pStr$[ebp]
  00021	83 c0 02	 add	 eax, 2
  00024	89 45 08	 mov	 DWORD PTR _pStr$[ebp], eax
  00027	85 d2		 test	 edx, edx
  00029	74 2c		 je	 SHORT $LN5@XmlCdata_C@3

; 426  :       {
; 427  :          // invalid codes are [0x0...0x31] except whitespace characters TAB, NL, CR
; 428  :          if (code < 0x20)

  0002b	0f b7 4d fc	 movzx	 ecx, WORD PTR _code$[ebp]
  0002f	83 f9 20	 cmp	 ecx, 32			; 00000020H
  00032	7d 21		 jge	 SHORT $LN2@XmlCdata_C@3

; 429  :          {
; 430  :             if ((code != 0x09) && (code != 0x0A) && (code != 0x0D))

  00034	0f b7 55 fc	 movzx	 edx, WORD PTR _code$[ebp]
  00038	83 fa 09	 cmp	 edx, 9
  0003b	74 18		 je	 SHORT $LN2@XmlCdata_C@3
  0003d	0f b7 45 fc	 movzx	 eax, WORD PTR _code$[ebp]
  00041	83 f8 0a	 cmp	 eax, 10			; 0000000aH
  00044	74 0f		 je	 SHORT $LN2@XmlCdata_C@3
  00046	0f b7 4d fc	 movzx	 ecx, WORD PTR _code$[ebp]
  0004a	83 f9 0d	 cmp	 ecx, 13			; 0000000dH
  0004d	74 06		 je	 SHORT $LN2@XmlCdata_C@3

; 431  :             {
; 432  :                result = FALSE;

  0004f	c6 45 fb 00	 mov	 BYTE PTR _result$[ebp], 0

; 433  :                break;

  00053	eb 02		 jmp	 SHORT $LN5@XmlCdata_C@3
$LN2@XmlCdata_C@3:

; 434  :             }
; 435  :          }
; 436  :       }

  00055	eb b9		 jmp	 SHORT $LN4@XmlCdata_C@3
$LN5@XmlCdata_C@3:

; 437  :    }
; 438  :    return result;

  00057	8a 45 fb	 mov	 al, BYTE PTR _result$[ebp]

; 439  : }

  0005a	8b e5		 mov	 esp, ebp
  0005c	5d		 pop	 ebp
  0005d	c3		 ret	 0
?XmlCdata_CheckLatin1@@YAEPB_W@Z ENDP			; XmlCdata_CheckLatin1
_TEXT	ENDS
PUBLIC	?XmlCdata_TrimWhitespace@@YAXPAUXML_STR_BUF@@@Z	; XmlCdata_TrimWhitespace
; Function compile flags: /Odtp
;	COMDAT ?XmlCdata_TrimWhitespace@@YAXPAUXML_STR_BUF@@@Z
_TEXT	SEGMENT
_len$ = -12						; size = 4
_toff$ = -8						; size = 4
_p$ = -4						; size = 4
_pBuf$ = 8						; size = 4
?XmlCdata_TrimWhitespace@@YAXPAUXML_STR_BUF@@@Z PROC	; XmlCdata_TrimWhitespace, COMDAT

; 234  : {

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

; 235  :    uint len;
; 236  :    uint toff;
; 237  :    TCHAR*  p;
; 238  : 
; 239  :    if (pBuf != NULL)

  00006	83 7d 08 00	 cmp	 DWORD PTR _pBuf$[ebp], 0
  0000a	0f 84 dd 00 00
	00		 je	 $LN10@XmlCdata_T

; 240  :    {
; 241  :       if (pBuf->off > 0)

  00010	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  00013	83 78 10 00	 cmp	 DWORD PTR [eax+16], 0
  00017	0f 86 d0 00 00
	00		 jbe	 $LN10@XmlCdata_T

; 242  :       {
; 243  :          len = pBuf->off;

  0001d	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00020	8b 51 10	 mov	 edx, DWORD PTR [ecx+16]
  00023	89 55 f4	 mov	 DWORD PTR _len$[ebp], edx

; 244  :          p = pBuf->pStrBuf + len - 1;

  00026	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  00029	8b 08		 mov	 ecx, DWORD PTR [eax]
  0002b	8b 55 f4	 mov	 edx, DWORD PTR _len$[ebp]
  0002e	8d 44 51 fe	 lea	 eax, DWORD PTR [ecx+edx*2-2]
  00032	89 45 fc	 mov	 DWORD PTR _p$[ebp], eax
$LN7@XmlCdata_T:

; 245  : 
; 246  :          while ((len > 0) &&
; 247  :                 ((*p == ' ') || (*p == '\t') || (*p == '\n') || (*p == '\r')))

  00035	83 7d f4 00	 cmp	 DWORD PTR _len$[ebp], 0
  00039	76 40		 jbe	 SHORT $LN6@XmlCdata_T
  0003b	8b 4d fc	 mov	 ecx, DWORD PTR _p$[ebp]
  0003e	0f b7 11	 movzx	 edx, WORD PTR [ecx]
  00041	83 fa 20	 cmp	 edx, 32			; 00000020H
  00044	74 21		 je	 SHORT $LN5@XmlCdata_T
  00046	8b 45 fc	 mov	 eax, DWORD PTR _p$[ebp]
  00049	0f b7 08	 movzx	 ecx, WORD PTR [eax]
  0004c	83 f9 09	 cmp	 ecx, 9
  0004f	74 16		 je	 SHORT $LN5@XmlCdata_T
  00051	8b 55 fc	 mov	 edx, DWORD PTR _p$[ebp]
  00054	0f b7 02	 movzx	 eax, WORD PTR [edx]
  00057	83 f8 0a	 cmp	 eax, 10			; 0000000aH
  0005a	74 0b		 je	 SHORT $LN5@XmlCdata_T
  0005c	8b 4d fc	 mov	 ecx, DWORD PTR _p$[ebp]
  0005f	0f b7 11	 movzx	 edx, WORD PTR [ecx]
  00062	83 fa 0d	 cmp	 edx, 13			; 0000000dH
  00065	75 14		 jne	 SHORT $LN6@XmlCdata_T
$LN5@XmlCdata_T:

; 248  :          {
; 249  :             len--;

  00067	8b 45 f4	 mov	 eax, DWORD PTR _len$[ebp]
  0006a	83 e8 01	 sub	 eax, 1
  0006d	89 45 f4	 mov	 DWORD PTR _len$[ebp], eax

; 250  :             p--;

  00070	8b 4d fc	 mov	 ecx, DWORD PTR _p$[ebp]
  00073	83 e9 02	 sub	 ecx, 2
  00076	89 4d fc	 mov	 DWORD PTR _p$[ebp], ecx

; 251  :          }

  00079	eb ba		 jmp	 SHORT $LN7@XmlCdata_T
$LN6@XmlCdata_T:

; 252  :          pBuf->off = len;

  0007b	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0007e	8b 45 f4	 mov	 eax, DWORD PTR _len$[ebp]
  00081	89 42 10	 mov	 DWORD PTR [edx+16], eax

; 253  :          *(++p) = 0;

  00084	8b 4d fc	 mov	 ecx, DWORD PTR _p$[ebp]
  00087	83 c1 02	 add	 ecx, 2
  0008a	89 4d fc	 mov	 DWORD PTR _p$[ebp], ecx
  0008d	33 d2		 xor	 edx, edx
  0008f	8b 45 fc	 mov	 eax, DWORD PTR _p$[ebp]
  00092	66 89 10	 mov	 WORD PTR [eax], dx

; 254  : 
; 255  :          p = pBuf->pStrBuf;

  00095	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00098	8b 11		 mov	 edx, DWORD PTR [ecx]
  0009a	89 55 fc	 mov	 DWORD PTR _p$[ebp], edx

; 256  :          toff = 0;

  0009d	c7 45 f8 00 00
	00 00		 mov	 DWORD PTR _toff$[ebp], 0
$LN4@XmlCdata_T:

; 257  :          while ((*p == ' ') || (*p == '\t') || (*p == '\n') || (*p == '\r'))

  000a4	8b 45 fc	 mov	 eax, DWORD PTR _p$[ebp]
  000a7	0f b7 08	 movzx	 ecx, WORD PTR [eax]
  000aa	83 f9 20	 cmp	 ecx, 32			; 00000020H
  000ad	74 21		 je	 SHORT $LN2@XmlCdata_T
  000af	8b 55 fc	 mov	 edx, DWORD PTR _p$[ebp]
  000b2	0f b7 02	 movzx	 eax, WORD PTR [edx]
  000b5	83 f8 09	 cmp	 eax, 9
  000b8	74 16		 je	 SHORT $LN2@XmlCdata_T
  000ba	8b 4d fc	 mov	 ecx, DWORD PTR _p$[ebp]
  000bd	0f b7 11	 movzx	 edx, WORD PTR [ecx]
  000c0	83 fa 0a	 cmp	 edx, 10			; 0000000aH
  000c3	74 0b		 je	 SHORT $LN2@XmlCdata_T
  000c5	8b 45 fc	 mov	 eax, DWORD PTR _p$[ebp]
  000c8	0f b7 08	 movzx	 ecx, WORD PTR [eax]
  000cb	83 f9 0d	 cmp	 ecx, 13			; 0000000dH
  000ce	75 14		 jne	 SHORT $LN3@XmlCdata_T
$LN2@XmlCdata_T:

; 258  :          {
; 259  :             toff++;

  000d0	8b 55 f8	 mov	 edx, DWORD PTR _toff$[ebp]
  000d3	83 c2 01	 add	 edx, 1
  000d6	89 55 f8	 mov	 DWORD PTR _toff$[ebp], edx

; 260  :             p++;

  000d9	8b 45 fc	 mov	 eax, DWORD PTR _p$[ebp]
  000dc	83 c0 02	 add	 eax, 2
  000df	89 45 fc	 mov	 DWORD PTR _p$[ebp], eax

; 261  :          }

  000e2	eb c0		 jmp	 SHORT $LN4@XmlCdata_T
$LN3@XmlCdata_T:

; 262  :          pBuf->skip = toff;

  000e4	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  000e7	8b 55 f8	 mov	 edx, DWORD PTR _toff$[ebp]
  000ea	89 51 0c	 mov	 DWORD PTR [ecx+12], edx
$LN10@XmlCdata_T:

; 263  :       }
; 264  :    }
; 265  :    else
; 266  :       fatal0(_T("XmlCdata-TrimWhitespace: invalid NULL ptr param"));
; 267  : }

  000ed	8b e5		 mov	 esp, ebp
  000ef	5d		 pop	 ebp
  000f0	c3		 ret	 0
?XmlCdata_TrimWhitespace@@YAXPAUXML_STR_BUF@@@Z ENDP	; XmlCdata_TrimWhitespace
_TEXT	ENDS
PUBLIC	?XmlCdata_Assign@@YAXPAUXML_STR_BUF@@0@Z	; XmlCdata_Assign
; Function compile flags: /Odtp
;	COMDAT ?XmlCdata_Assign@@YAXPAUXML_STR_BUF@@0@Z
_TEXT	SEGMENT
_tmpSize$ = -8						; size = 4
_pTmp$ = -4						; size = 4
_pDestBuf$ = 8						; size = 4
_pSrcBuf$ = 12						; size = 4
?XmlCdata_Assign@@YAXPAUXML_STR_BUF@@0@Z PROC		; XmlCdata_Assign, COMDAT

; 181  : {

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

; 182  :    TCHAR*  pTmp;
; 183  :    uint tmpSize;
; 184  : 
; 185  :    if ((pSrcBuf != NULL) && (pDestBuf != NULL))

  00006	83 7d 0c 00	 cmp	 DWORD PTR _pSrcBuf$[ebp], 0
  0000a	0f 84 98 00 00
	00		 je	 $LN5@XmlCdata_A
  00010	83 7d 08 00	 cmp	 DWORD PTR _pDestBuf$[ebp], 0
  00014	0f 84 8e 00 00
	00		 je	 $LN5@XmlCdata_A

; 186  :    {
; 187  :       if (pSrcBuf->pStrBuf != NULL)

  0001a	8b 45 0c	 mov	 eax, DWORD PTR _pSrcBuf$[ebp]
  0001d	83 38 00	 cmp	 DWORD PTR [eax], 0
  00020	0f 84 82 00 00
	00		 je	 $LN5@XmlCdata_A

; 188  :       {
; 189  :          // swap pointers and size between the two buffers
; 190  :          pTmp = pDestBuf->pStrBuf;

  00026	8b 4d 08	 mov	 ecx, DWORD PTR _pDestBuf$[ebp]
  00029	8b 11		 mov	 edx, DWORD PTR [ecx]
  0002b	89 55 fc	 mov	 DWORD PTR _pTmp$[ebp], edx

; 191  :          tmpSize = pDestBuf->size;

  0002e	8b 45 08	 mov	 eax, DWORD PTR _pDestBuf$[ebp]
  00031	8b 48 08	 mov	 ecx, DWORD PTR [eax+8]
  00034	89 4d f8	 mov	 DWORD PTR _tmpSize$[ebp], ecx

; 192  : 
; 193  :          pDestBuf->pStrBuf = pSrcBuf->pStrBuf;

  00037	8b 55 08	 mov	 edx, DWORD PTR _pDestBuf$[ebp]
  0003a	8b 45 0c	 mov	 eax, DWORD PTR _pSrcBuf$[ebp]
  0003d	8b 08		 mov	 ecx, DWORD PTR [eax]
  0003f	89 0a		 mov	 DWORD PTR [edx], ecx

; 194  :          pDestBuf->size = pSrcBuf->size;

  00041	8b 55 08	 mov	 edx, DWORD PTR _pDestBuf$[ebp]
  00044	8b 45 0c	 mov	 eax, DWORD PTR _pSrcBuf$[ebp]
  00047	8b 48 08	 mov	 ecx, DWORD PTR [eax+8]
  0004a	89 4a 08	 mov	 DWORD PTR [edx+8], ecx

; 195  :          pDestBuf->off = pSrcBuf->off;

  0004d	8b 55 08	 mov	 edx, DWORD PTR _pDestBuf$[ebp]
  00050	8b 45 0c	 mov	 eax, DWORD PTR _pSrcBuf$[ebp]
  00053	8b 48 10	 mov	 ecx, DWORD PTR [eax+16]
  00056	89 4a 10	 mov	 DWORD PTR [edx+16], ecx

; 196  :          pDestBuf->skip = pSrcBuf->skip;

  00059	8b 55 08	 mov	 edx, DWORD PTR _pDestBuf$[ebp]
  0005c	8b 45 0c	 mov	 eax, DWORD PTR _pSrcBuf$[ebp]
  0005f	8b 48 0c	 mov	 ecx, DWORD PTR [eax+12]
  00062	89 4a 0c	 mov	 DWORD PTR [edx+12], ecx

; 197  :          pDestBuf->lang = pSrcBuf->lang;

  00065	8b 55 08	 mov	 edx, DWORD PTR _pDestBuf$[ebp]
  00068	8b 45 0c	 mov	 eax, DWORD PTR _pSrcBuf$[ebp]
  0006b	8b 48 14	 mov	 ecx, DWORD PTR [eax+20]
  0006e	89 4a 14	 mov	 DWORD PTR [edx+20], ecx

; 198  : 
; 199  :          pSrcBuf->pStrBuf = pTmp;

  00071	8b 55 0c	 mov	 edx, DWORD PTR _pSrcBuf$[ebp]
  00074	8b 45 fc	 mov	 eax, DWORD PTR _pTmp$[ebp]
  00077	89 02		 mov	 DWORD PTR [edx], eax

; 200  :          pSrcBuf->size = tmpSize;

  00079	8b 4d 0c	 mov	 ecx, DWORD PTR _pSrcBuf$[ebp]
  0007c	8b 55 f8	 mov	 edx, DWORD PTR _tmpSize$[ebp]
  0007f	89 51 08	 mov	 DWORD PTR [ecx+8], edx

; 201  :          pSrcBuf->off = 0;

  00082	8b 45 0c	 mov	 eax, DWORD PTR _pSrcBuf$[ebp]
  00085	c7 40 10 00 00
	00 00		 mov	 DWORD PTR [eax+16], 0

; 202  :          pSrcBuf->skip = 0;

  0008c	8b 4d 0c	 mov	 ecx, DWORD PTR _pSrcBuf$[ebp]
  0008f	c7 41 0c 00 00
	00 00		 mov	 DWORD PTR [ecx+12], 0

; 203  :          if (pSrcBuf->pStrBuf != NULL)

  00096	8b 55 0c	 mov	 edx, DWORD PTR _pSrcBuf$[ebp]
  00099	83 3a 00	 cmp	 DWORD PTR [edx], 0
  0009c	74 0a		 je	 SHORT $LN5@XmlCdata_A

; 204  :          {
; 205  :             pSrcBuf->pStrBuf[0] = 0;

  0009e	8b 45 0c	 mov	 eax, DWORD PTR _pSrcBuf$[ebp]
  000a1	8b 08		 mov	 ecx, DWORD PTR [eax]
  000a3	33 d2		 xor	 edx, edx
  000a5	66 89 11	 mov	 WORD PTR [ecx], dx
$LN5@XmlCdata_A:

; 206  :          }
; 207  :       }
; 208  :    }
; 209  :    else
; 210  :       fatal0(_T("XmlCdata-Assign: invalid NULL ptr param"));
; 211  : }

  000a8	8b e5		 mov	 esp, ebp
  000aa	5d		 pop	 ebp
  000ab	c3		 ret	 0
?XmlCdata_Assign@@YAXPAUXML_STR_BUF@@0@Z ENDP		; XmlCdata_Assign
_TEXT	ENDS
PUBLIC	?XmlCdata_Grow@@YAXPAUXML_STR_BUF@@I@Z		; XmlCdata_Grow
; Function compile flags: /Odtp
;	COMDAT ?XmlCdata_Grow@@YAXPAUXML_STR_BUF@@I@Z
_TEXT	SEGMENT
_pNewbuf$ = -8						; size = 4
_newSize$ = -4						; size = 4
_pBuf$ = 8						; size = 4
_len$ = 12						; size = 4
?XmlCdata_Grow@@YAXPAUXML_STR_BUF@@I@Z PROC		; XmlCdata_Grow, COMDAT

; 111  : {

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

; 112  :    TCHAR*  pNewbuf;
; 113  :    uint newSize;
; 114  : 
; 115  :    assert((pBuf->pStrBuf == NULL) ? (pBuf->off == 0) : (pBuf->off + 1 <= pBuf->size));
; 116  :    assert(pBuf->skip <= pBuf->off);
; 117  : 
; 118  :    // size hint may be zero if the caller doesn't call _T("init") above, but instead just uses memset(0)
; 119  :    if (pBuf->sizeHint == 0)

  00006	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  00009	83 78 04 00	 cmp	 DWORD PTR [eax+4], 0
  0000d	75 0a		 jne	 SHORT $LN5@XmlCdata_G

; 120  :       pBuf->sizeHint = DEFAULT_BUF_SIZE_STEP;

  0000f	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00012	c7 41 04 00 08
	00 00		 mov	 DWORD PTR [ecx+4], 2048	; 00000800H
$LN5@XmlCdata_G:

; 121  : 
; 122  :    // increase buffer size in steps of the hint
; 123  :    newSize = pBuf->size + pBuf->sizeHint;

  00019	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0001c	8b 42 08	 mov	 eax, DWORD PTR [edx+8]
  0001f	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00022	03 41 04	 add	 eax, DWORD PTR [ecx+4]
  00025	89 45 fc	 mov	 DWORD PTR _newSize$[ebp], eax

; 124  :    if (newSize < pBuf->off - pBuf->skip + len + 1)

  00028	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0002b	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  0002e	8b 4a 10	 mov	 ecx, DWORD PTR [edx+16]
  00031	2b 48 0c	 sub	 ecx, DWORD PTR [eax+12]
  00034	8b 55 0c	 mov	 edx, DWORD PTR _len$[ebp]
  00037	8d 44 11 01	 lea	 eax, DWORD PTR [ecx+edx+1]
  0003b	39 45 fc	 cmp	 DWORD PTR _newSize$[ebp], eax
  0003e	73 27		 jae	 SHORT $LN4@XmlCdata_G

; 125  :    {
; 126  :       dprintf4(_T("XmlCdata-Grow: buffer len increment %d-%d+%d exceeds size hint %d\n"), pBuf->off, pBuf->skip, len, pBuf->sizeHint);
; 127  :       newSize = pBuf->off - pBuf->skip + len + 1 + (pBuf->sizeHint / 2);

  00040	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00043	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  00046	8b 41 10	 mov	 eax, DWORD PTR [ecx+16]
  00049	2b 42 0c	 sub	 eax, DWORD PTR [edx+12]
  0004c	03 45 0c	 add	 eax, DWORD PTR _len$[ebp]
  0004f	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00052	8b 51 04	 mov	 edx, DWORD PTR [ecx+4]
  00055	d1 ea		 shr	 edx, 1
  00057	8d 44 10 01	 lea	 eax, DWORD PTR [eax+edx+1]
  0005b	89 45 fc	 mov	 DWORD PTR _newSize$[ebp], eax

; 128  :       pBuf->sizeHint = newSize;

  0005e	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00061	8b 55 fc	 mov	 edx, DWORD PTR _newSize$[ebp]
  00064	89 51 04	 mov	 DWORD PTR [ecx+4], edx
$LN4@XmlCdata_G:

; 129  :    }
; 130  : 
; 131  :    // copy content into the new buffer and free the old one
; 132  :    if ((pBuf->pStrBuf != NULL) && (pBuf->skip == 0))

  00067	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  0006a	83 38 00	 cmp	 DWORD PTR [eax], 0
  0006d	74 20		 je	 SHORT $LN3@XmlCdata_G
  0006f	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00072	83 79 0c 00	 cmp	 DWORD PTR [ecx+12], 0
  00076	75 17		 jne	 SHORT $LN3@XmlCdata_G

; 133  :    {
; 134  :       pNewbuf = (TCHAR*) xrealloc(pBuf->pStrBuf, newSize);

  00078	8b 55 fc	 mov	 edx, DWORD PTR _newSize$[ebp]
  0007b	52		 push	 edx
  0007c	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  0007f	8b 08		 mov	 ecx, DWORD PTR [eax]
  00081	51		 push	 ecx
  00082	e8 00 00 00 00	 call	 _realloc
  00087	83 c4 08	 add	 esp, 8
  0008a	89 45 f8	 mov	 DWORD PTR _pNewbuf$[ebp], eax

; 135  :    }
; 136  :    else

  0008d	eb 57		 jmp	 SHORT $LN2@XmlCdata_G
$LN3@XmlCdata_G:

; 137  :    {
; 138  :       pNewbuf = (TCHAR*) xmalloc(newSize);

  0008f	8b 55 fc	 mov	 edx, DWORD PTR _newSize$[ebp]
  00092	52		 push	 edx
  00093	e8 00 00 00 00	 call	 _malloc
  00098	83 c4 04	 add	 esp, 4
  0009b	89 45 f8	 mov	 DWORD PTR _pNewbuf$[ebp], eax

; 139  :       if (pBuf->pStrBuf != NULL)

  0009e	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  000a1	83 38 00	 cmp	 DWORD PTR [eax], 0
  000a4	74 36		 je	 SHORT $LN1@XmlCdata_G

; 140  :       {
; 141  :          memcpy(pNewbuf, pBuf->pStrBuf + pBuf->skip, pBuf->size - pBuf->skip);

  000a6	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  000a9	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  000ac	8b 41 08	 mov	 eax, DWORD PTR [ecx+8]
  000af	2b 42 0c	 sub	 eax, DWORD PTR [edx+12]
  000b2	50		 push	 eax
  000b3	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  000b6	8b 51 0c	 mov	 edx, DWORD PTR [ecx+12]
  000b9	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  000bc	8b 08		 mov	 ecx, DWORD PTR [eax]
  000be	8d 14 51	 lea	 edx, DWORD PTR [ecx+edx*2]
  000c1	52		 push	 edx
  000c2	8b 45 f8	 mov	 eax, DWORD PTR _pNewbuf$[ebp]
  000c5	50		 push	 eax
  000c6	e8 00 00 00 00	 call	 _memcpy
  000cb	83 c4 0c	 add	 esp, 12			; 0000000cH

; 142  :          xfree(pBuf->pStrBuf);

  000ce	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  000d1	8b 11		 mov	 edx, DWORD PTR [ecx]
  000d3	52		 push	 edx
  000d4	e8 00 00 00 00	 call	 _free
  000d9	83 c4 04	 add	 esp, 4
$LN1@XmlCdata_G:

; 143  :       }
; 144  :       pBuf->skip = 0;

  000dc	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  000df	c7 40 0c 00 00
	00 00		 mov	 DWORD PTR [eax+12], 0
$LN2@XmlCdata_G:

; 145  :    }
; 146  :    pBuf->pStrBuf = pNewbuf;

  000e6	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  000e9	8b 55 f8	 mov	 edx, DWORD PTR _pNewbuf$[ebp]
  000ec	89 11		 mov	 DWORD PTR [ecx], edx

; 147  :    pBuf->size = newSize;

  000ee	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  000f1	8b 4d fc	 mov	 ecx, DWORD PTR _newSize$[ebp]
  000f4	89 48 08	 mov	 DWORD PTR [eax+8], ecx

; 148  : }

  000f7	8b e5		 mov	 esp, ebp
  000f9	5d		 pop	 ebp
  000fa	c3		 ret	 0
?XmlCdata_Grow@@YAXPAUXML_STR_BUF@@I@Z ENDP		; XmlCdata_Grow
_TEXT	ENDS
PUBLIC	?XmlCdata_Free@@YAXPAUXML_STR_BUF@@@Z		; XmlCdata_Free
; Function compile flags: /Odtp
;	COMDAT ?XmlCdata_Free@@YAXPAUXML_STR_BUF@@@Z
_TEXT	SEGMENT
_pBuf$ = 8						; size = 4
?XmlCdata_Free@@YAXPAUXML_STR_BUF@@@Z PROC		; XmlCdata_Free, COMDAT

; 91   : {

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

; 92   :    if (pBuf != NULL)

  00003	83 7d 08 00	 cmp	 DWORD PTR _pBuf$[ebp], 0
  00007	74 53		 je	 SHORT $LN8@XmlCdata_F
$LN6@XmlCdata_F:

; 93   :    {
; 94   :       XmlCdata_Reset(pBuf);

  00009	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  0000c	83 38 00	 cmp	 DWORD PTR [eax], 0
  0000f	74 1e		 je	 SHORT $LN5@XmlCdata_F
  00011	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00014	c7 41 10 00 00
	00 00		 mov	 DWORD PTR [ecx+16], 0
  0001b	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0001e	c7 42 0c 00 00
	00 00		 mov	 DWORD PTR [edx+12], 0
  00025	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  00028	8b 08		 mov	 ecx, DWORD PTR [eax]
  0002a	33 d2		 xor	 edx, edx
  0002c	66 89 11	 mov	 WORD PTR [ecx], dx
$LN5@XmlCdata_F:
  0002f	33 c0		 xor	 eax, eax
  00031	75 d6		 jne	 SHORT $LN6@XmlCdata_F

; 95   : 
; 96   :       if (pBuf->pStrBuf != NULL)

  00033	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00036	83 39 00	 cmp	 DWORD PTR [ecx], 0
  00039	74 21		 je	 SHORT $LN8@XmlCdata_F

; 97   :       {
; 98   :          xfree(pBuf->pStrBuf);

  0003b	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0003e	8b 02		 mov	 eax, DWORD PTR [edx]
  00040	50		 push	 eax
  00041	e8 00 00 00 00	 call	 _free
  00046	83 c4 04	 add	 esp, 4

; 99   :          pBuf->pStrBuf = NULL;

  00049	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  0004c	c7 01 00 00 00
	00		 mov	 DWORD PTR [ecx], 0

; 100  :          pBuf->size = 0;

  00052	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  00055	c7 42 08 00 00
	00 00		 mov	 DWORD PTR [edx+8], 0
$LN8@XmlCdata_F:

; 101  :       }
; 102  :    }
; 103  :    else
; 104  :       fatal0(_T("XmlCdata-Free: illegal NULL ptr param"));
; 105  : }

  0005c	5d		 pop	 ebp
  0005d	c3		 ret	 0
?XmlCdata_Free@@YAXPAUXML_STR_BUF@@@Z ENDP		; XmlCdata_Free
_TEXT	ENDS
PUBLIC	?XmlCdata_Init@@YAXPAUXML_STR_BUF@@I@Z		; XmlCdata_Init
; Function compile flags: /Odtp
;	COMDAT ?XmlCdata_Init@@YAXPAUXML_STR_BUF@@I@Z
_TEXT	SEGMENT
_pBuf$ = 8						; size = 4
_sizeHint$ = 12						; size = 4
?XmlCdata_Init@@YAXPAUXML_STR_BUF@@I@Z PROC		; XmlCdata_Init, COMDAT

; 50   : {

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

; 51   :    if (pBuf != NULL)

  00003	83 7d 08 00	 cmp	 DWORD PTR _pBuf$[ebp], 0
  00007	74 26		 je	 SHORT $LN4@XmlCdata_I

; 52   :    {
; 53   :       if (sizeHint == 0)

  00009	83 7d 0c 00	 cmp	 DWORD PTR _sizeHint$[ebp], 0
  0000d	75 07		 jne	 SHORT $LN2@XmlCdata_I

; 54   :          sizeHint = DEFAULT_BUF_SIZE_STEP;

  0000f	c7 45 0c 00 08
	00 00		 mov	 DWORD PTR _sizeHint$[ebp], 2048 ; 00000800H
$LN2@XmlCdata_I:

; 55   : 
; 56   :       memset(pBuf, 0, sizeof(XML_STR_BUF));

  00016	6a 18		 push	 24			; 00000018H
  00018	6a 00		 push	 0
  0001a	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  0001d	50		 push	 eax
  0001e	e8 00 00 00 00	 call	 _memset
  00023	83 c4 0c	 add	 esp, 12			; 0000000cH

; 57   :       pBuf->sizeHint = sizeHint;

  00026	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00029	8b 55 0c	 mov	 edx, DWORD PTR _sizeHint$[ebp]
  0002c	89 51 04	 mov	 DWORD PTR [ecx+4], edx
$LN4@XmlCdata_I:

; 58   :    }
; 59   :    else
; 60   :       fatal0(_T("XmlCdata-Init: illegal NULL ptr param"));
; 61   : }

  0002f	5d		 pop	 ebp
  00030	c3		 ret	 0
?XmlCdata_Init@@YAXPAUXML_STR_BUF@@I@Z ENDP		; XmlCdata_Init
PUBLIC	?XmlCdata_CheckUtf8Name@@YAEPB_WE@Z		; XmlCdata_CheckUtf8Name
; Function compile flags: /Odtp
;	COMDAT ?XmlCdata_CheckUtf8Name@@YAEPB_WE@Z
_TEXT	SEGMENT
tv82 = -24						; size = 4
_result$ = -17						; size = 1
_c2$ = -16						; size = 2
_c1$ = -12						; size = 2
_code$ = -8						; size = 4
_c3$ = -4						; size = 2
_pStr$ = 8						; size = 4
_isNmtoken$ = 12					; size = 1
?XmlCdata_CheckUtf8Name@@YAEPB_WE@Z PROC		; XmlCdata_CheckUtf8Name, COMDAT

; 742  : {

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

; 743  :    TCHAR c1, c2, c3;
; 744  :    uint code;
; 745  :    Bool result = TRUE;

  00006	c6 45 ef 01	 mov	 BYTE PTR _result$[ebp], 1

; 746  : 
; 747  :    if (pStr != NULL)

  0000a	83 7d 08 00	 cmp	 DWORD PTR _pStr$[ebp], 0
  0000e	0f 84 d5 01 00
	00		 je	 $LN21@XmlCdata_C@4
$LN20@XmlCdata_C@4:

; 748  :    {
; 749  :       while ( ((c1 = *(pStr++)) != 0) && result )

  00014	8b 45 08	 mov	 eax, DWORD PTR _pStr$[ebp]
  00017	66 8b 08	 mov	 cx, WORD PTR [eax]
  0001a	66 89 4d f4	 mov	 WORD PTR _c1$[ebp], cx
  0001e	0f b7 55 f4	 movzx	 edx, WORD PTR _c1$[ebp]
  00022	8b 45 08	 mov	 eax, DWORD PTR _pStr$[ebp]
  00025	83 c0 02	 add	 eax, 2
  00028	89 45 08	 mov	 DWORD PTR _pStr$[ebp], eax
  0002b	85 d2		 test	 edx, edx
  0002d	0f 84 b6 01 00
	00		 je	 $LN21@XmlCdata_C@4
  00033	0f b6 4d ef	 movzx	 ecx, BYTE PTR _result$[ebp]
  00037	85 c9		 test	 ecx, ecx
  00039	0f 84 aa 01 00
	00		 je	 $LN21@XmlCdata_C@4

; 750  :       {
; 751  :          if (c1 < 0x80)

  0003f	0f b7 55 f4	 movzx	 edx, WORD PTR _c1$[ebp]
  00043	81 fa 80 00 00
	00		 cmp	 edx, 128		; 00000080H
  00049	7d 2d		 jge	 SHORT $LN18@XmlCdata_C@4

; 752  :          {
; 753  :             if (c1 < 0x20)

  0004b	0f b7 45 f4	 movzx	 eax, WORD PTR _c1$[ebp]
  0004f	83 f8 20	 cmp	 eax, 32			; 00000020H
  00052	7d 1f		 jge	 SHORT $LN17@XmlCdata_C@4

; 754  :             {
; 755  :                if ((c1 != 0x09) && (c1 != 0x0A) && (c1 != 0x0D))

  00054	0f b7 4d f4	 movzx	 ecx, WORD PTR _c1$[ebp]
  00058	83 f9 09	 cmp	 ecx, 9
  0005b	74 16		 je	 SHORT $LN17@XmlCdata_C@4
  0005d	0f b7 55 f4	 movzx	 edx, WORD PTR _c1$[ebp]
  00061	83 fa 0a	 cmp	 edx, 10			; 0000000aH
  00064	74 0d		 je	 SHORT $LN17@XmlCdata_C@4
  00066	0f b7 45 f4	 movzx	 eax, WORD PTR _c1$[ebp]
  0006a	83 f8 0d	 cmp	 eax, 13			; 0000000dH
  0006d	74 04		 je	 SHORT $LN17@XmlCdata_C@4

; 756  :                {
; 757  :                   dprintf1(_T("XmlCdata-CheckUtf8Name: invalid control code 0x%02X\n"), c1);
; 758  :                   result = FALSE;

  0006f	c6 45 ef 00	 mov	 BYTE PTR _result$[ebp], 0
$LN17@XmlCdata_C@4:

; 759  :                }
; 760  :             }
; 761  :             // else: ASCII range already checked by scanner
; 762  :          }
; 763  :          else

  00073	e9 68 01 00 00	 jmp	 $LN15@XmlCdata_C@4
$LN18@XmlCdata_C@4:

; 764  :          {
; 765  :             switch (c1 >> 4)

  00078	0f b7 4d f4	 movzx	 ecx, WORD PTR _c1$[ebp]
  0007c	c1 f9 04	 sar	 ecx, 4
  0007f	89 4d e8	 mov	 DWORD PTR tv82[ebp], ecx
  00082	8b 55 e8	 mov	 edx, DWORD PTR tv82[ebp]
  00085	83 ea 0c	 sub	 edx, 12			; 0000000cH
  00088	89 55 e8	 mov	 DWORD PTR tv82[ebp], edx
  0008b	83 7d e8 03	 cmp	 DWORD PTR tv82[ebp], 3
  0008f	0f 87 47 01 00
	00		 ja	 $LN1@XmlCdata_C@4
  00095	8b 45 e8	 mov	 eax, DWORD PTR tv82[ebp]
  00098	ff 24 85 00 00
	00 00		 jmp	 DWORD PTR $LN24@XmlCdata_C@4[eax*4]
$LN12@XmlCdata_C@4:

; 766  :             {
; 767  :                case 0xC:  // 2-byte code
; 768  :                case 0xD:
; 769  :                   c2 = *pStr++;

  0009f	8b 4d 08	 mov	 ecx, DWORD PTR _pStr$[ebp]
  000a2	66 8b 11	 mov	 dx, WORD PTR [ecx]
  000a5	66 89 55 f0	 mov	 WORD PTR _c2$[ebp], dx
  000a9	8b 45 08	 mov	 eax, DWORD PTR _pStr$[ebp]
  000ac	83 c0 02	 add	 eax, 2
  000af	89 45 08	 mov	 DWORD PTR _pStr$[ebp], eax

; 770  :                   if ((c2 & ~0x3Fu) == 0x80)

  000b2	0f b7 4d f0	 movzx	 ecx, WORD PTR _c2$[ebp]
  000b6	83 e1 c0	 and	 ecx, -64		; ffffffc0H
  000b9	81 f9 80 00 00
	00		 cmp	 ecx, 128		; 00000080H
  000bf	75 58		 jne	 SHORT $LN11@XmlCdata_C@4

; 771  :                   {
; 772  :                      code = ((c1 & 0x1F) << 6) | (c2 & 0x3F);

  000c1	0f b7 55 f4	 movzx	 edx, WORD PTR _c1$[ebp]
  000c5	83 e2 1f	 and	 edx, 31			; 0000001fH
  000c8	c1 e2 06	 shl	 edx, 6
  000cb	0f b7 45 f0	 movzx	 eax, WORD PTR _c2$[ebp]
  000cf	83 e0 3f	 and	 eax, 63			; 0000003fH
  000d2	0b d0		 or	 edx, eax
  000d4	89 55 f8	 mov	 DWORD PTR _code$[ebp], edx

; 773  : 
; 774  :                      if (  (XmlCdata_SearchUtfCodeRange(code, XmlCData_UtfLetterRange2, XML_UTF_LETTER_RANGE2_COUNT) == FALSE) &&
; 775  :                           ((XmlCdata_SearchUtfCodeRange(code, XmlCData_UtfDigiCombExtRange2, XML_UTF_DIGICOMBEXT_RANGE2_COUNT) == FALSE) || (isNmtoken == FALSE)) )

  000d7	6a 2f		 push	 47			; 0000002fH
  000d9	68 00 00 00 00	 push	 OFFSET _XmlCData_UtfLetterRange2
  000de	8b 4d f8	 mov	 ecx, DWORD PTR _code$[ebp]
  000e1	51		 push	 ecx
  000e2	e8 00 00 00 00	 call	 ?XmlCdata_SearchUtfCodeRange@@YAEIPBUXML_CDATA_UTF_RANGE@@I@Z ; XmlCdata_SearchUtfCodeRange
  000e7	83 c4 0c	 add	 esp, 12			; 0000000cH
  000ea	0f b6 d0	 movzx	 edx, al
  000ed	85 d2		 test	 edx, edx
  000ef	75 26		 jne	 SHORT $LN10@XmlCdata_C@4
  000f1	6a 16		 push	 22			; 00000016H
  000f3	68 00 00 00 00	 push	 OFFSET _XmlCData_UtfDigiCombExtRange2
  000f8	8b 45 f8	 mov	 eax, DWORD PTR _code$[ebp]
  000fb	50		 push	 eax
  000fc	e8 00 00 00 00	 call	 ?XmlCdata_SearchUtfCodeRange@@YAEIPBUXML_CDATA_UTF_RANGE@@I@Z ; XmlCdata_SearchUtfCodeRange
  00101	83 c4 0c	 add	 esp, 12			; 0000000cH
  00104	0f b6 c8	 movzx	 ecx, al
  00107	85 c9		 test	 ecx, ecx
  00109	74 08		 je	 SHORT $LN9@XmlCdata_C@4
  0010b	0f b6 55 0c	 movzx	 edx, BYTE PTR _isNmtoken$[ebp]
  0010f	85 d2		 test	 edx, edx
  00111	75 04		 jne	 SHORT $LN10@XmlCdata_C@4
$LN9@XmlCdata_C@4:

; 776  :                      {
; 777  :                         dprintf3(_T("XmlCdata-CheckUtf8Name: not a letter: 0x%X (2-byte code: 0x%02X,%02X)\n"), code, c1, c2);
; 778  :                         result = FALSE;

  00113	c6 45 ef 00	 mov	 BYTE PTR _result$[ebp], 0
$LN10@XmlCdata_C@4:

; 779  :                      }
; 780  :                   }
; 781  :                   else

  00117	eb 04		 jmp	 SHORT $LN8@XmlCdata_C@4
$LN11@XmlCdata_C@4:

; 782  :                   {
; 783  :                      dprintf2(_T("XmlCdata-CheckUtf8Name: sequence error in 2-byte code: 0x%02X,%02X\n"), c1, c2);
; 784  :                      result = FALSE;

  00119	c6 45 ef 00	 mov	 BYTE PTR _result$[ebp], 0
$LN8@XmlCdata_C@4:

; 785  :                   }
; 786  :                   break;

  0011d	e9 be 00 00 00	 jmp	 $LN15@XmlCdata_C@4
$LN7@XmlCdata_C@4:

; 787  : 
; 788  :                case 0xE:  // 3-byte code
; 789  :                   if ( (((c2 = *(pStr++)) & ~0x3Fu) == 0x80) &&
; 790  :                        (((c3 = *(pStr++)) & ~0x3Fu) == 0x80) )

  00122	8b 45 08	 mov	 eax, DWORD PTR _pStr$[ebp]
  00125	66 8b 08	 mov	 cx, WORD PTR [eax]
  00128	66 89 4d f0	 mov	 WORD PTR _c2$[ebp], cx
  0012c	0f b7 55 f0	 movzx	 edx, WORD PTR _c2$[ebp]
  00130	83 e2 c0	 and	 edx, -64		; ffffffc0H
  00133	8b 45 08	 mov	 eax, DWORD PTR _pStr$[ebp]
  00136	83 c0 02	 add	 eax, 2
  00139	89 45 08	 mov	 DWORD PTR _pStr$[ebp], eax
  0013c	81 fa 80 00 00
	00		 cmp	 edx, 128		; 00000080H
  00142	0f 85 88 00 00
	00		 jne	 $LN6@XmlCdata_C@4
  00148	8b 4d 08	 mov	 ecx, DWORD PTR _pStr$[ebp]
  0014b	66 8b 11	 mov	 dx, WORD PTR [ecx]
  0014e	66 89 55 fc	 mov	 WORD PTR _c3$[ebp], dx
  00152	0f b7 45 fc	 movzx	 eax, WORD PTR _c3$[ebp]
  00156	83 e0 c0	 and	 eax, -64		; ffffffc0H
  00159	8b 4d 08	 mov	 ecx, DWORD PTR _pStr$[ebp]
  0015c	83 c1 02	 add	 ecx, 2
  0015f	89 4d 08	 mov	 DWORD PTR _pStr$[ebp], ecx
  00162	3d 80 00 00 00	 cmp	 eax, 128		; 00000080H
  00167	75 67		 jne	 SHORT $LN6@XmlCdata_C@4

; 791  :                   {
; 792  :                      code = ((c1 & 0x0F) << (2*6)) | ((c2 & 0x3F) << 6) | (c3 & 0x3F);

  00169	0f b7 55 f4	 movzx	 edx, WORD PTR _c1$[ebp]
  0016d	83 e2 0f	 and	 edx, 15			; 0000000fH
  00170	c1 e2 0c	 shl	 edx, 12			; 0000000cH
  00173	0f b7 45 f0	 movzx	 eax, WORD PTR _c2$[ebp]
  00177	83 e0 3f	 and	 eax, 63			; 0000003fH
  0017a	c1 e0 06	 shl	 eax, 6
  0017d	0b d0		 or	 edx, eax
  0017f	0f b7 4d fc	 movzx	 ecx, WORD PTR _c3$[ebp]
  00183	83 e1 3f	 and	 ecx, 63			; 0000003fH
  00186	0b d1		 or	 edx, ecx
  00188	89 55 f8	 mov	 DWORD PTR _code$[ebp], edx

; 793  : 
; 794  :                      if (  (XmlCdata_SearchUtfCodeRange(code, XmlCData_UtfLetterRange3, XML_UTF_LETTER_RANGE3_COUNT) == FALSE) &&
; 795  :                           ((XmlCdata_SearchUtfCodeRange(code, XmlCData_UtfDigiCombExtRange3, XML_UTF_DIGICOMBEXT_RANGE3_COUNT) == FALSE) || (isNmtoken == FALSE)) )

  0018b	68 9c 00 00 00	 push	 156			; 0000009cH
  00190	68 00 00 00 00	 push	 OFFSET _XmlCData_UtfLetterRange3
  00195	8b 55 f8	 mov	 edx, DWORD PTR _code$[ebp]
  00198	52		 push	 edx
  00199	e8 00 00 00 00	 call	 ?XmlCdata_SearchUtfCodeRange@@YAEIPBUXML_CDATA_UTF_RANGE@@I@Z ; XmlCdata_SearchUtfCodeRange
  0019e	83 c4 0c	 add	 esp, 12			; 0000000cH
  001a1	0f b6 c0	 movzx	 eax, al
  001a4	85 c0		 test	 eax, eax
  001a6	75 26		 jne	 SHORT $LN5@XmlCdata_C@4
  001a8	6a 61		 push	 97			; 00000061H
  001aa	68 00 00 00 00	 push	 OFFSET _XmlCData_UtfDigiCombExtRange3
  001af	8b 4d f8	 mov	 ecx, DWORD PTR _code$[ebp]
  001b2	51		 push	 ecx
  001b3	e8 00 00 00 00	 call	 ?XmlCdata_SearchUtfCodeRange@@YAEIPBUXML_CDATA_UTF_RANGE@@I@Z ; XmlCdata_SearchUtfCodeRange
  001b8	83 c4 0c	 add	 esp, 12			; 0000000cH
  001bb	0f b6 d0	 movzx	 edx, al
  001be	85 d2		 test	 edx, edx
  001c0	74 08		 je	 SHORT $LN4@XmlCdata_C@4
  001c2	0f b6 45 0c	 movzx	 eax, BYTE PTR _isNmtoken$[ebp]
  001c6	85 c0		 test	 eax, eax
  001c8	75 04		 jne	 SHORT $LN5@XmlCdata_C@4
$LN4@XmlCdata_C@4:

; 796  :                      {
; 797  :                         dprintf4(_T("XmlCdata-CheckUtf8Name: not a letter: 0x%X (3-byte code: 0x%02X,%02X,%02X)\n"), code, c1, c2, c3);
; 798  :                         result = FALSE;

  001ca	c6 45 ef 00	 mov	 BYTE PTR _result$[ebp], 0
$LN5@XmlCdata_C@4:

; 799  :                      }
; 800  :                   }
; 801  :                   else

  001ce	eb 04		 jmp	 SHORT $LN3@XmlCdata_C@4
$LN6@XmlCdata_C@4:

; 802  :                   {
; 803  :                      dprintf2(_T("XmlCdata-CheckUtf8Name: sequence error in 3-byte code: 0x%02X,%02X,...\n"), c1, c2);
; 804  :                      result = FALSE;

  001d0	c6 45 ef 00	 mov	 BYTE PTR _result$[ebp], 0
$LN3@XmlCdata_C@4:

; 805  :                   }
; 806  :                   break;

  001d4	eb 0a		 jmp	 SHORT $LN15@XmlCdata_C@4
$LN2@XmlCdata_C@4:

; 807  : 
; 808  :                case 0xF:  // 4 or more byte: code >= 0x10000
; 809  :                   dprintf1(_T("XmlCdata-CheckUtf8Name: 4-byte code: not a letter: 0x%02X\n"), c1);
; 810  :                   result = FALSE;

  001d6	c6 45 ef 00	 mov	 BYTE PTR _result$[ebp], 0

; 811  :                   break;

  001da	eb 04		 jmp	 SHORT $LN15@XmlCdata_C@4
$LN1@XmlCdata_C@4:

; 812  : 
; 813  :                default:
; 814  :                   dprintf1(_T("XmlCdata-CheckUtf8Name: sequence error: unexpected trailing code 0x%02X\n"), c1);
; 815  :                   result = FALSE;

  001dc	c6 45 ef 00	 mov	 BYTE PTR _result$[ebp], 0
$LN15@XmlCdata_C@4:

; 816  :                   break;
; 817  :             }
; 818  :          }
; 819  :          isNmtoken = TRUE;

  001e0	c6 45 0c 01	 mov	 BYTE PTR _isNmtoken$[ebp], 1

; 820  :       }

  001e4	e9 2b fe ff ff	 jmp	 $LN20@XmlCdata_C@4
$LN21@XmlCdata_C@4:

; 821  :    }
; 822  :    return result;

  001e9	8a 45 ef	 mov	 al, BYTE PTR _result$[ebp]

; 823  : }

  001ec	8b e5		 mov	 esp, ebp
  001ee	5d		 pop	 ebp
  001ef	c3		 ret	 0
$LN24@XmlCdata_C@4:
  001f0	00 00 00 00	 DD	 $LN12@XmlCdata_C@4
  001f4	00 00 00 00	 DD	 $LN12@XmlCdata_C@4
  001f8	00 00 00 00	 DD	 $LN7@XmlCdata_C@4
  001fc	00 00 00 00	 DD	 $LN2@XmlCdata_C@4
?XmlCdata_CheckUtf8Name@@YAEPB_WE@Z ENDP		; XmlCdata_CheckUtf8Name
_TEXT	ENDS
PUBLIC	?XmlCdata_AppendUtf8ToLatin1@@YAXPAUXML_STR_BUF@@PB_WI@Z ; XmlCdata_AppendUtf8ToLatin1
; Function compile flags: /Odtp
;	COMDAT ?XmlCdata_AppendUtf8ToLatin1@@YAXPAUXML_STR_BUF@@PB_WI@Z
_TEXT	SEGMENT
_c2$ = -16						; size = 2
_c1$ = -12						; size = 2
_code$ = -8						; size = 4
_pDest$ = -4						; size = 4
_pBuf$ = 8						; size = 4
_pStr$ = 12						; size = 4
_len$ = 16						; size = 4
?XmlCdata_AppendUtf8ToLatin1@@YAXPAUXML_STR_BUF@@PB_WI@Z PROC ; XmlCdata_AppendUtf8ToLatin1, COMDAT

; 350  : {

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

; 351  :    TCHAR*  pDest;
; 352  :    uint code;
; 353  :    TCHAR c1;
; 354  :    TCHAR c2;
; 355  : 
; 356  :    // Latin-1 encoding is guaranteed to be at most as long as UTF-8
; 357  :    if ( (pBuf->pStrBuf == NULL) ||
; 358  :         (pBuf->off + len + 1 > pBuf->size) )

  00006	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  00009	83 38 00	 cmp	 DWORD PTR [eax], 0
  0000c	74 15		 je	 SHORT $LN13@XmlCdata_A@2
  0000e	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00011	8b 51 10	 mov	 edx, DWORD PTR [ecx+16]
  00014	8b 45 10	 mov	 eax, DWORD PTR _len$[ebp]
  00017	8d 4c 02 01	 lea	 ecx, DWORD PTR [edx+eax+1]
  0001b	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0001e	3b 4a 08	 cmp	 ecx, DWORD PTR [edx+8]
  00021	76 10		 jbe	 SHORT $LN14@XmlCdata_A@2
$LN13@XmlCdata_A@2:

; 359  :    {
; 360  :       XmlCdata_Grow(pBuf, len);

  00023	8b 45 10	 mov	 eax, DWORD PTR _len$[ebp]
  00026	50		 push	 eax
  00027	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  0002a	51		 push	 ecx
  0002b	e8 00 00 00 00	 call	 ?XmlCdata_Grow@@YAXPAUXML_STR_BUF@@I@Z ; XmlCdata_Grow
  00030	83 c4 08	 add	 esp, 8
$LN14@XmlCdata_A@2:

; 361  :    }
; 362  : 
; 363  :    pDest = pBuf->pStrBuf + pBuf->off;

  00033	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  00036	8b 42 10	 mov	 eax, DWORD PTR [edx+16]
  00039	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  0003c	8b 11		 mov	 edx, DWORD PTR [ecx]
  0003e	8d 04 42	 lea	 eax, DWORD PTR [edx+eax*2]
  00041	89 45 fc	 mov	 DWORD PTR _pDest$[ebp], eax
$LN12@XmlCdata_A@2:

; 364  : 
; 365  :    while (len != 0)

  00044	83 7d 10 00	 cmp	 DWORD PTR _len$[ebp], 0
  00048	0f 84 2d 01 00
	00		 je	 $LN11@XmlCdata_A@2

; 366  :    {
; 367  :       c1 = *(pStr++);

  0004e	8b 4d 0c	 mov	 ecx, DWORD PTR _pStr$[ebp]
  00051	66 8b 11	 mov	 dx, WORD PTR [ecx]
  00054	66 89 55 f4	 mov	 WORD PTR _c1$[ebp], dx
  00058	8b 45 0c	 mov	 eax, DWORD PTR _pStr$[ebp]
  0005b	83 c0 02	 add	 eax, 2
  0005e	89 45 0c	 mov	 DWORD PTR _pStr$[ebp], eax

; 368  :       len--;

  00061	8b 4d 10	 mov	 ecx, DWORD PTR _len$[ebp]
  00064	83 e9 01	 sub	 ecx, 1
  00067	89 4d 10	 mov	 DWORD PTR _len$[ebp], ecx

; 369  : 
; 370  :       if (c1 < 0x80)

  0006a	0f b7 55 f4	 movzx	 edx, WORD PTR _c1$[ebp]
  0006e	81 fa 80 00 00
	00		 cmp	 edx, 128		; 00000080H
  00074	7d 18		 jge	 SHORT $LN10@XmlCdata_A@2

; 371  :       {
; 372  :          // ASCII range: passed through unmodified
; 373  :          *(pDest++) = c1;

  00076	8b 45 fc	 mov	 eax, DWORD PTR _pDest$[ebp]
  00079	66 8b 4d f4	 mov	 cx, WORD PTR _c1$[ebp]
  0007d	66 89 08	 mov	 WORD PTR [eax], cx
  00080	8b 55 fc	 mov	 edx, DWORD PTR _pDest$[ebp]
  00083	83 c2 02	 add	 edx, 2
  00086	89 55 fc	 mov	 DWORD PTR _pDest$[ebp], edx
  00089	e9 e8 00 00 00	 jmp	 $LN9@XmlCdata_A@2
$LN10@XmlCdata_A@2:

; 374  :       }
; 375  :       else if ((c1 & 0xE0) == 0xC0)

  0008e	0f b7 45 f4	 movzx	 eax, WORD PTR _c1$[ebp]
  00092	25 e0 00 00 00	 and	 eax, 224		; 000000e0H
  00097	3d c0 00 00 00	 cmp	 eax, 192		; 000000c0H
  0009c	0f 85 94 00 00
	00		 jne	 $LN8@XmlCdata_A@2

; 376  :       {
; 377  :          if (len != 0)

  000a2	83 7d 10 00	 cmp	 DWORD PTR _len$[ebp], 0
  000a6	74 78		 je	 SHORT $LN7@XmlCdata_A@2

; 378  :          {
; 379  :             c2 = *(pStr++);

  000a8	8b 4d 0c	 mov	 ecx, DWORD PTR _pStr$[ebp]
  000ab	66 8b 11	 mov	 dx, WORD PTR [ecx]
  000ae	66 89 55 f0	 mov	 WORD PTR _c2$[ebp], dx
  000b2	8b 45 0c	 mov	 eax, DWORD PTR _pStr$[ebp]
  000b5	83 c0 02	 add	 eax, 2
  000b8	89 45 0c	 mov	 DWORD PTR _pStr$[ebp], eax

; 380  :             len--;

  000bb	8b 4d 10	 mov	 ecx, DWORD PTR _len$[ebp]
  000be	83 e9 01	 sub	 ecx, 1
  000c1	89 4d 10	 mov	 DWORD PTR _len$[ebp], ecx

; 381  : 
; 382  :             code = ((c1 & 0x1F) << 6) | (c2 & 0x3F);

  000c4	0f b7 55 f4	 movzx	 edx, WORD PTR _c1$[ebp]
  000c8	83 e2 1f	 and	 edx, 31			; 0000001fH
  000cb	c1 e2 06	 shl	 edx, 6
  000ce	0f b7 45 f0	 movzx	 eax, WORD PTR _c2$[ebp]
  000d2	83 e0 3f	 and	 eax, 63			; 0000003fH
  000d5	0b d0		 or	 edx, eax
  000d7	89 55 f8	 mov	 DWORD PTR _code$[ebp], edx

; 383  :             if ( ((c2 & 0xC0) == 0x80) && (code < 0x100) )

  000da	0f b7 4d f0	 movzx	 ecx, WORD PTR _c2$[ebp]
  000de	81 e1 c0 00 00
	00		 and	 ecx, 192		; 000000c0H
  000e4	81 f9 80 00 00
	00		 cmp	 ecx, 128		; 00000080H
  000ea	75 1e		 jne	 SHORT $LN6@XmlCdata_A@2
  000ec	81 7d f8 00 01
	00 00		 cmp	 DWORD PTR _code$[ebp], 256 ; 00000100H
  000f3	73 15		 jae	 SHORT $LN6@XmlCdata_A@2

; 384  :                *(pDest++) = code;

  000f5	8b 55 fc	 mov	 edx, DWORD PTR _pDest$[ebp]
  000f8	66 8b 45 f8	 mov	 ax, WORD PTR _code$[ebp]
  000fc	66 89 02	 mov	 WORD PTR [edx], ax
  000ff	8b 4d fc	 mov	 ecx, DWORD PTR _pDest$[ebp]
  00102	83 c1 02	 add	 ecx, 2
  00105	89 4d fc	 mov	 DWORD PTR _pDest$[ebp], ecx

; 385  :             else

  00108	eb 14		 jmp	 SHORT $LN5@XmlCdata_A@2
$LN6@XmlCdata_A@2:

; 386  :                *(pDest++) = (char)0xA0;  // outside of ISO8859-1 range

  0010a	ba a0 ff 00 00	 mov	 edx, 65440		; 0000ffa0H
  0010f	8b 45 fc	 mov	 eax, DWORD PTR _pDest$[ebp]
  00112	66 89 10	 mov	 WORD PTR [eax], dx
  00115	8b 4d fc	 mov	 ecx, DWORD PTR _pDest$[ebp]
  00118	83 c1 02	 add	 ecx, 2
  0011b	89 4d fc	 mov	 DWORD PTR _pDest$[ebp], ecx
$LN5@XmlCdata_A@2:

; 387  :          }
; 388  :          else

  0011e	eb 14		 jmp	 SHORT $LN4@XmlCdata_A@2
$LN7@XmlCdata_A@2:

; 389  :          {
; 390  :             dprintf1(_T("XmlCdata-AppendUtf8ToLatin1: sequence error in input: tstring ends after 0x%02X\n"), c1);
; 391  :             *(pDest++) = (char)0xA0;

  00120	ba a0 ff 00 00	 mov	 edx, 65440		; 0000ffa0H
  00125	8b 45 fc	 mov	 eax, DWORD PTR _pDest$[ebp]
  00128	66 89 10	 mov	 WORD PTR [eax], dx
  0012b	8b 4d fc	 mov	 ecx, DWORD PTR _pDest$[ebp]
  0012e	83 c1 02	 add	 ecx, 2
  00131	89 4d fc	 mov	 DWORD PTR _pDest$[ebp], ecx
$LN4@XmlCdata_A@2:

; 392  :          }
; 393  :       }
; 394  :       else

  00134	eb 40		 jmp	 SHORT $LN9@XmlCdata_A@2
$LN8@XmlCdata_A@2:

; 395  :       {  // >= 3-byte sequence -> Unicode character codes >= 0x800
; 396  :          // not a Latin-1 character, replace with Latin-1 'NBSP' (non-breaking space)
; 397  :          *(pDest++) = (char)0xA0;

  00136	ba a0 ff 00 00	 mov	 edx, 65440		; 0000ffa0H
  0013b	8b 45 fc	 mov	 eax, DWORD PTR _pDest$[ebp]
  0013e	66 89 10	 mov	 WORD PTR [eax], dx
  00141	8b 4d fc	 mov	 ecx, DWORD PTR _pDest$[ebp]
  00144	83 c1 02	 add	 ecx, 2
  00147	89 4d fc	 mov	 DWORD PTR _pDest$[ebp], ecx
$LN2@XmlCdata_A@2:

; 398  : 
; 399  :          // skip the complete multi-byte code in the source tstring
; 400  :          while ( (len != 0) && ((*pStr & 0xC0) == 0x80) )

  0014a	83 7d 10 00	 cmp	 DWORD PTR _len$[ebp], 0
  0014e	74 26		 je	 SHORT $LN9@XmlCdata_A@2
  00150	8b 55 0c	 mov	 edx, DWORD PTR _pStr$[ebp]
  00153	0f b7 02	 movzx	 eax, WORD PTR [edx]
  00156	25 c0 00 00 00	 and	 eax, 192		; 000000c0H
  0015b	3d 80 00 00 00	 cmp	 eax, 128		; 00000080H
  00160	75 14		 jne	 SHORT $LN9@XmlCdata_A@2

; 401  :          {
; 402  :             pStr++;

  00162	8b 4d 0c	 mov	 ecx, DWORD PTR _pStr$[ebp]
  00165	83 c1 02	 add	 ecx, 2
  00168	89 4d 0c	 mov	 DWORD PTR _pStr$[ebp], ecx

; 403  :             len--;

  0016b	8b 55 10	 mov	 edx, DWORD PTR _len$[ebp]
  0016e	83 ea 01	 sub	 edx, 1
  00171	89 55 10	 mov	 DWORD PTR _len$[ebp], edx

; 404  :          }

  00174	eb d4		 jmp	 SHORT $LN2@XmlCdata_A@2
$LN9@XmlCdata_A@2:

; 405  :       }
; 406  :    }

  00176	e9 c9 fe ff ff	 jmp	 $LN12@XmlCdata_A@2
$LN11@XmlCdata_A@2:

; 407  :    *pDest = 0;

  0017b	33 c0		 xor	 eax, eax
  0017d	8b 4d fc	 mov	 ecx, DWORD PTR _pDest$[ebp]
  00180	66 89 01	 mov	 WORD PTR [ecx], ax

; 408  : 
; 409  :    pBuf->off = pDest - pBuf->pStrBuf;

  00183	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  00186	8b 45 fc	 mov	 eax, DWORD PTR _pDest$[ebp]
  00189	2b 02		 sub	 eax, DWORD PTR [edx]
  0018b	d1 f8		 sar	 eax, 1
  0018d	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00190	89 41 10	 mov	 DWORD PTR [ecx+16], eax

; 410  : }

  00193	8b e5		 mov	 esp, ebp
  00195	5d		 pop	 ebp
  00196	c3		 ret	 0
?XmlCdata_AppendUtf8ToLatin1@@YAXPAUXML_STR_BUF@@PB_WI@Z ENDP ; XmlCdata_AppendUtf8ToLatin1
_TEXT	ENDS
PUBLIC	?XmlCdata_AppendLatin1ToUtf8@@YAXPAUXML_STR_BUF@@PB_WI@Z ; XmlCdata_AppendLatin1ToUtf8
; Function compile flags: /Odtp
;	COMDAT ?XmlCdata_AppendLatin1ToUtf8@@YAXPAUXML_STR_BUF@@PB_WI@Z
_TEXT	SEGMENT
_code$ = -8						; size = 2
_pDest$ = -4						; size = 4
_pBuf$ = 8						; size = 4
_pStr$ = 12						; size = 4
_len$ = 16						; size = 4
?XmlCdata_AppendLatin1ToUtf8@@YAXPAUXML_STR_BUF@@PB_WI@Z PROC ; XmlCdata_AppendLatin1ToUtf8, COMDAT

; 311  : {

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

; 312  :    TCHAR*  pDest;
; 313  :    TCHAR code;
; 314  : 
; 315  :    // to save time, we allocate space for the worst case which is twice the original size
; 316  :    // hence we don't have to keep track of the destination buffer size in the loop
; 317  :    if ( (pBuf->pStrBuf == NULL) ||
; 318  :         (pBuf->off + (2 * len) + 1 > pBuf->size) )

  00006	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  00009	83 38 00	 cmp	 DWORD PTR [eax], 0
  0000c	74 15		 je	 SHORT $LN6@XmlCdata_A@3
  0000e	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00011	8b 51 10	 mov	 edx, DWORD PTR [ecx+16]
  00014	8b 45 10	 mov	 eax, DWORD PTR _len$[ebp]
  00017	8d 4c 42 01	 lea	 ecx, DWORD PTR [edx+eax*2+1]
  0001b	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0001e	3b 4a 08	 cmp	 ecx, DWORD PTR [edx+8]
  00021	76 12		 jbe	 SHORT $LN7@XmlCdata_A@3
$LN6@XmlCdata_A@3:

; 319  :    {
; 320  :       XmlCdata_Grow(pBuf, 2 * len);

  00023	8b 45 10	 mov	 eax, DWORD PTR _len$[ebp]
  00026	d1 e0		 shl	 eax, 1
  00028	50		 push	 eax
  00029	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  0002c	51		 push	 ecx
  0002d	e8 00 00 00 00	 call	 ?XmlCdata_Grow@@YAXPAUXML_STR_BUF@@I@Z ; XmlCdata_Grow
  00032	83 c4 08	 add	 esp, 8
$LN7@XmlCdata_A@3:

; 321  :    }
; 322  : 
; 323  :    pDest = pBuf->pStrBuf + pBuf->off;

  00035	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  00038	8b 42 10	 mov	 eax, DWORD PTR [edx+16]
  0003b	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  0003e	8b 11		 mov	 edx, DWORD PTR [ecx]
  00040	8d 04 42	 lea	 eax, DWORD PTR [edx+eax*2]
  00043	89 45 fc	 mov	 DWORD PTR _pDest$[ebp], eax

; 324  : 
; 325  :    for ( ; len != 0; len-- )

  00046	eb 09		 jmp	 SHORT $LN5@XmlCdata_A@3
$LN4@XmlCdata_A@3:
  00048	8b 4d 10	 mov	 ecx, DWORD PTR _len$[ebp]
  0004b	83 e9 01	 sub	 ecx, 1
  0004e	89 4d 10	 mov	 DWORD PTR _len$[ebp], ecx
$LN5@XmlCdata_A@3:
  00051	83 7d 10 00	 cmp	 DWORD PTR _len$[ebp], 0
  00055	74 77		 je	 SHORT $LN3@XmlCdata_A@3

; 326  :    {
; 327  :       code = *(pStr++);

  00057	8b 55 0c	 mov	 edx, DWORD PTR _pStr$[ebp]
  0005a	66 8b 02	 mov	 ax, WORD PTR [edx]
  0005d	66 89 45 f8	 mov	 WORD PTR _code$[ebp], ax
  00061	8b 4d 0c	 mov	 ecx, DWORD PTR _pStr$[ebp]
  00064	83 c1 02	 add	 ecx, 2
  00067	89 4d 0c	 mov	 DWORD PTR _pStr$[ebp], ecx

; 328  : 
; 329  :       if (code < 0x80)

  0006a	0f b7 55 f8	 movzx	 edx, WORD PTR _code$[ebp]
  0006e	81 fa 80 00 00
	00		 cmp	 edx, 128		; 00000080H
  00074	7d 15		 jge	 SHORT $LN2@XmlCdata_A@3

; 330  :       {
; 331  :          // ASCII range: passed through unmodified
; 332  :          *(pDest++) = code;

  00076	8b 45 fc	 mov	 eax, DWORD PTR _pDest$[ebp]
  00079	66 8b 4d f8	 mov	 cx, WORD PTR _code$[ebp]
  0007d	66 89 08	 mov	 WORD PTR [eax], cx
  00080	8b 55 fc	 mov	 edx, DWORD PTR _pDest$[ebp]
  00083	83 c2 02	 add	 edx, 2
  00086	89 55 fc	 mov	 DWORD PTR _pDest$[ebp], edx

; 333  :       }
; 334  :       else

  00089	eb 3e		 jmp	 SHORT $LN1@XmlCdata_A@3
$LN2@XmlCdata_A@3:

; 335  :       {
; 336  :          // Latin-1 code page: char code is identical, but encoded as 2-byte sequence
; 337  :          *(pDest++) = 0xC0 | (char) (code >> 6);

  0008b	0f b7 45 f8	 movzx	 eax, WORD PTR _code$[ebp]
  0008f	c1 f8 06	 sar	 eax, 6
  00092	0f be c8	 movsx	 ecx, al
  00095	81 c9 c0 00 00
	00		 or	 ecx, 192		; 000000c0H
  0009b	8b 55 fc	 mov	 edx, DWORD PTR _pDest$[ebp]
  0009e	66 89 0a	 mov	 WORD PTR [edx], cx
  000a1	8b 45 fc	 mov	 eax, DWORD PTR _pDest$[ebp]
  000a4	83 c0 02	 add	 eax, 2
  000a7	89 45 fc	 mov	 DWORD PTR _pDest$[ebp], eax

; 338  :          *(pDest++) = 0x80 | (char) (code & 0x3F);

  000aa	0f b7 4d f8	 movzx	 ecx, WORD PTR _code$[ebp]
  000ae	83 e1 3f	 and	 ecx, 63			; 0000003fH
  000b1	0f be d1	 movsx	 edx, cl
  000b4	81 ca 80 00 00
	00		 or	 edx, 128		; 00000080H
  000ba	8b 45 fc	 mov	 eax, DWORD PTR _pDest$[ebp]
  000bd	66 89 10	 mov	 WORD PTR [eax], dx
  000c0	8b 4d fc	 mov	 ecx, DWORD PTR _pDest$[ebp]
  000c3	83 c1 02	 add	 ecx, 2
  000c6	89 4d fc	 mov	 DWORD PTR _pDest$[ebp], ecx
$LN1@XmlCdata_A@3:

; 339  :       }
; 340  :    }

  000c9	e9 7a ff ff ff	 jmp	 $LN4@XmlCdata_A@3
$LN3@XmlCdata_A@3:

; 341  :    *pDest = 0;

  000ce	33 d2		 xor	 edx, edx
  000d0	8b 45 fc	 mov	 eax, DWORD PTR _pDest$[ebp]
  000d3	66 89 10	 mov	 WORD PTR [eax], dx

; 342  : 
; 343  :    pBuf->off = pDest - pBuf->pStrBuf;

  000d6	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  000d9	8b 55 fc	 mov	 edx, DWORD PTR _pDest$[ebp]
  000dc	2b 11		 sub	 edx, DWORD PTR [ecx]
  000de	d1 fa		 sar	 edx, 1
  000e0	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  000e3	89 50 10	 mov	 DWORD PTR [eax+16], edx

; 344  : }

  000e6	8b e5		 mov	 esp, ebp
  000e8	5d		 pop	 ebp
  000e9	c3		 ret	 0
?XmlCdata_AppendLatin1ToUtf8@@YAXPAUXML_STR_BUF@@PB_WI@Z ENDP ; XmlCdata_AppendLatin1ToUtf8
_TEXT	ENDS
PUBLIC	?XmlCdata_AppendParagraph@@YAXPAUXML_STR_BUF@@E@Z ; XmlCdata_AppendParagraph
; Function compile flags: /Odtp
;	COMDAT ?XmlCdata_AppendParagraph@@YAXPAUXML_STR_BUF@@E@Z
_TEXT	SEGMENT
_pBuf$ = 8						; size = 4
_insertTwo$ = 12					; size = 1
?XmlCdata_AppendParagraph@@YAXPAUXML_STR_BUF@@E@Z PROC	; XmlCdata_AppendParagraph, COMDAT

; 273  : {

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

; 274  :    // if tstring is empty, do nothing
; 275  :    if (pBuf->off > 0)

  00003	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  00006	83 78 10 00	 cmp	 DWORD PTR [eax+16], 0
  0000a	0f 86 a3 01 00
	00		 jbe	 $LN23@XmlCdata_A@4

; 276  :    {
; 277  :       if (insertTwo)

  00010	0f b6 4d 0c	 movzx	 ecx, BYTE PTR _insertTwo$[ebp]
  00014	85 c9		 test	 ecx, ecx
  00016	0f 84 10 01 00
	00		 je	 $LN21@XmlCdata_A@4

; 278  :       {
; 279  :          if (pBuf->pStrBuf[pBuf->off - 1] == '\n')

  0001c	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0001f	8b 42 10	 mov	 eax, DWORD PTR [edx+16]
  00022	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00025	8b 11		 mov	 edx, DWORD PTR [ecx]
  00027	0f b7 44 42 fe	 movzx	 eax, WORD PTR [edx+eax*2-2]
  0002c	83 f8 0a	 cmp	 eax, 10			; 0000000aH
  0002f	0f 85 89 00 00
	00		 jne	 $LN12@XmlCdata_A@4

; 280  :          {
; 281  :             if ( (pBuf->off > 2) &&
; 282  :                  (pBuf->pStrBuf[pBuf->off - 2] != '\n') )

  00035	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00038	83 79 10 02	 cmp	 DWORD PTR [ecx+16], 2
  0003c	76 7e		 jbe	 SHORT $LN19@XmlCdata_A@4
  0003e	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  00041	8b 42 10	 mov	 eax, DWORD PTR [edx+16]
  00044	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00047	8b 11		 mov	 edx, DWORD PTR [ecx]
  00049	0f b7 44 42 fc	 movzx	 eax, WORD PTR [edx+eax*2-4]
  0004e	83 f8 0a	 cmp	 eax, 10			; 0000000aH
  00051	74 69		 je	 SHORT $LN19@XmlCdata_A@4
$LN18@XmlCdata_A@4:

; 283  :             {
; 284  :                // single newline only (and tstring consists not of newline only) -> add one
; 285  :                XmlCdata_AppendRaw(pBuf, _T("\n"), 1);

  00053	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00056	83 39 00	 cmp	 DWORD PTR [ecx], 0
  00059	74 11		 je	 SHORT $LN14@XmlCdata_A@4
  0005b	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0005e	8b 42 10	 mov	 eax, DWORD PTR [edx+16]
  00061	83 c0 02	 add	 eax, 2
  00064	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00067	3b 41 08	 cmp	 eax, DWORD PTR [ecx+8]
  0006a	76 0e		 jbe	 SHORT $LN15@XmlCdata_A@4
$LN14@XmlCdata_A@4:
  0006c	6a 01		 push	 1
  0006e	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  00071	52		 push	 edx
  00072	e8 00 00 00 00	 call	 ?XmlCdata_Grow@@YAXPAUXML_STR_BUF@@I@Z ; XmlCdata_Grow
  00077	83 c4 08	 add	 esp, 8
$LN15@XmlCdata_A@4:
  0007a	6a 01		 push	 1
  0007c	68 00 00 00 00	 push	 OFFSET ??_C@_13LBAGMAIH@?$AA?6?$AA?$AA@
  00081	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  00084	8b 48 10	 mov	 ecx, DWORD PTR [eax+16]
  00087	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0008a	8b 02		 mov	 eax, DWORD PTR [edx]
  0008c	8d 0c 48	 lea	 ecx, DWORD PTR [eax+ecx*2]
  0008f	51		 push	 ecx
  00090	e8 00 00 00 00	 call	 _memcpy
  00095	83 c4 0c	 add	 esp, 12			; 0000000cH
  00098	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0009b	8b 42 10	 mov	 eax, DWORD PTR [edx+16]
  0009e	83 c0 01	 add	 eax, 1
  000a1	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  000a4	89 41 10	 mov	 DWORD PTR [ecx+16], eax
  000a7	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  000aa	8b 42 10	 mov	 eax, DWORD PTR [edx+16]
  000ad	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  000b0	8b 11		 mov	 edx, DWORD PTR [ecx]
  000b2	33 c9		 xor	 ecx, ecx
  000b4	66 89 0c 42	 mov	 WORD PTR [edx+eax*2], cx
  000b8	33 d2		 xor	 edx, edx
  000ba	75 97		 jne	 SHORT $LN18@XmlCdata_A@4
$LN19@XmlCdata_A@4:

; 286  :             }
; 287  :          }
; 288  :          else

  000bc	eb 69		 jmp	 SHORT $LN13@XmlCdata_A@4
$LN12@XmlCdata_A@4:

; 289  :          {  // no newline at all at the end -> add double newline
; 290  :             XmlCdata_AppendRaw(pBuf, _T("\n\n"), 2);

  000be	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  000c1	83 38 00	 cmp	 DWORD PTR [eax], 0
  000c4	74 11		 je	 SHORT $LN8@XmlCdata_A@4
  000c6	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  000c9	8b 51 10	 mov	 edx, DWORD PTR [ecx+16]
  000cc	83 c2 03	 add	 edx, 3
  000cf	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  000d2	3b 50 08	 cmp	 edx, DWORD PTR [eax+8]
  000d5	76 0e		 jbe	 SHORT $LN9@XmlCdata_A@4
$LN8@XmlCdata_A@4:
  000d7	6a 02		 push	 2
  000d9	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  000dc	51		 push	 ecx
  000dd	e8 00 00 00 00	 call	 ?XmlCdata_Grow@@YAXPAUXML_STR_BUF@@I@Z ; XmlCdata_Grow
  000e2	83 c4 08	 add	 esp, 8
$LN9@XmlCdata_A@4:
  000e5	6a 02		 push	 2
  000e7	68 00 00 00 00	 push	 OFFSET ??_C@_15IABLJNFO@?$AA?6?$AA?6?$AA?$AA@
  000ec	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  000ef	8b 42 10	 mov	 eax, DWORD PTR [edx+16]
  000f2	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  000f5	8b 11		 mov	 edx, DWORD PTR [ecx]
  000f7	8d 04 42	 lea	 eax, DWORD PTR [edx+eax*2]
  000fa	50		 push	 eax
  000fb	e8 00 00 00 00	 call	 _memcpy
  00100	83 c4 0c	 add	 esp, 12			; 0000000cH
  00103	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00106	8b 51 10	 mov	 edx, DWORD PTR [ecx+16]
  00109	83 c2 02	 add	 edx, 2
  0010c	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  0010f	89 50 10	 mov	 DWORD PTR [eax+16], edx
  00112	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00115	8b 51 10	 mov	 edx, DWORD PTR [ecx+16]
  00118	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  0011b	8b 08		 mov	 ecx, DWORD PTR [eax]
  0011d	33 c0		 xor	 eax, eax
  0011f	66 89 04 51	 mov	 WORD PTR [ecx+edx*2], ax
  00123	33 c9		 xor	 ecx, ecx
  00125	75 97		 jne	 SHORT $LN12@XmlCdata_A@4
$LN13@XmlCdata_A@4:

; 291  :          }
; 292  :       }
; 293  :       else

  00127	e9 87 00 00 00	 jmp	 $LN23@XmlCdata_A@4
$LN21@XmlCdata_A@4:

; 294  :       {
; 295  :          if ( (pBuf->off > 1) &&
; 296  :               (pBuf->pStrBuf[pBuf->off - 1] != '\n') )

  0012c	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0012f	83 7a 10 01	 cmp	 DWORD PTR [edx+16], 1
  00133	76 7e		 jbe	 SHORT $LN23@XmlCdata_A@4
  00135	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  00138	8b 48 10	 mov	 ecx, DWORD PTR [eax+16]
  0013b	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0013e	8b 02		 mov	 eax, DWORD PTR [edx]
  00140	0f b7 4c 48 fe	 movzx	 ecx, WORD PTR [eax+ecx*2-2]
  00145	83 f9 0a	 cmp	 ecx, 10			; 0000000aH
  00148	74 69		 je	 SHORT $LN23@XmlCdata_A@4
$LN5@XmlCdata_A@4:

; 297  :          {
; 298  :             XmlCdata_AppendRaw(pBuf, _T("\n"), 1);

  0014a	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0014d	83 3a 00	 cmp	 DWORD PTR [edx], 0
  00150	74 11		 je	 SHORT $LN1@XmlCdata_A@4
  00152	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  00155	8b 48 10	 mov	 ecx, DWORD PTR [eax+16]
  00158	83 c1 02	 add	 ecx, 2
  0015b	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0015e	3b 4a 08	 cmp	 ecx, DWORD PTR [edx+8]
  00161	76 0e		 jbe	 SHORT $LN2@XmlCdata_A@4
$LN1@XmlCdata_A@4:
  00163	6a 01		 push	 1
  00165	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  00168	50		 push	 eax
  00169	e8 00 00 00 00	 call	 ?XmlCdata_Grow@@YAXPAUXML_STR_BUF@@I@Z ; XmlCdata_Grow
  0016e	83 c4 08	 add	 esp, 8
$LN2@XmlCdata_A@4:
  00171	6a 01		 push	 1
  00173	68 00 00 00 00	 push	 OFFSET ??_C@_13LBAGMAIH@?$AA?6?$AA?$AA@
  00178	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  0017b	8b 51 10	 mov	 edx, DWORD PTR [ecx+16]
  0017e	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  00181	8b 08		 mov	 ecx, DWORD PTR [eax]
  00183	8d 14 51	 lea	 edx, DWORD PTR [ecx+edx*2]
  00186	52		 push	 edx
  00187	e8 00 00 00 00	 call	 _memcpy
  0018c	83 c4 0c	 add	 esp, 12			; 0000000cH
  0018f	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  00192	8b 48 10	 mov	 ecx, DWORD PTR [eax+16]
  00195	83 c1 01	 add	 ecx, 1
  00198	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0019b	89 4a 10	 mov	 DWORD PTR [edx+16], ecx
  0019e	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  001a1	8b 48 10	 mov	 ecx, DWORD PTR [eax+16]
  001a4	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  001a7	8b 02		 mov	 eax, DWORD PTR [edx]
  001a9	33 d2		 xor	 edx, edx
  001ab	66 89 14 48	 mov	 WORD PTR [eax+ecx*2], dx
  001af	33 c0		 xor	 eax, eax
  001b1	75 97		 jne	 SHORT $LN5@XmlCdata_A@4
$LN23@XmlCdata_A@4:

; 299  :          }
; 300  :       }
; 301  :    }
; 302  : }

  001b3	5d		 pop	 ebp
  001b4	c3		 ret	 0
?XmlCdata_AppendParagraph@@YAXPAUXML_STR_BUF@@E@Z ENDP	; XmlCdata_AppendParagraph
_TEXT	ENDS
PUBLIC	?XmlCdata_AppendRawNOINLINE@@YAXPAUXML_STR_BUF@@PB_WI@Z ; XmlCdata_AppendRawNOINLINE
; Function compile flags: /Odtp
;	COMDAT ?XmlCdata_AppendRawNOINLINE@@YAXPAUXML_STR_BUF@@PB_WI@Z
_TEXT	SEGMENT
_pBuf$ = 8						; size = 4
_pStr$ = 12						; size = 4
_len$ = 16						; size = 4
?XmlCdata_AppendRawNOINLINE@@YAXPAUXML_STR_BUF@@PB_WI@Z PROC ; XmlCdata_AppendRawNOINLINE, COMDAT

; 157  : {

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

; 158  :    if ( (pBuf->pStrBuf == NULL) ||
; 159  :         (pBuf->off + len + 1 > pBuf->size) )

  00003	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  00006	83 38 00	 cmp	 DWORD PTR [eax], 0
  00009	74 15		 je	 SHORT $LN1@XmlCdata_A@5
  0000b	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  0000e	8b 51 10	 mov	 edx, DWORD PTR [ecx+16]
  00011	8b 45 10	 mov	 eax, DWORD PTR _len$[ebp]
  00014	8d 4c 02 01	 lea	 ecx, DWORD PTR [edx+eax+1]
  00018	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0001b	3b 4a 08	 cmp	 ecx, DWORD PTR [edx+8]
  0001e	76 10		 jbe	 SHORT $LN2@XmlCdata_A@5
$LN1@XmlCdata_A@5:

; 160  :    {
; 161  :       XmlCdata_Grow(pBuf, len);

  00020	8b 45 10	 mov	 eax, DWORD PTR _len$[ebp]
  00023	50		 push	 eax
  00024	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  00027	51		 push	 ecx
  00028	e8 00 00 00 00	 call	 ?XmlCdata_Grow@@YAXPAUXML_STR_BUF@@I@Z ; XmlCdata_Grow
  0002d	83 c4 08	 add	 esp, 8
$LN2@XmlCdata_A@5:

; 162  :    }
; 163  : 
; 164  :    memcpy(pBuf->pStrBuf + pBuf->off, pStr, len);

  00030	8b 55 10	 mov	 edx, DWORD PTR _len$[ebp]
  00033	52		 push	 edx
  00034	8b 45 0c	 mov	 eax, DWORD PTR _pStr$[ebp]
  00037	50		 push	 eax
  00038	8b 4d 08	 mov	 ecx, DWORD PTR _pBuf$[ebp]
  0003b	8b 51 10	 mov	 edx, DWORD PTR [ecx+16]
  0003e	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  00041	8b 08		 mov	 ecx, DWORD PTR [eax]
  00043	8d 14 51	 lea	 edx, DWORD PTR [ecx+edx*2]
  00046	52		 push	 edx
  00047	e8 00 00 00 00	 call	 _memcpy
  0004c	83 c4 0c	 add	 esp, 12			; 0000000cH

; 165  :    pBuf->off += len;

  0004f	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  00052	8b 48 10	 mov	 ecx, DWORD PTR [eax+16]
  00055	03 4d 10	 add	 ecx, DWORD PTR _len$[ebp]
  00058	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  0005b	89 4a 10	 mov	 DWORD PTR [edx+16], ecx

; 166  :    pBuf->pStrBuf[pBuf->off] = 0;

  0005e	8b 45 08	 mov	 eax, DWORD PTR _pBuf$[ebp]
  00061	8b 48 10	 mov	 ecx, DWORD PTR [eax+16]
  00064	8b 55 08	 mov	 edx, DWORD PTR _pBuf$[ebp]
  00067	8b 02		 mov	 eax, DWORD PTR [edx]
  00069	33 d2		 xor	 edx, edx
  0006b	66 89 14 48	 mov	 WORD PTR [eax+ecx*2], dx

; 167  : }

  0006f	5d		 pop	 ebp
  00070	c3		 ret	 0
?XmlCdata_AppendRawNOINLINE@@YAXPAUXML_STR_BUF@@PB_WI@Z ENDP ; XmlCdata_AppendRawNOINLINE
END
