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

SECTION _TEXT
;
; Line 50:	static void CreateWindowMsg(WINDOW wnd)
;
_CreateWindowMsg:
	PUSH	EBP
	MOV	EBP,ESP
	PUSH	ESI
	MOV	ESI,DWORD [EBP+08H]
L_26:
;
; Line 51:	{
;
;
; Line 52:	Helping = TRUE;
;
	MOV	DWORD [_Helping],01H
;
; Line 53:	GetClass(wnd) = HELPBOX;
;
	MOV	DWORD [ESI+00H],013H
;
; Line 54:	InitWindowColors(wnd);
;
	PUSH	ESI
	CALL	_InitWindowColors
	POP	ECX
;
; Line 55:	if (ThisHelp != NULL)
;
	CMP	DWORD [_ThisHelp],BYTE 00H
	JE	SHORT	L_27
;
; Line 56:	ThisHelp->hwnd = wnd;
;
	MOV	EAX,DWORD [_ThisHelp]
	MOV	DWORD [EAX+016H],ESI
L_27:
;
; Line 57:	}
;
L_25:
	POP	ESI
	POP	EBP
	RET
;
; Line 60:	static BOOL CommandMsg(WINDOW wnd, PARAM p1)
;
_CommandMsg:
	PUSH	EBP
	MOV	EBP,ESP
	PUSH	EBX
	PUSH	ESI
	PUSH	EDI
	MOV	EBX,DWORD [EBP+08H]
	MOV	ESI,DWORD _ThisHelp
	MOV	EDI,DWORD _FirstHelp
L_30:
;
; Line 61:	{
;
;
; Line 62:	switch ((int)p1)    {
;
	MOV	EAX,DWORD [EBP+0CH]
	CMP	EAX,BYTE 049H
	JE	SHORT	L_35
	CMP	EAX,BYTE 04AH
	JE	SHORT	L_33
	CMP	EAX,BYTE 04BH
	JE	SHORT	L_34
	JMP	SHORT	L_32
L_33:
;
; Line 64:	if (ThisHelp  != NULL)
;
	CMP	DWORD [ESI+00H],BYTE 00H
	JE	SHORT	L_36
;
; Line 65:	SelectHelp(wnd, FirstHelp+(ThisHelp->prevhlp), TRUE);
;
	PUSH	BYTE 01H
	MOV	EAX,DWORD [ESI+00H]
	MOVSX	EAX,WORD [EAX+014H]
	IMUL	EAX,BYTE 022H
	ADD	EAX,DWORD [EDI+00H]
	PUSH	EAX
	PUSH	EBX
	CALL	_SelectHelp
	ADD	ESP,BYTE 0CH
L_36:
;
; Line 66:	return TRUE;
;
	MOV	EAX,01H
	JMP	SHORT	L_29
L_34:
;
; Line 68:	if (ThisHelp != NULL)
;
	CMP	DWORD [ESI+00H],BYTE 00H
	JE	SHORT	L_38
;
; Line 69:	SelectHelp(wnd, FirstHelp+(ThisHelp->nexthlp), TRUE);
;
	PUSH	BYTE 01H
	MOV	EAX,DWORD [ESI+00H]
	MOVSX	EAX,WORD [EAX+012H]
	IMUL	EAX,BYTE 022H
	ADD	EAX,DWORD [EDI+00H]
	PUSH	EAX
	PUSH	EBX
	CALL	_SelectHelp
	ADD	ESP,BYTE 0CH
L_38:
;
; Line 70:	return TRUE;
;
	MOV	EAX,01H
	JMP	SHORT	L_29
L_35:
;
; Line 72:	if (stacked)
;
	CMP	DWORD [_stacked],BYTE 00H
	JE	SHORT	L_40
;
; Line 73:	SelectHelp(wnd, FirstHelp+HelpStack[--stacked], FALSE);
;
	PUSH	BYTE 00H
	DEC	DWORD [_stacked]
	MOV	EAX,DWORD [_stacked]
	MOV	EAX,DWORD [EAX*4+_HelpStack+00H]
	IMUL	EAX,BYTE 022H
	ADD	EAX,DWORD [EDI+00H]
	PUSH	EAX
	PUSH	EBX
	CALL	_SelectHelp
	ADD	ESP,BYTE 0CH
L_40:
;
; Line 74:	return TRUE;
;
	MOV	EAX,01H
	JMP	SHORT	L_29
L_32:
;
; Line 76:	break;
;
	JMP	SHORT	L_31
L_31:
;
; Line 78:	return FALSE;
;
	MOV	EAX,00H
L_29:
	POP	EDI
	POP	ESI
	POP	EBX
	POP	EBP
	RET
;
; Line 82:	static BOOL KeyboardMsg(WINDOW wnd, PARAM p1)
;
_KeyboardMsg:
	PUSH	EBP
	MOV	EBP,ESP
	SUB	ESP,BYTE 04H
	PUSH	EBX
	PUSH	ESI
	PUSH	EDI
	MOV	EDI,DWORD _thisword
L_43:
;
; Line 83:	{
;
;
; Line 86:	cwnd = ControlWindow(wnd->extension, ID_HELPTEXT);
;
	PUSH	BYTE 048H
	MOV	EAX,DWORD [EBP+08H]
	PUSH	DWORD [EAX+06CH]
	CALL	_ControlWindow
	ADD	ESP,BYTE 08H
	MOV	ESI,EAX
;
; Line 87:	if (cwnd == NULL || inFocus != cwnd)
;
	TEST	ESI,ESI
	JE	SHORT	L_46
	CMP	DWORD [_inFocus],ESI
	JE	SHORT	L_44
L_46:
;
; Line 88:	return FALSE;
;
	MOV	EAX,00H
	JMP	NEAR	L_42
L_44:
;
; Line 89:	switch ((int)p1)    {
;
	MOV	EAX,DWORD [EBP+0CH]
	CMP	EAX,BYTE 09H
	JE	SHORT	L_50
	CMP	EAX,BYTE 0DH
	JE	SHORT	L_49
	CMP	EAX,DWORD 0108FH
	JE	NEAR	L_51
	JMP	NEAR	L_48
L_49:
;
; Line 91:	if (keywordcount)
;
	CMP	DWORD [_keywordcount],BYTE 00H
	JE	SHORT	L_52
;
; Line 92:	if (thisword != NULL)    {
;
	CMP	DWORD [EDI+00H],BYTE 00H
	JE	SHORT	L_54
;
; Line 93:	char *hp = thisword->hkey->hname;
;
	MOV	EAX,DWORD [EDI+00H]
	MOV	EAX,DWORD [EAX+00H]
	MOV	EAX,DWORD [EAX+00H]
	MOV	DWORD [EBP-04H],EAX
;
; Line 94:	if (thisword->isDefinition)
;
	MOV	EAX,DWORD [EDI+00H]
	CMP	BYTE [EAX+014H],BYTE 00H
	JE	SHORT	L_56
;
; Line 95:	DisplayDefinition(GetParent(wnd), hp);
;
	PUSH	DWORD [EBP-04H]
	MOV	EAX,DWORD [EBP+08H]
	PUSH	DWORD [EAX+03CH]
	CALL	_DisplayDefinition
	ADD	ESP,BYTE 08H
	JMP	SHORT	L_57
L_56:
;
; Line 97:	SelectHelp(wnd, thisword->hkey, TRUE);
;
	PUSH	BYTE 01H
	MOV	EAX,DWORD [EDI+00H]
	PUSH	DWORD [EAX+00H]
	PUSH	DWORD [EBP+08H]
	CALL	_SelectHelp
	ADD	ESP,BYTE 0CH
L_57:
L_54:
L_52:
;
; Line 99:	return TRUE;
;
	MOV	EAX,01H
	JMP	NEAR	L_42
L_50:
;
; Line 101:	if (!keywordcount)
;
	CMP	DWORD [_keywordcount],BYTE 00H
	JNE	SHORT	L_58
;
; Line 102:	return TRUE;
;
	MOV	EAX,01H
	JMP	NEAR	L_42
L_58:
;
; Line 103:	if (thisword == NULL ||
;
	CMP	DWORD [EDI+00H],BYTE 00H
	JE	SHORT	L_62
	MOV	EAX,DWORD [_keywordcount]
	IMUL	EAX,BYTE 015H
	ADD	EAX,DWORD _KeyWords
	ADD	DWORD [EDI+00H],BYTE 015H
	CMP	DWORD [EDI+00H],EAX
	JNE	SHORT	L_60
L_62:
;
; Line 105:	thisword = KeyWords;
;
	MOV	DWORD [EDI+00H],DWORD _KeyWords
L_60:
;
; Line 106:	break;
;
	JMP	SHORT	L_47
L_51:
;
; Line 108:	if (!keywordcount)
;
	CMP	DWORD [_keywordcount],BYTE 00H
	JNE	SHORT	L_63
;
; Line 109:	return TRUE;
;
	MOV	EAX,01H
	JMP	NEAR	L_42
L_63:
;
; Line 110:	if (thisword == NULL || thisword == KeyWords)
;
	CMP	DWORD [EDI+00H],BYTE 00H
	JE	SHORT	L_67
	CMP	DWORD [EDI+00H],DWORD _KeyWords
	JNE	SHORT	L_65
L_67:
;
; Line 111:	thisword = KeyWords+keywordcount;
;
	MOV	EAX,DWORD [_keywordcount]
	IMUL	EAX,BYTE 015H
	ADD	EAX,DWORD _KeyWords
	MOV	DWORD [EDI+00H],EAX
L_65:
;
; Line 112:	--thisword;
;
	SUB	DWORD [EDI+00H],BYTE 015H
;
; Line 113:	break;;
;
	JMP	SHORT	L_47
L_48:
;
; Line 115:	return FALSE;
;
	MOV	EAX,00H
	JMP	NEAR	L_42
L_47:
;
; Line 117:	if (thisword->lineno < cwnd->wtop ||
;
	MOV	EAX,DWORD [EDI+00H]
	MOV	EAX,DWORD [EAX+04H]
	CMP	EAX,DWORD [ESI+094H]
	JL	NEAR	L_70
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_71
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,BYTE 08H
	JE	SHORT	L_71
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,010000H
	JE	SHORT	L_71
	MOV	EAX,03H
	JMP	SHORT	L_72
L_71:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_76
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,BYTE 08H
	JNE	SHORT	L_75
L_76:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_73
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,010000H
	JE	SHORT	L_73
L_75:
	MOV	EAX,02H
	JMP	SHORT	L_74
L_73:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,014108H
	JE	SHORT	L_77
	MOV	EAX,01H
	JMP	SHORT	L_78
L_77:
	MOV	EAX,00H
L_78:
L_74:
L_72:
	MOV	ECX,DWORD [ESI+01CH]
	SUB	ECX,EAX
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,08000H
	JE	SHORT	L_79
	MOV	EAX,01H
	JMP	SHORT	L_80
L_79:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,04000H
	JE	SHORT	L_81
	MOV	EAX,01H
	JMP	SHORT	L_82
L_81:
	MOV	EAX,00H
L_82:
L_80:
	SUB	ECX,EAX
	ADD	ECX,DWORD [ESI+094H]
	MOV	EAX,DWORD [EDI+00H]
	CMP	DWORD [EAX+04H],ECX
	JL	NEAR	L_68
L_70:
;
; Line 120:	int distance = ClientHeight(cwnd)/2;
;
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_83
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,BYTE 08H
	JE	SHORT	L_83
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,010000H
	JE	SHORT	L_83
	MOV	EAX,03H
	JMP	SHORT	L_84
L_83:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_88
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,BYTE 08H
	JNE	SHORT	L_87
L_88:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_85
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,010000H
	JE	SHORT	L_85
L_87:
	MOV	EAX,02H
	JMP	SHORT	L_86
L_85:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,014108H
	JE	SHORT	L_89
	MOV	EAX,01H
	JMP	SHORT	L_90
L_89:
	MOV	EAX,00H
L_90:
L_86:
L_84:
	MOV	ECX,DWORD [ESI+01CH]
	SUB	ECX,EAX
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,08000H
	JE	SHORT	L_91
	MOV	EAX,01H
	JMP	SHORT	L_92
L_91:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,04000H
	JE	SHORT	L_93
	MOV	EAX,01H
	JMP	SHORT	L_94
L_93:
	MOV	EAX,00H
L_94:
L_92:
	SUB	ECX,EAX
	SAR	ECX,01H
	JNS	SHORT	L_95
	ADC	ECX,BYTE 00H
L_95:
	MOV	EBX,ECX
;
; Line 121:	do    {
;
L_96:
;
; Line 122:	cwnd->wtop = thisword->lineno-distance;
;
	MOV	EAX,DWORD [EDI+00H]
	MOV	EAX,DWORD [EAX+04H]
	SUB	EAX,EBX
	MOV	DWORD [ESI+094H],EAX
;
; Line 123:	distance /= 2;
;
	SAR	EBX,01H
	JNS	SHORT	L_99
	ADC	EBX,BYTE 00H
L_99:
L_97:
	CMP	DWORD [ESI+094H],BYTE 00H
	JL	SHORT	L_96
L_98:
L_68:
;
; Line 127:	SendMessage(cwnd, PAINT, 0, 0);
;
	PUSH	BYTE 00H
	PUSH	BYTE 00H
	PUSH	BYTE 09H
	PUSH	ESI
	CALL	_SendMessage
	ADD	ESP,BYTE 010H
;
; Line 128:	return TRUE;
;
	MOV	EAX,01H
L_42:
	POP	EDI
	POP	ESI
	POP	EBX
	MOV	ESP,EBP
	POP	EBP
	RET
[GLOBAL	_HelpBoxProc]
;
; Line 132:	int HelpBoxProc(WINDOW wnd, MESSAGE msg, PARAM p1, PARAM p2)
;
_HelpBoxProc:
	PUSH	EBP
	MOV	EBP,ESP
	PUSH	EBX
	PUSH	ESI
	PUSH	EDI
	MOV	EBX,DWORD [EBP+08H]
	MOV	ESI,DWORD [EBP+010H]
	MOV	EDI,DWORD [EBP+014H]
L_101:
;
; Line 133:	{
;
;
; Line 134:	switch (msg)    {
;
	MOV	EAX,DWORD [EBP+0CH]
	CMP	EAX,BYTE 07H
	JE	SHORT	L_108
	JA	SHORT	L_109
	CMP	EAX,BYTE 03H
	JE	SHORT	L_104
	JA	NEAR	L_103
	CMP	EAX,BYTE 02H
	JE	SHORT	L_106
	JMP	SHORT	L_103
L_109:
	CMP	EAX,BYTE 048H
	JE	SHORT	L_105
	JA	SHORT	L_103
	CMP	EAX,BYTE 015H
	JE	SHORT	L_107
	JMP	SHORT	L_103
L_104:
;
; Line 136:	CreateWindowMsg(wnd);
;
	PUSH	EBX
	CALL	_CreateWindowMsg
	POP	ECX
;
; Line 137:	break;
;
	JMP	SHORT	L_102
L_105:
;
; Line 139:	ReadHelp(wnd);
;
	PUSH	EBX
	CALL	_ReadHelp
	POP	ECX
;
; Line 140:	break;
;
	JMP	SHORT	L_102
L_106:
;
; Line 142:	if (p2 != 0)
;
	TEST	EDI,EDI
	JNE	SHORT	L_102
;
; Line 143:	break;
;
L_110:
;
; Line 144:	if (CommandMsg(wnd, p1))
;
	PUSH	ESI
	PUSH	EBX
	CALL	_CommandMsg
	ADD	ESP,BYTE 08H
	TEST	EAX,EAX
	JE	SHORT	L_112
;
; Line 145:	return TRUE;
;
	MOV	EAX,01H
	JMP	SHORT	L_100
L_112:
;
; Line 146:	break;
;
	JMP	SHORT	L_102
L_107:
;
; Line 148:	if (WindowMoving)
;
	CMP	DWORD [_WindowMoving],BYTE 00H
	JNE	SHORT	L_102
;
; Line 149:	break;
;
L_114:
;
; Line 150:	if (KeyboardMsg(wnd, p1))
;
	PUSH	ESI
	PUSH	EBX
	CALL	_KeyboardMsg
	ADD	ESP,BYTE 08H
	TEST	EAX,EAX
	JE	SHORT	L_116
;
; Line 151:	return TRUE;
;
	MOV	EAX,01H
	JMP	SHORT	L_100
L_116:
;
; Line 152:	break;
;
	JMP	SHORT	L_102
L_108:
;
; Line 154:	if (ThisHelp != NULL)
;
	CMP	DWORD [_ThisHelp],BYTE 00H
	JE	SHORT	L_118
;
; Line 155:	ThisHelp->hwnd = NULL;
;
	MOV	EAX,DWORD [_ThisHelp]
	MOV	DWORD [EAX+016H],00H
L_118:
;
; Line 156:	Helping = FALSE;
;
	MOV	DWORD [_Helping],00H
;
; Line 157:	break;
;
	JMP	SHORT	L_102
L_103:
;
; Line 159:	break;
;
	JMP	SHORT	L_102
L_102:
;
; Line 161:	return BaseWndProc(HELPBOX, wnd, msg, p1, p2);
;
	PUSH	EDI
	PUSH	ESI
	MOVSX	EAX,WORD [EBP+0CH]
	PUSH	EAX
	PUSH	EBX
	MOV	EAX,DWORD [_classdefs+0E4H]
	IMUL	EAX,BYTE 0CH
	CALL	DWORD [EAX+04H+_classdefs+00H]
	ADD	ESP,BYTE 010H
L_100:
	POP	EDI
	POP	ESI
	POP	EBX
	POP	EBP
	RET
;
; Line 165:	static int PaintMsg(WINDOW wnd, PARAM p1, PARAM p2)
;
_PaintMsg:
	PUSH	EBP
	MOV	EBP,ESP
	SUB	ESP,BYTE 0CH
	PUSH	EBX
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,DWORD [EBP+08H]
	MOV	EBX,DWORD [EBP+0CH]
L_121:
;
; Line 166:	{
;
;
; Line 168:	if (thisword != NULL)    {
;
	CMP	DWORD [_thisword],BYTE 00H
	JE	NEAR	L_122
;
; Line 169:	WINDOW pwnd = GetParent(wnd);
;
	MOV	EAX,DWORD [ESI+03CH]
	MOV	DWORD [EBP-0CH],EAX
;
; Line 171:	cp = TextLine(wnd, thisword->lineno);
;
	MOV	EAX,DWORD [ESI+0C4H]
	MOV	ECX,DWORD [_thisword]
	MOV	ECX,DWORD [ECX+04H]
	MOV	EDI,DWORD [EAX+ECX*4+00H]
	SHL	EDI,01H
	ADD	EDI,DWORD [ESI+098H]
;
; Line 172:	cp += thisword->off1 ;
;
	MOV	EAX,DWORD [_thisword]
	MOV	EAX,DWORD [EAX+08H]
	SHL	EAX,01H
	ADD	EDI,EAX
;
; Line 173:	cp[1].ch =
;
	MOV	EAX,DWORD [EBP-0CH]
	MOVSX	EAX,BYTE [EAX+036H]
	MOVZX	EAX,AL
	OR	EAX,080H
	MOV	BYTE [EDI+02H],AL
;
; Line 175:	cp[2].ch =
;
	MOV	EAX,DWORD [EBP-0CH]
	MOVSX	EAX,BYTE [EAX+037H]
	MOVZX	EAX,AL
	OR	EAX,080H
	MOV	BYTE [EDI+04H],AL
;
; Line 177:	rtn = DefaultWndProc(wnd, PAINT, p1, p2);
;
	MOV	EAX,DWORD [ESI+00H]
	IMUL	EAX,BYTE 0CH
	CMP	DWORD [EAX+04H+_classdefs+00H],BYTE 00H
	JNE	SHORT	L_124
	PUSH	DWORD [EBP+010H]
	PUSH	EBX
	PUSH	BYTE 09H
	PUSH	ESI
	MOV	EAX,DWORD [ESI+00H]
	IMUL	EAX,BYTE 0CH
	MOV	EAX,DWORD [EAX+_classdefs+00H]
	IMUL	EAX,BYTE 0CH
	CALL	DWORD [EAX+04H+_classdefs+00H]
	ADD	ESP,BYTE 010H
	JMP	SHORT	L_125
L_124:
	PUSH	DWORD [EBP+010H]
	PUSH	EBX
	PUSH	BYTE 09H
	PUSH	ESI
	MOV	EAX,DWORD [ESI+00H]
	IMUL	EAX,BYTE 0CH
	CALL	DWORD [EAX+04H+_classdefs+00H]
	ADD	ESP,BYTE 010H
L_125:
	MOV	DWORD [EBP-04H],EAX
;
; Line 178:	cp[1].ch =
;
	MOV	EAX,DWORD [EBP-0CH]
	MOVSX	EAX,BYTE [EAX+03AH]
	MOVZX	EAX,AL
	OR	EAX,080H
	MOV	BYTE [EDI+02H],AL
;
; Line 180:	cp[2].ch =
;
	MOV	EAX,DWORD [EBP-0CH]
	MOVSX	EAX,BYTE [EAX+03BH]
	MOVZX	EAX,AL
	OR	EAX,080H
	MOV	BYTE [EDI+04H],AL
;
; Line 182:	return rtn;
;
	MOV	EAX,DWORD [EBP-04H]
	JMP	SHORT	L_120
L_122:
;
; Line 184:	return DefaultWndProc(wnd, PAINT, p1, p2);
;
	MOV	EAX,DWORD [ESI+00H]
	IMUL	EAX,BYTE 0CH
	CMP	DWORD [EAX+04H+_classdefs+00H],BYTE 00H
	JNE	SHORT	L_126
	PUSH	DWORD [EBP+010H]
	PUSH	EBX
	PUSH	BYTE 09H
	PUSH	ESI
	MOV	EAX,DWORD [ESI+00H]
	IMUL	EAX,BYTE 0CH
	MOV	EAX,DWORD [EAX+_classdefs+00H]
	IMUL	EAX,BYTE 0CH
	CALL	DWORD [EAX+04H+_classdefs+00H]
	ADD	ESP,BYTE 010H
	JMP	SHORT	L_127
L_126:
	PUSH	DWORD [EBP+010H]
	PUSH	EBX
	PUSH	BYTE 09H
	PUSH	ESI
	MOV	EAX,DWORD [ESI+00H]
	IMUL	EAX,BYTE 0CH
	CALL	DWORD [EAX+04H+_classdefs+00H]
	ADD	ESP,BYTE 010H
L_127:
L_120:
	POP	EDI
	POP	ESI
	POP	EBX
	MOV	ESP,EBP
	POP	EBP
	RET
;
; Line 188:	static int LeftButtonMsg(WINDOW wnd, PARAM p1, PARAM p2)
;
_LeftButtonMsg:
	PUSH	EBP
	MOV	EBP,ESP
	SUB	ESP,BYTE 010H
	PUSH	EBX
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,DWORD [EBP+08H]
L_129:
;
; Line 189:	{
;
;
; Line 192:	rtn = DefaultWndProc(wnd, LEFT_BUTTON, p1, p2);
;
	MOV	EAX,DWORD [ESI+00H]
	IMUL	EAX,BYTE 0CH
	CMP	DWORD [EAX+04H+_classdefs+00H],BYTE 00H
	JNE	SHORT	L_130
	PUSH	DWORD [EBP+010H]
	PUSH	DWORD [EBP+0CH]
	PUSH	BYTE 024H
	PUSH	ESI
	MOV	EAX,DWORD [ESI+00H]
	IMUL	EAX,BYTE 0CH
	MOV	EAX,DWORD [EAX+_classdefs+00H]
	IMUL	EAX,BYTE 0CH
	CALL	DWORD [EAX+04H+_classdefs+00H]
	ADD	ESP,BYTE 010H
	JMP	SHORT	L_131
L_130:
	PUSH	DWORD [EBP+010H]
	PUSH	DWORD [EBP+0CH]
	PUSH	BYTE 024H
	PUSH	ESI
	MOV	EAX,DWORD [ESI+00H]
	IMUL	EAX,BYTE 0CH
	CALL	DWORD [EAX+04H+_classdefs+00H]
	ADD	ESP,BYTE 010H
L_131:
	MOV	DWORD [EBP-0CH],EAX
;
; Line 193:	mx = (int)p1 - GetClientLeft(wnd);
;
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,04000H
	JE	SHORT	L_132
	MOV	EAX,01H
	JMP	SHORT	L_133
L_132:
	MOV	EAX,00H
L_133:
	ADD	EAX,DWORD [ESI+0CH]
	MOV	ECX,DWORD [EBP+0CH]
	SUB	ECX,EAX
	MOV	DWORD [EBP-08H],ECX
;
; Line 194:	my = (int)p2 - GetClientTop(wnd);
;
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_134
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,BYTE 08H
	JE	SHORT	L_134
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,010000H
	JE	SHORT	L_134
	MOV	EAX,03H
	JMP	SHORT	L_135
L_134:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_139
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,BYTE 08H
	JNE	SHORT	L_138
L_139:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_136
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,010000H
	JE	SHORT	L_136
L_138:
	MOV	EAX,02H
	JMP	SHORT	L_137
L_136:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,014108H
	JE	SHORT	L_140
	MOV	EAX,01H
	JMP	SHORT	L_141
L_140:
	MOV	EAX,00H
L_141:
L_137:
L_135:
	ADD	EAX,DWORD [ESI+010H]
	MOV	ECX,DWORD [EBP+010H]
	SUB	ECX,EAX
	MOV	DWORD [EBP-04H],ECX
;
; Line 195:	my += wnd->wtop;
;
	MOV	EAX,DWORD [ESI+094H]
	ADD	DWORD [EBP-04H],EAX
;
; Line 196:	thisword = KeyWords;
;
	MOV	DWORD [_thisword],DWORD _KeyWords
	MOV	EBX,00H
	JMP	SHORT	L_144
L_142:
;
; Line 198:	if (my == thisword->lineno)    {
;
	MOV	EAX,DWORD [_thisword]
	MOV	ECX,DWORD [EBP-04H]
	CMP	ECX,DWORD [EAX+04H]
	JNE	SHORT	L_146
;
; Line 199:	if (mx >= thisword->off2 &&
;
	MOV	EAX,DWORD [_thisword]
	MOV	ECX,DWORD [EBP-08H]
	CMP	ECX,DWORD [EAX+0CH]
	JL	SHORT	L_148
	MOV	EAX,DWORD [_thisword]
	MOV	ECX,DWORD [EBP-08H]
	CMP	ECX,DWORD [EAX+010H]
	JGE	SHORT	L_148
;
; Line 201:	SendMessage(wnd, PAINT, 0, 0);
;
	PUSH	BYTE 00H
	PUSH	BYTE 00H
	PUSH	BYTE 09H
	PUSH	ESI
	CALL	_SendMessage
	ADD	ESP,BYTE 010H
;
; Line 202:	if (thisword->isDefinition)    {
;
	MOV	EAX,DWORD [_thisword]
	CMP	BYTE [EAX+014H],BYTE 00H
	JE	SHORT	L_150
;
; Line 203:	WINDOW pwnd = GetParent(wnd);
;
	MOV	EDI,DWORD [ESI+03CH]
;
; Line 204:	if (pwnd != NULL)
;
	TEST	EDI,EDI
	JE	SHORT	L_152
;
; Line 205:	DisplayDefinition(GetParent(pwnd),
;
	MOV	EAX,DWORD [_thisword]
	MOV	EAX,DWORD [EAX+00H]
	PUSH	DWORD [EAX+00H]
	PUSH	DWORD [EDI+03CH]
	CALL	_DisplayDefinition
	ADD	ESP,BYTE 08H
L_152:
L_150:
;
; Line 208:	break;
;
	JMP	SHORT	L_145
L_148:
L_146:
;
; Line 211:	thisword++;
;
	ADD	DWORD [_thisword],BYTE 015H
;
; Line 197:	for (i = 0; i < keywordcount; i++)    {
;
L_143:
	INC	EBX
L_144:
	CMP	EBX,DWORD [_keywordcount]
	JL	SHORT	L_142
L_145:
;
; Line 213:	if (i == keywordcount)
;
	CMP	EBX,DWORD [_keywordcount]
	JNE	SHORT	L_154
;
; Line 214:	thisword = NULL;
;
	MOV	DWORD [_thisword],00H
L_154:
;
; Line 215:	return rtn;
;
	MOV	EAX,DWORD [EBP-0CH]
L_128:
	POP	EDI
	POP	ESI
	POP	EBX
	MOV	ESP,EBP
	POP	EBP
	RET
[GLOBAL	_HelpTextProc]
;
; Line 219:	int HelpTextProc(WINDOW wnd, MESSAGE msg, PARAM p1, PARAM p2)
;
_HelpTextProc:
	PUSH	EBP
	MOV	EBP,ESP
	PUSH	EBX
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,DWORD [EBP+08H]
	MOV	EBX,DWORD [EBP+010H]
	MOV	EDI,DWORD _classdefs
L_157:
;
; Line 220:	{
;
;
; Line 221:	switch (msg)    {
;
	MOV	EAX,DWORD [EBP+0CH]
	CMP	EAX,BYTE 09H
	JE	SHORT	L_161
	CMP	EAX,BYTE 015H
	JE	SHORT	L_160
	CMP	EAX,BYTE 024H
	JE	SHORT	L_162
	CMP	EAX,BYTE 025H
	JE	SHORT	L_163
	JMP	SHORT	L_159
L_160:
;
; Line 223:	break;
;
	JMP	SHORT	L_158
L_161:
;
; Line 225:	return PaintMsg(wnd, p1, p2);
;
	PUSH	DWORD [EBP+014H]
	PUSH	EBX
	PUSH	ESI
	CALL	_PaintMsg
	ADD	ESP,BYTE 0CH
	JMP	SHORT	L_156
L_162:
;
; Line 227:	return LeftButtonMsg(wnd, p1, p2);
;
	PUSH	DWORD [EBP+014H]
	PUSH	EBX
	PUSH	ESI
	CALL	_LeftButtonMsg
	ADD	ESP,BYTE 0CH
	JMP	SHORT	L_156
L_163:
;
; Line 229:	PostMessage(wnd, KEYBOARD, '\r', 0);
;
	PUSH	BYTE 00H
	PUSH	BYTE 0DH
	PUSH	BYTE 015H
	PUSH	ESI
	CALL	_PostMessage
	ADD	ESP,BYTE 010H
;
; Line 230:	break;
;
	JMP	SHORT	L_158
L_159:
;
; Line 232:	break;
;
	JMP	SHORT	L_158
L_158:
;
; Line 234:	return DefaultWndProc(wnd, msg, p1, p2);
;
	MOV	EAX,DWORD [ESI+00H]
	IMUL	EAX,BYTE 0CH
	LEA	EAX,[EDI+EAX+00H]
	CMP	DWORD [EAX+04H],BYTE 00H
	JNE	SHORT	L_164
	PUSH	DWORD [EBP+014H]
	PUSH	EBX
	MOVSX	EAX,WORD [EBP+0CH]
	PUSH	EAX
	PUSH	ESI
	MOV	EAX,DWORD [ESI+00H]
	IMUL	EAX,BYTE 0CH
	MOV	EAX,DWORD [EDI+EAX+00H]
	IMUL	EAX,BYTE 0CH
	LEA	EAX,[EDI+EAX+00H]
	CALL	DWORD [EAX+04H]
	ADD	ESP,BYTE 010H
	JMP	SHORT	L_165
L_164:
	PUSH	DWORD [EBP+014H]
	PUSH	EBX
	MOVSX	EAX,WORD [EBP+0CH]
	PUSH	EAX
	PUSH	ESI
	MOV	EAX,DWORD [ESI+00H]
	IMUL	EAX,BYTE 0CH
	LEA	EAX,[EDI+EAX+00H]
	CALL	DWORD [EAX+04H]
	ADD	ESP,BYTE 010H
L_165:
L_156:
	POP	EDI
	POP	ESI
	POP	EBX
	POP	EBP
	RET
;
; Line 238:	static void ReadHelp(WINDOW wnd)
;
_ReadHelp:
	PUSH	EBP
	MOV	EBP,ESP
	SUB	ESP,BYTE 068H
	PUSH	EBX
	PUSH	ESI
	PUSH	EDI
L_167:
;
; Line 239:	{
;
;
; Line 240:	WINDOW cwnd = ControlWindow(wnd->extension, ID_HELPTEXT);
;
	PUSH	BYTE 048H
	MOV	EAX,DWORD [EBP+08H]
	PUSH	DWORD [EAX+06CH]
	CALL	_ControlWindow
	ADD	ESP,BYTE 08H
	MOV	ESI,EAX
;
; Line 241:	int linectr = 0;
;
	MOV	DWORD [EBP-04H],00H
;
; Line 242:	if (cwnd == NULL)
;
	TEST	ESI,ESI
	JE	NEAR	L_166
;
; Line 243:	return;
;
L_168:
;
; Line 244:	thisword = KeyWords;
;
	MOV	DWORD [_thisword],DWORD _KeyWords
;
; Line 245:	keywordcount = 0;
;
	MOV	DWORD [_keywordcount],00H
;
; Line 246:	cwnd->wndproc = HelpTextProc;
;
	MOV	DWORD [ESI+08H],DWORD _HelpTextProc
;
; Line 247:	SendMessage(cwnd, CLEARTEXT, 0, 0);
;
	PUSH	BYTE 00H
	PUSH	BYTE 00H
	PUSH	BYTE 033H
	PUSH	ESI
	CALL	_SendMessage
	ADD	ESP,BYTE 010H
	JMP	NEAR	L_170
L_172:
;
; Line 250:	unsigned char *cp = hline, *cp1;
;
	MOV	EDI,DWORD _hline
;
; Line 251:	int colorct = 0;
;
	MOV	DWORD [EBP-0CH],00H
;
; Line 252:	if (GetHelpLine(hline) == NULL)
;
	PUSH	DWORD _hline
	CALL	_GetHelpLine
	POP	ECX
	TEST	EAX,EAX
	JE	NEAR	L_171
;
; Line 253:	break;
;
L_173:
;
; Line 254:	if (*hline == '<')
;
	MOVSX	EAX,BYTE [_hline]
	CMP	EAX,BYTE 03CH
	JE	NEAR	L_171
;
; Line 255:	break;
;
L_175:
;
; Line 256:	hline[strlen(hline)-1] = '\0';
;
	PUSH	DWORD _hline
	CALL	_strlen
	POP	ECX
	DEC	EAX
	MOV	BYTE [EAX+_hline+00H],00H
	JMP	NEAR	L_177
L_179:
;
; Line 259:	if ((cp = strchr(cp, '[')) != NULL)    {
;
	PUSH	BYTE 05BH
	PUSH	EDI
	CALL	_strchr
	ADD	ESP,BYTE 08H
	MOV	EDI,EAX
	TEST	EAX,EAX
	JE	NEAR	L_180
;
; Line 261:	if (*(cp+1) != '.' && *(cp+1) != '*')    {
;
	MOVZX	EAX,BYTE [EDI+01H]
	CMP	EAX,BYTE 02EH
	JE	SHORT	L_182
	MOVZX	EAX,BYTE [EDI+01H]
	CMP	EAX,BYTE 02AH
	JE	SHORT	L_182
;
; Line 262:	cp++;
;
	INC	EDI
;
; Line 263:	continue;
;
	JMP	NEAR	L_177
L_182:
;
; Line 265:	thisword->lineno = cwnd->wlines;
;
	MOV	EAX,DWORD [_thisword]
	MOV	ECX,DWORD [ESI+090H]
	MOV	DWORD [EAX+04H],ECX
;
; Line 266:	thisword->off1 = (int) (cp - hline);
;
	MOV	EAX,EDI
	SUB	EAX,DWORD _hline
	MOV	ECX,DWORD [_thisword]
	MOV	DWORD [ECX+08H],EAX
;
; Line 267:	thisword->off2 = thisword->off1 - colorct * 4;
;
	MOV	EAX,DWORD [_thisword]
	MOV	ECX,DWORD [EBP-0CH]
	SHL	ECX,02H
	MOV	EAX,DWORD [EAX+08H]
	SUB	EAX,ECX
	MOV	ECX,DWORD [_thisword]
	MOV	DWORD [ECX+0CH],EAX
;
; Line 268:	thisword->isDefinition = *(cp+1) == '*';
;
	MOVZX	EAX,BYTE [EDI+01H]
	CMP	EAX,BYTE 02AH
	SETE	AL
	MOV	ECX,DWORD [_thisword]
	MOV	BYTE [ECX+014H],AL
;
; Line 269:	colorct++;
;
	INC	DWORD [EBP-0CH]
;
; Line 270:	*cp++ = CHANGECOLOR;
;
	MOV	EAX,EDI
	INC	EDI
	MOV	BYTE [EAX+00H],0FCH
;
; Line 271:	*cp++ =
;
	MOV	EAX,DWORD [EBP+08H]
	MOVSX	EAX,BYTE [EAX+03AH]
	MOVZX	EAX,AL
	OR	EAX,080H
	MOV	ECX,EDI
	INC	EDI
	MOV	BYTE [ECX+00H],AL
;
; Line 273:	*cp++ =
;
	MOV	EAX,DWORD [EBP+08H]
	MOVSX	EAX,BYTE [EAX+03BH]
	MOVZX	EAX,AL
	OR	EAX,080H
	MOV	ECX,EDI
	INC	EDI
	MOV	BYTE [ECX+00H],AL
;
; Line 275:	cp1 = cp;
;
	MOV	DWORD [EBP-010H],EDI
;
; Line 276:	if ((cp = strchr(cp, ']')) != NULL)    {
;
	PUSH	BYTE 05DH
	PUSH	EDI
	CALL	_strchr
	ADD	ESP,BYTE 08H
	MOV	EDI,EAX
	TEST	EAX,EAX
	JE	SHORT	L_184
;
; Line 277:	if (thisword != NULL)
;
	CMP	DWORD [_thisword],BYTE 00H
	JE	SHORT	L_186
;
; Line 278:	thisword->off3 =
;
	MOV	EAX,DWORD [_thisword]
	MOV	ECX,EDI
	SUB	ECX,DWORD [EBP-010H]
	ADD	ECX,DWORD [EAX+0CH]
	MOV	EAX,DWORD [_thisword]
	MOV	DWORD [EAX+010H],ECX
L_186:
;
; Line 280:	*cp++ = RESETCOLOR;
;
	MOV	EAX,EDI
	INC	EDI
	MOV	BYTE [EAX+00H],0FDH
L_184:
;
; Line 282:	if ((cp = strchr(cp, '<')) != NULL)    {
;
	PUSH	BYTE 03CH
	PUSH	EDI
	CALL	_strchr
	ADD	ESP,BYTE 08H
	MOV	EDI,EAX
	TEST	EAX,EAX
	JE	SHORT	L_188
;
; Line 283:	char *cp1 = strchr(cp, '>');
;
	PUSH	BYTE 03EH
	PUSH	EDI
	CALL	_strchr
	ADD	ESP,BYTE 08H
	MOV	DWORD [EBP-014H],EAX
;
; Line 284:	if (cp1 != NULL)    {
;
	CMP	DWORD [EBP-014H],BYTE 00H
	JE	SHORT	L_190
;
; Line 286:	int len = (int) (cp1 - cp);
;
	MOV	EAX,DWORD [EBP-014H]
	SUB	EAX,EDI
	MOV	DWORD [EBP-018H],EAX
;
; Line 287:	memset(hname, 0, 80);
;
	PUSH	BYTE 050H
	PUSH	BYTE 00H
	LEA	EAX,[EBP-068H]
	PUSH	EAX
	CALL	_memset
	ADD	ESP,BYTE 0CH
;
; Line 288:	strncpy(hname, cp+1, len-1);
;
	MOV	EAX,DWORD [EBP-018H]
	DEC	EAX
	PUSH	EAX
	MOV	EAX,EDI
	INC	EAX
	PUSH	EAX
	LEA	EAX,[EBP-068H]
	PUSH	EAX
	CALL	_strncpy
	ADD	ESP,BYTE 0CH
;
; Line 289:	thisword->hkey = FindHelp(hname);
;
	LEA	EAX,[EBP-068H]
	PUSH	EAX
	CALL	_FindHelp
	POP	ECX
	MOV	ECX,DWORD [_thisword]
	MOV	DWORD [ECX+00H],EAX
;
; Line 290:	memmove(cp, cp1+1, strlen(cp1));
;
	PUSH	DWORD [EBP-014H]
	CALL	_strlen
	POP	ECX
	PUSH	EAX
	MOV	EAX,DWORD [EBP-014H]
	INC	EAX
	PUSH	EAX
	PUSH	EDI
	CALL	_memmove
	ADD	ESP,BYTE 0CH
L_190:
L_188:
;
; Line 293:	thisword++;
;
	ADD	DWORD [_thisword],BYTE 015H
;
; Line 294:	keywordcount++;
;
	INC	DWORD [_keywordcount]
L_180:
L_177:
;
; Line 258:	while (cp != NULL)    {
;
	TEST	EDI,EDI
	JNE	NEAR	L_179
L_178:
;
; Line 297:	PutItemText(wnd, ID_HELPTEXT, hline);
;
	PUSH	DWORD _hline
	PUSH	BYTE 048H
	PUSH	DWORD [EBP+08H]
	CALL	_PutItemText
	ADD	ESP,BYTE 0CH
;
; Line 299:	if (++linectr == ClientHeight(cwnd))	{
;
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_194
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,BYTE 08H
	JE	SHORT	L_194
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,010000H
	JE	SHORT	L_194
	MOV	EAX,03H
	JMP	SHORT	L_195
L_194:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_199
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,BYTE 08H
	JNE	SHORT	L_198
L_199:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_196
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,010000H
	JE	SHORT	L_196
L_198:
	MOV	EAX,02H
	JMP	SHORT	L_197
L_196:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,014108H
	JE	SHORT	L_200
	MOV	EAX,01H
	JMP	SHORT	L_201
L_200:
	MOV	EAX,00H
L_201:
L_197:
L_195:
	MOV	ECX,DWORD [ESI+01CH]
	SUB	ECX,EAX
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,08000H
	JE	SHORT	L_202
	MOV	EAX,01H
	JMP	SHORT	L_203
L_202:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,04000H
	JE	SHORT	L_204
	MOV	EAX,01H
	JMP	SHORT	L_205
L_204:
	MOV	EAX,00H
L_205:
L_203:
	SUB	ECX,EAX
	INC	DWORD [EBP-04H]
	CMP	DWORD [EBP-04H],ECX
	JNE	SHORT	L_192
;
; Line 300:	struct keywords *holdthis = thisword;
;
	MOV	EBX,DWORD [_thisword]
;
; Line 301:	thisword = NULL;
;
	MOV	DWORD [_thisword],00H
;
; Line 302:	SendMessage(cwnd, PAINT, 0, 0);
;
	PUSH	BYTE 00H
	PUSH	BYTE 00H
	PUSH	BYTE 09H
	PUSH	ESI
	CALL	_SendMessage
	ADD	ESP,BYTE 010H
;
; Line 303:	thisword = holdthis;
;
	MOV	DWORD [_thisword],EBX
L_192:
;
; Line 305:	if (linectr > ClientHeight(cwnd) &&
;
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_208
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,BYTE 08H
	JE	SHORT	L_208
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,010000H
	JE	SHORT	L_208
	MOV	EAX,03H
	JMP	SHORT	L_209
L_208:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_213
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,BYTE 08H
	JNE	SHORT	L_212
L_213:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_210
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,010000H
	JE	SHORT	L_210
L_212:
	MOV	EAX,02H
	JMP	SHORT	L_211
L_210:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,014108H
	JE	SHORT	L_214
	MOV	EAX,01H
	JMP	SHORT	L_215
L_214:
	MOV	EAX,00H
L_215:
L_211:
L_209:
	MOV	ECX,DWORD [ESI+01CH]
	SUB	ECX,EAX
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,08000H
	JE	SHORT	L_216
	MOV	EAX,01H
	JMP	SHORT	L_217
L_216:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,04000H
	JE	SHORT	L_218
	MOV	EAX,01H
	JMP	SHORT	L_219
L_218:
	MOV	EAX,00H
L_219:
L_217:
	SUB	ECX,EAX
	CMP	DWORD [EBP-04H],ECX
	JLE	SHORT	L_206
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,BYTE 010H
	JNE	SHORT	L_206
;
; Line 307:	AddAttribute(cwnd, VSCROLLBAR);
;
	BTS	DWORD [ESI+054H],04H
;
; Line 308:	SendMessage(cwnd, BORDER, 0, 0);
;
	PUSH	BYTE 00H
	PUSH	BYTE 00H
	PUSH	BYTE 0AH
	PUSH	ESI
	CALL	_SendMessage
	ADD	ESP,BYTE 010H
L_206:
L_170:
;
; Line 249:	while (TRUE)    {
;
	JMP	NEAR	L_172
L_171:
;
; Line 311:	thisword = NULL;
;
	MOV	DWORD [_thisword],00H
;
; Line 312:	}
;
L_166:
	POP	EDI
	POP	ESI
	POP	EBX
	MOV	ESP,EBP
	POP	EBP
	RET
;
; Line 315:	static int HelpLength(char *s)
;
_HelpLength:
	PUSH	EBP
	MOV	EBP,ESP
	PUSH	EBX
	PUSH	ESI
	PUSH	EDI
L_221:
;
; Line 316:	{
;
;
; Line 317:	int len = strlen(s);
;
	PUSH	DWORD [EBP+08H]
	CALL	_strlen
	POP	ECX
	MOV	EDI,EAX
;
; Line 318:	char *cp = strchr(s, '[');
;
	PUSH	BYTE 05BH
	PUSH	DWORD [EBP+08H]
	CALL	_strchr
	ADD	ESP,BYTE 08H
	MOV	EBX,EAX
	JMP	SHORT	L_222
L_224:
;
; Line 320:	len -= 4;
;
	SUB	EDI,BYTE 04H
;
; Line 321:	cp = strchr(cp+1, '[');
;
	PUSH	BYTE 05BH
	MOV	EAX,EBX
	INC	EAX
	PUSH	EAX
	CALL	_strchr
	ADD	ESP,BYTE 08H
	MOV	EBX,EAX
L_222:
;
; Line 319:	while (cp != NULL)    {
;
	TEST	EBX,EBX
	JNE	SHORT	L_224
L_223:
;
; Line 323:	cp = strchr(s, '<');
;
	PUSH	BYTE 03CH
	PUSH	DWORD [EBP+08H]
	CALL	_strchr
	ADD	ESP,BYTE 08H
	MOV	EBX,EAX
	JMP	SHORT	L_225
L_227:
;
; Line 325:	char *cp1 = strchr(cp, '>');
;
	PUSH	BYTE 03EH
	PUSH	EBX
	CALL	_strchr
	ADD	ESP,BYTE 08H
	MOV	ESI,EAX
;
; Line 326:	if (cp1 != NULL)
;
	TEST	ESI,ESI
	JE	SHORT	L_228
;
; Line 327:	len -= (int) (cp1-cp)+1;
;
	MOV	EAX,ESI
	SUB	EAX,EBX
	INC	EAX
	SUB	EDI,EAX
L_228:
;
; Line 328:	cp = strchr(cp1, '<');
;
	PUSH	BYTE 03CH
	PUSH	ESI
	CALL	_strchr
	ADD	ESP,BYTE 08H
	MOV	EBX,EAX
L_225:
;
; Line 324:	while (cp != NULL)    {
;
	TEST	EBX,EBX
	JNE	SHORT	L_227
L_226:
;
; Line 330:	return len;
;
	MOV	EAX,EDI
L_220:
	POP	EDI
	POP	ESI
	POP	EBX
	POP	EBP
	RET
[GLOBAL	_LoadHelpFile]
;
; Line 334:	void LoadHelpFile(char *fname)
;
_LoadHelpFile:
	PUSH	EBP
	MOV	EBP,ESP
	SUB	ESP,BYTE 0CH
	PUSH	EBX
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,DWORD _helpfp
	MOV	EDI,DWORD _FirstHelp
L_232:
;
; Line 335:	{
;
;
; Line 338:	if (Helping)
;
	CMP	DWORD [_Helping],BYTE 00H
	JNE	NEAR	L_231
;
; Line 339:	return;
;
L_233:
;
; Line 340:	UnLoadHelpFile();
;
	CALL	_UnLoadHelpFile
;
; Line 341:	if ((helpfp = OpenHelpFile(fname, "rb")) == NULL)
;
	PUSH	DWORD L_230
	PUSH	DWORD [EBP+08H]
	CALL	_OpenHelpFile
	ADD	ESP,BYTE 08H
	MOV	DWORD [ESI+00H],EAX
	TEST	EAX,EAX
	JE	NEAR	L_231
;
; Line 342:	return;
;
L_235:
;
; Line 343:	strcpy(HelpFileName, fname);
;
	PUSH	DWORD [EBP+08H]
	PUSH	DWORD _HelpFileName
	CALL	_strcpy
	ADD	ESP,BYTE 08H
;
; Line 344:	fseek(helpfp, - (long) sizeof(long), SEEK_END);
;
	PUSH	BYTE 02H
	PUSH	BYTE 0FFFFFFFCH
	PUSH	DWORD [ESI+00H]
	CALL	_fseek
	ADD	ESP,BYTE 0CH
;
; Line 345:	fread(&where, sizeof(long), 1, helpfp);
;
	PUSH	DWORD [ESI+00H]
	PUSH	BYTE 01H
	PUSH	BYTE 04H
	LEA	EAX,[EBP-04H]
	PUSH	EAX
	CALL	_fread
	ADD	ESP,BYTE 010H
;
; Line 346:	fseek(helpfp, where, SEEK_SET);
;
	PUSH	BYTE 00H
	PUSH	DWORD [EBP-04H]
	PUSH	DWORD [ESI+00H]
	CALL	_fseek
	ADD	ESP,BYTE 0CH
;
; Line 347:	fread(&HelpCount, sizeof(int), 1, helpfp);
;
	PUSH	DWORD [ESI+00H]
	PUSH	BYTE 01H
	PUSH	BYTE 04H
	PUSH	DWORD _HelpCount
	CALL	_fread
	ADD	ESP,BYTE 010H
;
; Line 348:	FirstHelp = DFcalloc(sizeof(struct helps) * HelpCount, 1);
;
	PUSH	BYTE 01H
	MOV	EAX,DWORD [_HelpCount]
	IMUL	EAX,BYTE 022H
	PUSH	EAX
	CALL	_DFcalloc
	ADD	ESP,BYTE 08H
	MOV	DWORD [EDI+00H],EAX
	MOV	EBX,00H
	JMP	NEAR	L_239
L_237:
;
; Line 351:	fread(&len, sizeof(short), 1, helpfp);
;
	PUSH	DWORD [ESI+00H]
	PUSH	BYTE 01H
	PUSH	BYTE 02H
	LEA	EAX,[EBP-0CH]
	PUSH	EAX
	CALL	_fread
	ADD	ESP,BYTE 010H
;
; Line 352:	if (len)	{
;
	CMP	DWORD [EBP-0CH],BYTE 00H
	JE	SHORT	L_241
;
; Line 353:	(FirstHelp+i)->hname = DFcalloc(len+1, 1);
;
	PUSH	BYTE 01H
	MOV	EAX,DWORD [EBP-0CH]
	INC	EAX
	PUSH	EAX
	CALL	_DFcalloc
	ADD	ESP,BYTE 08H
	MOV	ECX,DWORD [EDI+00H]
	MOV	EDX,EBX
	IMUL	EDX,BYTE 022H
	MOV	DWORD [ECX+EDX+00H],EAX
;
; Line 354:	fread((FirstHelp+i)->hname, len+1, 1, helpfp);
;
	PUSH	DWORD [ESI+00H]
	PUSH	BYTE 01H
	MOV	EAX,DWORD [EBP-0CH]
	INC	EAX
	PUSH	EAX
	MOV	EAX,DWORD [EDI+00H]
	MOV	ECX,EBX
	IMUL	ECX,BYTE 022H
	PUSH	DWORD [EAX+ECX+00H]
	CALL	_fread
	ADD	ESP,BYTE 010H
L_241:
;
; Line 356:	fread(&len, sizeof(short), 1, helpfp);
;
	PUSH	DWORD [ESI+00H]
	PUSH	BYTE 01H
	PUSH	BYTE 02H
	LEA	EAX,[EBP-0CH]
	PUSH	EAX
	CALL	_fread
	ADD	ESP,BYTE 010H
;
; Line 357:	if (len)	{
;
	CMP	DWORD [EBP-0CH],BYTE 00H
	JE	SHORT	L_243
;
; Line 358:	(FirstHelp+i)->comment = DFcalloc(len+1, 1);
;
	PUSH	BYTE 01H
	MOV	EAX,DWORD [EBP-0CH]
	INC	EAX
	PUSH	EAX
	CALL	_DFcalloc
	ADD	ESP,BYTE 08H
	MOV	ECX,DWORD [EDI+00H]
	MOV	EDX,EBX
	IMUL	EDX,BYTE 022H
	LEA	ECX,[ECX+EDX+00H]
	MOV	DWORD [ECX+04H],EAX
;
; Line 359:	fread((FirstHelp+i)->comment, len+1, 1, helpfp);
;
	PUSH	DWORD [ESI+00H]
	PUSH	BYTE 01H
	MOV	EAX,DWORD [EBP-0CH]
	INC	EAX
	PUSH	EAX
	MOV	EAX,DWORD [EDI+00H]
	MOV	ECX,EBX
	IMUL	ECX,BYTE 022H
	LEA	EAX,[EAX+ECX+00H]
	PUSH	DWORD [EAX+04H]
	CALL	_fread
	ADD	ESP,BYTE 010H
L_243:
;
; Line 361:	fread(&(FirstHelp+i)->hptr, sizeof(short)*5+sizeof(long), 1, helpfp);
;
	PUSH	DWORD [ESI+00H]
	PUSH	BYTE 01H
	PUSH	BYTE 0EH
	MOV	EAX,EBX
	IMUL	EAX,BYTE 022H
	ADD	EAX,DWORD [EDI+00H]
	ADD	EAX,BYTE 08H
	PUSH	EAX
	CALL	_fread
	ADD	ESP,BYTE 010H
;
; Line 349:	for (i = 0; i < HelpCount; i++)	{
;
L_238:
	INC	EBX
L_239:
	CMP	EBX,DWORD [_HelpCount]
	JL	NEAR	L_237
L_240:
;
; Line 363:	fclose(helpfp);
;
	PUSH	DWORD [ESI+00H]
	CALL	_fclose
	POP	ECX
;
; Line 364:	helpfp = NULL;
;
	MOV	DWORD [ESI+00H],00H
;
; Line 365:	}
;
L_231:
	POP	EDI
	POP	ESI
	POP	EBX
	MOV	ESP,EBP
	POP	EBP
	RET
[GLOBAL	_UnLoadHelpFile]
;
; Line 368:	void UnLoadHelpFile(void)
;
_UnLoadHelpFile:
	PUSH	EBX
	PUSH	ESI
	MOV	ESI,DWORD _FirstHelp
L_246:
;
; Line 369:	{
;
	MOV	EBX,00H
	JMP	SHORT	L_249
L_247:
;
; Line 372:	free((FirstHelp+i)->comment);
;
	MOV	EAX,DWORD [ESI+00H]
	MOV	ECX,EBX
	IMUL	ECX,BYTE 022H
	LEA	EAX,[EAX+ECX+00H]
	PUSH	DWORD [EAX+04H]
	CALL	_free
	POP	ECX
;
; Line 373:	free((FirstHelp+i)->hname);
;
	MOV	EAX,DWORD [ESI+00H]
	MOV	ECX,EBX
	IMUL	ECX,BYTE 022H
	PUSH	DWORD [EAX+ECX+00H]
	CALL	_free
	POP	ECX
;
; Line 371:	for (i = 0; i < HelpCount; i++)	{
;
L_248:
	INC	EBX
L_249:
	CMP	EBX,DWORD [_HelpCount]
	JL	SHORT	L_247
L_250:
;
; Line 375:	free(FirstHelp);
;
	PUSH	DWORD [ESI+00H]
	CALL	_free
	POP	ECX
;
; Line 376:	FirstHelp = NULL;
;
	MOV	DWORD [ESI+00H],00H
;
; Line 377:	free(HelpTree);
;
	PUSH	DWORD [_HelpTree]
	CALL	_free
	POP	ECX
;
; Line 378:	HelpTree = NULL;
;
	MOV	DWORD [_HelpTree],00H
;
; Line 379:	}
;
L_245:
	POP	ESI
	POP	EBX
	RET
;
; Line 381:	static void BuildHelpBox(WINDOW wnd)
;
_BuildHelpBox:
	PUSH	EBP
	MOV	EBP,ESP
	SUB	ESP,BYTE 08H
	PUSH	EBX
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,DWORD _HelpBox
	MOV	EDI,DWORD _ThisHelp
L_252:
;
; Line 382:	{
;
;
; Line 386:	SeekHelpLine(ThisHelp->hptr, ThisHelp->bit);
;
	MOV	EAX,DWORD [EDI+00H]
	MOVSX	EAX,WORD [EAX+0CH]
	PUSH	EAX
	MOV	EAX,DWORD [EDI+00H]
	PUSH	DWORD [EAX+08H]
	CALL	_SeekHelpLine
	ADD	ESP,BYTE 08H
;
; Line 388:	GetHelpLine(hline);
;
	PUSH	DWORD _hline
	CALL	_GetHelpLine
	POP	ECX
;
; Line 389:	hline[strlen(hline)-1] = '\0';
;
	PUSH	DWORD _hline
	CALL	_strlen
	POP	ECX
	DEC	EAX
	MOV	BYTE [EAX+_hline+00H],00H
;
; Line 390:	free(HelpBox.dwnd.title);
;
	PUSH	DWORD [ESI+04H]
	CALL	_free
	POP	ECX
;
; Line 391:	HelpBox.dwnd.title = DFmalloc(strlen(hline)+1);
;
	PUSH	DWORD _hline
	CALL	_strlen
	POP	ECX
	INC	EAX
	PUSH	EAX
	CALL	_DFmalloc
	POP	ECX
	MOV	DWORD [ESI+04H],EAX
;
; Line 392:	strcpy(HelpBox.dwnd.title, hline);
;
	PUSH	DWORD _hline
	PUSH	DWORD [ESI+04H]
	CALL	_strcpy
	ADD	ESP,BYTE 08H
;
; Line 394:	HelpBox.dwnd.h = min(ThisHelp->hheight, MAXHEIGHT)+7;
;
	CALL	_isVGA
	TEST	EAX,EAX
	JNE	SHORT	L_257
	CALL	_isEGA
	TEST	EAX,EAX
	JE	SHORT	L_255
L_257:
	MOV	EAX,084H
	MOVZX	ECX,WORD [___seg0040]
	MOV	EDX,ECX
	MOV	FS,DX
	MOVSX	EAX,BYTE [FS:EAX+00H]
	INC	EAX
	JMP	SHORT	L_256
L_255:
	MOV	EAX,019H
L_256:
	SUB	EAX,BYTE 0AH
	MOV	ECX,DWORD [EDI+00H]
	MOVSX	ECX,WORD [ECX+0EH]
	CMP	ECX,EAX
	JGE	SHORT	L_253
	MOV	EAX,DWORD [EDI+00H]
	MOVSX	EAX,WORD [EAX+0EH]
	JMP	SHORT	L_254
L_253:
	CALL	_isVGA
	TEST	EAX,EAX
	JNE	SHORT	L_260
	CALL	_isEGA
	TEST	EAX,EAX
	JE	SHORT	L_258
L_260:
	MOV	EAX,084H
	MOVZX	ECX,WORD [___seg0040]
	MOV	EDX,ECX
	MOV	FS,DX
	MOVSX	EAX,BYTE [FS:EAX+00H]
	INC	EAX
	JMP	SHORT	L_259
L_258:
	MOV	EAX,019H
L_259:
	SUB	EAX,BYTE 0AH
L_254:
	ADD	EAX,BYTE 07H
	MOV	DWORD [ESI+010H],EAX
;
; Line 395:	HelpBox.dwnd.w = max(45, ThisHelp->hwidth+6);
;
	MOV	EAX,DWORD [EDI+00H]
	MOVSX	EAX,WORD [EAX+010H]
	ADD	EAX,BYTE 06H
	CMP	EAX,BYTE 02DH
	JGE	SHORT	L_261
	MOV	EAX,02DH
	JMP	SHORT	L_262
L_261:
	MOV	EAX,DWORD [EDI+00H]
	MOVSX	EAX,WORD [EAX+010H]
	ADD	EAX,BYTE 06H
L_262:
	MOV	DWORD [ESI+014H],EAX
;
; Line 397:	if (wnd != NULL)
;
	CMP	DWORD [EBP+08H],BYTE 00H
	JE	SHORT	L_263
;
; Line 398:	BestFit(wnd, &HelpBox.dwnd);
;
	MOV	EAX,ESI
	ADD	EAX,BYTE 04H
	PUSH	EAX
	PUSH	DWORD [EBP+08H]
	CALL	_BestFit
	ADD	ESP,BYTE 08H
L_263:
;
; Line 400:	HelpBox.ctl[0].dwnd.w = max(40, ThisHelp->hwidth+2);
;
	MOV	EAX,DWORD [EDI+00H]
	MOVSX	EAX,WORD [EAX+010H]
	ADD	EAX,BYTE 02H
	CMP	EAX,BYTE 028H
	JGE	SHORT	L_265
	MOV	EAX,028H
	JMP	SHORT	L_266
L_265:
	MOV	EAX,DWORD [EDI+00H]
	MOVSX	EAX,WORD [EAX+010H]
	ADD	EAX,BYTE 02H
L_266:
	MOV	DWORD [ESI+028H],EAX
;
; Line 401:	HelpBox.ctl[0].dwnd.h =
;
	CALL	_isVGA
	TEST	EAX,EAX
	JNE	SHORT	L_271
	CALL	_isEGA
	TEST	EAX,EAX
	JE	SHORT	L_269
L_271:
	MOV	EAX,084H
	MOVZX	ECX,WORD [___seg0040]
	MOV	EDX,ECX
	MOV	FS,DX
	MOVSX	EAX,BYTE [FS:EAX+00H]
	INC	EAX
	JMP	SHORT	L_270
L_269:
	MOV	EAX,019H
L_270:
	SUB	EAX,BYTE 0AH
	MOV	ECX,DWORD [EDI+00H]
	MOVSX	ECX,WORD [ECX+0EH]
	CMP	ECX,EAX
	JGE	SHORT	L_267
	MOV	EAX,DWORD [EDI+00H]
	MOVSX	EAX,WORD [EAX+0EH]
	JMP	SHORT	L_268
L_267:
	CALL	_isVGA
	TEST	EAX,EAX
	JNE	SHORT	L_274
	CALL	_isEGA
	TEST	EAX,EAX
	JE	SHORT	L_272
L_274:
	MOV	EAX,084H
	MOVZX	ECX,WORD [___seg0040]
	MOV	EDX,ECX
	MOV	FS,DX
	MOVSX	EAX,BYTE [FS:EAX+00H]
	INC	EAX
	JMP	SHORT	L_273
L_272:
	MOV	EAX,019H
L_273:
	SUB	EAX,BYTE 0AH
L_268:
	ADD	EAX,BYTE 02H
	MOV	DWORD [ESI+024H],EAX
;
; Line 403:	offset = (HelpBox.dwnd.w-40) / 2;
;
	MOV	EAX,DWORD [ESI+014H]
	SUB	EAX,BYTE 028H
	SAR	EAX,01H
	JNS	SHORT	L_275
	ADC	EAX,BYTE 00H
L_275:
	MOV	DWORD [EBP-04H],EAX
	MOV	EBX,01H
	JMP	NEAR	L_278
L_276:
;
; Line 405:	HelpBox.ctl[i].dwnd.y =
;
	CALL	_isVGA
	TEST	EAX,EAX
	JNE	SHORT	L_284
	CALL	_isEGA
	TEST	EAX,EAX
	JE	SHORT	L_282
L_284:
	MOV	EAX,084H
	MOVZX	ECX,WORD [___seg0040]
	MOV	EDX,ECX
	MOV	FS,DX
	MOVSX	EAX,BYTE [FS:EAX+00H]
	INC	EAX
	JMP	SHORT	L_283
L_282:
	MOV	EAX,019H
L_283:
	SUB	EAX,BYTE 0AH
	MOV	ECX,DWORD [EDI+00H]
	MOVSX	ECX,WORD [ECX+0EH]
	CMP	ECX,EAX
	JGE	SHORT	L_280
	MOV	EAX,DWORD [EDI+00H]
	MOVSX	EAX,WORD [EAX+0EH]
	JMP	SHORT	L_281
L_280:
	CALL	_isVGA
	TEST	EAX,EAX
	JNE	SHORT	L_287
	CALL	_isEGA
	TEST	EAX,EAX
	JE	SHORT	L_285
L_287:
	MOV	EAX,084H
	MOVZX	ECX,WORD [___seg0040]
	MOV	EDX,ECX
	MOV	FS,DX
	MOVSX	EAX,BYTE [FS:EAX+00H]
	INC	EAX
	JMP	SHORT	L_286
L_285:
	MOV	EAX,019H
L_286:
	SUB	EAX,BYTE 0AH
L_281:
	ADD	EAX,BYTE 03H
	MOV	ECX,EBX
	IMUL	ECX,BYTE 030H
	LEA	ECX,[ESI+ECX+018H]
	MOV	DWORD [ECX+08H],EAX
;
; Line 407:	HelpBox.ctl[i].dwnd.x = (i-1) * 10 + offset;
;
	MOV	EAX,EBX
	DEC	EAX
	IMUL	EAX,BYTE 0AH
	ADD	EAX,DWORD [EBP-04H]
	MOV	ECX,EBX
	IMUL	ECX,BYTE 030H
	LEA	ECX,[ESI+ECX+018H]
	MOV	DWORD [ECX+04H],EAX
;
; Line 404:	for (i = 1; i < 5; i++)    {
;
L_277:
	INC	EBX
L_278:
	CMP	EBX,BYTE 05H
	JL	NEAR	L_276
L_279:
;
; Line 410:	if (ThisHelp->nexthlp == -1)
;
	MOV	EAX,DWORD [EDI+00H]
	MOVSX	EAX,WORD [EAX+012H]
	CMP	EAX,BYTE 0FFFFFFFFH
	JNE	SHORT	L_288
;
; Line 411:	DisableButton(&HelpBox, ID_NEXT);
;
	PUSH	BYTE 00H
	PUSH	BYTE 0BH
	PUSH	BYTE 04BH
	PUSH	ESI
	CALL	_ControlSetting
	ADD	ESP,BYTE 010H
	JMP	SHORT	L_289
L_288:
;
; Line 413:	EnableButton(&HelpBox, ID_NEXT);
;
	PUSH	BYTE 01H
	PUSH	BYTE 0BH
	PUSH	BYTE 04BH
	PUSH	ESI
	CALL	_ControlSetting
	ADD	ESP,BYTE 010H
L_289:
;
; Line 414:	if (ThisHelp->prevhlp == -1)
;
	MOV	EAX,DWORD [EDI+00H]
	MOVSX	EAX,WORD [EAX+014H]
	CMP	EAX,BYTE 0FFFFFFFFH
	JNE	SHORT	L_290
;
; Line 415:	DisableButton(&HelpBox, ID_PREV);
;
	PUSH	BYTE 00H
	PUSH	BYTE 0BH
	PUSH	BYTE 04AH
	PUSH	ESI
	CALL	_ControlSetting
	ADD	ESP,BYTE 010H
	JMP	SHORT	L_291
L_290:
;
; Line 417:	EnableButton(&HelpBox, ID_PREV);
;
	PUSH	BYTE 01H
	PUSH	BYTE 0BH
	PUSH	BYTE 04AH
	PUSH	ESI
	CALL	_ControlSetting
	ADD	ESP,BYTE 010H
L_291:
;
; Line 418:	}
;
L_251:
	POP	EDI
	POP	ESI
	POP	EBX
	MOV	ESP,EBP
	POP	EBP
	RET
;
; Line 421:	static void SelectHelp(WINDOW wnd, struct helps *newhelp, BOOL recall)
;
_SelectHelp:
	PUSH	EBP
	MOV	EBP,ESP
	SUB	ESP,BYTE 08H
	PUSH	EBX
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,DWORD [EBP+08H]
L_293:
;
; Line 422:	{
;
;
; Line 423:	if (newhelp != NULL)	{
;
	CMP	DWORD [EBP+0CH],BYTE 00H
	JE	NEAR	L_294
;
; Line 425:	SendMessage(wnd, HIDE_WINDOW, 0, 0);
;
	PUSH	BYTE 00H
	PUSH	BYTE 00H
	PUSH	BYTE 06H
	PUSH	ESI
	CALL	_SendMessage
	ADD	ESP,BYTE 010H
;
; Line 426:	if (recall && stacked < MAXHELPSTACK)
;
	CMP	DWORD [EBP+010H],BYTE 00H
	JE	SHORT	L_296
	CMP	DWORD [_stacked],BYTE 064H
	JGE	SHORT	L_296
;
; Line 427:	HelpStack[stacked++] = ThisHelp-FirstHelp;
;
	MOV	EAX,DWORD [_ThisHelp]
	SUB	EAX,DWORD [_FirstHelp]
	CDQ
	IDIV	DWORD [L_298]
	MOV	ECX,DWORD [_stacked]
	INC	DWORD [_stacked]
	MOV	DWORD [ECX*4+_HelpStack+00H],EAX
L_296:
;
; Line 428:	ThisHelp = newhelp;
;
	MOV	EAX,DWORD [EBP+0CH]
	MOV	DWORD [_ThisHelp],EAX
;
; Line 429:	SendMessage(GetParent(wnd), DISPLAY_HELP, (PARAM) ThisHelp->hname, 0);
;
	PUSH	BYTE 00H
	MOV	EAX,DWORD [_ThisHelp]
	PUSH	DWORD [EAX+00H]
	PUSH	BYTE 04CH
	PUSH	DWORD [ESI+03CH]
	CALL	_SendMessage
	ADD	ESP,BYTE 010H
;
; Line 430:	if (stacked)
;
	CMP	DWORD [_stacked],BYTE 00H
	JE	SHORT	L_299
;
; Line 431:	EnableButton(&HelpBox, ID_BACK);
;
	PUSH	BYTE 01H
	PUSH	BYTE 0BH
	PUSH	BYTE 049H
	PUSH	DWORD _HelpBox
	CALL	_ControlSetting
	ADD	ESP,BYTE 010H
	JMP	SHORT	L_300
L_299:
;
; Line 433:	DisableButton(&HelpBox, ID_BACK);
;
	PUSH	BYTE 00H
	PUSH	BYTE 0BH
	PUSH	BYTE 049H
	PUSH	DWORD _HelpBox
	CALL	_ControlSetting
	ADD	ESP,BYTE 010H
L_300:
;
; Line 434:	BuildHelpBox(NULL);
;
	PUSH	BYTE 00H
	CALL	_BuildHelpBox
	POP	ECX
;
; Line 435:	AddTitle(wnd, HelpBox.dwnd.title);
;
	PUSH	DWORD [_HelpBox+04H]
	PUSH	ESI
	CALL	_AddTitle
	ADD	ESP,BYTE 08H
;
; Line 437:	HelpBox.dwnd.x = (SCREENWIDTH-HelpBox.dwnd.w)/2;
;
	MOV	EAX,04AH
	MOVZX	ECX,WORD [___seg0040]
	MOV	EDX,ECX
	MOV	FS,DX
	MOVSX	EAX,BYTE [FS:EAX+00H]
	MOVZX	EAX,AL
	SUB	EAX,DWORD [_HelpBox+014H]
	SAR	EAX,01H
	JNS	SHORT	L_301
	ADC	EAX,BYTE 00H
L_301:
	MOV	DWORD [_HelpBox+08H],EAX
;
; Line 438:	HelpBox.dwnd.y = (SCREENHEIGHT-HelpBox.dwnd.h)/2;
;
	CALL	_isVGA
	TEST	EAX,EAX
	JNE	SHORT	L_304
	CALL	_isEGA
	TEST	EAX,EAX
	JE	SHORT	L_302
L_304:
	MOV	EAX,084H
	MOVZX	ECX,WORD [___seg0040]
	MOV	EDX,ECX
	MOV	FS,DX
	MOVSX	EAX,BYTE [FS:EAX+00H]
	INC	EAX
	JMP	SHORT	L_303
L_302:
	MOV	EAX,019H
L_303:
	SUB	EAX,DWORD [_HelpBox+010H]
	SAR	EAX,01H
	JNS	SHORT	L_305
	ADC	EAX,BYTE 00H
L_305:
	MOV	DWORD [_HelpBox+0CH],EAX
;
; Line 439:	SendMessage(wnd, MOVE, HelpBox.dwnd.x, HelpBox.dwnd.y);
;
	PUSH	DWORD [_HelpBox+0CH]
	PUSH	DWORD [_HelpBox+08H]
	PUSH	BYTE 0CH
	PUSH	ESI
	CALL	_SendMessage
	ADD	ESP,BYTE 010H
;
; Line 440:	SendMessage(wnd, SIZE,
;
	MOV	EAX,DWORD [_HelpBox+0CH]
	ADD	EAX,DWORD [_HelpBox+010H]
	DEC	EAX
	PUSH	EAX
	MOV	EAX,DWORD [_HelpBox+08H]
	ADD	EAX,DWORD [_HelpBox+014H]
	DEC	EAX
	PUSH	EAX
	PUSH	BYTE 0DH
	PUSH	ESI
	CALL	_SendMessage
	ADD	ESP,BYTE 010H
	MOV	EBX,00H
	JMP	NEAR	L_308
L_306:
;
; Line 445:	WINDOW cwnd = HelpBox.ctl[i].wnd;
;
	MOV	EAX,EBX
	IMUL	EAX,BYTE 030H
	MOV	EAX,DWORD [EAX+02CH+018H+_HelpBox+00H]
	MOV	DWORD [EBP-08H],EAX
;
; Line 446:	x = HelpBox.ctl[i].dwnd.x+GetClientLeft(wnd);
;
	MOV	EAX,EBX
	IMUL	EAX,BYTE 030H
	MOV	ECX,DWORD [ESI+054H]
	AND	ECX,04000H
	JE	SHORT	L_310
	MOV	ECX,01H
	JMP	SHORT	L_311
L_310:
	MOV	ECX,00H
L_311:
	ADD	ECX,DWORD [ESI+0CH]
	ADD	ECX,DWORD [EAX+018H+_HelpBox+00H+04H]
	MOV	DWORD [EBP-04H],ECX
;
; Line 447:	y = HelpBox.ctl[i].dwnd.y+GetClientTop(wnd);
;
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_312
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,BYTE 08H
	JE	SHORT	L_312
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,010000H
	JE	SHORT	L_312
	MOV	EAX,03H
	JMP	SHORT	L_313
L_312:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_317
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,BYTE 08H
	JNE	SHORT	L_316
L_317:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_314
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,010000H
	JE	SHORT	L_314
L_316:
	MOV	EAX,02H
	JMP	SHORT	L_315
L_314:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,014108H
	JE	SHORT	L_318
	MOV	EAX,01H
	JMP	SHORT	L_319
L_318:
	MOV	EAX,00H
L_319:
L_315:
L_313:
	ADD	EAX,DWORD [ESI+010H]
	MOV	ECX,EBX
	IMUL	ECX,BYTE 030H
	ADD	EAX,DWORD [ECX+018H+_HelpBox+00H+08H]
	MOV	EDI,EAX
;
; Line 448:	SendMessage(cwnd, MOVE, x, y);
;
	PUSH	EDI
	PUSH	DWORD [EBP-04H]
	PUSH	BYTE 0CH
	PUSH	DWORD [EBP-08H]
	CALL	_SendMessage
	ADD	ESP,BYTE 010H
;
; Line 449:	if (i == 0)	{
;
	TEST	EBX,EBX
	JNE	SHORT	L_320
;
; Line 450:	x += HelpBox.ctl[i].dwnd.w - 1;
;
	MOV	EAX,EBX
	IMUL	EAX,BYTE 030H
	MOV	EAX,DWORD [EAX+018H+_HelpBox+00H+010H]
	DEC	EAX
	ADD	DWORD [EBP-04H],EAX
;
; Line 451:	y += HelpBox.ctl[i].dwnd.h - 1;
;
	MOV	EAX,EBX
	IMUL	EAX,BYTE 030H
	MOV	EAX,DWORD [EAX+018H+_HelpBox+00H+0CH]
	DEC	EAX
	ADD	EDI,EAX
;
; Line 452:	SendMessage(cwnd, SIZE, x, y);
;
	PUSH	EDI
	PUSH	DWORD [EBP-04H]
	PUSH	BYTE 0DH
	PUSH	DWORD [EBP-08H]
	CALL	_SendMessage
	ADD	ESP,BYTE 010H
L_320:
;
; Line 444:	for (i = 0; i < 5; i++)    {
;
L_307:
	INC	EBX
L_308:
	CMP	EBX,BYTE 05H
	JL	NEAR	L_306
L_309:
;
; Line 456:	ReadHelp(wnd);
;
	PUSH	ESI
	CALL	_ReadHelp
	POP	ECX
;
; Line 457:	ReFocus(wnd);
;
	PUSH	ESI
	CALL	_ReFocus
	POP	ECX
;
; Line 458:	SendMessage(wnd, SHOW_WINDOW, 0, 0);
;
	PUSH	BYTE 00H
	PUSH	BYTE 00H
	PUSH	BYTE 05H
	PUSH	ESI
	CALL	_SendMessage
	ADD	ESP,BYTE 010H
L_294:
;
; Line 460:	}
;
L_292:
	POP	EDI
	POP	ESI
	POP	EBX
	MOV	ESP,EBP
	POP	EBP
	RET
;
; Line 462:	static void StripTildes(char *fh, char *hp)
;
_StripTildes:
	PUSH	EBP
	MOV	EBP,ESP
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,DWORD [EBP+0CH]
	MOV	EDI,DWORD [EBP+08H]
L_323:
;
; Line 463:	{
;
	JMP	SHORT	L_324
L_326:
;
; Line 465:	if (*hp != '~')
;
	MOVSX	EAX,BYTE [ESI+00H]
	CMP	EAX,BYTE 07EH
	JE	SHORT	L_327
;
; Line 466:	*fh++ = *hp;
;
	MOV	EAX,EDI
	INC	EDI
	MOV	CL,BYTE [ESI+00H]
	MOV	BYTE [EAX+00H],CL
L_327:
;
; Line 467:	hp++;
;
	INC	ESI
L_324:
;
; Line 464:	while (*hp)	{
;
	CMP	BYTE [ESI+00H],BYTE 00H
	JNE	SHORT	L_326
L_325:
;
; Line 469:	*fh = '\0';
;
	MOV	BYTE [EDI+00H],00H
;
; Line 470:	}
;
L_322:
	POP	EDI
	POP	ESI
	POP	EBP
	RET
[GLOBAL	_HelpComment]
;
; Line 472:	char *HelpComment(char *Help)
;
_HelpComment:
	PUSH	EBP
	MOV	EBP,ESP
	SUB	ESP,BYTE 024H
L_330:
;
; Line 473:	{
;
;
; Line 475:	StripTildes(FixedHelp, Help);
;
	PUSH	DWORD [EBP+08H]
	LEA	EAX,[EBP-020H]
	PUSH	EAX
	CALL	_StripTildes
	ADD	ESP,BYTE 08H
;
; Line 476:	if ((ThisHelp = FindHelp(FixedHelp)) != NULL)
;
	LEA	EAX,[EBP-020H]
	PUSH	EAX
	CALL	_FindHelp
	POP	ECX
	MOV	DWORD [_ThisHelp],EAX
	TEST	EAX,EAX
	JE	SHORT	L_331
;
; Line 477:	return ThisHelp->comment;
;
	MOV	EAX,DWORD [_ThisHelp]
	MOV	EAX,DWORD [EAX+04H]
	JMP	SHORT	L_329
L_331:
;
; Line 478:	return NULL;
;
	MOV	EAX,00H
L_329:
	MOV	ESP,EBP
	POP	EBP
	RET
[GLOBAL	_DisplayHelp]
;
; Line 481:	BOOL DisplayHelp(WINDOW wnd, char *Help)
;
_DisplayHelp:
	PUSH	EBP
	MOV	EBP,ESP
	SUB	ESP,BYTE 024H
	PUSH	EBX
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,DWORD [EBP+08H]
	MOV	EDI,DWORD _HelpBox
L_334:
;
; Line 482:	{
;
;
; Line 484:	BOOL rtn = FALSE;
;
	MOV	EBX,00H
;
; Line 486:	if (Helping)
;
	CMP	DWORD [_Helping],BYTE 00H
	JE	SHORT	L_335
;
; Line 487:	return TRUE;
;
	MOV	EAX,01H
	JMP	NEAR	L_333
L_335:
;
; Line 488:	StripTildes(FixedHelp, Help);
;
	PUSH	DWORD [EBP+0CH]
	LEA	EAX,[EBP-020H]
	PUSH	EAX
	CALL	_StripTildes
	ADD	ESP,BYTE 08H
;
; Line 489:	stacked = 0;
;
	MOV	DWORD [_stacked],00H
;
; Line 490:	wnd->isHelping++;
;
	INC	DWORD [ESI+08CH]
;
; Line 491:	if ((ThisHelp = FindHelp(FixedHelp)) != NULL)	{
;
	LEA	EAX,[EBP-020H]
	PUSH	EAX
	CALL	_FindHelp
	POP	ECX
	MOV	DWORD [_ThisHelp],EAX
	TEST	EAX,EAX
	JE	SHORT	L_337
;
; Line 492:	if ((helpfp = OpenHelpFile(HelpFileName, "rb")) != NULL)    {
;
	PUSH	DWORD L_230
	PUSH	DWORD _HelpFileName
	CALL	_OpenHelpFile
	ADD	ESP,BYTE 08H
	MOV	DWORD [_helpfp],EAX
	TEST	EAX,EAX
	JE	SHORT	L_339
;
; Line 493:	BuildHelpBox(wnd);
;
	PUSH	ESI
	CALL	_BuildHelpBox
	POP	ECX
;
; Line 494:	DisableButton(&HelpBox, ID_BACK);
;
	PUSH	BYTE 00H
	PUSH	BYTE 0BH
	PUSH	BYTE 049H
	PUSH	EDI
	CALL	_ControlSetting
	ADD	ESP,BYTE 010H
;
; Line 496:	DialogBox(NULL, &HelpBox, TRUE, HelpBoxProc);
;
	PUSH	DWORD _HelpBoxProc
	PUSH	BYTE 01H
	PUSH	EDI
	PUSH	BYTE 00H
	CALL	_DialogBox
	ADD	ESP,BYTE 010H
;
; Line 497:	free(HelpBox.dwnd.title);
;
	PUSH	DWORD [EDI+04H]
	CALL	_free
	POP	ECX
;
; Line 498:	HelpBox.dwnd.title = NULL;
;
	MOV	DWORD [EDI+04H],00H
;
; Line 499:	fclose(helpfp);
;
	PUSH	DWORD [_helpfp]
	CALL	_fclose
	POP	ECX
;
; Line 500:	helpfp = NULL;
;
	MOV	DWORD [_helpfp],00H
;
; Line 501:	rtn = TRUE;
;
	MOV	EBX,01H
L_339:
L_337:
;
; Line 504:	--wnd->isHelping;
;
	DEC	DWORD [ESI+08CH]
;
; Line 505:	return rtn;
;
	MOV	EAX,EBX
L_333:
	POP	EDI
	POP	ESI
	POP	EBX
	MOV	ESP,EBP
	POP	EBP
	RET
;
; Line 509:	static void DisplayDefinition(WINDOW wnd, char *def)
;
_DisplayDefinition:
	PUSH	EBP
	MOV	EBP,ESP
	SUB	ESP,BYTE 0CH
	PUSH	EBX
	PUSH	ESI
	PUSH	EDI
	MOV	EDI,DWORD _hline
L_342:
;
; Line 510:	{
;
;
; Line 512:	WINDOW hwnd = wnd;
;
	MOV	ESI,DWORD [EBP+08H]
;
; Line 516:	HoldThisHelp = ThisHelp;
;
	MOV	EAX,DWORD [_ThisHelp]
	MOV	DWORD [EBP-04H],EAX
;
; Line 517:	if (GetClass(wnd) == POPDOWNMENU)
;
	MOV	EAX,DWORD [EBP+08H]
	CMP	DWORD [EAX+00H],BYTE 07H
	JNE	SHORT	L_343
;
; Line 518:	hwnd = GetParent(wnd);
;
	MOV	EAX,DWORD [EBP+08H]
	MOV	ESI,DWORD [EAX+03CH]
L_343:
;
; Line 519:	y = GetClass(hwnd) == MENUBAR ? 2 : 1;
;
	CMP	DWORD [ESI+00H],BYTE 05H
	JNE	SHORT	L_345
	MOV	EAX,02H
	JMP	SHORT	L_346
L_345:
	MOV	EAX,01H
L_346:
	MOV	DWORD [EBP-08H],EAX
;
; Line 520:	if ((ThisHelp = FindHelp(def)) != NULL)    {
;
	PUSH	DWORD [EBP+0CH]
	CALL	_FindHelp
	POP	ECX
	MOV	DWORD [_ThisHelp],EAX
	TEST	EAX,EAX
	JE	NEAR	L_347
;
; Line 521:	dwnd = CreateWindow(
;
	PUSH	DWORD 04800H
	PUSH	BYTE 00H
	PUSH	DWORD [EBP+08H]
	PUSH	BYTE 00H
	MOV	EAX,DWORD [_ThisHelp]
	MOVSX	EAX,WORD [EAX+010H]
	ADD	EAX,BYTE 02H
	PUSH	EAX
	CALL	_isVGA
	TEST	EAX,EAX
	JNE	SHORT	L_353
	CALL	_isEGA
	TEST	EAX,EAX
	JE	SHORT	L_351
L_353:
	MOV	EAX,084H
	MOVZX	ECX,WORD [___seg0040]
	MOV	EDX,ECX
	MOV	FS,DX
	MOVSX	EAX,BYTE [FS:EAX+00H]
	INC	EAX
	JMP	SHORT	L_352
L_351:
	MOV	EAX,019H
L_352:
	SUB	EAX,BYTE 0AH
	MOV	ECX,DWORD [_ThisHelp]
	MOVSX	ECX,WORD [ECX+0EH]
	CMP	ECX,EAX
	JGE	SHORT	L_349
	MOV	EAX,DWORD [_ThisHelp]
	MOVSX	EAX,WORD [EAX+0EH]
	JMP	SHORT	L_350
L_349:
	CALL	_isVGA
	TEST	EAX,EAX
	JNE	SHORT	L_356
	CALL	_isEGA
	TEST	EAX,EAX
	JE	SHORT	L_354
L_356:
	MOV	EAX,084H
	MOVZX	ECX,WORD [___seg0040]
	MOV	EDX,ECX
	MOV	FS,DX
	MOVSX	EAX,BYTE [FS:EAX+00H]
	INC	EAX
	JMP	SHORT	L_355
L_354:
	MOV	EAX,019H
L_355:
	SUB	EAX,BYTE 0AH
L_350:
	ADD	EAX,BYTE 03H
	PUSH	EAX
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_357
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,BYTE 08H
	JE	SHORT	L_357
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,010000H
	JE	SHORT	L_357
	MOV	EAX,03H
	JMP	SHORT	L_358
L_357:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_362
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,BYTE 08H
	JNE	SHORT	L_361
L_362:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,0100H
	JE	SHORT	L_359
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,010000H
	JE	SHORT	L_359
L_361:
	MOV	EAX,02H
	JMP	SHORT	L_360
L_359:
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,014108H
	JE	SHORT	L_363
	MOV	EAX,01H
	JMP	SHORT	L_364
L_363:
	MOV	EAX,00H
L_364:
L_360:
L_358:
	ADD	EAX,DWORD [ESI+010H]
	ADD	EAX,DWORD [EBP-08H]
	PUSH	EAX
	MOV	EAX,DWORD [ESI+054H]
	AND	EAX,04000H
	JE	SHORT	L_365
	MOV	EAX,01H
	JMP	SHORT	L_366
L_365:
	MOV	EAX,00H
L_366:
	ADD	EAX,DWORD [ESI+0CH]
	PUSH	EAX
	PUSH	BYTE 00H
	PUSH	BYTE 02H
	CALL	_CreateWindow
	ADD	ESP,BYTE 028H
	MOV	EBX,EAX
;
; Line 532:	if (dwnd != NULL)    {
;
	TEST	EBX,EBX
	JE	NEAR	L_367
;
; Line 533:	clearBIOSbuffer();
;
	MOV	EAX,01CH
	MOVZX	ECX,WORD [___seg0040]
	MOV	EDX,ECX
	MOV	FS,DX
	MOV	ECX,01AH
	MOVZX	EDX,WORD [___seg0040]
	MOV	GS,DX
	MOV	AX,WORD [FS:EAX+00H]
	MOV	WORD [GS:ECX+00H],AX
;
; Line 535:	SeekHelpLine(ThisHelp->hptr, ThisHelp->bit);
;
	MOV	EAX,DWORD [_ThisHelp]
	MOVSX	EAX,WORD [EAX+0CH]
	PUSH	EAX
	MOV	EAX,DWORD [_ThisHelp]
	PUSH	DWORD [EAX+08H]
	CALL	_SeekHelpLine
	ADD	ESP,BYTE 08H
	JMP	SHORT	L_369
L_371:
;
; Line 537:	clearBIOSbuffer();
;
	MOV	EAX,01CH
	MOVZX	ECX,WORD [___seg0040]
	MOV	EDX,ECX
	MOV	FS,DX
	MOV	ECX,01AH
	MOVZX	EDX,WORD [___seg0040]
	MOV	GS,DX
	MOV	AX,WORD [FS:EAX+00H]
	MOV	WORD [GS:ECX+00H],AX
;
; Line 538:	if (GetHelpLine(hline) == NULL)
;
	PUSH	EDI
	CALL	_GetHelpLine
	POP	ECX
	TEST	EAX,EAX
	JE	SHORT	L_370
;
; Line 539:	break;
;
L_372:
;
; Line 540:	if (*hline == '<')
;
	MOVSX	EAX,BYTE [EDI+00H]
	CMP	EAX,BYTE 03CH
	JE	SHORT	L_370
;
; Line 541:	break;
;
L_374:
;
; Line 542:	hline[strlen(hline)-1] = '\0';
;
	PUSH	EDI
	CALL	_strlen
	POP	ECX
	DEC	EAX
	MOV	BYTE [EDI+EAX+00H],00H
;
; Line 543:	SendMessage(dwnd,ADDTEXT,(PARAM)hline,0);
;
	PUSH	BYTE 00H
	PUSH	EDI
	PUSH	BYTE 030H
	PUSH	EBX
	CALL	_SendMessage
	ADD	ESP,BYTE 010H
L_369:
;
; Line 536:	while (TRUE)    {
;
	JMP	SHORT	L_371
L_370:
;
; Line 545:	SendMessage(dwnd, SHOW_WINDOW, 0, 0);
;
	PUSH	BYTE 00H
	PUSH	BYTE 00H
	PUSH	BYTE 05H
	PUSH	EBX
	CALL	_SendMessage
	ADD	ESP,BYTE 010H
;
; Line 546:	SendMessage(NULL, WAITKEYBOARD, 0, 0);
;
	PUSH	BYTE 00H
	PUSH	BYTE 00H
	PUSH	BYTE 01FH
	PUSH	BYTE 00H
	CALL	_SendMessage
	ADD	ESP,BYTE 010H
;
; Line 547:	SendMessage(NULL, WAITMOUSE, 0, 0);
;
	PUSH	BYTE 00H
	PUSH	BYTE 00H
	PUSH	BYTE 02CH
	PUSH	BYTE 00H
	CALL	_SendMessage
	ADD	ESP,BYTE 010H
;
; Line 548:	SendMessage(dwnd, CLOSE_WINDOW, 0, 0);
;
	PUSH	BYTE 00H
	PUSH	BYTE 00H
	PUSH	BYTE 07H
	PUSH	EBX
	CALL	_SendMessage
	ADD	ESP,BYTE 010H
L_367:
L_347:
;
; Line 551:	ThisHelp = HoldThisHelp;
;
	MOV	EAX,DWORD [EBP-04H]
	MOV	DWORD [_ThisHelp],EAX
;
; Line 552:	}
;
L_341:
	POP	EDI
	POP	ESI
	POP	EBX
	MOV	ESP,EBP
	POP	EBP
	RET
;
; Line 555:	static BOOL wildcmp(char *s1, char *s2)
;
_wildcmp:
	PUSH	EBP
	MOV	EBP,ESP
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,DWORD [EBP+0CH]
	MOV	EDI,DWORD [EBP+08H]
L_377:
;
; Line 556:	{
;
	JMP	SHORT	L_378
L_380:
;
; Line 558:	if (tolower(*s1) != tolower(*s2))
;
	MOVSX	EAX,BYTE [ESI+00H]
	PUSH	EAX
	CALL	_tolower
	POP	ECX
	PUSH	EAX
	MOVSX	EAX,BYTE [EDI+00H]
	PUSH	EAX
	CALL	_tolower
	POP	ECX
	MOV	ECX,EAX
	POP	EAX
	CMP	ECX,EAX
	JE	SHORT	L_381
;
; Line 559:	if (*s1 != '?' && *s2 != '?')
;
	MOVSX	EAX,BYTE [EDI+00H]
	CMP	EAX,BYTE 03FH
	JE	SHORT	L_383
	MOVSX	EAX,BYTE [ESI+00H]
	CMP	EAX,BYTE 03FH
	JE	SHORT	L_383
;
; Line 560:	return TRUE;
;
	MOV	EAX,01H
	JMP	SHORT	L_376
L_383:
L_381:
;
; Line 561:	s1++, s2++;
;
	INC	EDI
	INC	ESI
L_378:
;
; Line 557:	while (*s1 || *s2)    {
;
	CMP	BYTE [EDI+00H],BYTE 00H
	JNE	SHORT	L_380
	CMP	BYTE [ESI+00H],BYTE 00H
	JNE	SHORT	L_380
L_379:
;
; Line 563:	return FALSE;
;
	MOV	EAX,00H
L_376:
	POP	EDI
	POP	ESI
	POP	EBP
	RET
;
; Line 567:	static struct helps *FindHelp(char *Help)
;
_FindHelp:
	PUSH	EBP
	MOV	EBP,ESP
	PUSH	EBX
	PUSH	ESI
L_386:
;
; Line 568:	{
;
;
; Line 570:	struct helps *thishelp = NULL;
;
	MOV	ESI,00H
	MOV	EBX,00H
	JMP	SHORT	L_389
L_387:
;
; Line 572:	if (wildcmp(Help, (FirstHelp+i)->hname) == FALSE)	{
;
	MOV	EAX,DWORD [_FirstHelp]
	MOV	ECX,EBX
	IMUL	ECX,BYTE 022H
	PUSH	DWORD [EAX+ECX+00H]
	PUSH	DWORD [EBP+08H]
	CALL	_wildcmp
	ADD	ESP,BYTE 08H
	TEST	EAX,EAX
	JNE	SHORT	L_391
;
; Line 573:	thishelp = FirstHelp+i;
;
	MOV	ESI,EBX
	IMUL	ESI,BYTE 022H
	ADD	ESI,DWORD [_FirstHelp]
;
; Line 574:	break;
;
	JMP	SHORT	L_390
L_391:
;
; Line 571:	for (i = 0; i < HelpCount; i++)	{
;
L_388:
	INC	EBX
L_389:
	CMP	EBX,DWORD [_HelpCount]
	JL	SHORT	L_387
L_390:
;
; Line 577:	return thishelp;
;
	MOV	EAX,ESI
L_385:
	POP	ESI
	POP	EBX
	POP	EBP
	RET
;
; Line 580:	static int OverLap(int a, int b)
;
_OverLap:
	PUSH	EBP
	MOV	EBP,ESP
	PUSH	EBX
L_394:
;
; Line 581:	{
;
;
; Line 582:	int ov = a - b;
;
	MOV	EBX,DWORD [EBP+08H]
	SUB	EBX,DWORD [EBP+0CH]
;
; Line 583:	if (ov < 0)
;
	JGE	SHORT	L_395
;
; Line 584:	ov = 0;
;
	MOV	EBX,00H
L_395:
;
; Line 585:	return ov;
;
	MOV	EAX,EBX
L_393:
	POP	EBX
	POP	EBP
	RET
;
; Line 589:	static void BestFit(WINDOW wnd, DIALOGWINDOW *dwnd)
;
_BestFit:
	PUSH	EBP
	MOV	EBP,ESP
	SUB	ESP,BYTE 010H
	PUSH	EBX
	PUSH	ESI
	PUSH	EDI
	MOV	ESI,DWORD [EBP+0CH]
	MOV	EDI,DWORD [EBP+08H]
L_398:
;
; Line 590:	{
;
;
; Line 592:	if (GetClass(wnd) == MENUBAR ||
;
	CMP	DWORD [EDI+00H],BYTE 05H
	JE	SHORT	L_401
	CMP	DWORD [EDI+00H],BYTE 01H
	JNE	SHORT	L_399
L_401:
;
; Line 594:	dwnd->x = dwnd->y = -1;
;
	MOV	DWORD [ESI+08H],0FFFFFFFFH
	MOV	DWORD [ESI+04H],0FFFFFFFFH
;
; Line 595:	return;
;
	JMP	NEAR	L_397
L_399:
;
; Line 598:	above = OverLap(dwnd->h, GetTop(wnd));
;
	PUSH	DWORD [EDI+010H]
	PUSH	DWORD [ESI+0CH]
	CALL	_OverLap
	ADD	ESP,BYTE 08H
	MOV	DWORD [EBP-0CH],EAX
;
; Line 600:	below = OverLap(GetBottom(wnd), SCREENHEIGHT-dwnd->h);
;
	CALL	_isVGA
	TEST	EAX,EAX
	JNE	SHORT	L_404
	CALL	_isEGA
	TEST	EAX,EAX
	JE	SHORT	L_402
L_404:
	MOV	EAX,084H
	MOVZX	ECX,WORD [___seg0040]
	MOV	EDX,ECX
	MOV	FS,DX
	MOVSX	EAX,BYTE [FS:EAX+00H]
	INC	EAX
	JMP	SHORT	L_403
L_402:
	MOV	EAX,019H
L_403:
	SUB	EAX,DWORD [ESI+0CH]
	PUSH	EAX
	PUSH	DWORD [EDI+018H]
	CALL	_OverLap
	ADD	ESP,BYTE 08H
	MOV	DWORD [EBP-08H],EAX
;
; Line 602:	right = OverLap(GetRight(wnd), SCREENWIDTH-dwnd->w);
;
	MOV	EAX,04AH
	MOVZX	ECX,WORD [___seg0040]
	MOV	EDX,ECX
	MOV	FS,DX
	MOVSX	EAX,BYTE [FS:EAX+00H]
	MOVZX	EAX,AL
	SUB	EAX,DWORD [ESI+010H]
	PUSH	EAX
	PUSH	DWORD [EDI+014H]
	CALL	_OverLap
	ADD	ESP,BYTE 08H
	MOV	DWORD [EBP-04H],EAX
;
; Line 604:	left = OverLap(dwnd->w, GetLeft(wnd));
;
	PUSH	DWORD [EDI+0CH]
	PUSH	DWORD [ESI+010H]
	CALL	_OverLap
	ADD	ESP,BYTE 08H
	MOV	EBX,EAX
;
; Line 606:	if (above < below)
;
	MOV	EAX,DWORD [EBP-0CH]
	CMP	EAX,DWORD [EBP-08H]
	JGE	SHORT	L_405
;
; Line 607:	dwnd->y = max(0, GetTop(wnd)-dwnd->h-2);
;
	MOV	EAX,DWORD [EDI+010H]
	SUB	EAX,DWORD [ESI+0CH]
	SUB	EAX,BYTE 02H
	JGE	SHORT	L_407
	MOV	EAX,00H
	JMP	SHORT	L_408
L_407:
	MOV	EAX,DWORD [EDI+010H]
	SUB	EAX,DWORD [ESI+0CH]
	SUB	EAX,BYTE 02H
L_408:
	MOV	DWORD [ESI+08H],EAX
	JMP	NEAR	L_406
L_405:
;
; Line 609:	dwnd->y = min(SCREENHEIGHT-dwnd->h, GetBottom(wnd)+2);
;
	MOV	EAX,DWORD [EDI+018H]
	ADD	EAX,BYTE 02H
	PUSH	EAX
	CALL	_isVGA
	MOV	ECX,EAX
	POP	EAX
	TEST	ECX,ECX
	JNE	SHORT	L_413
	PUSH	EAX
	CALL	_isEGA
	MOV	ECX,EAX
	POP	EAX
	TEST	ECX,ECX
	JE	SHORT	L_411
L_413:
	MOV	ECX,084H
	MOVZX	EDX,WORD [___seg0040]
	MOV	FS,DX
	MOVSX	ECX,BYTE [FS:ECX+00H]
	INC	ECX
	JMP	SHORT	L_412
L_411:
	MOV	ECX,019H
L_412:
	SUB	ECX,DWORD [ESI+0CH]
	CMP	ECX,EAX
	JGE	SHORT	L_409
	CALL	_isVGA
	TEST	EAX,EAX
	JNE	SHORT	L_416
	CALL	_isEGA
	TEST	EAX,EAX
	JE	SHORT	L_414
L_416:
	MOV	EAX,084H
	MOVZX	ECX,WORD [___seg0040]
	MOV	EDX,ECX
	MOV	FS,DX
	MOVSX	EAX,BYTE [FS:EAX+00H]
	INC	EAX
	JMP	SHORT	L_415
L_414:
	MOV	EAX,019H
L_415:
	SUB	EAX,DWORD [ESI+0CH]
	JMP	SHORT	L_410
L_409:
	MOV	EAX,DWORD [EDI+018H]
	ADD	EAX,BYTE 02H
L_410:
	MOV	DWORD [ESI+08H],EAX
L_406:
;
; Line 610:	if (right < left)
;
	CMP	DWORD [EBP-04H],EBX
	JGE	SHORT	L_417
;
; Line 611:	dwnd->x = min(GetRight(wnd)+2, SCREENWIDTH-dwnd->w);
;
	MOV	EAX,04AH
	MOVZX	ECX,WORD [___seg0040]
	MOV	EDX,ECX
	MOV	FS,DX
	MOVSX	EAX,BYTE [FS:EAX+00H]
	MOVZX	EAX,AL
	SUB	EAX,DWORD [ESI+010H]
	MOV	ECX,DWORD [EDI+014H]
	ADD	ECX,BYTE 02H
	CMP	ECX,EAX
	JGE	SHORT	L_419
	MOV	EAX,DWORD [EDI+014H]
	ADD	EAX,BYTE 02H
	JMP	SHORT	L_420
L_419:
	MOV	EAX,04AH
	MOVZX	ECX,WORD [___seg0040]
	MOV	EDX,ECX
	MOV	FS,DX
	MOVSX	EAX,BYTE [FS:EAX+00H]
	MOVZX	EAX,AL
	SUB	EAX,DWORD [ESI+010H]
L_420:
	MOV	DWORD [ESI+04H],EAX
	JMP	SHORT	L_418
L_417:
;
; Line 613:	dwnd->x = max(0, GetLeft(wnd)-dwnd->w-2);
;
	MOV	EAX,DWORD [EDI+0CH]
	SUB	EAX,DWORD [ESI+010H]
	SUB	EAX,BYTE 02H
	JGE	SHORT	L_421
	MOV	EAX,00H
	JMP	SHORT	L_422
L_421:
	MOV	EAX,DWORD [EDI+0CH]
	SUB	EAX,DWORD [ESI+010H]
	SUB	EAX,BYTE 02H
L_422:
	MOV	DWORD [ESI+04H],EAX
L_418:
;
; Line 615:	if (dwnd->x == GetRight(wnd)+2 ||
;
	MOV	EAX,DWORD [EDI+014H]
	ADD	EAX,BYTE 02H
	CMP	DWORD [ESI+04H],EAX
	JE	SHORT	L_425
	MOV	EAX,DWORD [EDI+0CH]
	SUB	EAX,DWORD [ESI+010H]
	SUB	EAX,BYTE 02H
	CMP	DWORD [ESI+04H],EAX
	JNE	SHORT	L_423
L_425:
;
; Line 617:	dwnd->y = -1;
;
	MOV	DWORD [ESI+08H],0FFFFFFFFH
L_423:
;
; Line 618:	if (dwnd->y ==GetTop(wnd)-dwnd->h-2 ||
;
	MOV	EAX,DWORD [EDI+010H]
	SUB	EAX,DWORD [ESI+0CH]
	SUB	EAX,BYTE 02H
	CMP	DWORD [ESI+08H],EAX
	JE	SHORT	L_428
	MOV	EAX,DWORD [EDI+018H]
	ADD	EAX,BYTE 02H
	CMP	DWORD [ESI+08H],EAX
	JNE	SHORT	L_426
L_428:
;
; Line 620:	dwnd->x = -1;
;
	MOV	DWORD [ESI+04H],0FFFFFFFFH
L_426:
;
; Line 621:	}
;
L_397:
	POP	EDI
	POP	ESI
	POP	EBX
	MOV	ESP,EBP
	POP	EBP
	RET
SECTION _STRING
L_230:
	DB	072H,062H,00H
L_24:
	DB	044H,055H,04DH,04DH,059H,00H
L_23:
	DB	054H,049H,054H,04CH,045H,042H,041H,052H,00H
L_22:
	DB	045H,044H,049H,054H,04FH,052H,00H
L_21:
	DB	053H,054H,041H,054H,055H,053H,042H,041H,052H,00H
L_20:
	DB	048H,045H,04CH,050H,042H,04FH,058H,00H
L_19:
	DB	04DH,045H,053H,053H,041H,047H,045H,042H,04FH,058H,00H
L_18:
	DB	045H,052H,052H,04FH,052H,042H,04FH,058H,00H
L_17:
	DB	053H,050H,049H,04EH,042H,055H,054H,054H,04FH,04EH,00H
L_16:
	DB	043H,048H,045H,043H,04BH,042H,04FH,058H,00H
L_15:
	DB	052H,041H,044H,049H,04FH,042H,055H,054H,054H,04FH,04EH,00H
L_14:
	DB	054H,045H,058H,054H,00H
L_13:
	DB	043H,04FH,04DH,042H,04FH,042H,04FH,058H,00H
L_12:
	DB	042H,055H,054H,054H,04FH,04EH,00H
L_11:
	DB	042H,04FH,058H,00H
L_10:
	DB	044H,049H,041H,04CH,04FH,047H,00H
L_9:
	DB	050H,049H,043H,054H,055H,052H,045H,042H,04FH,058H,00H
L_8:
	DB	050H,04FH,050H,044H,04FH,057H,04EH,04DH,045H,04EH,055H,00H
L_7:
	DB	054H,041H,042H,042H,041H,052H,00H
L_6:
	DB	04DH,045H,04EH,055H,042H,041H,052H,00H
L_5:
	DB	045H,044H,049H,054H,042H,04FH,058H,00H
L_4:
	DB	04CH,049H,053H,054H,042H,04FH,058H,00H
L_3:
	DB	054H,045H,058H,054H,042H,04FH,058H,00H
L_2:
	DB	041H,050H,050H,04CH,049H,043H,041H,054H,049H,04FH,04EH,00H
L_1:
	DB	04EH,04FH,052H,04DH,041H,04CH,00H
SECTION _DATA
[GLOBAL	_ClassNames]

_ClassNames	DD	L_1,L_2,L_3,L_4,L_5,L_6,L_7
	DD	L_8,L_9,L_10,L_11,L_12,L_13,L_14
	DD	L_15,L_16,L_17,L_18,L_19,L_20,L_21
	DD	L_22,L_23,L_24,00H
SECTION _BSS

_FirstHelp	RESB	04H

_ThisHelp	RESB	04H

_HelpCount	RESB	04H

_HelpFileName	RESB	09H
	RESB	03H

_HelpStack	RESB	0190H

_stacked	RESB	04H

_KeyWords	RESB	041AH
	RESB	02H

_thisword	RESB	04H

_keywordcount	RESB	04H

_helpfp	RESB	04H

_hline	RESB	0A0H

_Helping	RESB	04H
SECTION _CONST

	TIMES $$-$ & 3 NOP
L_298:
	DD	022H

SECTION _TEXT
[EXTERN	_HelpBox]
[EXTERN	_HelpTree]
[EXTERN	_WindowMoving]
[EXTERN	_InitWindowColors]
[EXTERN	_CreateWindow]
[EXTERN	_GetHelpLine]
[EXTERN	_ReFocus]
[EXTERN	_fread]
[EXTERN	_inFocus]
[EXTERN	_DFcalloc]
[EXTERN	_SeekHelpLine]
[EXTERN	_strncpy]
[EXTERN	_strlen]
[EXTERN	_DialogBox]
[EXTERN	_isEGA]
[EXTERN	_ControlSetting]
[EXTERN	_memmove]
[EXTERN	_ControlWindow]
[EXTERN	_DFmalloc]
[EXTERN	_isVGA]
[EXTERN	_tolower]
[EXTERN	_AddTitle]
[EXTERN	_fseek]
[EXTERN	_free]
[EXTERN	_classdefs]
[EXTERN	_PutItemText]
[EXTERN	_memset]
[EXTERN	_SendMessage]
[EXTERN	_PostMessage]
[EXTERN	___seg0040]
[EXTERN	_OpenHelpFile]
[EXTERN	_strchr]
[EXTERN	_fclose]
[EXTERN	_strcpy]
