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

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

INCLUDELIB OLDNAMES

PUBLIC	??_C@_06PNMEMOHD@?$CGapos?$DL?$AA@		; `string'
PUBLIC	??_C@_06DDLNFFBN@?$CGquot?$DL?$AA@		; `string'
PUBLIC	??_C@_04LOOHDCEI@?$CGgt?$DL?$AA@		; `string'
PUBLIC	??_C@_04GJOGLFEJ@?$CGlt?$DL?$AA@		; `string'
PUBLIC	??_C@_05JKJFEODM@?$CGamp?$DL?$AA@		; `string'
PUBLIC	?StreamIn@TiXmlDeclaration@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ; TiXmlDeclaration::StreamIn
PUBLIC	?Parse@TiXmlDeclaration@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDeclaration::Parse
PUBLIC	?Parse@TiXmlAttribute@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlAttribute::Parse
PUBLIC	?StreamIn@TiXmlUnknown@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ; TiXmlUnknown::StreamIn
PUBLIC	?Parse@TiXmlUnknown@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlUnknown::Parse
PUBLIC	?StreamIn@TiXmlComment@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ; TiXmlComment::StreamIn
PUBLIC	?Parse@TiXmlComment@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlComment::Parse
PUBLIC	?StreamIn@TiXmlElement@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ; TiXmlElement::StreamIn
PUBLIC	?Parse@TiXmlElement@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlElement::Parse
PUBLIC	?StreamIn@TiXmlText@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ; TiXmlText::StreamIn
PUBLIC	?Parse@TiXmlText@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlText::Parse
PUBLIC	?StreamIn@TiXmlDocument@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ; TiXmlDocument::StreamIn
PUBLIC	?Parse@TiXmlDocument@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::Parse
PUBLIC	?ToLower@TiXmlBase@@KAHHW4TiXmlEncoding@@@Z	; TiXmlBase::ToLower
PUBLIC	?GetChar@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z ; TiXmlBase::GetChar
PUBLIC	?Encoding@TiXmlDeclaration@@QBEPBDXZ		; TiXmlDeclaration::Encoding
PUBLIC	?TabSize@TiXmlDocument@@QBEHXZ			; TiXmlDocument::TabSize
PUBLIC	??0TiXmlParsingData@@AAE@PBDHHH@Z		; TiXmlParsingData::TiXmlParsingData
PUBLIC	?SetCDATA@TiXmlText@@QAEX_N@Z			; TiXmlText::SetCDATA
PUBLIC	?IsWhiteSpace@TiXmlBase@@KA_NH@Z		; TiXmlBase::IsWhiteSpace
PUBLIC	?NameTStr@TiXmlAttribute@@QBEABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ ; TiXmlAttribute::NameTStr
PUBLIC	?SetDocument@TiXmlAttribute@@QAEXPAVTiXmlDocument@@@Z ; TiXmlAttribute::SetDocument
PUBLIC	?IsWhiteSpaceCondensed@TiXmlBase@@SA_NXZ	; TiXmlBase::IsWhiteSpaceCondensed
PUBLIC	?at@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAADI@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::at
PUBLIC	?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::peek
PUBLIC	?is@?$ctype@D@std@@QBE_NFD@Z			; std::ctype<char>::is
PUBLIC	?sgetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_streambuf<char,std::char_traits<char> >::sgetc
PUBLIC	?_Gnpreinc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ ; std::basic_streambuf<char,std::char_traits<char> >::_Gnpreinc
PUBLIC	?snextc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_streambuf<char,std::char_traits<char> >::snextc
PUBLIC	?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z ; std::basic_istream<char,std::char_traits<char> >::_Ipfx
PUBLIC	??0_Sentry_base@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@@Z ; std::basic_istream<char,std::char_traits<char> >::_Sentry_base::_Sentry_base
PUBLIC	??0sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@_N@Z ; std::basic_istream<char,std::char_traits<char> >::sentry::sentry
PUBLIC	??Bsentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QBE_NXZ ; std::basic_istream<char,std::char_traits<char> >::sentry::operator bool
PUBLIC	??1_Sentry_base@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ ; std::basic_istream<char,std::char_traits<char> >::_Sentry_base::~_Sentry_base
PUBLIC	??1sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ ; std::basic_istream<char,std::char_traits<char> >::sentry::~sentry
PUBLIC	?sbumpc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_streambuf<char,std::char_traits<char> >::sbumpc
PUBLIC	?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::get
PUBLIC	?Cursor@TiXmlParsingData@@QAEABUTiXmlCursor@@XZ	; TiXmlParsingData::Cursor
PUBLIC	?IsWhiteSpace@TiXmlBase@@KA_ND@Z		; TiXmlBase::IsWhiteSpace
PUBLIC	?entity@TiXmlBase@@0PAUEntity@1@A		; TiXmlBase::entity
PUBLIC	?utf8ByteTable@TiXmlBase@@2QBHB			; TiXmlBase::utf8ByteTable
PUBLIC	??_C@_05EGJIMALK@UTF?98?$AA@			; `string'
PUBLIC	??_C@_04OOMJJNCF@UTF8?$AA@			; `string'
PUBLIC	??_C@_05DJDIECHG@?$DM?$DPxml?$AA@		; `string'
PUBLIC	??_C@_02KBFACPPK@?$DM?$CB?$AA@			; `string'
PUBLIC	??_C@_07CPCPJPKL@version?$AA@			; `string'
PUBLIC	??_C@_08MLPGAEIK@encoding?$AA@			; `string'
PUBLIC	??_C@_0L@FLHGMILF@standalone?$AA@		; `string'
EXTRN	_isalpha:PROC
EXTRN	_isalnum:PROC
EXTRN	_strchr:PROC
;	COMDAT ??_C@_0L@FLHGMILF@standalone?$AA@
CONST	SEGMENT
??_C@_0L@FLHGMILF@standalone?$AA@ DB 'standalone', 00H	; `string'
CONST	ENDS
;	COMDAT ??_C@_08MLPGAEIK@encoding?$AA@
CONST	SEGMENT
??_C@_08MLPGAEIK@encoding?$AA@ DB 'encoding', 00H	; `string'
CONST	ENDS
;	COMDAT ??_C@_07CPCPJPKL@version?$AA@
CONST	SEGMENT
??_C@_07CPCPJPKL@version?$AA@ DB 'version', 00H		; `string'
CONST	ENDS
;	COMDAT ??_C@_02KBFACPPK@?$DM?$CB?$AA@
CONST	SEGMENT
??_C@_02KBFACPPK@?$DM?$CB?$AA@ DB '<!', 00H		; `string'
CONST	ENDS
;	COMDAT ??_C@_05DJDIECHG@?$DM?$DPxml?$AA@
CONST	SEGMENT
??_C@_05DJDIECHG@?$DM?$DPxml?$AA@ DB '<?xml', 00H	; `string'
CONST	ENDS
;	COMDAT ??_C@_04OOMJJNCF@UTF8?$AA@
CONST	SEGMENT
??_C@_04OOMJJNCF@UTF8?$AA@ DB 'UTF8', 00H		; `string'
CONST	ENDS
;	COMDAT ??_C@_05EGJIMALK@UTF?98?$AA@
CONST	SEGMENT
??_C@_05EGJIMALK@UTF?98?$AA@ DB 'UTF-8', 00H		; `string'
CONST	ENDS
;	COMDAT ??_C@_06PNMEMOHD@?$CGapos?$DL?$AA@
CONST	SEGMENT
??_C@_06PNMEMOHD@?$CGapos?$DL?$AA@ DB '&apos;', 00H	; `string'
CONST	ENDS
;	COMDAT ??_C@_06DDLNFFBN@?$CGquot?$DL?$AA@
CONST	SEGMENT
??_C@_06DDLNFFBN@?$CGquot?$DL?$AA@ DB '&quot;', 00H	; `string'
CONST	ENDS
;	COMDAT ??_C@_04LOOHDCEI@?$CGgt?$DL?$AA@
CONST	SEGMENT
??_C@_04LOOHDCEI@?$CGgt?$DL?$AA@ DB '&gt;', 00H		; `string'
CONST	ENDS
;	COMDAT ??_C@_04GJOGLFEJ@?$CGlt?$DL?$AA@
CONST	SEGMENT
??_C@_04GJOGLFEJ@?$CGlt?$DL?$AA@ DB '&lt;', 00H		; `string'
CONST	ENDS
;	COMDAT ??_C@_05JKJFEODM@?$CGamp?$DL?$AA@
CONST	SEGMENT
??_C@_05JKJFEODM@?$CGamp?$DL?$AA@ DB '&amp;', 00H	; `string'
?utf8ByteTable@TiXmlBase@@2QBHB DD 01H			; TiXmlBase::utf8ByteTable
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	02H
	DD	03H
	DD	03H
	DD	03H
	DD	03H
	DD	03H
	DD	03H
	DD	03H
	DD	03H
	DD	03H
	DD	03H
	DD	03H
	DD	03H
	DD	03H
	DD	03H
	DD	03H
	DD	03H
	DD	04H
	DD	04H
	DD	04H
	DD	04H
	DD	04H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
	DD	01H
__bad_alloc_Message DD FLAT:??_C@_0P@GHFPNOJB@bad?5allocation?$AA@
?entity@TiXmlBase@@0PAUEntity@1@A DD FLAT:??_C@_05JKJFEODM@?$CGamp?$DL?$AA@ ; TiXmlBase::entity
	DD	05H
	DB	026H
	ORG $+3
	DD	FLAT:??_C@_04GJOGLFEJ@?$CGlt?$DL?$AA@
	DD	04H
	DB	03cH
	ORG $+3
	DD	FLAT:??_C@_04LOOHDCEI@?$CGgt?$DL?$AA@
	DD	04H
	DB	03eH
	ORG $+3
	DD	FLAT:??_C@_06DDLNFFBN@?$CGquot?$DL?$AA@
	DD	06H
	DB	022H
	ORG $+3
	DD	FLAT:??_C@_06PNMEMOHD@?$CGapos?$DL?$AA@
	DD	06H
	DB	027H
	ORG $+3
; Function compile flags: /Odtp
; File c:\program files (x86)\microsoft visual studio 9.0\vc\include\streambuf
;	COMDAT ?_Gnpreinc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ
_TEXT	SEGMENT
_this$ = -4						; size = 4
?_Gnpreinc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ PROC ; std::basic_streambuf<char,std::char_traits<char> >::_Gnpreinc, COMDAT
; _this$ = ecx

; 239  : 		{	// preincrement current position in read buffer

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

; 240  : 		--*_IGcount;

  00007	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  0000a	8b 48 30	 mov	 ecx, DWORD PTR [eax+48]
  0000d	8b 11		 mov	 edx, DWORD PTR [ecx]
  0000f	83 ea 01	 sub	 edx, 1
  00012	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  00015	8b 48 30	 mov	 ecx, DWORD PTR [eax+48]
  00018	89 11		 mov	 DWORD PTR [ecx], edx

; 241  : 		return (++(*_IGnext));

  0001a	8b 55 fc	 mov	 edx, DWORD PTR _this$[ebp]
  0001d	8b 42 20	 mov	 eax, DWORD PTR [edx+32]
  00020	8b 08		 mov	 ecx, DWORD PTR [eax]
  00022	83 c1 01	 add	 ecx, 1
  00025	8b 55 fc	 mov	 edx, DWORD PTR _this$[ebp]
  00028	8b 42 20	 mov	 eax, DWORD PTR [edx+32]
  0002b	89 08		 mov	 DWORD PTR [eax], ecx
  0002d	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  00030	8b 51 20	 mov	 edx, DWORD PTR [ecx+32]
  00033	8b 02		 mov	 eax, DWORD PTR [edx]

; 242  : 		}

  00035	8b e5		 mov	 esp, ebp
  00037	5d		 pop	 ebp
  00038	c3		 ret	 0
?_Gnpreinc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ ENDP ; std::basic_streambuf<char,std::char_traits<char> >::_Gnpreinc
; Function compile flags: /Odtp
; File c:\program files (x86)\microsoft visual studio 9.0\vc\include\istream
_TEXT	ENDS
;	COMDAT ??Bsentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QBE_NXZ
_TEXT	SEGMENT
_this$ = -4						; size = 4
??Bsentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QBE_NXZ PROC ; std::basic_istream<char,std::char_traits<char> >::sentry::operator bool, COMDAT
; _this$ = ecx

; 80   : 			{	// test if _Ipfx succeeded

  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   : 			return (_Ok);

  00007	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  0000a	8a 40 04	 mov	 al, BYTE PTR [eax+4]

; 82   : 			}

  0000d	8b e5		 mov	 esp, ebp
  0000f	5d		 pop	 ebp
  00010	c3		 ret	 0
??Bsentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QBE_NXZ ENDP ; std::basic_istream<char,std::char_traits<char> >::sentry::operator bool
_TEXT	ENDS
PUBLIC	?Stamp@TiXmlParsingData@@QAEXPBDW4TiXmlEncoding@@@Z ; TiXmlParsingData::Stamp
; Function compile flags: /Odtp
; File c:\develop\dscaler423a\dscaler\tinyxmlparser.cpp
;	COMDAT ?Stamp@TiXmlParsingData@@QAEXPBDW4TiXmlEncoding@@@Z
_TEXT	SEGMENT
tv70 = -28						; size = 4
_this$ = -24						; size = 4
_step$21006 = -20					; size = 4
_pU$20982 = -16						; size = 4
_row$ = -12						; size = 4
_col$ = -8						; size = 4
_p$ = -4						; size = 4
_now$ = 8						; size = 4
_encoding$ = 12						; size = 4
?Stamp@TiXmlParsingData@@QAEXPBDW4TiXmlEncoding@@@Z PROC ; TiXmlParsingData::Stamp, COMDAT
; _this$ = ecx

; 197  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 1c	 sub	 esp, 28			; 0000001cH
  00006	89 4d e8	 mov	 DWORD PTR _this$[ebp], ecx

; 198  :     assert( now );
; 199  : 
; 200  :     // Do nothing if the tabsize is 0.
; 201  :     if ( tabsize < 1 )

  00009	8b 45 e8	 mov	 eax, DWORD PTR _this$[ebp]
  0000c	83 78 0c 01	 cmp	 DWORD PTR [eax+12], 1
  00010	7d 05		 jge	 SHORT $LN25@Stamp

; 202  :     {
; 203  :         return;

  00012	e9 12 02 00 00	 jmp	 $LN26@Stamp
$LN25@Stamp:

; 204  :     }
; 205  : 
; 206  :     // Get the current row, column.
; 207  :     int row = cursor.row;

  00017	8b 4d e8	 mov	 ecx, DWORD PTR _this$[ebp]
  0001a	8b 11		 mov	 edx, DWORD PTR [ecx]
  0001c	89 55 f4	 mov	 DWORD PTR _row$[ebp], edx

; 208  :     int col = cursor.col;

  0001f	8b 45 e8	 mov	 eax, DWORD PTR _this$[ebp]
  00022	8b 48 04	 mov	 ecx, DWORD PTR [eax+4]
  00025	89 4d f8	 mov	 DWORD PTR _col$[ebp], ecx

; 209  :     const char* p = stamp;

  00028	8b 55 e8	 mov	 edx, DWORD PTR _this$[ebp]
  0002b	8b 42 08	 mov	 eax, DWORD PTR [edx+8]
  0002e	89 45 fc	 mov	 DWORD PTR _p$[ebp], eax
$LN24@Stamp:

; 210  :     assert( p );
; 211  : 
; 212  :     while ( p < now )

  00031	8b 4d fc	 mov	 ecx, DWORD PTR _p$[ebp]
  00034	3b 4d 08	 cmp	 ecx, DWORD PTR _now$[ebp]
  00037	0f 83 d2 01 00
	00		 jae	 $LN23@Stamp

; 213  :     {
; 214  :         // Treat p as unsigned, so we have a happy compiler.
; 215  :         const unsigned char* pU = (const unsigned char*)p;

  0003d	8b 55 fc	 mov	 edx, DWORD PTR _p$[ebp]
  00040	89 55 f0	 mov	 DWORD PTR _pU$20982[ebp], edx

; 216  : 
; 217  :         // Code contributed by Fletcher Dunn: (modified by lee)
; 218  :         switch (*pU) {

  00043	8b 45 f0	 mov	 eax, DWORD PTR _pU$20982[ebp]
  00046	0f b6 08	 movzx	 ecx, BYTE PTR [eax]
  00049	89 4d e4	 mov	 DWORD PTR tv70[ebp], ecx
  0004c	81 7d e4 ef 00
	00 00		 cmp	 DWORD PTR tv70[ebp], 239 ; 000000efH
  00053	0f 87 68 01 00
	00		 ja	 $LN4@Stamp
  00059	8b 55 e4	 mov	 edx, DWORD PTR tv70[ebp]
  0005c	0f b6 82 00 00
	00 00		 movzx	 eax, BYTE PTR $LN28@Stamp[edx]
  00063	ff 24 85 00 00
	00 00		 jmp	 DWORD PTR $LN29@Stamp[eax*4]
$LN20@Stamp:

; 219  :             case 0:
; 220  :                 // We *should* never get here, but in case we do, don't
; 221  :                 // advance past the terminating null character, ever
; 222  :                 return;

  0006a	e9 ba 01 00 00	 jmp	 $LN26@Stamp
$LN19@Stamp:

; 223  : 
; 224  :             case '\r':
; 225  :                 // bump down to the next line
; 226  :                 ++row;

  0006f	8b 4d f4	 mov	 ecx, DWORD PTR _row$[ebp]
  00072	83 c1 01	 add	 ecx, 1
  00075	89 4d f4	 mov	 DWORD PTR _row$[ebp], ecx

; 227  :                 col = 0;

  00078	c7 45 f8 00 00
	00 00		 mov	 DWORD PTR _col$[ebp], 0

; 228  :                 // Eat the character
; 229  :                 ++p;

  0007f	8b 55 fc	 mov	 edx, DWORD PTR _p$[ebp]
  00082	83 c2 01	 add	 edx, 1
  00085	89 55 fc	 mov	 DWORD PTR _p$[ebp], edx

; 230  : 
; 231  :                 // Check for \r\n sequence, and treat this as a single character
; 232  :                 if (*p == '\n') {

  00088	8b 45 fc	 mov	 eax, DWORD PTR _p$[ebp]
  0008b	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  0008e	83 f9 0a	 cmp	 ecx, 10			; 0000000aH
  00091	75 09		 jne	 SHORT $LN18@Stamp

; 233  :                     ++p;

  00093	8b 55 fc	 mov	 edx, DWORD PTR _p$[ebp]
  00096	83 c2 01	 add	 edx, 1
  00099	89 55 fc	 mov	 DWORD PTR _p$[ebp], edx
$LN18@Stamp:

; 234  :                 }
; 235  :                 break;

  0009c	e9 69 01 00 00	 jmp	 $LN21@Stamp
$LN17@Stamp:

; 236  : 
; 237  :             case '\n':
; 238  :                 // bump down to the next line
; 239  :                 ++row;

  000a1	8b 45 f4	 mov	 eax, DWORD PTR _row$[ebp]
  000a4	83 c0 01	 add	 eax, 1
  000a7	89 45 f4	 mov	 DWORD PTR _row$[ebp], eax

; 240  :                 col = 0;

  000aa	c7 45 f8 00 00
	00 00		 mov	 DWORD PTR _col$[ebp], 0

; 241  : 
; 242  :                 // Eat the character
; 243  :                 ++p;

  000b1	8b 4d fc	 mov	 ecx, DWORD PTR _p$[ebp]
  000b4	83 c1 01	 add	 ecx, 1
  000b7	89 4d fc	 mov	 DWORD PTR _p$[ebp], ecx

; 244  : 
; 245  :                 // Check for \n\r sequence, and treat this as a single
; 246  :                 // character.  (Yes, this bizarre thing does occur still
; 247  :                 // on some arcane platforms...)
; 248  :                 if (*p == '\r') {

  000ba	8b 55 fc	 mov	 edx, DWORD PTR _p$[ebp]
  000bd	0f be 02	 movsx	 eax, BYTE PTR [edx]
  000c0	83 f8 0d	 cmp	 eax, 13			; 0000000dH
  000c3	75 09		 jne	 SHORT $LN16@Stamp

; 249  :                     ++p;

  000c5	8b 4d fc	 mov	 ecx, DWORD PTR _p$[ebp]
  000c8	83 c1 01	 add	 ecx, 1
  000cb	89 4d fc	 mov	 DWORD PTR _p$[ebp], ecx
$LN16@Stamp:

; 250  :                 }
; 251  :                 break;

  000ce	e9 37 01 00 00	 jmp	 $LN21@Stamp
$LN15@Stamp:

; 252  : 
; 253  :             case '\t':
; 254  :                 // Eat the character
; 255  :                 ++p;

  000d3	8b 55 fc	 mov	 edx, DWORD PTR _p$[ebp]
  000d6	83 c2 01	 add	 edx, 1
  000d9	89 55 fc	 mov	 DWORD PTR _p$[ebp], edx

; 256  : 
; 257  :                 // Skip to next tab stop
; 258  :                 col = (col / tabsize + 1) * tabsize;

  000dc	8b 4d e8	 mov	 ecx, DWORD PTR _this$[ebp]
  000df	8b 45 f8	 mov	 eax, DWORD PTR _col$[ebp]
  000e2	99		 cdq
  000e3	f7 79 0c	 idiv	 DWORD PTR [ecx+12]
  000e6	83 c0 01	 add	 eax, 1
  000e9	8b 55 e8	 mov	 edx, DWORD PTR _this$[ebp]
  000ec	0f af 42 0c	 imul	 eax, DWORD PTR [edx+12]
  000f0	89 45 f8	 mov	 DWORD PTR _col$[ebp], eax

; 259  :                 break;

  000f3	e9 12 01 00 00	 jmp	 $LN21@Stamp
$LN14@Stamp:

; 260  : 
; 261  :             case TIXML_UTF_LEAD_0:
; 262  :                 if ( encoding == TIXML_ENCODING_UTF8 )

  000f8	83 7d 0c 01	 cmp	 DWORD PTR _encoding$[ebp], 1
  000fc	0f 85 ab 00 00
	00		 jne	 $LN13@Stamp

; 263  :                 {
; 264  :                     if ( *(p+1) && *(p+2) )

  00102	8b 45 fc	 mov	 eax, DWORD PTR _p$[ebp]
  00105	0f be 48 01	 movsx	 ecx, BYTE PTR [eax+1]
  00109	85 c9		 test	 ecx, ecx
  0010b	0f 84 9a 00 00
	00		 je	 $LN12@Stamp
  00111	8b 55 fc	 mov	 edx, DWORD PTR _p$[ebp]
  00114	0f be 42 02	 movsx	 eax, BYTE PTR [edx+2]
  00118	85 c0		 test	 eax, eax
  0011a	0f 84 8b 00 00
	00		 je	 $LN12@Stamp

; 265  :                     {
; 266  :                         // In these cases, don't advance the column. These are
; 267  :                         // 0-width spaces.
; 268  :                         if ( *(pU+1)==TIXML_UTF_LEAD_1 && *(pU+2)==TIXML_UTF_LEAD_2 )

  00120	8b 4d f0	 mov	 ecx, DWORD PTR _pU$20982[ebp]
  00123	0f b6 51 01	 movzx	 edx, BYTE PTR [ecx+1]
  00127	81 fa bb 00 00
	00		 cmp	 edx, 187		; 000000bbH
  0012d	75 1a		 jne	 SHORT $LN11@Stamp
  0012f	8b 45 f0	 mov	 eax, DWORD PTR _pU$20982[ebp]
  00132	0f b6 48 02	 movzx	 ecx, BYTE PTR [eax+2]
  00136	81 f9 bf 00 00
	00		 cmp	 ecx, 191		; 000000bfH
  0013c	75 0b		 jne	 SHORT $LN11@Stamp

; 269  :                             p += 3;

  0013e	8b 55 fc	 mov	 edx, DWORD PTR _p$[ebp]
  00141	83 c2 03	 add	 edx, 3
  00144	89 55 fc	 mov	 DWORD PTR _p$[ebp], edx
  00147	eb 62		 jmp	 SHORT $LN12@Stamp
$LN11@Stamp:

; 270  :                         else if ( *(pU+1)==0xbfU && *(pU+2)==0xbeU )

  00149	8b 45 f0	 mov	 eax, DWORD PTR _pU$20982[ebp]
  0014c	0f b6 48 01	 movzx	 ecx, BYTE PTR [eax+1]
  00150	81 f9 bf 00 00
	00		 cmp	 ecx, 191		; 000000bfH
  00156	75 19		 jne	 SHORT $LN9@Stamp
  00158	8b 55 f0	 mov	 edx, DWORD PTR _pU$20982[ebp]
  0015b	0f b6 42 02	 movzx	 eax, BYTE PTR [edx+2]
  0015f	3d be 00 00 00	 cmp	 eax, 190		; 000000beH
  00164	75 0b		 jne	 SHORT $LN9@Stamp

; 271  :                             p += 3;

  00166	8b 4d fc	 mov	 ecx, DWORD PTR _p$[ebp]
  00169	83 c1 03	 add	 ecx, 3
  0016c	89 4d fc	 mov	 DWORD PTR _p$[ebp], ecx
  0016f	eb 3a		 jmp	 SHORT $LN12@Stamp
$LN9@Stamp:

; 272  :                         else if ( *(pU+1)==0xbfU && *(pU+2)==0xbfU )

  00171	8b 55 f0	 mov	 edx, DWORD PTR _pU$20982[ebp]
  00174	0f b6 42 01	 movzx	 eax, BYTE PTR [edx+1]
  00178	3d bf 00 00 00	 cmp	 eax, 191		; 000000bfH
  0017d	75 1a		 jne	 SHORT $LN7@Stamp
  0017f	8b 4d f0	 mov	 ecx, DWORD PTR _pU$20982[ebp]
  00182	0f b6 51 02	 movzx	 edx, BYTE PTR [ecx+2]
  00186	81 fa bf 00 00
	00		 cmp	 edx, 191		; 000000bfH
  0018c	75 0b		 jne	 SHORT $LN7@Stamp

; 273  :                             p += 3;

  0018e	8b 45 fc	 mov	 eax, DWORD PTR _p$[ebp]
  00191	83 c0 03	 add	 eax, 3
  00194	89 45 fc	 mov	 DWORD PTR _p$[ebp], eax

; 274  :                         else

  00197	eb 12		 jmp	 SHORT $LN12@Stamp
$LN7@Stamp:

; 275  :                             { p +=3; ++col; }    // A normal character.

  00199	8b 4d fc	 mov	 ecx, DWORD PTR _p$[ebp]
  0019c	83 c1 03	 add	 ecx, 3
  0019f	89 4d fc	 mov	 DWORD PTR _p$[ebp], ecx
  001a2	8b 55 f8	 mov	 edx, DWORD PTR _col$[ebp]
  001a5	83 c2 01	 add	 edx, 1
  001a8	89 55 f8	 mov	 DWORD PTR _col$[ebp], edx
$LN12@Stamp:

; 276  :                     }
; 277  :                 }
; 278  :                 else

  001ab	eb 12		 jmp	 SHORT $LN5@Stamp
$LN13@Stamp:

; 279  :                 {
; 280  :                     ++p;

  001ad	8b 45 fc	 mov	 eax, DWORD PTR _p$[ebp]
  001b0	83 c0 01	 add	 eax, 1
  001b3	89 45 fc	 mov	 DWORD PTR _p$[ebp], eax

; 281  :                     ++col;

  001b6	8b 4d f8	 mov	 ecx, DWORD PTR _col$[ebp]
  001b9	83 c1 01	 add	 ecx, 1
  001bc	89 4d f8	 mov	 DWORD PTR _col$[ebp], ecx
$LN5@Stamp:

; 282  :                 }
; 283  :                 break;

  001bf	eb 49		 jmp	 SHORT $LN21@Stamp
$LN4@Stamp:

; 284  : 
; 285  :             default:
; 286  :                 if ( encoding == TIXML_ENCODING_UTF8 )

  001c1	83 7d 0c 01	 cmp	 DWORD PTR _encoding$[ebp], 1
  001c5	75 31		 jne	 SHORT $LN3@Stamp

; 287  :                 {
; 288  :                     // Eat the 1 to 4 byte utf8 character.
; 289  :                     int step = TiXmlBase::utf8ByteTable[*((const unsigned char*)p)];

  001c7	8b 55 fc	 mov	 edx, DWORD PTR _p$[ebp]
  001ca	0f b6 02	 movzx	 eax, BYTE PTR [edx]
  001cd	8b 0c 85 00 00
	00 00		 mov	 ecx, DWORD PTR ?utf8ByteTable@TiXmlBase@@2QBHB[eax*4]
  001d4	89 4d ec	 mov	 DWORD PTR _step$21006[ebp], ecx

; 290  :                     if ( step == 0 )

  001d7	83 7d ec 00	 cmp	 DWORD PTR _step$21006[ebp], 0
  001db	75 07		 jne	 SHORT $LN2@Stamp

; 291  :                         step = 1;        // Error case from bad encoding, but handle gracefully.

  001dd	c7 45 ec 01 00
	00 00		 mov	 DWORD PTR _step$21006[ebp], 1
$LN2@Stamp:

; 292  :                     p += step;

  001e4	8b 55 fc	 mov	 edx, DWORD PTR _p$[ebp]
  001e7	03 55 ec	 add	 edx, DWORD PTR _step$21006[ebp]
  001ea	89 55 fc	 mov	 DWORD PTR _p$[ebp], edx

; 293  : 
; 294  :                     // Just advance one column, of course.
; 295  :                     ++col;

  001ed	8b 45 f8	 mov	 eax, DWORD PTR _col$[ebp]
  001f0	83 c0 01	 add	 eax, 1
  001f3	89 45 f8	 mov	 DWORD PTR _col$[ebp], eax

; 296  :                 }
; 297  :                 else

  001f6	eb 12		 jmp	 SHORT $LN21@Stamp
$LN3@Stamp:

; 298  :                 {
; 299  :                     ++p;

  001f8	8b 4d fc	 mov	 ecx, DWORD PTR _p$[ebp]
  001fb	83 c1 01	 add	 ecx, 1
  001fe	89 4d fc	 mov	 DWORD PTR _p$[ebp], ecx

; 300  :                     ++col;

  00201	8b 55 f8	 mov	 edx, DWORD PTR _col$[ebp]
  00204	83 c2 01	 add	 edx, 1
  00207	89 55 f8	 mov	 DWORD PTR _col$[ebp], edx
$LN21@Stamp:

; 301  :                 }
; 302  :                 break;
; 303  :         }
; 304  :     }

  0020a	e9 22 fe ff ff	 jmp	 $LN24@Stamp
$LN23@Stamp:

; 305  :     cursor.row = row;

  0020f	8b 45 e8	 mov	 eax, DWORD PTR _this$[ebp]
  00212	8b 4d f4	 mov	 ecx, DWORD PTR _row$[ebp]
  00215	89 08		 mov	 DWORD PTR [eax], ecx

; 306  :     cursor.col = col;

  00217	8b 55 e8	 mov	 edx, DWORD PTR _this$[ebp]
  0021a	8b 45 f8	 mov	 eax, DWORD PTR _col$[ebp]
  0021d	89 42 04	 mov	 DWORD PTR [edx+4], eax

; 307  :     assert( cursor.row >= -1 );
; 308  :     assert( cursor.col >= -1 );
; 309  :     stamp = p;

  00220	8b 4d e8	 mov	 ecx, DWORD PTR _this$[ebp]
  00223	8b 55 fc	 mov	 edx, DWORD PTR _p$[ebp]
  00226	89 51 08	 mov	 DWORD PTR [ecx+8], edx
$LN26@Stamp:

; 310  :     assert( stamp );
; 311  : }

  00229	8b e5		 mov	 esp, ebp
  0022b	5d		 pop	 ebp
  0022c	c2 08 00	 ret	 8
  0022f	90		 npad	 1
$LN29@Stamp:
  00230	00 00 00 00	 DD	 $LN20@Stamp
  00234	00 00 00 00	 DD	 $LN15@Stamp
  00238	00 00 00 00	 DD	 $LN17@Stamp
  0023c	00 00 00 00	 DD	 $LN19@Stamp
  00240	00 00 00 00	 DD	 $LN14@Stamp
  00244	00 00 00 00	 DD	 $LN4@Stamp
$LN28@Stamp:
  00248	00		 DB	 0
  00249	05		 DB	 5
  0024a	05		 DB	 5
  0024b	05		 DB	 5
  0024c	05		 DB	 5
  0024d	05		 DB	 5
  0024e	05		 DB	 5
  0024f	05		 DB	 5
  00250	05		 DB	 5
  00251	01		 DB	 1
  00252	02		 DB	 2
  00253	05		 DB	 5
  00254	05		 DB	 5
  00255	03		 DB	 3
  00256	05		 DB	 5
  00257	05		 DB	 5
  00258	05		 DB	 5
  00259	05		 DB	 5
  0025a	05		 DB	 5
  0025b	05		 DB	 5
  0025c	05		 DB	 5
  0025d	05		 DB	 5
  0025e	05		 DB	 5
  0025f	05		 DB	 5
  00260	05		 DB	 5
  00261	05		 DB	 5
  00262	05		 DB	 5
  00263	05		 DB	 5
  00264	05		 DB	 5
  00265	05		 DB	 5
  00266	05		 DB	 5
  00267	05		 DB	 5
  00268	05		 DB	 5
  00269	05		 DB	 5
  0026a	05		 DB	 5
  0026b	05		 DB	 5
  0026c	05		 DB	 5
  0026d	05		 DB	 5
  0026e	05		 DB	 5
  0026f	05		 DB	 5
  00270	05		 DB	 5
  00271	05		 DB	 5
  00272	05		 DB	 5
  00273	05		 DB	 5
  00274	05		 DB	 5
  00275	05		 DB	 5
  00276	05		 DB	 5
  00277	05		 DB	 5
  00278	05		 DB	 5
  00279	05		 DB	 5
  0027a	05		 DB	 5
  0027b	05		 DB	 5
  0027c	05		 DB	 5
  0027d	05		 DB	 5
  0027e	05		 DB	 5
  0027f	05		 DB	 5
  00280	05		 DB	 5
  00281	05		 DB	 5
  00282	05		 DB	 5
  00283	05		 DB	 5
  00284	05		 DB	 5
  00285	05		 DB	 5
  00286	05		 DB	 5
  00287	05		 DB	 5
  00288	05		 DB	 5
  00289	05		 DB	 5
  0028a	05		 DB	 5
  0028b	05		 DB	 5
  0028c	05		 DB	 5
  0028d	05		 DB	 5
  0028e	05		 DB	 5
  0028f	05		 DB	 5
  00290	05		 DB	 5
  00291	05		 DB	 5
  00292	05		 DB	 5
  00293	05		 DB	 5
  00294	05		 DB	 5
  00295	05		 DB	 5
  00296	05		 DB	 5
  00297	05		 DB	 5
  00298	05		 DB	 5
  00299	05		 DB	 5
  0029a	05		 DB	 5
  0029b	05		 DB	 5
  0029c	05		 DB	 5
  0029d	05		 DB	 5
  0029e	05		 DB	 5
  0029f	05		 DB	 5
  002a0	05		 DB	 5
  002a1	05		 DB	 5
  002a2	05		 DB	 5
  002a3	05		 DB	 5
  002a4	05		 DB	 5
  002a5	05		 DB	 5
  002a6	05		 DB	 5
  002a7	05		 DB	 5
  002a8	05		 DB	 5
  002a9	05		 DB	 5
  002aa	05		 DB	 5
  002ab	05		 DB	 5
  002ac	05		 DB	 5
  002ad	05		 DB	 5
  002ae	05		 DB	 5
  002af	05		 DB	 5
  002b0	05		 DB	 5
  002b1	05		 DB	 5
  002b2	05		 DB	 5
  002b3	05		 DB	 5
  002b4	05		 DB	 5
  002b5	05		 DB	 5
  002b6	05		 DB	 5
  002b7	05		 DB	 5
  002b8	05		 DB	 5
  002b9	05		 DB	 5
  002ba	05		 DB	 5
  002bb	05		 DB	 5
  002bc	05		 DB	 5
  002bd	05		 DB	 5
  002be	05		 DB	 5
  002bf	05		 DB	 5
  002c0	05		 DB	 5
  002c1	05		 DB	 5
  002c2	05		 DB	 5
  002c3	05		 DB	 5
  002c4	05		 DB	 5
  002c5	05		 DB	 5
  002c6	05		 DB	 5
  002c7	05		 DB	 5
  002c8	05		 DB	 5
  002c9	05		 DB	 5
  002ca	05		 DB	 5
  002cb	05		 DB	 5
  002cc	05		 DB	 5
  002cd	05		 DB	 5
  002ce	05		 DB	 5
  002cf	05		 DB	 5
  002d0	05		 DB	 5
  002d1	05		 DB	 5
  002d2	05		 DB	 5
  002d3	05		 DB	 5
  002d4	05		 DB	 5
  002d5	05		 DB	 5
  002d6	05		 DB	 5
  002d7	05		 DB	 5
  002d8	05		 DB	 5
  002d9	05		 DB	 5
  002da	05		 DB	 5
  002db	05		 DB	 5
  002dc	05		 DB	 5
  002dd	05		 DB	 5
  002de	05		 DB	 5
  002df	05		 DB	 5
  002e0	05		 DB	 5
  002e1	05		 DB	 5
  002e2	05		 DB	 5
  002e3	05		 DB	 5
  002e4	05		 DB	 5
  002e5	05		 DB	 5
  002e6	05		 DB	 5
  002e7	05		 DB	 5
  002e8	05		 DB	 5
  002e9	05		 DB	 5
  002ea	05		 DB	 5
  002eb	05		 DB	 5
  002ec	05		 DB	 5
  002ed	05		 DB	 5
  002ee	05		 DB	 5
  002ef	05		 DB	 5
  002f0	05		 DB	 5
  002f1	05		 DB	 5
  002f2	05		 DB	 5
  002f3	05		 DB	 5
  002f4	05		 DB	 5
  002f5	05		 DB	 5
  002f6	05		 DB	 5
  002f7	05		 DB	 5
  002f8	05		 DB	 5
  002f9	05		 DB	 5
  002fa	05		 DB	 5
  002fb	05		 DB	 5
  002fc	05		 DB	 5
  002fd	05		 DB	 5
  002fe	05		 DB	 5
  002ff	05		 DB	 5
  00300	05		 DB	 5
  00301	05		 DB	 5
  00302	05		 DB	 5
  00303	05		 DB	 5
  00304	05		 DB	 5
  00305	05		 DB	 5
  00306	05		 DB	 5
  00307	05		 DB	 5
  00308	05		 DB	 5
  00309	05		 DB	 5
  0030a	05		 DB	 5
  0030b	05		 DB	 5
  0030c	05		 DB	 5
  0030d	05		 DB	 5
  0030e	05		 DB	 5
  0030f	05		 DB	 5
  00310	05		 DB	 5
  00311	05		 DB	 5
  00312	05		 DB	 5
  00313	05		 DB	 5
  00314	05		 DB	 5
  00315	05		 DB	 5
  00316	05		 DB	 5
  00317	05		 DB	 5
  00318	05		 DB	 5
  00319	05		 DB	 5
  0031a	05		 DB	 5
  0031b	05		 DB	 5
  0031c	05		 DB	 5
  0031d	05		 DB	 5
  0031e	05		 DB	 5
  0031f	05		 DB	 5
  00320	05		 DB	 5
  00321	05		 DB	 5
  00322	05		 DB	 5
  00323	05		 DB	 5
  00324	05		 DB	 5
  00325	05		 DB	 5
  00326	05		 DB	 5
  00327	05		 DB	 5
  00328	05		 DB	 5
  00329	05		 DB	 5
  0032a	05		 DB	 5
  0032b	05		 DB	 5
  0032c	05		 DB	 5
  0032d	05		 DB	 5
  0032e	05		 DB	 5
  0032f	05		 DB	 5
  00330	05		 DB	 5
  00331	05		 DB	 5
  00332	05		 DB	 5
  00333	05		 DB	 5
  00334	05		 DB	 5
  00335	05		 DB	 5
  00336	05		 DB	 5
  00337	04		 DB	 4
?Stamp@TiXmlParsingData@@QAEXPBDW4TiXmlEncoding@@@Z ENDP ; TiXmlParsingData::Stamp
; Function compile flags: /Odtp
_TEXT	ENDS
;	COMDAT ?Cursor@TiXmlParsingData@@QAEABUTiXmlCursor@@XZ
_TEXT	SEGMENT
_this$ = -4						; size = 4
?Cursor@TiXmlParsingData@@QAEABUTiXmlCursor@@XZ PROC	; TiXmlParsingData::Cursor, COMDAT
; _this$ = ecx

; 177  :     const TiXmlCursor& Cursor()    { return cursor; }

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
  00004	89 4d fc	 mov	 DWORD PTR _this$[ebp], ecx
  00007	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  0000a	8b e5		 mov	 esp, ebp
  0000c	5d		 pop	 ebp
  0000d	c3		 ret	 0
?Cursor@TiXmlParsingData@@QAEABUTiXmlCursor@@XZ ENDP	; TiXmlParsingData::Cursor
_TEXT	ENDS
PUBLIC	?IsAlphaNum@TiXmlBase@@KAHEW4TiXmlEncoding@@@Z	; TiXmlBase::IsAlphaNum
; Function compile flags: /Odtp
;	COMDAT ?IsAlphaNum@TiXmlBase@@KAHEW4TiXmlEncoding@@@Z
_TEXT	SEGMENT
_anyByte$ = 8						; size = 1
___formal$ = 12						; size = 4
?IsAlphaNum@TiXmlBase@@KAHEW4TiXmlEncoding@@@Z PROC	; TiXmlBase::IsAlphaNum, COMDAT

; 151  : {

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

; 152  :     // This will only work for low-ascii, everything else is assumed to be a valid
; 153  :     // letter. I'm not sure this is the best approach, but it is quite tricky trying
; 154  :     // to figure out alhabetical vs. not across encoding. So take a very
; 155  :     // conservative approach.
; 156  : 
; 157  : //    if ( encoding == TIXML_ENCODING_UTF8 )
; 158  : //    {
; 159  :         if ( anyByte < 127 )

  00003	0f b6 45 08	 movzx	 eax, BYTE PTR _anyByte$[ebp]
  00007	83 f8 7f	 cmp	 eax, 127		; 0000007fH
  0000a	7d 11		 jge	 SHORT $LN2@IsAlphaNum

; 160  :             return isalnum( anyByte );

  0000c	0f b6 4d 08	 movzx	 ecx, BYTE PTR _anyByte$[ebp]
  00010	51		 push	 ecx
  00011	e8 00 00 00 00	 call	 _isalnum
  00016	83 c4 04	 add	 esp, 4
  00019	eb 07		 jmp	 SHORT $LN3@IsAlphaNum

; 161  :         else

  0001b	eb 05		 jmp	 SHORT $LN3@IsAlphaNum
$LN2@IsAlphaNum:

; 162  :             return 1;    // What else to do? The unicode set is huge...get the english ones right.

  0001d	b8 01 00 00 00	 mov	 eax, 1
$LN3@IsAlphaNum:

; 163  : //    }
; 164  : //    else
; 165  : //    {
; 166  : //        return isalnum( anyByte );
; 167  : //    }
; 168  : }

  00022	5d		 pop	 ebp
  00023	c3		 ret	 0
?IsAlphaNum@TiXmlBase@@KAHEW4TiXmlEncoding@@@Z ENDP	; TiXmlBase::IsAlphaNum
_TEXT	ENDS
PUBLIC	?IsAlpha@TiXmlBase@@KAHEW4TiXmlEncoding@@@Z	; TiXmlBase::IsAlpha
; Function compile flags: /Odtp
;	COMDAT ?IsAlpha@TiXmlBase@@KAHEW4TiXmlEncoding@@@Z
_TEXT	SEGMENT
_anyByte$ = 8						; size = 1
___formal$ = 12						; size = 4
?IsAlpha@TiXmlBase@@KAHEW4TiXmlEncoding@@@Z PROC	; TiXmlBase::IsAlpha, COMDAT

; 130  : {

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

; 131  :     // This will only work for low-ascii, everything else is assumed to be a valid
; 132  :     // letter. I'm not sure this is the best approach, but it is quite tricky trying
; 133  :     // to figure out alhabetical vs. not across encoding. So take a very
; 134  :     // conservative approach.
; 135  : 
; 136  : //    if ( encoding == TIXML_ENCODING_UTF8 )
; 137  : //    {
; 138  :         if ( anyByte < 127 )

  00003	0f b6 45 08	 movzx	 eax, BYTE PTR _anyByte$[ebp]
  00007	83 f8 7f	 cmp	 eax, 127		; 0000007fH
  0000a	7d 11		 jge	 SHORT $LN2@IsAlpha

; 139  :             return isalpha( anyByte );

  0000c	0f b6 4d 08	 movzx	 ecx, BYTE PTR _anyByte$[ebp]
  00010	51		 push	 ecx
  00011	e8 00 00 00 00	 call	 _isalpha
  00016	83 c4 04	 add	 esp, 4
  00019	eb 07		 jmp	 SHORT $LN3@IsAlpha

; 140  :         else

  0001b	eb 05		 jmp	 SHORT $LN3@IsAlpha
$LN2@IsAlpha:

; 141  :             return 1;    // What else to do? The unicode set is huge...get the english ones right.

  0001d	b8 01 00 00 00	 mov	 eax, 1
$LN3@IsAlpha:

; 142  : //    }
; 143  : //    else
; 144  : //    {
; 145  : //        return isalpha( anyByte );
; 146  : //    }
; 147  : }

  00022	5d		 pop	 ebp
  00023	c3		 ret	 0
?IsAlpha@TiXmlBase@@KAHEW4TiXmlEncoding@@@Z ENDP	; TiXmlBase::IsAlpha
_TEXT	ENDS
PUBLIC	?ConvertUTF32ToUTF8@TiXmlBase@@KAXKPADPAH@Z	; TiXmlBase::ConvertUTF32ToUTF8
; Function compile flags: /Odtp
;	COMDAT ?ConvertUTF32ToUTF8@TiXmlBase@@KAXKPADPAH@Z
_TEXT	SEGMENT
tv69 = -40						; size = 4
_BYTE_MARK$ = -36					; size = 4
_BYTE_MASK$ = -32					; size = 4
_FIRST_BYTE_MARK$ = -28					; size = 28
_input$ = 8						; size = 4
_output$ = 12						; size = 4
_length$ = 16						; size = 4
?ConvertUTF32ToUTF8@TiXmlBase@@KAXKPADPAH@Z PROC	; TiXmlBase::ConvertUTF32ToUTF8, COMDAT

; 89   : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 28	 sub	 esp, 40			; 00000028H

; 90   :     const unsigned long BYTE_MASK = 0xBF;

  00006	c7 45 e0 bf 00
	00 00		 mov	 DWORD PTR _BYTE_MASK$[ebp], 191 ; 000000bfH

; 91   :     const unsigned long BYTE_MARK = 0x80;

  0000d	c7 45 dc 80 00
	00 00		 mov	 DWORD PTR _BYTE_MARK$[ebp], 128 ; 00000080H

; 92   :     const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };

  00014	c7 45 e4 00 00
	00 00		 mov	 DWORD PTR _FIRST_BYTE_MARK$[ebp], 0
  0001b	c7 45 e8 00 00
	00 00		 mov	 DWORD PTR _FIRST_BYTE_MARK$[ebp+4], 0
  00022	c7 45 ec c0 00
	00 00		 mov	 DWORD PTR _FIRST_BYTE_MARK$[ebp+8], 192 ; 000000c0H
  00029	c7 45 f0 e0 00
	00 00		 mov	 DWORD PTR _FIRST_BYTE_MARK$[ebp+12], 224 ; 000000e0H
  00030	c7 45 f4 f0 00
	00 00		 mov	 DWORD PTR _FIRST_BYTE_MARK$[ebp+16], 240 ; 000000f0H
  00037	c7 45 f8 f8 00
	00 00		 mov	 DWORD PTR _FIRST_BYTE_MARK$[ebp+20], 248 ; 000000f8H
  0003e	c7 45 fc fc 00
	00 00		 mov	 DWORD PTR _FIRST_BYTE_MARK$[ebp+24], 252 ; 000000fcH

; 93   : 
; 94   :     if (input < 0x80)

  00045	81 7d 08 80 00
	00 00		 cmp	 DWORD PTR _input$[ebp], 128 ; 00000080H
  0004c	73 0b		 jae	 SHORT $LN14@ConvertUTF

; 95   :         *length = 1;

  0004e	8b 45 10	 mov	 eax, DWORD PTR _length$[ebp]
  00051	c7 00 01 00 00
	00		 mov	 DWORD PTR [eax], 1
  00057	eb 4a		 jmp	 SHORT $LN13@ConvertUTF
$LN14@ConvertUTF:

; 96   :     else if ( input < 0x800 )

  00059	81 7d 08 00 08
	00 00		 cmp	 DWORD PTR _input$[ebp], 2048 ; 00000800H
  00060	73 0b		 jae	 SHORT $LN12@ConvertUTF

; 97   :         *length = 2;

  00062	8b 4d 10	 mov	 ecx, DWORD PTR _length$[ebp]
  00065	c7 01 02 00 00
	00		 mov	 DWORD PTR [ecx], 2
  0006b	eb 36		 jmp	 SHORT $LN13@ConvertUTF
$LN12@ConvertUTF:

; 98   :     else if ( input < 0x10000 )

  0006d	81 7d 08 00 00
	01 00		 cmp	 DWORD PTR _input$[ebp], 65536 ; 00010000H
  00074	73 0b		 jae	 SHORT $LN10@ConvertUTF

; 99   :         *length = 3;

  00076	8b 55 10	 mov	 edx, DWORD PTR _length$[ebp]
  00079	c7 02 03 00 00
	00		 mov	 DWORD PTR [edx], 3
  0007f	eb 22		 jmp	 SHORT $LN13@ConvertUTF
$LN10@ConvertUTF:

; 100  :     else if ( input < 0x200000 )

  00081	81 7d 08 00 00
	20 00		 cmp	 DWORD PTR _input$[ebp], 2097152 ; 00200000H
  00088	73 0b		 jae	 SHORT $LN8@ConvertUTF

; 101  :         *length = 4;

  0008a	8b 45 10	 mov	 eax, DWORD PTR _length$[ebp]
  0008d	c7 00 04 00 00
	00		 mov	 DWORD PTR [eax], 4

; 102  :     else

  00093	eb 0e		 jmp	 SHORT $LN13@ConvertUTF
$LN8@ConvertUTF:

; 103  :         { *length = 0; return; }    // This code won't covert this correctly anyway.

  00095	8b 4d 10	 mov	 ecx, DWORD PTR _length$[ebp]
  00098	c7 01 00 00 00
	00		 mov	 DWORD PTR [ecx], 0
  0009e	e9 ba 00 00 00	 jmp	 $LN15@ConvertUTF
$LN13@ConvertUTF:

; 104  : 
; 105  :     output += *length;

  000a3	8b 55 10	 mov	 edx, DWORD PTR _length$[ebp]
  000a6	8b 45 0c	 mov	 eax, DWORD PTR _output$[ebp]
  000a9	03 02		 add	 eax, DWORD PTR [edx]
  000ab	89 45 0c	 mov	 DWORD PTR _output$[ebp], eax

; 106  : 
; 107  :     // Scary scary fall throughs.
; 108  :     switch (*length)

  000ae	8b 4d 10	 mov	 ecx, DWORD PTR _length$[ebp]
  000b1	8b 11		 mov	 edx, DWORD PTR [ecx]
  000b3	89 55 d8	 mov	 DWORD PTR tv69[ebp], edx
  000b6	8b 45 d8	 mov	 eax, DWORD PTR tv69[ebp]
  000b9	83 e8 01	 sub	 eax, 1
  000bc	89 45 d8	 mov	 DWORD PTR tv69[ebp], eax
  000bf	83 7d d8 03	 cmp	 DWORD PTR tv69[ebp], 3
  000c3	0f 87 94 00 00
	00		 ja	 $LN15@ConvertUTF
  000c9	8b 4d d8	 mov	 ecx, DWORD PTR tv69[ebp]
  000cc	ff 24 8d 00 00
	00 00		 jmp	 DWORD PTR $LN17@ConvertUTF[ecx*4]
$LN4@ConvertUTF:

; 109  :     {
; 110  :         case 4:
; 111  :             --output;

  000d3	8b 55 0c	 mov	 edx, DWORD PTR _output$[ebp]
  000d6	83 ea 01	 sub	 edx, 1
  000d9	89 55 0c	 mov	 DWORD PTR _output$[ebp], edx

; 112  :             *output = (char)((input | BYTE_MARK) & BYTE_MASK);

  000dc	8b 45 08	 mov	 eax, DWORD PTR _input$[ebp]
  000df	0d 80 00 00 00	 or	 eax, 128		; 00000080H
  000e4	25 bf 00 00 00	 and	 eax, 191		; 000000bfH
  000e9	8b 4d 0c	 mov	 ecx, DWORD PTR _output$[ebp]
  000ec	88 01		 mov	 BYTE PTR [ecx], al

; 113  :             input >>= 6;

  000ee	8b 55 08	 mov	 edx, DWORD PTR _input$[ebp]
  000f1	c1 ea 06	 shr	 edx, 6
  000f4	89 55 08	 mov	 DWORD PTR _input$[ebp], edx
$LN3@ConvertUTF:

; 114  :         case 3:
; 115  :             --output;

  000f7	8b 45 0c	 mov	 eax, DWORD PTR _output$[ebp]
  000fa	83 e8 01	 sub	 eax, 1
  000fd	89 45 0c	 mov	 DWORD PTR _output$[ebp], eax

; 116  :             *output = (char)((input | BYTE_MARK) & BYTE_MASK);

  00100	8b 4d 08	 mov	 ecx, DWORD PTR _input$[ebp]
  00103	81 c9 80 00 00
	00		 or	 ecx, 128		; 00000080H
  00109	81 e1 bf 00 00
	00		 and	 ecx, 191		; 000000bfH
  0010f	8b 55 0c	 mov	 edx, DWORD PTR _output$[ebp]
  00112	88 0a		 mov	 BYTE PTR [edx], cl

; 117  :             input >>= 6;

  00114	8b 45 08	 mov	 eax, DWORD PTR _input$[ebp]
  00117	c1 e8 06	 shr	 eax, 6
  0011a	89 45 08	 mov	 DWORD PTR _input$[ebp], eax
$LN2@ConvertUTF:

; 118  :         case 2:
; 119  :             --output;

  0011d	8b 4d 0c	 mov	 ecx, DWORD PTR _output$[ebp]
  00120	83 e9 01	 sub	 ecx, 1
  00123	89 4d 0c	 mov	 DWORD PTR _output$[ebp], ecx

; 120  :             *output = (char)((input | BYTE_MARK) & BYTE_MASK);

  00126	8b 55 08	 mov	 edx, DWORD PTR _input$[ebp]
  00129	81 ca 80 00 00
	00		 or	 edx, 128		; 00000080H
  0012f	81 e2 bf 00 00
	00		 and	 edx, 191		; 000000bfH
  00135	8b 45 0c	 mov	 eax, DWORD PTR _output$[ebp]
  00138	88 10		 mov	 BYTE PTR [eax], dl

; 121  :             input >>= 6;

  0013a	8b 4d 08	 mov	 ecx, DWORD PTR _input$[ebp]
  0013d	c1 e9 06	 shr	 ecx, 6
  00140	89 4d 08	 mov	 DWORD PTR _input$[ebp], ecx
$LN1@ConvertUTF:

; 122  :         case 1:
; 123  :             --output;

  00143	8b 55 0c	 mov	 edx, DWORD PTR _output$[ebp]
  00146	83 ea 01	 sub	 edx, 1
  00149	89 55 0c	 mov	 DWORD PTR _output$[ebp], edx

; 124  :             *output = (char)(input | FIRST_BYTE_MARK[*length]);

  0014c	8b 45 10	 mov	 eax, DWORD PTR _length$[ebp]
  0014f	8b 08		 mov	 ecx, DWORD PTR [eax]
  00151	8b 55 08	 mov	 edx, DWORD PTR _input$[ebp]
  00154	0b 54 8d e4	 or	 edx, DWORD PTR _FIRST_BYTE_MARK$[ebp+ecx*4]
  00158	8b 45 0c	 mov	 eax, DWORD PTR _output$[ebp]
  0015b	88 10		 mov	 BYTE PTR [eax], dl
$LN15@ConvertUTF:

; 125  :     }
; 126  : }

  0015d	8b e5		 mov	 esp, ebp
  0015f	5d		 pop	 ebp
  00160	c3		 ret	 0
  00161	8d 49 00	 npad	 3
$LN17@ConvertUTF:
  00164	00 00 00 00	 DD	 $LN1@ConvertUTF
  00168	00 00 00 00	 DD	 $LN2@ConvertUTF
  0016c	00 00 00 00	 DD	 $LN3@ConvertUTF
  00170	00 00 00 00	 DD	 $LN4@ConvertUTF
?ConvertUTF32ToUTF8@TiXmlBase@@KAXKPADPAH@Z ENDP	; TiXmlBase::ConvertUTF32ToUTF8
; Function compile flags: /Odtp
; File c:\develop\dscaler423a\dscaler\tinyxml.h
_TEXT	ENDS
;	COMDAT ?TabSize@TiXmlDocument@@QBEHXZ
_TEXT	SEGMENT
_this$ = -4						; size = 4
?TabSize@TiXmlDocument@@QBEHXZ PROC			; TiXmlDocument::TabSize, COMDAT
; _this$ = ecx

; 1476 :     int TabSize() const    { return tabsize; }

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
  00004	89 4d fc	 mov	 DWORD PTR _this$[ebp], ecx
  00007	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  0000a	8b 40 68	 mov	 eax, DWORD PTR [eax+104]
  0000d	8b e5		 mov	 esp, ebp
  0000f	5d		 pop	 ebp
  00010	c3		 ret	 0
?TabSize@TiXmlDocument@@QBEHXZ ENDP			; TiXmlDocument::TabSize
; Function compile flags: /Odtp
_TEXT	ENDS
;	COMDAT ?SetCDATA@TiXmlText@@QAEX_N@Z
_TEXT	SEGMENT
_this$ = -4						; size = 4
__cdata$ = 8						; size = 1
?SetCDATA@TiXmlText@@QAEX_N@Z PROC			; TiXmlText::SetCDATA, COMDAT
; _this$ = ecx

; 1211 :     void SetCDATA( bool _cdata )    { cdata = _cdata; }

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
  00004	89 4d fc	 mov	 DWORD PTR _this$[ebp], ecx
  00007	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  0000a	8a 4d 08	 mov	 cl, BYTE PTR __cdata$[ebp]
  0000d	88 48 44	 mov	 BYTE PTR [eax+68], cl
  00010	8b e5		 mov	 esp, ebp
  00012	5d		 pop	 ebp
  00013	c2 04 00	 ret	 4
?SetCDATA@TiXmlText@@QAEX_N@Z ENDP			; TiXmlText::SetCDATA
; Function compile flags: /Odtp
_TEXT	ENDS
;	COMDAT ?SetDocument@TiXmlAttribute@@QAEXPAVTiXmlDocument@@@Z
_TEXT	SEGMENT
_this$ = -4						; size = 4
_doc$ = 8						; size = 4
?SetDocument@TiXmlAttribute@@QAEXPAVTiXmlDocument@@@Z PROC ; TiXmlAttribute::SetDocument, COMDAT
; _this$ = ecx

; 870  :     void SetDocument( TiXmlDocument* doc )    { document = doc; }

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
  00004	89 4d fc	 mov	 DWORD PTR _this$[ebp], ecx
  00007	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  0000a	8b 4d 08	 mov	 ecx, DWORD PTR _doc$[ebp]
  0000d	89 48 10	 mov	 DWORD PTR [eax+16], ecx
  00010	8b e5		 mov	 esp, ebp
  00012	5d		 pop	 ebp
  00013	c2 04 00	 ret	 4
?SetDocument@TiXmlAttribute@@QAEXPAVTiXmlDocument@@@Z ENDP ; TiXmlAttribute::SetDocument
; Function compile flags: /Odtp
_TEXT	ENDS
;	COMDAT ?NameTStr@TiXmlAttribute@@QBEABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ
_TEXT	SEGMENT
_this$ = -4						; size = 4
?NameTStr@TiXmlAttribute@@QBEABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ PROC ; TiXmlAttribute::NameTStr, COMDAT
; _this$ = ecx

; 813  :     const TIXML_STRING& NameTStr() const { return name; }

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
  00004	89 4d fc	 mov	 DWORD PTR _this$[ebp], ecx
  00007	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  0000a	83 c0 14	 add	 eax, 20			; 00000014H
  0000d	8b e5		 mov	 esp, ebp
  0000f	5d		 pop	 ebp
  00010	c3		 ret	 0
?NameTStr@TiXmlAttribute@@QBEABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ ENDP ; TiXmlAttribute::NameTStr
; Function compile flags: /Odtp
_TEXT	ENDS
;	COMDAT ?ToLower@TiXmlBase@@KAHHW4TiXmlEncoding@@@Z
_TEXT	SEGMENT
_v$ = 8							; size = 4
_encoding$ = 12						; size = 4
?ToLower@TiXmlBase@@KAHHW4TiXmlEncoding@@@Z PROC	; TiXmlBase::ToLower, COMDAT

; 378  :     {

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

; 379  :         if ( encoding == TIXML_ENCODING_UTF8 )

  00003	83 7d 0c 01	 cmp	 DWORD PTR _encoding$[ebp], 1
  00007	75 1e		 jne	 SHORT $LN3@ToLower

; 380  :         {
; 381  :             if ( v < 128 ) return tolower( v );

  00009	81 7d 08 80 00
	00 00		 cmp	 DWORD PTR _v$[ebp], 128	; 00000080H
  00010	7d 0e		 jge	 SHORT $LN2@ToLower
  00012	8b 45 08	 mov	 eax, DWORD PTR _v$[ebp]
  00015	50		 push	 eax
  00016	e8 00 00 00 00	 call	 _tolower
  0001b	83 c4 04	 add	 esp, 4
  0001e	eb 13		 jmp	 SHORT $LN4@ToLower
$LN2@ToLower:

; 382  :             return v;

  00020	8b 45 08	 mov	 eax, DWORD PTR _v$[ebp]
  00023	eb 0e		 jmp	 SHORT $LN4@ToLower

; 383  :         }
; 384  :         else

  00025	eb 0c		 jmp	 SHORT $LN4@ToLower
$LN3@ToLower:

; 385  :         {
; 386  :             return tolower( v );

  00027	8b 4d 08	 mov	 ecx, DWORD PTR _v$[ebp]
  0002a	51		 push	 ecx
  0002b	e8 00 00 00 00	 call	 _tolower
  00030	83 c4 04	 add	 esp, 4
$LN4@ToLower:

; 387  :         }
; 388  :     }

  00033	5d		 pop	 ebp
  00034	c3		 ret	 0
?ToLower@TiXmlBase@@KAHHW4TiXmlEncoding@@@Z ENDP	; TiXmlBase::ToLower
; Function compile flags: /Odtp
_TEXT	ENDS
;	COMDAT ?IsWhiteSpace@TiXmlBase@@KA_ND@Z
_TEXT	SEGMENT
tv72 = -4						; size = 4
_c$ = 8							; size = 1
?IsWhiteSpace@TiXmlBase@@KA_ND@Z PROC			; TiXmlBase::IsWhiteSpace, COMDAT

; 282  :     {

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

; 283  :         return ( isspace( (unsigned char) c ) || c == '\n' || c == '\r' );

  00004	0f b6 45 08	 movzx	 eax, BYTE PTR _c$[ebp]
  00008	50		 push	 eax
  00009	e8 00 00 00 00	 call	 _isspace
  0000e	83 c4 04	 add	 esp, 4
  00011	85 c0		 test	 eax, eax
  00013	75 1b		 jne	 SHORT $LN3@IsWhiteSpa
  00015	0f be 4d 08	 movsx	 ecx, BYTE PTR _c$[ebp]
  00019	83 f9 0a	 cmp	 ecx, 10			; 0000000aH
  0001c	74 12		 je	 SHORT $LN3@IsWhiteSpa
  0001e	0f be 55 08	 movsx	 edx, BYTE PTR _c$[ebp]
  00022	83 fa 0d	 cmp	 edx, 13			; 0000000dH
  00025	74 09		 je	 SHORT $LN3@IsWhiteSpa
  00027	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR tv72[ebp], 0
  0002e	eb 07		 jmp	 SHORT $LN4@IsWhiteSpa
$LN3@IsWhiteSpa:
  00030	c7 45 fc 01 00
	00 00		 mov	 DWORD PTR tv72[ebp], 1
$LN4@IsWhiteSpa:
  00037	8a 45 fc	 mov	 al, BYTE PTR tv72[ebp]

; 284  :     }

  0003a	8b e5		 mov	 esp, ebp
  0003c	5d		 pop	 ebp
  0003d	c3		 ret	 0
?IsWhiteSpace@TiXmlBase@@KA_ND@Z ENDP			; TiXmlBase::IsWhiteSpace
; Function compile flags: /Odtp
_TEXT	ENDS
;	COMDAT ?IsWhiteSpaceCondensed@TiXmlBase@@SA_NXZ
_TEXT	SEGMENT
?IsWhiteSpaceCondensed@TiXmlBase@@SA_NXZ PROC		; TiXmlBase::IsWhiteSpaceCondensed, COMDAT

; 220  :     static bool IsWhiteSpaceCondensed()                        { return condenseWhiteSpace; }

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	a0 00 00 00 00	 mov	 al, BYTE PTR ?condenseWhiteSpace@TiXmlBase@@0_NA ; TiXmlBase::condenseWhiteSpace
  00008	5d		 pop	 ebp
  00009	c3		 ret	 0
?IsWhiteSpaceCondensed@TiXmlBase@@SA_NXZ ENDP		; TiXmlBase::IsWhiteSpaceCondensed
; Function compile flags: /Odtp
; File c:\program files (x86)\microsoft visual studio 9.0\vc\include\xlocale
_TEXT	ENDS
;	COMDAT ?is@?$ctype@D@std@@QBE_NFD@Z
_TEXT	SEGMENT
_this$ = -4						; size = 4
__Maskval$ = 8						; size = 2
__Ch$ = 12						; size = 1
?is@?$ctype@D@std@@QBE_NFD@Z PROC			; std::ctype<char>::is, COMDAT
; _this$ = ecx

; 1662 : 		{	// test if element fits any mask classifications

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

; 1663 : 		return ((_Ctype._Table[(unsigned char)_Ch] & _Maskval) != 0);

  00007	0f b6 45 0c	 movzx	 eax, BYTE PTR __Ch$[ebp]
  0000b	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  0000e	8b 51 10	 mov	 edx, DWORD PTR [ecx+16]
  00011	0f bf 04 42	 movsx	 eax, WORD PTR [edx+eax*2]
  00015	0f bf 4d 08	 movsx	 ecx, WORD PTR __Maskval$[ebp]
  00019	23 c1		 and	 eax, ecx
  0001b	f7 d8		 neg	 eax
  0001d	1b c0		 sbb	 eax, eax
  0001f	f7 d8		 neg	 eax

; 1664 : 		}

  00021	8b e5		 mov	 esp, ebp
  00023	5d		 pop	 ebp
  00024	c2 08 00	 ret	 8
?is@?$ctype@D@std@@QBE_NFD@Z ENDP			; std::ctype<char>::is
; Function compile flags: /Odtp
; File c:\program files (x86)\microsoft visual studio 9.0\vc\include\streambuf
;	COMDAT ?sbumpc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ
_TEXT	SEGMENT
tv75 = -8						; size = 4
_this$ = -4						; size = 4
?sbumpc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ PROC ; std::basic_streambuf<char,std::char_traits<char> >::sbumpc, COMDAT
; _this$ = ecx

; 104  : 		{	// get a character and point past it

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 08	 sub	 esp, 8
  00006	89 4d fc	 mov	 DWORD PTR _this$[ebp], ecx

; 105  : 		return (0 < _Gnavail()
; 106  : 			? _Traits::to_int_type(*_Gninc()) : uflow());

  00009	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  0000c	e8 00 00 00 00	 call	 ?_Gnavail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEHXZ ; std::basic_streambuf<char,std::char_traits<char> >::_Gnavail
  00011	85 c0		 test	 eax, eax
  00013	7e 16		 jle	 SHORT $LN3@sbumpc
  00015	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  00018	e8 00 00 00 00	 call	 ?_Gninc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ ; std::basic_streambuf<char,std::char_traits<char> >::_Gninc
  0001d	50		 push	 eax
  0001e	e8 00 00 00 00	 call	 ?to_int_type@?$char_traits@D@std@@SAHABD@Z ; std::char_traits<char>::to_int_type
  00023	83 c4 04	 add	 esp, 4
  00026	89 45 f8	 mov	 DWORD PTR tv75[ebp], eax
  00029	eb 10		 jmp	 SHORT $LN4@sbumpc
$LN3@sbumpc:
  0002b	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  0002e	8b 10		 mov	 edx, DWORD PTR [eax]
  00030	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  00033	8b 42 14	 mov	 eax, DWORD PTR [edx+20]
  00036	ff d0		 call	 eax
  00038	89 45 f8	 mov	 DWORD PTR tv75[ebp], eax
$LN4@sbumpc:
  0003b	8b 45 f8	 mov	 eax, DWORD PTR tv75[ebp]

; 107  : 		}

  0003e	8b e5		 mov	 esp, ebp
  00040	5d		 pop	 ebp
  00041	c3		 ret	 0
?sbumpc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ ENDP ; std::basic_streambuf<char,std::char_traits<char> >::sbumpc
; Function compile flags: /Odtp
; File c:\program files (x86)\microsoft visual studio 9.0\vc\include\istream
_TEXT	ENDS
;	COMDAT ??0_Sentry_base@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@@Z
_TEXT	SEGMENT
_this$ = -4						; size = 4
__Istr$ = 8						; size = 4
??0_Sentry_base@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@@Z PROC ; std::basic_istream<char,std::char_traits<char> >::_Sentry_base::_Sentry_base, COMDAT
; _this$ = ecx

; 55   : 			{	// lock the stream buffer, if there

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
  00004	89 4d fc	 mov	 DWORD PTR _this$[ebp], ecx
  00007	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  0000a	8b 4d 08	 mov	 ecx, DWORD PTR __Istr$[ebp]
  0000d	89 08		 mov	 DWORD PTR [eax], ecx

; 56   : 			if (_Myistr.rdbuf() != 0)

  0000f	8b 55 fc	 mov	 edx, DWORD PTR _this$[ebp]
  00012	8b 02		 mov	 eax, DWORD PTR [edx]
  00014	8b 08		 mov	 ecx, DWORD PTR [eax]
  00016	8b 55 fc	 mov	 edx, DWORD PTR _this$[ebp]
  00019	8b 02		 mov	 eax, DWORD PTR [edx]
  0001b	03 41 04	 add	 eax, DWORD PTR [ecx+4]
  0001e	8b c8		 mov	 ecx, eax
  00020	e8 00 00 00 00	 call	 ?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ ; std::basic_ios<char,std::char_traits<char> >::rdbuf
  00025	85 c0		 test	 eax, eax
  00027	74 1b		 je	 SHORT $LN2@Sentry_bas

; 57   : 				_Myistr.rdbuf()->_Lock();

  00029	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  0002c	8b 11		 mov	 edx, DWORD PTR [ecx]
  0002e	8b 02		 mov	 eax, DWORD PTR [edx]
  00030	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  00033	8b 09		 mov	 ecx, DWORD PTR [ecx]
  00035	03 48 04	 add	 ecx, DWORD PTR [eax+4]
  00038	e8 00 00 00 00	 call	 ?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ ; std::basic_ios<char,std::char_traits<char> >::rdbuf
  0003d	8b c8		 mov	 ecx, eax
  0003f	e8 00 00 00 00	 call	 ?_Lock@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEXXZ ; std::basic_streambuf<char,std::char_traits<char> >::_Lock
$LN2@Sentry_bas:

; 58   : 			}

  00044	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  00047	8b e5		 mov	 esp, ebp
  00049	5d		 pop	 ebp
  0004a	c2 04 00	 ret	 4
??0_Sentry_base@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@@Z ENDP ; std::basic_istream<char,std::char_traits<char> >::_Sentry_base::_Sentry_base
; Function compile flags: /Odtp
; File c:\program files (x86)\microsoft visual studio 9.0\vc\include\streambuf
_TEXT	ENDS
;	COMDAT ?sgetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ
_TEXT	SEGMENT
tv75 = -8						; size = 4
_this$ = -4						; size = 4
?sgetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ PROC ; std::basic_streambuf<char,std::char_traits<char> >::sgetc, COMDAT
; _this$ = ecx

; 110  : 		{	// get a character and don't point past it

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 08	 sub	 esp, 8
  00006	89 4d fc	 mov	 DWORD PTR _this$[ebp], ecx

; 111  : 		return (0 < _Gnavail()
; 112  : 			? _Traits::to_int_type(*gptr()) : underflow());

  00009	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  0000c	e8 00 00 00 00	 call	 ?_Gnavail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEHXZ ; std::basic_streambuf<char,std::char_traits<char> >::_Gnavail
  00011	85 c0		 test	 eax, eax
  00013	7e 16		 jle	 SHORT $LN3@sgetc
  00015	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  00018	e8 00 00 00 00	 call	 ?gptr@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEPADXZ ; std::basic_streambuf<char,std::char_traits<char> >::gptr
  0001d	50		 push	 eax
  0001e	e8 00 00 00 00	 call	 ?to_int_type@?$char_traits@D@std@@SAHABD@Z ; std::char_traits<char>::to_int_type
  00023	83 c4 04	 add	 esp, 4
  00026	89 45 f8	 mov	 DWORD PTR tv75[ebp], eax
  00029	eb 10		 jmp	 SHORT $LN4@sgetc
$LN3@sgetc:
  0002b	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  0002e	8b 10		 mov	 edx, DWORD PTR [eax]
  00030	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  00033	8b 42 10	 mov	 eax, DWORD PTR [edx+16]
  00036	ff d0		 call	 eax
  00038	89 45 f8	 mov	 DWORD PTR tv75[ebp], eax
$LN4@sgetc:
  0003b	8b 45 f8	 mov	 eax, DWORD PTR tv75[ebp]

; 113  : 		}

  0003e	8b e5		 mov	 esp, ebp
  00040	5d		 pop	 ebp
  00041	c3		 ret	 0
?sgetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ ENDP ; std::basic_streambuf<char,std::char_traits<char> >::sgetc
; Function compile flags: /Odtp
; File c:\program files (x86)\microsoft visual studio 9.0\vc\include\istream
_TEXT	ENDS
;	COMDAT ??1_Sentry_base@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ
_TEXT	SEGMENT
_this$ = -4						; size = 4
??1_Sentry_base@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ PROC ; std::basic_istream<char,std::char_traits<char> >::_Sentry_base::~_Sentry_base, COMDAT
; _this$ = ecx

; 61   : 			{	// destroy after unlocking

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

; 62   : 			if (_Myistr.rdbuf() != 0)

  00007	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  0000a	8b 08		 mov	 ecx, DWORD PTR [eax]
  0000c	8b 11		 mov	 edx, DWORD PTR [ecx]
  0000e	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  00011	8b 08		 mov	 ecx, DWORD PTR [eax]
  00013	03 4a 04	 add	 ecx, DWORD PTR [edx+4]
  00016	e8 00 00 00 00	 call	 ?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ ; std::basic_ios<char,std::char_traits<char> >::rdbuf
  0001b	85 c0		 test	 eax, eax
  0001d	74 1b		 je	 SHORT $LN2@Sentry_bas@2

; 63   : 				_Myistr.rdbuf()->_Unlock();

  0001f	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  00022	8b 11		 mov	 edx, DWORD PTR [ecx]
  00024	8b 02		 mov	 eax, DWORD PTR [edx]
  00026	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  00029	8b 09		 mov	 ecx, DWORD PTR [ecx]
  0002b	03 48 04	 add	 ecx, DWORD PTR [eax+4]
  0002e	e8 00 00 00 00	 call	 ?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ ; std::basic_ios<char,std::char_traits<char> >::rdbuf
  00033	8b c8		 mov	 ecx, eax
  00035	e8 00 00 00 00	 call	 ?_Unlock@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEXXZ ; std::basic_streambuf<char,std::char_traits<char> >::_Unlock
$LN2@Sentry_bas@2:

; 64   : 			}

  0003a	8b e5		 mov	 esp, ebp
  0003c	5d		 pop	 ebp
  0003d	c3		 ret	 0
??1_Sentry_base@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ ENDP ; std::basic_istream<char,std::char_traits<char> >::_Sentry_base::~_Sentry_base
; Function compile flags: /Odtp
; File c:\program files (x86)\microsoft visual studio 9.0\vc\include\xstring
_TEXT	ENDS
;	COMDAT ?at@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAADI@Z
_TEXT	SEGMENT
_this$ = -4						; size = 4
__Off$ = 8						; size = 4
?at@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAADI@Z PROC ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::at, COMDAT
; _this$ = ecx

; 1541 : 		{	// subscript mutable sequence with checking

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

; 1542 : 		if (_Mysize <= _Off)

  00007	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  0000a	8b 48 14	 mov	 ecx, DWORD PTR [eax+20]
  0000d	3b 4d 08	 cmp	 ecx, DWORD PTR __Off$[ebp]
  00010	77 05		 ja	 SHORT $LN1@at

; 1543 : 			_String_base::_Xran();	// _Off off end

  00012	e8 00 00 00 00	 call	 ?_Xran@_String_base@std@@SAXXZ ; std::_String_base::_Xran
$LN1@at:

; 1544 : 		return (_Myptr()[_Off]);

  00017	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  0001a	e8 00 00 00 00	 call	 ?_Myptr@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@IAEPADXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::_Myptr
  0001f	03 45 08	 add	 eax, DWORD PTR __Off$[ebp]

; 1545 : 		}

  00022	8b e5		 mov	 esp, ebp
  00024	5d		 pop	 ebp
  00025	c2 04 00	 ret	 4
?at@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAADI@Z ENDP ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::at
_TEXT	ENDS
PUBLIC	?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
; Function compile flags: /Odtp
; File c:\develop\dscaler423a\dscaler\tinyxmlparser.cpp
;	COMDAT ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z
_TEXT	SEGMENT
_q$ = -4						; size = 4
_p$ = 8							; size = 4
_tag$ = 12						; size = 4
_ignoreCase$ = 16					; size = 1
_encoding$ = 20						; size = 4
?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z PROC ; TiXmlBase::StringEqual, COMDAT

; 538  : {

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

; 539  :     assert( p );
; 540  :     assert( tag );
; 541  :     if ( !p || !*p )

  00005	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00009	74 0a		 je	 SHORT $LN9@StringEqua
  0000b	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0000e	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  00011	85 c9		 test	 ecx, ecx
  00013	75 07		 jne	 SHORT $LN10@StringEqua
$LN9@StringEqua:

; 542  :     {
; 543  :         assert( 0 );
; 544  :         return false;

  00015	32 c0		 xor	 al, al
  00017	e9 ba 00 00 00	 jmp	 $LN11@StringEqua
$LN10@StringEqua:

; 545  :     }
; 546  : 
; 547  :     const char* q = p;

  0001c	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0001f	89 55 fc	 mov	 DWORD PTR _q$[ebp], edx

; 548  : 
; 549  :     if ( ignoreCase )

  00022	0f b6 45 10	 movzx	 eax, BYTE PTR _ignoreCase$[ebp]
  00026	85 c0		 test	 eax, eax
  00028	74 64		 je	 SHORT $LN3@StringEqua
$LN7@StringEqua:

; 550  :     {
; 551  :         while ( *q && *tag && ToLower( *q, encoding ) == ToLower( *tag, encoding ) )

  0002a	8b 4d fc	 mov	 ecx, DWORD PTR _q$[ebp]
  0002d	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  00030	85 d2		 test	 edx, edx
  00032	74 4a		 je	 SHORT $LN6@StringEqua
  00034	8b 45 0c	 mov	 eax, DWORD PTR _tag$[ebp]
  00037	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  0003a	85 c9		 test	 ecx, ecx
  0003c	74 40		 je	 SHORT $LN6@StringEqua
  0003e	8b 55 14	 mov	 edx, DWORD PTR _encoding$[ebp]
  00041	52		 push	 edx
  00042	8b 45 fc	 mov	 eax, DWORD PTR _q$[ebp]
  00045	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  00048	51		 push	 ecx
  00049	e8 00 00 00 00	 call	 ?ToLower@TiXmlBase@@KAHHW4TiXmlEncoding@@@Z ; TiXmlBase::ToLower
  0004e	83 c4 08	 add	 esp, 8
  00051	8b f0		 mov	 esi, eax
  00053	8b 55 14	 mov	 edx, DWORD PTR _encoding$[ebp]
  00056	52		 push	 edx
  00057	8b 45 0c	 mov	 eax, DWORD PTR _tag$[ebp]
  0005a	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  0005d	51		 push	 ecx
  0005e	e8 00 00 00 00	 call	 ?ToLower@TiXmlBase@@KAHHW4TiXmlEncoding@@@Z ; TiXmlBase::ToLower
  00063	83 c4 08	 add	 esp, 8
  00066	3b f0		 cmp	 esi, eax
  00068	75 14		 jne	 SHORT $LN6@StringEqua

; 552  :         {
; 553  :             ++q;

  0006a	8b 55 fc	 mov	 edx, DWORD PTR _q$[ebp]
  0006d	83 c2 01	 add	 edx, 1
  00070	89 55 fc	 mov	 DWORD PTR _q$[ebp], edx

; 554  :             ++tag;

  00073	8b 45 0c	 mov	 eax, DWORD PTR _tag$[ebp]
  00076	83 c0 01	 add	 eax, 1
  00079	89 45 0c	 mov	 DWORD PTR _tag$[ebp], eax

; 555  :         }

  0007c	eb ac		 jmp	 SHORT $LN7@StringEqua
$LN6@StringEqua:

; 556  : 
; 557  :         if ( *tag == 0 )

  0007e	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  00081	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  00084	85 d2		 test	 edx, edx
  00086	75 04		 jne	 SHORT $LN5@StringEqua

; 558  :             return true;

  00088	b0 01		 mov	 al, 1
  0008a	eb 4a		 jmp	 SHORT $LN11@StringEqua
$LN5@StringEqua:

; 559  :     }
; 560  :     else

  0008c	eb 46		 jmp	 SHORT $LN4@StringEqua
$LN3@StringEqua:

; 561  :     {
; 562  :         while ( *q && *tag && *q == *tag )

  0008e	8b 45 fc	 mov	 eax, DWORD PTR _q$[ebp]
  00091	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  00094	85 c9		 test	 ecx, ecx
  00096	74 2e		 je	 SHORT $LN2@StringEqua
  00098	8b 55 0c	 mov	 edx, DWORD PTR _tag$[ebp]
  0009b	0f be 02	 movsx	 eax, BYTE PTR [edx]
  0009e	85 c0		 test	 eax, eax
  000a0	74 24		 je	 SHORT $LN2@StringEqua
  000a2	8b 4d fc	 mov	 ecx, DWORD PTR _q$[ebp]
  000a5	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  000a8	8b 45 0c	 mov	 eax, DWORD PTR _tag$[ebp]
  000ab	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  000ae	3b d1		 cmp	 edx, ecx
  000b0	75 14		 jne	 SHORT $LN2@StringEqua

; 563  :         {
; 564  :             ++q;

  000b2	8b 55 fc	 mov	 edx, DWORD PTR _q$[ebp]
  000b5	83 c2 01	 add	 edx, 1
  000b8	89 55 fc	 mov	 DWORD PTR _q$[ebp], edx

; 565  :             ++tag;

  000bb	8b 45 0c	 mov	 eax, DWORD PTR _tag$[ebp]
  000be	83 c0 01	 add	 eax, 1
  000c1	89 45 0c	 mov	 DWORD PTR _tag$[ebp], eax

; 566  :         }

  000c4	eb c8		 jmp	 SHORT $LN3@StringEqua
$LN2@StringEqua:

; 567  : 
; 568  :         if ( *tag == 0 )        // Have we found the end of the tag, and everything equal?

  000c6	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  000c9	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  000cc	85 d2		 test	 edx, edx
  000ce	75 04		 jne	 SHORT $LN4@StringEqua

; 569  :             return true;

  000d0	b0 01		 mov	 al, 1
  000d2	eb 02		 jmp	 SHORT $LN11@StringEqua
$LN4@StringEqua:

; 570  :     }
; 571  :     return false;

  000d4	32 c0		 xor	 al, al
$LN11@StringEqua:

; 572  : }

  000d6	5e		 pop	 esi
  000d7	8b e5		 mov	 esp, ebp
  000d9	5d		 pop	 ebp
  000da	c3		 ret	 0
?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ENDP ; TiXmlBase::StringEqual
_TEXT	ENDS
PUBLIC	?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
; Function compile flags: /Odtp
;	COMDAT ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z
_TEXT	SEGMENT
_pU$21023 = -4						; size = 4
_p$ = 8							; size = 4
_encoding$ = 12						; size = 4
?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z PROC ; TiXmlBase::SkipWhiteSpace, COMDAT

; 315  : {

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

; 316  :     if ( !p || !*p )

  00004	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00008	74 0a		 je	 SHORT $LN17@SkipWhiteS
  0000a	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0000d	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  00010	85 c9		 test	 ecx, ecx
  00012	75 07		 jne	 SHORT $LN18@SkipWhiteS
$LN17@SkipWhiteS:

; 317  :     {
; 318  :         return 0;

  00014	33 c0		 xor	 eax, eax
  00016	e9 4e 01 00 00	 jmp	 $LN19@SkipWhiteS
$LN18@SkipWhiteS:

; 319  :     }
; 320  :     if ( encoding == TIXML_ENCODING_UTF8 )

  0001b	83 7d 0c 01	 cmp	 DWORD PTR _encoding$[ebp], 1
  0001f	0f 85 00 01 00
	00		 jne	 $LN4@SkipWhiteS
$LN15@SkipWhiteS:

; 321  :     {
; 322  :         while ( *p )

  00025	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00028	0f be 02	 movsx	 eax, BYTE PTR [edx]
  0002b	85 c0		 test	 eax, eax
  0002d	0f 84 f0 00 00
	00		 je	 $LN14@SkipWhiteS

; 323  :         {
; 324  :             const unsigned char* pU = (const unsigned char*)p;

  00033	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00036	89 4d fc	 mov	 DWORD PTR _pU$21023[ebp], ecx

; 325  : 
; 326  :             // Skip the stupid Microsoft UTF-8 Byte order marks
; 327  :             if (    *(pU+0)==TIXML_UTF_LEAD_0
; 328  :                  && *(pU+1)==TIXML_UTF_LEAD_1
; 329  :                  && *(pU+2)==TIXML_UTF_LEAD_2 )

  00039	8b 55 fc	 mov	 edx, DWORD PTR _pU$21023[ebp]
  0003c	0f b6 02	 movzx	 eax, BYTE PTR [edx]
  0003f	3d ef 00 00 00	 cmp	 eax, 239		; 000000efH
  00044	75 2b		 jne	 SHORT $LN13@SkipWhiteS
  00046	8b 4d fc	 mov	 ecx, DWORD PTR _pU$21023[ebp]
  00049	0f b6 51 01	 movzx	 edx, BYTE PTR [ecx+1]
  0004d	81 fa bb 00 00
	00		 cmp	 edx, 187		; 000000bbH
  00053	75 1c		 jne	 SHORT $LN13@SkipWhiteS
  00055	8b 45 fc	 mov	 eax, DWORD PTR _pU$21023[ebp]
  00058	0f b6 48 02	 movzx	 ecx, BYTE PTR [eax+2]
  0005c	81 f9 bf 00 00
	00		 cmp	 ecx, 191		; 000000bfH
  00062	75 0d		 jne	 SHORT $LN13@SkipWhiteS

; 330  :             {
; 331  :                 p += 3;

  00064	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00067	83 c2 03	 add	 edx, 3
  0006a	89 55 08	 mov	 DWORD PTR _p$[ebp], edx

; 332  :                 continue;

  0006d	eb b6		 jmp	 SHORT $LN15@SkipWhiteS

; 333  :             }
; 334  :             else if(*(pU+0)==TIXML_UTF_LEAD_0

  0006f	eb 74		 jmp	 SHORT $LN12@SkipWhiteS
$LN13@SkipWhiteS:

; 335  :                  && *(pU+1)==0xbfU
; 336  :                  && *(pU+2)==0xbeU )

  00071	8b 45 fc	 mov	 eax, DWORD PTR _pU$21023[ebp]
  00074	0f b6 08	 movzx	 ecx, BYTE PTR [eax]
  00077	81 f9 ef 00 00
	00		 cmp	 ecx, 239		; 000000efH
  0007d	75 2d		 jne	 SHORT $LN11@SkipWhiteS
  0007f	8b 55 fc	 mov	 edx, DWORD PTR _pU$21023[ebp]
  00082	0f b6 42 01	 movzx	 eax, BYTE PTR [edx+1]
  00086	3d bf 00 00 00	 cmp	 eax, 191		; 000000bfH
  0008b	75 1f		 jne	 SHORT $LN11@SkipWhiteS
  0008d	8b 4d fc	 mov	 ecx, DWORD PTR _pU$21023[ebp]
  00090	0f b6 51 02	 movzx	 edx, BYTE PTR [ecx+2]
  00094	81 fa be 00 00
	00		 cmp	 edx, 190		; 000000beH
  0009a	75 10		 jne	 SHORT $LN11@SkipWhiteS

; 337  :             {
; 338  :                 p += 3;

  0009c	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0009f	83 c0 03	 add	 eax, 3
  000a2	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 339  :                 continue;

  000a5	e9 7b ff ff ff	 jmp	 $LN15@SkipWhiteS

; 340  :             }
; 341  :             else if(*(pU+0)==TIXML_UTF_LEAD_0

  000aa	eb 39		 jmp	 SHORT $LN12@SkipWhiteS
$LN11@SkipWhiteS:

; 342  :                  && *(pU+1)==0xbfU
; 343  :                  && *(pU+2)==0xbfU )

  000ac	8b 4d fc	 mov	 ecx, DWORD PTR _pU$21023[ebp]
  000af	0f b6 11	 movzx	 edx, BYTE PTR [ecx]
  000b2	81 fa ef 00 00
	00		 cmp	 edx, 239		; 000000efH
  000b8	75 2b		 jne	 SHORT $LN12@SkipWhiteS
  000ba	8b 45 fc	 mov	 eax, DWORD PTR _pU$21023[ebp]
  000bd	0f b6 48 01	 movzx	 ecx, BYTE PTR [eax+1]
  000c1	81 f9 bf 00 00
	00		 cmp	 ecx, 191		; 000000bfH
  000c7	75 1c		 jne	 SHORT $LN12@SkipWhiteS
  000c9	8b 55 fc	 mov	 edx, DWORD PTR _pU$21023[ebp]
  000cc	0f b6 42 02	 movzx	 eax, BYTE PTR [edx+2]
  000d0	3d bf 00 00 00	 cmp	 eax, 191		; 000000bfH
  000d5	75 0e		 jne	 SHORT $LN12@SkipWhiteS

; 344  :             {
; 345  :                 p += 3;

  000d7	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  000da	83 c1 03	 add	 ecx, 3
  000dd	89 4d 08	 mov	 DWORD PTR _p$[ebp], ecx

; 346  :                 continue;

  000e0	e9 40 ff ff ff	 jmp	 $LN15@SkipWhiteS
$LN12@SkipWhiteS:

; 347  :             }
; 348  : 
; 349  :             if ( IsWhiteSpace( *p ) || *p == '\n' || *p =='\r' )        // Still using old rules for white space.

  000e5	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  000e8	0f b6 02	 movzx	 eax, BYTE PTR [edx]
  000eb	50		 push	 eax
  000ec	e8 00 00 00 00	 call	 ?IsWhiteSpace@TiXmlBase@@KA_ND@Z ; TiXmlBase::IsWhiteSpace
  000f1	83 c4 04	 add	 esp, 4
  000f4	0f b6 c8	 movzx	 ecx, al
  000f7	85 c9		 test	 ecx, ecx
  000f9	75 16		 jne	 SHORT $LN7@SkipWhiteS
  000fb	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  000fe	0f be 02	 movsx	 eax, BYTE PTR [edx]
  00101	83 f8 0a	 cmp	 eax, 10			; 0000000aH
  00104	74 0b		 je	 SHORT $LN7@SkipWhiteS
  00106	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00109	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  0010c	83 fa 0d	 cmp	 edx, 13			; 0000000dH
  0010f	75 0b		 jne	 SHORT $LN8@SkipWhiteS
$LN7@SkipWhiteS:

; 350  :                 ++p;

  00111	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00114	83 c0 01	 add	 eax, 1
  00117	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 351  :             else

  0011a	eb 02		 jmp	 SHORT $LN6@SkipWhiteS
$LN8@SkipWhiteS:

; 352  :                 break;

  0011c	eb 05		 jmp	 SHORT $LN14@SkipWhiteS
$LN6@SkipWhiteS:

; 353  :         }

  0011e	e9 02 ff ff ff	 jmp	 $LN15@SkipWhiteS
$LN14@SkipWhiteS:

; 354  :     }
; 355  :     else

  00123	eb 41		 jmp	 SHORT $LN5@SkipWhiteS
$LN4@SkipWhiteS:

; 356  :     {
; 357  :         while ( *p && IsWhiteSpace( *p ) || *p == '\n' || *p =='\r' )

  00125	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00128	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  0012b	85 d2		 test	 edx, edx
  0012d	74 16		 je	 SHORT $LN1@SkipWhiteS
  0012f	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00132	0f b6 08	 movzx	 ecx, BYTE PTR [eax]
  00135	51		 push	 ecx
  00136	e8 00 00 00 00	 call	 ?IsWhiteSpace@TiXmlBase@@KA_ND@Z ; TiXmlBase::IsWhiteSpace
  0013b	83 c4 04	 add	 esp, 4
  0013e	0f b6 d0	 movzx	 edx, al
  00141	85 d2		 test	 edx, edx
  00143	75 16		 jne	 SHORT $LN2@SkipWhiteS
$LN1@SkipWhiteS:
  00145	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00148	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  0014b	83 f9 0a	 cmp	 ecx, 10			; 0000000aH
  0014e	74 0b		 je	 SHORT $LN2@SkipWhiteS
  00150	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00153	0f be 02	 movsx	 eax, BYTE PTR [edx]
  00156	83 f8 0d	 cmp	 eax, 13			; 0000000dH
  00159	75 0b		 jne	 SHORT $LN5@SkipWhiteS
$LN2@SkipWhiteS:

; 358  :             ++p;

  0015b	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0015e	83 c1 01	 add	 ecx, 1
  00161	89 4d 08	 mov	 DWORD PTR _p$[ebp], ecx
  00164	eb bf		 jmp	 SHORT $LN4@SkipWhiteS
$LN5@SkipWhiteS:

; 359  :     }
; 360  : 
; 361  :     return p;

  00166	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
$LN19@SkipWhiteS:

; 362  : }

  00169	8b e5		 mov	 esp, ebp
  0016b	5d		 pop	 ebp
  0016c	c3		 ret	 0
?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ENDP ; TiXmlBase::SkipWhiteSpace
; Function compile flags: /Odtp
_TEXT	ENDS
;	COMDAT ??0TiXmlParsingData@@AAE@PBDHHH@Z
_TEXT	SEGMENT
_this$ = -4						; size = 4
_start$ = 8						; size = 4
__tabsize$ = 12						; size = 4
_row$ = 16						; size = 4
_col$ = 20						; size = 4
??0TiXmlParsingData@@AAE@PBDHHH@Z PROC			; TiXmlParsingData::TiXmlParsingData, COMDAT
; _this$ = ecx

; 181  :     TiXmlParsingData( const char* start, int _tabsize, int row, int col )

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
  00004	89 4d fc	 mov	 DWORD PTR _this$[ebp], ecx
  00007	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  0000a	e8 00 00 00 00	 call	 ??0TiXmlCursor@@QAE@XZ	; TiXmlCursor::TiXmlCursor

; 182  :     {
; 183  :         assert( start );
; 184  :         stamp = start;

  0000f	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  00012	8b 4d 08	 mov	 ecx, DWORD PTR _start$[ebp]
  00015	89 48 08	 mov	 DWORD PTR [eax+8], ecx

; 185  :         tabsize = _tabsize;

  00018	8b 55 fc	 mov	 edx, DWORD PTR _this$[ebp]
  0001b	8b 45 0c	 mov	 eax, DWORD PTR __tabsize$[ebp]
  0001e	89 42 0c	 mov	 DWORD PTR [edx+12], eax

; 186  :         cursor.row = row;

  00021	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  00024	8b 55 10	 mov	 edx, DWORD PTR _row$[ebp]
  00027	89 11		 mov	 DWORD PTR [ecx], edx

; 187  :         cursor.col = col;

  00029	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  0002c	8b 4d 14	 mov	 ecx, DWORD PTR _col$[ebp]
  0002f	89 48 04	 mov	 DWORD PTR [eax+4], ecx

; 188  :     }

  00032	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  00035	8b e5		 mov	 esp, ebp
  00037	5d		 pop	 ebp
  00038	c2 10 00	 ret	 16			; 00000010H
??0TiXmlParsingData@@AAE@PBDHHH@Z ENDP			; TiXmlParsingData::TiXmlParsingData
; Function compile flags: /Odtp
; File c:\develop\dscaler423a\dscaler\tinyxml.h
_TEXT	ENDS
;	COMDAT ?IsWhiteSpace@TiXmlBase@@KA_NH@Z
_TEXT	SEGMENT
_c$ = 8							; size = 4
?IsWhiteSpace@TiXmlBase@@KA_NH@Z PROC			; TiXmlBase::IsWhiteSpace, COMDAT

; 286  :     {

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

; 287  :         if ( c < 256 )

  00003	81 7d 08 00 01
	00 00		 cmp	 DWORD PTR _c$[ebp], 256	; 00000100H
  0000a	7d 0f		 jge	 SHORT $LN1@IsWhiteSpa@2

; 288  :             return IsWhiteSpace( (char) c );

  0000c	0f b6 45 08	 movzx	 eax, BYTE PTR _c$[ebp]
  00010	50		 push	 eax
  00011	e8 00 00 00 00	 call	 ?IsWhiteSpace@TiXmlBase@@KA_ND@Z ; TiXmlBase::IsWhiteSpace
  00016	83 c4 04	 add	 esp, 4
  00019	eb 02		 jmp	 SHORT $LN2@IsWhiteSpa@2
$LN1@IsWhiteSpa@2:

; 289  :         return false;    // Again, only truly correct for English/Latin...but usually works.

  0001b	32 c0		 xor	 al, al
$LN2@IsWhiteSpa@2:

; 290  :     }

  0001d	5d		 pop	 ebp
  0001e	c3		 ret	 0
?IsWhiteSpace@TiXmlBase@@KA_NH@Z ENDP			; TiXmlBase::IsWhiteSpace
_TEXT	ENDS
;	COMDAT xdata$x
xdata$x	SEGMENT
__unwindtable$??1sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ DD 0ffffffffH
	DD	FLAT:__unwindfunclet$??1sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ$0
__ehfuncinfo$??1sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ DD 019930522H
	DD	01H
	DD	FLAT:__unwindtable$??1sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ
	DD	2 DUP(00H)
	DD	2 DUP(00H)
	DD	00H
	DD	00H
; Function compile flags: /Odtp
xdata$x	ENDS
;	COMDAT ??1sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ
_TEXT	SEGMENT
_this$ = -16						; size = 4
__$EHRec$ = -12						; size = 12
??1sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ PROC ; std::basic_istream<char,std::char_traits<char> >::sentry::~sentry, COMDAT
; _this$ = ecx
  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	6a ff		 push	 -1
  00005	68 00 00 00 00	 push	 __ehhandler$??1sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ
  0000a	64 a1 00 00 00
	00		 mov	 eax, DWORD PTR fs:0
  00010	50		 push	 eax
  00011	51		 push	 ecx
  00012	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  00017	33 c5		 xor	 eax, ebp
  00019	50		 push	 eax
  0001a	8d 45 f4	 lea	 eax, DWORD PTR __$EHRec$[ebp]
  0001d	64 a3 00 00 00
	00		 mov	 DWORD PTR fs:0, eax
  00023	89 4d f0	 mov	 DWORD PTR _this$[ebp], ecx
  00026	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+8], 0
  0002d	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  00034	8b 4d f0	 mov	 ecx, DWORD PTR _this$[ebp]
  00037	e8 00 00 00 00	 call	 ??1_Sentry_base@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ ; std::basic_istream<char,std::char_traits<char> >::_Sentry_base::~_Sentry_base
  0003c	8b 4d f4	 mov	 ecx, DWORD PTR __$EHRec$[ebp]
  0003f	64 89 0d 00 00
	00 00		 mov	 DWORD PTR fs:0, ecx
  00046	59		 pop	 ecx
  00047	8b e5		 mov	 esp, ebp
  00049	5d		 pop	 ebp
  0004a	c3		 ret	 0
_TEXT	ENDS
;	COMDAT text$x
text$x	SEGMENT
__unwindfunclet$??1sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ$0:
  00000	8b 4d f0	 mov	 ecx, DWORD PTR _this$[ebp]
  00003	e9 00 00 00 00	 jmp	 ??1_Sentry_base@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ ; std::basic_istream<char,std::char_traits<char> >::_Sentry_base::~_Sentry_base
__ehhandler$??1sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ:
  00008	8b 54 24 08	 mov	 edx, DWORD PTR [esp+8]
  0000c	8d 42 0c	 lea	 eax, DWORD PTR [edx+12]
  0000f	8b 4a f8	 mov	 ecx, DWORD PTR [edx-8]
  00012	33 c8		 xor	 ecx, eax
  00014	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00019	b8 00 00 00 00	 mov	 eax, OFFSET __ehfuncinfo$??1sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ
  0001e	e9 00 00 00 00	 jmp	 ___CxxFrameHandler3
text$x	ENDS
??1sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ ENDP ; std::basic_istream<char,std::char_traits<char> >::sentry::~sentry
; Function compile flags: /Odtp
; File c:\program files (x86)\microsoft visual studio 9.0\vc\include\streambuf
;	COMDAT ?snextc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ
_TEXT	SEGMENT
tv82 = -20						; size = 4
tv83 = -16						; size = 4
_this$ = -12						; size = 4
$T319079 = -8						; size = 4
$T319078 = -4						; size = 4
?snextc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ PROC ; std::basic_streambuf<char,std::char_traits<char> >::snextc, COMDAT
; _this$ = ecx

; 130  : 		{	// point to next character and return it

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 14	 sub	 esp, 20			; 00000014H
  00006	89 4d f4	 mov	 DWORD PTR _this$[ebp], ecx

; 131  : 		return (1 < _Gnavail()
; 132  : 			? _Traits::to_int_type(*_Gnpreinc())
; 133  : 			: _Traits::eq_int_type(_Traits::eof(), sbumpc())
; 134  : 				? _Traits::eof() : sgetc());

  00009	8b 4d f4	 mov	 ecx, DWORD PTR _this$[ebp]
  0000c	e8 00 00 00 00	 call	 ?_Gnavail@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IBEHXZ ; std::basic_streambuf<char,std::char_traits<char> >::_Gnavail
  00011	83 f8 01	 cmp	 eax, 1
  00014	7e 16		 jle	 SHORT $LN5@snextc
  00016	8b 4d f4	 mov	 ecx, DWORD PTR _this$[ebp]
  00019	e8 00 00 00 00	 call	 ?_Gnpreinc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@IAEPADXZ ; std::basic_streambuf<char,std::char_traits<char> >::_Gnpreinc
  0001e	50		 push	 eax
  0001f	e8 00 00 00 00	 call	 ?to_int_type@?$char_traits@D@std@@SAHABD@Z ; std::char_traits<char>::to_int_type
  00024	83 c4 04	 add	 esp, 4
  00027	89 45 f0	 mov	 DWORD PTR tv83[ebp], eax
  0002a	eb 45		 jmp	 SHORT $LN6@snextc
$LN5@snextc:
  0002c	8b 4d f4	 mov	 ecx, DWORD PTR _this$[ebp]
  0002f	e8 00 00 00 00	 call	 ?sbumpc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_streambuf<char,std::char_traits<char> >::sbumpc
  00034	89 45 fc	 mov	 DWORD PTR $T319078[ebp], eax
  00037	e8 00 00 00 00	 call	 ?eof@?$char_traits@D@std@@SAHXZ ; std::char_traits<char>::eof
  0003c	89 45 f8	 mov	 DWORD PTR $T319079[ebp], eax
  0003f	8d 45 fc	 lea	 eax, DWORD PTR $T319078[ebp]
  00042	50		 push	 eax
  00043	8d 4d f8	 lea	 ecx, DWORD PTR $T319079[ebp]
  00046	51		 push	 ecx
  00047	e8 00 00 00 00	 call	 ?eq_int_type@?$char_traits@D@std@@SA_NABH0@Z ; std::char_traits<char>::eq_int_type
  0004c	83 c4 08	 add	 esp, 8
  0004f	0f b6 d0	 movzx	 edx, al
  00052	85 d2		 test	 edx, edx
  00054	74 0a		 je	 SHORT $LN3@snextc
  00056	e8 00 00 00 00	 call	 ?eof@?$char_traits@D@std@@SAHXZ ; std::char_traits<char>::eof
  0005b	89 45 ec	 mov	 DWORD PTR tv82[ebp], eax
  0005e	eb 0b		 jmp	 SHORT $LN4@snextc
$LN3@snextc:
  00060	8b 4d f4	 mov	 ecx, DWORD PTR _this$[ebp]
  00063	e8 00 00 00 00	 call	 ?sgetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_streambuf<char,std::char_traits<char> >::sgetc
  00068	89 45 ec	 mov	 DWORD PTR tv82[ebp], eax
$LN4@snextc:
  0006b	8b 45 ec	 mov	 eax, DWORD PTR tv82[ebp]
  0006e	89 45 f0	 mov	 DWORD PTR tv83[ebp], eax
$LN6@snextc:
  00071	8b 45 f0	 mov	 eax, DWORD PTR tv83[ebp]

; 135  : 		}

  00074	8b e5		 mov	 esp, ebp
  00076	5d		 pop	 ebp
  00077	c3		 ret	 0
?snextc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ ENDP ; std::basic_streambuf<char,std::char_traits<char> >::snextc
_TEXT	ENDS
PUBLIC	?Blank@TiXmlText@@IBE_NXZ			; TiXmlText::Blank
; Function compile flags: /Odtp
; File c:\develop\dscaler423a\dscaler\tinyxmlparser.cpp
;	COMDAT ?Blank@TiXmlText@@IBE_NXZ
_TEXT	SEGMENT
_this$ = -8						; size = 4
_i$21738 = -4						; size = 4
?Blank@TiXmlText@@IBE_NXZ PROC				; TiXmlText::Blank, COMDAT
; _this$ = ecx

; 1600 : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 08	 sub	 esp, 8
  00006	89 4d f8	 mov	 DWORD PTR _this$[ebp], ecx

; 1601 :     for ( unsigned i=0; i<value.length(); i++ )

  00009	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR _i$21738[ebp], 0
  00010	eb 09		 jmp	 SHORT $LN4@Blank
$LN3@Blank:
  00012	8b 45 fc	 mov	 eax, DWORD PTR _i$21738[ebp]
  00015	83 c0 01	 add	 eax, 1
  00018	89 45 fc	 mov	 DWORD PTR _i$21738[ebp], eax
$LN4@Blank:
  0001b	8b 4d f8	 mov	 ecx, DWORD PTR _this$[ebp]
  0001e	83 c1 20	 add	 ecx, 32			; 00000020H
  00021	e8 00 00 00 00	 call	 ?length@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEIXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::length
  00026	39 45 fc	 cmp	 DWORD PTR _i$21738[ebp], eax
  00029	73 28		 jae	 SHORT $LN2@Blank

; 1602 :         if ( !IsWhiteSpace( value[i] ) )

  0002b	8b 4d fc	 mov	 ecx, DWORD PTR _i$21738[ebp]
  0002e	51		 push	 ecx
  0002f	8b 4d f8	 mov	 ecx, DWORD PTR _this$[ebp]
  00032	83 c1 20	 add	 ecx, 32			; 00000020H
  00035	e8 00 00 00 00	 call	 ??A?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEABDI@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator[]
  0003a	0f b6 10	 movzx	 edx, BYTE PTR [eax]
  0003d	52		 push	 edx
  0003e	e8 00 00 00 00	 call	 ?IsWhiteSpace@TiXmlBase@@KA_ND@Z ; TiXmlBase::IsWhiteSpace
  00043	83 c4 04	 add	 esp, 4
  00046	0f b6 c0	 movzx	 eax, al
  00049	85 c0		 test	 eax, eax
  0004b	75 04		 jne	 SHORT $LN1@Blank

; 1603 :             return false;

  0004d	32 c0		 xor	 al, al
  0004f	eb 04		 jmp	 SHORT $LN5@Blank
$LN1@Blank:

; 1604 :     return true;

  00051	eb bf		 jmp	 SHORT $LN3@Blank
$LN2@Blank:
  00053	b0 01		 mov	 al, 1
$LN5@Blank:

; 1605 : }

  00055	8b e5		 mov	 esp, ebp
  00057	5d		 pop	 ebp
  00058	c3		 ret	 0
?Blank@TiXmlText@@IBE_NXZ ENDP				; TiXmlText::Blank
; Function compile flags: /Odtp
; File c:\develop\dscaler423a\dscaler\tinyxml.h
_TEXT	ENDS
;	COMDAT ?Encoding@TiXmlDeclaration@@QBEPBDXZ
_TEXT	SEGMENT
_this$ = -4						; size = 4
?Encoding@TiXmlDeclaration@@QBEPBDXZ PROC		; TiXmlDeclaration::Encoding, COMDAT
; _this$ = ecx

; 1277 :     const char *Encoding() const        { return encoding.c_str (); }

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
  00004	89 4d fc	 mov	 DWORD PTR _this$[ebp], ecx
  00007	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  0000a	83 c1 60	 add	 ecx, 96			; 00000060H
  0000d	e8 00 00 00 00	 call	 ?c_str@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEPBDXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::c_str
  00012	8b e5		 mov	 esp, ebp
  00014	5d		 pop	 ebp
  00015	c3		 ret	 0
?Encoding@TiXmlDeclaration@@QBEPBDXZ ENDP		; TiXmlDeclaration::Encoding
PUBLIC	__$ArrayPad$
PUBLIC	?GetEntity@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z ; TiXmlBase::GetEntity
;	COMDAT xdata$x
; File c:\develop\dscaler423a\dscaler\tinyxmlparser.cpp
xdata$x	SEGMENT
__unwindtable$?GetEntity@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z DD 0ffffffffH
	DD	FLAT:__unwindfunclet$?GetEntity@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z$0
__ehfuncinfo$?GetEntity@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z DD 019930522H
	DD	01H
	DD	FLAT:__unwindtable$?GetEntity@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z
	DD	2 DUP(00H)
	DD	2 DUP(00H)
	DD	00H
	DD	00H
; Function compile flags: /Odtp
xdata$x	ENDS
;	COMDAT ?GetEntity@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z
_TEXT	SEGMENT
$T326319 = -104						; size = 4
$T326318 = -100						; size = 4
$T326317 = -96						; size = 4
$T326316 = -92						; size = 4
$T326315 = -88						; size = 4
$T326314 = -84						; size = 4
$T326313 = -80						; size = 4
$T326312 = -76						; size = 4
$T326311 = -72						; size = 4
_q$21201 = -68						; size = 4
_q$21184 = -64						; size = 4
_mult$21180 = -60					; size = 4
_ucs$21178 = -56					; size = 4
_delta$21179 = -52					; size = 4
_ent$ = -48						; size = 28
__$ArrayPad$ = -20					; size = 4
_i$ = -16						; size = 4
__$EHRec$ = -12						; size = 12
_p$ = 8							; size = 4
_value$ = 12						; size = 4
_length$ = 16						; size = 4
_encoding$ = 20						; size = 4
?GetEntity@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z PROC ; TiXmlBase::GetEntity, COMDAT

; 439  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	6a ff		 push	 -1
  00005	68 00 00 00 00	 push	 __ehhandler$?GetEntity@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z
  0000a	64 a1 00 00 00
	00		 mov	 eax, DWORD PTR fs:0
  00010	50		 push	 eax
  00011	83 ec 5c	 sub	 esp, 92			; 0000005cH
  00014	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  00019	33 c5		 xor	 eax, ebp
  0001b	89 45 ec	 mov	 DWORD PTR __$ArrayPad$[ebp], eax
  0001e	50		 push	 eax
  0001f	8d 45 f4	 lea	 eax, DWORD PTR __$EHRec$[ebp]
  00022	64 a3 00 00 00
	00		 mov	 DWORD PTR fs:0, eax

; 440  :     // Presume an entity, and pull it out.
; 441  :     TIXML_STRING ent;

  00028	8d 4d d0	 lea	 ecx, DWORD PTR _ent$[ebp]
  0002b	e8 00 00 00 00	 call	 ??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::basic_string<char,std::char_traits<char>,std::allocator<char> >
  00030	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+8], 0

; 442  :     int i;
; 443  :     *length = 0;

  00037	8b 45 10	 mov	 eax, DWORD PTR _length$[ebp]
  0003a	c7 00 00 00 00
	00		 mov	 DWORD PTR [eax], 0

; 444  : 
; 445  :     if ( *(p+1) && *(p+1) == '#' && *(p+2) )

  00040	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00043	0f be 51 01	 movsx	 edx, BYTE PTR [ecx+1]
  00047	85 d2		 test	 edx, edx
  00049	0f 84 cd 02 00
	00		 je	 $LN27@GetEntity
  0004f	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00052	0f be 48 01	 movsx	 ecx, BYTE PTR [eax+1]
  00056	83 f9 23	 cmp	 ecx, 35			; 00000023H
  00059	0f 85 bd 02 00
	00		 jne	 $LN27@GetEntity
  0005f	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00062	0f be 42 02	 movsx	 eax, BYTE PTR [edx+2]
  00066	85 c0		 test	 eax, eax
  00068	0f 84 ae 02 00
	00		 je	 $LN27@GetEntity

; 446  :     {
; 447  :         unsigned long ucs = 0;

  0006e	c7 45 c8 00 00
	00 00		 mov	 DWORD PTR _ucs$21178[ebp], 0

; 448  :         ptrdiff_t delta = 0;

  00075	c7 45 cc 00 00
	00 00		 mov	 DWORD PTR _delta$21179[ebp], 0

; 449  :         unsigned mult = 1;

  0007c	c7 45 c4 01 00
	00 00		 mov	 DWORD PTR _mult$21180[ebp], 1

; 450  : 
; 451  :         if ( *(p+2) == 'x' )

  00083	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00086	0f be 51 02	 movsx	 edx, BYTE PTR [ecx+2]
  0008a	83 fa 78	 cmp	 edx, 120		; 00000078H
  0008d	0f 85 4d 01 00
	00		 jne	 $LN26@GetEntity

; 452  :         {
; 453  :             // Hexadecimal.
; 454  :             if ( !*(p+3) ) return 0;

  00093	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00096	0f be 48 03	 movsx	 ecx, BYTE PTR [eax+3]
  0009a	85 c9		 test	 ecx, ecx
  0009c	75 1e		 jne	 SHORT $LN25@GetEntity
  0009e	c7 45 b8 00 00
	00 00		 mov	 DWORD PTR $T326311[ebp], 0
  000a5	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  000ac	8d 4d d0	 lea	 ecx, DWORD PTR _ent$[ebp]
  000af	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  000b4	8b 45 b8	 mov	 eax, DWORD PTR $T326311[ebp]
  000b7	e9 09 03 00 00	 jmp	 $LN28@GetEntity
$LN25@GetEntity:

; 455  : 
; 456  :             const char* q = p+3;

  000bc	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  000bf	83 c2 03	 add	 edx, 3
  000c2	89 55 c0	 mov	 DWORD PTR _q$21184[ebp], edx

; 457  :             q = strchr( q, ';' );

  000c5	6a 3b		 push	 59			; 0000003bH
  000c7	8b 45 c0	 mov	 eax, DWORD PTR _q$21184[ebp]
  000ca	50		 push	 eax
  000cb	e8 00 00 00 00	 call	 _strchr
  000d0	83 c4 08	 add	 esp, 8
  000d3	89 45 c0	 mov	 DWORD PTR _q$21184[ebp], eax

; 458  : 
; 459  :             if ( !q || !*q ) return 0;

  000d6	83 7d c0 00	 cmp	 DWORD PTR _q$21184[ebp], 0
  000da	74 0a		 je	 SHORT $LN23@GetEntity
  000dc	8b 4d c0	 mov	 ecx, DWORD PTR _q$21184[ebp]
  000df	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  000e2	85 d2		 test	 edx, edx
  000e4	75 1e		 jne	 SHORT $LN24@GetEntity
$LN23@GetEntity:
  000e6	c7 45 b4 00 00
	00 00		 mov	 DWORD PTR $T326312[ebp], 0
  000ed	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  000f4	8d 4d d0	 lea	 ecx, DWORD PTR _ent$[ebp]
  000f7	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  000fc	8b 45 b4	 mov	 eax, DWORD PTR $T326312[ebp]
  000ff	e9 c1 02 00 00	 jmp	 $LN28@GetEntity
$LN24@GetEntity:

; 460  : 
; 461  :             delta = q-p;

  00104	8b 45 c0	 mov	 eax, DWORD PTR _q$21184[ebp]
  00107	2b 45 08	 sub	 eax, DWORD PTR _p$[ebp]
  0010a	89 45 cc	 mov	 DWORD PTR _delta$21179[ebp], eax

; 462  :             --q;

  0010d	8b 4d c0	 mov	 ecx, DWORD PTR _q$21184[ebp]
  00110	83 e9 01	 sub	 ecx, 1
  00113	89 4d c0	 mov	 DWORD PTR _q$21184[ebp], ecx
$LN22@GetEntity:

; 463  : 
; 464  :             while ( *q != 'x' )

  00116	8b 55 c0	 mov	 edx, DWORD PTR _q$21184[ebp]
  00119	0f be 02	 movsx	 eax, BYTE PTR [edx]
  0011c	83 f8 78	 cmp	 eax, 120		; 00000078H
  0011f	0f 84 b6 00 00
	00		 je	 $LN21@GetEntity

; 465  :             {
; 466  :                 if ( *q >= '0' && *q <= '9' )

  00125	8b 4d c0	 mov	 ecx, DWORD PTR _q$21184[ebp]
  00128	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  0012b	83 fa 30	 cmp	 edx, 48			; 00000030H
  0012e	7c 20		 jl	 SHORT $LN20@GetEntity
  00130	8b 45 c0	 mov	 eax, DWORD PTR _q$21184[ebp]
  00133	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  00136	83 f9 39	 cmp	 ecx, 57			; 00000039H
  00139	7f 15		 jg	 SHORT $LN20@GetEntity

; 467  :                     ucs += mult * (*q - '0');

  0013b	8b 55 c0	 mov	 edx, DWORD PTR _q$21184[ebp]
  0013e	0f be 02	 movsx	 eax, BYTE PTR [edx]
  00141	83 e8 30	 sub	 eax, 48			; 00000030H
  00144	0f af 45 c4	 imul	 eax, DWORD PTR _mult$21180[ebp]
  00148	03 45 c8	 add	 eax, DWORD PTR _ucs$21178[ebp]
  0014b	89 45 c8	 mov	 DWORD PTR _ucs$21178[ebp], eax
  0014e	eb 74		 jmp	 SHORT $LN19@GetEntity
$LN20@GetEntity:

; 468  :                 else if ( *q >= 'a' && *q <= 'f' )

  00150	8b 4d c0	 mov	 ecx, DWORD PTR _q$21184[ebp]
  00153	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  00156	83 fa 61	 cmp	 edx, 97			; 00000061H
  00159	7c 20		 jl	 SHORT $LN18@GetEntity
  0015b	8b 45 c0	 mov	 eax, DWORD PTR _q$21184[ebp]
  0015e	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  00161	83 f9 66	 cmp	 ecx, 102		; 00000066H
  00164	7f 15		 jg	 SHORT $LN18@GetEntity

; 469  :                     ucs += mult * (*q - 'a' + 10);

  00166	8b 55 c0	 mov	 edx, DWORD PTR _q$21184[ebp]
  00169	0f be 02	 movsx	 eax, BYTE PTR [edx]
  0016c	83 e8 57	 sub	 eax, 87			; 00000057H
  0016f	0f af 45 c4	 imul	 eax, DWORD PTR _mult$21180[ebp]
  00173	03 45 c8	 add	 eax, DWORD PTR _ucs$21178[ebp]
  00176	89 45 c8	 mov	 DWORD PTR _ucs$21178[ebp], eax
  00179	eb 49		 jmp	 SHORT $LN19@GetEntity
$LN18@GetEntity:

; 470  :                 else if ( *q >= 'A' && *q <= 'F' )

  0017b	8b 4d c0	 mov	 ecx, DWORD PTR _q$21184[ebp]
  0017e	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  00181	83 fa 41	 cmp	 edx, 65			; 00000041H
  00184	7c 20		 jl	 SHORT $LN16@GetEntity
  00186	8b 45 c0	 mov	 eax, DWORD PTR _q$21184[ebp]
  00189	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  0018c	83 f9 46	 cmp	 ecx, 70			; 00000046H
  0018f	7f 15		 jg	 SHORT $LN16@GetEntity

; 471  :                     ucs += mult * (*q - 'A' + 10 );

  00191	8b 55 c0	 mov	 edx, DWORD PTR _q$21184[ebp]
  00194	0f be 02	 movsx	 eax, BYTE PTR [edx]
  00197	83 e8 37	 sub	 eax, 55			; 00000037H
  0019a	0f af 45 c4	 imul	 eax, DWORD PTR _mult$21180[ebp]
  0019e	03 45 c8	 add	 eax, DWORD PTR _ucs$21178[ebp]
  001a1	89 45 c8	 mov	 DWORD PTR _ucs$21178[ebp], eax

; 472  :                 else

  001a4	eb 1e		 jmp	 SHORT $LN19@GetEntity
$LN16@GetEntity:

; 473  :                     return 0;

  001a6	c7 45 b0 00 00
	00 00		 mov	 DWORD PTR $T326313[ebp], 0
  001ad	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  001b4	8d 4d d0	 lea	 ecx, DWORD PTR _ent$[ebp]
  001b7	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  001bc	8b 45 b0	 mov	 eax, DWORD PTR $T326313[ebp]
  001bf	e9 01 02 00 00	 jmp	 $LN28@GetEntity
$LN19@GetEntity:

; 474  :                 mult *= 16;

  001c4	8b 4d c4	 mov	 ecx, DWORD PTR _mult$21180[ebp]
  001c7	c1 e1 04	 shl	 ecx, 4
  001ca	89 4d c4	 mov	 DWORD PTR _mult$21180[ebp], ecx

; 475  :                 --q;

  001cd	8b 55 c0	 mov	 edx, DWORD PTR _q$21184[ebp]
  001d0	83 ea 01	 sub	 edx, 1
  001d3	89 55 c0	 mov	 DWORD PTR _q$21184[ebp], edx

; 476  :             }

  001d6	e9 3b ff ff ff	 jmp	 $LN22@GetEntity
$LN21@GetEntity:

; 477  :         }
; 478  :         else

  001db	e9 eb 00 00 00	 jmp	 $LN14@GetEntity
$LN26@GetEntity:

; 479  :         {
; 480  :             // Decimal.
; 481  :             if ( !*(p+2) ) return 0;

  001e0	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  001e3	0f be 48 02	 movsx	 ecx, BYTE PTR [eax+2]
  001e7	85 c9		 test	 ecx, ecx
  001e9	75 1e		 jne	 SHORT $LN13@GetEntity
  001eb	c7 45 ac 00 00
	00 00		 mov	 DWORD PTR $T326314[ebp], 0
  001f2	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  001f9	8d 4d d0	 lea	 ecx, DWORD PTR _ent$[ebp]
  001fc	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  00201	8b 45 ac	 mov	 eax, DWORD PTR $T326314[ebp]
  00204	e9 bc 01 00 00	 jmp	 $LN28@GetEntity
$LN13@GetEntity:

; 482  : 
; 483  :             const char* q = p+2;

  00209	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0020c	83 c2 02	 add	 edx, 2
  0020f	89 55 bc	 mov	 DWORD PTR _q$21201[ebp], edx

; 484  :             q = strchr( q, ';' );

  00212	6a 3b		 push	 59			; 0000003bH
  00214	8b 45 bc	 mov	 eax, DWORD PTR _q$21201[ebp]
  00217	50		 push	 eax
  00218	e8 00 00 00 00	 call	 _strchr
  0021d	83 c4 08	 add	 esp, 8
  00220	89 45 bc	 mov	 DWORD PTR _q$21201[ebp], eax

; 485  : 
; 486  :             if ( !q || !*q ) return 0;

  00223	83 7d bc 00	 cmp	 DWORD PTR _q$21201[ebp], 0
  00227	74 0a		 je	 SHORT $LN11@GetEntity
  00229	8b 4d bc	 mov	 ecx, DWORD PTR _q$21201[ebp]
  0022c	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  0022f	85 d2		 test	 edx, edx
  00231	75 1e		 jne	 SHORT $LN12@GetEntity
$LN11@GetEntity:
  00233	c7 45 a8 00 00
	00 00		 mov	 DWORD PTR $T326315[ebp], 0
  0023a	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  00241	8d 4d d0	 lea	 ecx, DWORD PTR _ent$[ebp]
  00244	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  00249	8b 45 a8	 mov	 eax, DWORD PTR $T326315[ebp]
  0024c	e9 74 01 00 00	 jmp	 $LN28@GetEntity
$LN12@GetEntity:

; 487  : 
; 488  :             delta = q-p;

  00251	8b 45 bc	 mov	 eax, DWORD PTR _q$21201[ebp]
  00254	2b 45 08	 sub	 eax, DWORD PTR _p$[ebp]
  00257	89 45 cc	 mov	 DWORD PTR _delta$21179[ebp], eax

; 489  :             --q;

  0025a	8b 4d bc	 mov	 ecx, DWORD PTR _q$21201[ebp]
  0025d	83 e9 01	 sub	 ecx, 1
  00260	89 4d bc	 mov	 DWORD PTR _q$21201[ebp], ecx
$LN10@GetEntity:

; 490  : 
; 491  :             while ( *q != '#' )

  00263	8b 55 bc	 mov	 edx, DWORD PTR _q$21201[ebp]
  00266	0f be 02	 movsx	 eax, BYTE PTR [edx]
  00269	83 f8 23	 cmp	 eax, 35			; 00000023H
  0026c	74 5d		 je	 SHORT $LN14@GetEntity

; 492  :             {
; 493  :                 if ( *q >= '0' && *q <= '9' )

  0026e	8b 4d bc	 mov	 ecx, DWORD PTR _q$21201[ebp]
  00271	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  00274	83 fa 30	 cmp	 edx, 48			; 00000030H
  00277	7c 20		 jl	 SHORT $LN8@GetEntity
  00279	8b 45 bc	 mov	 eax, DWORD PTR _q$21201[ebp]
  0027c	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  0027f	83 f9 39	 cmp	 ecx, 57			; 00000039H
  00282	7f 15		 jg	 SHORT $LN8@GetEntity

; 494  :                     ucs += mult * (*q - '0');

  00284	8b 55 bc	 mov	 edx, DWORD PTR _q$21201[ebp]
  00287	0f be 02	 movsx	 eax, BYTE PTR [edx]
  0028a	83 e8 30	 sub	 eax, 48			; 00000030H
  0028d	0f af 45 c4	 imul	 eax, DWORD PTR _mult$21180[ebp]
  00291	03 45 c8	 add	 eax, DWORD PTR _ucs$21178[ebp]
  00294	89 45 c8	 mov	 DWORD PTR _ucs$21178[ebp], eax

; 495  :                 else

  00297	eb 1e		 jmp	 SHORT $LN7@GetEntity
$LN8@GetEntity:

; 496  :                     return 0;

  00299	c7 45 a4 00 00
	00 00		 mov	 DWORD PTR $T326316[ebp], 0
  002a0	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  002a7	8d 4d d0	 lea	 ecx, DWORD PTR _ent$[ebp]
  002aa	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  002af	8b 45 a4	 mov	 eax, DWORD PTR $T326316[ebp]
  002b2	e9 0e 01 00 00	 jmp	 $LN28@GetEntity
$LN7@GetEntity:

; 497  :                 mult *= 10;

  002b7	8b 4d c4	 mov	 ecx, DWORD PTR _mult$21180[ebp]
  002ba	6b c9 0a	 imul	 ecx, 10			; 0000000aH
  002bd	89 4d c4	 mov	 DWORD PTR _mult$21180[ebp], ecx

; 498  :                 --q;

  002c0	8b 55 bc	 mov	 edx, DWORD PTR _q$21201[ebp]
  002c3	83 ea 01	 sub	 edx, 1
  002c6	89 55 bc	 mov	 DWORD PTR _q$21201[ebp], edx

; 499  :             }

  002c9	eb 98		 jmp	 SHORT $LN10@GetEntity
$LN14@GetEntity:

; 500  :         }
; 501  :         if ( encoding == TIXML_ENCODING_UTF8 )

  002cb	83 7d 14 01	 cmp	 DWORD PTR _encoding$[ebp], 1
  002cf	75 16		 jne	 SHORT $LN6@GetEntity

; 502  :         {
; 503  :             // convert the UCS to UTF-8
; 504  :             ConvertUTF32ToUTF8( ucs, value, length );

  002d1	8b 45 10	 mov	 eax, DWORD PTR _length$[ebp]
  002d4	50		 push	 eax
  002d5	8b 4d 0c	 mov	 ecx, DWORD PTR _value$[ebp]
  002d8	51		 push	 ecx
  002d9	8b 55 c8	 mov	 edx, DWORD PTR _ucs$21178[ebp]
  002dc	52		 push	 edx
  002dd	e8 00 00 00 00	 call	 ?ConvertUTF32ToUTF8@TiXmlBase@@KAXKPADPAH@Z ; TiXmlBase::ConvertUTF32ToUTF8
  002e2	83 c4 0c	 add	 esp, 12			; 0000000cH

; 505  :         }
; 506  :         else

  002e5	eb 11		 jmp	 SHORT $LN5@GetEntity
$LN6@GetEntity:

; 507  :         {
; 508  :             *value = (char)ucs;

  002e7	8b 45 0c	 mov	 eax, DWORD PTR _value$[ebp]
  002ea	8a 4d c8	 mov	 cl, BYTE PTR _ucs$21178[ebp]
  002ed	88 08		 mov	 BYTE PTR [eax], cl

; 509  :             *length = 1;

  002ef	8b 55 10	 mov	 edx, DWORD PTR _length$[ebp]
  002f2	c7 02 01 00 00
	00		 mov	 DWORD PTR [edx], 1
$LN5@GetEntity:

; 510  :         }
; 511  :         return p + delta + 1;

  002f8	8b 45 cc	 mov	 eax, DWORD PTR _delta$21179[ebp]
  002fb	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  002fe	8d 54 01 01	 lea	 edx, DWORD PTR [ecx+eax+1]
  00302	89 55 a0	 mov	 DWORD PTR $T326317[ebp], edx
  00305	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  0030c	8d 4d d0	 lea	 ecx, DWORD PTR _ent$[ebp]
  0030f	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  00314	8b 45 a0	 mov	 eax, DWORD PTR $T326317[ebp]
  00317	e9 a9 00 00 00	 jmp	 $LN28@GetEntity
$LN27@GetEntity:

; 512  :     }
; 513  : 
; 514  :     // Now try to match it.
; 515  :     for( i=0; i<NUM_ENTITY; ++i )

  0031c	c7 45 f0 00 00
	00 00		 mov	 DWORD PTR _i$[ebp], 0
  00323	eb 09		 jmp	 SHORT $LN4@GetEntity
$LN3@GetEntity:
  00325	8b 45 f0	 mov	 eax, DWORD PTR _i$[ebp]
  00328	83 c0 01	 add	 eax, 1
  0032b	89 45 f0	 mov	 DWORD PTR _i$[ebp], eax
$LN4@GetEntity:
  0032e	83 7d f0 05	 cmp	 DWORD PTR _i$[ebp], 5
  00332	7d 6c		 jge	 SHORT $LN2@GetEntity

; 516  :     {
; 517  :         if ( strncmp( entity[i].str, p, entity[i].strLength ) == 0 )

  00334	8b 4d f0	 mov	 ecx, DWORD PTR _i$[ebp]
  00337	6b c9 0c	 imul	 ecx, 12			; 0000000cH
  0033a	8b 91 04 00 00
	00		 mov	 edx, DWORD PTR ?entity@TiXmlBase@@0PAUEntity@1@A[ecx+4]
  00340	52		 push	 edx
  00341	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00344	50		 push	 eax
  00345	8b 4d f0	 mov	 ecx, DWORD PTR _i$[ebp]
  00348	6b c9 0c	 imul	 ecx, 12			; 0000000cH
  0034b	8b 91 00 00 00
	00		 mov	 edx, DWORD PTR ?entity@TiXmlBase@@0PAUEntity@1@A[ecx]
  00351	52		 push	 edx
  00352	e8 00 00 00 00	 call	 _strncmp
  00357	83 c4 0c	 add	 esp, 12			; 0000000cH
  0035a	85 c0		 test	 eax, eax
  0035c	75 40		 jne	 SHORT $LN1@GetEntity

; 518  :         {
; 519  :             assert( strlen( entity[i].str ) == entity[i].strLength );
; 520  :             *value = entity[i].chr;

  0035e	8b 45 f0	 mov	 eax, DWORD PTR _i$[ebp]
  00361	6b c0 0c	 imul	 eax, 12			; 0000000cH
  00364	8b 4d 0c	 mov	 ecx, DWORD PTR _value$[ebp]
  00367	8a 90 08 00 00
	00		 mov	 dl, BYTE PTR ?entity@TiXmlBase@@0PAUEntity@1@A[eax+8]
  0036d	88 11		 mov	 BYTE PTR [ecx], dl

; 521  :             *length = 1;

  0036f	8b 45 10	 mov	 eax, DWORD PTR _length$[ebp]
  00372	c7 00 01 00 00
	00		 mov	 DWORD PTR [eax], 1

; 522  :             return ( p + entity[i].strLength );

  00378	8b 4d f0	 mov	 ecx, DWORD PTR _i$[ebp]
  0037b	6b c9 0c	 imul	 ecx, 12			; 0000000cH
  0037e	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00381	03 91 04 00 00
	00		 add	 edx, DWORD PTR ?entity@TiXmlBase@@0PAUEntity@1@A[ecx+4]
  00387	89 55 9c	 mov	 DWORD PTR $T326318[ebp], edx
  0038a	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  00391	8d 4d d0	 lea	 ecx, DWORD PTR _ent$[ebp]
  00394	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  00399	8b 45 9c	 mov	 eax, DWORD PTR $T326318[ebp]
  0039c	eb 27		 jmp	 SHORT $LN28@GetEntity
$LN1@GetEntity:

; 523  :         }
; 524  :     }

  0039e	eb 85		 jmp	 SHORT $LN3@GetEntity
$LN2@GetEntity:

; 525  : 
; 526  :     // So it wasn't an entity, its unrecognized, or something like that.
; 527  :     *value = *p;    // Don't put back the last one, since we return it!

  003a0	8b 45 0c	 mov	 eax, DWORD PTR _value$[ebp]
  003a3	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  003a6	8a 11		 mov	 dl, BYTE PTR [ecx]
  003a8	88 10		 mov	 BYTE PTR [eax], dl

; 528  :     //*length = 1;    // Leave unrecognized entities - this doesn't really work.
; 529  :                     // Just writes strange XML.
; 530  :     return p+1;

  003aa	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  003ad	83 c0 01	 add	 eax, 1
  003b0	89 45 98	 mov	 DWORD PTR $T326319[ebp], eax
  003b3	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  003ba	8d 4d d0	 lea	 ecx, DWORD PTR _ent$[ebp]
  003bd	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  003c2	8b 45 98	 mov	 eax, DWORD PTR $T326319[ebp]
$LN28@GetEntity:

; 531  : }

  003c5	8b 4d f4	 mov	 ecx, DWORD PTR __$EHRec$[ebp]
  003c8	64 89 0d 00 00
	00 00		 mov	 DWORD PTR fs:0, ecx
  003cf	59		 pop	 ecx
  003d0	8b 4d ec	 mov	 ecx, DWORD PTR __$ArrayPad$[ebp]
  003d3	33 cd		 xor	 ecx, ebp
  003d5	e8 00 00 00 00	 call	 @__security_check_cookie@4
  003da	8b e5		 mov	 esp, ebp
  003dc	5d		 pop	 ebp
  003dd	c3		 ret	 0
_TEXT	ENDS
;	COMDAT text$x
text$x	SEGMENT
__unwindfunclet$?GetEntity@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z$0:
  00000	8d 4d d0	 lea	 ecx, DWORD PTR _ent$[ebp]
  00003	e9 00 00 00 00	 jmp	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
__ehhandler$?GetEntity@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z:
  00008	8b 54 24 08	 mov	 edx, DWORD PTR [esp+8]
  0000c	8d 42 0c	 lea	 eax, DWORD PTR [edx+12]
  0000f	8b 4a a0	 mov	 ecx, DWORD PTR [edx-96]
  00012	33 c8		 xor	 ecx, eax
  00014	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00019	8b 4a f8	 mov	 ecx, DWORD PTR [edx-8]
  0001c	33 c8		 xor	 ecx, eax
  0001e	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00023	b8 00 00 00 00	 mov	 eax, OFFSET __ehfuncinfo$?GetEntity@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z
  00028	e9 00 00 00 00	 jmp	 ___CxxFrameHandler3
text$x	ENDS
?GetEntity@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z ENDP ; TiXmlBase::GetEntity
; Function compile flags: /Odtp
; File c:\develop\dscaler423a\dscaler\tinyxml.h
;	COMDAT ?GetChar@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z
_TEXT	SEGMENT
_i$19780 = -4						; size = 4
_p$ = 8							; size = 4
__value$ = 12						; size = 4
_length$ = 16						; size = 4
_encoding$ = 20						; size = 4
?GetChar@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z PROC ; TiXmlBase::GetChar, COMDAT

; 319  :     {

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

; 320  :         assert( p );
; 321  :         if ( encoding == TIXML_ENCODING_UTF8 )

  00004	83 7d 14 01	 cmp	 DWORD PTR _encoding$[ebp], 1
  00008	75 14		 jne	 SHORT $LN10@GetChar

; 322  :         {
; 323  :             *length = utf8ByteTable[ *((const unsigned char*)p) ];

  0000a	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0000d	0f b6 08	 movzx	 ecx, BYTE PTR [eax]
  00010	8b 55 10	 mov	 edx, DWORD PTR _length$[ebp]
  00013	8b 04 8d 00 00
	00 00		 mov	 eax, DWORD PTR ?utf8ByteTable@TiXmlBase@@2QBHB[ecx*4]
  0001a	89 02		 mov	 DWORD PTR [edx], eax

; 324  :             assert( *length >= 0 && *length < 5 );
; 325  :         }
; 326  :         else

  0001c	eb 09		 jmp	 SHORT $LN9@GetChar
$LN10@GetChar:

; 327  :         {
; 328  :             *length = 1;

  0001e	8b 4d 10	 mov	 ecx, DWORD PTR _length$[ebp]
  00021	c7 01 01 00 00
	00		 mov	 DWORD PTR [ecx], 1
$LN9@GetChar:

; 329  :         }
; 330  : 
; 331  :         if ( *length == 1 )

  00027	8b 55 10	 mov	 edx, DWORD PTR _length$[ebp]
  0002a	83 3a 01	 cmp	 DWORD PTR [edx], 1
  0002d	75 39		 jne	 SHORT $LN8@GetChar

; 332  :         {
; 333  :             if ( *p == '&' )

  0002f	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00032	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  00035	83 f9 26	 cmp	 ecx, 38			; 00000026H
  00038	75 1a		 jne	 SHORT $LN7@GetChar

; 334  :                 return GetEntity( p, _value, length, encoding );

  0003a	8b 55 14	 mov	 edx, DWORD PTR _encoding$[ebp]
  0003d	52		 push	 edx
  0003e	8b 45 10	 mov	 eax, DWORD PTR _length$[ebp]
  00041	50		 push	 eax
  00042	8b 4d 0c	 mov	 ecx, DWORD PTR __value$[ebp]
  00045	51		 push	 ecx
  00046	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00049	52		 push	 edx
  0004a	e8 00 00 00 00	 call	 ?GetEntity@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z ; TiXmlBase::GetEntity
  0004f	83 c4 10	 add	 esp, 16			; 00000010H
  00052	eb 67		 jmp	 SHORT $LN11@GetChar
$LN7@GetChar:

; 335  :             *_value = *p;

  00054	8b 45 0c	 mov	 eax, DWORD PTR __value$[ebp]
  00057	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0005a	8a 11		 mov	 dl, BYTE PTR [ecx]
  0005c	88 10		 mov	 BYTE PTR [eax], dl

; 336  :             return p+1;

  0005e	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00061	83 c0 01	 add	 eax, 1
  00064	eb 55		 jmp	 SHORT $LN11@GetChar
  00066	eb 53		 jmp	 SHORT $LN11@GetChar
$LN8@GetChar:

; 337  :         }
; 338  :         else if ( *length )

  00068	8b 45 10	 mov	 eax, DWORD PTR _length$[ebp]
  0006b	83 38 00	 cmp	 DWORD PTR [eax], 0
  0006e	74 49		 je	 SHORT $LN5@GetChar

; 339  :         {
; 340  :             //strncpy( _value, p, *length );    // lots of compilers don't like this function (unsafe),
; 341  :                                                 // and the null terminator isn't needed
; 342  :             for( int i=0; p[i] && i<*length; ++i ) {

  00070	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR _i$19780[ebp], 0
  00077	eb 09		 jmp	 SHORT $LN4@GetChar
$LN3@GetChar:
  00079	8b 4d fc	 mov	 ecx, DWORD PTR _i$19780[ebp]
  0007c	83 c1 01	 add	 ecx, 1
  0007f	89 4d fc	 mov	 DWORD PTR _i$19780[ebp], ecx
$LN4@GetChar:
  00082	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00085	03 55 fc	 add	 edx, DWORD PTR _i$19780[ebp]
  00088	0f be 02	 movsx	 eax, BYTE PTR [edx]
  0008b	85 c0		 test	 eax, eax
  0008d	74 1c		 je	 SHORT $LN2@GetChar
  0008f	8b 4d 10	 mov	 ecx, DWORD PTR _length$[ebp]
  00092	8b 55 fc	 mov	 edx, DWORD PTR _i$19780[ebp]
  00095	3b 11		 cmp	 edx, DWORD PTR [ecx]
  00097	7d 12		 jge	 SHORT $LN2@GetChar

; 343  :                 _value[i] = p[i];

  00099	8b 45 0c	 mov	 eax, DWORD PTR __value$[ebp]
  0009c	03 45 fc	 add	 eax, DWORD PTR _i$19780[ebp]
  0009f	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  000a2	03 4d fc	 add	 ecx, DWORD PTR _i$19780[ebp]
  000a5	8a 11		 mov	 dl, BYTE PTR [ecx]
  000a7	88 10		 mov	 BYTE PTR [eax], dl

; 344  :             }

  000a9	eb ce		 jmp	 SHORT $LN3@GetChar
$LN2@GetChar:

; 345  :             return p + (*length);

  000ab	8b 45 10	 mov	 eax, DWORD PTR _length$[ebp]
  000ae	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  000b1	03 08		 add	 ecx, DWORD PTR [eax]
  000b3	8b c1		 mov	 eax, ecx
  000b5	eb 04		 jmp	 SHORT $LN11@GetChar

; 346  :         }
; 347  :         else

  000b7	eb 02		 jmp	 SHORT $LN11@GetChar
$LN5@GetChar:

; 348  :         {
; 349  :             // Not valid text.
; 350  :             return 0;

  000b9	33 c0		 xor	 eax, eax
$LN11@GetChar:

; 351  :         }
; 352  :     }

  000bb	8b e5		 mov	 esp, ebp
  000bd	5d		 pop	 ebp
  000be	c3		 ret	 0
?GetChar@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z ENDP ; TiXmlBase::GetChar
PUBLIC	?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
; Function compile flags: /Odtp
; File c:\develop\dscaler423a\dscaler\tinyxmlparser.cpp
;	COMDAT ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
_TEXT	SEGMENT
_this$ = -4						; size = 4
_err$ = 8						; size = 4
_pError$ = 12						; size = 4
_data$ = 16						; size = 4
_encoding$ = 20						; size = 4
?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z PROC ; TiXmlDocument::SetError, COMDAT
; _this$ = ecx

; 799  : {

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

; 800  :     // The first error in a chain is more accurate - don't set again!
; 801  :     if ( error )

  00007	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  0000a	0f b6 48 44	 movzx	 ecx, BYTE PTR [eax+68]
  0000e	85 c9		 test	 ecx, ecx
  00010	74 02		 je	 SHORT $LN2@SetError

; 802  :         return;

  00012	eb 66		 jmp	 SHORT $LN3@SetError
$LN2@SetError:

; 803  : 
; 804  :     assert( err > 0 && err < TIXML_ERROR_STRING_COUNT );
; 805  :     error   = true;

  00014	8b 55 fc	 mov	 edx, DWORD PTR _this$[ebp]
  00017	c6 42 44 01	 mov	 BYTE PTR [edx+68], 1

; 806  :     errorId = err;

  0001b	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  0001e	8b 4d 08	 mov	 ecx, DWORD PTR _err$[ebp]
  00021	89 48 48	 mov	 DWORD PTR [eax+72], ecx

; 807  :     errorDesc = errorString[ errorId ];

  00024	8b 55 fc	 mov	 edx, DWORD PTR _this$[ebp]
  00027	8b 42 48	 mov	 eax, DWORD PTR [edx+72]
  0002a	8b 0c 85 00 00
	00 00		 mov	 ecx, DWORD PTR ?errorString@TiXmlBase@@1PAPBDA[eax*4]
  00031	51		 push	 ecx
  00032	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  00035	83 c1 4c	 add	 ecx, 76			; 0000004cH
  00038	e8 00 00 00 00	 call	 ??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@PBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=

; 808  : 
; 809  :     errorLocation.Clear();

  0003d	8b 4d fc	 mov	 ecx, DWORD PTR _this$[ebp]
  00040	83 c1 6c	 add	 ecx, 108		; 0000006cH
  00043	e8 00 00 00 00	 call	 ?Clear@TiXmlCursor@@QAEXXZ ; TiXmlCursor::Clear

; 810  :     if ( pError && data )

  00048	83 7d 0c 00	 cmp	 DWORD PTR _pError$[ebp], 0
  0004c	74 2c		 je	 SHORT $LN3@SetError
  0004e	83 7d 10 00	 cmp	 DWORD PTR _data$[ebp], 0
  00052	74 26		 je	 SHORT $LN3@SetError

; 811  :     {
; 812  :         data->Stamp( pError, encoding );

  00054	8b 55 14	 mov	 edx, DWORD PTR _encoding$[ebp]
  00057	52		 push	 edx
  00058	8b 45 0c	 mov	 eax, DWORD PTR _pError$[ebp]
  0005b	50		 push	 eax
  0005c	8b 4d 10	 mov	 ecx, DWORD PTR _data$[ebp]
  0005f	e8 00 00 00 00	 call	 ?Stamp@TiXmlParsingData@@QAEXPBDW4TiXmlEncoding@@@Z ; TiXmlParsingData::Stamp

; 813  :         errorLocation = data->Cursor();

  00064	8b 4d 10	 mov	 ecx, DWORD PTR _data$[ebp]
  00067	e8 00 00 00 00	 call	 ?Cursor@TiXmlParsingData@@QAEABUTiXmlCursor@@XZ ; TiXmlParsingData::Cursor
  0006c	8b 08		 mov	 ecx, DWORD PTR [eax]
  0006e	8b 50 04	 mov	 edx, DWORD PTR [eax+4]
  00071	8b 45 fc	 mov	 eax, DWORD PTR _this$[ebp]
  00074	89 48 6c	 mov	 DWORD PTR [eax+108], ecx
  00077	89 50 70	 mov	 DWORD PTR [eax+112], edx
$LN3@SetError:

; 814  :     }
; 815  : }

  0007a	8b e5		 mov	 esp, ebp
  0007c	5d		 pop	 ebp
  0007d	c2 10 00	 ret	 16			; 00000010H
?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ENDP ; TiXmlDocument::SetError
_TEXT	ENDS
PUBLIC	?ReadText@TiXmlBase@@KAPBDPBDPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@_N02W4TiXmlEncoding@@@Z ; TiXmlBase::ReadText
; Function compile flags: /Odtp
;	COMDAT ?ReadText@TiXmlBase@@KAPBDPBDPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@_N02W4TiXmlEncoding@@@Z
_TEXT	SEGMENT
_cArr$21271 = -20					; size = 4
_len$21270 = -16					; size = 4
_whitespace$21260 = -9					; size = 1
_cArr$21258 = -8					; size = 4
_len$21257 = -4						; size = 4
_p$ = 8							; size = 4
_text$ = 12						; size = 4
_trimWhiteSpace$ = 16					; size = 1
_endTag$ = 20						; size = 4
_caseInsensitive$ = 24					; size = 1
_encoding$ = 28						; size = 4
?ReadText@TiXmlBase@@KAPBDPBDPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@_N02W4TiXmlEncoding@@@Z PROC ; TiXmlBase::ReadText, COMDAT

; 580  : {

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

; 581  :     *text = "";

  00006	68 00 00 00 00	 push	 OFFSET ??_C@_00CNPNBAHC@?$AA@
  0000b	8b 4d 0c	 mov	 ecx, DWORD PTR _text$[ebp]
  0000e	e8 00 00 00 00	 call	 ??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@PBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=

; 582  :     if (    !trimWhiteSpace            // certain tags always keep whitespace
; 583  :          || !condenseWhiteSpace )    // if true, whitespace is always kept

  00013	0f b6 45 10	 movzx	 eax, BYTE PTR _trimWhiteSpace$[ebp]
  00017	85 c0		 test	 eax, eax
  00019	74 0b		 je	 SHORT $LN14@ReadText
  0001b	0f b6 0d 00 00
	00 00		 movzx	 ecx, BYTE PTR ?condenseWhiteSpace@TiXmlBase@@0_NA ; TiXmlBase::condenseWhiteSpace
  00022	85 c9		 test	 ecx, ecx
  00024	75 72		 jne	 SHORT $LN16@ReadText
$LN14@ReadText:

; 584  :     {
; 585  :         // Keep all the white space.
; 586  :         while (       p && *p
; 587  :                 && !StringEqual( p, endTag, caseInsensitive, encoding )
; 588  :               )

  00026	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  0002a	74 67		 je	 SHORT $LN13@ReadText
  0002c	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0002f	0f be 02	 movsx	 eax, BYTE PTR [edx]
  00032	85 c0		 test	 eax, eax
  00034	74 5d		 je	 SHORT $LN13@ReadText
  00036	8b 4d 1c	 mov	 ecx, DWORD PTR _encoding$[ebp]
  00039	51		 push	 ecx
  0003a	0f b6 55 18	 movzx	 edx, BYTE PTR _caseInsensitive$[ebp]
  0003e	52		 push	 edx
  0003f	8b 45 14	 mov	 eax, DWORD PTR _endTag$[ebp]
  00042	50		 push	 eax
  00043	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00046	51		 push	 ecx
  00047	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  0004c	83 c4 10	 add	 esp, 16			; 00000010H
  0004f	0f b6 d0	 movzx	 edx, al
  00052	85 d2		 test	 edx, edx
  00054	75 3d		 jne	 SHORT $LN13@ReadText

; 589  :         {
; 590  :             int len;
; 591  :             char cArr[4] = { 0, 0, 0, 0 };

  00056	c6 45 f8 00	 mov	 BYTE PTR _cArr$21258[ebp], 0
  0005a	c6 45 f9 00	 mov	 BYTE PTR _cArr$21258[ebp+1], 0
  0005e	c6 45 fa 00	 mov	 BYTE PTR _cArr$21258[ebp+2], 0
  00062	c6 45 fb 00	 mov	 BYTE PTR _cArr$21258[ebp+3], 0

; 592  :             p = GetChar( p, cArr, &len, encoding );

  00066	8b 45 1c	 mov	 eax, DWORD PTR _encoding$[ebp]
  00069	50		 push	 eax
  0006a	8d 4d fc	 lea	 ecx, DWORD PTR _len$21257[ebp]
  0006d	51		 push	 ecx
  0006e	8d 55 f8	 lea	 edx, DWORD PTR _cArr$21258[ebp]
  00071	52		 push	 edx
  00072	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00075	50		 push	 eax
  00076	e8 00 00 00 00	 call	 ?GetChar@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z ; TiXmlBase::GetChar
  0007b	83 c4 10	 add	 esp, 16			; 00000010H
  0007e	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 593  :             text->append( cArr, len );

  00081	8b 4d fc	 mov	 ecx, DWORD PTR _len$21257[ebp]
  00084	51		 push	 ecx
  00085	8d 55 f8	 lea	 edx, DWORD PTR _cArr$21258[ebp]
  00088	52		 push	 edx
  00089	8b 4d 0c	 mov	 ecx, DWORD PTR _text$[ebp]
  0008c	e8 00 00 00 00	 call	 ?append@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV12@PBDI@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::append

; 594  :         }

  00091	eb 93		 jmp	 SHORT $LN14@ReadText
$LN13@ReadText:

; 595  :     }
; 596  :     else

  00093	e9 0b 01 00 00	 jmp	 $LN12@ReadText
$LN16@ReadText:

; 597  :     {
; 598  :         bool whitespace = false;

  00098	c6 45 f7 00	 mov	 BYTE PTR _whitespace$21260[ebp], 0

; 599  : 
; 600  :         // Remove leading white space:
; 601  :         p = SkipWhiteSpace( p, encoding );

  0009c	8b 45 1c	 mov	 eax, DWORD PTR _encoding$[ebp]
  0009f	50		 push	 eax
  000a0	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  000a3	51		 push	 ecx
  000a4	e8 00 00 00 00	 call	 ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
  000a9	83 c4 08	 add	 esp, 8
  000ac	89 45 08	 mov	 DWORD PTR _p$[ebp], eax
$LN11@ReadText:

; 602  :         while (       p && *p
; 603  :                 && !StringEqual( p, endTag, caseInsensitive, encoding ) )

  000af	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  000b3	0f 84 ea 00 00
	00		 je	 $LN12@ReadText
  000b9	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  000bc	0f be 02	 movsx	 eax, BYTE PTR [edx]
  000bf	85 c0		 test	 eax, eax
  000c1	0f 84 dc 00 00
	00		 je	 $LN12@ReadText
  000c7	8b 4d 1c	 mov	 ecx, DWORD PTR _encoding$[ebp]
  000ca	51		 push	 ecx
  000cb	0f b6 55 18	 movzx	 edx, BYTE PTR _caseInsensitive$[ebp]
  000cf	52		 push	 edx
  000d0	8b 45 14	 mov	 eax, DWORD PTR _endTag$[ebp]
  000d3	50		 push	 eax
  000d4	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  000d7	51		 push	 ecx
  000d8	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  000dd	83 c4 10	 add	 esp, 16			; 00000010H
  000e0	0f b6 d0	 movzx	 edx, al
  000e3	85 d2		 test	 edx, edx
  000e5	0f 85 b8 00 00
	00		 jne	 $LN12@ReadText

; 604  :         {
; 605  :             if ( *p == '\r' || *p == '\n' )

  000eb	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  000ee	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  000f1	83 f9 0d	 cmp	 ecx, 13			; 0000000dH
  000f4	74 0b		 je	 SHORT $LN8@ReadText
  000f6	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  000f9	0f be 02	 movsx	 eax, BYTE PTR [edx]
  000fc	83 f8 0a	 cmp	 eax, 10			; 0000000aH
  000ff	75 12		 jne	 SHORT $LN9@ReadText
$LN8@ReadText:

; 606  :             {
; 607  :                 whitespace = true;

  00101	c6 45 f7 01	 mov	 BYTE PTR _whitespace$21260[ebp], 1

; 608  :                 ++p;

  00105	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00108	83 c1 01	 add	 ecx, 1
  0010b	89 4d 08	 mov	 DWORD PTR _p$[ebp], ecx
  0010e	e9 8b 00 00 00	 jmp	 $LN7@ReadText
$LN9@ReadText:

; 609  :             }
; 610  :             else if ( IsWhiteSpace( *p ) )

  00113	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00116	0f b6 02	 movzx	 eax, BYTE PTR [edx]
  00119	50		 push	 eax
  0011a	e8 00 00 00 00	 call	 ?IsWhiteSpace@TiXmlBase@@KA_ND@Z ; TiXmlBase::IsWhiteSpace
  0011f	83 c4 04	 add	 esp, 4
  00122	0f b6 c8	 movzx	 ecx, al
  00125	85 c9		 test	 ecx, ecx
  00127	74 0f		 je	 SHORT $LN6@ReadText

; 611  :             {
; 612  :                 whitespace = true;

  00129	c6 45 f7 01	 mov	 BYTE PTR _whitespace$21260[ebp], 1

; 613  :                 ++p;

  0012d	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00130	83 c2 01	 add	 edx, 1
  00133	89 55 08	 mov	 DWORD PTR _p$[ebp], edx

; 614  :             }
; 615  :             else

  00136	eb 66		 jmp	 SHORT $LN7@ReadText
$LN6@ReadText:

; 616  :             {
; 617  :                 // If we've found whitespace, add it before the
; 618  :                 // new character. Any whitespace just becomes a space.
; 619  :                 if ( whitespace )

  00138	0f b6 45 f7	 movzx	 eax, BYTE PTR _whitespace$21260[ebp]
  0013c	85 c0		 test	 eax, eax
  0013e	74 0e		 je	 SHORT $LN4@ReadText

; 620  :                 {
; 621  :                     (*text) += ' ';

  00140	6a 20		 push	 32			; 00000020H
  00142	8b 4d 0c	 mov	 ecx, DWORD PTR _text$[ebp]
  00145	e8 00 00 00 00	 call	 ??Y?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@D@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator+=

; 622  :                     whitespace = false;

  0014a	c6 45 f7 00	 mov	 BYTE PTR _whitespace$21260[ebp], 0
$LN4@ReadText:

; 623  :                 }
; 624  :                 int len;
; 625  :                 char cArr[4] = { 0, 0, 0, 0 };

  0014e	c6 45 ec 00	 mov	 BYTE PTR _cArr$21271[ebp], 0
  00152	c6 45 ed 00	 mov	 BYTE PTR _cArr$21271[ebp+1], 0
  00156	c6 45 ee 00	 mov	 BYTE PTR _cArr$21271[ebp+2], 0
  0015a	c6 45 ef 00	 mov	 BYTE PTR _cArr$21271[ebp+3], 0

; 626  :                 p = GetChar( p, cArr, &len, encoding );

  0015e	8b 4d 1c	 mov	 ecx, DWORD PTR _encoding$[ebp]
  00161	51		 push	 ecx
  00162	8d 55 f0	 lea	 edx, DWORD PTR _len$21270[ebp]
  00165	52		 push	 edx
  00166	8d 45 ec	 lea	 eax, DWORD PTR _cArr$21271[ebp]
  00169	50		 push	 eax
  0016a	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0016d	51		 push	 ecx
  0016e	e8 00 00 00 00	 call	 ?GetChar@TiXmlBase@@KAPBDPBDPADPAHW4TiXmlEncoding@@@Z ; TiXmlBase::GetChar
  00173	83 c4 10	 add	 esp, 16			; 00000010H
  00176	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 627  :                 if ( len == 1 )

  00179	83 7d f0 01	 cmp	 DWORD PTR _len$21270[ebp], 1
  0017d	75 0f		 jne	 SHORT $LN3@ReadText

; 628  :                     (*text) += cArr[0];    // more efficient

  0017f	0f b6 55 ec	 movzx	 edx, BYTE PTR _cArr$21271[ebp]
  00183	52		 push	 edx
  00184	8b 4d 0c	 mov	 ecx, DWORD PTR _text$[ebp]
  00187	e8 00 00 00 00	 call	 ??Y?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@D@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator+=

; 629  :                 else

  0018c	eb 10		 jmp	 SHORT $LN7@ReadText
$LN3@ReadText:

; 630  :                     text->append( cArr, len );

  0018e	8b 45 f0	 mov	 eax, DWORD PTR _len$21270[ebp]
  00191	50		 push	 eax
  00192	8d 4d ec	 lea	 ecx, DWORD PTR _cArr$21271[ebp]
  00195	51		 push	 ecx
  00196	8b 4d 0c	 mov	 ecx, DWORD PTR _text$[ebp]
  00199	e8 00 00 00 00	 call	 ?append@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV12@PBDI@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::append
$LN7@ReadText:

; 631  :             }
; 632  :         }

  0019e	e9 0c ff ff ff	 jmp	 $LN11@ReadText
$LN12@ReadText:

; 633  :     }
; 634  :     if ( p )

  001a3	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  001a7	74 12		 je	 SHORT $LN1@ReadText

; 635  :         p += strlen( endTag );

  001a9	8b 55 14	 mov	 edx, DWORD PTR _endTag$[ebp]
  001ac	52		 push	 edx
  001ad	e8 00 00 00 00	 call	 _strlen
  001b2	83 c4 04	 add	 esp, 4
  001b5	03 45 08	 add	 eax, DWORD PTR _p$[ebp]
  001b8	89 45 08	 mov	 DWORD PTR _p$[ebp], eax
$LN1@ReadText:

; 636  :     return p;

  001bb	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]

; 637  : }

  001be	8b e5		 mov	 esp, ebp
  001c0	5d		 pop	 ebp
  001c1	c3		 ret	 0
?ReadText@TiXmlBase@@KAPBDPBDPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@_N02W4TiXmlEncoding@@@Z ENDP ; TiXmlBase::ReadText
_TEXT	ENDS
PUBLIC	?ReadName@TiXmlBase@@KAPBDPBDPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@W4TiXmlEncoding@@@Z ; TiXmlBase::ReadName
; Function compile flags: /Odtp
;	COMDAT ?ReadName@TiXmlBase@@KAPBDPBDPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@W4TiXmlEncoding@@@Z
_TEXT	SEGMENT
_start$21072 = -4					; size = 4
_p$ = 8							; size = 4
_name$ = 12						; size = 4
_encoding$ = 16						; size = 4
?ReadName@TiXmlBase@@KAPBDPBDPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@W4TiXmlEncoding@@@Z PROC ; TiXmlBase::ReadName, COMDAT

; 402  : {

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

; 403  :     // Oddly, not supported on some comilers,
; 404  :     //name->clear();
; 405  :     // So use this:
; 406  :     *name = "";

  00004	68 00 00 00 00	 push	 OFFSET ??_C@_00CNPNBAHC@?$AA@
  00009	8b 4d 0c	 mov	 ecx, DWORD PTR _name$[ebp]
  0000c	e8 00 00 00 00	 call	 ??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@PBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=

; 407  :     assert( p );
; 408  : 
; 409  :     // Names start with letters or underscores.
; 410  :     // Of course, in unicode, tinyxml has no idea what a letter *is*. The
; 411  :     // algorithm is generous.
; 412  :     //
; 413  :     // After that, they can be letters, underscores, numbers,
; 414  :     // hyphens, or colons. (Colons are valid ony for namespaces,
; 415  :     // but tinyxml can't tell namespaces from names.)
; 416  :     if (    p && *p
; 417  :          && ( IsAlpha( (unsigned char) *p, encoding ) || *p == '_' ) )

  00011	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00015	0f 84 ba 00 00
	00		 je	 $LN6@ReadName
  0001b	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0001e	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  00021	85 c9		 test	 ecx, ecx
  00023	0f 84 ac 00 00
	00		 je	 $LN6@ReadName
  00029	8b 55 10	 mov	 edx, DWORD PTR _encoding$[ebp]
  0002c	52		 push	 edx
  0002d	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00030	0f b6 08	 movzx	 ecx, BYTE PTR [eax]
  00033	51		 push	 ecx
  00034	e8 00 00 00 00	 call	 ?IsAlpha@TiXmlBase@@KAHEW4TiXmlEncoding@@@Z ; TiXmlBase::IsAlpha
  00039	83 c4 08	 add	 esp, 8
  0003c	85 c0		 test	 eax, eax
  0003e	75 0f		 jne	 SHORT $LN5@ReadName
  00040	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00043	0f be 02	 movsx	 eax, BYTE PTR [edx]
  00046	83 f8 5f	 cmp	 eax, 95			; 0000005fH
  00049	0f 85 86 00 00
	00		 jne	 $LN6@ReadName
$LN5@ReadName:

; 418  :     {
; 419  :         const char* start = p;

  0004f	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00052	89 4d fc	 mov	 DWORD PTR _start$21072[ebp], ecx
$LN4@ReadName:

; 420  :         while(        p && *p
; 421  :                 &&    (        IsAlphaNum( (unsigned char ) *p, encoding )
; 422  :                          || *p == '_'
; 423  :                          || *p == '-'
; 424  :                          || *p == '.'
; 425  :                          || *p == ':' ) )

  00055	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00059	74 58		 je	 SHORT $LN3@ReadName
  0005b	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0005e	0f be 02	 movsx	 eax, BYTE PTR [edx]
  00061	85 c0		 test	 eax, eax
  00063	74 4e		 je	 SHORT $LN3@ReadName
  00065	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  00068	51		 push	 ecx
  00069	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0006c	0f b6 02	 movzx	 eax, BYTE PTR [edx]
  0006f	50		 push	 eax
  00070	e8 00 00 00 00	 call	 ?IsAlphaNum@TiXmlBase@@KAHEW4TiXmlEncoding@@@Z ; TiXmlBase::IsAlphaNum
  00075	83 c4 08	 add	 esp, 8
  00078	85 c0		 test	 eax, eax
  0007a	75 2c		 jne	 SHORT $LN2@ReadName
  0007c	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0007f	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  00082	83 fa 5f	 cmp	 edx, 95			; 0000005fH
  00085	74 21		 je	 SHORT $LN2@ReadName
  00087	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0008a	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  0008d	83 f9 2d	 cmp	 ecx, 45			; 0000002dH
  00090	74 16		 je	 SHORT $LN2@ReadName
  00092	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00095	0f be 02	 movsx	 eax, BYTE PTR [edx]
  00098	83 f8 2e	 cmp	 eax, 46			; 0000002eH
  0009b	74 0b		 je	 SHORT $LN2@ReadName
  0009d	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  000a0	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  000a3	83 fa 3a	 cmp	 edx, 58			; 0000003aH
  000a6	75 0b		 jne	 SHORT $LN3@ReadName
$LN2@ReadName:

; 426  :         {
; 427  :             //(*name) += *p; // expensive
; 428  :             ++p;

  000a8	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  000ab	83 c0 01	 add	 eax, 1
  000ae	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 429  :         }

  000b1	eb a2		 jmp	 SHORT $LN4@ReadName
$LN3@ReadName:

; 430  :         if ( p-start > 0 ) {

  000b3	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  000b6	2b 4d fc	 sub	 ecx, DWORD PTR _start$21072[ebp]
  000b9	85 c9		 test	 ecx, ecx
  000bb	7e 13		 jle	 SHORT $LN1@ReadName

; 431  :             name->assign( start, p-start );

  000bd	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  000c0	2b 55 fc	 sub	 edx, DWORD PTR _start$21072[ebp]
  000c3	52		 push	 edx
  000c4	8b 45 fc	 mov	 eax, DWORD PTR _start$21072[ebp]
  000c7	50		 push	 eax
  000c8	8b 4d 0c	 mov	 ecx, DWORD PTR _name$[ebp]
  000cb	e8 00 00 00 00	 call	 ?assign@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV12@PBDI@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::assign
$LN1@ReadName:

; 432  :         }
; 433  :         return p;

  000d0	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  000d3	eb 02		 jmp	 SHORT $LN7@ReadName
$LN6@ReadName:

; 434  :     }
; 435  :     return 0;

  000d5	33 c0		 xor	 eax, eax
$LN7@ReadName:

; 436  : }

  000d7	8b e5		 mov	 esp, ebp
  000d9	5d		 pop	 ebp
  000da	c3		 ret	 0
?ReadName@TiXmlBase@@KAPBDPBDPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@W4TiXmlEncoding@@@Z ENDP ; TiXmlBase::ReadName
PUBLIC	__$ArrayPad$
;	COMDAT xdata$x
xdata$x	SEGMENT
__unwindtable$?Parse@TiXmlText@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z DD 0ffffffffH
	DD	FLAT:__unwindfunclet$?Parse@TiXmlText@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z$0
__ehfuncinfo$?Parse@TiXmlText@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z DD 019930522H
	DD	01H
	DD	FLAT:__unwindtable$?Parse@TiXmlText@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
	DD	2 DUP(00H)
	DD	2 DUP(00H)
	DD	00H
	DD	00H
; Function compile flags: /Odtp
xdata$x	ENDS
;	COMDAT ?Parse@TiXmlText@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
_TEXT	SEGMENT
_this$ = -72						; size = 4
$T336808 = -68						; size = 4
_end$21688 = -64					; size = 4
_ignoreWhite$21687 = -57				; size = 1
_dummy$21684 = -56					; size = 28
__$ArrayPad$ = -28					; size = 4
_startTag$ = -24					; size = 4
_endTag$ = -20						; size = 4
_document$ = -16					; size = 4
__$EHRec$ = -12						; size = 12
_p$ = 8							; size = 4
_data$ = 12						; size = 4
_encoding$ = 16						; size = 4
?Parse@TiXmlText@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z PROC ; TiXmlText::Parse, COMDAT
; _this$ = ecx

; 1467 : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	6a ff		 push	 -1
  00005	68 00 00 00 00	 push	 __ehhandler$?Parse@TiXmlText@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
  0000a	64 a1 00 00 00
	00		 mov	 eax, DWORD PTR fs:0
  00010	50		 push	 eax
  00011	83 ec 3c	 sub	 esp, 60			; 0000003cH
  00014	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  00019	33 c5		 xor	 eax, ebp
  0001b	89 45 e4	 mov	 DWORD PTR __$ArrayPad$[ebp], eax
  0001e	50		 push	 eax
  0001f	8d 45 f4	 lea	 eax, DWORD PTR __$EHRec$[ebp]
  00022	64 a3 00 00 00
	00		 mov	 DWORD PTR fs:0, eax
  00028	89 4d b8	 mov	 DWORD PTR _this$[ebp], ecx

; 1468 :     value = "";

  0002b	68 00 00 00 00	 push	 OFFSET ??_C@_00CNPNBAHC@?$AA@
  00030	8b 4d b8	 mov	 ecx, DWORD PTR _this$[ebp]
  00033	83 c1 20	 add	 ecx, 32			; 00000020H
  00036	e8 00 00 00 00	 call	 ??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@PBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=

; 1469 :     TiXmlDocument* document = GetDocument();

  0003b	8b 4d b8	 mov	 ecx, DWORD PTR _this$[ebp]
  0003e	e8 00 00 00 00	 call	 ?GetDocument@TiXmlNode@@QAEPAVTiXmlDocument@@XZ ; TiXmlNode::GetDocument
  00043	89 45 f0	 mov	 DWORD PTR _document$[ebp], eax

; 1470 : 
; 1471 :     if ( data )

  00046	83 7d 0c 00	 cmp	 DWORD PTR _data$[ebp], 0
  0004a	74 26		 je	 SHORT $LN8@Parse

; 1472 :     {
; 1473 :         data->Stamp( p, encoding );

  0004c	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  0004f	50		 push	 eax
  00050	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00053	51		 push	 ecx
  00054	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  00057	e8 00 00 00 00	 call	 ?Stamp@TiXmlParsingData@@QAEXPBDW4TiXmlEncoding@@@Z ; TiXmlParsingData::Stamp

; 1474 :         location = data->Cursor();

  0005c	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  0005f	e8 00 00 00 00	 call	 ?Cursor@TiXmlParsingData@@QAEABUTiXmlCursor@@XZ ; TiXmlParsingData::Cursor
  00064	8b 10		 mov	 edx, DWORD PTR [eax]
  00066	8b 40 04	 mov	 eax, DWORD PTR [eax+4]
  00069	8b 4d b8	 mov	 ecx, DWORD PTR _this$[ebp]
  0006c	89 51 04	 mov	 DWORD PTR [ecx+4], edx
  0006f	89 41 08	 mov	 DWORD PTR [ecx+8], eax
$LN8@Parse:

; 1475 :     }
; 1476 : 
; 1477 :     const char* const startTag = "<![CDATA[";

  00072	c7 45 e8 00 00
	00 00		 mov	 DWORD PTR _startTag$[ebp], OFFSET ??_C@_09BLLNCBLF@?$DM?$CB?$FLCDATA?$FL?$AA@

; 1478 :     const char* const endTag   = "]]>";

  00079	c7 45 ec 00 00
	00 00		 mov	 DWORD PTR _endTag$[ebp], OFFSET ??_C@_03MCHNFBAC@?$FN?$FN?$DO?$AA@

; 1479 : 
; 1480 :     if ( cdata || StringEqual( p, startTag, false, encoding ) )

  00080	8b 55 b8	 mov	 edx, DWORD PTR _this$[ebp]
  00083	0f b6 42 44	 movzx	 eax, BYTE PTR [edx+68]
  00087	85 c0		 test	 eax, eax
  00089	75 21		 jne	 SHORT $LN6@Parse
  0008b	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  0008e	51		 push	 ecx
  0008f	6a 00		 push	 0
  00091	8b 55 e8	 mov	 edx, DWORD PTR _startTag$[ebp]
  00094	52		 push	 edx
  00095	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00098	50		 push	 eax
  00099	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  0009e	83 c4 10	 add	 esp, 16			; 00000010H
  000a1	0f b6 c8	 movzx	 ecx, al
  000a4	85 c9		 test	 ecx, ecx
  000a6	0f 84 e7 00 00
	00		 je	 $LN7@Parse
$LN6@Parse:

; 1481 :     {
; 1482 :         cdata = true;

  000ac	8b 55 b8	 mov	 edx, DWORD PTR _this$[ebp]
  000af	c6 42 44 01	 mov	 BYTE PTR [edx+68], 1

; 1483 : 
; 1484 :         if ( !StringEqual( p, startTag, false, encoding ) )

  000b3	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  000b6	50		 push	 eax
  000b7	6a 00		 push	 0
  000b9	8b 4d e8	 mov	 ecx, DWORD PTR _startTag$[ebp]
  000bc	51		 push	 ecx
  000bd	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  000c0	52		 push	 edx
  000c1	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  000c6	83 c4 10	 add	 esp, 16			; 00000010H
  000c9	0f b6 c0	 movzx	 eax, al
  000cc	85 c0		 test	 eax, eax
  000ce	75 1d		 jne	 SHORT $LN5@Parse

; 1485 :         {
; 1486 :             document->SetError( TIXML_ERROR_PARSING_CDATA, p, data, encoding );

  000d0	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  000d3	51		 push	 ecx
  000d4	8b 55 0c	 mov	 edx, DWORD PTR _data$[ebp]
  000d7	52		 push	 edx
  000d8	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  000db	50		 push	 eax
  000dc	6a 0f		 push	 15			; 0000000fH
  000de	8b 4d f0	 mov	 ecx, DWORD PTR _document$[ebp]
  000e1	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError

; 1487 :             return 0;

  000e6	33 c0		 xor	 eax, eax
  000e8	e9 e6 00 00 00	 jmp	 $LN9@Parse
$LN5@Parse:

; 1488 :         }
; 1489 :         p += strlen( startTag );

  000ed	8b 4d e8	 mov	 ecx, DWORD PTR _startTag$[ebp]
  000f0	51		 push	 ecx
  000f1	e8 00 00 00 00	 call	 _strlen
  000f6	83 c4 04	 add	 esp, 4
  000f9	03 45 08	 add	 eax, DWORD PTR _p$[ebp]
  000fc	89 45 08	 mov	 DWORD PTR _p$[ebp], eax
$LN4@Parse:

; 1490 : 
; 1491 :         // Keep all the white space, ignore the encoding, etc.
; 1492 :         while (       p && *p
; 1493 :                 && !StringEqual( p, endTag, false, encoding )
; 1494 :               )

  000ff	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00103	74 44		 je	 SHORT $LN3@Parse
  00105	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00108	0f be 02	 movsx	 eax, BYTE PTR [edx]
  0010b	85 c0		 test	 eax, eax
  0010d	74 3a		 je	 SHORT $LN3@Parse
  0010f	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  00112	51		 push	 ecx
  00113	6a 00		 push	 0
  00115	8b 55 ec	 mov	 edx, DWORD PTR _endTag$[ebp]
  00118	52		 push	 edx
  00119	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0011c	50		 push	 eax
  0011d	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  00122	83 c4 10	 add	 esp, 16			; 00000010H
  00125	0f b6 c8	 movzx	 ecx, al
  00128	85 c9		 test	 ecx, ecx
  0012a	75 1d		 jne	 SHORT $LN3@Parse

; 1495 :         {
; 1496 :             value += *p;

  0012c	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0012f	0f b6 02	 movzx	 eax, BYTE PTR [edx]
  00132	50		 push	 eax
  00133	8b 4d b8	 mov	 ecx, DWORD PTR _this$[ebp]
  00136	83 c1 20	 add	 ecx, 32			; 00000020H
  00139	e8 00 00 00 00	 call	 ??Y?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@D@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator+=

; 1497 :             ++p;

  0013e	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00141	83 c1 01	 add	 ecx, 1
  00144	89 4d 08	 mov	 DWORD PTR _p$[ebp], ecx

; 1498 :         }

  00147	eb b6		 jmp	 SHORT $LN4@Parse
$LN3@Parse:

; 1499 : 
; 1500 :         TIXML_STRING dummy;

  00149	8d 4d c8	 lea	 ecx, DWORD PTR _dummy$21684[ebp]
  0014c	e8 00 00 00 00	 call	 ??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::basic_string<char,std::char_traits<char>,std::allocator<char> >
  00151	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+8], 0

; 1501 :         p = ReadText( p, &dummy, false, endTag, false, encoding );

  00158	8b 55 10	 mov	 edx, DWORD PTR _encoding$[ebp]
  0015b	52		 push	 edx
  0015c	6a 00		 push	 0
  0015e	8b 45 ec	 mov	 eax, DWORD PTR _endTag$[ebp]
  00161	50		 push	 eax
  00162	6a 00		 push	 0
  00164	8d 4d c8	 lea	 ecx, DWORD PTR _dummy$21684[ebp]
  00167	51		 push	 ecx
  00168	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0016b	52		 push	 edx
  0016c	e8 00 00 00 00	 call	 ?ReadText@TiXmlBase@@KAPBDPBDPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@_N02W4TiXmlEncoding@@@Z ; TiXmlBase::ReadText
  00171	83 c4 18	 add	 esp, 24			; 00000018H
  00174	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1502 :         return p;

  00177	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0017a	89 45 bc	 mov	 DWORD PTR $T336808[ebp], eax
  0017d	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  00184	8d 4d c8	 lea	 ecx, DWORD PTR _dummy$21684[ebp]
  00187	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  0018c	8b 45 bc	 mov	 eax, DWORD PTR $T336808[ebp]
  0018f	eb 42		 jmp	 SHORT $LN9@Parse

; 1503 :     }
; 1504 :     else

  00191	eb 40		 jmp	 SHORT $LN9@Parse
$LN7@Parse:

; 1505 :     {
; 1506 :         bool ignoreWhite = true;

  00193	c6 45 c7 01	 mov	 BYTE PTR _ignoreWhite$21687[ebp], 1

; 1507 : 
; 1508 :         const char* end = "<";

  00197	c7 45 c0 00 00
	00 00		 mov	 DWORD PTR _end$21688[ebp], OFFSET ??_C@_01MNNFJEPP@?$DM?$AA@

; 1509 :         p = ReadText( p, &value, ignoreWhite, end, false, encoding );

  0019e	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  001a1	51		 push	 ecx
  001a2	6a 00		 push	 0
  001a4	8b 55 c0	 mov	 edx, DWORD PTR _end$21688[ebp]
  001a7	52		 push	 edx
  001a8	0f b6 45 c7	 movzx	 eax, BYTE PTR _ignoreWhite$21687[ebp]
  001ac	50		 push	 eax
  001ad	8b 4d b8	 mov	 ecx, DWORD PTR _this$[ebp]
  001b0	83 c1 20	 add	 ecx, 32			; 00000020H
  001b3	51		 push	 ecx
  001b4	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  001b7	52		 push	 edx
  001b8	e8 00 00 00 00	 call	 ?ReadText@TiXmlBase@@KAPBDPBDPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@_N02W4TiXmlEncoding@@@Z ; TiXmlBase::ReadText
  001bd	83 c4 18	 add	 esp, 24			; 00000018H
  001c0	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1510 :         if ( p )

  001c3	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  001c7	74 08		 je	 SHORT $LN1@Parse

; 1511 :             return p-1;    // don't truncate the '<'

  001c9	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  001cc	83 e8 01	 sub	 eax, 1
  001cf	eb 02		 jmp	 SHORT $LN9@Parse
$LN1@Parse:

; 1512 :         return 0;

  001d1	33 c0		 xor	 eax, eax
$LN9@Parse:

; 1513 :     }
; 1514 : }

  001d3	8b 4d f4	 mov	 ecx, DWORD PTR __$EHRec$[ebp]
  001d6	64 89 0d 00 00
	00 00		 mov	 DWORD PTR fs:0, ecx
  001dd	59		 pop	 ecx
  001de	8b 4d e4	 mov	 ecx, DWORD PTR __$ArrayPad$[ebp]
  001e1	33 cd		 xor	 ecx, ebp
  001e3	e8 00 00 00 00	 call	 @__security_check_cookie@4
  001e8	8b e5		 mov	 esp, ebp
  001ea	5d		 pop	 ebp
  001eb	c2 0c 00	 ret	 12			; 0000000cH
_TEXT	ENDS
;	COMDAT text$x
text$x	SEGMENT
__unwindfunclet$?Parse@TiXmlText@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z$0:
  00000	8d 4d c8	 lea	 ecx, DWORD PTR _dummy$21684[ebp]
  00003	e9 00 00 00 00	 jmp	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
__ehhandler$?Parse@TiXmlText@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z:
  00008	8b 54 24 08	 mov	 edx, DWORD PTR [esp+8]
  0000c	8d 42 0c	 lea	 eax, DWORD PTR [edx+12]
  0000f	8b 4a c0	 mov	 ecx, DWORD PTR [edx-64]
  00012	33 c8		 xor	 ecx, eax
  00014	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00019	8b 4a f0	 mov	 ecx, DWORD PTR [edx-16]
  0001c	33 c8		 xor	 ecx, eax
  0001e	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00023	b8 00 00 00 00	 mov	 eax, OFFSET __ehfuncinfo$?Parse@TiXmlText@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
  00028	e9 00 00 00 00	 jmp	 ___CxxFrameHandler3
text$x	ENDS
?Parse@TiXmlText@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ENDP ; TiXmlText::Parse
; Function compile flags: /Odtp
;	COMDAT ?Parse@TiXmlAttribute@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
_TEXT	SEGMENT
_this$ = -16						; size = 4
_SINGLE_QUOTE$ = -10					; size = 1
_DOUBLE_QUOTE$ = -9					; size = 1
_end$ = -8						; size = 4
_pErr$ = -4						; size = 4
_p$ = 8							; size = 4
_data$ = 12						; size = 4
_encoding$ = 16						; size = 4
?Parse@TiXmlAttribute@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z PROC ; TiXmlAttribute::Parse, COMDAT
; _this$ = ecx

; 1358 : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 10	 sub	 esp, 16			; 00000010H
  00006	89 4d f0	 mov	 DWORD PTR _this$[ebp], ecx

; 1359 :     p = SkipWhiteSpace( p, encoding );

  00009	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  0000c	50		 push	 eax
  0000d	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00010	51		 push	 ecx
  00011	e8 00 00 00 00	 call	 ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
  00016	83 c4 08	 add	 esp, 8
  00019	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1360 :     if ( !p || !*p ) return 0;

  0001c	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00020	74 0a		 je	 SHORT $LN20@Parse@2
  00022	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00025	0f be 02	 movsx	 eax, BYTE PTR [edx]
  00028	85 c0		 test	 eax, eax
  0002a	75 07		 jne	 SHORT $LN21@Parse@2
$LN20@Parse@2:
  0002c	33 c0		 xor	 eax, eax
  0002e	e9 8a 02 00 00	 jmp	 $LN22@Parse@2
$LN21@Parse@2:

; 1361 : 
; 1362 : //    int tabsize = 4;
; 1363 : //    if ( document )
; 1364 : //        tabsize = document->TabSize();
; 1365 : 
; 1366 :     if ( data )

  00033	83 7d 0c 00	 cmp	 DWORD PTR _data$[ebp], 0
  00037	74 26		 je	 SHORT $LN19@Parse@2

; 1367 :     {
; 1368 :         data->Stamp( p, encoding );

  00039	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  0003c	51		 push	 ecx
  0003d	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00040	52		 push	 edx
  00041	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  00044	e8 00 00 00 00	 call	 ?Stamp@TiXmlParsingData@@QAEXPBDW4TiXmlEncoding@@@Z ; TiXmlParsingData::Stamp

; 1369 :         location = data->Cursor();

  00049	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  0004c	e8 00 00 00 00	 call	 ?Cursor@TiXmlParsingData@@QAEABUTiXmlCursor@@XZ ; TiXmlParsingData::Cursor
  00051	8b 08		 mov	 ecx, DWORD PTR [eax]
  00053	8b 50 04	 mov	 edx, DWORD PTR [eax+4]
  00056	8b 45 f0	 mov	 eax, DWORD PTR _this$[ebp]
  00059	89 48 04	 mov	 DWORD PTR [eax+4], ecx
  0005c	89 50 08	 mov	 DWORD PTR [eax+8], edx
$LN19@Parse@2:

; 1370 :     }
; 1371 :     // Read the name, the '=' and the value.
; 1372 :     const char* pErr = p;

  0005f	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00062	89 4d fc	 mov	 DWORD PTR _pErr$[ebp], ecx

; 1373 :     p = ReadName( p, &name, encoding );

  00065	8b 55 10	 mov	 edx, DWORD PTR _encoding$[ebp]
  00068	52		 push	 edx
  00069	8b 45 f0	 mov	 eax, DWORD PTR _this$[ebp]
  0006c	83 c0 14	 add	 eax, 20			; 00000014H
  0006f	50		 push	 eax
  00070	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00073	51		 push	 ecx
  00074	e8 00 00 00 00	 call	 ?ReadName@TiXmlBase@@KAPBDPBDPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@W4TiXmlEncoding@@@Z ; TiXmlBase::ReadName
  00079	83 c4 0c	 add	 esp, 12			; 0000000cH
  0007c	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1374 :     if ( !p || !*p )

  0007f	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00083	74 0a		 je	 SHORT $LN17@Parse@2
  00085	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00088	0f be 02	 movsx	 eax, BYTE PTR [edx]
  0008b	85 c0		 test	 eax, eax
  0008d	75 29		 jne	 SHORT $LN18@Parse@2
$LN17@Parse@2:

; 1375 :     {
; 1376 :         if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, pErr, data, encoding );

  0008f	8b 4d f0	 mov	 ecx, DWORD PTR _this$[ebp]
  00092	83 79 10 00	 cmp	 DWORD PTR [ecx+16], 0
  00096	74 19		 je	 SHORT $LN16@Parse@2
  00098	8b 55 10	 mov	 edx, DWORD PTR _encoding$[ebp]
  0009b	52		 push	 edx
  0009c	8b 45 0c	 mov	 eax, DWORD PTR _data$[ebp]
  0009f	50		 push	 eax
  000a0	8b 4d fc	 mov	 ecx, DWORD PTR _pErr$[ebp]
  000a3	51		 push	 ecx
  000a4	6a 07		 push	 7
  000a6	8b 55 f0	 mov	 edx, DWORD PTR _this$[ebp]
  000a9	8b 4a 10	 mov	 ecx, DWORD PTR [edx+16]
  000ac	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN16@Parse@2:

; 1377 :         return 0;

  000b1	33 c0		 xor	 eax, eax
  000b3	e9 05 02 00 00	 jmp	 $LN22@Parse@2
$LN18@Parse@2:

; 1378 :     }
; 1379 :     p = SkipWhiteSpace( p, encoding );

  000b8	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  000bb	50		 push	 eax
  000bc	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  000bf	51		 push	 ecx
  000c0	e8 00 00 00 00	 call	 ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
  000c5	83 c4 08	 add	 esp, 8
  000c8	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1380 :     if ( !p || !*p || *p != '=' )

  000cb	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  000cf	74 15		 je	 SHORT $LN14@Parse@2
  000d1	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  000d4	0f be 02	 movsx	 eax, BYTE PTR [edx]
  000d7	85 c0		 test	 eax, eax
  000d9	74 0b		 je	 SHORT $LN14@Parse@2
  000db	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  000de	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  000e1	83 fa 3d	 cmp	 edx, 61			; 0000003dH
  000e4	74 29		 je	 SHORT $LN15@Parse@2
$LN14@Parse@2:

; 1381 :     {
; 1382 :         if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding );

  000e6	8b 45 f0	 mov	 eax, DWORD PTR _this$[ebp]
  000e9	83 78 10 00	 cmp	 DWORD PTR [eax+16], 0
  000ed	74 19		 je	 SHORT $LN13@Parse@2
  000ef	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  000f2	51		 push	 ecx
  000f3	8b 55 0c	 mov	 edx, DWORD PTR _data$[ebp]
  000f6	52		 push	 edx
  000f7	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  000fa	50		 push	 eax
  000fb	6a 07		 push	 7
  000fd	8b 4d f0	 mov	 ecx, DWORD PTR _this$[ebp]
  00100	8b 49 10	 mov	 ecx, DWORD PTR [ecx+16]
  00103	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN13@Parse@2:

; 1383 :         return 0;

  00108	33 c0		 xor	 eax, eax
  0010a	e9 ae 01 00 00	 jmp	 $LN22@Parse@2
$LN15@Parse@2:

; 1384 :     }
; 1385 : 
; 1386 :     ++p;    // skip '='

  0010f	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00112	83 c2 01	 add	 edx, 1
  00115	89 55 08	 mov	 DWORD PTR _p$[ebp], edx

; 1387 :     p = SkipWhiteSpace( p, encoding );

  00118	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  0011b	50		 push	 eax
  0011c	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0011f	51		 push	 ecx
  00120	e8 00 00 00 00	 call	 ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
  00125	83 c4 08	 add	 esp, 8
  00128	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1388 :     if ( !p || !*p )

  0012b	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  0012f	74 0a		 je	 SHORT $LN11@Parse@2
  00131	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00134	0f be 02	 movsx	 eax, BYTE PTR [edx]
  00137	85 c0		 test	 eax, eax
  00139	75 29		 jne	 SHORT $LN12@Parse@2
$LN11@Parse@2:

; 1389 :     {
; 1390 :         if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding );

  0013b	8b 4d f0	 mov	 ecx, DWORD PTR _this$[ebp]
  0013e	83 79 10 00	 cmp	 DWORD PTR [ecx+16], 0
  00142	74 19		 je	 SHORT $LN10@Parse@2
  00144	8b 55 10	 mov	 edx, DWORD PTR _encoding$[ebp]
  00147	52		 push	 edx
  00148	8b 45 0c	 mov	 eax, DWORD PTR _data$[ebp]
  0014b	50		 push	 eax
  0014c	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0014f	51		 push	 ecx
  00150	6a 07		 push	 7
  00152	8b 55 f0	 mov	 edx, DWORD PTR _this$[ebp]
  00155	8b 4a 10	 mov	 ecx, DWORD PTR [edx+16]
  00158	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN10@Parse@2:

; 1391 :         return 0;

  0015d	33 c0		 xor	 eax, eax
  0015f	e9 59 01 00 00	 jmp	 $LN22@Parse@2
$LN12@Parse@2:

; 1392 :     }
; 1393 : 
; 1394 :     const char* end;
; 1395 :     const char SINGLE_QUOTE = '\'';

  00164	c6 45 f6 27	 mov	 BYTE PTR _SINGLE_QUOTE$[ebp], 39 ; 00000027H

; 1396 :     const char DOUBLE_QUOTE = '\"';

  00168	c6 45 f7 22	 mov	 BYTE PTR _DOUBLE_QUOTE$[ebp], 34 ; 00000022H

; 1397 : 
; 1398 :     if ( *p == SINGLE_QUOTE )

  0016c	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0016f	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  00172	83 f9 27	 cmp	 ecx, 39			; 00000027H
  00175	75 37		 jne	 SHORT $LN9@Parse@2

; 1399 :     {
; 1400 :         ++p;

  00177	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0017a	83 c2 01	 add	 edx, 1
  0017d	89 55 08	 mov	 DWORD PTR _p$[ebp], edx

; 1401 :         end = "\'";        // single quote in string

  00180	c7 45 f8 00 00
	00 00		 mov	 DWORD PTR _end$[ebp], OFFSET ??_C@_01GEODFPGF@?8?$AA@

; 1402 :         p = ReadText( p, &value, false, end, false, encoding );

  00187	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  0018a	50		 push	 eax
  0018b	6a 00		 push	 0
  0018d	8b 4d f8	 mov	 ecx, DWORD PTR _end$[ebp]
  00190	51		 push	 ecx
  00191	6a 00		 push	 0
  00193	8b 55 f0	 mov	 edx, DWORD PTR _this$[ebp]
  00196	83 c2 30	 add	 edx, 48			; 00000030H
  00199	52		 push	 edx
  0019a	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0019d	50		 push	 eax
  0019e	e8 00 00 00 00	 call	 ?ReadText@TiXmlBase@@KAPBDPBDPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@_N02W4TiXmlEncoding@@@Z ; TiXmlBase::ReadText
  001a3	83 c4 18	 add	 esp, 24			; 00000018H
  001a6	89 45 08	 mov	 DWORD PTR _p$[ebp], eax
  001a9	e9 0c 01 00 00	 jmp	 $LN8@Parse@2
$LN9@Parse@2:

; 1403 :     }
; 1404 :     else if ( *p == DOUBLE_QUOTE )

  001ae	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  001b1	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  001b4	83 fa 22	 cmp	 edx, 34			; 00000022H
  001b7	75 37		 jne	 SHORT $LN7@Parse@2

; 1405 :     {
; 1406 :         ++p;

  001b9	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  001bc	83 c0 01	 add	 eax, 1
  001bf	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1407 :         end = "\"";        // double quote in string

  001c2	c7 45 f8 00 00
	00 00		 mov	 DWORD PTR _end$[ebp], OFFSET ??_C@_01BJJEKLCA@?$CC?$AA@

; 1408 :         p = ReadText( p, &value, false, end, false, encoding );

  001c9	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  001cc	51		 push	 ecx
  001cd	6a 00		 push	 0
  001cf	8b 55 f8	 mov	 edx, DWORD PTR _end$[ebp]
  001d2	52		 push	 edx
  001d3	6a 00		 push	 0
  001d5	8b 45 f0	 mov	 eax, DWORD PTR _this$[ebp]
  001d8	83 c0 30	 add	 eax, 48			; 00000030H
  001db	50		 push	 eax
  001dc	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  001df	51		 push	 ecx
  001e0	e8 00 00 00 00	 call	 ?ReadText@TiXmlBase@@KAPBDPBDPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@_N02W4TiXmlEncoding@@@Z ; TiXmlBase::ReadText
  001e5	83 c4 18	 add	 esp, 24			; 00000018H
  001e8	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1409 :     }
; 1410 :     else

  001eb	e9 ca 00 00 00	 jmp	 $LN8@Parse@2
$LN7@Parse@2:

; 1411 :     {
; 1412 :         // All attribute values should be in single or double quotes.
; 1413 :         // But this is such a common error that the parser will try
; 1414 :         // its best, even without them.
; 1415 :         value = "";

  001f0	68 00 00 00 00	 push	 OFFSET ??_C@_00CNPNBAHC@?$AA@
  001f5	8b 4d f0	 mov	 ecx, DWORD PTR _this$[ebp]
  001f8	83 c1 30	 add	 ecx, 48			; 00000030H
  001fb	e8 00 00 00 00	 call	 ??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@PBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=
$LN5@Parse@2:

; 1416 :         while (    p && *p                                            // existence
; 1417 :                 && !IsWhiteSpace( *p ) && *p != '\n' && *p != '\r'    // whitespace
; 1418 :                 && *p != '/' && *p != '>' )                            // tag end

  00200	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00204	0f 84 b0 00 00
	00		 je	 $LN8@Parse@2
  0020a	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0020d	0f be 02	 movsx	 eax, BYTE PTR [edx]
  00210	85 c0		 test	 eax, eax
  00212	0f 84 a2 00 00
	00		 je	 $LN8@Parse@2
  00218	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0021b	0f b6 11	 movzx	 edx, BYTE PTR [ecx]
  0021e	52		 push	 edx
  0021f	e8 00 00 00 00	 call	 ?IsWhiteSpace@TiXmlBase@@KA_ND@Z ; TiXmlBase::IsWhiteSpace
  00224	83 c4 04	 add	 esp, 4
  00227	0f b6 c0	 movzx	 eax, al
  0022a	85 c0		 test	 eax, eax
  0022c	0f 85 88 00 00
	00		 jne	 $LN8@Parse@2
  00232	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00235	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  00238	83 fa 0a	 cmp	 edx, 10			; 0000000aH
  0023b	74 7d		 je	 SHORT $LN8@Parse@2
  0023d	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00240	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  00243	83 f9 0d	 cmp	 ecx, 13			; 0000000dH
  00246	74 72		 je	 SHORT $LN8@Parse@2
  00248	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0024b	0f be 02	 movsx	 eax, BYTE PTR [edx]
  0024e	83 f8 2f	 cmp	 eax, 47			; 0000002fH
  00251	74 67		 je	 SHORT $LN8@Parse@2
  00253	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00256	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  00259	83 fa 3e	 cmp	 edx, 62			; 0000003eH
  0025c	74 5c		 je	 SHORT $LN8@Parse@2

; 1419 :         {
; 1420 :             if ( *p == SINGLE_QUOTE || *p == DOUBLE_QUOTE ) {

  0025e	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00261	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  00264	83 f9 27	 cmp	 ecx, 39			; 00000027H
  00267	74 0b		 je	 SHORT $LN2@Parse@2
  00269	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0026c	0f be 02	 movsx	 eax, BYTE PTR [edx]
  0026f	83 f8 22	 cmp	 eax, 34			; 00000022H
  00272	75 26		 jne	 SHORT $LN3@Parse@2
$LN2@Parse@2:

; 1421 :                 // [ 1451649 ] Attribute values with trailing quotes not handled correctly
; 1422 :                 // We did not have an opening quote but seem to have a
; 1423 :                 // closing one. Give up and throw an error.
; 1424 :                 if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, p, data, encoding );

  00274	8b 4d f0	 mov	 ecx, DWORD PTR _this$[ebp]
  00277	83 79 10 00	 cmp	 DWORD PTR [ecx+16], 0
  0027b	74 19		 je	 SHORT $LN1@Parse@2
  0027d	8b 55 10	 mov	 edx, DWORD PTR _encoding$[ebp]
  00280	52		 push	 edx
  00281	8b 45 0c	 mov	 eax, DWORD PTR _data$[ebp]
  00284	50		 push	 eax
  00285	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00288	51		 push	 ecx
  00289	6a 07		 push	 7
  0028b	8b 55 f0	 mov	 edx, DWORD PTR _this$[ebp]
  0028e	8b 4a 10	 mov	 ecx, DWORD PTR [edx+16]
  00291	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN1@Parse@2:

; 1425 :                 return 0;

  00296	33 c0		 xor	 eax, eax
  00298	eb 23		 jmp	 SHORT $LN22@Parse@2
$LN3@Parse@2:

; 1426 :             }
; 1427 :             value += *p;

  0029a	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0029d	0f b6 08	 movzx	 ecx, BYTE PTR [eax]
  002a0	51		 push	 ecx
  002a1	8b 4d f0	 mov	 ecx, DWORD PTR _this$[ebp]
  002a4	83 c1 30	 add	 ecx, 48			; 00000030H
  002a7	e8 00 00 00 00	 call	 ??Y?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@D@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator+=

; 1428 :             ++p;

  002ac	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  002af	83 c2 01	 add	 edx, 1
  002b2	89 55 08	 mov	 DWORD PTR _p$[ebp], edx

; 1429 :         }

  002b5	e9 46 ff ff ff	 jmp	 $LN5@Parse@2
$LN8@Parse@2:

; 1430 :     }
; 1431 :     return p;

  002ba	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
$LN22@Parse@2:

; 1432 : }

  002bd	8b e5		 mov	 esp, ebp
  002bf	5d		 pop	 ebp
  002c0	c2 0c 00	 ret	 12			; 0000000cH
?Parse@TiXmlAttribute@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ENDP ; TiXmlAttribute::Parse
; Function compile flags: /Odtp
_TEXT	ENDS
;	COMDAT ?Parse@TiXmlComment@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
_TEXT	SEGMENT
_this$ = -16						; size = 4
_startTag$ = -12					; size = 4
_endTag$ = -8						; size = 4
_document$ = -4						; size = 4
_p$ = 8							; size = 4
_data$ = 12						; size = 4
_encoding$ = 16						; size = 4
?Parse@TiXmlComment@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z PROC ; TiXmlComment::Parse, COMDAT
; _this$ = ecx

; 1332 : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 10	 sub	 esp, 16			; 00000010H
  00006	89 4d f0	 mov	 DWORD PTR _this$[ebp], ecx

; 1333 :     TiXmlDocument* document = GetDocument();

  00009	8b 4d f0	 mov	 ecx, DWORD PTR _this$[ebp]
  0000c	e8 00 00 00 00	 call	 ?GetDocument@TiXmlNode@@QAEPAVTiXmlDocument@@XZ ; TiXmlNode::GetDocument
  00011	89 45 fc	 mov	 DWORD PTR _document$[ebp], eax

; 1334 :     value = "";

  00014	68 00 00 00 00	 push	 OFFSET ??_C@_00CNPNBAHC@?$AA@
  00019	8b 4d f0	 mov	 ecx, DWORD PTR _this$[ebp]
  0001c	83 c1 20	 add	 ecx, 32			; 00000020H
  0001f	e8 00 00 00 00	 call	 ??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@PBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=

; 1335 : 
; 1336 :     p = SkipWhiteSpace( p, encoding );

  00024	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  00027	50		 push	 eax
  00028	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0002b	51		 push	 ecx
  0002c	e8 00 00 00 00	 call	 ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
  00031	83 c4 08	 add	 esp, 8
  00034	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1337 : 
; 1338 :     if ( data )

  00037	83 7d 0c 00	 cmp	 DWORD PTR _data$[ebp], 0
  0003b	74 26		 je	 SHORT $LN2@Parse@3

; 1339 :     {
; 1340 :         data->Stamp( p, encoding );

  0003d	8b 55 10	 mov	 edx, DWORD PTR _encoding$[ebp]
  00040	52		 push	 edx
  00041	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00044	50		 push	 eax
  00045	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  00048	e8 00 00 00 00	 call	 ?Stamp@TiXmlParsingData@@QAEXPBDW4TiXmlEncoding@@@Z ; TiXmlParsingData::Stamp

; 1341 :         location = data->Cursor();

  0004d	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  00050	e8 00 00 00 00	 call	 ?Cursor@TiXmlParsingData@@QAEABUTiXmlCursor@@XZ ; TiXmlParsingData::Cursor
  00055	8b 08		 mov	 ecx, DWORD PTR [eax]
  00057	8b 50 04	 mov	 edx, DWORD PTR [eax+4]
  0005a	8b 45 f0	 mov	 eax, DWORD PTR _this$[ebp]
  0005d	89 48 04	 mov	 DWORD PTR [eax+4], ecx
  00060	89 50 08	 mov	 DWORD PTR [eax+8], edx
$LN2@Parse@3:

; 1342 :     }
; 1343 :     const char* startTag = "<!--";

  00063	c7 45 f4 00 00
	00 00		 mov	 DWORD PTR _startTag$[ebp], OFFSET ??_C@_04FFDNBKGC@?$DM?$CB?9?9?$AA@

; 1344 :     const char* endTag   = "-->";

  0006a	c7 45 f8 00 00
	00 00		 mov	 DWORD PTR _endTag$[ebp], OFFSET ??_C@_03PNLDJJMO@?9?9?$DO?$AA@

; 1345 : 
; 1346 :     if ( !StringEqual( p, startTag, false, encoding ) )

  00071	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  00074	51		 push	 ecx
  00075	6a 00		 push	 0
  00077	8b 55 f4	 mov	 edx, DWORD PTR _startTag$[ebp]
  0007a	52		 push	 edx
  0007b	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0007e	50		 push	 eax
  0007f	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  00084	83 c4 10	 add	 esp, 16			; 00000010H
  00087	0f b6 c8	 movzx	 ecx, al
  0008a	85 c9		 test	 ecx, ecx
  0008c	75 1a		 jne	 SHORT $LN1@Parse@3

; 1347 :     {
; 1348 :         document->SetError( TIXML_ERROR_PARSING_COMMENT, p, data, encoding );

  0008e	8b 55 10	 mov	 edx, DWORD PTR _encoding$[ebp]
  00091	52		 push	 edx
  00092	8b 45 0c	 mov	 eax, DWORD PTR _data$[ebp]
  00095	50		 push	 eax
  00096	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00099	51		 push	 ecx
  0009a	6a 0b		 push	 11			; 0000000bH
  0009c	8b 4d fc	 mov	 ecx, DWORD PTR _document$[ebp]
  0009f	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError

; 1349 :         return 0;

  000a4	33 c0		 xor	 eax, eax
  000a6	eb 37		 jmp	 SHORT $LN3@Parse@3
$LN1@Parse@3:

; 1350 :     }
; 1351 :     p += strlen( startTag );

  000a8	8b 55 f4	 mov	 edx, DWORD PTR _startTag$[ebp]
  000ab	52		 push	 edx
  000ac	e8 00 00 00 00	 call	 _strlen
  000b1	83 c4 04	 add	 esp, 4
  000b4	03 45 08	 add	 eax, DWORD PTR _p$[ebp]
  000b7	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1352 :     p = ReadText( p, &value, false, endTag, false, encoding );

  000ba	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  000bd	50		 push	 eax
  000be	6a 00		 push	 0
  000c0	8b 4d f8	 mov	 ecx, DWORD PTR _endTag$[ebp]
  000c3	51		 push	 ecx
  000c4	6a 00		 push	 0
  000c6	8b 55 f0	 mov	 edx, DWORD PTR _this$[ebp]
  000c9	83 c2 20	 add	 edx, 32			; 00000020H
  000cc	52		 push	 edx
  000cd	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  000d0	50		 push	 eax
  000d1	e8 00 00 00 00	 call	 ?ReadText@TiXmlBase@@KAPBDPBDPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@_N02W4TiXmlEncoding@@@Z ; TiXmlBase::ReadText
  000d6	83 c4 18	 add	 esp, 24			; 00000018H
  000d9	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1353 :     return p;

  000dc	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
$LN3@Parse@3:

; 1354 : }

  000df	8b e5		 mov	 esp, ebp
  000e1	5d		 pop	 ebp
  000e2	c2 0c 00	 ret	 12			; 0000000cH
?Parse@TiXmlComment@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ENDP ; TiXmlComment::Parse
; Function compile flags: /Odtp
_TEXT	ENDS
;	COMDAT ?Parse@TiXmlUnknown@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
_TEXT	SEGMENT
_this$ = -8						; size = 4
_document$ = -4						; size = 4
_p$ = 8							; size = 4
_data$ = 12						; size = 4
_encoding$ = 16						; size = 4
?Parse@TiXmlUnknown@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z PROC ; TiXmlUnknown::Parse, COMDAT
; _this$ = ecx

; 1271 : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 08	 sub	 esp, 8
  00006	89 4d f8	 mov	 DWORD PTR _this$[ebp], ecx

; 1272 :     TiXmlDocument* document = GetDocument();

  00009	8b 4d f8	 mov	 ecx, DWORD PTR _this$[ebp]
  0000c	e8 00 00 00 00	 call	 ?GetDocument@TiXmlNode@@QAEPAVTiXmlDocument@@XZ ; TiXmlNode::GetDocument
  00011	89 45 fc	 mov	 DWORD PTR _document$[ebp], eax

; 1273 :     p = SkipWhiteSpace( p, encoding );

  00014	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  00017	50		 push	 eax
  00018	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0001b	51		 push	 ecx
  0001c	e8 00 00 00 00	 call	 ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
  00021	83 c4 08	 add	 esp, 8
  00024	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1274 : 
; 1275 :     if ( data )

  00027	83 7d 0c 00	 cmp	 DWORD PTR _data$[ebp], 0
  0002b	74 26		 je	 SHORT $LN9@Parse@4

; 1276 :     {
; 1277 :         data->Stamp( p, encoding );

  0002d	8b 55 10	 mov	 edx, DWORD PTR _encoding$[ebp]
  00030	52		 push	 edx
  00031	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00034	50		 push	 eax
  00035	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  00038	e8 00 00 00 00	 call	 ?Stamp@TiXmlParsingData@@QAEXPBDW4TiXmlEncoding@@@Z ; TiXmlParsingData::Stamp

; 1278 :         location = data->Cursor();

  0003d	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  00040	e8 00 00 00 00	 call	 ?Cursor@TiXmlParsingData@@QAEABUTiXmlCursor@@XZ ; TiXmlParsingData::Cursor
  00045	8b 08		 mov	 ecx, DWORD PTR [eax]
  00047	8b 50 04	 mov	 edx, DWORD PTR [eax+4]
  0004a	8b 45 f8	 mov	 eax, DWORD PTR _this$[ebp]
  0004d	89 48 04	 mov	 DWORD PTR [eax+4], ecx
  00050	89 50 08	 mov	 DWORD PTR [eax+8], edx
$LN9@Parse@4:

; 1279 :     }
; 1280 :     if ( !p || !*p || *p != '<' )

  00053	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00057	74 15		 je	 SHORT $LN7@Parse@4
  00059	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0005c	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  0005f	85 d2		 test	 edx, edx
  00061	74 0b		 je	 SHORT $LN7@Parse@4
  00063	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00066	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  00069	83 f9 3c	 cmp	 ecx, 60			; 0000003cH
  0006c	74 23		 je	 SHORT $LN8@Parse@4
$LN7@Parse@4:

; 1281 :     {
; 1282 :         if ( document ) document->SetError( TIXML_ERROR_PARSING_UNKNOWN, p, data, encoding );

  0006e	83 7d fc 00	 cmp	 DWORD PTR _document$[ebp], 0
  00072	74 16		 je	 SHORT $LN6@Parse@4
  00074	8b 55 10	 mov	 edx, DWORD PTR _encoding$[ebp]
  00077	52		 push	 edx
  00078	8b 45 0c	 mov	 eax, DWORD PTR _data$[ebp]
  0007b	50		 push	 eax
  0007c	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0007f	51		 push	 ecx
  00080	6a 0a		 push	 10			; 0000000aH
  00082	8b 4d fc	 mov	 ecx, DWORD PTR _document$[ebp]
  00085	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN6@Parse@4:

; 1283 :         return 0;

  0008a	33 c0		 xor	 eax, eax
  0008c	e9 85 00 00 00	 jmp	 $LN10@Parse@4
$LN8@Parse@4:

; 1284 :     }
; 1285 :     ++p;

  00091	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00094	83 c2 01	 add	 edx, 1
  00097	89 55 08	 mov	 DWORD PTR _p$[ebp], edx

; 1286 :     value = "";

  0009a	68 00 00 00 00	 push	 OFFSET ??_C@_00CNPNBAHC@?$AA@
  0009f	8b 4d f8	 mov	 ecx, DWORD PTR _this$[ebp]
  000a2	83 c1 20	 add	 ecx, 32			; 00000020H
  000a5	e8 00 00 00 00	 call	 ??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@PBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=
$LN5@Parse@4:

; 1287 : 
; 1288 :     while ( p && *p && *p != '>' )

  000aa	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  000ae	74 32		 je	 SHORT $LN4@Parse@4
  000b0	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  000b3	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  000b6	85 c9		 test	 ecx, ecx
  000b8	74 28		 je	 SHORT $LN4@Parse@4
  000ba	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  000bd	0f be 02	 movsx	 eax, BYTE PTR [edx]
  000c0	83 f8 3e	 cmp	 eax, 62			; 0000003eH
  000c3	74 1d		 je	 SHORT $LN4@Parse@4

; 1289 :     {
; 1290 :         value += *p;

  000c5	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  000c8	0f b6 11	 movzx	 edx, BYTE PTR [ecx]
  000cb	52		 push	 edx
  000cc	8b 4d f8	 mov	 ecx, DWORD PTR _this$[ebp]
  000cf	83 c1 20	 add	 ecx, 32			; 00000020H
  000d2	e8 00 00 00 00	 call	 ??Y?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@D@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator+=

; 1291 :         ++p;

  000d7	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  000da	83 c0 01	 add	 eax, 1
  000dd	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1292 :     }

  000e0	eb c8		 jmp	 SHORT $LN5@Parse@4
$LN4@Parse@4:

; 1293 : 
; 1294 :     if ( !p )

  000e2	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  000e6	75 18		 jne	 SHORT $LN3@Parse@4

; 1295 :     {
; 1296 :         if ( document )    document->SetError( TIXML_ERROR_PARSING_UNKNOWN, 0, 0, encoding );

  000e8	83 7d fc 00	 cmp	 DWORD PTR _document$[ebp], 0
  000ec	74 12		 je	 SHORT $LN3@Parse@4
  000ee	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  000f1	51		 push	 ecx
  000f2	6a 00		 push	 0
  000f4	6a 00		 push	 0
  000f6	6a 0a		 push	 10			; 0000000aH
  000f8	8b 4d fc	 mov	 ecx, DWORD PTR _document$[ebp]
  000fb	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN3@Parse@4:

; 1297 :     }
; 1298 :     if ( *p == '>' )

  00100	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00103	0f be 02	 movsx	 eax, BYTE PTR [edx]
  00106	83 f8 3e	 cmp	 eax, 62			; 0000003eH
  00109	75 08		 jne	 SHORT $LN1@Parse@4

; 1299 :         return p+1;

  0010b	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0010e	83 c0 01	 add	 eax, 1
  00111	eb 03		 jmp	 SHORT $LN10@Parse@4
$LN1@Parse@4:

; 1300 :     return p;

  00113	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
$LN10@Parse@4:

; 1301 : }

  00116	8b e5		 mov	 esp, ebp
  00118	5d		 pop	 ebp
  00119	c2 0c 00	 ret	 12			; 0000000cH
?Parse@TiXmlUnknown@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ENDP ; TiXmlUnknown::Parse
PUBLIC	__$ArrayPad$
;	COMDAT xdata$x
xdata$x	SEGMENT
__unwindtable$?Parse@TiXmlDeclaration@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z DD 0ffffffffH
	DD	FLAT:__unwindfunclet$?Parse@TiXmlDeclaration@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z$0
	DD	0ffffffffH
	DD	FLAT:__unwindfunclet$?Parse@TiXmlDeclaration@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z$1
	DD	0ffffffffH
	DD	FLAT:__unwindfunclet$?Parse@TiXmlDeclaration@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z$2
__ehfuncinfo$?Parse@TiXmlDeclaration@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z DD 019930522H
	DD	03H
	DD	FLAT:__unwindtable$?Parse@TiXmlDeclaration@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
	DD	2 DUP(00H)
	DD	2 DUP(00H)
	DD	00H
	DD	00H
; Function compile flags: /Odtp
xdata$x	ENDS
;	COMDAT ?Parse@TiXmlDeclaration@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
_TEXT	SEGMENT
_this$ = -288						; size = 4
_attrib$21730 = -284					; size = 84
_attrib$21726 = -196					; size = 84
_attrib$21722 = -108					; size = 84
__$ArrayPad$ = -20					; size = 4
_document$ = -16					; size = 4
__$EHRec$ = -12						; size = 12
_p$ = 8							; size = 4
_data$ = 12						; size = 4
__encoding$ = 16					; size = 4
?Parse@TiXmlDeclaration@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z PROC ; TiXmlDeclaration::Parse, COMDAT
; _this$ = ecx

; 1541 : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	6a ff		 push	 -1
  00005	68 00 00 00 00	 push	 __ehhandler$?Parse@TiXmlDeclaration@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
  0000a	64 a1 00 00 00
	00		 mov	 eax, DWORD PTR fs:0
  00010	50		 push	 eax
  00011	81 ec 14 01 00
	00		 sub	 esp, 276		; 00000114H
  00017	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  0001c	33 c5		 xor	 eax, ebp
  0001e	89 45 ec	 mov	 DWORD PTR __$ArrayPad$[ebp], eax
  00021	50		 push	 eax
  00022	8d 45 f4	 lea	 eax, DWORD PTR __$EHRec$[ebp]
  00025	64 a3 00 00 00
	00		 mov	 DWORD PTR fs:0, eax
  0002b	89 8d e0 fe ff
	ff		 mov	 DWORD PTR _this$[ebp], ecx

; 1542 :     p = SkipWhiteSpace( p, _encoding );

  00031	8b 45 10	 mov	 eax, DWORD PTR __encoding$[ebp]
  00034	50		 push	 eax
  00035	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00038	51		 push	 ecx
  00039	e8 00 00 00 00	 call	 ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
  0003e	83 c4 08	 add	 esp, 8
  00041	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1543 :     // Find the beginning, find the end, and look for
; 1544 :     // the stuff in-between.
; 1545 :     TiXmlDocument* document = GetDocument();

  00044	8b 8d e0 fe ff
	ff		 mov	 ecx, DWORD PTR _this$[ebp]
  0004a	e8 00 00 00 00	 call	 ?GetDocument@TiXmlNode@@QAEPAVTiXmlDocument@@XZ ; TiXmlNode::GetDocument
  0004f	89 45 f0	 mov	 DWORD PTR _document$[ebp], eax

; 1546 :     if ( !p || !*p || !StringEqual( p, "<?xml", true, _encoding ) )

  00052	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00056	74 28		 je	 SHORT $LN14@Parse@5
  00058	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0005b	0f be 02	 movsx	 eax, BYTE PTR [edx]
  0005e	85 c0		 test	 eax, eax
  00060	74 1e		 je	 SHORT $LN14@Parse@5
  00062	8b 4d 10	 mov	 ecx, DWORD PTR __encoding$[ebp]
  00065	51		 push	 ecx
  00066	6a 01		 push	 1
  00068	68 00 00 00 00	 push	 OFFSET ??_C@_05DJDIECHG@?$DM?$DPxml?$AA@
  0006d	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00070	52		 push	 edx
  00071	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  00076	83 c4 10	 add	 esp, 16			; 00000010H
  00079	0f b6 c0	 movzx	 eax, al
  0007c	85 c0		 test	 eax, eax
  0007e	75 1f		 jne	 SHORT $LN15@Parse@5
$LN14@Parse@5:

; 1547 :     {
; 1548 :         if ( document ) document->SetError( TIXML_ERROR_PARSING_DECLARATION, 0, 0, _encoding );

  00080	83 7d f0 00	 cmp	 DWORD PTR _document$[ebp], 0
  00084	74 12		 je	 SHORT $LN13@Parse@5
  00086	8b 4d 10	 mov	 ecx, DWORD PTR __encoding$[ebp]
  00089	51		 push	 ecx
  0008a	6a 00		 push	 0
  0008c	6a 00		 push	 0
  0008e	6a 0c		 push	 12			; 0000000cH
  00090	8b 4d f0	 mov	 ecx, DWORD PTR _document$[ebp]
  00093	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN13@Parse@5:

; 1549 :         return 0;

  00098	33 c0		 xor	 eax, eax
  0009a	e9 5d 02 00 00	 jmp	 $LN16@Parse@5
$LN15@Parse@5:

; 1550 :     }
; 1551 :     if ( data )

  0009f	83 7d 0c 00	 cmp	 DWORD PTR _data$[ebp], 0
  000a3	74 29		 je	 SHORT $LN12@Parse@5

; 1552 :     {
; 1553 :         data->Stamp( p, _encoding );

  000a5	8b 55 10	 mov	 edx, DWORD PTR __encoding$[ebp]
  000a8	52		 push	 edx
  000a9	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  000ac	50		 push	 eax
  000ad	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  000b0	e8 00 00 00 00	 call	 ?Stamp@TiXmlParsingData@@QAEXPBDW4TiXmlEncoding@@@Z ; TiXmlParsingData::Stamp

; 1554 :         location = data->Cursor();

  000b5	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  000b8	e8 00 00 00 00	 call	 ?Cursor@TiXmlParsingData@@QAEABUTiXmlCursor@@XZ ; TiXmlParsingData::Cursor
  000bd	8b 08		 mov	 ecx, DWORD PTR [eax]
  000bf	8b 50 04	 mov	 edx, DWORD PTR [eax+4]
  000c2	8b 85 e0 fe ff
	ff		 mov	 eax, DWORD PTR _this$[ebp]
  000c8	89 48 04	 mov	 DWORD PTR [eax+4], ecx
  000cb	89 50 08	 mov	 DWORD PTR [eax+8], edx
$LN12@Parse@5:

; 1555 :     }
; 1556 :     p += 5;

  000ce	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  000d1	83 c1 05	 add	 ecx, 5
  000d4	89 4d 08	 mov	 DWORD PTR _p$[ebp], ecx

; 1557 : 
; 1558 :     version = "";

  000d7	68 00 00 00 00	 push	 OFFSET ??_C@_00CNPNBAHC@?$AA@
  000dc	8b 8d e0 fe ff
	ff		 mov	 ecx, DWORD PTR _this$[ebp]
  000e2	83 c1 44	 add	 ecx, 68			; 00000044H
  000e5	e8 00 00 00 00	 call	 ??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@PBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=

; 1559 :     encoding = "";

  000ea	68 00 00 00 00	 push	 OFFSET ??_C@_00CNPNBAHC@?$AA@
  000ef	8b 8d e0 fe ff
	ff		 mov	 ecx, DWORD PTR _this$[ebp]
  000f5	83 c1 60	 add	 ecx, 96			; 00000060H
  000f8	e8 00 00 00 00	 call	 ??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@PBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=

; 1560 :     standalone = "";

  000fd	68 00 00 00 00	 push	 OFFSET ??_C@_00CNPNBAHC@?$AA@
  00102	8b 8d e0 fe ff
	ff		 mov	 ecx, DWORD PTR _this$[ebp]
  00108	83 c1 7c	 add	 ecx, 124		; 0000007cH
  0010b	e8 00 00 00 00	 call	 ??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@PBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=
$LN11@Parse@5:

; 1561 : 
; 1562 :     while ( p && *p )

  00110	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00114	0f 84 e0 01 00
	00		 je	 $LN10@Parse@5
  0011a	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0011d	0f be 02	 movsx	 eax, BYTE PTR [edx]
  00120	85 c0		 test	 eax, eax
  00122	0f 84 d2 01 00
	00		 je	 $LN10@Parse@5

; 1563 :     {
; 1564 :         if ( *p == '>' )

  00128	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0012b	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  0012e	83 fa 3e	 cmp	 edx, 62			; 0000003eH
  00131	75 11		 jne	 SHORT $LN9@Parse@5

; 1565 :         {
; 1566 :             ++p;

  00133	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00136	83 c0 01	 add	 eax, 1
  00139	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1567 :             return p;

  0013c	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0013f	e9 b8 01 00 00	 jmp	 $LN16@Parse@5
$LN9@Parse@5:

; 1568 :         }
; 1569 : 
; 1570 :         p = SkipWhiteSpace( p, _encoding );

  00144	8b 4d 10	 mov	 ecx, DWORD PTR __encoding$[ebp]
  00147	51		 push	 ecx
  00148	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0014b	52		 push	 edx
  0014c	e8 00 00 00 00	 call	 ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
  00151	83 c4 08	 add	 esp, 8
  00154	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1571 :         if ( StringEqual( p, "version", true, _encoding ) )

  00157	8b 45 10	 mov	 eax, DWORD PTR __encoding$[ebp]
  0015a	50		 push	 eax
  0015b	6a 01		 push	 1
  0015d	68 00 00 00 00	 push	 OFFSET ??_C@_07CPCPJPKL@version?$AA@
  00162	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00165	51		 push	 ecx
  00166	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  0016b	83 c4 10	 add	 esp, 16			; 00000010H
  0016e	0f b6 d0	 movzx	 edx, al
  00171	85 d2		 test	 edx, edx
  00173	74 51		 je	 SHORT $LN8@Parse@5

; 1572 :         {
; 1573 :             TiXmlAttribute attrib;

  00175	8d 4d 94	 lea	 ecx, DWORD PTR _attrib$21722[ebp]
  00178	e8 00 00 00 00	 call	 ??0TiXmlAttribute@@QAE@XZ ; TiXmlAttribute::TiXmlAttribute
  0017d	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+8], 0

; 1574 :             p = attrib.Parse( p, data, _encoding );

  00184	8b 45 10	 mov	 eax, DWORD PTR __encoding$[ebp]
  00187	50		 push	 eax
  00188	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  0018b	51		 push	 ecx
  0018c	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0018f	52		 push	 edx
  00190	8d 4d 94	 lea	 ecx, DWORD PTR _attrib$21722[ebp]
  00193	e8 00 00 00 00	 call	 ?Parse@TiXmlAttribute@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlAttribute::Parse
  00198	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1575 :             version = attrib.Value();

  0019b	8d 4d 94	 lea	 ecx, DWORD PTR _attrib$21722[ebp]
  0019e	e8 00 00 00 00	 call	 ?Value@TiXmlAttribute@@QBEPBDXZ ; TiXmlAttribute::Value
  001a3	50		 push	 eax
  001a4	8b 8d e0 fe ff
	ff		 mov	 ecx, DWORD PTR _this$[ebp]
  001aa	83 c1 44	 add	 ecx, 68			; 00000044H
  001ad	e8 00 00 00 00	 call	 ??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@PBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=

; 1576 :         }

  001b2	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  001b9	8d 4d 94	 lea	 ecx, DWORD PTR _attrib$21722[ebp]
  001bc	e8 00 00 00 00	 call	 ??1TiXmlAttribute@@UAE@XZ
  001c1	e9 2f 01 00 00	 jmp	 $LN7@Parse@5
$LN8@Parse@5:

; 1577 :         else if ( StringEqual( p, "encoding", true, _encoding ) )

  001c6	8b 45 10	 mov	 eax, DWORD PTR __encoding$[ebp]
  001c9	50		 push	 eax
  001ca	6a 01		 push	 1
  001cc	68 00 00 00 00	 push	 OFFSET ??_C@_08MLPGAEIK@encoding?$AA@
  001d1	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  001d4	51		 push	 ecx
  001d5	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  001da	83 c4 10	 add	 esp, 16			; 00000010H
  001dd	0f b6 d0	 movzx	 edx, al
  001e0	85 d2		 test	 edx, edx
  001e2	74 5d		 je	 SHORT $LN6@Parse@5

; 1578 :         {
; 1579 :             TiXmlAttribute attrib;

  001e4	8d 8d 3c ff ff
	ff		 lea	 ecx, DWORD PTR _attrib$21726[ebp]
  001ea	e8 00 00 00 00	 call	 ??0TiXmlAttribute@@QAE@XZ ; TiXmlAttribute::TiXmlAttribute
  001ef	c7 45 fc 01 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+8], 1

; 1580 :             p = attrib.Parse( p, data, _encoding );

  001f6	8b 45 10	 mov	 eax, DWORD PTR __encoding$[ebp]
  001f9	50		 push	 eax
  001fa	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  001fd	51		 push	 ecx
  001fe	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00201	52		 push	 edx
  00202	8d 8d 3c ff ff
	ff		 lea	 ecx, DWORD PTR _attrib$21726[ebp]
  00208	e8 00 00 00 00	 call	 ?Parse@TiXmlAttribute@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlAttribute::Parse
  0020d	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1581 :             encoding = attrib.Value();

  00210	8d 8d 3c ff ff
	ff		 lea	 ecx, DWORD PTR _attrib$21726[ebp]
  00216	e8 00 00 00 00	 call	 ?Value@TiXmlAttribute@@QBEPBDXZ ; TiXmlAttribute::Value
  0021b	50		 push	 eax
  0021c	8b 8d e0 fe ff
	ff		 mov	 ecx, DWORD PTR _this$[ebp]
  00222	83 c1 60	 add	 ecx, 96			; 00000060H
  00225	e8 00 00 00 00	 call	 ??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@PBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=

; 1582 :         }

  0022a	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  00231	8d 8d 3c ff ff
	ff		 lea	 ecx, DWORD PTR _attrib$21726[ebp]
  00237	e8 00 00 00 00	 call	 ??1TiXmlAttribute@@UAE@XZ
  0023c	e9 b4 00 00 00	 jmp	 $LN7@Parse@5
$LN6@Parse@5:

; 1583 :         else if ( StringEqual( p, "standalone", true, _encoding ) )

  00241	8b 45 10	 mov	 eax, DWORD PTR __encoding$[ebp]
  00244	50		 push	 eax
  00245	6a 01		 push	 1
  00247	68 00 00 00 00	 push	 OFFSET ??_C@_0L@FLHGMILF@standalone?$AA@
  0024c	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0024f	51		 push	 ecx
  00250	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  00255	83 c4 10	 add	 esp, 16			; 00000010H
  00258	0f b6 d0	 movzx	 edx, al
  0025b	85 d2		 test	 edx, edx
  0025d	74 5a		 je	 SHORT $LN2@Parse@5

; 1584 :         {
; 1585 :             TiXmlAttribute attrib;

  0025f	8d 8d e4 fe ff
	ff		 lea	 ecx, DWORD PTR _attrib$21730[ebp]
  00265	e8 00 00 00 00	 call	 ??0TiXmlAttribute@@QAE@XZ ; TiXmlAttribute::TiXmlAttribute
  0026a	c7 45 fc 02 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+8], 2

; 1586 :             p = attrib.Parse( p, data, _encoding );

  00271	8b 45 10	 mov	 eax, DWORD PTR __encoding$[ebp]
  00274	50		 push	 eax
  00275	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  00278	51		 push	 ecx
  00279	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0027c	52		 push	 edx
  0027d	8d 8d e4 fe ff
	ff		 lea	 ecx, DWORD PTR _attrib$21730[ebp]
  00283	e8 00 00 00 00	 call	 ?Parse@TiXmlAttribute@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlAttribute::Parse
  00288	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1587 :             standalone = attrib.Value();

  0028b	8d 8d e4 fe ff
	ff		 lea	 ecx, DWORD PTR _attrib$21730[ebp]
  00291	e8 00 00 00 00	 call	 ?Value@TiXmlAttribute@@QBEPBDXZ ; TiXmlAttribute::Value
  00296	50		 push	 eax
  00297	8b 8d e0 fe ff
	ff		 mov	 ecx, DWORD PTR _this$[ebp]
  0029d	83 c1 7c	 add	 ecx, 124		; 0000007cH
  002a0	e8 00 00 00 00	 call	 ??4?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@PBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator=

; 1588 :         }

  002a5	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  002ac	8d 8d e4 fe ff
	ff		 lea	 ecx, DWORD PTR _attrib$21730[ebp]
  002b2	e8 00 00 00 00	 call	 ??1TiXmlAttribute@@UAE@XZ

; 1589 :         else

  002b7	eb 3c		 jmp	 SHORT $LN7@Parse@5
$LN2@Parse@5:

; 1590 :         {
; 1591 :             // Read over whatever it is.
; 1592 :             while( p && *p && *p != '>' && !IsWhiteSpace( *p ) )

  002b9	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  002bd	74 36		 je	 SHORT $LN7@Parse@5
  002bf	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  002c2	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  002c5	85 c9		 test	 ecx, ecx
  002c7	74 2c		 je	 SHORT $LN7@Parse@5
  002c9	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  002cc	0f be 02	 movsx	 eax, BYTE PTR [edx]
  002cf	83 f8 3e	 cmp	 eax, 62			; 0000003eH
  002d2	74 21		 je	 SHORT $LN7@Parse@5
  002d4	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  002d7	0f b6 11	 movzx	 edx, BYTE PTR [ecx]
  002da	52		 push	 edx
  002db	e8 00 00 00 00	 call	 ?IsWhiteSpace@TiXmlBase@@KA_ND@Z ; TiXmlBase::IsWhiteSpace
  002e0	83 c4 04	 add	 esp, 4
  002e3	0f b6 c0	 movzx	 eax, al
  002e6	85 c0		 test	 eax, eax
  002e8	75 0b		 jne	 SHORT $LN7@Parse@5

; 1593 :                 ++p;

  002ea	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  002ed	83 c1 01	 add	 ecx, 1
  002f0	89 4d 08	 mov	 DWORD PTR _p$[ebp], ecx
  002f3	eb c4		 jmp	 SHORT $LN2@Parse@5
$LN7@Parse@5:

; 1594 :         }
; 1595 :     }

  002f5	e9 16 fe ff ff	 jmp	 $LN11@Parse@5
$LN10@Parse@5:

; 1596 :     return 0;

  002fa	33 c0		 xor	 eax, eax
$LN16@Parse@5:

; 1597 : }

  002fc	8b 4d f4	 mov	 ecx, DWORD PTR __$EHRec$[ebp]
  002ff	64 89 0d 00 00
	00 00		 mov	 DWORD PTR fs:0, ecx
  00306	59		 pop	 ecx
  00307	8b 4d ec	 mov	 ecx, DWORD PTR __$ArrayPad$[ebp]
  0030a	33 cd		 xor	 ecx, ebp
  0030c	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00311	8b e5		 mov	 esp, ebp
  00313	5d		 pop	 ebp
  00314	c2 0c 00	 ret	 12			; 0000000cH
_TEXT	ENDS
;	COMDAT text$x
text$x	SEGMENT
__unwindfunclet$?Parse@TiXmlDeclaration@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z$0:
  00000	8d 4d 94	 lea	 ecx, DWORD PTR _attrib$21722[ebp]
  00003	e9 00 00 00 00	 jmp	 ??1TiXmlAttribute@@UAE@XZ
__unwindfunclet$?Parse@TiXmlDeclaration@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z$1:
  00008	8d 8d 3c ff ff
	ff		 lea	 ecx, DWORD PTR _attrib$21726[ebp]
  0000e	e9 00 00 00 00	 jmp	 ??1TiXmlAttribute@@UAE@XZ
__unwindfunclet$?Parse@TiXmlDeclaration@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z$2:
  00013	8d 8d e4 fe ff
	ff		 lea	 ecx, DWORD PTR _attrib$21730[ebp]
  00019	e9 00 00 00 00	 jmp	 ??1TiXmlAttribute@@UAE@XZ
__ehhandler$?Parse@TiXmlDeclaration@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z:
  0001e	8b 54 24 08	 mov	 edx, DWORD PTR [esp+8]
  00022	8d 42 0c	 lea	 eax, DWORD PTR [edx+12]
  00025	8b 8a e8 fe ff
	ff		 mov	 ecx, DWORD PTR [edx-280]
  0002b	33 c8		 xor	 ecx, eax
  0002d	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00032	8b 4a f8	 mov	 ecx, DWORD PTR [edx-8]
  00035	33 c8		 xor	 ecx, eax
  00037	e8 00 00 00 00	 call	 @__security_check_cookie@4
  0003c	b8 00 00 00 00	 mov	 eax, OFFSET __ehfuncinfo$?Parse@TiXmlDeclaration@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
  00041	e9 00 00 00 00	 jmp	 ___CxxFrameHandler3
text$x	ENDS
?Parse@TiXmlDeclaration@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ENDP ; TiXmlDeclaration::Parse
PUBLIC	?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z ; TiXmlNode::Identify
;	COMDAT xdata$x
xdata$x	SEGMENT
__unwindtable$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z DD 0ffffffffH
	DD	FLAT:__unwindfunclet$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z$0
	DD	0ffffffffH
	DD	FLAT:__unwindfunclet$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z$1
	DD	0ffffffffH
	DD	FLAT:__unwindfunclet$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z$2
	DD	0ffffffffH
	DD	FLAT:__unwindfunclet$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z$3
	DD	0ffffffffH
	DD	FLAT:__unwindfunclet$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z$4
	DD	0ffffffffH
	DD	FLAT:__unwindfunclet$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z$5
__ehfuncinfo$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z DD 019930522H
	DD	06H
	DD	FLAT:__unwindtable$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z
	DD	2 DUP(00H)
	DD	2 DUP(00H)
	DD	00H
	DD	00H
; Function compile flags: /Odtp
xdata$x	ENDS
;	COMDAT ?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z
_TEXT	SEGMENT
tv217 = -116						; size = 4
tv206 = -112						; size = 4
tv186 = -108						; size = 4
tv163 = -104						; size = 4
tv147 = -100						; size = 4
tv129 = -96						; size = 4
_this$ = -92						; size = 4
$T340722 = -88						; size = 4
$T340721 = -84						; size = 4
$T340718 = -80						; size = 4
$T340717 = -76						; size = 4
$T340714 = -72						; size = 4
$T340713 = -68						; size = 4
$T340710 = -64						; size = 4
$T340709 = -60						; size = 4
$T340706 = -56						; size = 4
$T340705 = -52						; size = 4
$T340702 = -48						; size = 4
$T340701 = -44						; size = 4
_text$21377 = -40					; size = 4
_doc$ = -36						; size = 4
_commentHeader$ = -32					; size = 4
_dtdHeader$ = -28					; size = 4
_xmlHeader$ = -24					; size = 4
_returnNode$ = -20					; size = 4
_cdataHeader$ = -16					; size = 4
__$EHRec$ = -12						; size = 12
_p$ = 8							; size = 4
_encoding$ = 12						; size = 4
?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z PROC ; TiXmlNode::Identify, COMDAT
; _this$ = ecx

; 819  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	6a ff		 push	 -1
  00005	68 00 00 00 00	 push	 __ehhandler$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z
  0000a	64 a1 00 00 00
	00		 mov	 eax, DWORD PTR fs:0
  00010	50		 push	 eax
  00011	83 ec 68	 sub	 esp, 104		; 00000068H
  00014	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  00019	33 c5		 xor	 eax, ebp
  0001b	50		 push	 eax
  0001c	8d 45 f4	 lea	 eax, DWORD PTR __$EHRec$[ebp]
  0001f	64 a3 00 00 00
	00		 mov	 DWORD PTR fs:0, eax
  00025	89 4d a4	 mov	 DWORD PTR _this$[ebp], ecx

; 820  :     TiXmlNode* returnNode = 0;

  00028	c7 45 ec 00 00
	00 00		 mov	 DWORD PTR _returnNode$[ebp], 0

; 821  : 
; 822  :     p = SkipWhiteSpace( p, encoding );

  0002f	8b 45 0c	 mov	 eax, DWORD PTR _encoding$[ebp]
  00032	50		 push	 eax
  00033	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00036	51		 push	 ecx
  00037	e8 00 00 00 00	 call	 ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
  0003c	83 c4 08	 add	 esp, 8
  0003f	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 823  :     if( !p || !*p || *p != '<' )

  00042	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00046	74 15		 je	 SHORT $LN17@Identify
  00048	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0004b	0f be 02	 movsx	 eax, BYTE PTR [edx]
  0004e	85 c0		 test	 eax, eax
  00050	74 0b		 je	 SHORT $LN17@Identify
  00052	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00055	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  00058	83 fa 3c	 cmp	 edx, 60			; 0000003cH
  0005b	74 07		 je	 SHORT $LN18@Identify
$LN17@Identify:

; 824  :     {
; 825  :         return 0;

  0005d	33 c0		 xor	 eax, eax
  0005f	e9 cf 02 00 00	 jmp	 $LN19@Identify
$LN18@Identify:

; 826  :     }
; 827  : 
; 828  :     TiXmlDocument* doc = GetDocument();

  00064	8b 4d a4	 mov	 ecx, DWORD PTR _this$[ebp]
  00067	e8 00 00 00 00	 call	 ?GetDocument@TiXmlNode@@QAEPAVTiXmlDocument@@XZ ; TiXmlNode::GetDocument
  0006c	89 45 dc	 mov	 DWORD PTR _doc$[ebp], eax

; 829  :     p = SkipWhiteSpace( p, encoding );

  0006f	8b 45 0c	 mov	 eax, DWORD PTR _encoding$[ebp]
  00072	50		 push	 eax
  00073	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00076	51		 push	 ecx
  00077	e8 00 00 00 00	 call	 ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
  0007c	83 c4 08	 add	 esp, 8
  0007f	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 830  : 
; 831  :     if ( !p || !*p )

  00082	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00086	74 0a		 je	 SHORT $LN15@Identify
  00088	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  0008b	0f be 02	 movsx	 eax, BYTE PTR [edx]
  0008e	85 c0		 test	 eax, eax
  00090	75 07		 jne	 SHORT $LN16@Identify
$LN15@Identify:

; 832  :     {
; 833  :         return 0;

  00092	33 c0		 xor	 eax, eax
  00094	e9 9a 02 00 00	 jmp	 $LN19@Identify
$LN16@Identify:

; 834  :     }
; 835  : 
; 836  :     // What is this thing?
; 837  :     // - Elements start with a letter or underscore, but xml is reserved.
; 838  :     // - Comments: <!--
; 839  :     // - Decleration: <?xml
; 840  :     // - Everthing else is unknown to tinyxml.
; 841  :     //
; 842  : 
; 843  :     const char* xmlHeader = { "<?xml" };

  00099	c7 45 e8 00 00
	00 00		 mov	 DWORD PTR _xmlHeader$[ebp], OFFSET ??_C@_05DJDIECHG@?$DM?$DPxml?$AA@

; 844  :     const char* commentHeader = { "<!--" };

  000a0	c7 45 e0 00 00
	00 00		 mov	 DWORD PTR _commentHeader$[ebp], OFFSET ??_C@_04FFDNBKGC@?$DM?$CB?9?9?$AA@

; 845  :     const char* dtdHeader = { "<!" };

  000a7	c7 45 e4 00 00
	00 00		 mov	 DWORD PTR _dtdHeader$[ebp], OFFSET ??_C@_02KBFACPPK@?$DM?$CB?$AA@

; 846  :     const char* cdataHeader = { "<![CDATA[" };

  000ae	c7 45 f0 00 00
	00 00		 mov	 DWORD PTR _cdataHeader$[ebp], OFFSET ??_C@_09BLLNCBLF@?$DM?$CB?$FLCDATA?$FL?$AA@

; 847  : 
; 848  :     if ( StringEqual( p, xmlHeader, true, encoding ) )

  000b5	8b 4d 0c	 mov	 ecx, DWORD PTR _encoding$[ebp]
  000b8	51		 push	 ecx
  000b9	6a 01		 push	 1
  000bb	8b 55 e8	 mov	 edx, DWORD PTR _xmlHeader$[ebp]
  000be	52		 push	 edx
  000bf	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  000c2	50		 push	 eax
  000c3	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  000c8	83 c4 10	 add	 esp, 16			; 00000010H
  000cb	0f b6 c8	 movzx	 ecx, al
  000ce	85 c9		 test	 ecx, ecx
  000d0	74 49		 je	 SHORT $LN14@Identify

; 849  :     {
; 850  :         #ifdef DEBUG_PARSER
; 851  :             TIXML_LOG( "XML parsing Declaration\n" );
; 852  :         #endif
; 853  :         returnNode = new TiXmlDeclaration();

  000d2	68 98 00 00 00	 push	 152			; 00000098H
  000d7	e8 00 00 00 00	 call	 ??2@YAPAXI@Z		; operator new
  000dc	83 c4 04	 add	 esp, 4
  000df	89 45 d0	 mov	 DWORD PTR $T340702[ebp], eax
  000e2	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+8], 0
  000e9	83 7d d0 00	 cmp	 DWORD PTR $T340702[ebp], 0
  000ed	74 0d		 je	 SHORT $LN21@Identify
  000ef	8b 4d d0	 mov	 ecx, DWORD PTR $T340702[ebp]
  000f2	e8 00 00 00 00	 call	 ??0TiXmlDeclaration@@QAE@XZ ; TiXmlDeclaration::TiXmlDeclaration
  000f7	89 45 a0	 mov	 DWORD PTR tv129[ebp], eax
  000fa	eb 07		 jmp	 SHORT $LN22@Identify
$LN21@Identify:
  000fc	c7 45 a0 00 00
	00 00		 mov	 DWORD PTR tv129[ebp], 0
$LN22@Identify:
  00103	8b 55 a0	 mov	 edx, DWORD PTR tv129[ebp]
  00106	89 55 d4	 mov	 DWORD PTR $T340701[ebp], edx
  00109	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  00110	8b 45 d4	 mov	 eax, DWORD PTR $T340701[ebp]
  00113	89 45 ec	 mov	 DWORD PTR _returnNode$[ebp], eax
  00116	e9 ee 01 00 00	 jmp	 $LN13@Identify
$LN14@Identify:

; 854  :     }
; 855  :     else if ( StringEqual( p, commentHeader, false, encoding ) )

  0011b	8b 4d 0c	 mov	 ecx, DWORD PTR _encoding$[ebp]
  0011e	51		 push	 ecx
  0011f	6a 00		 push	 0
  00121	8b 55 e0	 mov	 edx, DWORD PTR _commentHeader$[ebp]
  00124	52		 push	 edx
  00125	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00128	50		 push	 eax
  00129	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  0012e	83 c4 10	 add	 esp, 16			; 00000010H
  00131	0f b6 c8	 movzx	 ecx, al
  00134	85 c9		 test	 ecx, ecx
  00136	74 46		 je	 SHORT $LN12@Identify

; 856  :     {
; 857  :         #ifdef DEBUG_PARSER
; 858  :             TIXML_LOG( "XML parsing Comment\n" );
; 859  :         #endif
; 860  :         returnNode = new TiXmlComment();

  00138	6a 44		 push	 68			; 00000044H
  0013a	e8 00 00 00 00	 call	 ??2@YAPAXI@Z		; operator new
  0013f	83 c4 04	 add	 esp, 4
  00142	89 45 c8	 mov	 DWORD PTR $T340706[ebp], eax
  00145	c7 45 fc 01 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+8], 1
  0014c	83 7d c8 00	 cmp	 DWORD PTR $T340706[ebp], 0
  00150	74 0d		 je	 SHORT $LN23@Identify
  00152	8b 4d c8	 mov	 ecx, DWORD PTR $T340706[ebp]
  00155	e8 00 00 00 00	 call	 ??0TiXmlComment@@QAE@XZ	; TiXmlComment::TiXmlComment
  0015a	89 45 9c	 mov	 DWORD PTR tv147[ebp], eax
  0015d	eb 07		 jmp	 SHORT $LN24@Identify
$LN23@Identify:
  0015f	c7 45 9c 00 00
	00 00		 mov	 DWORD PTR tv147[ebp], 0
$LN24@Identify:
  00166	8b 55 9c	 mov	 edx, DWORD PTR tv147[ebp]
  00169	89 55 cc	 mov	 DWORD PTR $T340705[ebp], edx
  0016c	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  00173	8b 45 cc	 mov	 eax, DWORD PTR $T340705[ebp]
  00176	89 45 ec	 mov	 DWORD PTR _returnNode$[ebp], eax
  00179	e9 8b 01 00 00	 jmp	 $LN13@Identify
$LN12@Identify:

; 861  :     }
; 862  :     else if ( StringEqual( p, cdataHeader, false, encoding ) )

  0017e	8b 4d 0c	 mov	 ecx, DWORD PTR _encoding$[ebp]
  00181	51		 push	 ecx
  00182	6a 00		 push	 0
  00184	8b 55 f0	 mov	 edx, DWORD PTR _cdataHeader$[ebp]
  00187	52		 push	 edx
  00188	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0018b	50		 push	 eax
  0018c	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  00191	83 c4 10	 add	 esp, 16			; 00000010H
  00194	0f b6 c8	 movzx	 ecx, al
  00197	85 c9		 test	 ecx, ecx
  00199	74 5b		 je	 SHORT $LN10@Identify

; 863  :     {
; 864  :         #ifdef DEBUG_PARSER
; 865  :             TIXML_LOG( "XML parsing CDATA\n" );
; 866  :         #endif
; 867  :         TiXmlText* text = new TiXmlText( "" );

  0019b	6a 48		 push	 72			; 00000048H
  0019d	e8 00 00 00 00	 call	 ??2@YAPAXI@Z		; operator new
  001a2	83 c4 04	 add	 esp, 4
  001a5	89 45 c0	 mov	 DWORD PTR $T340710[ebp], eax
  001a8	c7 45 fc 02 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+8], 2
  001af	83 7d c0 00	 cmp	 DWORD PTR $T340710[ebp], 0
  001b3	74 12		 je	 SHORT $LN25@Identify
  001b5	68 00 00 00 00	 push	 OFFSET ??_C@_00CNPNBAHC@?$AA@
  001ba	8b 4d c0	 mov	 ecx, DWORD PTR $T340710[ebp]
  001bd	e8 00 00 00 00	 call	 ??0TiXmlText@@QAE@PBD@Z	; TiXmlText::TiXmlText
  001c2	89 45 98	 mov	 DWORD PTR tv163[ebp], eax
  001c5	eb 07		 jmp	 SHORT $LN26@Identify
$LN25@Identify:
  001c7	c7 45 98 00 00
	00 00		 mov	 DWORD PTR tv163[ebp], 0
$LN26@Identify:
  001ce	8b 55 98	 mov	 edx, DWORD PTR tv163[ebp]
  001d1	89 55 c4	 mov	 DWORD PTR $T340709[ebp], edx
  001d4	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  001db	8b 45 c4	 mov	 eax, DWORD PTR $T340709[ebp]
  001de	89 45 d8	 mov	 DWORD PTR _text$21377[ebp], eax

; 868  :         text->SetCDATA( true );

  001e1	6a 01		 push	 1
  001e3	8b 4d d8	 mov	 ecx, DWORD PTR _text$21377[ebp]
  001e6	e8 00 00 00 00	 call	 ?SetCDATA@TiXmlText@@QAEX_N@Z ; TiXmlText::SetCDATA

; 869  :         returnNode = text;

  001eb	8b 4d d8	 mov	 ecx, DWORD PTR _text$21377[ebp]
  001ee	89 4d ec	 mov	 DWORD PTR _returnNode$[ebp], ecx
  001f1	e9 13 01 00 00	 jmp	 $LN13@Identify
$LN10@Identify:

; 870  :     }
; 871  :     else if ( StringEqual( p, dtdHeader, false, encoding ) )

  001f6	8b 55 0c	 mov	 edx, DWORD PTR _encoding$[ebp]
  001f9	52		 push	 edx
  001fa	6a 00		 push	 0
  001fc	8b 45 e4	 mov	 eax, DWORD PTR _dtdHeader$[ebp]
  001ff	50		 push	 eax
  00200	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00203	51		 push	 ecx
  00204	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  00209	83 c4 10	 add	 esp, 16			; 00000010H
  0020c	0f b6 d0	 movzx	 edx, al
  0020f	85 d2		 test	 edx, edx
  00211	74 46		 je	 SHORT $LN8@Identify

; 872  :     {
; 873  :         #ifdef DEBUG_PARSER
; 874  :             TIXML_LOG( "XML parsing Unknown(1)\n" );
; 875  :         #endif
; 876  :         returnNode = new TiXmlUnknown();

  00213	6a 44		 push	 68			; 00000044H
  00215	e8 00 00 00 00	 call	 ??2@YAPAXI@Z		; operator new
  0021a	83 c4 04	 add	 esp, 4
  0021d	89 45 b8	 mov	 DWORD PTR $T340714[ebp], eax
  00220	c7 45 fc 03 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+8], 3
  00227	83 7d b8 00	 cmp	 DWORD PTR $T340714[ebp], 0
  0022b	74 0d		 je	 SHORT $LN27@Identify
  0022d	8b 4d b8	 mov	 ecx, DWORD PTR $T340714[ebp]
  00230	e8 00 00 00 00	 call	 ??0TiXmlUnknown@@QAE@XZ	; TiXmlUnknown::TiXmlUnknown
  00235	89 45 94	 mov	 DWORD PTR tv186[ebp], eax
  00238	eb 07		 jmp	 SHORT $LN28@Identify
$LN27@Identify:
  0023a	c7 45 94 00 00
	00 00		 mov	 DWORD PTR tv186[ebp], 0
$LN28@Identify:
  00241	8b 45 94	 mov	 eax, DWORD PTR tv186[ebp]
  00244	89 45 bc	 mov	 DWORD PTR $T340713[ebp], eax
  00247	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  0024e	8b 4d bc	 mov	 ecx, DWORD PTR $T340713[ebp]
  00251	89 4d ec	 mov	 DWORD PTR _returnNode$[ebp], ecx

; 877  :     }
; 878  :     else if (    IsAlpha( *(p+1), encoding )

  00254	e9 b0 00 00 00	 jmp	 $LN13@Identify
$LN8@Identify:

; 879  :               || *(p+1) == '_' )

  00259	8b 55 0c	 mov	 edx, DWORD PTR _encoding$[ebp]
  0025c	52		 push	 edx
  0025d	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00260	0f b6 48 01	 movzx	 ecx, BYTE PTR [eax+1]
  00264	51		 push	 ecx
  00265	e8 00 00 00 00	 call	 ?IsAlpha@TiXmlBase@@KAHEW4TiXmlEncoding@@@Z ; TiXmlBase::IsAlpha
  0026a	83 c4 08	 add	 esp, 8
  0026d	85 c0		 test	 eax, eax
  0026f	75 0c		 jne	 SHORT $LN5@Identify
  00271	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00274	0f be 42 01	 movsx	 eax, BYTE PTR [edx+1]
  00278	83 f8 5f	 cmp	 eax, 95			; 0000005fH
  0027b	75 4b		 jne	 SHORT $LN6@Identify
$LN5@Identify:

; 880  :     {
; 881  :         #ifdef DEBUG_PARSER
; 882  :             TIXML_LOG( "XML parsing Element\n" );
; 883  :         #endif
; 884  :         returnNode = new TiXmlElement( "" );

  0027d	68 98 00 00 00	 push	 152			; 00000098H
  00282	e8 00 00 00 00	 call	 ??2@YAPAXI@Z		; operator new
  00287	83 c4 04	 add	 esp, 4
  0028a	89 45 b0	 mov	 DWORD PTR $T340718[ebp], eax
  0028d	c7 45 fc 04 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+8], 4
  00294	83 7d b0 00	 cmp	 DWORD PTR $T340718[ebp], 0
  00298	74 12		 je	 SHORT $LN29@Identify
  0029a	68 00 00 00 00	 push	 OFFSET ??_C@_00CNPNBAHC@?$AA@
  0029f	8b 4d b0	 mov	 ecx, DWORD PTR $T340718[ebp]
  002a2	e8 00 00 00 00	 call	 ??0TiXmlElement@@QAE@PBD@Z ; TiXmlElement::TiXmlElement
  002a7	89 45 90	 mov	 DWORD PTR tv206[ebp], eax
  002aa	eb 07		 jmp	 SHORT $LN30@Identify
$LN29@Identify:
  002ac	c7 45 90 00 00
	00 00		 mov	 DWORD PTR tv206[ebp], 0
$LN30@Identify:
  002b3	8b 4d 90	 mov	 ecx, DWORD PTR tv206[ebp]
  002b6	89 4d b4	 mov	 DWORD PTR $T340717[ebp], ecx
  002b9	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  002c0	8b 55 b4	 mov	 edx, DWORD PTR $T340717[ebp]
  002c3	89 55 ec	 mov	 DWORD PTR _returnNode$[ebp], edx

; 885  :     }
; 886  :     else

  002c6	eb 41		 jmp	 SHORT $LN13@Identify
$LN6@Identify:

; 887  :     {
; 888  :         #ifdef DEBUG_PARSER
; 889  :             TIXML_LOG( "XML parsing Unknown(2)\n" );
; 890  :         #endif
; 891  :         returnNode = new TiXmlUnknown();

  002c8	6a 44		 push	 68			; 00000044H
  002ca	e8 00 00 00 00	 call	 ??2@YAPAXI@Z		; operator new
  002cf	83 c4 04	 add	 esp, 4
  002d2	89 45 a8	 mov	 DWORD PTR $T340722[ebp], eax
  002d5	c7 45 fc 05 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+8], 5
  002dc	83 7d a8 00	 cmp	 DWORD PTR $T340722[ebp], 0
  002e0	74 0d		 je	 SHORT $LN31@Identify
  002e2	8b 4d a8	 mov	 ecx, DWORD PTR $T340722[ebp]
  002e5	e8 00 00 00 00	 call	 ??0TiXmlUnknown@@QAE@XZ	; TiXmlUnknown::TiXmlUnknown
  002ea	89 45 8c	 mov	 DWORD PTR tv217[ebp], eax
  002ed	eb 07		 jmp	 SHORT $LN32@Identify
$LN31@Identify:
  002ef	c7 45 8c 00 00
	00 00		 mov	 DWORD PTR tv217[ebp], 0
$LN32@Identify:
  002f6	8b 45 8c	 mov	 eax, DWORD PTR tv217[ebp]
  002f9	89 45 ac	 mov	 DWORD PTR $T340721[ebp], eax
  002fc	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  00303	8b 4d ac	 mov	 ecx, DWORD PTR $T340721[ebp]
  00306	89 4d ec	 mov	 DWORD PTR _returnNode$[ebp], ecx
$LN13@Identify:

; 892  :     }
; 893  : 
; 894  :     if ( returnNode )

  00309	83 7d ec 00	 cmp	 DWORD PTR _returnNode$[ebp], 0
  0030d	74 0b		 je	 SHORT $LN3@Identify

; 895  :     {
; 896  :         // Set the parent, so it can report errors
; 897  :         returnNode->parent = this;

  0030f	8b 55 ec	 mov	 edx, DWORD PTR _returnNode$[ebp]
  00312	8b 45 a4	 mov	 eax, DWORD PTR _this$[ebp]
  00315	89 42 10	 mov	 DWORD PTR [edx+16], eax

; 898  :     }
; 899  :     else

  00318	eb 16		 jmp	 SHORT $LN2@Identify
$LN3@Identify:

; 900  :     {
; 901  :         if ( doc )

  0031a	83 7d dc 00	 cmp	 DWORD PTR _doc$[ebp], 0
  0031e	74 10		 je	 SHORT $LN2@Identify

; 902  :             doc->SetError( TIXML_ERROR_OUT_OF_MEMORY, 0, 0, TIXML_ENCODING_UNKNOWN );

  00320	6a 00		 push	 0
  00322	6a 00		 push	 0
  00324	6a 00		 push	 0
  00326	6a 03		 push	 3
  00328	8b 4d dc	 mov	 ecx, DWORD PTR _doc$[ebp]
  0032b	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN2@Identify:

; 903  :     }
; 904  :     return returnNode;

  00330	8b 45 ec	 mov	 eax, DWORD PTR _returnNode$[ebp]
$LN19@Identify:

; 905  : }

  00333	8b 4d f4	 mov	 ecx, DWORD PTR __$EHRec$[ebp]
  00336	64 89 0d 00 00
	00 00		 mov	 DWORD PTR fs:0, ecx
  0033d	59		 pop	 ecx
  0033e	8b e5		 mov	 esp, ebp
  00340	5d		 pop	 ebp
  00341	c2 08 00	 ret	 8
_TEXT	ENDS
;	COMDAT text$x
text$x	SEGMENT
__unwindfunclet$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z$0:
  00000	8b 45 d0	 mov	 eax, DWORD PTR $T340702[ebp]
  00003	50		 push	 eax
  00004	e8 00 00 00 00	 call	 ??3@YAXPAX@Z		; operator delete
  00009	59		 pop	 ecx
  0000a	c3		 ret	 0
__unwindfunclet$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z$1:
  0000b	8b 45 c8	 mov	 eax, DWORD PTR $T340706[ebp]
  0000e	50		 push	 eax
  0000f	e8 00 00 00 00	 call	 ??3@YAXPAX@Z		; operator delete
  00014	59		 pop	 ecx
  00015	c3		 ret	 0
__unwindfunclet$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z$2:
  00016	8b 45 c0	 mov	 eax, DWORD PTR $T340710[ebp]
  00019	50		 push	 eax
  0001a	e8 00 00 00 00	 call	 ??3@YAXPAX@Z		; operator delete
  0001f	59		 pop	 ecx
  00020	c3		 ret	 0
__unwindfunclet$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z$3:
  00021	8b 45 b8	 mov	 eax, DWORD PTR $T340714[ebp]
  00024	50		 push	 eax
  00025	e8 00 00 00 00	 call	 ??3@YAXPAX@Z		; operator delete
  0002a	59		 pop	 ecx
  0002b	c3		 ret	 0
__unwindfunclet$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z$4:
  0002c	8b 45 b0	 mov	 eax, DWORD PTR $T340718[ebp]
  0002f	50		 push	 eax
  00030	e8 00 00 00 00	 call	 ??3@YAXPAX@Z		; operator delete
  00035	59		 pop	 ecx
  00036	c3		 ret	 0
__unwindfunclet$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z$5:
  00037	8b 45 a8	 mov	 eax, DWORD PTR $T340722[ebp]
  0003a	50		 push	 eax
  0003b	e8 00 00 00 00	 call	 ??3@YAXPAX@Z		; operator delete
  00040	59		 pop	 ecx
  00041	c3		 ret	 0
__ehhandler$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z:
  00042	8b 54 24 08	 mov	 edx, DWORD PTR [esp+8]
  00046	8d 42 0c	 lea	 eax, DWORD PTR [edx+12]
  00049	8b 4a 94	 mov	 ecx, DWORD PTR [edx-108]
  0004c	33 c8		 xor	 ecx, eax
  0004e	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00053	b8 00 00 00 00	 mov	 eax, OFFSET __ehfuncinfo$?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z
  00058	e9 00 00 00 00	 jmp	 ___CxxFrameHandler3
text$x	ENDS
?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z ENDP ; TiXmlNode::Identify
; Function compile flags: /Odtp
;	COMDAT ?Parse@TiXmlDocument@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
_TEXT	SEGMENT
_this$ = -36						; size = 4
_enc$21324 = -32					; size = 4
_dec$21323 = -28					; size = 4
_node$21319 = -24					; size = 4
_pU$21312 = -20						; size = 4
_data$ = -16						; size = 16
_p$ = 8							; size = 4
_prevData$ = 12						; size = 4
_encoding$ = 16						; size = 4
?Parse@TiXmlDocument@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z PROC ; TiXmlDocument::Parse, COMDAT
; _this$ = ecx

; 705  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 24	 sub	 esp, 36			; 00000024H
  00006	89 4d dc	 mov	 DWORD PTR _this$[ebp], ecx

; 706  :     ClearError();

  00009	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  0000c	e8 00 00 00 00	 call	 ?ClearError@TiXmlDocument@@QAEXXZ ; TiXmlDocument::ClearError

; 707  : 
; 708  :     // Parse away, at the document level. Since a document
; 709  :     // contains nothing but other tags, most of what happens
; 710  :     // here is skipping white space.
; 711  :     if ( !p || !*p )

  00011	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00015	74 0a		 je	 SHORT $LN18@Parse@6
  00017	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0001a	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  0001d	85 c9		 test	 ecx, ecx
  0001f	75 17		 jne	 SHORT $LN19@Parse@6
$LN18@Parse@6:

; 712  :     {
; 713  :         SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN );

  00021	6a 00		 push	 0
  00023	6a 00		 push	 0
  00025	6a 00		 push	 0
  00027	6a 0d		 push	 13			; 0000000dH
  00029	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  0002c	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError

; 714  :         return 0;

  00031	33 c0		 xor	 eax, eax
  00033	e9 40 02 00 00	 jmp	 $LN20@Parse@6
$LN19@Parse@6:

; 715  :     }
; 716  : 
; 717  :     // Note that, for a document, this needs to come
; 718  :     // before the while space skip, so that parsing
; 719  :     // starts from the pointer we are given.
; 720  :     location.Clear();

  00038	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  0003b	83 c1 04	 add	 ecx, 4
  0003e	e8 00 00 00 00	 call	 ?Clear@TiXmlCursor@@QAEXXZ ; TiXmlCursor::Clear

; 721  :     if ( prevData )

  00043	83 7d 0c 00	 cmp	 DWORD PTR _prevData$[ebp], 0
  00047	74 19		 je	 SHORT $LN17@Parse@6

; 722  :     {
; 723  :         location.row = prevData->cursor.row;

  00049	8b 55 dc	 mov	 edx, DWORD PTR _this$[ebp]
  0004c	8b 45 0c	 mov	 eax, DWORD PTR _prevData$[ebp]
  0004f	8b 08		 mov	 ecx, DWORD PTR [eax]
  00051	89 4a 04	 mov	 DWORD PTR [edx+4], ecx

; 724  :         location.col = prevData->cursor.col;

  00054	8b 55 dc	 mov	 edx, DWORD PTR _this$[ebp]
  00057	8b 45 0c	 mov	 eax, DWORD PTR _prevData$[ebp]
  0005a	8b 48 04	 mov	 ecx, DWORD PTR [eax+4]
  0005d	89 4a 08	 mov	 DWORD PTR [edx+8], ecx

; 725  :     }
; 726  :     else

  00060	eb 14		 jmp	 SHORT $LN16@Parse@6
$LN17@Parse@6:

; 727  :     {
; 728  :         location.row = 0;

  00062	8b 55 dc	 mov	 edx, DWORD PTR _this$[ebp]
  00065	c7 42 04 00 00
	00 00		 mov	 DWORD PTR [edx+4], 0

; 729  :         location.col = 0;

  0006c	8b 45 dc	 mov	 eax, DWORD PTR _this$[ebp]
  0006f	c7 40 08 00 00
	00 00		 mov	 DWORD PTR [eax+8], 0
$LN16@Parse@6:

; 730  :     }
; 731  :     TiXmlParsingData data( p, TabSize(), location.row, location.col );

  00076	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  00079	8b 51 08	 mov	 edx, DWORD PTR [ecx+8]
  0007c	52		 push	 edx
  0007d	8b 45 dc	 mov	 eax, DWORD PTR _this$[ebp]
  00080	8b 48 04	 mov	 ecx, DWORD PTR [eax+4]
  00083	51		 push	 ecx
  00084	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  00087	e8 00 00 00 00	 call	 ?TabSize@TiXmlDocument@@QBEHXZ ; TiXmlDocument::TabSize
  0008c	50		 push	 eax
  0008d	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00090	52		 push	 edx
  00091	8d 4d f0	 lea	 ecx, DWORD PTR _data$[ebp]
  00094	e8 00 00 00 00	 call	 ??0TiXmlParsingData@@AAE@PBDHHH@Z ; TiXmlParsingData::TiXmlParsingData

; 732  :     location = data.Cursor();

  00099	8d 4d f0	 lea	 ecx, DWORD PTR _data$[ebp]
  0009c	e8 00 00 00 00	 call	 ?Cursor@TiXmlParsingData@@QAEABUTiXmlCursor@@XZ ; TiXmlParsingData::Cursor
  000a1	8b 08		 mov	 ecx, DWORD PTR [eax]
  000a3	8b 50 04	 mov	 edx, DWORD PTR [eax+4]
  000a6	8b 45 dc	 mov	 eax, DWORD PTR _this$[ebp]
  000a9	89 48 04	 mov	 DWORD PTR [eax+4], ecx
  000ac	89 50 08	 mov	 DWORD PTR [eax+8], edx

; 733  : 
; 734  :     if ( encoding == TIXML_ENCODING_UNKNOWN )

  000af	83 7d 10 00	 cmp	 DWORD PTR _encoding$[ebp], 0
  000b3	75 5f		 jne	 SHORT $LN15@Parse@6

; 735  :     {
; 736  :         // Check for the Microsoft UTF-8 lead bytes.
; 737  :         const unsigned char* pU = (const unsigned char*)p;

  000b5	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  000b8	89 4d ec	 mov	 DWORD PTR _pU$21312[ebp], ecx

; 738  :         if (    *(pU+0) && *(pU+0) == TIXML_UTF_LEAD_0
; 739  :              && *(pU+1) && *(pU+1) == TIXML_UTF_LEAD_1
; 740  :              && *(pU+2) && *(pU+2) == TIXML_UTF_LEAD_2 )

  000bb	8b 55 ec	 mov	 edx, DWORD PTR _pU$21312[ebp]
  000be	0f b6 02	 movzx	 eax, BYTE PTR [edx]
  000c1	85 c0		 test	 eax, eax
  000c3	74 4f		 je	 SHORT $LN15@Parse@6
  000c5	8b 4d ec	 mov	 ecx, DWORD PTR _pU$21312[ebp]
  000c8	0f b6 11	 movzx	 edx, BYTE PTR [ecx]
  000cb	81 fa ef 00 00
	00		 cmp	 edx, 239		; 000000efH
  000d1	75 41		 jne	 SHORT $LN15@Parse@6
  000d3	8b 45 ec	 mov	 eax, DWORD PTR _pU$21312[ebp]
  000d6	0f b6 48 01	 movzx	 ecx, BYTE PTR [eax+1]
  000da	85 c9		 test	 ecx, ecx
  000dc	74 36		 je	 SHORT $LN15@Parse@6
  000de	8b 55 ec	 mov	 edx, DWORD PTR _pU$21312[ebp]
  000e1	0f b6 42 01	 movzx	 eax, BYTE PTR [edx+1]
  000e5	3d bb 00 00 00	 cmp	 eax, 187		; 000000bbH
  000ea	75 28		 jne	 SHORT $LN15@Parse@6
  000ec	8b 4d ec	 mov	 ecx, DWORD PTR _pU$21312[ebp]
  000ef	0f b6 51 02	 movzx	 edx, BYTE PTR [ecx+2]
  000f3	85 d2		 test	 edx, edx
  000f5	74 1d		 je	 SHORT $LN15@Parse@6
  000f7	8b 45 ec	 mov	 eax, DWORD PTR _pU$21312[ebp]
  000fa	0f b6 48 02	 movzx	 ecx, BYTE PTR [eax+2]
  000fe	81 f9 bf 00 00
	00		 cmp	 ecx, 191		; 000000bfH
  00104	75 0e		 jne	 SHORT $LN15@Parse@6

; 741  :         {
; 742  :             encoding = TIXML_ENCODING_UTF8;

  00106	c7 45 10 01 00
	00 00		 mov	 DWORD PTR _encoding$[ebp], 1

; 743  :             useMicrosoftBOM = true;

  0010d	8b 55 dc	 mov	 edx, DWORD PTR _this$[ebp]
  00110	c6 42 74 01	 mov	 BYTE PTR [edx+116], 1
$LN15@Parse@6:

; 744  :         }
; 745  :     }
; 746  : 
; 747  :     p = SkipWhiteSpace( p, encoding );

  00114	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  00117	50		 push	 eax
  00118	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0011b	51		 push	 ecx
  0011c	e8 00 00 00 00	 call	 ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
  00121	83 c4 08	 add	 esp, 8
  00124	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 748  :     if ( !p )

  00127	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  0012b	75 17		 jne	 SHORT $LN12@Parse@6

; 749  :     {
; 750  :         SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN );

  0012d	6a 00		 push	 0
  0012f	6a 00		 push	 0
  00131	6a 00		 push	 0
  00133	6a 0d		 push	 13			; 0000000dH
  00135	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  00138	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError

; 751  :         return 0;

  0013d	33 c0		 xor	 eax, eax
  0013f	e9 34 01 00 00	 jmp	 $LN20@Parse@6
$LN12@Parse@6:

; 752  :     }
; 753  : 
; 754  :     while ( p && *p )

  00144	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00148	0f 84 08 01 00
	00		 je	 $LN11@Parse@6
  0014e	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00151	0f be 02	 movsx	 eax, BYTE PTR [edx]
  00154	85 c0		 test	 eax, eax
  00156	0f 84 fa 00 00
	00		 je	 $LN11@Parse@6

; 755  :     {
; 756  :         TiXmlNode* node = Identify( p, encoding );

  0015c	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  0015f	51		 push	 ecx
  00160	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00163	52		 push	 edx
  00164	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  00167	e8 00 00 00 00	 call	 ?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z ; TiXmlNode::Identify
  0016c	89 45 e8	 mov	 DWORD PTR _node$21319[ebp], eax

; 757  :         if ( node )

  0016f	83 7d e8 00	 cmp	 DWORD PTR _node$21319[ebp], 0
  00173	74 2a		 je	 SHORT $LN10@Parse@6

; 758  :         {
; 759  :             p = node->Parse( p, &data, encoding );

  00175	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  00178	50		 push	 eax
  00179	8d 4d f0	 lea	 ecx, DWORD PTR _data$[ebp]
  0017c	51		 push	 ecx
  0017d	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00180	52		 push	 edx
  00181	8b 45 e8	 mov	 eax, DWORD PTR _node$21319[ebp]
  00184	8b 10		 mov	 edx, DWORD PTR [eax]
  00186	8b 4d e8	 mov	 ecx, DWORD PTR _node$21319[ebp]
  00189	8b 42 08	 mov	 eax, DWORD PTR [edx+8]
  0018c	ff d0		 call	 eax
  0018e	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 760  :             LinkEndChild( node );

  00191	8b 4d e8	 mov	 ecx, DWORD PTR _node$21319[ebp]
  00194	51		 push	 ecx
  00195	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  00198	e8 00 00 00 00	 call	 ?LinkEndChild@TiXmlNode@@QAEPAV1@PAV1@@Z ; TiXmlNode::LinkEndChild

; 761  :         }
; 762  :         else

  0019d	eb 05		 jmp	 SHORT $LN9@Parse@6
$LN10@Parse@6:

; 763  :         {
; 764  :             break;

  0019f	e9 b2 00 00 00	 jmp	 $LN11@Parse@6
$LN9@Parse@6:

; 765  :         }
; 766  : 
; 767  :         // Did we get encoding info?
; 768  :         if (    encoding == TIXML_ENCODING_UNKNOWN
; 769  :              && node->ToDeclaration() )

  001a4	83 7d 10 00	 cmp	 DWORD PTR _encoding$[ebp], 0
  001a8	0f 85 90 00 00
	00		 jne	 $LN8@Parse@6
  001ae	8b 55 e8	 mov	 edx, DWORD PTR _node$21319[ebp]
  001b1	8b 02		 mov	 eax, DWORD PTR [edx]
  001b3	8b 4d e8	 mov	 ecx, DWORD PTR _node$21319[ebp]
  001b6	8b 50 34	 mov	 edx, DWORD PTR [eax+52]
  001b9	ff d2		 call	 edx
  001bb	85 c0		 test	 eax, eax
  001bd	74 7f		 je	 SHORT $LN8@Parse@6

; 770  :         {
; 771  :             TiXmlDeclaration* dec = node->ToDeclaration();

  001bf	8b 45 e8	 mov	 eax, DWORD PTR _node$21319[ebp]
  001c2	8b 10		 mov	 edx, DWORD PTR [eax]
  001c4	8b 4d e8	 mov	 ecx, DWORD PTR _node$21319[ebp]
  001c7	8b 42 34	 mov	 eax, DWORD PTR [edx+52]
  001ca	ff d0		 call	 eax
  001cc	89 45 e4	 mov	 DWORD PTR _dec$21323[ebp], eax

; 772  :             const char* enc = dec->Encoding();

  001cf	8b 4d e4	 mov	 ecx, DWORD PTR _dec$21323[ebp]
  001d2	e8 00 00 00 00	 call	 ?Encoding@TiXmlDeclaration@@QBEPBDXZ ; TiXmlDeclaration::Encoding
  001d7	89 45 e0	 mov	 DWORD PTR _enc$21324[ebp], eax

; 773  :             assert( enc );
; 774  : 
; 775  :             if ( *enc == 0 )

  001da	8b 4d e0	 mov	 ecx, DWORD PTR _enc$21324[ebp]
  001dd	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  001e0	85 d2		 test	 edx, edx
  001e2	75 09		 jne	 SHORT $LN7@Parse@6

; 776  :                 encoding = TIXML_ENCODING_UTF8;

  001e4	c7 45 10 01 00
	00 00		 mov	 DWORD PTR _encoding$[ebp], 1
  001eb	eb 51		 jmp	 SHORT $LN8@Parse@6
$LN7@Parse@6:

; 777  :             else if ( StringEqual( enc, "UTF-8", true, TIXML_ENCODING_UNKNOWN ) )

  001ed	6a 00		 push	 0
  001ef	6a 01		 push	 1
  001f1	68 00 00 00 00	 push	 OFFSET ??_C@_05EGJIMALK@UTF?98?$AA@
  001f6	8b 45 e0	 mov	 eax, DWORD PTR _enc$21324[ebp]
  001f9	50		 push	 eax
  001fa	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  001ff	83 c4 10	 add	 esp, 16			; 00000010H
  00202	0f b6 c8	 movzx	 ecx, al
  00205	85 c9		 test	 ecx, ecx
  00207	74 09		 je	 SHORT $LN5@Parse@6

; 778  :                 encoding = TIXML_ENCODING_UTF8;

  00209	c7 45 10 01 00
	00 00		 mov	 DWORD PTR _encoding$[ebp], 1
  00210	eb 2c		 jmp	 SHORT $LN8@Parse@6
$LN5@Parse@6:

; 779  :             else if ( StringEqual( enc, "UTF8", true, TIXML_ENCODING_UNKNOWN ) )

  00212	6a 00		 push	 0
  00214	6a 01		 push	 1
  00216	68 00 00 00 00	 push	 OFFSET ??_C@_04OOMJJNCF@UTF8?$AA@
  0021b	8b 55 e0	 mov	 edx, DWORD PTR _enc$21324[ebp]
  0021e	52		 push	 edx
  0021f	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  00224	83 c4 10	 add	 esp, 16			; 00000010H
  00227	0f b6 c0	 movzx	 eax, al
  0022a	85 c0		 test	 eax, eax
  0022c	74 09		 je	 SHORT $LN3@Parse@6

; 780  :                 encoding = TIXML_ENCODING_UTF8;    // incorrect, but be nice

  0022e	c7 45 10 01 00
	00 00		 mov	 DWORD PTR _encoding$[ebp], 1

; 781  :             else

  00235	eb 07		 jmp	 SHORT $LN8@Parse@6
$LN3@Parse@6:

; 782  :                 encoding = TIXML_ENCODING_LEGACY;

  00237	c7 45 10 02 00
	00 00		 mov	 DWORD PTR _encoding$[ebp], 2
$LN8@Parse@6:

; 783  :         }
; 784  : 
; 785  :         p = SkipWhiteSpace( p, encoding );

  0023e	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  00241	51		 push	 ecx
  00242	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00245	52		 push	 edx
  00246	e8 00 00 00 00	 call	 ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
  0024b	83 c4 08	 add	 esp, 8
  0024e	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 786  :     }

  00251	e9 ee fe ff ff	 jmp	 $LN12@Parse@6
$LN11@Parse@6:

; 787  : 
; 788  :     // Was this empty?
; 789  :     if ( !firstChild ) {

  00256	8b 45 dc	 mov	 eax, DWORD PTR _this$[ebp]
  00259	83 78 18 00	 cmp	 DWORD PTR [eax+24], 0
  0025d	75 16		 jne	 SHORT $LN1@Parse@6

; 790  :         SetError( TIXML_ERROR_DOCUMENT_EMPTY, 0, 0, encoding );

  0025f	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  00262	51		 push	 ecx
  00263	6a 00		 push	 0
  00265	6a 00		 push	 0
  00267	6a 0d		 push	 13			; 0000000dH
  00269	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  0026c	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError

; 791  :         return 0;

  00271	33 c0		 xor	 eax, eax
  00273	eb 03		 jmp	 SHORT $LN20@Parse@6
$LN1@Parse@6:

; 792  :     }
; 793  : 
; 794  :     // All is well.
; 795  :     return p;

  00275	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
$LN20@Parse@6:

; 796  : }

  00278	8b e5		 mov	 esp, ebp
  0027a	5d		 pop	 ebp
  0027b	c2 0c 00	 ret	 12			; 0000000cH
?Parse@TiXmlDocument@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ENDP ; TiXmlDocument::Parse
PUBLIC	?ReadValue@TiXmlElement@@IAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlElement::ReadValue
;	COMDAT xdata$x
xdata$x	SEGMENT
__unwindtable$?ReadValue@TiXmlElement@@IAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z DD 0ffffffffH
	DD	FLAT:__unwindfunclet$?ReadValue@TiXmlElement@@IAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z$0
__ehfuncinfo$?ReadValue@TiXmlElement@@IAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z DD 019930522H
	DD	01H
	DD	FLAT:__unwindtable$?ReadValue@TiXmlElement@@IAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
	DD	2 DUP(00H)
	DD	2 DUP(00H)
	DD	00H
	DD	00H
; Function compile flags: /Odtp
xdata$x	ENDS
;	COMDAT ?ReadValue@TiXmlElement@@IAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
_TEXT	SEGMENT
tv174 = -56						; size = 4
tv86 = -52						; size = 4
_this$ = -48						; size = 4
$T343178 = -44						; size = 4
$T343177 = -40						; size = 4
$T343174 = -36						; size = 4
$T343173 = -32						; size = 4
_node$21554 = -28					; size = 4
_textNode$21538 = -24					; size = 4
_pWithWhiteSpace$ = -20					; size = 4
_document$ = -16					; size = 4
__$EHRec$ = -12						; size = 12
_p$ = 8							; size = 4
_data$ = 12						; size = 4
_encoding$ = 16						; size = 4
?ReadValue@TiXmlElement@@IAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z PROC ; TiXmlElement::ReadValue, COMDAT
; _this$ = ecx

; 1174 : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	6a ff		 push	 -1
  00005	68 00 00 00 00	 push	 __ehhandler$?ReadValue@TiXmlElement@@IAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
  0000a	64 a1 00 00 00
	00		 mov	 eax, DWORD PTR fs:0
  00010	50		 push	 eax
  00011	83 ec 2c	 sub	 esp, 44			; 0000002cH
  00014	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  00019	33 c5		 xor	 eax, ebp
  0001b	50		 push	 eax
  0001c	8d 45 f4	 lea	 eax, DWORD PTR __$EHRec$[ebp]
  0001f	64 a3 00 00 00
	00		 mov	 DWORD PTR fs:0, eax
  00025	89 4d d0	 mov	 DWORD PTR _this$[ebp], ecx

; 1175 :     TiXmlDocument* document = GetDocument();

  00028	8b 4d d0	 mov	 ecx, DWORD PTR _this$[ebp]
  0002b	e8 00 00 00 00	 call	 ?GetDocument@TiXmlNode@@QAEPAVTiXmlDocument@@XZ ; TiXmlNode::GetDocument
  00030	89 45 f0	 mov	 DWORD PTR _document$[ebp], eax

; 1176 : 
; 1177 :     // Read in text and elements in any order.
; 1178 :     const char* pWithWhiteSpace = p;

  00033	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00036	89 45 ec	 mov	 DWORD PTR _pWithWhiteSpace$[ebp], eax

; 1179 :     p = SkipWhiteSpace( p, encoding );

  00039	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  0003c	51		 push	 ecx
  0003d	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00040	52		 push	 edx
  00041	e8 00 00 00 00	 call	 ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
  00046	83 c4 08	 add	 esp, 8
  00049	89 45 08	 mov	 DWORD PTR _p$[ebp], eax
$LN16@ReadValue:

; 1180 : 
; 1181 :     while ( p && *p )

  0004c	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00050	0f 84 a6 01 00
	00		 je	 $LN15@ReadValue
  00056	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00059	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  0005c	85 c9		 test	 ecx, ecx
  0005e	0f 84 98 01 00
	00		 je	 $LN15@ReadValue

; 1182 :     {
; 1183 :         if ( *p != '<' )

  00064	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00067	0f be 02	 movsx	 eax, BYTE PTR [edx]
  0006a	83 f8 3c	 cmp	 eax, 60			; 0000003cH
  0006d	0f 84 fc 00 00
	00		 je	 $LN14@ReadValue

; 1184 :         {
; 1185 :             // Take what we have, make a text element.
; 1186 :             TiXmlText* textNode = new TiXmlText( "" );

  00073	6a 48		 push	 72			; 00000048H
  00075	e8 00 00 00 00	 call	 ??2@YAPAXI@Z		; operator new
  0007a	83 c4 04	 add	 esp, 4
  0007d	89 45 dc	 mov	 DWORD PTR $T343174[ebp], eax
  00080	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+8], 0
  00087	83 7d dc 00	 cmp	 DWORD PTR $T343174[ebp], 0
  0008b	74 12		 je	 SHORT $LN19@ReadValue
  0008d	68 00 00 00 00	 push	 OFFSET ??_C@_00CNPNBAHC@?$AA@
  00092	8b 4d dc	 mov	 ecx, DWORD PTR $T343174[ebp]
  00095	e8 00 00 00 00	 call	 ??0TiXmlText@@QAE@PBD@Z	; TiXmlText::TiXmlText
  0009a	89 45 cc	 mov	 DWORD PTR tv86[ebp], eax
  0009d	eb 07		 jmp	 SHORT $LN20@ReadValue
$LN19@ReadValue:
  0009f	c7 45 cc 00 00
	00 00		 mov	 DWORD PTR tv86[ebp], 0
$LN20@ReadValue:
  000a6	8b 4d cc	 mov	 ecx, DWORD PTR tv86[ebp]
  000a9	89 4d e0	 mov	 DWORD PTR $T343173[ebp], ecx
  000ac	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  000b3	8b 55 e0	 mov	 edx, DWORD PTR $T343173[ebp]
  000b6	89 55 e8	 mov	 DWORD PTR _textNode$21538[ebp], edx

; 1187 : 
; 1188 :             if ( !textNode )

  000b9	83 7d e8 00	 cmp	 DWORD PTR _textNode$21538[ebp], 0
  000bd	75 1f		 jne	 SHORT $LN13@ReadValue

; 1189 :             {
; 1190 :                 if ( document ) document->SetError( TIXML_ERROR_OUT_OF_MEMORY, 0, 0, encoding );

  000bf	83 7d f0 00	 cmp	 DWORD PTR _document$[ebp], 0
  000c3	74 12		 je	 SHORT $LN12@ReadValue
  000c5	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  000c8	50		 push	 eax
  000c9	6a 00		 push	 0
  000cb	6a 00		 push	 0
  000cd	6a 03		 push	 3
  000cf	8b 4d f0	 mov	 ecx, DWORD PTR _document$[ebp]
  000d2	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN12@ReadValue:

; 1191 :                     return 0;

  000d7	33 c0		 xor	 eax, eax
  000d9	e9 3f 01 00 00	 jmp	 $LN17@ReadValue
$LN13@ReadValue:

; 1192 :             }
; 1193 : 
; 1194 :             if ( TiXmlBase::IsWhiteSpaceCondensed() )

  000de	e8 00 00 00 00	 call	 ?IsWhiteSpaceCondensed@TiXmlBase@@SA_NXZ ; TiXmlBase::IsWhiteSpaceCondensed
  000e3	0f b6 c8	 movzx	 ecx, al
  000e6	85 c9		 test	 ecx, ecx
  000e8	74 1e		 je	 SHORT $LN11@ReadValue

; 1195 :             {
; 1196 :                 p = textNode->Parse( p, data, encoding );

  000ea	8b 55 10	 mov	 edx, DWORD PTR _encoding$[ebp]
  000ed	52		 push	 edx
  000ee	8b 45 0c	 mov	 eax, DWORD PTR _data$[ebp]
  000f1	50		 push	 eax
  000f2	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  000f5	51		 push	 ecx
  000f6	8b 55 e8	 mov	 edx, DWORD PTR _textNode$21538[ebp]
  000f9	8b 02		 mov	 eax, DWORD PTR [edx]
  000fb	8b 4d e8	 mov	 ecx, DWORD PTR _textNode$21538[ebp]
  000fe	8b 50 08	 mov	 edx, DWORD PTR [eax+8]
  00101	ff d2		 call	 edx
  00103	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1197 :             }
; 1198 :             else

  00106	eb 1c		 jmp	 SHORT $LN10@ReadValue
$LN11@ReadValue:

; 1199 :             {
; 1200 :                 // Special case: we want to keep the white space
; 1201 :                 // so that leading spaces aren't removed.
; 1202 :                 p = textNode->Parse( pWithWhiteSpace, data, encoding );

  00108	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  0010b	50		 push	 eax
  0010c	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  0010f	51		 push	 ecx
  00110	8b 55 ec	 mov	 edx, DWORD PTR _pWithWhiteSpace$[ebp]
  00113	52		 push	 edx
  00114	8b 45 e8	 mov	 eax, DWORD PTR _textNode$21538[ebp]
  00117	8b 10		 mov	 edx, DWORD PTR [eax]
  00119	8b 4d e8	 mov	 ecx, DWORD PTR _textNode$21538[ebp]
  0011c	8b 42 08	 mov	 eax, DWORD PTR [edx+8]
  0011f	ff d0		 call	 eax
  00121	89 45 08	 mov	 DWORD PTR _p$[ebp], eax
$LN10@ReadValue:

; 1203 :             }
; 1204 : 
; 1205 :             if ( !textNode->Blank() )

  00124	8b 4d e8	 mov	 ecx, DWORD PTR _textNode$21538[ebp]
  00127	e8 00 00 00 00	 call	 ?Blank@TiXmlText@@IBE_NXZ ; TiXmlText::Blank
  0012c	0f b6 c8	 movzx	 ecx, al
  0012f	85 c9		 test	 ecx, ecx
  00131	75 0e		 jne	 SHORT $LN9@ReadValue

; 1206 :                 LinkEndChild( textNode );

  00133	8b 55 e8	 mov	 edx, DWORD PTR _textNode$21538[ebp]
  00136	52		 push	 edx
  00137	8b 4d d0	 mov	 ecx, DWORD PTR _this$[ebp]
  0013a	e8 00 00 00 00	 call	 ?LinkEndChild@TiXmlNode@@QAEPAV1@PAV1@@Z ; TiXmlNode::LinkEndChild

; 1207 :             else

  0013f	eb 2c		 jmp	 SHORT $LN8@ReadValue
$LN9@ReadValue:

; 1208 :                 delete textNode;

  00141	8b 45 e8	 mov	 eax, DWORD PTR _textNode$21538[ebp]
  00144	89 45 d4	 mov	 DWORD PTR $T343178[ebp], eax
  00147	8b 4d d4	 mov	 ecx, DWORD PTR $T343178[ebp]
  0014a	89 4d d8	 mov	 DWORD PTR $T343177[ebp], ecx
  0014d	83 7d d8 00	 cmp	 DWORD PTR $T343177[ebp], 0
  00151	74 13		 je	 SHORT $LN21@ReadValue
  00153	6a 01		 push	 1
  00155	8b 55 d8	 mov	 edx, DWORD PTR $T343177[ebp]
  00158	8b 02		 mov	 eax, DWORD PTR [edx]
  0015a	8b 4d d8	 mov	 ecx, DWORD PTR $T343177[ebp]
  0015d	8b 10		 mov	 edx, DWORD PTR [eax]
  0015f	ff d2		 call	 edx
  00161	89 45 c8	 mov	 DWORD PTR tv174[ebp], eax
  00164	eb 07		 jmp	 SHORT $LN8@ReadValue
$LN21@ReadValue:
  00166	c7 45 c8 00 00
	00 00		 mov	 DWORD PTR tv174[ebp], 0
$LN8@ReadValue:

; 1209 :         }
; 1210 :         else

  0016d	eb 6f		 jmp	 SHORT $LN7@ReadValue
$LN14@ReadValue:

; 1211 :         {
; 1212 :             // We hit a '<'
; 1213 :             // Have we hit a new element or an end tag? This could also be
; 1214 :             // a TiXmlText in the "CDATA" style.
; 1215 :             if ( StringEqual( p, "</", false, encoding ) )

  0016f	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  00172	50		 push	 eax
  00173	6a 00		 push	 0
  00175	68 00 00 00 00	 push	 OFFSET ??_C@_02DPNDACHE@?$DM?1?$AA@
  0017a	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0017d	51		 push	 ecx
  0017e	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  00183	83 c4 10	 add	 esp, 16			; 00000010H
  00186	0f b6 d0	 movzx	 edx, al
  00189	85 d2		 test	 edx, edx
  0018b	74 0a		 je	 SHORT $LN6@ReadValue

; 1216 :             {
; 1217 :                 return p;

  0018d	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00190	e9 88 00 00 00	 jmp	 $LN17@ReadValue

; 1218 :             }
; 1219 :             else

  00195	eb 47		 jmp	 SHORT $LN7@ReadValue
$LN6@ReadValue:

; 1220 :             {
; 1221 :                 TiXmlNode* node = Identify( p, encoding );

  00197	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  0019a	50		 push	 eax
  0019b	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0019e	51		 push	 ecx
  0019f	8b 4d d0	 mov	 ecx, DWORD PTR _this$[ebp]
  001a2	e8 00 00 00 00	 call	 ?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z ; TiXmlNode::Identify
  001a7	89 45 e4	 mov	 DWORD PTR _node$21554[ebp], eax

; 1222 :                 if ( node )

  001aa	83 7d e4 00	 cmp	 DWORD PTR _node$21554[ebp], 0
  001ae	74 2a		 je	 SHORT $LN4@ReadValue

; 1223 :                 {
; 1224 :                     p = node->Parse( p, data, encoding );

  001b0	8b 55 10	 mov	 edx, DWORD PTR _encoding$[ebp]
  001b3	52		 push	 edx
  001b4	8b 45 0c	 mov	 eax, DWORD PTR _data$[ebp]
  001b7	50		 push	 eax
  001b8	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  001bb	51		 push	 ecx
  001bc	8b 55 e4	 mov	 edx, DWORD PTR _node$21554[ebp]
  001bf	8b 02		 mov	 eax, DWORD PTR [edx]
  001c1	8b 4d e4	 mov	 ecx, DWORD PTR _node$21554[ebp]
  001c4	8b 50 08	 mov	 edx, DWORD PTR [eax+8]
  001c7	ff d2		 call	 edx
  001c9	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1225 :                     LinkEndChild( node );

  001cc	8b 45 e4	 mov	 eax, DWORD PTR _node$21554[ebp]
  001cf	50		 push	 eax
  001d0	8b 4d d0	 mov	 ecx, DWORD PTR _this$[ebp]
  001d3	e8 00 00 00 00	 call	 ?LinkEndChild@TiXmlNode@@QAEPAV1@PAV1@@Z ; TiXmlNode::LinkEndChild

; 1226 :                 }
; 1227 :                 else

  001d8	eb 04		 jmp	 SHORT $LN7@ReadValue
$LN4@ReadValue:

; 1228 :                 {
; 1229 :                     return 0;

  001da	33 c0		 xor	 eax, eax
  001dc	eb 3f		 jmp	 SHORT $LN17@ReadValue
$LN7@ReadValue:

; 1230 :                 }
; 1231 :             }
; 1232 :         }
; 1233 :         pWithWhiteSpace = p;

  001de	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  001e1	89 4d ec	 mov	 DWORD PTR _pWithWhiteSpace$[ebp], ecx

; 1234 :         p = SkipWhiteSpace( p, encoding );

  001e4	8b 55 10	 mov	 edx, DWORD PTR _encoding$[ebp]
  001e7	52		 push	 edx
  001e8	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  001eb	50		 push	 eax
  001ec	e8 00 00 00 00	 call	 ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
  001f1	83 c4 08	 add	 esp, 8
  001f4	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1235 :     }

  001f7	e9 50 fe ff ff	 jmp	 $LN16@ReadValue
$LN15@ReadValue:

; 1236 : 
; 1237 :     if ( !p )

  001fc	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00200	75 18		 jne	 SHORT $LN2@ReadValue

; 1238 :     {
; 1239 :         if ( document ) document->SetError( TIXML_ERROR_READING_ELEMENT_VALUE, 0, 0, encoding );

  00202	83 7d f0 00	 cmp	 DWORD PTR _document$[ebp], 0
  00206	74 12		 je	 SHORT $LN2@ReadValue
  00208	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  0020b	51		 push	 ecx
  0020c	6a 00		 push	 0
  0020e	6a 00		 push	 0
  00210	6a 06		 push	 6
  00212	8b 4d f0	 mov	 ecx, DWORD PTR _document$[ebp]
  00215	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN2@ReadValue:

; 1240 :     }
; 1241 :     return p;

  0021a	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
$LN17@ReadValue:

; 1242 : }

  0021d	8b 4d f4	 mov	 ecx, DWORD PTR __$EHRec$[ebp]
  00220	64 89 0d 00 00
	00 00		 mov	 DWORD PTR fs:0, ecx
  00227	59		 pop	 ecx
  00228	8b e5		 mov	 esp, ebp
  0022a	5d		 pop	 ebp
  0022b	c2 0c 00	 ret	 12			; 0000000cH
_TEXT	ENDS
;	COMDAT text$x
text$x	SEGMENT
__unwindfunclet$?ReadValue@TiXmlElement@@IAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z$0:
  00000	8b 45 dc	 mov	 eax, DWORD PTR $T343174[ebp]
  00003	50		 push	 eax
  00004	e8 00 00 00 00	 call	 ??3@YAXPAX@Z		; operator delete
  00009	59		 pop	 ecx
  0000a	c3		 ret	 0
__ehhandler$?ReadValue@TiXmlElement@@IAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z:
  0000b	8b 54 24 08	 mov	 edx, DWORD PTR [esp+8]
  0000f	8d 42 0c	 lea	 eax, DWORD PTR [edx+12]
  00012	8b 4a d0	 mov	 ecx, DWORD PTR [edx-48]
  00015	33 c8		 xor	 ecx, eax
  00017	e8 00 00 00 00	 call	 @__security_check_cookie@4
  0001c	b8 00 00 00 00	 mov	 eax, OFFSET __ehfuncinfo$?ReadValue@TiXmlElement@@IAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
  00021	e9 00 00 00 00	 jmp	 ___CxxFrameHandler3
text$x	ENDS
?ReadValue@TiXmlElement@@IAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ENDP ; TiXmlElement::ReadValue
PUBLIC	__$ArrayPad$
;	COMDAT xdata$x
xdata$x	SEGMENT
__unwindtable$?Parse@TiXmlElement@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z DD 0ffffffffH
	DD	FLAT:__unwindfunclet$?Parse@TiXmlElement@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z$0
	DD	00H
	DD	FLAT:__unwindfunclet$?Parse@TiXmlElement@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z$1
__ehfuncinfo$?Parse@TiXmlElement@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z DD 019930522H
	DD	02H
	DD	FLAT:__unwindtable$?Parse@TiXmlElement@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
	DD	2 DUP(00H)
	DD	2 DUP(00H)
	DD	00H
	DD	00H
; Function compile flags: /Odtp
xdata$x	ENDS
;	COMDAT ?Parse@TiXmlElement@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
_TEXT	SEGMENT
tv293 = -140						; size = 4
tv271 = -136						; size = 4
tv232 = -132						; size = 4
_this$ = -128						; size = 4
$T343212 = -124						; size = 4
$T343211 = -120						; size = 4
$T343208 = -116						; size = 4
$T343207 = -112						; size = 4
$T343206 = -108						; size = 4
$T343203 = -104						; size = 4
$T343202 = -100						; size = 4
$T343201 = -96						; size = 4
$T343198 = -92						; size = 4
$T343197 = -88						; size = 4
$T343196 = -84						; size = 4
$T343195 = -80						; size = 4
$T343194 = -76						; size = 4
$T343193 = -72						; size = 4
$T343192 = -68						; size = 4
$T343191 = -64						; size = 4
_node$21520 = -60					; size = 4
_attrib$21506 = -56					; size = 4
_endTag$ = -52						; size = 28
__$ArrayPad$ = -24					; size = 4
_document$ = -20					; size = 4
_pErr$ = -16						; size = 4
__$EHRec$ = -12						; size = 12
_p$ = 8							; size = 4
_data$ = 12						; size = 4
_encoding$ = 16						; size = 4
?Parse@TiXmlElement@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z PROC ; TiXmlElement::Parse, COMDAT
; _this$ = ecx

; 1050 : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	6a ff		 push	 -1
  00005	68 00 00 00 00	 push	 __ehhandler$?Parse@TiXmlElement@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
  0000a	64 a1 00 00 00
	00		 mov	 eax, DWORD PTR fs:0
  00010	50		 push	 eax
  00011	81 ec 80 00 00
	00		 sub	 esp, 128		; 00000080H
  00017	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  0001c	33 c5		 xor	 eax, ebp
  0001e	89 45 e8	 mov	 DWORD PTR __$ArrayPad$[ebp], eax
  00021	50		 push	 eax
  00022	8d 45 f4	 lea	 eax, DWORD PTR __$EHRec$[ebp]
  00025	64 a3 00 00 00
	00		 mov	 DWORD PTR fs:0, eax
  0002b	89 4d 80	 mov	 DWORD PTR _this$[ebp], ecx

; 1051 :     p = SkipWhiteSpace( p, encoding );

  0002e	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  00031	50		 push	 eax
  00032	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00035	51		 push	 ecx
  00036	e8 00 00 00 00	 call	 ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
  0003b	83 c4 08	 add	 esp, 8
  0003e	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1052 :     TiXmlDocument* document = GetDocument();

  00041	8b 4d 80	 mov	 ecx, DWORD PTR _this$[ebp]
  00044	e8 00 00 00 00	 call	 ?GetDocument@TiXmlNode@@QAEPAVTiXmlDocument@@XZ ; TiXmlNode::GetDocument
  00049	89 45 ec	 mov	 DWORD PTR _document$[ebp], eax

; 1053 : 
; 1054 :     if ( !p || !*p )

  0004c	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00050	74 0a		 je	 SHORT $LN30@Parse@7
  00052	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00055	0f be 02	 movsx	 eax, BYTE PTR [edx]
  00058	85 c0		 test	 eax, eax
  0005a	75 1f		 jne	 SHORT $LN31@Parse@7
$LN30@Parse@7:

; 1055 :     {
; 1056 :         if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, 0, 0, encoding );

  0005c	83 7d ec 00	 cmp	 DWORD PTR _document$[ebp], 0
  00060	74 12		 je	 SHORT $LN29@Parse@7
  00062	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  00065	51		 push	 ecx
  00066	6a 00		 push	 0
  00068	6a 00		 push	 0
  0006a	6a 04		 push	 4
  0006c	8b 4d ec	 mov	 ecx, DWORD PTR _document$[ebp]
  0006f	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN29@Parse@7:

; 1057 :         return 0;

  00074	33 c0		 xor	 eax, eax
  00076	e9 ac 04 00 00	 jmp	 $LN32@Parse@7
$LN31@Parse@7:

; 1058 :     }
; 1059 : 
; 1060 :     if ( data )

  0007b	83 7d 0c 00	 cmp	 DWORD PTR _data$[ebp], 0
  0007f	74 26		 je	 SHORT $LN28@Parse@7

; 1061 :     {
; 1062 :         data->Stamp( p, encoding );

  00081	8b 55 10	 mov	 edx, DWORD PTR _encoding$[ebp]
  00084	52		 push	 edx
  00085	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00088	50		 push	 eax
  00089	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  0008c	e8 00 00 00 00	 call	 ?Stamp@TiXmlParsingData@@QAEXPBDW4TiXmlEncoding@@@Z ; TiXmlParsingData::Stamp

; 1063 :         location = data->Cursor();

  00091	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  00094	e8 00 00 00 00	 call	 ?Cursor@TiXmlParsingData@@QAEABUTiXmlCursor@@XZ ; TiXmlParsingData::Cursor
  00099	8b 08		 mov	 ecx, DWORD PTR [eax]
  0009b	8b 50 04	 mov	 edx, DWORD PTR [eax+4]
  0009e	8b 45 80	 mov	 eax, DWORD PTR _this$[ebp]
  000a1	89 48 04	 mov	 DWORD PTR [eax+4], ecx
  000a4	89 50 08	 mov	 DWORD PTR [eax+8], edx
$LN28@Parse@7:

; 1064 :     }
; 1065 : 
; 1066 :     if ( *p != '<' )

  000a7	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  000aa	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  000ad	83 fa 3c	 cmp	 edx, 60			; 0000003cH
  000b0	74 23		 je	 SHORT $LN27@Parse@7

; 1067 :     {
; 1068 :         if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, p, data, encoding );

  000b2	83 7d ec 00	 cmp	 DWORD PTR _document$[ebp], 0
  000b6	74 16		 je	 SHORT $LN26@Parse@7
  000b8	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  000bb	50		 push	 eax
  000bc	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  000bf	51		 push	 ecx
  000c0	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  000c3	52		 push	 edx
  000c4	6a 04		 push	 4
  000c6	8b 4d ec	 mov	 ecx, DWORD PTR _document$[ebp]
  000c9	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN26@Parse@7:

; 1069 :         return 0;

  000ce	33 c0		 xor	 eax, eax
  000d0	e9 52 04 00 00	 jmp	 $LN32@Parse@7
$LN27@Parse@7:

; 1070 :     }
; 1071 : 
; 1072 :     p = SkipWhiteSpace( p+1, encoding );

  000d5	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  000d8	50		 push	 eax
  000d9	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  000dc	83 c1 01	 add	 ecx, 1
  000df	51		 push	 ecx
  000e0	e8 00 00 00 00	 call	 ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
  000e5	83 c4 08	 add	 esp, 8
  000e8	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1073 : 
; 1074 :     // Read the name.
; 1075 :     const char* pErr = p;

  000eb	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  000ee	89 55 f0	 mov	 DWORD PTR _pErr$[ebp], edx

; 1076 : 
; 1077 :     p = ReadName( p, &value, encoding );

  000f1	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  000f4	50		 push	 eax
  000f5	8b 4d 80	 mov	 ecx, DWORD PTR _this$[ebp]
  000f8	83 c1 20	 add	 ecx, 32			; 00000020H
  000fb	51		 push	 ecx
  000fc	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  000ff	52		 push	 edx
  00100	e8 00 00 00 00	 call	 ?ReadName@TiXmlBase@@KAPBDPBDPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@W4TiXmlEncoding@@@Z ; TiXmlBase::ReadName
  00105	83 c4 0c	 add	 esp, 12			; 0000000cH
  00108	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1078 :     if ( !p || !*p )

  0010b	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  0010f	74 0a		 je	 SHORT $LN24@Parse@7
  00111	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00114	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  00117	85 c9		 test	 ecx, ecx
  00119	75 23		 jne	 SHORT $LN25@Parse@7
$LN24@Parse@7:

; 1079 :     {
; 1080 :         if ( document )    document->SetError( TIXML_ERROR_FAILED_TO_READ_ELEMENT_NAME, pErr, data, encoding );

  0011b	83 7d ec 00	 cmp	 DWORD PTR _document$[ebp], 0
  0011f	74 16		 je	 SHORT $LN23@Parse@7
  00121	8b 55 10	 mov	 edx, DWORD PTR _encoding$[ebp]
  00124	52		 push	 edx
  00125	8b 45 0c	 mov	 eax, DWORD PTR _data$[ebp]
  00128	50		 push	 eax
  00129	8b 4d f0	 mov	 ecx, DWORD PTR _pErr$[ebp]
  0012c	51		 push	 ecx
  0012d	6a 05		 push	 5
  0012f	8b 4d ec	 mov	 ecx, DWORD PTR _document$[ebp]
  00132	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN23@Parse@7:

; 1081 :         return 0;

  00137	33 c0		 xor	 eax, eax
  00139	e9 e9 03 00 00	 jmp	 $LN32@Parse@7
$LN25@Parse@7:

; 1082 :     }
; 1083 : 
; 1084 :     TIXML_STRING endTag ("</");

  0013e	68 00 00 00 00	 push	 OFFSET ??_C@_02DPNDACHE@?$DM?1?$AA@
  00143	8d 4d cc	 lea	 ecx, DWORD PTR _endTag$[ebp]
  00146	e8 00 00 00 00	 call	 ??0?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@PBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::basic_string<char,std::char_traits<char>,std::allocator<char> >
  0014b	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+8], 0

; 1085 :     endTag += value;

  00152	8b 55 80	 mov	 edx, DWORD PTR _this$[ebp]
  00155	83 c2 20	 add	 edx, 32			; 00000020H
  00158	52		 push	 edx
  00159	8d 4d cc	 lea	 ecx, DWORD PTR _endTag$[ebp]
  0015c	e8 00 00 00 00	 call	 ??Y?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@ABV01@@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator+=

; 1086 :     endTag += ">";

  00161	68 00 00 00 00	 push	 OFFSET ??_C@_01PPODPGHN@?$DO?$AA@
  00166	8d 4d cc	 lea	 ecx, DWORD PTR _endTag$[ebp]
  00169	e8 00 00 00 00	 call	 ??Y?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@PBD@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator+=
$LN22@Parse@7:

; 1087 : 
; 1088 :     // Check for and read attributes. Also look for an empty
; 1089 :     // tag or an end tag.
; 1090 :     while ( p && *p )

  0016e	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00172	0f 84 97 03 00
	00		 je	 $LN21@Parse@7
  00178	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0017b	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  0017e	85 c9		 test	 ecx, ecx
  00180	0f 84 89 03 00
	00		 je	 $LN21@Parse@7

; 1091 :     {
; 1092 :         pErr = p;

  00186	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00189	89 55 f0	 mov	 DWORD PTR _pErr$[ebp], edx

; 1093 :         p = SkipWhiteSpace( p, encoding );

  0018c	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  0018f	50		 push	 eax
  00190	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00193	51		 push	 ecx
  00194	e8 00 00 00 00	 call	 ?SkipWhiteSpace@TiXmlBase@@KAPBDPBDW4TiXmlEncoding@@@Z ; TiXmlBase::SkipWhiteSpace
  00199	83 c4 08	 add	 esp, 8
  0019c	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1094 :         if ( !p || !*p )

  0019f	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  001a3	74 0a		 je	 SHORT $LN19@Parse@7
  001a5	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  001a8	0f be 02	 movsx	 eax, BYTE PTR [edx]
  001ab	85 c0		 test	 eax, eax
  001ad	75 3a		 jne	 SHORT $LN20@Parse@7
$LN19@Parse@7:

; 1095 :         {
; 1096 :             if ( document ) document->SetError( TIXML_ERROR_READING_ATTRIBUTES, pErr, data, encoding );

  001af	83 7d ec 00	 cmp	 DWORD PTR _document$[ebp], 0
  001b3	74 16		 je	 SHORT $LN18@Parse@7
  001b5	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  001b8	51		 push	 ecx
  001b9	8b 55 0c	 mov	 edx, DWORD PTR _data$[ebp]
  001bc	52		 push	 edx
  001bd	8b 45 f0	 mov	 eax, DWORD PTR _pErr$[ebp]
  001c0	50		 push	 eax
  001c1	6a 07		 push	 7
  001c3	8b 4d ec	 mov	 ecx, DWORD PTR _document$[ebp]
  001c6	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN18@Parse@7:

; 1097 :             return 0;

  001cb	c7 45 c0 00 00
	00 00		 mov	 DWORD PTR $T343191[ebp], 0
  001d2	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  001d9	8d 4d cc	 lea	 ecx, DWORD PTR _endTag$[ebp]
  001dc	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  001e1	8b 45 c0	 mov	 eax, DWORD PTR $T343191[ebp]
  001e4	e9 3e 03 00 00	 jmp	 $LN32@Parse@7
$LN20@Parse@7:

; 1098 :         }
; 1099 :         if ( *p == '/' )

  001e9	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  001ec	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  001ef	83 fa 2f	 cmp	 edx, 47			; 0000002fH
  001f2	75 73		 jne	 SHORT $LN17@Parse@7

; 1100 :         {
; 1101 :             ++p;

  001f4	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  001f7	83 c0 01	 add	 eax, 1
  001fa	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1102 :             // Empty tag.
; 1103 :             if ( *p  != '>' )

  001fd	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  00200	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  00203	83 fa 3e	 cmp	 edx, 62			; 0000003eH
  00206	74 3a		 je	 SHORT $LN16@Parse@7

; 1104 :             {
; 1105 :                 if ( document ) document->SetError( TIXML_ERROR_PARSING_EMPTY, p, data, encoding );

  00208	83 7d ec 00	 cmp	 DWORD PTR _document$[ebp], 0
  0020c	74 16		 je	 SHORT $LN15@Parse@7
  0020e	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  00211	50		 push	 eax
  00212	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  00215	51		 push	 ecx
  00216	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00219	52		 push	 edx
  0021a	6a 08		 push	 8
  0021c	8b 4d ec	 mov	 ecx, DWORD PTR _document$[ebp]
  0021f	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN15@Parse@7:

; 1106 :                 return 0;

  00224	c7 45 bc 00 00
	00 00		 mov	 DWORD PTR $T343192[ebp], 0
  0022b	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  00232	8d 4d cc	 lea	 ecx, DWORD PTR _endTag$[ebp]
  00235	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  0023a	8b 45 bc	 mov	 eax, DWORD PTR $T343192[ebp]
  0023d	e9 e5 02 00 00	 jmp	 $LN32@Parse@7
$LN16@Parse@7:

; 1107 :             }
; 1108 :             return (p+1);

  00242	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00245	83 c0 01	 add	 eax, 1
  00248	89 45 b8	 mov	 DWORD PTR $T343193[ebp], eax
  0024b	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  00252	8d 4d cc	 lea	 ecx, DWORD PTR _endTag$[ebp]
  00255	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  0025a	8b 45 b8	 mov	 eax, DWORD PTR $T343193[ebp]
  0025d	e9 c5 02 00 00	 jmp	 $LN32@Parse@7
  00262	e9 a3 02 00 00	 jmp	 $LN14@Parse@7
$LN17@Parse@7:

; 1109 :         }
; 1110 :         else if ( *p == '>' )

  00267	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0026a	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  0026d	83 fa 3e	 cmp	 edx, 62			; 0000003eH
  00270	0f 85 dc 00 00
	00		 jne	 $LN13@Parse@7

; 1111 :         {
; 1112 :             // Done with attributes (if there were any.)
; 1113 :             // Read the value -- which can include other
; 1114 :             // elements -- read the end tag, and return.
; 1115 :             ++p;

  00276	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00279	83 c0 01	 add	 eax, 1
  0027c	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1116 :             p = ReadValue( p, data, encoding );        // Note this is an Element method, and will set the error if one happens.

  0027f	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  00282	51		 push	 ecx
  00283	8b 55 0c	 mov	 edx, DWORD PTR _data$[ebp]
  00286	52		 push	 edx
  00287	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0028a	50		 push	 eax
  0028b	8b 4d 80	 mov	 ecx, DWORD PTR _this$[ebp]
  0028e	e8 00 00 00 00	 call	 ?ReadValue@TiXmlElement@@IAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlElement::ReadValue
  00293	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1117 :             if ( !p || !*p )

  00296	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  0029a	74 0a		 je	 SHORT $LN11@Parse@7
  0029c	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  0029f	0f be 11	 movsx	 edx, BYTE PTR [ecx]
  002a2	85 d2		 test	 edx, edx
  002a4	75 1e		 jne	 SHORT $LN12@Parse@7
$LN11@Parse@7:

; 1118 :                 return 0;

  002a6	c7 45 b4 00 00
	00 00		 mov	 DWORD PTR $T343194[ebp], 0
  002ad	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  002b4	8d 4d cc	 lea	 ecx, DWORD PTR _endTag$[ebp]
  002b7	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  002bc	8b 45 b4	 mov	 eax, DWORD PTR $T343194[ebp]
  002bf	e9 63 02 00 00	 jmp	 $LN32@Parse@7
$LN12@Parse@7:

; 1119 : 
; 1120 :             // We should find the end tag now
; 1121 :             if ( StringEqual( p, endTag.c_str(), false, encoding ) )

  002c4	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  002c7	50		 push	 eax
  002c8	6a 00		 push	 0
  002ca	8d 4d cc	 lea	 ecx, DWORD PTR _endTag$[ebp]
  002cd	e8 00 00 00 00	 call	 ?c_str@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEPBDXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::c_str
  002d2	50		 push	 eax
  002d3	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  002d6	51		 push	 ecx
  002d7	e8 00 00 00 00	 call	 ?StringEqual@TiXmlBase@@KA_NPBD0_NW4TiXmlEncoding@@@Z ; TiXmlBase::StringEqual
  002dc	83 c4 10	 add	 esp, 16			; 00000010H
  002df	0f b6 d0	 movzx	 edx, al
  002e2	85 d2		 test	 edx, edx
  002e4	74 2d		 je	 SHORT $LN10@Parse@7

; 1122 :             {
; 1123 :                 p += endTag.length();

  002e6	8d 4d cc	 lea	 ecx, DWORD PTR _endTag$[ebp]
  002e9	e8 00 00 00 00	 call	 ?length@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEIXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::length
  002ee	03 45 08	 add	 eax, DWORD PTR _p$[ebp]
  002f1	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1124 :                 return p;

  002f4	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  002f7	89 45 b0	 mov	 DWORD PTR $T343195[ebp], eax
  002fa	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  00301	8d 4d cc	 lea	 ecx, DWORD PTR _endTag$[ebp]
  00304	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  00309	8b 45 b0	 mov	 eax, DWORD PTR $T343195[ebp]
  0030c	e9 16 02 00 00	 jmp	 $LN32@Parse@7

; 1125 :             }
; 1126 :             else

  00311	eb 3a		 jmp	 SHORT $LN9@Parse@7
$LN10@Parse@7:

; 1127 :             {
; 1128 :                 if ( document ) document->SetError( TIXML_ERROR_READING_END_TAG, p, data, encoding );

  00313	83 7d ec 00	 cmp	 DWORD PTR _document$[ebp], 0
  00317	74 16		 je	 SHORT $LN8@Parse@7
  00319	8b 4d 10	 mov	 ecx, DWORD PTR _encoding$[ebp]
  0031c	51		 push	 ecx
  0031d	8b 55 0c	 mov	 edx, DWORD PTR _data$[ebp]
  00320	52		 push	 edx
  00321	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  00324	50		 push	 eax
  00325	6a 09		 push	 9
  00327	8b 4d ec	 mov	 ecx, DWORD PTR _document$[ebp]
  0032a	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN8@Parse@7:

; 1129 :                 return 0;

  0032f	c7 45 ac 00 00
	00 00		 mov	 DWORD PTR $T343196[ebp], 0
  00336	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  0033d	8d 4d cc	 lea	 ecx, DWORD PTR _endTag$[ebp]
  00340	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  00345	8b 45 ac	 mov	 eax, DWORD PTR $T343196[ebp]
  00348	e9 da 01 00 00	 jmp	 $LN32@Parse@7
$LN9@Parse@7:

; 1130 :             }
; 1131 :         }
; 1132 :         else

  0034d	e9 b8 01 00 00	 jmp	 $LN14@Parse@7
$LN13@Parse@7:

; 1133 :         {
; 1134 :             // Try to read an attribute:
; 1135 :             TiXmlAttribute* attrib = new TiXmlAttribute();

  00352	6a 54		 push	 84			; 00000054H
  00354	e8 00 00 00 00	 call	 ??2@YAPAXI@Z		; operator new
  00359	83 c4 04	 add	 esp, 4
  0035c	89 45 a4	 mov	 DWORD PTR $T343198[ebp], eax
  0035f	c6 45 fc 01	 mov	 BYTE PTR __$EHRec$[ebp+8], 1
  00363	83 7d a4 00	 cmp	 DWORD PTR $T343198[ebp], 0
  00367	74 10		 je	 SHORT $LN34@Parse@7
  00369	8b 4d a4	 mov	 ecx, DWORD PTR $T343198[ebp]
  0036c	e8 00 00 00 00	 call	 ??0TiXmlAttribute@@QAE@XZ ; TiXmlAttribute::TiXmlAttribute
  00371	89 85 7c ff ff
	ff		 mov	 DWORD PTR tv232[ebp], eax
  00377	eb 0a		 jmp	 SHORT $LN35@Parse@7
$LN34@Parse@7:
  00379	c7 85 7c ff ff
	ff 00 00 00 00	 mov	 DWORD PTR tv232[ebp], 0
$LN35@Parse@7:
  00383	8b 8d 7c ff ff
	ff		 mov	 ecx, DWORD PTR tv232[ebp]
  00389	89 4d a8	 mov	 DWORD PTR $T343197[ebp], ecx
  0038c	c6 45 fc 00	 mov	 BYTE PTR __$EHRec$[ebp+8], 0
  00390	8b 55 a8	 mov	 edx, DWORD PTR $T343197[ebp]
  00393	89 55 c8	 mov	 DWORD PTR _attrib$21506[ebp], edx

; 1136 :             if ( !attrib )

  00396	83 7d c8 00	 cmp	 DWORD PTR _attrib$21506[ebp], 0
  0039a	75 3a		 jne	 SHORT $LN6@Parse@7

; 1137 :             {
; 1138 :                 if ( document ) document->SetError( TIXML_ERROR_OUT_OF_MEMORY, pErr, data, encoding );

  0039c	83 7d ec 00	 cmp	 DWORD PTR _document$[ebp], 0
  003a0	74 16		 je	 SHORT $LN5@Parse@7
  003a2	8b 45 10	 mov	 eax, DWORD PTR _encoding$[ebp]
  003a5	50		 push	 eax
  003a6	8b 4d 0c	 mov	 ecx, DWORD PTR _data$[ebp]
  003a9	51		 push	 ecx
  003aa	8b 55 f0	 mov	 edx, DWORD PTR _pErr$[ebp]
  003ad	52		 push	 edx
  003ae	6a 03		 push	 3
  003b0	8b 4d ec	 mov	 ecx, DWORD PTR _document$[ebp]
  003b3	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN5@Parse@7:

; 1139 :                 return 0;

  003b8	c7 45 a0 00 00
	00 00		 mov	 DWORD PTR $T343201[ebp], 0
  003bf	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  003c6	8d 4d cc	 lea	 ecx, DWORD PTR _endTag$[ebp]
  003c9	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  003ce	8b 45 a0	 mov	 eax, DWORD PTR $T343201[ebp]
  003d1	e9 51 01 00 00	 jmp	 $LN32@Parse@7
$LN6@Parse@7:

; 1140 :             }
; 1141 : 
; 1142 :             attrib->SetDocument( document );

  003d6	8b 45 ec	 mov	 eax, DWORD PTR _document$[ebp]
  003d9	50		 push	 eax
  003da	8b 4d c8	 mov	 ecx, DWORD PTR _attrib$21506[ebp]
  003dd	e8 00 00 00 00	 call	 ?SetDocument@TiXmlAttribute@@QAEXPAVTiXmlDocument@@@Z ; TiXmlAttribute::SetDocument

; 1143 :             pErr = p;

  003e2	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  003e5	89 4d f0	 mov	 DWORD PTR _pErr$[ebp], ecx

; 1144 :             p = attrib->Parse( p, data, encoding );

  003e8	8b 55 10	 mov	 edx, DWORD PTR _encoding$[ebp]
  003eb	52		 push	 edx
  003ec	8b 45 0c	 mov	 eax, DWORD PTR _data$[ebp]
  003ef	50		 push	 eax
  003f0	8b 4d 08	 mov	 ecx, DWORD PTR _p$[ebp]
  003f3	51		 push	 ecx
  003f4	8b 55 c8	 mov	 edx, DWORD PTR _attrib$21506[ebp]
  003f7	8b 02		 mov	 eax, DWORD PTR [edx]
  003f9	8b 4d c8	 mov	 ecx, DWORD PTR _attrib$21506[ebp]
  003fc	8b 50 08	 mov	 edx, DWORD PTR [eax+8]
  003ff	ff d2		 call	 edx
  00401	89 45 08	 mov	 DWORD PTR _p$[ebp], eax

; 1145 : 
; 1146 :             if ( !p || !*p )

  00404	83 7d 08 00	 cmp	 DWORD PTR _p$[ebp], 0
  00408	74 0a		 je	 SHORT $LN3@Parse@7
  0040a	8b 45 08	 mov	 eax, DWORD PTR _p$[ebp]
  0040d	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  00410	85 c9		 test	 ecx, ecx
  00412	75 6c		 jne	 SHORT $LN4@Parse@7
$LN3@Parse@7:

; 1147 :             {
; 1148 :                 if ( document ) document->SetError( TIXML_ERROR_PARSING_ELEMENT, pErr, data, encoding );

  00414	83 7d ec 00	 cmp	 DWORD PTR _document$[ebp], 0
  00418	74 16		 je	 SHORT $LN2@Parse@7
  0041a	8b 55 10	 mov	 edx, DWORD PTR _encoding$[ebp]
  0041d	52		 push	 edx
  0041e	8b 45 0c	 mov	 eax, DWORD PTR _data$[ebp]
  00421	50		 push	 eax
  00422	8b 4d f0	 mov	 ecx, DWORD PTR _pErr$[ebp]
  00425	51		 push	 ecx
  00426	6a 04		 push	 4
  00428	8b 4d ec	 mov	 ecx, DWORD PTR _document$[ebp]
  0042b	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN2@Parse@7:

; 1149 :                 delete attrib;

  00430	8b 55 c8	 mov	 edx, DWORD PTR _attrib$21506[ebp]
  00433	89 55 98	 mov	 DWORD PTR $T343203[ebp], edx
  00436	8b 45 98	 mov	 eax, DWORD PTR $T343203[ebp]
  00439	89 45 9c	 mov	 DWORD PTR $T343202[ebp], eax
  0043c	83 7d 9c 00	 cmp	 DWORD PTR $T343202[ebp], 0
  00440	74 16		 je	 SHORT $LN36@Parse@7
  00442	6a 01		 push	 1
  00444	8b 4d 9c	 mov	 ecx, DWORD PTR $T343202[ebp]
  00447	8b 11		 mov	 edx, DWORD PTR [ecx]
  00449	8b 4d 9c	 mov	 ecx, DWORD PTR $T343202[ebp]
  0044c	8b 02		 mov	 eax, DWORD PTR [edx]
  0044e	ff d0		 call	 eax
  00450	89 85 78 ff ff
	ff		 mov	 DWORD PTR tv271[ebp], eax
  00456	eb 0a		 jmp	 SHORT $LN37@Parse@7
$LN36@Parse@7:
  00458	c7 85 78 ff ff
	ff 00 00 00 00	 mov	 DWORD PTR tv271[ebp], 0
$LN37@Parse@7:

; 1150 :                 return 0;

  00462	c7 45 94 00 00
	00 00		 mov	 DWORD PTR $T343206[ebp], 0
  00469	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  00470	8d 4d cc	 lea	 ecx, DWORD PTR _endTag$[ebp]
  00473	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  00478	8b 45 94	 mov	 eax, DWORD PTR $T343206[ebp]
  0047b	e9 a7 00 00 00	 jmp	 $LN32@Parse@7
$LN4@Parse@7:

; 1151 :             }
; 1152 : 
; 1153 :             // Handle the strange case of double attributes:
; 1154 :             #ifdef TIXML_USE_STL
; 1155 :             TiXmlAttribute* node = attributeSet.Find( attrib->NameTStr() );

  00480	8b 4d c8	 mov	 ecx, DWORD PTR _attrib$21506[ebp]
  00483	e8 00 00 00 00	 call	 ?NameTStr@TiXmlAttribute@@QBEABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@XZ ; TiXmlAttribute::NameTStr
  00488	50		 push	 eax
  00489	8b 4d 80	 mov	 ecx, DWORD PTR _this$[ebp]
  0048c	83 c1 44	 add	 ecx, 68			; 00000044H
  0048f	e8 00 00 00 00	 call	 ?Find@TiXmlAttributeSet@@QAEPAVTiXmlAttribute@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z ; TiXmlAttributeSet::Find
  00494	89 45 c4	 mov	 DWORD PTR _node$21520[ebp], eax

; 1156 :             #else
; 1157 :             TiXmlAttribute* node = attributeSet.Find( attrib->Name() );
; 1158 :             #endif
; 1159 :             if ( node )

  00497	83 7d c4 00	 cmp	 DWORD PTR _node$21520[ebp], 0
  0049b	74 5e		 je	 SHORT $LN1@Parse@7

; 1160 :             {
; 1161 :                 node->SetValue( attrib->Value() );

  0049d	8b 4d c8	 mov	 ecx, DWORD PTR _attrib$21506[ebp]
  004a0	e8 00 00 00 00	 call	 ?Value@TiXmlAttribute@@QBEPBDXZ ; TiXmlAttribute::Value
  004a5	50		 push	 eax
  004a6	8b 4d c4	 mov	 ecx, DWORD PTR _node$21520[ebp]
  004a9	e8 00 00 00 00	 call	 ?SetValue@TiXmlAttribute@@QAEXPBD@Z ; TiXmlAttribute::SetValue

; 1162 :                 delete attrib;

  004ae	8b 4d c8	 mov	 ecx, DWORD PTR _attrib$21506[ebp]
  004b1	89 4d 8c	 mov	 DWORD PTR $T343208[ebp], ecx
  004b4	8b 55 8c	 mov	 edx, DWORD PTR $T343208[ebp]
  004b7	89 55 90	 mov	 DWORD PTR $T343207[ebp], edx
  004ba	83 7d 90 00	 cmp	 DWORD PTR $T343207[ebp], 0
  004be	74 16		 je	 SHORT $LN38@Parse@7
  004c0	6a 01		 push	 1
  004c2	8b 45 90	 mov	 eax, DWORD PTR $T343207[ebp]
  004c5	8b 10		 mov	 edx, DWORD PTR [eax]
  004c7	8b 4d 90	 mov	 ecx, DWORD PTR $T343207[ebp]
  004ca	8b 02		 mov	 eax, DWORD PTR [edx]
  004cc	ff d0		 call	 eax
  004ce	89 85 74 ff ff
	ff		 mov	 DWORD PTR tv293[ebp], eax
  004d4	eb 0a		 jmp	 SHORT $LN39@Parse@7
$LN38@Parse@7:
  004d6	c7 85 74 ff ff
	ff 00 00 00 00	 mov	 DWORD PTR tv293[ebp], 0
$LN39@Parse@7:

; 1163 :                 return 0;

  004e0	c7 45 88 00 00
	00 00		 mov	 DWORD PTR $T343211[ebp], 0
  004e7	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  004ee	8d 4d cc	 lea	 ecx, DWORD PTR _endTag$[ebp]
  004f1	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  004f6	8b 45 88	 mov	 eax, DWORD PTR $T343211[ebp]
  004f9	eb 2c		 jmp	 SHORT $LN32@Parse@7
$LN1@Parse@7:

; 1164 :             }
; 1165 : 
; 1166 :             attributeSet.Add( attrib );

  004fb	8b 4d c8	 mov	 ecx, DWORD PTR _attrib$21506[ebp]
  004fe	51		 push	 ecx
  004ff	8b 4d 80	 mov	 ecx, DWORD PTR _this$[ebp]
  00502	83 c1 44	 add	 ecx, 68			; 00000044H
  00505	e8 00 00 00 00	 call	 ?Add@TiXmlAttributeSet@@QAEXPAVTiXmlAttribute@@@Z ; TiXmlAttributeSet::Add
$LN14@Parse@7:

; 1167 :         }
; 1168 :     }

  0050a	e9 5f fc ff ff	 jmp	 $LN22@Parse@7
$LN21@Parse@7:

; 1169 :     return p;

  0050f	8b 55 08	 mov	 edx, DWORD PTR _p$[ebp]
  00512	89 55 84	 mov	 DWORD PTR $T343212[ebp], edx
  00515	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  0051c	8d 4d cc	 lea	 ecx, DWORD PTR _endTag$[ebp]
  0051f	e8 00 00 00 00	 call	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
  00524	8b 45 84	 mov	 eax, DWORD PTR $T343212[ebp]
$LN32@Parse@7:

; 1170 : }

  00527	8b 4d f4	 mov	 ecx, DWORD PTR __$EHRec$[ebp]
  0052a	64 89 0d 00 00
	00 00		 mov	 DWORD PTR fs:0, ecx
  00531	59		 pop	 ecx
  00532	8b 4d e8	 mov	 ecx, DWORD PTR __$ArrayPad$[ebp]
  00535	33 cd		 xor	 ecx, ebp
  00537	e8 00 00 00 00	 call	 @__security_check_cookie@4
  0053c	8b e5		 mov	 esp, ebp
  0053e	5d		 pop	 ebp
  0053f	c2 0c 00	 ret	 12			; 0000000cH
_TEXT	ENDS
;	COMDAT text$x
text$x	SEGMENT
__unwindfunclet$?Parse@TiXmlElement@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z$0:
  00000	8d 4d cc	 lea	 ecx, DWORD PTR _endTag$[ebp]
  00003	e9 00 00 00 00	 jmp	 ??1?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAE@XZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::~basic_string<char,std::char_traits<char>,std::allocator<char> >
__unwindfunclet$?Parse@TiXmlElement@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z$1:
  00008	8b 45 a4	 mov	 eax, DWORD PTR $T343198[ebp]
  0000b	50		 push	 eax
  0000c	e8 00 00 00 00	 call	 ??3@YAXPAX@Z		; operator delete
  00011	59		 pop	 ecx
  00012	c3		 ret	 0
__ehhandler$?Parse@TiXmlElement@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z:
  00013	8b 54 24 08	 mov	 edx, DWORD PTR [esp+8]
  00017	8d 42 0c	 lea	 eax, DWORD PTR [edx+12]
  0001a	8b 8a 7c ff ff
	ff		 mov	 ecx, DWORD PTR [edx-132]
  00020	33 c8		 xor	 ecx, eax
  00022	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00027	8b 4a f4	 mov	 ecx, DWORD PTR [edx-12]
  0002a	33 c8		 xor	 ecx, eax
  0002c	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00031	b8 00 00 00 00	 mov	 eax, OFFSET __ehfuncinfo$?Parse@TiXmlElement@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z
  00036	e9 00 00 00 00	 jmp	 ___CxxFrameHandler3
text$x	ENDS
?Parse@TiXmlElement@@UAEPBDPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ENDP ; TiXmlElement::Parse
;	COMDAT xdata$x
; File c:\program files (x86)\microsoft visual studio 9.0\vc\include\istream
xdata$x	SEGMENT
__unwindtable$?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z DD 0ffffffffH
	DD	FLAT:__unwindfunclet$?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z$2
	DD	0ffffffffH
	DD	00H
	DD	0ffffffffH
	DD	00H
__catchsym$?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z$3 DD 00H
	DD	00H
	DD	00H
	DD	FLAT:__catch$?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z$0
__tryblocktable$?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z DD 01H
	DD	01H
	DD	02H
	DD	01H
	DD	FLAT:__catchsym$?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z$3
__ehfuncinfo$?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z DD 019930522H
	DD	03H
	DD	FLAT:__unwindtable$?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z
	DD	01H
	DD	FLAT:__tryblocktable$?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z
	DD	2 DUP(00H)
	DD	00H
	DD	00H
; Function compile flags: /Odtp
xdata$x	ENDS
;	COMDAT ?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z
_TEXT	SEGMENT
tv254 = -44						; size = 4
tv256 = -40						; size = 4
_this$ = -36						; size = 4
$T345458 = -32						; size = 4
$T345457 = -28						; size = 4
__Meta$22281 = -24					; size = 4
__Ctype_fac$22277 = -20					; size = 4
__$EHRec$ = -16						; size = 16
__Noskip$ = 8						; size = 1
?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z PROC ; std::basic_istream<char,std::char_traits<char> >::_Ipfx, COMDAT
; _this$ = ecx

; 92   : 		{	// test stream state and skip whitespace as needed

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	6a ff		 push	 -1
  00005	68 00 00 00 00	 push	 __ehhandler$?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z
  0000a	64 a1 00 00 00
	00		 mov	 eax, DWORD PTR fs:0
  00010	50		 push	 eax
  00011	51		 push	 ecx
  00012	83 ec 1c	 sub	 esp, 28			; 0000001cH
  00015	53		 push	 ebx
  00016	56		 push	 esi
  00017	57		 push	 edi
  00018	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  0001d	33 c5		 xor	 eax, ebp
  0001f	50		 push	 eax
  00020	8d 45 f4	 lea	 eax, DWORD PTR __$EHRec$[ebp+4]
  00023	64 a3 00 00 00
	00		 mov	 DWORD PTR fs:0, eax
  00029	89 65 f0	 mov	 DWORD PTR __$EHRec$[ebp], esp
  0002c	89 4d dc	 mov	 DWORD PTR _this$[ebp], ecx

; 93   : 		if (ios_base::good())

  0002f	8b 45 dc	 mov	 eax, DWORD PTR _this$[ebp]
  00032	8b 08		 mov	 ecx, DWORD PTR [eax]
  00034	8b 55 dc	 mov	 edx, DWORD PTR _this$[ebp]
  00037	03 51 04	 add	 edx, DWORD PTR [ecx+4]
  0003a	8b ca		 mov	 ecx, edx
  0003c	e8 00 00 00 00	 call	 ?good@ios_base@std@@QBE_NXZ ; std::ios_base::good
  00041	0f b6 c0	 movzx	 eax, al
  00044	85 c0		 test	 eax, eax
  00046	0f 84 78 01 00
	00		 je	 $LN11@Ipfx

; 94   : 			{	// state okay, flush tied stream and skip whitespace
; 95   : 			if (_Myios::tie() != 0)

  0004c	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  0004f	8b 11		 mov	 edx, DWORD PTR [ecx]
  00051	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  00054	03 4a 04	 add	 ecx, DWORD PTR [edx+4]
  00057	e8 00 00 00 00	 call	 ?tie@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEPAV?$basic_ostream@DU?$char_traits@D@std@@@2@XZ ; std::basic_ios<char,std::char_traits<char> >::tie
  0005c	85 c0		 test	 eax, eax
  0005e	74 19		 je	 SHORT $LN10@Ipfx

; 96   : 				_Myios::tie()->flush();

  00060	8b 45 dc	 mov	 eax, DWORD PTR _this$[ebp]
  00063	8b 08		 mov	 ecx, DWORD PTR [eax]
  00065	8b 55 dc	 mov	 edx, DWORD PTR _this$[ebp]
  00068	03 51 04	 add	 edx, DWORD PTR [ecx+4]
  0006b	8b ca		 mov	 ecx, edx
  0006d	e8 00 00 00 00	 call	 ?tie@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEPAV?$basic_ostream@DU?$char_traits@D@std@@@2@XZ ; std::basic_ios<char,std::char_traits<char> >::tie
  00072	8b c8		 mov	 ecx, eax
  00074	e8 00 00 00 00	 call	 ?flush@?$basic_ostream@DU?$char_traits@D@std@@@std@@QAEAAV12@XZ ; std::basic_ostream<char,std::char_traits<char> >::flush
$LN10@Ipfx:

; 97   : 
; 98   : 			if (!_Noskip && ios_base::flags() & ios_base::skipws)

  00079	0f b6 45 08	 movzx	 eax, BYTE PTR __Noskip$[ebp]
  0007d	85 c0		 test	 eax, eax
  0007f	0f 85 22 01 00
	00		 jne	 $LN9@Ipfx
  00085	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  00088	8b 11		 mov	 edx, DWORD PTR [ecx]
  0008a	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  0008d	03 4a 04	 add	 ecx, DWORD PTR [edx+4]
  00090	e8 00 00 00 00	 call	 ?flags@ios_base@std@@QBEHXZ ; std::ios_base::flags
  00095	83 e0 01	 and	 eax, 1
  00098	0f 84 09 01 00
	00		 je	 $LN9@Ipfx

; 99   : 				{	// skip whitespace
; 100  : 				const _Ctype& _Ctype_fac = _USE(ios_base::getloc(), _Ctype);

  0009e	8d 45 e4	 lea	 eax, DWORD PTR $T345457[ebp]
  000a1	50		 push	 eax
  000a2	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  000a5	8b 11		 mov	 edx, DWORD PTR [ecx]
  000a7	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  000aa	03 4a 04	 add	 ecx, DWORD PTR [edx+4]
  000ad	e8 00 00 00 00	 call	 ?getloc@ios_base@std@@QBE?AVlocale@2@XZ ; std::ios_base::getloc
  000b2	89 45 d8	 mov	 DWORD PTR tv256[ebp], eax
  000b5	8b 45 d8	 mov	 eax, DWORD PTR tv256[ebp]
  000b8	89 45 d4	 mov	 DWORD PTR tv254[ebp], eax
  000bb	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+12], 0
  000c2	8b 4d d4	 mov	 ecx, DWORD PTR tv254[ebp]
  000c5	51		 push	 ecx
  000c6	e8 00 00 00 00	 call	 ??$use_facet@V?$ctype@D@std@@@std@@YAABV?$ctype@D@0@ABVlocale@0@@Z ; std::use_facet<std::ctype<char> >
  000cb	83 c4 04	 add	 esp, 4
  000ce	89 45 ec	 mov	 DWORD PTR __Ctype_fac$22277[ebp], eax
  000d1	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+12], -1
  000d8	8d 4d e4	 lea	 ecx, DWORD PTR $T345457[ebp]
  000db	e8 00 00 00 00	 call	 ??1locale@std@@QAE@XZ	; std::locale::~locale

; 101  : 
; 102  : 				_TRY_IO_BEGIN

  000e0	c7 45 fc 01 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+12], 1

; 103  : 				int_type _Meta = _Myios::rdbuf()->sgetc();

  000e7	8b 55 dc	 mov	 edx, DWORD PTR _this$[ebp]
  000ea	8b 02		 mov	 eax, DWORD PTR [edx]
  000ec	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  000ef	03 48 04	 add	 ecx, DWORD PTR [eax+4]
  000f2	e8 00 00 00 00	 call	 ?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ ; std::basic_ios<char,std::char_traits<char> >::rdbuf
  000f7	8b c8		 mov	 ecx, eax
  000f9	e8 00 00 00 00	 call	 ?sgetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_streambuf<char,std::char_traits<char> >::sgetc
  000fe	89 45 e8	 mov	 DWORD PTR __Meta$22281[ebp], eax
  00101	eb 1a		 jmp	 SHORT $LN7@Ipfx
$LN6@Ipfx:

; 104  : 
; 105  : 				for (; ; _Meta = _Myios::rdbuf()->snextc())

  00103	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  00106	8b 11		 mov	 edx, DWORD PTR [ecx]
  00108	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  0010b	03 4a 04	 add	 ecx, DWORD PTR [edx+4]
  0010e	e8 00 00 00 00	 call	 ?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ ; std::basic_ios<char,std::char_traits<char> >::rdbuf
  00113	8b c8		 mov	 ecx, eax
  00115	e8 00 00 00 00	 call	 ?snextc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_streambuf<char,std::char_traits<char> >::snextc
  0011a	89 45 e8	 mov	 DWORD PTR __Meta$22281[ebp], eax
$LN7@Ipfx:

; 106  : 					if (_Traits::eq_int_type(_Traits::eof(), _Meta))

  0011d	e8 00 00 00 00	 call	 ?eof@?$char_traits@D@std@@SAHXZ ; std::char_traits<char>::eof
  00122	89 45 e0	 mov	 DWORD PTR $T345458[ebp], eax
  00125	8d 45 e8	 lea	 eax, DWORD PTR __Meta$22281[ebp]
  00128	50		 push	 eax
  00129	8d 4d e0	 lea	 ecx, DWORD PTR $T345458[ebp]
  0012c	51		 push	 ecx
  0012d	e8 00 00 00 00	 call	 ?eq_int_type@?$char_traits@D@std@@SA_NABH0@Z ; std::char_traits<char>::eq_int_type
  00132	83 c4 08	 add	 esp, 8
  00135	0f b6 d0	 movzx	 edx, al
  00138	85 d2		 test	 edx, edx
  0013a	74 1a		 je	 SHORT $LN4@Ipfx

; 107  : 						{	// end of file, quit
; 108  : 						_Myios::setstate(ios_base::eofbit);

  0013c	6a 00		 push	 0
  0013e	6a 01		 push	 1
  00140	8b 45 dc	 mov	 eax, DWORD PTR _this$[ebp]
  00143	8b 08		 mov	 ecx, DWORD PTR [eax]
  00145	8b 55 dc	 mov	 edx, DWORD PTR _this$[ebp]
  00148	03 51 04	 add	 edx, DWORD PTR [ecx+4]
  0014b	8b ca		 mov	 ecx, edx
  0014d	e8 00 00 00 00	 call	 ?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXH_N@Z ; std::basic_ios<char,std::char_traits<char> >::setstate

; 109  : 						break;

  00152	eb 27		 jmp	 SHORT $LN5@Ipfx

; 110  : 						}
; 111  : 					else if (!_Ctype_fac.is(_Ctype::space,

  00154	eb 23		 jmp	 SHORT $LN3@Ipfx
$LN4@Ipfx:

; 112  : 						_Traits::to_char_type(_Meta)))

  00156	8d 45 e8	 lea	 eax, DWORD PTR __Meta$22281[ebp]
  00159	50		 push	 eax
  0015a	e8 00 00 00 00	 call	 ?to_char_type@?$char_traits@D@std@@SADABH@Z ; std::char_traits<char>::to_char_type
  0015f	83 c4 04	 add	 esp, 4
  00162	0f b6 c8	 movzx	 ecx, al
  00165	51		 push	 ecx
  00166	6a 48		 push	 72			; 00000048H
  00168	8b 4d ec	 mov	 ecx, DWORD PTR __Ctype_fac$22277[ebp]
  0016b	e8 00 00 00 00	 call	 ?is@?$ctype@D@std@@QBE_NFD@Z ; std::ctype<char>::is
  00170	0f b6 d0	 movzx	 edx, al
  00173	85 d2		 test	 edx, edx
  00175	75 02		 jne	 SHORT $LN3@Ipfx

; 113  : 						break;	// not whitespace, quit

  00177	eb 02		 jmp	 SHORT $LN5@Ipfx
$LN3@Ipfx:

; 114  : 				_CATCH_IO_END

  00179	eb 88		 jmp	 SHORT $LN6@Ipfx
$LN5@Ipfx:
  0017b	eb 23		 jmp	 SHORT $LN14@Ipfx
__catch$?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z$0:
  0017d	6a 01		 push	 1
  0017f	6a 04		 push	 4
  00181	8b 45 dc	 mov	 eax, DWORD PTR _this$[ebp]
  00184	8b 08		 mov	 ecx, DWORD PTR [eax]
  00186	8b 55 dc	 mov	 edx, DWORD PTR _this$[ebp]
  00189	03 51 04	 add	 edx, DWORD PTR [ecx+4]
  0018c	8b ca		 mov	 ecx, edx
  0018e	e8 00 00 00 00	 call	 ?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXH_N@Z ; std::basic_ios<char,std::char_traits<char> >::setstate
  00193	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+12], -1
  0019a	b8 00 00 00 00	 mov	 eax, $LN9@Ipfx
  0019f	c3		 ret	 0
$LN14@Ipfx:
  001a0	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+12], -1
$LN9@Ipfx:

; 115  : 				}
; 116  : 
; 117  : 			if (ios_base::good())

  001a7	8b 45 dc	 mov	 eax, DWORD PTR _this$[ebp]
  001aa	8b 08		 mov	 ecx, DWORD PTR [eax]
  001ac	8b 55 dc	 mov	 edx, DWORD PTR _this$[ebp]
  001af	03 51 04	 add	 edx, DWORD PTR [ecx+4]
  001b2	8b ca		 mov	 ecx, edx
  001b4	e8 00 00 00 00	 call	 ?good@ios_base@std@@QBE_NXZ ; std::ios_base::good
  001b9	0f b6 c0	 movzx	 eax, al
  001bc	85 c0		 test	 eax, eax
  001be	74 04		 je	 SHORT $LN11@Ipfx

; 118  : 				return (true);

  001c0	b0 01		 mov	 al, 1
  001c2	eb 16		 jmp	 SHORT $LN12@Ipfx
$LN11@Ipfx:

; 119  : 			}
; 120  : 		_Myios::setstate(ios_base::failbit);

  001c4	6a 00		 push	 0
  001c6	6a 02		 push	 2
  001c8	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  001cb	8b 11		 mov	 edx, DWORD PTR [ecx]
  001cd	8b 4d dc	 mov	 ecx, DWORD PTR _this$[ebp]
  001d0	03 4a 04	 add	 ecx, DWORD PTR [edx+4]
  001d3	e8 00 00 00 00	 call	 ?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXH_N@Z ; std::basic_ios<char,std::char_traits<char> >::setstate

; 121  : 		return (false);

  001d8	32 c0		 xor	 al, al
$LN12@Ipfx:

; 122  : 		}

  001da	8b 4d f4	 mov	 ecx, DWORD PTR __$EHRec$[ebp+4]
  001dd	64 89 0d 00 00
	00 00		 mov	 DWORD PTR fs:0, ecx
  001e4	59		 pop	 ecx
  001e5	5f		 pop	 edi
  001e6	5e		 pop	 esi
  001e7	5b		 pop	 ebx
  001e8	8b e5		 mov	 esp, ebp
  001ea	5d		 pop	 ebp
  001eb	c2 04 00	 ret	 4
_TEXT	ENDS
;	COMDAT text$x
text$x	SEGMENT
__unwindfunclet$?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z$2:
  00000	8d 4d e4	 lea	 ecx, DWORD PTR $T345457[ebp]
  00003	e9 00 00 00 00	 jmp	 ??1locale@std@@QAE@XZ	; std::locale::~locale
__ehhandler$?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z:
  00008	8b 54 24 08	 mov	 edx, DWORD PTR [esp+8]
  0000c	8d 42 0c	 lea	 eax, DWORD PTR [edx+12]
  0000f	8b 4a d0	 mov	 ecx, DWORD PTR [edx-48]
  00012	33 c8		 xor	 ecx, eax
  00014	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00019	b8 00 00 00 00	 mov	 eax, OFFSET __ehfuncinfo$?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z
  0001e	e9 00 00 00 00	 jmp	 ___CxxFrameHandler3
text$x	ENDS
?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z ENDP ; std::basic_istream<char,std::char_traits<char> >::_Ipfx
;	COMDAT xdata$x
xdata$x	SEGMENT
__unwindtable$??0sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@_N@Z DD 0ffffffffH
	DD	FLAT:__unwindfunclet$??0sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@_N@Z$0
__ehfuncinfo$??0sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@_N@Z DD 019930522H
	DD	01H
	DD	FLAT:__unwindtable$??0sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@_N@Z
	DD	2 DUP(00H)
	DD	2 DUP(00H)
	DD	00H
	DD	00H
; Function compile flags: /Odtp
xdata$x	ENDS
;	COMDAT ??0sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@_N@Z
_TEXT	SEGMENT
_this$ = -16						; size = 4
__$EHRec$ = -12						; size = 12
__Istr$ = 8						; size = 4
__Noskip$ = 12						; size = 1
??0sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@_N@Z PROC ; std::basic_istream<char,std::char_traits<char> >::sentry::sentry, COMDAT
; _this$ = ecx

; 75   : 			{	// construct locking and calling _Ipfx

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	6a ff		 push	 -1
  00005	68 00 00 00 00	 push	 __ehhandler$??0sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@_N@Z
  0000a	64 a1 00 00 00
	00		 mov	 eax, DWORD PTR fs:0
  00010	50		 push	 eax
  00011	51		 push	 ecx
  00012	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  00017	33 c5		 xor	 eax, ebp
  00019	50		 push	 eax
  0001a	8d 45 f4	 lea	 eax, DWORD PTR __$EHRec$[ebp]
  0001d	64 a3 00 00 00
	00		 mov	 DWORD PTR fs:0, eax
  00023	89 4d f0	 mov	 DWORD PTR _this$[ebp], ecx
  00026	8b 45 08	 mov	 eax, DWORD PTR __Istr$[ebp]
  00029	50		 push	 eax
  0002a	8b 4d f0	 mov	 ecx, DWORD PTR _this$[ebp]
  0002d	e8 00 00 00 00	 call	 ??0_Sentry_base@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@@Z ; std::basic_istream<char,std::char_traits<char> >::_Sentry_base::_Sentry_base
  00032	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+8], 0

; 76   : 			_Ok = this->_Myistr._Ipfx(_Noskip);

  00039	0f b6 4d 0c	 movzx	 ecx, BYTE PTR __Noskip$[ebp]
  0003d	51		 push	 ecx
  0003e	8b 55 f0	 mov	 edx, DWORD PTR _this$[ebp]
  00041	8b 0a		 mov	 ecx, DWORD PTR [edx]
  00043	e8 00 00 00 00	 call	 ?_Ipfx@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE_N_N@Z ; std::basic_istream<char,std::char_traits<char> >::_Ipfx
  00048	8b 4d f0	 mov	 ecx, DWORD PTR _this$[ebp]
  0004b	88 41 04	 mov	 BYTE PTR [ecx+4], al

; 77   : 			}

  0004e	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  00055	8b 45 f0	 mov	 eax, DWORD PTR _this$[ebp]
  00058	8b 4d f4	 mov	 ecx, DWORD PTR __$EHRec$[ebp]
  0005b	64 89 0d 00 00
	00 00		 mov	 DWORD PTR fs:0, ecx
  00062	59		 pop	 ecx
  00063	8b e5		 mov	 esp, ebp
  00065	5d		 pop	 ebp
  00066	c2 08 00	 ret	 8
_TEXT	ENDS
;	COMDAT text$x
text$x	SEGMENT
__unwindfunclet$??0sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@_N@Z$0:
  00000	8b 4d f0	 mov	 ecx, DWORD PTR _this$[ebp]
  00003	e9 00 00 00 00	 jmp	 ??1_Sentry_base@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ ; std::basic_istream<char,std::char_traits<char> >::_Sentry_base::~_Sentry_base
__ehhandler$??0sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@_N@Z:
  00008	8b 54 24 08	 mov	 edx, DWORD PTR [esp+8]
  0000c	8d 42 0c	 lea	 eax, DWORD PTR [edx+12]
  0000f	8b 4a f8	 mov	 ecx, DWORD PTR [edx-8]
  00012	33 c8		 xor	 ecx, eax
  00014	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00019	b8 00 00 00 00	 mov	 eax, OFFSET __ehfuncinfo$??0sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@_N@Z
  0001e	e9 00 00 00 00	 jmp	 ___CxxFrameHandler3
text$x	ENDS
??0sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@_N@Z ENDP ; std::basic_istream<char,std::char_traits<char> >::sentry::sentry
;	COMDAT xdata$x
xdata$x	SEGMENT
__unwindtable$?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ DD 0ffffffffH
	DD	FLAT:__unwindfunclet$?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ$2
	DD	00H
	DD	00H
	DD	00H
	DD	00H
__catchsym$?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ$3 DD 00H
	DD	00H
	DD	00H
	DD	FLAT:__catch$?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ$0
__tryblocktable$?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ DD 01H
	DD	01H
	DD	02H
	DD	01H
	DD	FLAT:__catchsym$?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ$3
__ehfuncinfo$?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ DD 019930522H
	DD	03H
	DD	FLAT:__unwindtable$?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ
	DD	01H
	DD	FLAT:__tryblocktable$?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ
	DD	2 DUP(00H)
	DD	00H
	DD	00H
; Function compile flags: /Odtp
xdata$x	ENDS
;	COMDAT ?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ
_TEXT	SEGMENT
_this$ = -44						; size = 4
$T345485 = -40						; size = 4
$T345484 = -36						; size = 4
__Meta$ = -32						; size = 4
__Ok$ = -28						; size = 8
__State$ = -20						; size = 4
__$EHRec$ = -16						; size = 16
?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ PROC ; std::basic_istream<char,std::char_traits<char> >::peek, COMDAT
; _this$ = ecx

; 730  : 		{	// return next character, unconsumed

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	6a ff		 push	 -1
  00005	68 00 00 00 00	 push	 __ehhandler$?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ
  0000a	64 a1 00 00 00
	00		 mov	 eax, DWORD PTR fs:0
  00010	50		 push	 eax
  00011	51		 push	 ecx
  00012	83 ec 1c	 sub	 esp, 28			; 0000001cH
  00015	53		 push	 ebx
  00016	56		 push	 esi
  00017	57		 push	 edi
  00018	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  0001d	33 c5		 xor	 eax, ebp
  0001f	50		 push	 eax
  00020	8d 45 f4	 lea	 eax, DWORD PTR __$EHRec$[ebp+4]
  00023	64 a3 00 00 00
	00		 mov	 DWORD PTR fs:0, eax
  00029	89 65 f0	 mov	 DWORD PTR __$EHRec$[ebp], esp
  0002c	89 4d d4	 mov	 DWORD PTR _this$[ebp], ecx

; 731  : 		ios_base::iostate _State = ios_base::goodbit;

  0002f	c7 45 ec 00 00
	00 00		 mov	 DWORD PTR __State$[ebp], 0

; 732  : 		_Chcount = 0;

  00036	8b 45 d4	 mov	 eax, DWORD PTR _this$[ebp]
  00039	c7 40 04 00 00
	00 00		 mov	 DWORD PTR [eax+4], 0

; 733  : 		int_type _Meta = 0;

  00040	c7 45 e0 00 00
	00 00		 mov	 DWORD PTR __Meta$[ebp], 0

; 734  : 		const sentry _Ok(*this, true);

  00047	6a 01		 push	 1
  00049	8b 4d d4	 mov	 ecx, DWORD PTR _this$[ebp]
  0004c	51		 push	 ecx
  0004d	8d 4d e4	 lea	 ecx, DWORD PTR __Ok$[ebp]
  00050	e8 00 00 00 00	 call	 ??0sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@_N@Z ; std::basic_istream<char,std::char_traits<char> >::sentry::sentry
  00055	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+12], 0

; 735  : 
; 736  : 		if (!_Ok)

  0005c	8d 4d e4	 lea	 ecx, DWORD PTR __Ok$[ebp]
  0005f	e8 00 00 00 00	 call	 ??Bsentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QBE_NXZ ; std::basic_istream<char,std::char_traits<char> >::sentry::operator bool
  00064	0f b6 d0	 movzx	 edx, al
  00067	85 d2		 test	 edx, edx
  00069	75 0a		 jne	 SHORT $LN4@peek

; 737  : 			_Meta = _Traits::eof();	// state not okay, return EOF

  0006b	e8 00 00 00 00	 call	 ?eof@?$char_traits@D@std@@SAHXZ ; std::char_traits<char>::eof
  00070	89 45 e0	 mov	 DWORD PTR __Meta$[ebp], eax

; 738  : 		else

  00073	eb 72		 jmp	 SHORT $LN3@peek
$LN4@peek:

; 739  : 			{	// state okay, read a character
; 740  : 			_TRY_IO_BEGIN

  00075	c6 45 fc 01	 mov	 BYTE PTR __$EHRec$[ebp+12], 1

; 741  : 			if (_Traits::eq_int_type(_Traits::eof(),
; 742  : 				_Meta = _Myios::rdbuf()->sgetc()))

  00079	8b 45 d4	 mov	 eax, DWORD PTR _this$[ebp]
  0007c	8b 08		 mov	 ecx, DWORD PTR [eax]
  0007e	8b 55 d4	 mov	 edx, DWORD PTR _this$[ebp]
  00081	03 51 04	 add	 edx, DWORD PTR [ecx+4]
  00084	8b ca		 mov	 ecx, edx
  00086	e8 00 00 00 00	 call	 ?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ ; std::basic_ios<char,std::char_traits<char> >::rdbuf
  0008b	8b c8		 mov	 ecx, eax
  0008d	e8 00 00 00 00	 call	 ?sgetc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_streambuf<char,std::char_traits<char> >::sgetc
  00092	89 45 e0	 mov	 DWORD PTR __Meta$[ebp], eax
  00095	e8 00 00 00 00	 call	 ?eof@?$char_traits@D@std@@SAHXZ ; std::char_traits<char>::eof
  0009a	89 45 dc	 mov	 DWORD PTR $T345484[ebp], eax
  0009d	8d 45 e0	 lea	 eax, DWORD PTR __Meta$[ebp]
  000a0	50		 push	 eax
  000a1	8d 4d dc	 lea	 ecx, DWORD PTR $T345484[ebp]
  000a4	51		 push	 ecx
  000a5	e8 00 00 00 00	 call	 ?eq_int_type@?$char_traits@D@std@@SA_NABH0@Z ; std::char_traits<char>::eq_int_type
  000aa	83 c4 08	 add	 esp, 8
  000ad	0f b6 d0	 movzx	 edx, al
  000b0	85 d2		 test	 edx, edx
  000b2	74 09		 je	 SHORT $LN1@peek

; 743  : 				_State |= ios_base::eofbit;

  000b4	8b 45 ec	 mov	 eax, DWORD PTR __State$[ebp]
  000b7	83 c8 01	 or	 eax, 1
  000ba	89 45 ec	 mov	 DWORD PTR __State$[ebp], eax
$LN1@peek:
  000bd	eb 21		 jmp	 SHORT $LN7@peek
__catch$?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ$0:

; 744  : 			_CATCH_IO_END

  000bf	6a 01		 push	 1
  000c1	6a 04		 push	 4
  000c3	8b 4d d4	 mov	 ecx, DWORD PTR _this$[ebp]
  000c6	8b 11		 mov	 edx, DWORD PTR [ecx]
  000c8	8b 4d d4	 mov	 ecx, DWORD PTR _this$[ebp]
  000cb	03 4a 04	 add	 ecx, DWORD PTR [edx+4]
  000ce	e8 00 00 00 00	 call	 ?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXH_N@Z ; std::basic_ios<char,std::char_traits<char> >::setstate
  000d3	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+12], 0
  000da	b8 00 00 00 00	 mov	 eax, $LN3@peek
  000df	c3		 ret	 0
$LN7@peek:
  000e0	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+12], 0
$LN3@peek:

; 745  : 			}
; 746  : 
; 747  : 		_Myios::setstate(_State);

  000e7	6a 00		 push	 0
  000e9	8b 45 ec	 mov	 eax, DWORD PTR __State$[ebp]
  000ec	50		 push	 eax
  000ed	8b 4d d4	 mov	 ecx, DWORD PTR _this$[ebp]
  000f0	8b 11		 mov	 edx, DWORD PTR [ecx]
  000f2	8b 4d d4	 mov	 ecx, DWORD PTR _this$[ebp]
  000f5	03 4a 04	 add	 ecx, DWORD PTR [edx+4]
  000f8	e8 00 00 00 00	 call	 ?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXH_N@Z ; std::basic_ios<char,std::char_traits<char> >::setstate

; 748  : 		return (_Meta);

  000fd	8b 45 e0	 mov	 eax, DWORD PTR __Meta$[ebp]
  00100	89 45 d8	 mov	 DWORD PTR $T345485[ebp], eax
  00103	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+12], -1
  0010a	8d 4d e4	 lea	 ecx, DWORD PTR __Ok$[ebp]
  0010d	e8 00 00 00 00	 call	 ??1sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ
  00112	8b 45 d8	 mov	 eax, DWORD PTR $T345485[ebp]

; 749  : 		}

  00115	8b 4d f4	 mov	 ecx, DWORD PTR __$EHRec$[ebp+4]
  00118	64 89 0d 00 00
	00 00		 mov	 DWORD PTR fs:0, ecx
  0011f	59		 pop	 ecx
  00120	5f		 pop	 edi
  00121	5e		 pop	 esi
  00122	5b		 pop	 ebx
  00123	8b e5		 mov	 esp, ebp
  00125	5d		 pop	 ebp
  00126	c3		 ret	 0
_TEXT	ENDS
;	COMDAT text$x
text$x	SEGMENT
__unwindfunclet$?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ$2:
  00000	8d 4d e4	 lea	 ecx, DWORD PTR __Ok$[ebp]
  00003	e9 00 00 00 00	 jmp	 ??1sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ
__ehhandler$?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ:
  00008	8b 54 24 08	 mov	 edx, DWORD PTR [esp+8]
  0000c	8d 42 0c	 lea	 eax, DWORD PTR [edx+12]
  0000f	8b 4a d0	 mov	 ecx, DWORD PTR [edx-48]
  00012	33 c8		 xor	 ecx, eax
  00014	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00019	b8 00 00 00 00	 mov	 eax, OFFSET __ehfuncinfo$?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ
  0001e	e9 00 00 00 00	 jmp	 ___CxxFrameHandler3
text$x	ENDS
?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ENDP ; std::basic_istream<char,std::char_traits<char> >::peek
;	COMDAT xdata$x
xdata$x	SEGMENT
__unwindtable$?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ DD 0ffffffffH
	DD	FLAT:__unwindfunclet$?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ$2
	DD	00H
	DD	00H
	DD	00H
	DD	00H
__catchsym$?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ$3 DD 00H
	DD	00H
	DD	00H
	DD	FLAT:__catch$?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ$0
__tryblocktable$?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ DD 01H
	DD	01H
	DD	02H
	DD	01H
	DD	FLAT:__catchsym$?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ$3
__ehfuncinfo$?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ DD 019930522H
	DD	03H
	DD	FLAT:__unwindtable$?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ
	DD	01H
	DD	FLAT:__tryblocktable$?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ
	DD	2 DUP(00H)
	DD	00H
	DD	00H
; Function compile flags: /Odtp
xdata$x	ENDS
;	COMDAT ?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ
_TEXT	SEGMENT
_this$ = -44						; size = 4
$T345503 = -40						; size = 4
$T345502 = -36						; size = 4
__Meta$ = -32						; size = 4
__Ok$ = -28						; size = 8
__State$ = -20						; size = 4
__$EHRec$ = -16						; size = 16
?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ PROC ; std::basic_istream<char,std::char_traits<char> >::get, COMDAT
; _this$ = ecx

; 477  : 		{	// extract a metacharacter

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	6a ff		 push	 -1
  00005	68 00 00 00 00	 push	 __ehhandler$?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ
  0000a	64 a1 00 00 00
	00		 mov	 eax, DWORD PTR fs:0
  00010	50		 push	 eax
  00011	51		 push	 ecx
  00012	83 ec 1c	 sub	 esp, 28			; 0000001cH
  00015	53		 push	 ebx
  00016	56		 push	 esi
  00017	57		 push	 edi
  00018	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  0001d	33 c5		 xor	 eax, ebp
  0001f	50		 push	 eax
  00020	8d 45 f4	 lea	 eax, DWORD PTR __$EHRec$[ebp+4]
  00023	64 a3 00 00 00
	00		 mov	 DWORD PTR fs:0, eax
  00029	89 65 f0	 mov	 DWORD PTR __$EHRec$[ebp], esp
  0002c	89 4d d4	 mov	 DWORD PTR _this$[ebp], ecx

; 478  : 		int_type _Meta = 0;

  0002f	c7 45 e0 00 00
	00 00		 mov	 DWORD PTR __Meta$[ebp], 0

; 479  : 		ios_base::iostate _State = ios_base::goodbit;

  00036	c7 45 ec 00 00
	00 00		 mov	 DWORD PTR __State$[ebp], 0

; 480  : 		_Chcount = 0;

  0003d	8b 45 d4	 mov	 eax, DWORD PTR _this$[ebp]
  00040	c7 40 04 00 00
	00 00		 mov	 DWORD PTR [eax+4], 0

; 481  : 		const sentry _Ok(*this, true);

  00047	6a 01		 push	 1
  00049	8b 4d d4	 mov	 ecx, DWORD PTR _this$[ebp]
  0004c	51		 push	 ecx
  0004d	8d 4d e4	 lea	 ecx, DWORD PTR __Ok$[ebp]
  00050	e8 00 00 00 00	 call	 ??0sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@AAV12@_N@Z ; std::basic_istream<char,std::char_traits<char> >::sentry::sentry
  00055	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+12], 0

; 482  : 
; 483  : 		if (!_Ok)

  0005c	8d 4d e4	 lea	 ecx, DWORD PTR __Ok$[ebp]
  0005f	e8 00 00 00 00	 call	 ??Bsentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QBE_NXZ ; std::basic_istream<char,std::char_traits<char> >::sentry::operator bool
  00064	0f b6 d0	 movzx	 edx, al
  00067	85 d2		 test	 edx, edx
  00069	75 0d		 jne	 SHORT $LN5@get@2

; 484  : 			_Meta = _Traits::eof();	// state not okay, return EOF

  0006b	e8 00 00 00 00	 call	 ?eof@?$char_traits@D@std@@SAHXZ ; std::char_traits<char>::eof
  00070	89 45 e0	 mov	 DWORD PTR __Meta$[ebp], eax

; 485  : 		else

  00073	e9 83 00 00 00	 jmp	 $LN4@get@2
$LN5@get@2:

; 486  : 			{	// state okay, extract a character
; 487  : 			_TRY_IO_BEGIN

  00078	c6 45 fc 01	 mov	 BYTE PTR __$EHRec$[ebp+12], 1

; 488  : 			_Meta = _Myios::rdbuf()->sbumpc();

  0007c	8b 45 d4	 mov	 eax, DWORD PTR _this$[ebp]
  0007f	8b 08		 mov	 ecx, DWORD PTR [eax]
  00081	8b 55 d4	 mov	 edx, DWORD PTR _this$[ebp]
  00084	03 51 04	 add	 edx, DWORD PTR [ecx+4]
  00087	8b ca		 mov	 ecx, edx
  00089	e8 00 00 00 00	 call	 ?rdbuf@?$basic_ios@DU?$char_traits@D@std@@@std@@QBEPAV?$basic_streambuf@DU?$char_traits@D@std@@@2@XZ ; std::basic_ios<char,std::char_traits<char> >::rdbuf
  0008e	8b c8		 mov	 ecx, eax
  00090	e8 00 00 00 00	 call	 ?sbumpc@?$basic_streambuf@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_streambuf<char,std::char_traits<char> >::sbumpc
  00095	89 45 e0	 mov	 DWORD PTR __Meta$[ebp], eax

; 489  : 
; 490  : 			if (_Traits::eq_int_type(_Traits::eof(), _Meta))

  00098	e8 00 00 00 00	 call	 ?eof@?$char_traits@D@std@@SAHXZ ; std::char_traits<char>::eof
  0009d	89 45 dc	 mov	 DWORD PTR $T345502[ebp], eax
  000a0	8d 45 e0	 lea	 eax, DWORD PTR __Meta$[ebp]
  000a3	50		 push	 eax
  000a4	8d 4d dc	 lea	 ecx, DWORD PTR $T345502[ebp]
  000a7	51		 push	 ecx
  000a8	e8 00 00 00 00	 call	 ?eq_int_type@?$char_traits@D@std@@SA_NABH0@Z ; std::char_traits<char>::eq_int_type
  000ad	83 c4 08	 add	 esp, 8
  000b0	0f b6 d0	 movzx	 edx, al
  000b3	85 d2		 test	 edx, edx
  000b5	74 0b		 je	 SHORT $LN2@get@2

; 491  : 				_State |= ios_base::eofbit | ios_base::failbit;	// end of file

  000b7	8b 45 ec	 mov	 eax, DWORD PTR __State$[ebp]
  000ba	83 c8 03	 or	 eax, 3
  000bd	89 45 ec	 mov	 DWORD PTR __State$[ebp], eax

; 492  : 			else

  000c0	eb 0f		 jmp	 SHORT $LN1@get@2
$LN2@get@2:

; 493  : 				++_Chcount;	// got a character, count it

  000c2	8b 4d d4	 mov	 ecx, DWORD PTR _this$[ebp]
  000c5	8b 51 04	 mov	 edx, DWORD PTR [ecx+4]
  000c8	83 c2 01	 add	 edx, 1
  000cb	8b 45 d4	 mov	 eax, DWORD PTR _this$[ebp]
  000ce	89 50 04	 mov	 DWORD PTR [eax+4], edx
$LN1@get@2:
  000d1	eb 21		 jmp	 SHORT $LN8@get@2
__catch$?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ$0:

; 494  : 			_CATCH_IO_END

  000d3	6a 01		 push	 1
  000d5	6a 04		 push	 4
  000d7	8b 4d d4	 mov	 ecx, DWORD PTR _this$[ebp]
  000da	8b 11		 mov	 edx, DWORD PTR [ecx]
  000dc	8b 4d d4	 mov	 ecx, DWORD PTR _this$[ebp]
  000df	03 4a 04	 add	 ecx, DWORD PTR [edx+4]
  000e2	e8 00 00 00 00	 call	 ?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXH_N@Z ; std::basic_ios<char,std::char_traits<char> >::setstate
  000e7	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+12], 0
  000ee	b8 00 00 00 00	 mov	 eax, $LN4@get@2
  000f3	c3		 ret	 0
$LN8@get@2:
  000f4	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+12], 0
$LN4@get@2:

; 495  : 			}
; 496  : 
; 497  : 		_Myios::setstate(_State);

  000fb	6a 00		 push	 0
  000fd	8b 45 ec	 mov	 eax, DWORD PTR __State$[ebp]
  00100	50		 push	 eax
  00101	8b 4d d4	 mov	 ecx, DWORD PTR _this$[ebp]
  00104	8b 11		 mov	 edx, DWORD PTR [ecx]
  00106	8b 4d d4	 mov	 ecx, DWORD PTR _this$[ebp]
  00109	03 4a 04	 add	 ecx, DWORD PTR [edx+4]
  0010c	e8 00 00 00 00	 call	 ?setstate@?$basic_ios@DU?$char_traits@D@std@@@std@@QAEXH_N@Z ; std::basic_ios<char,std::char_traits<char> >::setstate

; 498  : 		return (_Meta);

  00111	8b 45 e0	 mov	 eax, DWORD PTR __Meta$[ebp]
  00114	89 45 d8	 mov	 DWORD PTR $T345503[ebp], eax
  00117	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+12], -1
  0011e	8d 4d e4	 lea	 ecx, DWORD PTR __Ok$[ebp]
  00121	e8 00 00 00 00	 call	 ??1sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ
  00126	8b 45 d8	 mov	 eax, DWORD PTR $T345503[ebp]

; 499  : 		}

  00129	8b 4d f4	 mov	 ecx, DWORD PTR __$EHRec$[ebp+4]
  0012c	64 89 0d 00 00
	00 00		 mov	 DWORD PTR fs:0, ecx
  00133	59		 pop	 ecx
  00134	5f		 pop	 edi
  00135	5e		 pop	 esi
  00136	5b		 pop	 ebx
  00137	8b e5		 mov	 esp, ebp
  00139	5d		 pop	 ebp
  0013a	c3		 ret	 0
_TEXT	ENDS
;	COMDAT text$x
text$x	SEGMENT
__unwindfunclet$?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ$2:
  00000	8d 4d e4	 lea	 ecx, DWORD PTR __Ok$[ebp]
  00003	e9 00 00 00 00	 jmp	 ??1sentry@?$basic_istream@DU?$char_traits@D@std@@@std@@QAE@XZ
__ehhandler$?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ:
  00008	8b 54 24 08	 mov	 edx, DWORD PTR [esp+8]
  0000c	8d 42 0c	 lea	 eax, DWORD PTR [edx+12]
  0000f	8b 4a d0	 mov	 ecx, DWORD PTR [edx-48]
  00012	33 c8		 xor	 ecx, eax
  00014	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00019	b8 00 00 00 00	 mov	 eax, OFFSET __ehfuncinfo$?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ
  0001e	e9 00 00 00 00	 jmp	 ___CxxFrameHandler3
text$x	ENDS
?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ENDP ; std::basic_istream<char,std::char_traits<char> >::get
; Function compile flags: /Odtp
; File c:\develop\dscaler423a\dscaler\tinyxmlparser.cpp
;	COMDAT ?StreamIn@TiXmlDeclaration@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z
_TEXT	SEGMENT
_this$ = -12						; size = 4
_document$21701 = -8					; size = 4
_c$21699 = -4						; size = 4
_in$ = 8						; size = 4
_tag$ = 12						; size = 4
?StreamIn@TiXmlDeclaration@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z PROC ; TiXmlDeclaration::StreamIn, COMDAT
; _this$ = ecx

; 1518 : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 0c	 sub	 esp, 12			; 0000000cH
  00006	89 4d f4	 mov	 DWORD PTR _this$[ebp], ecx
$LN5@StreamIn:

; 1519 :     while ( in->good() )

  00009	8b 45 08	 mov	 eax, DWORD PTR _in$[ebp]
  0000c	8b 08		 mov	 ecx, DWORD PTR [eax]
  0000e	8b 55 08	 mov	 edx, DWORD PTR _in$[ebp]
  00011	03 51 04	 add	 edx, DWORD PTR [ecx+4]
  00014	8b ca		 mov	 ecx, edx
  00016	e8 00 00 00 00	 call	 ?good@ios_base@std@@QBE_NXZ ; std::ios_base::good
  0001b	0f b6 c0	 movzx	 eax, al
  0001e	85 c0		 test	 eax, eax
  00020	74 4b		 je	 SHORT $LN6@StreamIn

; 1520 :     {
; 1521 :         int c = in->get();

  00022	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  00025	e8 00 00 00 00	 call	 ?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::get
  0002a	89 45 fc	 mov	 DWORD PTR _c$21699[ebp], eax

; 1522 :         if ( c <= 0 )

  0002d	83 7d fc 00	 cmp	 DWORD PTR _c$21699[ebp], 0
  00031	7f 23		 jg	 SHORT $LN3@StreamIn

; 1523 :         {
; 1524 :             TiXmlDocument* document = GetDocument();

  00033	8b 4d f4	 mov	 ecx, DWORD PTR _this$[ebp]
  00036	e8 00 00 00 00	 call	 ?GetDocument@TiXmlNode@@QAEPAVTiXmlDocument@@XZ ; TiXmlNode::GetDocument
  0003b	89 45 f8	 mov	 DWORD PTR _document$21701[ebp], eax

; 1525 :             if ( document )

  0003e	83 7d f8 00	 cmp	 DWORD PTR _document$21701[ebp], 0
  00042	74 10		 je	 SHORT $LN2@StreamIn

; 1526 :                 document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );

  00044	6a 00		 push	 0
  00046	6a 00		 push	 0
  00048	6a 00		 push	 0
  0004a	6a 0e		 push	 14			; 0000000eH
  0004c	8b 4d f8	 mov	 ecx, DWORD PTR _document$21701[ebp]
  0004f	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN2@StreamIn:

; 1527 :             return;

  00054	eb 17		 jmp	 SHORT $LN6@StreamIn
$LN3@StreamIn:

; 1528 :         }
; 1529 :         (*tag) += (char) c;

  00056	0f b6 4d fc	 movzx	 ecx, BYTE PTR _c$21699[ebp]
  0005a	51		 push	 ecx
  0005b	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  0005e	e8 00 00 00 00	 call	 ??Y?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@D@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator+=

; 1530 : 
; 1531 :         if ( c == '>' )

  00063	83 7d fc 3e	 cmp	 DWORD PTR _c$21699[ebp], 62 ; 0000003eH
  00067	75 02		 jne	 SHORT $LN1@StreamIn

; 1532 :         {
; 1533 :             // All is well.
; 1534 :             return;

  00069	eb 02		 jmp	 SHORT $LN6@StreamIn
$LN1@StreamIn:

; 1535 :         }
; 1536 :     }

  0006b	eb 9c		 jmp	 SHORT $LN5@StreamIn
$LN6@StreamIn:

; 1537 : }

  0006d	8b e5		 mov	 esp, ebp
  0006f	5d		 pop	 ebp
  00070	c2 08 00	 ret	 8
?StreamIn@TiXmlDeclaration@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ENDP ; TiXmlDeclaration::StreamIn
; Function compile flags: /Odtp
_TEXT	ENDS
;	COMDAT ?StreamIn@TiXmlText@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z
_TEXT	SEGMENT
_this$ = -16						; size = 4
_len$21665 = -12					; size = 4
_document$21661 = -8					; size = 4
_c$21658 = -4						; size = 4
_in$ = 8						; size = 4
_tag$ = 12						; size = 4
?StreamIn@TiXmlText@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z PROC ; TiXmlText::StreamIn, COMDAT
; _this$ = ecx

; 1436 : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 10	 sub	 esp, 16			; 00000010H
  00006	89 4d f0	 mov	 DWORD PTR _this$[ebp], ecx
$LN7@StreamIn@2:

; 1437 :     while ( in->good() )

  00009	8b 45 08	 mov	 eax, DWORD PTR _in$[ebp]
  0000c	8b 08		 mov	 ecx, DWORD PTR [eax]
  0000e	8b 55 08	 mov	 edx, DWORD PTR _in$[ebp]
  00011	03 51 04	 add	 edx, DWORD PTR [ecx+4]
  00014	8b ca		 mov	 ecx, edx
  00016	e8 00 00 00 00	 call	 ?good@ios_base@std@@QBE_NXZ ; std::ios_base::good
  0001b	0f b6 c0	 movzx	 eax, al
  0001e	85 c0		 test	 eax, eax
  00020	0f 84 bd 00 00
	00		 je	 $LN8@StreamIn@2

; 1438 :     {
; 1439 :         int c = in->peek();

  00026	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  00029	e8 00 00 00 00	 call	 ?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::peek
  0002e	89 45 fc	 mov	 DWORD PTR _c$21658[ebp], eax

; 1440 :         if ( !cdata && (c == '<' ) )

  00031	8b 4d f0	 mov	 ecx, DWORD PTR _this$[ebp]
  00034	0f b6 51 44	 movzx	 edx, BYTE PTR [ecx+68]
  00038	85 d2		 test	 edx, edx
  0003a	75 0b		 jne	 SHORT $LN5@StreamIn@2
  0003c	83 7d fc 3c	 cmp	 DWORD PTR _c$21658[ebp], 60 ; 0000003cH
  00040	75 05		 jne	 SHORT $LN5@StreamIn@2

; 1441 :         {
; 1442 :             return;

  00042	e9 9c 00 00 00	 jmp	 $LN8@StreamIn@2
$LN5@StreamIn@2:

; 1443 :         }
; 1444 :         if ( c <= 0 )

  00047	83 7d fc 00	 cmp	 DWORD PTR _c$21658[ebp], 0
  0004b	7f 23		 jg	 SHORT $LN4@StreamIn@2

; 1445 :         {
; 1446 :             TiXmlDocument* document = GetDocument();

  0004d	8b 4d f0	 mov	 ecx, DWORD PTR _this$[ebp]
  00050	e8 00 00 00 00	 call	 ?GetDocument@TiXmlNode@@QAEPAVTiXmlDocument@@XZ ; TiXmlNode::GetDocument
  00055	89 45 f8	 mov	 DWORD PTR _document$21661[ebp], eax

; 1447 :             if ( document )

  00058	83 7d f8 00	 cmp	 DWORD PTR _document$21661[ebp], 0
  0005c	74 10		 je	 SHORT $LN3@StreamIn@2

; 1448 :                 document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );

  0005e	6a 00		 push	 0
  00060	6a 00		 push	 0
  00062	6a 00		 push	 0
  00064	6a 0e		 push	 14			; 0000000eH
  00066	8b 4d f8	 mov	 ecx, DWORD PTR _document$21661[ebp]
  00069	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN3@StreamIn@2:

; 1449 :             return;

  0006e	eb 73		 jmp	 SHORT $LN8@StreamIn@2
$LN4@StreamIn@2:

; 1450 :         }
; 1451 : 
; 1452 :         (*tag) += (char) c;

  00070	0f b6 45 fc	 movzx	 eax, BYTE PTR _c$21658[ebp]
  00074	50		 push	 eax
  00075	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  00078	e8 00 00 00 00	 call	 ??Y?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@D@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator+=

; 1453 :         in->get();    // "commits" the peek made above

  0007d	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  00080	e8 00 00 00 00	 call	 ?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::get

; 1454 : 
; 1455 :         if ( cdata && c == '>' && tag->size() >= 3 ) {

  00085	8b 4d f0	 mov	 ecx, DWORD PTR _this$[ebp]
  00088	0f b6 51 44	 movzx	 edx, BYTE PTR [ecx+68]
  0008c	85 d2		 test	 edx, edx
  0008e	74 4e		 je	 SHORT $LN2@StreamIn@2
  00090	83 7d fc 3e	 cmp	 DWORD PTR _c$21658[ebp], 62 ; 0000003eH
  00094	75 48		 jne	 SHORT $LN2@StreamIn@2
  00096	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  00099	e8 00 00 00 00	 call	 ?size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEIXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::size
  0009e	83 f8 03	 cmp	 eax, 3
  000a1	72 3b		 jb	 SHORT $LN2@StreamIn@2

; 1456 :             size_t len = tag->size();

  000a3	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  000a6	e8 00 00 00 00	 call	 ?size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEIXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::size
  000ab	89 45 f4	 mov	 DWORD PTR _len$21665[ebp], eax

; 1457 :             if ( (*tag)[len-2] == ']' && (*tag)[len-3] == ']' ) {

  000ae	8b 45 f4	 mov	 eax, DWORD PTR _len$21665[ebp]
  000b1	83 e8 02	 sub	 eax, 2
  000b4	50		 push	 eax
  000b5	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  000b8	e8 00 00 00 00	 call	 ??A?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAADI@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator[]
  000bd	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  000c0	83 f9 5d	 cmp	 ecx, 93			; 0000005dH
  000c3	75 19		 jne	 SHORT $LN2@StreamIn@2
  000c5	8b 55 f4	 mov	 edx, DWORD PTR _len$21665[ebp]
  000c8	83 ea 03	 sub	 edx, 3
  000cb	52		 push	 edx
  000cc	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  000cf	e8 00 00 00 00	 call	 ??A?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAADI@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator[]
  000d4	0f be 00	 movsx	 eax, BYTE PTR [eax]
  000d7	83 f8 5d	 cmp	 eax, 93			; 0000005dH
  000da	75 02		 jne	 SHORT $LN2@StreamIn@2

; 1458 :                 // terminator of cdata.
; 1459 :                 return;

  000dc	eb 05		 jmp	 SHORT $LN8@StreamIn@2
$LN2@StreamIn@2:

; 1460 :             }
; 1461 :         }
; 1462 :     }

  000de	e9 26 ff ff ff	 jmp	 $LN7@StreamIn@2
$LN8@StreamIn@2:

; 1463 : }

  000e3	8b e5		 mov	 esp, ebp
  000e5	5d		 pop	 ebp
  000e6	c2 08 00	 ret	 8
?StreamIn@TiXmlText@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ENDP ; TiXmlText::StreamIn
; Function compile flags: /Odtp
_TEXT	ENDS
;	COMDAT ?StreamIn@TiXmlComment@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z
_TEXT	SEGMENT
_this$ = -12						; size = 4
_document$21600 = -8					; size = 4
_c$21598 = -4						; size = 4
_in$ = 8						; size = 4
_tag$ = 12						; size = 4
?StreamIn@TiXmlComment@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z PROC ; TiXmlComment::StreamIn, COMDAT
; _this$ = ecx

; 1305 : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 0c	 sub	 esp, 12			; 0000000cH
  00006	89 4d f4	 mov	 DWORD PTR _this$[ebp], ecx
$LN5@StreamIn@3:

; 1306 :     while ( in->good() )

  00009	8b 45 08	 mov	 eax, DWORD PTR _in$[ebp]
  0000c	8b 08		 mov	 ecx, DWORD PTR [eax]
  0000e	8b 55 08	 mov	 edx, DWORD PTR _in$[ebp]
  00011	03 51 04	 add	 edx, DWORD PTR [ecx+4]
  00014	8b ca		 mov	 ecx, edx
  00016	e8 00 00 00 00	 call	 ?good@ios_base@std@@QBE_NXZ ; std::ios_base::good
  0001b	0f b6 c0	 movzx	 eax, al
  0001e	85 c0		 test	 eax, eax
  00020	0f 84 86 00 00
	00		 je	 $LN6@StreamIn@3

; 1307 :     {
; 1308 :         int c = in->get();

  00026	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  00029	e8 00 00 00 00	 call	 ?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::get
  0002e	89 45 fc	 mov	 DWORD PTR _c$21598[ebp], eax

; 1309 :         if ( c <= 0 )

  00031	83 7d fc 00	 cmp	 DWORD PTR _c$21598[ebp], 0
  00035	7f 23		 jg	 SHORT $LN3@StreamIn@3

; 1310 :         {
; 1311 :             TiXmlDocument* document = GetDocument();

  00037	8b 4d f4	 mov	 ecx, DWORD PTR _this$[ebp]
  0003a	e8 00 00 00 00	 call	 ?GetDocument@TiXmlNode@@QAEPAVTiXmlDocument@@XZ ; TiXmlNode::GetDocument
  0003f	89 45 f8	 mov	 DWORD PTR _document$21600[ebp], eax

; 1312 :             if ( document )

  00042	83 7d f8 00	 cmp	 DWORD PTR _document$21600[ebp], 0
  00046	74 10		 je	 SHORT $LN2@StreamIn@3

; 1313 :                 document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );

  00048	6a 00		 push	 0
  0004a	6a 00		 push	 0
  0004c	6a 00		 push	 0
  0004e	6a 0e		 push	 14			; 0000000eH
  00050	8b 4d f8	 mov	 ecx, DWORD PTR _document$21600[ebp]
  00053	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN2@StreamIn@3:

; 1314 :             return;

  00058	eb 52		 jmp	 SHORT $LN6@StreamIn@3
$LN3@StreamIn@3:

; 1315 :         }
; 1316 : 
; 1317 :         (*tag) += (char) c;

  0005a	0f b6 4d fc	 movzx	 ecx, BYTE PTR _c$21598[ebp]
  0005e	51		 push	 ecx
  0005f	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  00062	e8 00 00 00 00	 call	 ??Y?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@D@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator+=

; 1318 : 
; 1319 :         if ( c == '>'
; 1320 :              && tag->at( tag->length() - 2 ) == '-'
; 1321 :              && tag->at( tag->length() - 3 ) == '-' )

  00067	83 7d fc 3e	 cmp	 DWORD PTR _c$21598[ebp], 62 ; 0000003eH
  0006b	75 3a		 jne	 SHORT $LN1@StreamIn@3
  0006d	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  00070	e8 00 00 00 00	 call	 ?length@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEIXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::length
  00075	83 e8 02	 sub	 eax, 2
  00078	50		 push	 eax
  00079	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  0007c	e8 00 00 00 00	 call	 ?at@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAADI@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::at
  00081	0f be 10	 movsx	 edx, BYTE PTR [eax]
  00084	83 fa 2d	 cmp	 edx, 45			; 0000002dH
  00087	75 1e		 jne	 SHORT $LN1@StreamIn@3
  00089	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  0008c	e8 00 00 00 00	 call	 ?length@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEIXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::length
  00091	83 e8 03	 sub	 eax, 3
  00094	50		 push	 eax
  00095	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  00098	e8 00 00 00 00	 call	 ?at@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAADI@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::at
  0009d	0f be 00	 movsx	 eax, BYTE PTR [eax]
  000a0	83 f8 2d	 cmp	 eax, 45			; 0000002dH
  000a3	75 02		 jne	 SHORT $LN1@StreamIn@3

; 1322 :         {
; 1323 :             // All is well.
; 1324 :             return;

  000a5	eb 05		 jmp	 SHORT $LN6@StreamIn@3
$LN1@StreamIn@3:

; 1325 :         }
; 1326 :     }

  000a7	e9 5d ff ff ff	 jmp	 $LN5@StreamIn@3
$LN6@StreamIn@3:

; 1327 : }

  000ac	8b e5		 mov	 esp, ebp
  000ae	5d		 pop	 ebp
  000af	c2 08 00	 ret	 8
?StreamIn@TiXmlComment@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ENDP ; TiXmlComment::StreamIn
; Function compile flags: /Odtp
_TEXT	ENDS
;	COMDAT ?StreamIn@TiXmlUnknown@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z
_TEXT	SEGMENT
_this$ = -12						; size = 4
_document$21569 = -8					; size = 4
_c$21567 = -4						; size = 4
_in$ = 8						; size = 4
_tag$ = 12						; size = 4
?StreamIn@TiXmlUnknown@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z PROC ; TiXmlUnknown::StreamIn, COMDAT
; _this$ = ecx

; 1247 : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 0c	 sub	 esp, 12			; 0000000cH
  00006	89 4d f4	 mov	 DWORD PTR _this$[ebp], ecx
$LN5@StreamIn@4:

; 1248 :     while ( in->good() )

  00009	8b 45 08	 mov	 eax, DWORD PTR _in$[ebp]
  0000c	8b 08		 mov	 ecx, DWORD PTR [eax]
  0000e	8b 55 08	 mov	 edx, DWORD PTR _in$[ebp]
  00011	03 51 04	 add	 edx, DWORD PTR [ecx+4]
  00014	8b ca		 mov	 ecx, edx
  00016	e8 00 00 00 00	 call	 ?good@ios_base@std@@QBE_NXZ ; std::ios_base::good
  0001b	0f b6 c0	 movzx	 eax, al
  0001e	85 c0		 test	 eax, eax
  00020	74 4b		 je	 SHORT $LN6@StreamIn@4

; 1249 :     {
; 1250 :         int c = in->get();

  00022	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  00025	e8 00 00 00 00	 call	 ?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::get
  0002a	89 45 fc	 mov	 DWORD PTR _c$21567[ebp], eax

; 1251 :         if ( c <= 0 )

  0002d	83 7d fc 00	 cmp	 DWORD PTR _c$21567[ebp], 0
  00031	7f 23		 jg	 SHORT $LN3@StreamIn@4

; 1252 :         {
; 1253 :             TiXmlDocument* document = GetDocument();

  00033	8b 4d f4	 mov	 ecx, DWORD PTR _this$[ebp]
  00036	e8 00 00 00 00	 call	 ?GetDocument@TiXmlNode@@QAEPAVTiXmlDocument@@XZ ; TiXmlNode::GetDocument
  0003b	89 45 f8	 mov	 DWORD PTR _document$21569[ebp], eax

; 1254 :             if ( document )

  0003e	83 7d f8 00	 cmp	 DWORD PTR _document$21569[ebp], 0
  00042	74 10		 je	 SHORT $LN2@StreamIn@4

; 1255 :                 document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );

  00044	6a 00		 push	 0
  00046	6a 00		 push	 0
  00048	6a 00		 push	 0
  0004a	6a 0e		 push	 14			; 0000000eH
  0004c	8b 4d f8	 mov	 ecx, DWORD PTR _document$21569[ebp]
  0004f	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN2@StreamIn@4:

; 1256 :             return;

  00054	eb 17		 jmp	 SHORT $LN6@StreamIn@4
$LN3@StreamIn@4:

; 1257 :         }
; 1258 :         (*tag) += (char) c;

  00056	0f b6 4d fc	 movzx	 ecx, BYTE PTR _c$21567[ebp]
  0005a	51		 push	 ecx
  0005b	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  0005e	e8 00 00 00 00	 call	 ??Y?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@D@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator+=

; 1259 : 
; 1260 :         if ( c == '>' )

  00063	83 7d fc 3e	 cmp	 DWORD PTR _c$21567[ebp], 62 ; 0000003eH
  00067	75 02		 jne	 SHORT $LN1@StreamIn@4

; 1261 :         {
; 1262 :             // All is well.
; 1263 :             return;

  00069	eb 02		 jmp	 SHORT $LN6@StreamIn@4
$LN1@StreamIn@4:

; 1264 :         }
; 1265 :     }

  0006b	eb 9c		 jmp	 SHORT $LN5@StreamIn@4
$LN6@StreamIn@4:

; 1266 : }

  0006d	8b e5		 mov	 esp, ebp
  0006f	5d		 pop	 ebp
  00070	c2 08 00	 ret	 8
?StreamIn@TiXmlUnknown@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ENDP ; TiXmlUnknown::StreamIn
_TEXT	ENDS
PUBLIC	?StreamTo@TiXmlBase@@KA_NPAV?$basic_istream@DU?$char_traits@D@std@@@std@@HPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ; TiXmlBase::StreamTo
; Function compile flags: /Odtp
;	COMDAT ?StreamTo@TiXmlBase@@KA_NPAV?$basic_istream@DU?$char_traits@D@std@@@std@@HPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z
_TEXT	SEGMENT
_c$21059 = -4						; size = 4
_in$ = 8						; size = 4
_character$ = 12					; size = 4
_tag$ = 16						; size = 4
?StreamTo@TiXmlBase@@KA_NPAV?$basic_istream@DU?$char_traits@D@std@@@std@@HPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z PROC ; TiXmlBase::StreamTo, COMDAT

; 381  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
$LN4@StreamTo:

; 382  :     //assert( character > 0 && character < 128 );    // else it won't work in utf-8
; 383  :     while ( in->good() )

  00004	8b 45 08	 mov	 eax, DWORD PTR _in$[ebp]
  00007	8b 08		 mov	 ecx, DWORD PTR [eax]
  00009	8b 55 08	 mov	 edx, DWORD PTR _in$[ebp]
  0000c	03 51 04	 add	 edx, DWORD PTR [ecx+4]
  0000f	8b ca		 mov	 ecx, edx
  00011	e8 00 00 00 00	 call	 ?good@ios_base@std@@QBE_NXZ ; std::ios_base::good
  00016	0f b6 c0	 movzx	 eax, al
  00019	85 c0		 test	 eax, eax
  0001b	74 38		 je	 SHORT $LN3@StreamTo

; 384  :     {
; 385  :         int c = in->peek();

  0001d	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  00020	e8 00 00 00 00	 call	 ?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::peek
  00025	89 45 fc	 mov	 DWORD PTR _c$21059[ebp], eax

; 386  :         if ( c == character )

  00028	8b 4d fc	 mov	 ecx, DWORD PTR _c$21059[ebp]
  0002b	3b 4d 0c	 cmp	 ecx, DWORD PTR _character$[ebp]
  0002e	75 04		 jne	 SHORT $LN2@StreamTo

; 387  :             return true;

  00030	b0 01		 mov	 al, 1
  00032	eb 23		 jmp	 SHORT $LN5@StreamTo
$LN2@StreamTo:

; 388  :         if ( c <= 0 )        // Silent failure: can't get document at this scope

  00034	83 7d fc 00	 cmp	 DWORD PTR _c$21059[ebp], 0
  00038	7f 04		 jg	 SHORT $LN1@StreamTo

; 389  :             return false;

  0003a	32 c0		 xor	 al, al
  0003c	eb 19		 jmp	 SHORT $LN5@StreamTo
$LN1@StreamTo:

; 390  : 
; 391  :         in->get();

  0003e	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  00041	e8 00 00 00 00	 call	 ?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::get

; 392  :         *tag += (char) c;

  00046	0f b6 55 fc	 movzx	 edx, BYTE PTR _c$21059[ebp]
  0004a	52		 push	 edx
  0004b	8b 4d 10	 mov	 ecx, DWORD PTR _tag$[ebp]
  0004e	e8 00 00 00 00	 call	 ??Y?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@D@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator+=

; 393  :     }

  00053	eb af		 jmp	 SHORT $LN4@StreamTo
$LN3@StreamTo:

; 394  :     return false;

  00055	32 c0		 xor	 al, al
$LN5@StreamTo:

; 395  : }

  00057	8b e5		 mov	 esp, ebp
  00059	5d		 pop	 ebp
  0005a	c3		 ret	 0
?StreamTo@TiXmlBase@@KA_NPAV?$basic_istream@DU?$char_traits@D@std@@@std@@HPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ENDP ; TiXmlBase::StreamTo
_TEXT	ENDS
PUBLIC	?StreamWhiteSpace@TiXmlBase@@KA_NPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ; TiXmlBase::StreamWhiteSpace
; Function compile flags: /Odtp
;	COMDAT ?StreamWhiteSpace@TiXmlBase@@KA_NPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z
_TEXT	SEGMENT
_c$21047 = -4						; size = 4
_in$ = 8						; size = 4
_tag$ = 12						; size = 4
?StreamWhiteSpace@TiXmlBase@@KA_NPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z PROC ; TiXmlBase::StreamWhiteSpace, COMDAT

; 366  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	51		 push	 ecx
$LN5@StreamWhit:

; 367  :     for( ;; )
; 368  :     {
; 369  :         if ( !in->good() ) return false;

  00004	8b 45 08	 mov	 eax, DWORD PTR _in$[ebp]
  00007	8b 08		 mov	 ecx, DWORD PTR [eax]
  00009	8b 55 08	 mov	 edx, DWORD PTR _in$[ebp]
  0000c	03 51 04	 add	 edx, DWORD PTR [ecx+4]
  0000f	8b ca		 mov	 ecx, edx
  00011	e8 00 00 00 00	 call	 ?good@ios_base@std@@QBE_NXZ ; std::ios_base::good
  00016	0f b6 c0	 movzx	 eax, al
  00019	85 c0		 test	 eax, eax
  0001b	75 04		 jne	 SHORT $LN3@StreamWhit
  0001d	32 c0		 xor	 al, al
  0001f	eb 3b		 jmp	 SHORT $LN6@StreamWhit
$LN3@StreamWhit:

; 370  : 
; 371  :         int c = in->peek();

  00021	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  00024	e8 00 00 00 00	 call	 ?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::peek
  00029	89 45 fc	 mov	 DWORD PTR _c$21047[ebp], eax

; 372  :         // At this scope, we can't get to a document. So fail silently.
; 373  :         if ( !IsWhiteSpace( c ) || c <= 0 )

  0002c	8b 4d fc	 mov	 ecx, DWORD PTR _c$21047[ebp]
  0002f	51		 push	 ecx
  00030	e8 00 00 00 00	 call	 ?IsWhiteSpace@TiXmlBase@@KA_NH@Z ; TiXmlBase::IsWhiteSpace
  00035	83 c4 04	 add	 esp, 4
  00038	0f b6 d0	 movzx	 edx, al
  0003b	85 d2		 test	 edx, edx
  0003d	74 06		 je	 SHORT $LN1@StreamWhit
  0003f	83 7d fc 00	 cmp	 DWORD PTR _c$21047[ebp], 0
  00043	7f 04		 jg	 SHORT $LN2@StreamWhit
$LN1@StreamWhit:

; 374  :             return true;

  00045	b0 01		 mov	 al, 1
  00047	eb 13		 jmp	 SHORT $LN6@StreamWhit
$LN2@StreamWhit:

; 375  : 
; 376  :         *tag += (char) in->get();

  00049	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  0004c	e8 00 00 00 00	 call	 ?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::get
  00051	50		 push	 eax
  00052	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  00055	e8 00 00 00 00	 call	 ??Y?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@D@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator+=

; 377  :     }

  0005a	eb a8		 jmp	 SHORT $LN5@StreamWhit
$LN6@StreamWhit:

; 378  : }

  0005c	8b e5		 mov	 esp, ebp
  0005e	5d		 pop	 ebp
  0005f	c3		 ret	 0
?StreamWhiteSpace@TiXmlBase@@KA_NPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ENDP ; TiXmlBase::StreamWhiteSpace
PUBLIC	__$ArrayPad$
;	COMDAT xdata$x
xdata$x	SEGMENT
__unwindtable$?StreamIn@TiXmlElement@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z DD 0ffffffffH
	DD	FLAT:__unwindfunclet$?StreamIn@TiXmlElement@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z$0
__ehfuncinfo$?StreamIn@TiXmlElement@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z DD 019930522H
	DD	01H
	DD	FLAT:__unwindtable$?StreamIn@TiXmlElement@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z
	DD	2 DUP(00H)
	DD	2 DUP(00H)
	DD	00H
	DD	00H
; Function compile flags: /Odtp
xdata$x	ENDS
;	COMDAT ?StreamIn@TiXmlElement@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z
_TEXT	SEGMENT
tv307 = -156						; size = 4
_this$ = -152						; size = 4
$T347363 = -148						; size = 4
$T347362 = -144						; size = 4
_node$21459 = -140					; size = 4
_tagloc$21458 = -136					; size = 4
_document$21453 = -132					; size = 4
_c$21451 = -128						; size = 4
_start$21444 = -124					; size = 4
_len$21443 = -120					; size = 4
_document$21438 = -116					; size = 4
_c$21436 = -112						; size = 4
_text$21425 = -108					; size = 72
__$ArrayPad$ = -32					; size = 4
_tagIndex$21428 = -28					; size = 4
_closingTag$21430 = -22					; size = 1
_firstCharFound$21431 = -21				; size = 1
_document$21413 = -20					; size = 4
_c$21411 = -16						; size = 4
__$EHRec$ = -12						; size = 12
_in$ = 8						; size = 4
_tag$ = 12						; size = 4
?StreamIn@TiXmlElement@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z PROC ; TiXmlElement::StreamIn, COMDAT
; _this$ = ecx

; 910  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	6a ff		 push	 -1
  00005	68 00 00 00 00	 push	 __ehhandler$?StreamIn@TiXmlElement@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z
  0000a	64 a1 00 00 00
	00		 mov	 eax, DWORD PTR fs:0
  00010	50		 push	 eax
  00011	81 ec 90 00 00
	00		 sub	 esp, 144		; 00000090H
  00017	a1 00 00 00 00	 mov	 eax, DWORD PTR ___security_cookie
  0001c	33 c5		 xor	 eax, ebp
  0001e	89 45 e0	 mov	 DWORD PTR __$ArrayPad$[ebp], eax
  00021	50		 push	 eax
  00022	8d 45 f4	 lea	 eax, DWORD PTR __$EHRec$[ebp]
  00025	64 a3 00 00 00
	00		 mov	 DWORD PTR fs:0, eax
  0002b	89 8d 68 ff ff
	ff		 mov	 DWORD PTR _this$[ebp], ecx
$LN29@StreamIn@5:

; 911  :     // We're called with some amount of pre-parsing. That is, some of "this"
; 912  :     // element is in "tag". Go ahead and stream to the closing ">"
; 913  :     while( in->good() )

  00031	8b 45 08	 mov	 eax, DWORD PTR _in$[ebp]
  00034	8b 08		 mov	 ecx, DWORD PTR [eax]
  00036	8b 55 08	 mov	 edx, DWORD PTR _in$[ebp]
  00039	03 51 04	 add	 edx, DWORD PTR [ecx+4]
  0003c	8b ca		 mov	 ecx, edx
  0003e	e8 00 00 00 00	 call	 ?good@ios_base@std@@QBE_NXZ ; std::ios_base::good
  00043	0f b6 c0	 movzx	 eax, al
  00046	85 c0		 test	 eax, eax
  00048	74 51		 je	 SHORT $LN28@StreamIn@5

; 914  :     {
; 915  :         int c = in->get();

  0004a	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  0004d	e8 00 00 00 00	 call	 ?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::get
  00052	89 45 f0	 mov	 DWORD PTR _c$21411[ebp], eax

; 916  :         if ( c <= 0 )

  00055	83 7d f0 00	 cmp	 DWORD PTR _c$21411[ebp], 0
  00059	7f 29		 jg	 SHORT $LN27@StreamIn@5

; 917  :         {
; 918  :             TiXmlDocument* document = GetDocument();

  0005b	8b 8d 68 ff ff
	ff		 mov	 ecx, DWORD PTR _this$[ebp]
  00061	e8 00 00 00 00	 call	 ?GetDocument@TiXmlNode@@QAEPAVTiXmlDocument@@XZ ; TiXmlNode::GetDocument
  00066	89 45 ec	 mov	 DWORD PTR _document$21413[ebp], eax

; 919  :             if ( document )

  00069	83 7d ec 00	 cmp	 DWORD PTR _document$21413[ebp], 0
  0006d	74 10		 je	 SHORT $LN26@StreamIn@5

; 920  :                 document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );

  0006f	6a 00		 push	 0
  00071	6a 00		 push	 0
  00073	6a 00		 push	 0
  00075	6a 0e		 push	 14			; 0000000eH
  00077	8b 4d ec	 mov	 ecx, DWORD PTR _document$21413[ebp]
  0007a	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN26@StreamIn@5:

; 921  :             return;

  0007f	e9 3d 03 00 00	 jmp	 $LN30@StreamIn@5
$LN27@StreamIn@5:

; 922  :         }
; 923  :         (*tag) += (char) c ;

  00084	0f b6 4d f0	 movzx	 ecx, BYTE PTR _c$21411[ebp]
  00088	51		 push	 ecx
  00089	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  0008c	e8 00 00 00 00	 call	 ??Y?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@D@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator+=

; 924  : 
; 925  :         if ( c == '>' )

  00091	83 7d f0 3e	 cmp	 DWORD PTR _c$21411[ebp], 62 ; 0000003eH
  00095	75 02		 jne	 SHORT $LN25@StreamIn@5

; 926  :             break;

  00097	eb 02		 jmp	 SHORT $LN28@StreamIn@5
$LN25@StreamIn@5:

; 927  :     }

  00099	eb 96		 jmp	 SHORT $LN29@StreamIn@5
$LN28@StreamIn@5:

; 928  : 
; 929  :     if ( tag->length() < 3 ) return;

  0009b	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  0009e	e8 00 00 00 00	 call	 ?length@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEIXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::length
  000a3	83 f8 03	 cmp	 eax, 3
  000a6	73 05		 jae	 SHORT $LN24@StreamIn@5
  000a8	e9 14 03 00 00	 jmp	 $LN30@StreamIn@5
$LN24@StreamIn@5:

; 930  : 
; 931  :     // Okay...if we are a "/>" tag, then we're done. We've read a complete tag.
; 932  :     // If not, identify and stream.
; 933  : 
; 934  :     if (    tag->at( tag->length() - 1 ) == '>'
; 935  :          && tag->at( tag->length() - 2 ) == '/' )

  000ad	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  000b0	e8 00 00 00 00	 call	 ?length@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEIXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::length
  000b5	83 e8 01	 sub	 eax, 1
  000b8	50		 push	 eax
  000b9	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  000bc	e8 00 00 00 00	 call	 ?at@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAADI@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::at
  000c1	0f be 10	 movsx	 edx, BYTE PTR [eax]
  000c4	83 fa 3e	 cmp	 edx, 62			; 0000003eH
  000c7	75 26		 jne	 SHORT $LN23@StreamIn@5
  000c9	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  000cc	e8 00 00 00 00	 call	 ?length@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEIXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::length
  000d1	83 e8 02	 sub	 eax, 2
  000d4	50		 push	 eax
  000d5	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  000d8	e8 00 00 00 00	 call	 ?at@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAADI@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::at
  000dd	0f be 00	 movsx	 eax, BYTE PTR [eax]
  000e0	83 f8 2f	 cmp	 eax, 47			; 0000002fH
  000e3	75 0a		 jne	 SHORT $LN23@StreamIn@5
  000e5	e9 d7 02 00 00	 jmp	 $LN30@StreamIn@5

; 936  :     {
; 937  :         // All good!
; 938  :         return;

  000ea	e9 d2 02 00 00	 jmp	 $LN30@StreamIn@5
$LN23@StreamIn@5:

; 939  :     }
; 940  :     else if ( tag->at( tag->length() - 1 ) == '>' )

  000ef	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  000f2	e8 00 00 00 00	 call	 ?length@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEIXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::length
  000f7	83 e8 01	 sub	 eax, 1
  000fa	50		 push	 eax
  000fb	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  000fe	e8 00 00 00 00	 call	 ?at@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAADI@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::at
  00103	0f be 08	 movsx	 ecx, BYTE PTR [eax]
  00106	83 f9 3e	 cmp	 ecx, 62			; 0000003eH
  00109	0f 85 b2 02 00
	00		 jne	 $LN30@StreamIn@5
$LN20@StreamIn@5:

; 941  :     {
; 942  :         // There is more. Could be:
; 943  :         //        text
; 944  :         //        cdata text (which looks like another node)
; 945  :         //        closing tag
; 946  :         //        another node.
; 947  :         for ( ;; )
; 948  :         {
; 949  :             StreamWhiteSpace( in, tag );

  0010f	8b 55 0c	 mov	 edx, DWORD PTR _tag$[ebp]
  00112	52		 push	 edx
  00113	8b 45 08	 mov	 eax, DWORD PTR _in$[ebp]
  00116	50		 push	 eax
  00117	e8 00 00 00 00	 call	 ?StreamWhiteSpace@TiXmlBase@@KA_NPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ; TiXmlBase::StreamWhiteSpace
  0011c	83 c4 08	 add	 esp, 8

; 950  : 
; 951  :             // Do we have text?
; 952  :             if ( in->good() && in->peek() != '<' )

  0011f	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  00122	8b 11		 mov	 edx, DWORD PTR [ecx]
  00124	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  00127	03 4a 04	 add	 ecx, DWORD PTR [edx+4]
  0012a	e8 00 00 00 00	 call	 ?good@ios_base@std@@QBE_NXZ ; std::ios_base::good
  0012f	0f b6 c0	 movzx	 eax, al
  00132	85 c0		 test	 eax, eax
  00134	74 42		 je	 SHORT $LN18@StreamIn@5
  00136	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  00139	e8 00 00 00 00	 call	 ?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::peek
  0013e	83 f8 3c	 cmp	 eax, 60			; 0000003cH
  00141	74 35		 je	 SHORT $LN18@StreamIn@5

; 953  :             {
; 954  :                 // Yep, text.
; 955  :                 TiXmlText text( "" );

  00143	68 00 00 00 00	 push	 OFFSET ??_C@_00CNPNBAHC@?$AA@
  00148	8d 4d 94	 lea	 ecx, DWORD PTR _text$21425[ebp]
  0014b	e8 00 00 00 00	 call	 ??0TiXmlText@@QAE@PBD@Z	; TiXmlText::TiXmlText
  00150	c7 45 fc 00 00
	00 00		 mov	 DWORD PTR __$EHRec$[ebp+8], 0

; 956  :                 text.StreamIn( in, tag );

  00157	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  0015a	51		 push	 ecx
  0015b	8b 55 08	 mov	 edx, DWORD PTR _in$[ebp]
  0015e	52		 push	 edx
  0015f	8d 4d 94	 lea	 ecx, DWORD PTR _text$21425[ebp]
  00162	e8 00 00 00 00	 call	 ?StreamIn@TiXmlText@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ; TiXmlText::StreamIn

; 957  : 
; 958  :                 // What follows text is a closing tag or another node.
; 959  :                 // Go around again and figure it out.
; 960  :                 continue;

  00167	c7 45 fc ff ff
	ff ff		 mov	 DWORD PTR __$EHRec$[ebp+8], -1
  0016e	8d 4d 94	 lea	 ecx, DWORD PTR _text$21425[ebp]
  00171	e8 00 00 00 00	 call	 ??1TiXmlText@@UAE@XZ	; TiXmlText::~TiXmlText
  00176	eb 97		 jmp	 SHORT $LN20@StreamIn@5
$LN18@StreamIn@5:

; 961  :             }
; 962  : 
; 963  :             // We now have either a closing tag...or another node.
; 964  :             // We should be at a "<", regardless.
; 965  :             if ( !in->good() ) return;

  00178	8b 45 08	 mov	 eax, DWORD PTR _in$[ebp]
  0017b	8b 08		 mov	 ecx, DWORD PTR [eax]
  0017d	8b 55 08	 mov	 edx, DWORD PTR _in$[ebp]
  00180	03 51 04	 add	 edx, DWORD PTR [ecx+4]
  00183	8b ca		 mov	 ecx, edx
  00185	e8 00 00 00 00	 call	 ?good@ios_base@std@@QBE_NXZ ; std::ios_base::good
  0018a	0f b6 c0	 movzx	 eax, al
  0018d	85 c0		 test	 eax, eax
  0018f	75 05		 jne	 SHORT $LN17@StreamIn@5
  00191	e9 2b 02 00 00	 jmp	 $LN30@StreamIn@5
$LN17@StreamIn@5:

; 966  :             assert( in->peek() == '<' );
; 967  :             int tagIndex = (int) tag->length();

  00196	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  00199	e8 00 00 00 00	 call	 ?length@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEIXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::length
  0019e	89 45 e4	 mov	 DWORD PTR _tagIndex$21428[ebp], eax

; 968  : 
; 969  :             bool closingTag = false;

  001a1	c6 45 ea 00	 mov	 BYTE PTR _closingTag$21430[ebp], 0

; 970  :             bool firstCharFound = false;

  001a5	c6 45 eb 00	 mov	 BYTE PTR _firstCharFound$21431[ebp], 0
$LN16@StreamIn@5:

; 971  : 
; 972  :             for( ;; )
; 973  :             {
; 974  :                 if ( !in->good() )

  001a9	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  001ac	8b 11		 mov	 edx, DWORD PTR [ecx]
  001ae	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  001b1	03 4a 04	 add	 ecx, DWORD PTR [edx+4]
  001b4	e8 00 00 00 00	 call	 ?good@ios_base@std@@QBE_NXZ ; std::ios_base::good
  001b9	0f b6 c0	 movzx	 eax, al
  001bc	85 c0		 test	 eax, eax
  001be	75 05		 jne	 SHORT $LN14@StreamIn@5

; 975  :                     return;

  001c0	e9 fc 01 00 00	 jmp	 $LN30@StreamIn@5
$LN14@StreamIn@5:

; 976  : 
; 977  :                 int c = in->peek();

  001c5	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  001c8	e8 00 00 00 00	 call	 ?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::peek
  001cd	89 45 90	 mov	 DWORD PTR _c$21436[ebp], eax

; 978  :                 if ( c <= 0 )

  001d0	83 7d 90 00	 cmp	 DWORD PTR _c$21436[ebp], 0
  001d4	7f 29		 jg	 SHORT $LN13@StreamIn@5

; 979  :                 {
; 980  :                     TiXmlDocument* document = GetDocument();

  001d6	8b 8d 68 ff ff
	ff		 mov	 ecx, DWORD PTR _this$[ebp]
  001dc	e8 00 00 00 00	 call	 ?GetDocument@TiXmlNode@@QAEPAVTiXmlDocument@@XZ ; TiXmlNode::GetDocument
  001e1	89 45 8c	 mov	 DWORD PTR _document$21438[ebp], eax

; 981  :                     if ( document )

  001e4	83 7d 8c 00	 cmp	 DWORD PTR _document$21438[ebp], 0
  001e8	74 10		 je	 SHORT $LN12@StreamIn@5

; 982  :                         document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );

  001ea	6a 00		 push	 0
  001ec	6a 00		 push	 0
  001ee	6a 00		 push	 0
  001f0	6a 0e		 push	 14			; 0000000eH
  001f2	8b 4d 8c	 mov	 ecx, DWORD PTR _document$21438[ebp]
  001f5	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN12@StreamIn@5:

; 983  :                     return;

  001fa	e9 c2 01 00 00	 jmp	 $LN30@StreamIn@5
$LN13@StreamIn@5:

; 984  :                 }
; 985  : 
; 986  :                 if ( c == '>' )

  001ff	83 7d 90 3e	 cmp	 DWORD PTR _c$21436[ebp], 62 ; 0000003eH
  00203	75 05		 jne	 SHORT $LN11@StreamIn@5

; 987  :                     break;

  00205	e9 90 00 00 00	 jmp	 $LN15@StreamIn@5
$LN11@StreamIn@5:

; 988  : 
; 989  :                 *tag += (char) c;

  0020a	0f b6 4d 90	 movzx	 ecx, BYTE PTR _c$21436[ebp]
  0020e	51		 push	 ecx
  0020f	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  00212	e8 00 00 00 00	 call	 ??Y?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@D@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator+=

; 990  :                 in->get();

  00217	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  0021a	e8 00 00 00 00	 call	 ?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::get

; 991  : 
; 992  :                 // Early out if we find the CDATA id.
; 993  :                 if ( c == '[' && tag->size() >= 9 )

  0021f	83 7d 90 5b	 cmp	 DWORD PTR _c$21436[ebp], 91 ; 0000005bH
  00223	75 41		 jne	 SHORT $LN10@StreamIn@5
  00225	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  00228	e8 00 00 00 00	 call	 ?size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEIXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::size
  0022d	83 f8 09	 cmp	 eax, 9
  00230	72 34		 jb	 SHORT $LN10@StreamIn@5

; 994  :                 {
; 995  :                     size_t len = tag->size();

  00232	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  00235	e8 00 00 00 00	 call	 ?size@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEIXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::size
  0023a	89 45 88	 mov	 DWORD PTR _len$21443[ebp], eax

; 996  :                     const char* start = tag->c_str() + len - 9;

  0023d	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  00240	e8 00 00 00 00	 call	 ?c_str@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEPBDXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::c_str
  00245	8b 55 88	 mov	 edx, DWORD PTR _len$21443[ebp]
  00248	8d 44 10 f7	 lea	 eax, DWORD PTR [eax+edx-9]
  0024c	89 45 84	 mov	 DWORD PTR _start$21444[ebp], eax

; 997  :                     if ( strcmp( start, "<![CDATA[" ) == 0 ) {

  0024f	68 00 00 00 00	 push	 OFFSET ??_C@_09BLLNCBLF@?$DM?$CB?$FLCDATA?$FL?$AA@
  00254	8b 4d 84	 mov	 ecx, DWORD PTR _start$21444[ebp]
  00257	51		 push	 ecx
  00258	e8 00 00 00 00	 call	 _strcmp
  0025d	83 c4 08	 add	 esp, 8
  00260	85 c0		 test	 eax, eax
  00262	75 02		 jne	 SHORT $LN10@StreamIn@5

; 998  :                         assert( !closingTag );
; 999  :                         break;

  00264	eb 34		 jmp	 SHORT $LN15@StreamIn@5
$LN10@StreamIn@5:

; 1000 :                     }
; 1001 :                 }
; 1002 : 
; 1003 :                 if ( !firstCharFound && c != '<' && !IsWhiteSpace( c ) )

  00266	0f b6 55 eb	 movzx	 edx, BYTE PTR _firstCharFound$21431[ebp]
  0026a	85 d2		 test	 edx, edx
  0026c	75 27		 jne	 SHORT $LN8@StreamIn@5
  0026e	83 7d 90 3c	 cmp	 DWORD PTR _c$21436[ebp], 60 ; 0000003cH
  00272	74 21		 je	 SHORT $LN8@StreamIn@5
  00274	8b 45 90	 mov	 eax, DWORD PTR _c$21436[ebp]
  00277	50		 push	 eax
  00278	e8 00 00 00 00	 call	 ?IsWhiteSpace@TiXmlBase@@KA_NH@Z ; TiXmlBase::IsWhiteSpace
  0027d	83 c4 04	 add	 esp, 4
  00280	0f b6 c8	 movzx	 ecx, al
  00283	85 c9		 test	 ecx, ecx
  00285	75 0e		 jne	 SHORT $LN8@StreamIn@5

; 1004 :                 {
; 1005 :                     firstCharFound = true;

  00287	c6 45 eb 01	 mov	 BYTE PTR _firstCharFound$21431[ebp], 1

; 1006 :                     if ( c == '/' )

  0028b	83 7d 90 2f	 cmp	 DWORD PTR _c$21436[ebp], 47 ; 0000002fH
  0028f	75 04		 jne	 SHORT $LN8@StreamIn@5

; 1007 :                         closingTag = true;

  00291	c6 45 ea 01	 mov	 BYTE PTR _closingTag$21430[ebp], 1
$LN8@StreamIn@5:

; 1008 :                 }
; 1009 :             }

  00295	e9 0f ff ff ff	 jmp	 $LN16@StreamIn@5
$LN15@StreamIn@5:

; 1010 :             // If it was a closing tag, then read in the closing '>' to clean up the input stream.
; 1011 :             // If it was not, the streaming will be done by the tag.
; 1012 :             if ( closingTag )

  0029a	0f b6 55 ea	 movzx	 edx, BYTE PTR _closingTag$21430[ebp]
  0029e	85 d2		 test	 edx, edx
  002a0	74 78		 je	 SHORT $LN6@StreamIn@5

; 1013 :             {
; 1014 :                 if ( !in->good() )

  002a2	8b 45 08	 mov	 eax, DWORD PTR _in$[ebp]
  002a5	8b 08		 mov	 ecx, DWORD PTR [eax]
  002a7	8b 55 08	 mov	 edx, DWORD PTR _in$[ebp]
  002aa	03 51 04	 add	 edx, DWORD PTR [ecx+4]
  002ad	8b ca		 mov	 ecx, edx
  002af	e8 00 00 00 00	 call	 ?good@ios_base@std@@QBE_NXZ ; std::ios_base::good
  002b4	0f b6 c0	 movzx	 eax, al
  002b7	85 c0		 test	 eax, eax
  002b9	75 05		 jne	 SHORT $LN5@StreamIn@5

; 1015 :                     return;

  002bb	e9 01 01 00 00	 jmp	 $LN30@StreamIn@5
$LN5@StreamIn@5:

; 1016 : 
; 1017 :                 int c = in->get();

  002c0	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  002c3	e8 00 00 00 00	 call	 ?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::get
  002c8	89 45 80	 mov	 DWORD PTR _c$21451[ebp], eax

; 1018 :                 if ( c <= 0 )

  002cb	83 7d 80 00	 cmp	 DWORD PTR _c$21451[ebp], 0
  002cf	7f 32		 jg	 SHORT $LN4@StreamIn@5

; 1019 :                 {
; 1020 :                     TiXmlDocument* document = GetDocument();

  002d1	8b 8d 68 ff ff
	ff		 mov	 ecx, DWORD PTR _this$[ebp]
  002d7	e8 00 00 00 00	 call	 ?GetDocument@TiXmlNode@@QAEPAVTiXmlDocument@@XZ ; TiXmlNode::GetDocument
  002dc	89 85 7c ff ff
	ff		 mov	 DWORD PTR _document$21453[ebp], eax

; 1021 :                     if ( document )

  002e2	83 bd 7c ff ff
	ff 00		 cmp	 DWORD PTR _document$21453[ebp], 0
  002e9	74 13		 je	 SHORT $LN3@StreamIn@5

; 1022 :                         document->SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );

  002eb	6a 00		 push	 0
  002ed	6a 00		 push	 0
  002ef	6a 00		 push	 0
  002f1	6a 0e		 push	 14			; 0000000eH
  002f3	8b 8d 7c ff ff
	ff		 mov	 ecx, DWORD PTR _document$21453[ebp]
  002f9	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN3@StreamIn@5:

; 1023 :                     return;

  002fe	e9 be 00 00 00	 jmp	 $LN30@StreamIn@5
$LN4@StreamIn@5:

; 1024 :                 }
; 1025 :                 assert( c == '>' );
; 1026 :                 *tag += (char) c;

  00303	0f b6 4d 80	 movzx	 ecx, BYTE PTR _c$21451[ebp]
  00307	51		 push	 ecx
  00308	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  0030b	e8 00 00 00 00	 call	 ??Y?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@D@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator+=

; 1027 : 
; 1028 :                 // We are done, once we've found our closing tag.
; 1029 :                 return;

  00310	e9 ac 00 00 00	 jmp	 $LN30@StreamIn@5

; 1030 :             }
; 1031 :             else

  00315	e9 a2 00 00 00	 jmp	 $LN2@StreamIn@5
$LN6@StreamIn@5:

; 1032 :             {
; 1033 :                 // If not a closing tag, id it, and stream.
; 1034 :                 const char* tagloc = tag->c_str() + tagIndex;

  0031a	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  0031d	e8 00 00 00 00	 call	 ?c_str@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEPBDXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::c_str
  00322	03 45 e4	 add	 eax, DWORD PTR _tagIndex$21428[ebp]
  00325	89 85 78 ff ff
	ff		 mov	 DWORD PTR _tagloc$21458[ebp], eax

; 1035 :                 TiXmlNode* node = Identify( tagloc, TIXML_DEFAULT_ENCODING );

  0032b	6a 00		 push	 0
  0032d	8b 95 78 ff ff
	ff		 mov	 edx, DWORD PTR _tagloc$21458[ebp]
  00333	52		 push	 edx
  00334	8b 8d 68 ff ff
	ff		 mov	 ecx, DWORD PTR _this$[ebp]
  0033a	e8 00 00 00 00	 call	 ?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z ; TiXmlNode::Identify
  0033f	89 85 74 ff ff
	ff		 mov	 DWORD PTR _node$21459[ebp], eax

; 1036 :                 if ( !node )

  00345	83 bd 74 ff ff
	ff 00		 cmp	 DWORD PTR _node$21459[ebp], 0
  0034c	75 02		 jne	 SHORT $LN1@StreamIn@5

; 1037 :                     return;

  0034e	eb 71		 jmp	 SHORT $LN30@StreamIn@5
$LN1@StreamIn@5:

; 1038 :                 node->StreamIn( in, tag );

  00350	8b 45 0c	 mov	 eax, DWORD PTR _tag$[ebp]
  00353	50		 push	 eax
  00354	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  00357	51		 push	 ecx
  00358	8b 95 74 ff ff
	ff		 mov	 edx, DWORD PTR _node$21459[ebp]
  0035e	8b 02		 mov	 eax, DWORD PTR [edx]
  00360	8b 8d 74 ff ff
	ff		 mov	 ecx, DWORD PTR _node$21459[ebp]
  00366	8b 50 44	 mov	 edx, DWORD PTR [eax+68]
  00369	ff d2		 call	 edx

; 1039 :                 delete node;

  0036b	8b 85 74 ff ff
	ff		 mov	 eax, DWORD PTR _node$21459[ebp]
  00371	89 85 6c ff ff
	ff		 mov	 DWORD PTR $T347363[ebp], eax
  00377	8b 8d 6c ff ff
	ff		 mov	 ecx, DWORD PTR $T347363[ebp]
  0037d	89 8d 70 ff ff
	ff		 mov	 DWORD PTR $T347362[ebp], ecx
  00383	83 bd 70 ff ff
	ff 00		 cmp	 DWORD PTR $T347362[ebp], 0
  0038a	74 1c		 je	 SHORT $LN32@StreamIn@5
  0038c	6a 01		 push	 1
  0038e	8b 95 70 ff ff
	ff		 mov	 edx, DWORD PTR $T347362[ebp]
  00394	8b 02		 mov	 eax, DWORD PTR [edx]
  00396	8b 8d 70 ff ff
	ff		 mov	 ecx, DWORD PTR $T347362[ebp]
  0039c	8b 10		 mov	 edx, DWORD PTR [eax]
  0039e	ff d2		 call	 edx
  003a0	89 85 64 ff ff
	ff		 mov	 DWORD PTR tv307[ebp], eax
  003a6	eb 0a		 jmp	 SHORT $LN33@StreamIn@5
$LN32@StreamIn@5:
  003a8	c7 85 64 ff ff
	ff 00 00 00 00	 mov	 DWORD PTR tv307[ebp], 0
$LN33@StreamIn@5:

; 1040 :                 node = 0;

  003b2	c7 85 74 ff ff
	ff 00 00 00 00	 mov	 DWORD PTR _node$21459[ebp], 0
$LN2@StreamIn@5:

; 1041 : 
; 1042 :                 // No return: go around from the beginning: text, closing tag, or node.
; 1043 :             }
; 1044 :         }

  003bc	e9 4e fd ff ff	 jmp	 $LN20@StreamIn@5
$LN30@StreamIn@5:

; 1045 :     }
; 1046 : }

  003c1	8b 4d f4	 mov	 ecx, DWORD PTR __$EHRec$[ebp]
  003c4	64 89 0d 00 00
	00 00		 mov	 DWORD PTR fs:0, ecx
  003cb	59		 pop	 ecx
  003cc	8b 4d e0	 mov	 ecx, DWORD PTR __$ArrayPad$[ebp]
  003cf	33 cd		 xor	 ecx, ebp
  003d1	e8 00 00 00 00	 call	 @__security_check_cookie@4
  003d6	8b e5		 mov	 esp, ebp
  003d8	5d		 pop	 ebp
  003d9	c2 08 00	 ret	 8
_TEXT	ENDS
;	COMDAT text$x
text$x	SEGMENT
__unwindfunclet$?StreamIn@TiXmlElement@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z$0:
  00000	8d 4d 94	 lea	 ecx, DWORD PTR _text$21425[ebp]
  00003	e9 00 00 00 00	 jmp	 ??1TiXmlText@@UAE@XZ	; TiXmlText::~TiXmlText
__ehhandler$?StreamIn@TiXmlElement@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z:
  00008	8b 54 24 08	 mov	 edx, DWORD PTR [esp+8]
  0000c	8d 42 0c	 lea	 eax, DWORD PTR [edx+12]
  0000f	8b 8a 6c ff ff
	ff		 mov	 ecx, DWORD PTR [edx-148]
  00015	33 c8		 xor	 ecx, eax
  00017	e8 00 00 00 00	 call	 @__security_check_cookie@4
  0001c	8b 4a ec	 mov	 ecx, DWORD PTR [edx-20]
  0001f	33 c8		 xor	 ecx, eax
  00021	e8 00 00 00 00	 call	 @__security_check_cookie@4
  00026	b8 00 00 00 00	 mov	 eax, OFFSET __ehfuncinfo$?StreamIn@TiXmlElement@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z
  0002b	e9 00 00 00 00	 jmp	 ___CxxFrameHandler3
text$x	ENDS
?StreamIn@TiXmlElement@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ENDP ; TiXmlElement::StreamIn
; Function compile flags: /Odtp
;	COMDAT ?StreamIn@TiXmlDocument@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z
_TEXT	SEGMENT
tv195 = -32						; size = 4
_this$ = -28						; size = 4
$T347377 = -24						; size = 4
$T347376 = -20						; size = 4
_isElement$21295 = -13					; size = 1
_node$21293 = -12					; size = 4
_c$21289 = -8						; size = 4
_tagIndex$21284 = -4					; size = 4
_in$ = 8						; size = 4
_tag$ = 12						; size = 4
?StreamIn@TiXmlDocument@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z PROC ; TiXmlDocument::StreamIn, COMDAT
; _this$ = ecx

; 642  : {

  00000	55		 push	 ebp
  00001	8b ec		 mov	 ebp, esp
  00003	83 ec 20	 sub	 esp, 32			; 00000020H
  00006	89 4d e4	 mov	 DWORD PTR _this$[ebp], ecx

; 643  :     // The basic issue with a document is that we don't know what we're
; 644  :     // streaming. Read something presumed to be a tag (and hope), then
; 645  :     // identify it, and call the appropriate stream method on the tag.
; 646  :     //
; 647  :     // This "pre-streaming" will never read the closing ">" so the
; 648  :     // sub-tag can orient itself.
; 649  : 
; 650  :     if ( !StreamTo( in, '<', tag ) )

  00009	8b 45 0c	 mov	 eax, DWORD PTR _tag$[ebp]
  0000c	50		 push	 eax
  0000d	6a 3c		 push	 60			; 0000003cH
  0000f	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  00012	51		 push	 ecx
  00013	e8 00 00 00 00	 call	 ?StreamTo@TiXmlBase@@KA_NPAV?$basic_istream@DU?$char_traits@D@std@@@std@@HPAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ; TiXmlBase::StreamTo
  00018	83 c4 0c	 add	 esp, 12			; 0000000cH
  0001b	0f b6 d0	 movzx	 edx, al
  0001e	85 d2		 test	 edx, edx
  00020	75 15		 jne	 SHORT $LN9@StreamIn@6

; 651  :     {
; 652  :         SetError( TIXML_ERROR_PARSING_EMPTY, 0, 0, TIXML_ENCODING_UNKNOWN );

  00022	6a 00		 push	 0
  00024	6a 00		 push	 0
  00026	6a 00		 push	 0
  00028	6a 08		 push	 8
  0002a	8b 4d e4	 mov	 ecx, DWORD PTR _this$[ebp]
  0002d	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError

; 653  :         return;

  00032	e9 49 01 00 00	 jmp	 $LN11@StreamIn@6
$LN9@StreamIn@6:

; 654  :     }
; 655  : 
; 656  :     while ( in->good() )

  00037	8b 45 08	 mov	 eax, DWORD PTR _in$[ebp]
  0003a	8b 08		 mov	 ecx, DWORD PTR [eax]
  0003c	8b 55 08	 mov	 edx, DWORD PTR _in$[ebp]
  0003f	03 51 04	 add	 edx, DWORD PTR [ecx+4]
  00042	8b ca		 mov	 ecx, edx
  00044	e8 00 00 00 00	 call	 ?good@ios_base@std@@QBE_NXZ ; std::ios_base::good
  00049	0f b6 c0	 movzx	 eax, al
  0004c	85 c0		 test	 eax, eax
  0004e	0f 84 1c 01 00
	00		 je	 $LN8@StreamIn@6

; 657  :     {
; 658  :         int tagIndex = (int) tag->length();

  00054	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  00057	e8 00 00 00 00	 call	 ?length@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEIXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::length
  0005c	89 45 fc	 mov	 DWORD PTR _tagIndex$21284[ebp], eax
$LN7@StreamIn@6:

; 659  :         while ( in->good() && in->peek() != '>' )

  0005f	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  00062	8b 11		 mov	 edx, DWORD PTR [ecx]
  00064	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  00067	03 4a 04	 add	 ecx, DWORD PTR [edx+4]
  0006a	e8 00 00 00 00	 call	 ?good@ios_base@std@@QBE_NXZ ; std::ios_base::good
  0006f	0f b6 c0	 movzx	 eax, al
  00072	85 c0		 test	 eax, eax
  00074	74 3f		 je	 SHORT $LN6@StreamIn@6
  00076	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  00079	e8 00 00 00 00	 call	 ?peek@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::peek
  0007e	83 f8 3e	 cmp	 eax, 62			; 0000003eH
  00081	74 32		 je	 SHORT $LN6@StreamIn@6

; 660  :         {
; 661  :             int c = in->get();

  00083	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  00086	e8 00 00 00 00	 call	 ?get@?$basic_istream@DU?$char_traits@D@std@@@std@@QAEHXZ ; std::basic_istream<char,std::char_traits<char> >::get
  0008b	89 45 f8	 mov	 DWORD PTR _c$21289[ebp], eax

; 662  :             if ( c <= 0 )

  0008e	83 7d f8 00	 cmp	 DWORD PTR _c$21289[ebp], 0
  00092	7f 12		 jg	 SHORT $LN5@StreamIn@6

; 663  :             {
; 664  :                 SetError( TIXML_ERROR_EMBEDDED_NULL, 0, 0, TIXML_ENCODING_UNKNOWN );

  00094	6a 00		 push	 0
  00096	6a 00		 push	 0
  00098	6a 00		 push	 0
  0009a	6a 0e		 push	 14			; 0000000eH
  0009c	8b 4d e4	 mov	 ecx, DWORD PTR _this$[ebp]
  0009f	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError

; 665  :                 break;

  000a4	eb 0f		 jmp	 SHORT $LN6@StreamIn@6
$LN5@StreamIn@6:

; 666  :             }
; 667  :             (*tag) += (char) c;

  000a6	0f b6 4d f8	 movzx	 ecx, BYTE PTR _c$21289[ebp]
  000aa	51		 push	 ecx
  000ab	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  000ae	e8 00 00 00 00	 call	 ??Y?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QAEAAV01@D@Z ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::operator+=

; 668  :         }

  000b3	eb aa		 jmp	 SHORT $LN7@StreamIn@6
$LN6@StreamIn@6:

; 669  : 
; 670  :         if ( in->good() )

  000b5	8b 55 08	 mov	 edx, DWORD PTR _in$[ebp]
  000b8	8b 02		 mov	 eax, DWORD PTR [edx]
  000ba	8b 4d 08	 mov	 ecx, DWORD PTR _in$[ebp]
  000bd	03 48 04	 add	 ecx, DWORD PTR [eax+4]
  000c0	e8 00 00 00 00	 call	 ?good@ios_base@std@@QBE_NXZ ; std::ios_base::good
  000c5	0f b6 c8	 movzx	 ecx, al
  000c8	85 c9		 test	 ecx, ecx
  000ca	0f 84 9b 00 00
	00		 je	 $LN4@StreamIn@6

; 671  :         {
; 672  :             // We now have something we presume to be a node of
; 673  :             // some sort. Identify it, and call the node to
; 674  :             // continue streaming.
; 675  :             TiXmlNode* node = Identify( tag->c_str() + tagIndex, TIXML_DEFAULT_ENCODING );

  000d0	6a 00		 push	 0
  000d2	8b 4d 0c	 mov	 ecx, DWORD PTR _tag$[ebp]
  000d5	e8 00 00 00 00	 call	 ?c_str@?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@QBEPBDXZ ; std::basic_string<char,std::char_traits<char>,std::allocator<char> >::c_str
  000da	03 45 fc	 add	 eax, DWORD PTR _tagIndex$21284[ebp]
  000dd	50		 push	 eax
  000de	8b 4d e4	 mov	 ecx, DWORD PTR _this$[ebp]
  000e1	e8 00 00 00 00	 call	 ?Identify@TiXmlNode@@IAEPAV1@PBDW4TiXmlEncoding@@@Z ; TiXmlNode::Identify
  000e6	89 45 f4	 mov	 DWORD PTR _node$21293[ebp], eax

; 676  : 
; 677  :             if ( node )

  000e9	83 7d f4 00	 cmp	 DWORD PTR _node$21293[ebp], 0
  000ed	74 6a		 je	 SHORT $LN3@StreamIn@6

; 678  :             {
; 679  :                 node->StreamIn( in, tag );

  000ef	8b 55 0c	 mov	 edx, DWORD PTR _tag$[ebp]
  000f2	52		 push	 edx
  000f3	8b 45 08	 mov	 eax, DWORD PTR _in$[ebp]
  000f6	50		 push	 eax
  000f7	8b 4d f4	 mov	 ecx, DWORD PTR _node$21293[ebp]
  000fa	8b 11		 mov	 edx, DWORD PTR [ecx]
  000fc	8b 4d f4	 mov	 ecx, DWORD PTR _node$21293[ebp]
  000ff	8b 42 44	 mov	 eax, DWORD PTR [edx+68]
  00102	ff d0		 call	 eax

; 680  :                 bool isElement = node->ToElement() != 0;

  00104	8b 4d f4	 mov	 ecx, DWORD PTR _node$21293[ebp]
  00107	8b 11		 mov	 edx, DWORD PTR [ecx]
  00109	8b 4d f4	 mov	 ecx, DWORD PTR _node$21293[ebp]
  0010c	8b 42 14	 mov	 eax, DWORD PTR [edx+20]
  0010f	ff d0		 call	 eax
  00111	f7 d8		 neg	 eax
  00113	1b c0		 sbb	 eax, eax
  00115	f7 d8		 neg	 eax
  00117	88 45 f3	 mov	 BYTE PTR _isElement$21295[ebp], al

; 681  :                 delete node;

  0011a	8b 4d f4	 mov	 ecx, DWORD PTR _node$21293[ebp]
  0011d	89 4d e8	 mov	 DWORD PTR $T347377[ebp], ecx
  00120	8b 55 e8	 mov	 edx, DWORD PTR $T347377[ebp]
  00123	89 55 ec	 mov	 DWORD PTR $T347376[ebp], edx
  00126	83 7d ec 00	 cmp	 DWORD PTR $T347376[ebp], 0
  0012a	74 13		 je	 SHORT $LN13@StreamIn@6
  0012c	6a 01		 push	 1
  0012e	8b 45 ec	 mov	 eax, DWORD PTR $T347376[ebp]
  00131	8b 10		 mov	 edx, DWORD PTR [eax]
  00133	8b 4d ec	 mov	 ecx, DWORD PTR $T347376[ebp]
  00136	8b 02		 mov	 eax, DWORD PTR [edx]
  00138	ff d0		 call	 eax
  0013a	89 45 e0	 mov	 DWORD PTR tv195[ebp], eax
  0013d	eb 07		 jmp	 SHORT $LN14@StreamIn@6
$LN13@StreamIn@6:
  0013f	c7 45 e0 00 00
	00 00		 mov	 DWORD PTR tv195[ebp], 0
$LN14@StreamIn@6:

; 682  :                 node = 0;

  00146	c7 45 f4 00 00
	00 00		 mov	 DWORD PTR _node$21293[ebp], 0

; 683  : 
; 684  :                 // If this is the root element, we're done. Parsing will be
; 685  :                 // done by the >> operator.
; 686  :                 if ( isElement )

  0014d	0f b6 4d f3	 movzx	 ecx, BYTE PTR _isElement$21295[ebp]
  00151	85 c9		 test	 ecx, ecx
  00153	74 02		 je	 SHORT $LN2@StreamIn@6

; 687  :                 {
; 688  :                     return;

  00155	eb 29		 jmp	 SHORT $LN11@StreamIn@6
$LN2@StreamIn@6:

; 689  :                 }
; 690  :             }
; 691  :             else

  00157	eb 12		 jmp	 SHORT $LN4@StreamIn@6
$LN3@StreamIn@6:

; 692  :             {
; 693  :                 SetError( TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN );

  00159	6a 00		 push	 0
  0015b	6a 00		 push	 0
  0015d	6a 00		 push	 0
  0015f	6a 01		 push	 1
  00161	8b 4d e4	 mov	 ecx, DWORD PTR _this$[ebp]
  00164	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError

; 694  :                 return;

  00169	eb 15		 jmp	 SHORT $LN11@StreamIn@6
$LN4@StreamIn@6:

; 695  :             }
; 696  :         }
; 697  :     }

  0016b	e9 c7 fe ff ff	 jmp	 $LN9@StreamIn@6
$LN8@StreamIn@6:

; 698  :     // We should have returned sooner.
; 699  :     SetError( TIXML_ERROR, 0, 0, TIXML_ENCODING_UNKNOWN );

  00170	6a 00		 push	 0
  00172	6a 00		 push	 0
  00174	6a 00		 push	 0
  00176	6a 01		 push	 1
  00178	8b 4d e4	 mov	 ecx, DWORD PTR _this$[ebp]
  0017b	e8 00 00 00 00	 call	 ?SetError@TiXmlDocument@@QAEXHPBDPAVTiXmlParsingData@@W4TiXmlEncoding@@@Z ; TiXmlDocument::SetError
$LN11@StreamIn@6:

; 700  : }

  00180	8b e5		 mov	 esp, ebp
  00182	5d		 pop	 ebp
  00183	c2 08 00	 ret	 8
?StreamIn@TiXmlDocument@@MAEXPAV?$basic_istream@DU?$char_traits@D@std@@@std@@PAV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@3@@Z ENDP ; TiXmlDocument::StreamIn
END
