	SECTION _TEXT CLASS=CODE USE32
	SECTION _DATA CLASS=DATA USE32
	SECTION _BSS  CLASS=BSS USE32
	SECTION _CONST  CLASS=CONST USE32
	SECTION _STRING  CLASS=STRING USE32
	SECTION cstartup CLASS=INITDATA USE32
	SECTION crundown CLASS=EXITDATA USE32
	SECTION cppinit  CLASS=CPPINIT USE32
	SECTION cppexit  CLASS=CPPEXIT USE32
	GROUP DGROUP _DATA _BSS _CONST _STRING

SECTION _TEXT
;
; Line 12:	{
;
_getnum:
	PUSH	EBP
	MOV	EBP,ESP
	SUB	ESP,BYTE 08H
	PUSH	EBX
	PUSH	ESI
	PUSH	EDI
	MOV	EDI,DWORD [EBP+08H]
	MOV	EBX,DWORD [EBP+010H]
;
; Line 13:		int i,sz=0;
;
	MOV	DWORD [EBP+0FFFFFFF8H],00H
	MOV	ESI,00H
	JMP	L_3
L_1:
;
; Line 16:			string[i] = '0';
;
	MOV	BYTE [EDI+ESI+00H],030H
;
; Line 15:		for (i=0; i < 32-1; i++)
;
L_2:
	INC	ESI
L_3:
	CMP	ESI,BYTE 01FH
	JL	SHORT	L_1
L_4:
;
; Line 17:		string[32-1] = 0;
;
	MOV	BYTE [EDI+01FH],00H
;
; Line 18:		if (num < 0 && !unsign)
;
	CMP	DWORD [EBP+0CH],BYTE 00H
	JGE	SHORT	L_5
	CMP	DWORD [EBP+018H],BYTE 00H
	JNE	SHORT	L_5
;
; Line 19:			unum = - num;
;
	MOV	EAX,DWORD [EBP+0CH]
	NEG	EAX
	MOV	DWORD [EBP+0FFFFFFFCH],EAX
	JMP	L_6
L_5:
;
; Line 21:			unum = num;
;
	MOV	EAX,DWORD [EBP+0CH]
	MOV	DWORD [EBP+0FFFFFFFCH],EAX
L_6:
;
; Line 22:		i = 32-2;
;
	MOV	ESI,01EH
	JMP	L_7
L_9:
;
; Line 24:			string[i] = (char)((unum % radix)+ '0');
;
	MOV	EAX,DWORD [EBP+0FFFFFFFCH]
	SUB	EDX,EDX
	DIV	EBX
	ADD	EDX,BYTE 030H
	MOV	BYTE [EDI+ESI+00H],DL
;
; Line 25:			if (string[i] > '9') {
;
	MOVSX	EAX,BYTE [EDI+ESI+00H]
	CMP	EAX,BYTE 039H
	JLE	SHORT	L_10
;
; Line 26:				string[i] += 7;
;
	ADD	BYTE [EDI+ESI+00H],BYTE 07H
;
; Line 27:				if (lc)
;
	CMP	DWORD [EBP+014H],BYTE 00H
	JE	SHORT	L_12
;
; Line 28:					string[i] += 32;
;
	ADD	BYTE [EDI+ESI+00H],BYTE 020H
L_12:
;
; Line 29:			}
;
L_10:
;
; Line 30:			i--;
;
	DEC	ESI
;
; Line 31:			unum /= radix;
;
	MOV	EAX,DWORD [EBP+0FFFFFFFCH]
	SUB	EDX,EDX
	DIV	EBX
	MOV	DWORD [EBP+0FFFFFFFCH],EAX
;
; Line 32:			sz++;
;
	INC	DWORD [EBP+0FFFFFFF8H]
;
; Line 33:		}
;
L_7:
;
; Line 23:		while (unum) {
;
	CMP	DWORD [EBP+0FFFFFFFCH],BYTE 00H
	JNE	NEAR	L_9
L_8:
;
; Line 34:		if (sz == 0)
;
	CMP	DWORD [EBP+0FFFFFFF8H],BYTE 00H
	JNE	SHORT	L_14
;
; Line 35:			sz++;
;
	INC	DWORD [EBP+0FFFFFFF8H]
L_14:
;
; Line 36:		return sz;
;
	MOV	EAX,DWORD [EBP+0FFFFFFF8H]
L_16:
	POP	EDI
	POP	ESI
	POP	EBX
	MOV	ESP,EBP
	POP	EBP
	RET
;
; Line 39:	{
;
_onetostr:
	PUSH	EBP
	MOV	EBP,ESP
	SUB	ESP,0C4H
	PUSH	EBX
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,DWORD [EBP+0CH]
;
; Line 43:		int looping = 1;
;
	MOV	DWORD [EBP+0FFFFFF50H],01H
;
; Line 44:		int issigned = 0, ljustify = 0, spaced = 0, prefixed = 0;
;
	MOV	DWORD [EBP+0FFFFFF54H],00H
	MOV	DWORD [EBP+0FFFFFF58H],00H
	MOV	DWORD [EBP+0FFFFFF5CH],00H
	MOV	DWORD [EBP+0FFFFFF60H],00H
;
; Line 45:		int	leadzero = 0;
;
	MOV	DWORD [EBP+0FFFFFF64H],00H
;
; Line 46:		int width = 0;
;
	MOV	EBX,00H
;
; Line 47:		int prec = -1;
;
	MOV	DWORD [EBP+0FFFFFF68H],0FFFFFFFFH
;
; Line 48:		int mode = 0;
;
	MOV	DWORD [EBP+0FFFFFF6CH],00H
;
; Line 50:		char echar = 'e';
;
	MOV	BYTE [EBP+0FFFFFF77H],065H
;
; Line 51:		int isf=1, isg=0;
;
	MOV	DWORD [EBP+0FFFFFF78H],01H
	MOV	DWORD [EBP+0FFFFFF7CH],00H
;
; Line 56:		char locbuf[32],*ofm = format;
;
	MOV	EAX,DWORD [EBP+010H]
	MOV	DWORD [EBP+0FFFFFFFCH],EAX
	JMP	L_22
L_24:
;
; Line 58:			switch (*format) {
;
	MOV	EAX,DWORD [EBP+010H]
	MOV	AL,BYTE [EAX+00H]
	CMP	AL,BYTE 02BH
	JE	NEAR	L_27
	JG	SHORT	L_33
	CMP	AL,BYTE 023H
	JE	NEAR	L_30
	JG	NEAR	L_25
	CMP	AL,BYTE 020H
	JE	NEAR	L_29
	JMP	L_25
L_33:
	CMP	AL,BYTE 030H
	JE	NEAR	L_31
	JG	NEAR	L_25
	CMP	AL,BYTE 02DH
	JE	SHORT	L_28
	JMP	L_25
L_27:
;
; Line 59:				case '+':	issigned = 1;
;
	MOV	DWORD [EBP+0FFFFFF54H],01H
;
; Line 60:						format++;
;
	INC	DWORD [EBP+010H]
;
; Line 61:						break;
;
	JMP	L_26
L_28:
;
; Line 62:				case '-':	ljustify = 1;
;
	MOV	DWORD [EBP+0FFFFFF58H],01H
;
; Line 63:						format++;
;
	INC	DWORD [EBP+010H]
;
; Line 64:						break;
;
	JMP	L_26
L_29:
;
; Line 65:				case ' ': spaced = 1;
;
	MOV	DWORD [EBP+0FFFFFF5CH],01H
;
; Line 66:						format++;
;
	INC	DWORD [EBP+010H]
;
; Line 67:						break;
;
	JMP	L_26
L_30:
;
; Line 68:				case '#': prefixed = 1;
;
	MOV	DWORD [EBP+0FFFFFF60H],01H
;
; Line 69:						format++;
;
	INC	DWORD [EBP+010H]
;
; Line 70:						break;
;
	JMP	L_26
L_31:
;
; Line 71:				case '0':	leadzero = 1;
;
	MOV	DWORD [EBP+0FFFFFF64H],01H
;
; Line 72:						format++;
;
	INC	DWORD [EBP+010H]
;
; Line 73:						break;
;
	JMP	L_26
L_25:
;
; Line 75:						looping = 0;
;
	MOV	DWORD [EBP+0FFFFFF50H],00H
L_26:
L_22:
;
; Line 57:		while (looping) 
;
	CMP	DWORD [EBP+0FFFFFF50H],BYTE 00H
	JNE	NEAR	L_24
L_23:
;
; Line 77:		if ((_ctype[ (*format) ] & (2            ))) {
;
	MOV	EAX,DWORD [EBP+010H]
	MOVSX	EAX,BYTE [EAX+00H]
	MOVZX	EAX,BYTE [EAX+__ctype+00H]
	AND	EAX,BYTE 02H
	JE	NEAR	L_34
;
; Line 78:			width = 0;
;
	MOV	EBX,00H
	JMP	L_36
L_38:
;
; Line 80:				width *= 10;
;
	IMUL	EBX,DWORD 0AH
;
; Line 81:				width += *format++ - '0';
;
	MOV	EAX,DWORD [EBP+010H]
	INC	DWORD [EBP+010H]
	MOVSX	EAX,BYTE [EAX+00H]
	SUB	EAX,BYTE 030H
	ADD	EBX,EAX
;
; Line 82:			}
;
L_36:
;
; Line 79:			while ((_ctype[ (*format) ] & (2            ))) {
;
	MOV	EAX,DWORD [EBP+010H]
	MOVSX	EAX,BYTE [EAX+00H]
	MOVZX	EAX,BYTE [EAX+__ctype+00H]
	AND	EAX,BYTE 02H
	JNE	NEAR	L_38
L_37:
;
; Line 83:		}
;
	JMP	L_35
L_34:
;
; Line 84:		else if (*format == '*') {
;
	MOV	EAX,DWORD [EBP+010H]
	MOVSX	EAX,BYTE [EAX+00H]
	CMP	EAX,BYTE 02AH
	JNE	SHORT	L_39
;
; Line 85:			width = *((int *)arg)++;
;
	MOV	EAX,DWORD [EBP+014H]
	ADD	DWORD [EBP+014H],BYTE 04H
	MOV	EBX,DWORD [EAX+00H]
;
; Line 86:			(*count)++;
;
	MOV	EAX,DWORD [EBP+018H]
	INC	DWORD [EAX+00H]
;
; Line 87:			format++;
;
	INC	DWORD [EBP+010H]
;
; Line 88:		}
;
L_39:
L_35:
;
; Line 89:		if (*format == '.') {
;
	MOV	EAX,DWORD [EBP+010H]
	MOVSX	EAX,BYTE [EAX+00H]
	CMP	EAX,BYTE 02EH
	JNE	NEAR	L_41
;
; Line 90:			format++;
;
	INC	DWORD [EBP+010H]
;
; Line 91:			prec = 0;
;
	MOV	DWORD [EBP+0FFFFFF68H],00H
	JMP	L_43
L_45:
;
; Line 93:				prec *= 10;
;
	MOV	EAX,0AH
	IMUL	EAX,DWORD [EBP+0FFFFFF68H]
	MOV	DWORD [EBP+0FFFFFF68H],EAX
;
; Line 94:				prec += *format++ - '0';
;
	MOV	EAX,DWORD [EBP+010H]
	INC	DWORD [EBP+010H]
	MOVSX	EAX,BYTE [EAX+00H]
	SUB	EAX,BYTE 030H
	ADD	DWORD [EBP+0FFFFFF68H],EAX
;
; Line 95:			}
;
L_43:
;
; Line 92:			while ((_ctype[ (*format) ] & (2            ))) {
;
	MOV	EAX,DWORD [EBP+010H]
	MOVSX	EAX,BYTE [EAX+00H]
	MOVZX	EAX,BYTE [EAX+__ctype+00H]
	AND	EAX,BYTE 02H
	JNE	NEAR	L_45
L_44:
;
; Line 96:		}
;
L_41:
;
; Line 97:		if (*format == 'h' || *format == 'l')
;
	MOV	EAX,DWORD [EBP+010H]
	MOVSX	EAX,BYTE [EAX+00H]
	CMP	EAX,BYTE 068H
	JE	SHORT	L_48
	MOV	EAX,DWORD [EBP+010H]
	MOVSX	EAX,BYTE [EAX+00H]
	CMP	EAX,BYTE 06CH
	JNE	SHORT	L_46
L_48:
;
; Line 98:			mode = *format++;
;
	MOV	EAX,DWORD [EBP+010H]
	INC	DWORD [EBP+010H]
	MOVSX	EAX,BYTE [EAX+00H]
	MOV	DWORD [EBP+0FFFFFF6CH],EAX
	JMP	L_47
L_46:
;
; Line 99:		else if (*format == 'F' || *format == 'N')  
;
	MOV	EAX,DWORD [EBP+010H]
	MOVSX	EAX,BYTE [EAX+00H]
	CMP	EAX,BYTE 046H
	JE	SHORT	L_51
	MOV	EAX,DWORD [EBP+010H]
	MOVSX	EAX,BYTE [EAX+00H]
	CMP	EAX,BYTE 04EH
	JNE	SHORT	L_49
L_51:
;
; Line 100:			format++;
;
	INC	DWORD [EBP+010H]
L_49:
L_47:
;
; Line 101:		switch (*format++) {
;
	MOV	EAX,DWORD [EBP+010H]
	INC	DWORD [EBP+010H]
	MOV	AL,BYTE [EAX+00H]
	CMP	AL,BYTE 067H
	JE	NEAR	L_59
	JG	NEAR	L_71
	CMP	AL,BYTE 063H
	JE	NEAR	L_55
	JG	NEAR	L_72
	CMP	AL,BYTE 047H
	JE	NEAR	L_58
	JG	SHORT	L_73
	CMP	AL,BYTE 045H
	JE	NEAR	L_60
	JG	NEAR	L_52
	CMP	AL,BYTE 025H
	JE	NEAR	L_54
	JMP	L_52
L_73:
	CMP	AL,BYTE 058H
	JE	NEAR	L_69
	JMP	L_52
L_72:
	CMP	AL,BYTE 065H
	JE	NEAR	L_61
	JG	SHORT	L_74
	CMP	AL,BYTE 064H
	JE	NEAR	L_56
	JMP	L_52
L_74:
	CMP	AL,BYTE 066H
	JE	NEAR	L_62
	JMP	L_52
L_71:
	CMP	AL,BYTE 070H
	JE	NEAR	L_68
	JG	NEAR	L_75
	CMP	AL,BYTE 06EH
	JE	NEAR	L_63
	JG	SHORT	L_76
	CMP	AL,BYTE 069H
	JE	NEAR	L_57
	JMP	L_52
L_76:
	CMP	AL,BYTE 06FH
	JE	NEAR	L_64
	JMP	L_52
L_75:
	CMP	AL,BYTE 075H
	JE	NEAR	L_66
	JG	SHORT	L_77
	CMP	AL,BYTE 073H
	JE	NEAR	L_65
	JMP	L_52
L_77:
	CMP	AL,BYTE 078H
	JE	NEAR	L_67
	JMP	L_52
L_54:
;
; Line 103:				*(*buffer)++ = '%';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],025H
;
; Line 104:				*(*buffer) = 0;
;
	MOV	EAX,DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],00H
;
; Line 105:				break;
;
	JMP	L_53
L_55:
;
; Line 107:				(*count)++;
;
	MOV	EAX,DWORD [EBP+018H]
	INC	DWORD [EAX+00H]
;
; Line 108:				c = *(int *)arg;
;
	MOV	EAX,DWORD [EBP+014H]
	MOV	EAX,DWORD [EAX+00H]
	MOV	DWORD [EBP+0FFFFFF40H],EAX
;
; Line 109:				*(*buffer)++ = (char)c;
;
	MOV	EAX,DWORD [EBP+0FFFFFF40H]
	MOV	ECX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [ECX+00H],AL
;
; Line 110:				*(*buffer) = 0;
;
	MOV	EAX,DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],00H
;
; Line 111:				break;
;
	JMP	L_53
L_56:
L_57:
;
; Line 114:				(*count)++;
;
	MOV	EAX,DWORD [EBP+018H]
	INC	DWORD [EAX+00H]
;
; Line 115:				c = *(int *)arg;
;
	MOV	EAX,DWORD [EBP+014H]
	MOV	EAX,DWORD [EAX+00H]
	MOV	DWORD [EBP+0FFFFFF40H],EAX
;
; Line 116:				if (mode == 'h') {
;
	CMP	DWORD [EBP+0FFFFFF6CH],BYTE 068H
	JNE	SHORT	L_78
;
; Line 117:					c &= 0xffff;
;
	AND	DWORD [EBP+0FFFFFF40H],0FFFFH
;
; Line 118:					if (c & 0x8000)
;
	MOV	EAX,DWORD [EBP+0FFFFFF40H]
	AND	EAX,08000H
	JE	SHORT	L_80
;
; Line 119:						c |= 0xffff0000;
;
	OR	DWORD [EBP+0FFFFFF40H],0FFFF0000H
L_80:
;
; Line 120:				}
;
L_78:
;
; Line 121:				sz = getnum(locbuf,c,10,0,0);
;
	PUSH	BYTE 00H
	PUSH	BYTE 00H
	PUSH	BYTE 0AH
	PUSH	DWORD [EBP+0FFFFFF40H]
	LEA	EAX,[EBP+0FFFFFFDCH]
	PUSH	EAX
	CALL	_getnum
	ADD	ESP,BYTE 014H
	MOV	DWORD [EBP+0FFFFFF44H],EAX
;
; Line 122:				if (issigned) {
;
	CMP	DWORD [EBP+0FFFFFF54H],BYTE 00H
	JE	NEAR	L_82
;
; Line 123:					if (c < 0) 
;
	CMP	DWORD [EBP+0FFFFFF40H],BYTE 00H
	JGE	SHORT	L_84
;
; Line 124:						*(*buffer)++ = '-';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],02DH
	JMP	L_85
L_84:
;
; Line 126:						*(*buffer)++ = '+';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],02BH
L_85:
;
; Line 127:					if (width)
;
	TEST	EBX,EBX
	JE	SHORT	L_86
;
; Line 128:						width--;
;
	DEC	EBX
L_86:
;
; Line 129:				}
;
	JMP	L_83
L_82:
;
; Line 130:				else if (spaced) {
;
	CMP	DWORD [EBP+0FFFFFF5CH],BYTE 00H
	JE	NEAR	L_88
;
; Line 131:					if (c < 0) 
;
	CMP	DWORD [EBP+0FFFFFF40H],BYTE 00H
	JGE	SHORT	L_90
;
; Line 132:						*(*buffer)++ = '-';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],02DH
	JMP	L_91
L_90:
;
; Line 134:						*(*buffer)++ = ' ';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],020H
L_91:
;
; Line 135:					if (width)
;
	TEST	EBX,EBX
	JE	SHORT	L_92
;
; Line 136:						width--;
;
	DEC	EBX
L_92:
;
; Line 137:				}
;
	JMP	L_89
L_88:
;
; Line 139:					if (c < 0) {
;
	CMP	DWORD [EBP+0FFFFFF40H],BYTE 00H
	JGE	SHORT	L_94
;
; Line 140:						*(*buffer)++ = '-';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],02DH
;
; Line 141:						if (width)
;
	TEST	EBX,EBX
	JE	SHORT	L_96
;
; Line 142:							width--;
;
	DEC	EBX
L_96:
;
; Line 143:					}
;
L_94:
;
; Line 144:				}
;
L_89:
L_83:
;
; Line 145:				goto numfin;
;
	JMP	L_17
L_58:
;
; Line 148:				echar='E';
;
	MOV	BYTE [EBP+0FFFFFF77H],045H
;
; Line 149:				isf = 0;
;
	MOV	DWORD [EBP+0FFFFFF78H],00H
L_59:
;
; Line 151:				isg = 1;
;
	MOV	DWORD [EBP+0FFFFFF7CH],01H
;
; Line 152:				goto dofloat;
;
	JMP	L_18
L_60:
;
; Line 154:				echar='E';
;
	MOV	BYTE [EBP+0FFFFFF77H],045H
L_61:
;
; Line 156:				isf = 0;
;
	MOV	DWORD [EBP+0FFFFFF78H],00H
;
; Line 157:				goto dofloat;
;
L_62:
L_18:
;
; Line 161:				if (mode == 'l') {
;
	CMP	DWORD [EBP+0FFFFFF6CH],BYTE 06CH
	JNE	SHORT	L_98
;
; Line 162:					(*count)+=3;
;
	MOV	EAX,DWORD [EBP+018H]
	ADD	DWORD [EAX+00H],BYTE 03H
;
; Line 163:					fmant = *(long double *)arg;
;
	MOV	EAX,DWORD [EBP+014H]
	FLD	TWORD [EAX+00H]
	FSTP	TWORD [EBP+0FFFFFF80H]
;
; Line 164:				}
;
	JMP	L_99
L_98:
;
; Line 166:					(*count)+=2;
;
	MOV	EAX,DWORD [EBP+018H]
	ADD	DWORD [EAX+00H],BYTE 02H
;
; Line 167:					fmant = *(double *)arg;
;
	MOV	EAX,DWORD [EBP+014H]
	FLD	QWORD [EAX+00H]
	FSTP	TWORD [EBP+0FFFFFF80H]
;
; Line 168:				}
;
L_99:
;
; Line 173:				if (fxs = _fextract(&fmant,&fexp,&fsign) < 0) {
;
	LEA	EAX,[EBP+0FFFFFF8CH]
	PUSH	EAX
	LEA	EAX,[EBP+0FFFFFF90H]
	PUSH	EAX
	LEA	EAX,[EBP+0FFFFFF80H]
	PUSH	EAX
	CALL	__fextract
	ADD	ESP,BYTE 0CH
	TEST	EAX,EAX
	SETL	AL
	MOVZX	EAX,AL
	MOV	DWORD [EBP+0FFFFFF48H],EAX
	TEST	EAX,EAX
	JE	NEAR	L_100
;
; Line 174:					strcpy(fbuf,"(NaN)");
;
	MOV	EAX,DWORD L_19
	LEA	ECX,[EBP+0FFFFFF94H]
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,EAX
	MOV	EDI,ECX
	XCHG	ESI,EDI
	CLD
	PUSH	EDI
	SUB	EAX,EAX
	MOV	ECX,0FFFFFFFFH
	REPNZ	SCASB
	NOT	ECX
	MOV	EAX,ECX
	POP	EDI
	XCHG	ESI,EDI
	REPNZ	MOVSB
	POP	EDI
	POP	ESI
	LEA	ECX,[EBP+0FFFFFF94H]
;
; Line 175:				}
;
	JMP	L_101
L_100:
;
; Line 177:					fbp = fbuf;
;
	LEA	EAX,[EBP+0FFFFFF94H]
	MOV	DWORD [EBP+0FFFFFFD4H],EAX
;
; Line 179:					if (issigned || fsign < 0)
;
	CMP	DWORD [EBP+0FFFFFF54H],BYTE 00H
	JNE	SHORT	L_104
	CMP	DWORD [EBP+0FFFFFF8CH],BYTE 00H
	JGE	NEAR	L_102
L_104:
;
; Line 180:						if (fsign < 0)
;
	CMP	DWORD [EBP+0FFFFFF8CH],BYTE 00H
	JGE	SHORT	L_105
;
; Line 181:							*fbp++='-';
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [EAX+00H],02DH
	JMP	L_106
L_105:
;
; Line 183:							*fbp++='+';
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [EAX+00H],02BH
L_106:
L_102:
;
; Line 186:					if (fxs) {
;
	CMP	DWORD [EBP+0FFFFFF48H],BYTE 00H
	JE	NEAR	L_107
;
; Line 187:						strcpy(fbp,"(Inf)");
;
	MOV	EAX,DWORD L_20
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,EAX
	MOV	EDI,DWORD [EBP+0FFFFFFD4H]
	XCHG	ESI,EDI
	CLD
	PUSH	EDI
	SUB	EAX,EAX
	MOV	ECX,0FFFFFFFFH
	REPNZ	SCASB
	NOT	ECX
	MOV	EAX,ECX
	POP	EDI
	XCHG	ESI,EDI
	REPNZ	MOVSB
	POP	EDI
	POP	ESI
;
; Line 188:					}
;
	JMP	L_108
L_107:
;
; Line 191:						if (fexp < 0) {
;
	CMP	DWORD [EBP+0FFFFFF90H],BYTE 00H
	JGE	SHORT	L_109
;
; Line 192:							_fnd(&fmant);
;
	LEA	EAX,[EBP+0FFFFFF80H]
	PUSH	EAX
	CALL	__fnd
	POP	ECX
;
; Line 193:							fexp--;
;
	DEC	DWORD [EBP+0FFFFFF90H]
;
; Line 194:						}
;
L_109:
;
; Line 196:						if (prec == -1)
;
	CMP	DWORD [EBP+0FFFFFF68H],BYTE 0FFFFFFFFH
	JNE	SHORT	L_111
;
; Line 197:							prec = 6;
;
	MOV	DWORD [EBP+0FFFFFF68H],06H
L_111:
;
; Line 201:						if (fexp > 0)
;
	CMP	DWORD [EBP+0FFFFFF90H],BYTE 00H
	JLE	NEAR	L_113
;
; Line 202:							if ((width && (prec +1+fexp > width)) || fexp > 10)
;
	TEST	EBX,EBX
	JE	SHORT	L_118
	MOV	EAX,DWORD [EBP+0FFFFFF68H]
	ADD	EAX,DWORD [EBP+0FFFFFF90H]
	INC	EAX
	CMP	EAX,EBX
	JG	SHORT	L_117
L_118:
	CMP	DWORD [EBP+0FFFFFF90H],BYTE 0AH
	JLE	SHORT	L_115
L_117:
;
; Line 203:								isf = 0;
;
	MOV	DWORD [EBP+0FFFFFF78H],00H
	JMP	L_116
L_115:
;
; Line 205:							if (-fexp > prec)
;
	MOV	EAX,DWORD [EBP+0FFFFFF90H]
	NEG	EAX
	CMP	EAX,DWORD [EBP+0FFFFFF68H]
	JLE	SHORT	L_119
;
; Line 206:								isf = 0;
;
	MOV	DWORD [EBP+0FFFFFF78H],00H
L_119:
L_116:
L_113:
;
; Line 209:						if (isg) prec = 18;
;
	CMP	DWORD [EBP+0FFFFFF7CH],BYTE 00H
	JE	SHORT	L_121
	MOV	DWORD [EBP+0FFFFFF68H],012H
L_121:
;
; Line 211:						xxx = fbp;		 
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	MOV	DWORD [EBP+0FFFFFFD8H],EAX
;
; Line 212:						*fbp++ = '0';						 
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [EAX+00H],030H
;
; Line 215:						if (isf) {
;
	CMP	DWORD [EBP+0FFFFFF78H],BYTE 00H
	JE	NEAR	L_123
;
; Line 216:							if (fexp < 0) {
;
	CMP	DWORD [EBP+0FFFFFF90H],BYTE 00H
	JGE	NEAR	L_125
;
; Line 217:								*fbp++ = '0';
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [EAX+00H],030H
;
; Line 218:								*fbp++ = '.';
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [EAX+00H],02EH
;
; Line 219:								if (fexp < -prec)
;
	MOV	EAX,DWORD [EBP+0FFFFFF68H]
	NEG	EAX
	CMP	DWORD [EBP+0FFFFFF90H],EAX
	JGE	SHORT	L_127
;
; Line 220:									fexp = -prec-1;
;
	MOV	EAX,DWORD [EBP+0FFFFFF68H]
	NEG	EAX
	DEC	EAX
	MOV	DWORD [EBP+0FFFFFF90H],EAX
L_127:
	MOV	EAX,DWORD [EBP+0FFFFFF90H]
	MOV	DWORD [EBP+0FFFFFF70H],EAX
	JMP	L_131
L_129:
;
; Line 222:									*fbp++ = '0';
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [EAX+00H],030H
;
; Line 221:								for (i=fexp; i < -1; i++)
;
L_130:
	INC	DWORD [EBP+0FFFFFF70H]
L_131:
	CMP	DWORD [EBP+0FFFFFF70H],BYTE 0FFFFFFFFH
	JL	SHORT	L_129
L_132:
	MOV	EAX,DWORD [EBP+0FFFFFF90H]
	NEG	EAX
	DEC	EAX
	MOV	DWORD [EBP+0FFFFFF70H],EAX
	JMP	L_135
L_133:
;
; Line 224:									*fbp++ = _fnd(&fmant) + '0';
;
	LEA	EAX,[EBP+0FFFFFF80H]
	PUSH	EAX
	CALL	__fnd
	POP	ECX
	ADD	EAX,BYTE 030H
	MOV	ECX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [ECX+00H],AL
;
; Line 223:								for (i=-fexp-1; i < prec; i++)
;
L_134:
	INC	DWORD [EBP+0FFFFFF70H]
L_135:
	MOV	EAX,DWORD [EBP+0FFFFFF70H]
	CMP	EAX,DWORD [EBP+0FFFFFF68H]
	JL	NEAR	L_133
L_136:
;
; Line 225:							}
;
	JMP	L_126
L_125:
;
; Line 227:								*fbp++ = _fnd(&fmant) + '0';
;
	LEA	EAX,[EBP+0FFFFFF80H]
	PUSH	EAX
	CALL	__fnd
	POP	ECX
	ADD	EAX,BYTE 030H
	MOV	ECX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [ECX+00H],AL
	JMP	L_137
L_139:
;
; Line 229:									*fbp++ = _fnd(&fmant) + '0';
;
	LEA	EAX,[EBP+0FFFFFF80H]
	PUSH	EAX
	CALL	__fnd
	POP	ECX
	ADD	EAX,BYTE 030H
	MOV	ECX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [ECX+00H],AL
;
; Line 230:									fexp--;
;
	DEC	DWORD [EBP+0FFFFFF90H]
;
; Line 231:								}
;
L_137:
;
; Line 228:								while (fexp > 0) {
;
	CMP	DWORD [EBP+0FFFFFF90H],BYTE 00H
	JG	NEAR	L_139
L_138:
;
; Line 232:								*fbp++ = '.';
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [EAX+00H],02EH
	MOV	DWORD [EBP+0FFFFFF70H],00H
	JMP	L_142
L_140:
;
; Line 234:									*fbp++ = _fnd(&fmant) + '0';
;
	LEA	EAX,[EBP+0FFFFFF80H]
	PUSH	EAX
	CALL	__fnd
	POP	ECX
	ADD	EAX,BYTE 030H
	MOV	ECX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [ECX+00H],AL
;
; Line 233:								for (i=0; i < prec; i++)
;
L_141:
	INC	DWORD [EBP+0FFFFFF70H]
L_142:
	MOV	EAX,DWORD [EBP+0FFFFFF70H]
	CMP	EAX,DWORD [EBP+0FFFFFF68H]
	JL	NEAR	L_140
L_143:
;
; Line 235:							}
;
L_126:
;
; Line 236:						}
;
	JMP	L_124
L_123:
;
; Line 238:							*fbp++ = _fnd(&fmant) + '0';
;
	LEA	EAX,[EBP+0FFFFFF80H]
	PUSH	EAX
	CALL	__fnd
	POP	ECX
	ADD	EAX,BYTE 030H
	MOV	ECX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [ECX+00H],AL
;
; Line 239:							*fbp++ = '.';
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [EAX+00H],02EH
	MOV	DWORD [EBP+0FFFFFF70H],00H
	JMP	L_146
L_144:
;
; Line 241:								*fbp++ = _fnd(&fmant) + '0';
;
	LEA	EAX,[EBP+0FFFFFF80H]
	PUSH	EAX
	CALL	__fnd
	POP	ECX
	ADD	EAX,BYTE 030H
	MOV	ECX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [ECX+00H],AL
;
; Line 240:							for (i=0; i < prec; i++)
;
L_145:
	INC	DWORD [EBP+0FFFFFF70H]
L_146:
	MOV	EAX,DWORD [EBP+0FFFFFF70H]
	CMP	EAX,DWORD [EBP+0FFFFFF68H]
	JL	NEAR	L_144
L_147:
;
; Line 242:						}
;
L_124:
;
; Line 245:						i = _fnd(&fmant);
;
	LEA	EAX,[EBP+0FFFFFF80H]
	PUSH	EAX
	CALL	__fnd
	POP	ECX
	MOV	DWORD [EBP+0FFFFFF70H],EAX
;
; Line 246:						if (i >4) {
;
	CMP	DWORD [EBP+0FFFFFF70H],BYTE 04H
	JLE	NEAR	L_148
;
; Line 247:							char *fbp2=fbp-1;
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	DEC	EAX
	MOV	DWORD [EBP+0FFFFFF3CH],EAX
	JMP	L_150
L_152:
;
; Line 249:								if (*fbp2 < '0') {
;
	MOV	EAX,DWORD [EBP+0FFFFFF3CH]
	MOVSX	EAX,BYTE [EAX+00H]
	CMP	EAX,BYTE 030H
	JGE	SHORT	L_153
;
; Line 250:									fbp2--;
;
	DEC	DWORD [EBP+0FFFFFF3CH]
;
; Line 251:									continue;
;
	JMP	L_150
L_153:
;
; Line 253:								(*fbp2)++;
;
	MOV	EAX,DWORD [EBP+0FFFFFF3CH]
	INC	BYTE [EAX+00H]
;
; Line 254:								if (*fbp2 != 0x3a)
;
	MOV	EAX,DWORD [EBP+0FFFFFF3CH]
	MOVSX	EAX,BYTE [EAX+00H]
	CMP	EAX,BYTE 03AH
	JNE	SHORT	L_151
;
; Line 255:									break;
;
L_155:
;
; Line 256:								(*fbp2--)='0';
;
	MOV	EAX,DWORD [EBP+0FFFFFF3CH]
	DEC	DWORD [EBP+0FFFFFF3CH]
	MOV	BYTE [EAX+00H],030H
;
; Line 257:							}
;
L_150:
;
; Line 248:							while (fbp2 >= fbuf) {
;
	LEA	EAX,[EBP+0FFFFFF94H]
	CMP	DWORD [EBP+0FFFFFF3CH],EAX
	JNC	NEAR	L_152
L_151:
;
; Line 258:						}
;
L_148:
	JMP	L_157
L_159:
;
; Line 262:							fbp--;
;
	DEC	DWORD [EBP+0FFFFFFD4H]
L_157:
;
; Line 261:						while (isg && *(fbp-1) == '0')
;
	CMP	DWORD [EBP+0FFFFFF7CH],BYTE 00H
	JE	SHORT	L_160
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	DEC	EAX
	MOVSX	EAX,BYTE [EAX+00H]
	CMP	EAX,BYTE 030H
	JE	SHORT	L_159
L_160:
L_158:
;
; Line 265:						*fbp = 0;
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [EAX+00H],00H
;
; Line 266:						if (*xxx == '0') {
;
	MOV	EAX,DWORD [EBP+0FFFFFFD8H]
	MOVSX	EAX,BYTE [EAX+00H]
	CMP	EAX,BYTE 030H
	JNE	NEAR	L_161
;
; Line 267:							strcpy(xxx,xxx+1);	 
;
	MOV	EAX,DWORD [EBP+0FFFFFFD8H]
	INC	EAX
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,EAX
	MOV	EDI,DWORD [EBP+0FFFFFFD8H]
	XCHG	ESI,EDI
	CLD
	PUSH	EDI
	SUB	EAX,EAX
	MOV	ECX,0FFFFFFFFH
	REPNZ	SCASB
	NOT	ECX
	MOV	EAX,ECX
	POP	EDI
	XCHG	ESI,EDI
	REPNZ	MOVSB
	POP	EDI
	POP	ESI
;
; Line 268:							fbp--;
;
	DEC	DWORD [EBP+0FFFFFFD4H]
;
; Line 269:						}
;
	JMP	L_162
L_161:
;
; Line 271:							if (!isf) {
;
	CMP	DWORD [EBP+0FFFFFF78H],BYTE 00H
	JNE	SHORT	L_163
;
; Line 272:								*(xxx+1) = '.';	 
;
	MOV	EAX,DWORD [EBP+0FFFFFFD8H]
	MOV	BYTE [EAX+01H],02EH
;
; Line 273:								*(xxx+2) = '0';
;
	MOV	EAX,DWORD [EBP+0FFFFFFD8H]
	MOV	BYTE [EAX+02H],030H
;
; Line 274:								if (!isg)
;
	CMP	DWORD [EBP+0FFFFFF7CH],BYTE 00H
	JNE	SHORT	L_165
;
; Line 275:									fbp--;	 
;
	DEC	DWORD [EBP+0FFFFFFD4H]
L_165:
;
; Line 276:								fexp++;	 
;
	INC	DWORD [EBP+0FFFFFF90H]
;
; Line 277:							}
;
L_163:
;
; Line 279:						}
;
L_162:
;
; Line 281:						if ((isg || prefixed || prec == 0) && *(fbp-1) == '.')
;
	CMP	DWORD [EBP+0FFFFFF7CH],BYTE 00H
	JNE	SHORT	L_169
	CMP	DWORD [EBP+0FFFFFF60H],BYTE 00H
	JNE	SHORT	L_169
	CMP	DWORD [EBP+0FFFFFF68H],BYTE 00H
	JNE	SHORT	L_167
L_169:
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	DEC	EAX
	MOVSX	EAX,BYTE [EAX+00H]
	CMP	EAX,BYTE 02EH
	JNE	SHORT	L_167
;
; Line 282:							fbp--;
;
	DEC	DWORD [EBP+0FFFFFFD4H]
L_167:
;
; Line 283:						if (!isf) {
;
	CMP	DWORD [EBP+0FFFFFF78H],BYTE 00H
	JNE	NEAR	L_170
;
; Line 284:							if (*(fbp-1) == '1' && fbp == fbuf+1)
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	DEC	EAX
	MOVSX	EAX,BYTE [EAX+00H]
	CMP	EAX,BYTE 031H
	JNE	SHORT	L_172
	LEA	EAX,[EBP+0FFFFFF94H]
	INC	EAX
	CMP	DWORD [EBP+0FFFFFFD4H],EAX
	JNE	SHORT	L_172
;
; Line 285:								fbp--;
;
	DEC	DWORD [EBP+0FFFFFFD4H]
L_172:
;
; Line 286:							*fbp++ = echar;
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	CL,BYTE [EBP+0FFFFFF77H]
	MOV	BYTE [EAX+00H],CL
;
; Line 287:							if (fexp < 0) {
;
	CMP	DWORD [EBP+0FFFFFF90H],BYTE 00H
	JGE	SHORT	L_174
;
; Line 288:								fexp=-fexp;
;
	NEG	DWORD [EBP+0FFFFFF90H]
;
; Line 289:								*fbp++='-';
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [EAX+00H],02DH
;
; Line 290:							}
;
	JMP	L_175
L_174:
;
; Line 292:								*fbp++='+';
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [EAX+00H],02BH
L_175:
;
; Line 293:							if (fexp > 99)
;
	CMP	DWORD [EBP+0FFFFFF90H],BYTE 063H
	JLE	SHORT	L_176
;
; Line 294:								*fbp++= fexp/100 + '0';
;
	MOV	EAX,DWORD [EBP+0FFFFFF90H]
	CDQ
	IDIV	DWORD [L_178]
	ADD	EAX,BYTE 030H
	MOV	ECX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [ECX+00H],AL
L_176:
;
; Line 295:							if (fexp > 9)
;
	CMP	DWORD [EBP+0FFFFFF90H],BYTE 09H
	JLE	NEAR	L_179
;
; Line 296:								*fbp++ = fexp/10 % 10 + '0';
;
	MOV	EAX,DWORD [EBP+0FFFFFF90H]
	CDQ
	IDIV	DWORD [L_181]
	CDQ
	IDIV	DWORD [L_181]
	ADD	EDX,BYTE 030H
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [EAX+00H],DL
	JMP	L_180
L_179:
;
; Line 298:								*fbp++ = '0';
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [EAX+00H],030H
L_180:
;
; Line 299:							*fbp++ = fexp %10 + '0';
;
	MOV	EAX,DWORD [EBP+0FFFFFF90H]
	CDQ
	IDIV	DWORD [L_181]
	ADD	EDX,BYTE 030H
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [EAX+00H],DL
;
; Line 300:						}
;
L_170:
;
; Line 301:						*fbp++ = 0;
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [EAX+00H],00H
;
; Line 302:					}
;
L_108:
;
; Line 303:				}
;
L_101:
;
; Line 304:				i = strlen(fbuf);
;
	LEA	EAX,[EBP+0FFFFFF94H]
	PUSH	EDI
	MOV	EDI,EAX
	CLD
	SUB	EAX,EAX
	MOV	ECX,0FFFFFFFFH
	REPNZ	SCASB
	NOT	ECX
	DEC	ECX
	MOV	EAX,ECX
	POP	EDI
	MOV	DWORD [EBP+0FFFFFF70H],EAX
;
; Line 305:				if (ljustify) {
;
	CMP	DWORD [EBP+0FFFFFF58H],BYTE 00H
	JE	NEAR	L_182
;
; Line 306:					strcpy(*buffer,fbuf);
;
	LEA	EAX,[EBP+0FFFFFF94H]
	MOV	ECX,DWORD [ESI+00H]
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,EAX
	MOV	EDI,ECX
	XCHG	ESI,EDI
	CLD
	PUSH	EDI
	SUB	EAX,EAX
	MOV	ECX,0FFFFFFFFH
	REPNZ	SCASB
	NOT	ECX
	MOV	EAX,ECX
	POP	EDI
	XCHG	ESI,EDI
	REPNZ	MOVSB
	POP	EDI
	POP	ESI
	JMP	L_186
L_184:
;
; Line 308:						(*buffer)[i] = ' ';
;
	MOV	EAX,DWORD [ESI+00H]
	MOV	ECX,DWORD [EBP+0FFFFFF70H]
	MOV	BYTE [EAX+ECX+00H],020H
;
; Line 307:					for (; i < width; i++)
;
L_185:
	INC	DWORD [EBP+0FFFFFF70H]
L_186:
	CMP	DWORD [EBP+0FFFFFF70H],EBX
	JL	SHORT	L_184
L_187:
;
; Line 309:					(*buffer)[i]=0;
;
	MOV	EAX,DWORD [ESI+00H]
	MOV	ECX,DWORD [EBP+0FFFFFF70H]
	MOV	BYTE [EAX+ECX+00H],00H
;
; Line 310:				}
;
	JMP	L_183
L_182:
;
; Line 312:					fbp = *buffer;
;
	MOV	EAX,DWORD [ESI+00H]
	MOV	DWORD [EBP+0FFFFFFD4H],EAX
	JMP	L_190
L_188:
;
; Line 314:						*fbp++= ' ';
;
	MOV	EAX,DWORD [EBP+0FFFFFFD4H]
	INC	DWORD [EBP+0FFFFFFD4H]
	MOV	BYTE [EAX+00H],020H
;
; Line 313:					for (;i< width; i++)
;
L_189:
	INC	DWORD [EBP+0FFFFFF70H]
L_190:
	CMP	DWORD [EBP+0FFFFFF70H],EBX
	JL	SHORT	L_188
L_191:
;
; Line 315:					strcpy(fbp,fbuf);
;
	LEA	EAX,[EBP+0FFFFFF94H]
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,EAX
	MOV	EDI,DWORD [EBP+0FFFFFFD4H]
	XCHG	ESI,EDI
	CLD
	PUSH	EDI
	SUB	EAX,EAX
	MOV	ECX,0FFFFFFFFH
	REPNZ	SCASB
	NOT	ECX
	MOV	EAX,ECX
	POP	EDI
	XCHG	ESI,EDI
	REPNZ	MOVSB
	POP	EDI
	POP	ESI
;
; Line 316:				}
;
L_183:
;
; Line 317:				*buffer+=strlen(*buffer);	
;
	PUSH	EDI
	MOV	EDI,DWORD [ESI+00H]
	CLD
	SUB	EAX,EAX
	MOV	ECX,0FFFFFFFFH
	REPNZ	SCASB
	NOT	ECX
	DEC	ECX
	MOV	EAX,ECX
	POP	EDI
	ADD	DWORD [ESI+00H],EAX
;
; Line 319:				break;
;
	JMP	L_53
L_63:
;
; Line 321:				(*count)++;
;
	MOV	EAX,DWORD [EBP+018H]
	INC	DWORD [EAX+00H]
;
; Line 322:				p = *(int **)arg;
;
	MOV	EAX,DWORD [EBP+014H]
	MOV	EAX,DWORD [EAX+00H]
	MOV	DWORD [EBP+0FFFFFF4CH],EAX
;
; Line 323:				*p = (int)((*buffer) - obuf);
;
	MOV	EAX,DWORD [ESI+00H]
	SUB	EAX,DWORD [EBP+08H]
	MOV	ECX,DWORD [EBP+0FFFFFF4CH]
	MOV	DWORD [ECX+00H],EAX
;
; Line 324:				break;
;
	JMP	L_53
L_64:
;
; Line 326:				(*count)++;
;
	MOV	EAX,DWORD [EBP+018H]
	INC	DWORD [EAX+00H]
;
; Line 327:				c = *(int *)arg;
;
	MOV	EAX,DWORD [EBP+014H]
	MOV	EAX,DWORD [EAX+00H]
	MOV	DWORD [EBP+0FFFFFF40H],EAX
;
; Line 328:				if (mode == 'h') {
;
	CMP	DWORD [EBP+0FFFFFF6CH],BYTE 068H
	JNE	SHORT	L_192
;
; Line 329:					c &= 0xffff;
;
	AND	DWORD [EBP+0FFFFFF40H],0FFFFH
;
; Line 330:					if (c & 0x8000)
;
	MOV	EAX,DWORD [EBP+0FFFFFF40H]
	AND	EAX,08000H
	JE	SHORT	L_194
;
; Line 331:						c |= 0xffff0000;
;
	OR	DWORD [EBP+0FFFFFF40H],0FFFF0000H
L_194:
;
; Line 332:				}
;
L_192:
;
; Line 333:				sz = getnum(locbuf,c,8,0,1);
;
	PUSH	BYTE 01H
	PUSH	BYTE 00H
	PUSH	BYTE 08H
	PUSH	DWORD [EBP+0FFFFFF40H]
	LEA	EAX,[EBP+0FFFFFFDCH]
	PUSH	EAX
	CALL	_getnum
	ADD	ESP,BYTE 014H
	MOV	DWORD [EBP+0FFFFFF44H],EAX
;
; Line 334:				if (prefixed && c)
;
	CMP	DWORD [EBP+0FFFFFF60H],BYTE 00H
	JE	SHORT	L_196
	CMP	DWORD [EBP+0FFFFFF40H],BYTE 00H
	JE	SHORT	L_196
;
; Line 335:					sz--;
;
	DEC	DWORD [EBP+0FFFFFF44H]
L_196:
;
; Line 336:				if (issigned) {
;
	CMP	DWORD [EBP+0FFFFFF54H],BYTE 00H
	JE	SHORT	L_198
;
; Line 337:					*(*buffer)++ = '+';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],02BH
;
; Line 338:					if (width)
;
	TEST	EBX,EBX
	JE	SHORT	L_200
;
; Line 339:						width--;
;
	DEC	EBX
L_200:
;
; Line 340:				}
;
	JMP	L_199
L_198:
;
; Line 341:				else if (spaced) {
;
	CMP	DWORD [EBP+0FFFFFF5CH],BYTE 00H
	JE	SHORT	L_202
;
; Line 342:					*(*buffer)++ = ' ';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],020H
;
; Line 343:					if (width)
;
	TEST	EBX,EBX
	JE	SHORT	L_204
;
; Line 344:						width--;
;
	DEC	EBX
L_204:
;
; Line 345:				}
;
L_202:
L_199:
;
; Line 346:				goto numfin;
;
	JMP	L_17
L_65:
;
; Line 348:				(*count)++;
;
	MOV	EAX,DWORD [EBP+018H]
	INC	DWORD [EAX+00H]
;
; Line 349:				sz = strlen(*(char **)arg);
;
	MOV	EAX,DWORD [EBP+014H]
	PUSH	EDI
	MOV	EDI,DWORD [EAX+00H]
	CLD
	SUB	EAX,EAX
	MOV	ECX,0FFFFFFFFH
	REPNZ	SCASB
	NOT	ECX
	DEC	ECX
	MOV	EAX,ECX
	POP	EDI
	MOV	DWORD [EBP+0FFFFFF44H],EAX
;
; Line 350:				if (prec > 0 && prec < sz)
;
	CMP	DWORD [EBP+0FFFFFF68H],BYTE 00H
	JLE	SHORT	L_206
	MOV	EAX,DWORD [EBP+0FFFFFF68H]
	CMP	EAX,DWORD [EBP+0FFFFFF44H]
	JGE	SHORT	L_206
;
; Line 351:					sz = prec;
;
	MOV	EAX,DWORD [EBP+0FFFFFF68H]
	MOV	DWORD [EBP+0FFFFFF44H],EAX
L_206:
;
; Line 352:				if (width) {
;
	TEST	EBX,EBX
	JE	NEAR	L_208
;
; Line 353:					memset(*buffer,' ',width);
;
	MOV	EAX,020H
	MOV	ECX,EBX
	PUSH	EDI
	PUSH	EAX
	MOV	EDI,DWORD [ESI+00H]
	CLD
	REPNZ	STOSB
	POP	EAX
	POP	EDI
;
; Line 354:					*((*buffer) + width) = 0;
;
	MOV	EAX,DWORD [ESI+00H]
	MOV	BYTE [EAX+EBX+00H],00H
;
; Line 355:				} else
;
	JMP	L_209
L_208:
;
; Line 356:					*((*buffer)+sz) = 0;
;
	MOV	EAX,DWORD [ESI+00H]
	MOV	ECX,DWORD [EBP+0FFFFFF44H]
	MOV	BYTE [EAX+ECX+00H],00H
L_209:
;
; Line 357:				if (width && (sz < width) && !ljustify)
;
	TEST	EBX,EBX
	JE	NEAR	L_210
	CMP	DWORD [EBP+0FFFFFF44H],EBX
	JGE	NEAR	L_210
	CMP	DWORD [EBP+0FFFFFF58H],BYTE 00H
	JNE	NEAR	L_210
;
; Line 358:					strncpy((*buffer)+width-sz,*(char **)arg,sz);
;
	PUSH	DWORD [EBP+0FFFFFF44H]
	MOV	EAX,DWORD [EBP+014H]
	PUSH	DWORD [EAX+00H]
	MOV	EAX,DWORD [ESI+00H]
	ADD	EAX,EBX
	SUB	EAX,DWORD [EBP+0FFFFFF44H]
	PUSH	EAX
	CALL	_strncpy
	ADD	ESP,BYTE 0CH
	JMP	L_211
L_210:
;
; Line 360:					if (width && sz >= width)
;
	TEST	EBX,EBX
	JE	SHORT	L_212
	CMP	DWORD [EBP+0FFFFFF44H],EBX
	JL	SHORT	L_212
;
; Line 361:						sz++;
;
	INC	DWORD [EBP+0FFFFFF44H]
L_212:
;
; Line 362:					strncpy(*buffer,*(char **)arg,sz);
;
	PUSH	DWORD [EBP+0FFFFFF44H]
	MOV	EAX,DWORD [EBP+014H]
	PUSH	DWORD [EAX+00H]
	PUSH	DWORD [ESI+00H]
	CALL	_strncpy
	ADD	ESP,BYTE 0CH
;
; Line 363:				}
;
L_211:
;
; Line 364:				*buffer += strlen(*buffer);
;
	PUSH	EDI
	MOV	EDI,DWORD [ESI+00H]
	CLD
	SUB	EAX,EAX
	MOV	ECX,0FFFFFFFFH
	REPNZ	SCASB
	NOT	ECX
	DEC	ECX
	MOV	EAX,ECX
	POP	EDI
	ADD	DWORD [ESI+00H],EAX
;
; Line 365:				break;
;
	JMP	L_53
L_66:
;
; Line 367:				(*count)++;
;
	MOV	EAX,DWORD [EBP+018H]
	INC	DWORD [EAX+00H]
;
; Line 368:				c = (int )arg;
;
	MOV	EAX,DWORD [EBP+014H]
	MOV	DWORD [EBP+0FFFFFF40H],EAX
;
; Line 369:				if (mode == 'h') {
;
	CMP	DWORD [EBP+0FFFFFF6CH],BYTE 068H
	JNE	SHORT	L_214
;
; Line 370:					c &= 0xffff;
;
	AND	DWORD [EBP+0FFFFFF40H],0FFFFH
;
; Line 371:					if (c & 0x8000)
;
	MOV	EAX,DWORD [EBP+0FFFFFF40H]
	AND	EAX,08000H
	JE	SHORT	L_216
;
; Line 372:						c |= 0xffff0000;
;
	OR	DWORD [EBP+0FFFFFF40H],0FFFF0000H
L_216:
;
; Line 373:				}
;
L_214:
;
; Line 374:				sz = getnum(locbuf,*(int *)arg,10,0,1);
;
	PUSH	BYTE 01H
	PUSH	BYTE 00H
	PUSH	BYTE 0AH
	MOV	EAX,DWORD [EBP+014H]
	PUSH	DWORD [EAX+00H]
	LEA	EAX,[EBP+0FFFFFFDCH]
	PUSH	EAX
	CALL	_getnum
	ADD	ESP,BYTE 014H
	MOV	DWORD [EBP+0FFFFFF44H],EAX
;
; Line 376:				if (issigned) {
;
	CMP	DWORD [EBP+0FFFFFF54H],BYTE 00H
	JE	SHORT	L_218
;
; Line 377:					*(*buffer)++ = '+';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],02BH
;
; Line 378:					if (width)
;
	TEST	EBX,EBX
	JE	SHORT	L_220
;
; Line 379:						width--;
;
	DEC	EBX
L_220:
;
; Line 380:				}
;
	JMP	L_219
L_218:
;
; Line 381:				else if (spaced) {
;
	CMP	DWORD [EBP+0FFFFFF5CH],BYTE 00H
	JE	SHORT	L_222
;
; Line 382:					*(*buffer)++ = ' ';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],020H
;
; Line 383:					if (width)
;
	TEST	EBX,EBX
	JE	SHORT	L_224
;
; Line 384:						width--;
;
	DEC	EBX
L_224:
;
; Line 385:				}
;
L_222:
L_219:
;
; Line 386:				goto numfin;
;
	JMP	L_17
L_67:
L_68:
;
; Line 389:						lc = 1;
;
	MOV	EDI,01H
L_69:
;
; Line 391:				(*count)++;
;
	MOV	EAX,DWORD [EBP+018H]
	INC	DWORD [EAX+00H]
;
; Line 392:				if (*(format-1) == 'X')
;
	MOV	EAX,DWORD [EBP+010H]
	DEC	EAX
	MOVSX	EAX,BYTE [EAX+00H]
	CMP	EAX,BYTE 058H
	JNE	SHORT	L_226
;
; Line 393:					lc = 0;
;
	MOV	EDI,00H
L_226:
;
; Line 394:				c = *(int *)arg;
;
	MOV	EAX,DWORD [EBP+014H]
	MOV	EAX,DWORD [EAX+00H]
	MOV	DWORD [EBP+0FFFFFF40H],EAX
;
; Line 395:				if (mode == 'h') {
;
	CMP	DWORD [EBP+0FFFFFF6CH],BYTE 068H
	JNE	SHORT	L_228
;
; Line 396:					c &= 0xffff;
;
	AND	DWORD [EBP+0FFFFFF40H],0FFFFH
;
; Line 397:					if (c & 0x8000)
;
	MOV	EAX,DWORD [EBP+0FFFFFF40H]
	AND	EAX,08000H
	JE	SHORT	L_230
;
; Line 398:						c |= 0xffff0000;
;
	OR	DWORD [EBP+0FFFFFF40H],0FFFF0000H
L_230:
;
; Line 399:				}
;
L_228:
;
; Line 400:				sz = getnum(locbuf,c,16,lc,1);
;
	PUSH	BYTE 01H
	PUSH	EDI
	PUSH	BYTE 010H
	PUSH	DWORD [EBP+0FFFFFF40H]
	LEA	EAX,[EBP+0FFFFFFDCH]
	PUSH	EAX
	CALL	_getnum
	ADD	ESP,BYTE 014H
	MOV	DWORD [EBP+0FFFFFF44H],EAX
;
; Line 401:				if (issigned) {
;
	CMP	DWORD [EBP+0FFFFFF54H],BYTE 00H
	JE	SHORT	L_232
;
; Line 402:					*(*buffer)++ = '+';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],02BH
;
; Line 403:					if (width)
;
	TEST	EBX,EBX
	JE	SHORT	L_234
;
; Line 404:						width--;
;
	DEC	EBX
L_234:
;
; Line 405:				}
;
	JMP	L_233
L_232:
;
; Line 406:				else if (spaced) {
;
	CMP	DWORD [EBP+0FFFFFF5CH],BYTE 00H
	JE	SHORT	L_236
;
; Line 407:					*(*buffer)++ = ' ';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],020H
;
; Line 408:					if (width)
;
	TEST	EBX,EBX
	JE	SHORT	L_238
;
; Line 409:						width--;
;
	DEC	EBX
L_238:
;
; Line 410:				}
;
L_236:
L_233:
;
; Line 411:				if (prefixed) {
;
	CMP	DWORD [EBP+0FFFFFF60H],BYTE 00H
	JE	SHORT	L_240
;
; Line 412:					*(*buffer)++ = '0';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],030H
;
; Line 413:					*(*buffer)++ = 'x';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],078H
;
; Line 414:				}
;
L_240:
L_17:
;
; Line 416:				if (width) {
;
	TEST	EBX,EBX
	JE	NEAR	L_242
;
; Line 417:					if (width <= sz) {
;
	CMP	EBX,DWORD [EBP+0FFFFFF44H]
	JNG	NEAR	L_21
;
; Line 418:						goto nowidth;
;
;
; Line 419:					}
;
L_244:
;
; Line 420:					if (!ljustify || leadzero) {
;
	CMP	DWORD [EBP+0FFFFFF58H],BYTE 00H
	JE	SHORT	L_248
	CMP	DWORD [EBP+0FFFFFF64H],BYTE 00H
	JE	NEAR	L_246
L_248:
;
; Line 421:						if (leadzero) {
;
	CMP	DWORD [EBP+0FFFFFF64H],BYTE 00H
	JE	NEAR	L_249
	MOV	DWORD [EBP+0FFFFFF70H],00H
	JMP	L_253
L_251:
;
; Line 423:								*(*buffer)++ = '0';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],030H
;
; Line 422:							for (i=0; i < width-sz; i++)
;
L_252:
	INC	DWORD [EBP+0FFFFFF70H]
L_253:
	MOV	EAX,EBX
	SUB	EAX,DWORD [EBP+0FFFFFF44H]
	CMP	DWORD [EBP+0FFFFFF70H],EAX
	JL	SHORT	L_251
L_254:
;
; Line 424:						}
;
	JMP	L_250
L_249:
	MOV	DWORD [EBP+0FFFFFF70H],00H
	JMP	L_257
L_255:
;
; Line 427:								*(*buffer)++ = ' ';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],020H
;
; Line 426:							for (i=0; i < width-sz; i++)
;
L_256:
	INC	DWORD [EBP+0FFFFFF70H]
L_257:
	MOV	EAX,EBX
	SUB	EAX,DWORD [EBP+0FFFFFF44H]
	CMP	DWORD [EBP+0FFFFFF70H],EAX
	JL	SHORT	L_255
L_258:
;
; Line 428:						}
;
L_250:
;
; Line 429:						strcpy(*buffer,&locbuf[32-sz-1]);
;
	LEA	EAX,[EBP+0FFFFFFDCH]
	MOV	ECX,DWORD [EBP+0FFFFFF44H]
	NEG	ECX
	ADD	EAX,ECX
	ADD	EAX,BYTE 01FH
	MOV	ECX,DWORD [ESI+00H]
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,EAX
	MOV	EDI,ECX
	XCHG	ESI,EDI
	CLD
	PUSH	EDI
	SUB	EAX,EAX
	MOV	ECX,0FFFFFFFFH
	REPNZ	SCASB
	NOT	ECX
	MOV	EAX,ECX
	POP	EDI
	XCHG	ESI,EDI
	REPNZ	MOVSB
	POP	EDI
	POP	ESI
;
; Line 430:						(*buffer) += strlen(*buffer);
;
	PUSH	EDI
	MOV	EDI,DWORD [ESI+00H]
	CLD
	SUB	EAX,EAX
	MOV	ECX,0FFFFFFFFH
	REPNZ	SCASB
	NOT	ECX
	DEC	ECX
	MOV	EAX,ECX
	POP	EDI
	ADD	DWORD [ESI+00H],EAX
;
; Line 431:					}
;
	JMP	L_247
L_246:
;
; Line 433:						strcpy(*buffer,&locbuf[32-sz-1]);
;
	LEA	EAX,[EBP+0FFFFFFDCH]
	MOV	ECX,DWORD [EBP+0FFFFFF44H]
	NEG	ECX
	ADD	EAX,ECX
	ADD	EAX,BYTE 01FH
	MOV	ECX,DWORD [ESI+00H]
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,EAX
	MOV	EDI,ECX
	XCHG	ESI,EDI
	CLD
	PUSH	EDI
	SUB	EAX,EAX
	MOV	ECX,0FFFFFFFFH
	REPNZ	SCASB
	NOT	ECX
	MOV	EAX,ECX
	POP	EDI
	XCHG	ESI,EDI
	REPNZ	MOVSB
	POP	EDI
	POP	ESI
;
; Line 434:						(*buffer) += strlen(*buffer);
;
	PUSH	EDI
	MOV	EDI,DWORD [ESI+00H]
	CLD
	SUB	EAX,EAX
	MOV	ECX,0FFFFFFFFH
	REPNZ	SCASB
	NOT	ECX
	DEC	ECX
	MOV	EAX,ECX
	POP	EDI
	ADD	DWORD [ESI+00H],EAX
	MOV	DWORD [EBP+0FFFFFF70H],00H
	JMP	L_261
L_259:
;
; Line 436:							*(*buffer)++ = ' ';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],020H
;
; Line 435:						for (i=0; i < width-sz; i++)
;
L_260:
	INC	DWORD [EBP+0FFFFFF70H]
L_261:
	MOV	EAX,EBX
	SUB	EAX,DWORD [EBP+0FFFFFF44H]
	CMP	DWORD [EBP+0FFFFFF70H],EAX
	JL	SHORT	L_259
L_262:
;
; Line 437:						*(*buffer) = 0;
;
	MOV	EAX,DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],00H
;
; Line 438:					}
;
L_247:
;
; Line 439:				}
;
	JMP	L_243
L_242:
L_21:
;
; Line 442:					strcpy(*buffer,&locbuf[32-sz-1]);
;
	LEA	EAX,[EBP+0FFFFFFDCH]
	MOV	ECX,DWORD [EBP+0FFFFFF44H]
	NEG	ECX
	ADD	EAX,ECX
	ADD	EAX,BYTE 01FH
	MOV	ECX,DWORD [ESI+00H]
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,EAX
	MOV	EDI,ECX
	XCHG	ESI,EDI
	CLD
	PUSH	EDI
	SUB	EAX,EAX
	MOV	ECX,0FFFFFFFFH
	REPNZ	SCASB
	NOT	ECX
	MOV	EAX,ECX
	POP	EDI
	XCHG	ESI,EDI
	REPNZ	MOVSB
	POP	EDI
	POP	ESI
;
; Line 443:					(*buffer) += strlen(*buffer);
;
	PUSH	EDI
	MOV	EDI,DWORD [ESI+00H]
	CLD
	SUB	EAX,EAX
	MOV	ECX,0FFFFFFFFH
	REPNZ	SCASB
	NOT	ECX
	DEC	ECX
	MOV	EAX,ECX
	POP	EDI
	ADD	DWORD [ESI+00H],EAX
;
; Line 444:					*(*buffer) = 0;
;
	MOV	EAX,DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],00H
;
; Line 445:				}
;
L_243:
;
; Line 446:				break;
;
	JMP	L_53
L_52:
;
; Line 448:			 	*(*buffer)++ = '%';
;
	MOV	EAX,DWORD [ESI+00H]
	INC	DWORD [ESI+00H]
	MOV	BYTE [EAX+00H],025H
;
; Line 449:				format = ofm;
;
	MOV	EAX,DWORD [EBP+0FFFFFFFCH]
	MOV	DWORD [EBP+010H],EAX
;
; Line 450:				break;
;
L_53:
;
; Line 452:		return(format);
;
	MOV	EAX,DWORD [EBP+010H]
L_263:
	POP	EDI
	POP	ESI
	POP	EBX
	MOV	ESP,EBP
	POP	EBP
	RET
[GLOBAL	_vsprintf]
;
; Line 456:	{
;
_vsprintf:
	PUSH	EBP
	MOV	EBP,ESP
	SUB	ESP,BYTE 04H
	PUSH	EBX
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,DWORD [EBP+0CH]
	LEA	EDI,[EBP+08H]
;
; Line 457:		int i = 0;
;
	MOV	DWORD [EBP+0FFFFFFFCH],00H
;
; Line 458:		char *obuf = buffer;
;
	MOV	EBX,DWORD [EDI+00H]
	JMP	L_264
L_266:
	JMP	L_267
L_269:
;
; Line 461:				*buffer++ = *format++;
;
	MOV	EAX,ESI
	INC	ESI
	MOV	ECX,DWORD [EDI+00H]
	INC	DWORD [EDI+00H]
	MOV	AL,BYTE [EAX+00H]
	MOV	BYTE [ECX+00H],AL
L_267:
;
; Line 460:			while (*format != '%' && *format != 0)
;
	MOVSX	EAX,BYTE [ESI+00H]
	CMP	EAX,BYTE 025H
	JE	SHORT	L_270
	MOVSX	EAX,BYTE [ESI+00H]
	TEST	EAX,EAX
	JNE	NEAR	L_269
L_270:
L_268:
;
; Line 462:			if (*format && *(format+1))
;
	CMP	BYTE [ESI+00H],BYTE 00H
	JE	NEAR	L_271
	CMP	BYTE [ESI+01H],BYTE 00H
	JE	NEAR	L_271
;
; Line 463:				format = onetostr(obuf,&buffer,format+1,&((char **)arglist+i),&i);
;
	LEA	EAX,[EBP+0FFFFFFFCH]
	PUSH	EAX
	MOV	EAX,DWORD [EBP+0FFFFFFFCH]
	SHL	EAX,02H
	ADD	EAX,DWORD [EBP+010H]
	PUSH	EAX
	LEA	EAX,[ESI+01H]
	PUSH	EAX
	PUSH	EDI
	PUSH	EBX
	CALL	_onetostr
	ADD	ESP,BYTE 014H
	MOV	ESI,EAX
L_271:
;
; Line 464:		}
;
L_264:
;
; Line 459:		while (*format) {
;
	CMP	BYTE [ESI+00H],BYTE 00H
	JNE	NEAR	L_266
L_265:
;
; Line 465:		*buffer++ = 0;
;
	MOV	EAX,DWORD [EDI+00H]
	INC	DWORD [EDI+00H]
	MOV	BYTE [EAX+00H],00H
;
; Line 466:		return(strlen(obuf));
;
	PUSH	EDI
	MOV	EDI,EBX
	CLD
	SUB	EAX,EAX
	MOV	ECX,0FFFFFFFFH
	REPNZ	SCASB
	NOT	ECX
	DEC	ECX
	MOV	EAX,ECX
	POP	EDI
L_273:
	POP	EDI
	POP	ESI
	POP	EBX
	MOV	ESP,EBP
	POP	EBP
	RET
[GLOBAL	_sprintf]
;
; Line 469:	{
;
_sprintf:
	PUSH	EBP
	MOV	EBP,ESP
;
; Line 470:		return vsprintf(buffer,format,(((char *)&format) + sizeof(char *)));
;
	LEA	EAX,[EBP+0CH]
	ADD	EAX,BYTE 04H
	PUSH	EAX
	PUSH	DWORD [EBP+0CH]
	PUSH	DWORD [EBP+08H]
	CALL	_vsprintf
	ADD	ESP,BYTE 0CH
L_274:
	POP	EBP
	RET

	TIMES $$-$ & 3 NOP
L_181:
	DD	0aH
L_178:
	DD	064H

SECTION _STRING
L_20:
	DB	028H,049H,06EH,066H,029H,00H
L_19:
	DB	028H,04EH,061H,04EH,029H,00H

SECTION _TEXT
[EXTERN	_strncpy]
[EXTERN	__fnd]
[EXTERN	__fextract]

SECTION _DATA
[EXTERN	__ctype]
