• Domingo 27 de Septiembre de 2020, 18:05

Autor Tema:  Suma de matrices  (Leído 4113 veces)

joseph_xD

  • Nuevo Miembro
  • *
  • Mensajes: 1
    • Ver Perfil
Suma de matrices
« en: Sábado 24 de Noviembre de 2012, 05:06 »
0
Hola, necesito ayuda con este código de asembler que supuestamente debe sumar una matriz de 2x2
el problema es que aprece el mensaje A11: yo ingreso un numero x ejemplo 12
luego aparece A12: ingreso 14 y luego no aparece nada más
mi sistema operativo es windows 7 32bits e intale el turbo assembler 5.0
si pudieran ayudarme se los agradecira mucho nose mucho sobre asembler
no he llevado el curso pero un profesor nos dejo de tarea buscar codigos de assembler de diferentes temas a mi me toco de operaciones aritmeticas de matrices
y tratar de explicar lo que entendamos.
TITLE MATRICES

        .MODEL SMALL
        .STACK 64
        .DATA

;MATRIZ A

A11     DB      ?
A12     DB      ?
A21     DB      ?
A22     DB      ?

;MATRIZ B

B11     DB      12
B12     DB      12
B21     DB      12
B22     DB      12

;MATRIZ RESULTANTE

R11     DB      ?
R12     DB      ?
R21     DB      ?
R22     DB      ?

ASCVAL  DB      '00','$'
DIVR    DB      ?

;MENSAJES PARA INGRESO MATRIZ

MSG11   DB      'A11: ','$'
MSG12   DB      'A12: ','$'
MSG21   DB      'A21: ','$'
MSG22   DB      'A22: ','$'

MSGB11  DB      'B11: ','$'
MSGB12  DB      'B12: ','$'
MSGB21  DB      'B21: ','$'
MSGB22  DB      'B22: ','$'

MSG     DB      'MATRIZ RESULTADO','$'
MSG2    DB      'DERECHOS RESEVADOS POR REFLEX','$'

;VARIABLES PARA LEER DEL BUFFER DEL TECLADO

NAMEPAR LABEL   BYTE
MAXLEN  DB      3
ACTLEN  DB      ?
NAMEFLD DB      3 DUP('')

        .CODE
BEGIN   PROC    FAR
        MOV     AX,@DATA
        MOV     DS,AX

;IMPRIMIR EN PANTALLA MENSAJE MSG11

        MOV     AH,09H
        LEA     DX,MSG11
        INT     21H

;LEE DESDE TECLADO Y LO TRASPASA A LA VARIABLE A11

        MOV     AH,0AH
        LEA     DX,NAMEPAR
        INT     21H
        LEA     SI,NAMEFLD
        MOV     AL,[SI]
        SUB     AL,48
        MOV     A11,AL
        MOV     AX,10
        MUL     A11
        MOV     A11,AL
        LEA     SI,NAMEFLD(1)
        MOV     AL,[SI]
        SUB     AL,48
        ADD     A11,AL

;LIMPIA PANTALLA

        MOV     AH,08H
        INT     10H
        MOV     BH,AH
        MOV     AX,0600H
        MOV     CX,0000
        MOV     DX,184FH
        INT     10H

;IMPRIMIR EN PANTALLA MENSAJE MSG12

        MOV     AH,09H
        LEA     DX,MSG12
        INT     21H

;LEE DESDE TECLADO Y LO TRASPASA A LA VARIABLE A12

        MOV     AH,0AH
        LEA     DX,NAMEPAR
        INT     21H
        LEA     SI,NAMEFLD
        MOV     AL,[SI]
        SUB     AL,48
        MOV     A12,AL
        MOV     AX,10
        MUL     A12
        MOV     A12,AL
        LEA     SI,NAMEFLD(1)
        MOV     AL,[SI]
        SUB     AL,48
        ADD     A12,AL

;LIMPIA PANTALLA

        MOV     AH,08H
        INT     10H
        MOV     BH,AH
        MOV     AX,0600H
        MOV     CX,0000
        MOV     DX,184FH
        INT     10H

;IMPRIMIR EN PANTALLA MENSAJE MSG21

        MOV     AH,09H
        LEA     DX,MSG21
        INT     21H

;LEE DESDE TECLADO Y LO TRASPASA A LA VARIABLE A21

        MOV     AH,0AH
        LEA     DX,NAMEPAR
        INT     21H
        LEA     SI,NAMEFLD
        MOV     AL,[SI]
        SUB     AL,48
        MOV     A21,AL
        MOV     AX,10
        MUL     A21
        MOV     A21,AL
        LEA     SI,NAMEFLD(1)
        MOV     AL,[SI]
        SUB     AL,48
        ADD     A21,AL

;LIMPIA PANTALLA

        MOV     AH,08H
        INT     10H
        MOV     BH,AH
        MOV     AX,0600H
        MOV     CX,0000
        MOV     DX,184FH
        INT     10H

;IMPRIMIR EN PANTALLA MENSAJE MSG22

        MOV     AH,09H
        LEA     DX,MSG22
        INT     21H

;LEE DESDE TECLADO Y LO TRASPASA A LA VARIABLE A22

        MOV     AH,0AH
        LEA     DX,NAMEPAR
        INT     21H
        LEA     SI,NAMEFLD
        MOV     AL,[SI]
        SUB     AL,48
        MOV     A22,AL
        MOV     AX,10
        MUL     A22
        MOV     A22,AL
        LEA     SI,NAMEFLD(1)
        MOV     AL,[SI]
        SUB     AL,48
        ADD     A22,AL

;LIMPIA PANTALLA

        MOV     AH,08H
        INT     10H
        MOV     BH,AH
        MOV     AX,0600H
        MOV     CX,0000
        MOV     DX,184FH
        INT     10H

;IMPRIMIR EN PANTALLA MENSAJE MSGB11

        MOV     AH,09H
        LEA     DX,MSGB11
        INT     21H

;LEE DESDE TECLADO Y LO TRASPASA A LA VARIABLE B11

        MOV     AH,0AH
        LEA     DX,NAMEPAR
        INT     21H
        LEA     SI,NAMEFLD
        MOV     AL,[SI]
        SUB     AL,48
        MOV     B11,AL
        MOV     AX,10
        MUL     B11
        MOV     B11,AL
        LEA     SI,NAMEFLD(1)
        MOV     AL,[SI]
        SUB     AL,48
        ADD     B11,AL

;LIMPIA PANTALLA

        MOV     AH,08H
        INT     10H
        MOV     BH,AH
        MOV     AX,0600H
        MOV     CX,0000
        MOV     DX,184FH
        INT     10H

;IMPRIMIR EN PANTALLA MENSAJE MSGB12

        MOV     AH,09H
        LEA     DX,MSGB12
        INT     21H

;LEE DESDE TECLADO Y LO TRASPASA A LA VARIABLE B12

        MOV     AH,0AH
        LEA     DX,NAMEPAR
        INT     21H
        LEA     SI,NAMEFLD
        MOV     AL,[SI]
        SUB     AL,48
        MOV     B12,AL
        MOV     AX,10
        MUL     B12
        MOV     B12,AL
        LEA     SI,NAMEFLD(1)
        MOV     AL,[SI]
        SUB     AL,48
        ADD     B12,AL

;LIMPIA PANTALLA

        MOV     AH,08H
        INT     10H
        MOV     BH,AH
        MOV     AX,0600H
        MOV     CX,0000
        MOV     DX,184FH
        INT     10H

;IMPRIMIR EN PANTALLA MENSAJE MSGB21

        MOV     AH,09H
        LEA     DX,MSGB21
        INT     21H

;LEE DESDE TECLADO Y LO TRASPASA A LA VARIABLE B21

        MOV     AH,0AH
        LEA     DX,NAMEPAR
        INT     21H
        LEA     SI,NAMEFLD
        MOV     AL,[SI]
        SUB     AL,48
        MOV     B21,AL
        MOV     AX,10
        MUL     B21
        MOV     B21,AL
        LEA     SI,NAMEFLD(1)
        MOV     AL,[SI]
        SUB     AL,48
        ADD     B21,AL

;LIMPIA PANTALLA

        MOV     AH,08H
        INT     10H
        MOV     BH,AH
        MOV     AX,0600H
        MOV     CX,0000
        MOV     DX,184FH
        INT     10H

;IMPRIMIR EN PANTALLA MENSAJE MSGB22

        MOV     AH,09H
        LEA     DX,MSGB22
        INT     21H

;LEE DESDE TECLADO Y LO TRASPASA A LA VARIABLE B22

        MOV     AH,0AH
        LEA     DX,NAMEPAR
        INT     21H
        LEA     SI,NAMEFLD
        MOV     AL,[SI]
        SUB     AL,48
        MOV     B22,AL
        MOV     AX,10
        MUL     B22
        MOV     B22,AL
        LEA     SI,NAMEFLD(1)
        MOV     AL,[SI]
        SUB     AL,48
        ADD     B22,AL

;LIMPIA PANTALLA

        MOV     AH,08H
        INT     10H
        MOV     BH,AH
        MOV     AX,0600H
        MOV     CX,0000
        MOV     DX,184FH
        INT     10H


;SUMA LAS MATRICES A Y B

        MOV     AH,A11
        ADD     AH,B11
        MOV     R11,AH

        MOV     AH,A12
        ADD     AH,B12
        MOV     R12,AH

        MOV     AH,A21
        ADD     AH,B21
        MOV     R21,AH

        MOV     AH,A22
        ADD     AH,B22
        MOV     R22,AH


;IMPRIMIR EN PANTALLA MENSAJE MSG

        MOV     AH,09H
        LEA     DX,MSG
        INT     21H

;TRANSFORMA LA VARIABLE R11 A ASCII

        MOV     AL,R11
        CBW
        MOV     DIVR,10
        DIV     DIVR
        ADD     AL,48
        ADD     AH,48
        MOV     ASCVAL(0),AL
        MOV     ASCVAL(1),AH

;UBICA EL CURSOR EN LA POSICION 2,1

        MOV     AH,02H
        MOV     BH,00H
        MOV     DH,2
        MOV     DL,1
        INT     10H

;IMPRIME LA VARIABLE R11 EN PANTALLA

        MOV     AH,09H
        LEA     DX,ASCVAL
        INT     21H

;TRANSFORMA LA VARIABLE R12 A ASCII

        MOV     AL,R12
        CBW
        MOV     DIVR,10
        DIV     DIVR
        ADD     AL,48
        ADD     AH,48
        MOV     ASCVAL(0),AL
        MOV     ASCVAL(1),AH

;UBICA EL CURSOR EN LA POSICION 2,4

        MOV     AH,02H
        MOV     BH,00H
        MOV     DH,2
        MOV     DL,4
        INT     10H

;IMPRIME LA VARIABLE R12 EN PANTALLA

        MOV     AH,09H
        LEA     DX,ASCVAL
        INT     21H

;TRANSFORMA LA VARIABLE R21 A ASCII

        MOV     AL,R21
        CBW
        MOV     DIVR,10
        DIV     DIVR
        ADD     AL,48
        ADD     AH,48
        MOV     ASCVAL(0),AL
        MOV     ASCVAL(1),AH

;UBICA EL CURSOR EN LA POSICION 3,1

        MOV     AH,02H
        MOV     BH,00H
        MOV     DH,3
        MOV     DL,1
        INT     10H

;IMPRIME LA VARIABLE R21 EN PANTALLA

        MOV     AH,09H
        LEA     DX,ASCVAL
        INT     21H

;TRANSFORMA LA VARIABLE R22 A ASCII

        MOV     AL,R22
        CBW
        MOV     DIVR,10
        DIV     DIVR
        ADD     AL,48
        ADD     AH,48
        MOV     ASCVAL(0),AL
        MOV     ASCVAL(1),AH

;UBICA EL CURSOR EN LA POSICION 3,4

        MOV     AH,02H
        MOV     BH,00H
        MOV     DH,3
        MOV     DL,4
        INT     10H

;IMPRIME LA VARIABLE R22 EN PANTALLA

        MOV     AH,09H
        LEA     DX,ASCVAL
        INT     21H


;UBICA EL CURSOR EN LA POSICION 3,4

        MOV     AH,02H
        MOV     BH,00H
        MOV     DH,10
        MOV     DL,1
        INT     10H

        MOV     AH,09H
        LEA     DX,MSG2
        INT     21H


;FINALIZA EL PROGRAMA Y VUELVE A DOS

        MOV     AX,4C00H
        INT 21H
BEGIN   ENDP
        END     BEGIN

flony

  • Nuevo Miembro
  • *
  • Mensajes: 4
    • Ver Perfil
Re:Suma de matrices
« Respuesta #1 en: Lunes 26 de Noviembre de 2012, 05:47 »
0
la verdad hice trampa el programa original es en c++ pero visualstudio permite ver el codigo en enssambler y es este
Código: [Seleccionar]
#include <iostream>
using namespace std;
int main()
{
01264EE0  push        ebp 
01264EE1  mov         ebp,esp 
01264EE3  sub         esp,184h 
01264EE9  push        ebx 
01264EEA  push        esi 
01264EEB  push        edi 
01264EEC  lea         edi,[ebp-184h] 
01264EF2  mov         ecx,61h 
01264EF7  mov         eax,0CCCCCCCCh 
01264EFC  rep stos    dword ptr es:[edi] 
01264EFE  mov         eax,dword ptr ds:[0126F0E0h] 
01264F03  xor         eax,ebp 
01264F05  mov         dword ptr [ebp-4],eax 
int matriz1 [2][2];
int matriz2 [2][2];
int matrizresultado[2][2];
int i,j;
//ingreso de datos matriz 1
for (int i = 0; i <=1 ; i++)
01264F08  mov         dword ptr [ebp-6Ch],0 
01264F0F  jmp         main+3Ah (01264F1Ah) 
01264F11  mov         eax,dword ptr [ebp-6Ch] 
01264F14  add         eax,1 
01264F17  mov         dword ptr [ebp-6Ch],eax 
01264F1A  cmp         dword ptr [ebp-6Ch],1 
01264F1E  jg          main+0AAh (01264F8Ah) 
{
for (int j = 0; j <=1; j++)
01264F20  mov         dword ptr [ebp-78h],0 
01264F27  jmp         main+52h (01264F32h) 
01264F29  mov         eax,dword ptr [ebp-78h] 
01264F2C  add         eax,1 
01264F2F  mov         dword ptr [ebp-78h],eax 
01264F32  cmp         dword ptr [ebp-78h],1 
01264F36  jg          main+0A8h (01264F88h) 
{
cout<<"ingrese valores primer matriz"<<endl;
01264F38  mov         esi,esp 
01264F3A  mov         eax,dword ptr ds:[01270328h] 
01264F3F  push        eax 
01264F40  push        126CE54h 
01264F45  mov         ecx,dword ptr ds:[1270334h] 
01264F4B  push        ecx 
01264F4C  call        std::operator<<<std::char_traits<char> > (012612ADh) 
01264F51  add         esp,8 
{
cout<<"ingrese valores primer matriz"<<endl;
01264F54  mov         ecx,eax 
01264F56  call        dword ptr ds:[127033Ch] 
01264F5C  cmp         esi,esp 
01264F5E  call        __RTC_CheckEsp (0126132Fh) 
cin>>matriz1[i][j];
01264F63  mov         eax,dword ptr [ebp-6Ch] 
01264F66  lea         ecx,matriz1[eax*8] 
01264F6A  mov         edx,dword ptr [ebp-78h] 
01264F6D  lea         eax,[ecx+edx*4] 
01264F70  mov         esi,esp 
01264F72  push        eax 
01264F73  mov         ecx,dword ptr ds:[1270394h] 
01264F79  call        dword ptr ds:[127032Ch] 
01264F7F  cmp         esi,esp 
01264F81  call        __RTC_CheckEsp (0126132Fh) 
}
01264F86  jmp         main+49h (01264F29h) 
}
01264F88  jmp         main+31h (01264F11h) 
//ingreso matriz 2
for (int i = 0; i<=1; i++)
01264F8A  mov         dword ptr [ebp-84h],0 
01264F94  jmp         main+0C5h (01264FA5h) 
01264F96  mov         eax,dword ptr [ebp-84h] 
01264F9C  add         eax,1 
01264F9F  mov         dword ptr [ebp-84h],eax 
01264FA5  cmp         dword ptr [ebp-84h],1 
01264FAC  jg          main+14Dh (0126502Dh) 
{
for (int j = 0; j <=1; j++)
01264FAE  mov         dword ptr [ebp-90h],0 
01264FB8  jmp         main+0E9h (01264FC9h) 
01264FBA  mov         eax,dword ptr [ebp-90h] 
01264FC0  add         eax,1 
01264FC3  mov         dword ptr [ebp-90h],eax 
01264FC9  cmp         dword ptr [ebp-90h],1 
01264FD0  jg          main+148h (01265028h) 
{
cout<<"ingrese valores segunda matriz"<<endl;
01264FD2  mov         esi,esp 
01264FD4  mov         eax,dword ptr ds:[01270328h] 
01264FD9  push        eax 
01264FDA  push        126CD18h 
01264FDF  mov         ecx,dword ptr ds:[1270334h] 
01264FE5  push        ecx 
01264FE6  call        std::operator<<<std::char_traits<char> > (012612ADh) 
01264FEB  add         esp,8 
01264FEE  mov         ecx,eax 
01264FF0  call        dword ptr ds:[127033Ch] 
01264FF6  cmp         esi,esp 
01264FF8  call        __RTC_CheckEsp (0126132Fh) 
cin>>matriz2[i][j];
01264FFD  mov         eax,dword ptr [ebp-84h] 
01265003  lea         ecx,matriz2[eax*8] 
01265007  mov         edx,dword ptr [ebp-90h] 
0126500D  lea         eax,[ecx+edx*4] 
01265010  mov         esi,esp 
01265012  push        eax 
01265013  mov         ecx,dword ptr ds:[1270394h] 
01265019  call        dword ptr ds:[127032Ch] 
0126501F  cmp         esi,esp 
01265021  call        __RTC_CheckEsp (0126132Fh) 
}
01265026  jmp         main+0DAh (01264FBAh) 
}
01265028  jmp         main+0B6h (01264F96h) 
//suma de matrices
for (int i = 0; i<=1; i++)
0126502D  mov         dword ptr [ebp-9Ch],0 
01265037  jmp         main+168h (01265048h) 
01265039  mov         eax,dword ptr [ebp-9Ch] 
0126503F  add         eax,1 
01265042  mov         dword ptr [ebp-9Ch],eax 
01265048  cmp         dword ptr [ebp-9Ch],1 
0126504F  jg          main+1D2h (012650B2h) 
{
for (int j = 0; j <=1; j++)
01265051  mov         dword ptr [ebp-0A8h],0 
0126505B  jmp         main+18Ch (0126506Ch) 
0126505D  mov         eax,dword ptr [ebp-0A8h] 
01265063  add         eax,1 
01265066  mov         dword ptr [ebp-0A8h],eax 
0126506C  cmp         dword ptr [ebp-0A8h],1 
01265073  jg          main+1D0h (012650B0h) 
{
matrizresultado[i][j]=matriz1[i][j]+matriz2[i][j];
01265075  mov         eax,dword ptr [ebp-9Ch] 
0126507B  lea         ecx,matriz1[eax*8] 
0126507F  mov         edx,dword ptr [ebp-9Ch] 
01265085  lea         eax,matriz2[edx*8] 
01265089  mov         edx,dword ptr [ebp-0A8h] 
0126508F  mov         ecx,dword ptr [ecx+edx*4] 
01265092  mov         edx,dword ptr [ebp-0A8h] 
01265098  add         ecx,dword ptr [eax+edx*4] 
0126509B  mov         eax,dword ptr [ebp-9Ch] 
012650A1  lea         edx,matrizresultado[eax*8] 
012650A5  mov         eax,dword ptr [ebp-0A8h] 
012650AB  mov         dword ptr [edx+eax*4],ecx 
}
012650AE  jmp         main+17Dh (0126505Dh) 
}
012650B0  jmp         main+159h (01265039h) 
//mostrar resultado
for (int i = 0; i<=1; i++)
012650B2  mov         dword ptr [ebp-0B4h],0 
012650BC  jmp         main+1EDh (012650CDh) 
012650BE  mov         eax,dword ptr [ebp-0B4h] 
012650C4  add         eax,1 
012650C7  mov         dword ptr [ebp-0B4h],eax 
012650CD  cmp         dword ptr [ebp-0B4h],1 
012650D4  jg          main+271h (01265151h) 
{
for (int j = 0; j <=1; j++)
012650D6  mov         dword ptr [ebp-0C0h],0 
012650E0  jmp         main+211h (012650F1h) 
012650E2  mov         eax,dword ptr [ebp-0C0h] 
012650E8  add         eax,1 
012650EB  mov         dword ptr [ebp-0C0h],eax 
012650F1  cmp         dword ptr [ebp-0C0h],1 
012650F8  jg          main+26Ch (0126514Ch) 
{
cout<<"el resultado es "<<matrizresultado[i][j]<<endl;
012650FA  mov         esi,esp 
012650FC  mov         eax,dword ptr ds:[01270328h] 
01265101  push        eax 
01265102  mov         ecx,dword ptr [ebp-0B4h] 
01265108  lea         edx,matrizresultado[ecx*8] 
0126510C  mov         edi,esp 
0126510E  mov         eax,dword ptr [ebp-0C0h] 
01265114  mov         ecx,dword ptr [edx+eax*4] 
01265117  push        ecx 
01265118  push        126CD50h 
0126511D  mov         edx,dword ptr ds:[1270334h] 
01265123  push        edx 
01265124  call        std::operator<<<std::char_traits<char> > (012612ADh) 
01265129  add         esp,8 
0126512C  mov         ecx,eax 
0126512E  call        dword ptr ds:[1270338h] 
01265134  cmp         edi,esp 
01265136  call        __RTC_CheckEsp (0126132Fh) 
0126513B  mov         ecx,eax 
0126513D  call        dword ptr ds:[127033Ch] 
01265143  cmp         esi,esp 
01265145  call        __RTC_CheckEsp (0126132Fh) 
}
0126514A  jmp         main+202h (012650E2h) 
}
0126514C  jmp         main+1DEh (012650BEh) 
getchar();
01265151  mov         esi,esp 
01265153  call        dword ptr ds:[1270470h] 
01265159  cmp         esi,esp 
0126515B  call        __RTC_CheckEsp (0126132Fh) 
system("PAUSE");
01265160  mov         esi,esp 
01265162  push        126CD64h 
01265167  call        dword ptr ds:[1270484h] 
0126516D  add         esp,4 
01265170  cmp         esi,esp 
01265172  call        __RTC_CheckEsp (0126132Fh) 
return 0;
01265177  xor         eax,eax 
}
01265179  push        edx 
0126517A  mov         ecx,ebp 
0126517C  push        eax 
0126517D  lea         edx,ds:[12651A8h] 
01265183  call        @_RTC_CheckStackVars@8 (01261127h) 
01265188  pop         eax 
01265189  pop         edx 
0126518A  pop         edi 
0126518B  pop         esi 
0126518C  pop         ebx 
0126518D  mov         ecx,dword ptr [ebp-4] 
01265190  xor         ecx,ebp 
01265192  call        @__security_check_cookie@4 (01261041h) 
01265197  add         esp,184h 
0126519D  cmp         ebp,esp 
0126519F  call        __RTC_CheckEsp (0126132Fh) 
012651A4  mov         esp,ebp 
012651A6  pop         ebp 
012651A7  ret 
012651A8  add         eax,dword ptr [eax] 
012651AA  add         byte ptr [eax],al 
012651AC  mov         al,51h 
012651AE  add         eax,ebp 
012651B1  ?? ??
012651B2  ?? ??
012651B3  call        dword ptr [eax] 
012651B5  add         byte ptr [eax],al 
012651B7  add         ah,ch 
012651B9  push        ecx 
012651BA  add         eax,edx 
012651BD  ?? ??
012651BE  ?? ??
012651BF  call        dword ptr [eax] 
012651C1  add         byte ptr [eax],al 
012651C3  add         ah,ah 
012651C5  push        ecx 
012651C6  add         dword ptr es:[eax+10FFFFFFh],edi 
012651CD  add         byte ptr [eax],al 
012651CF  add         ah,dl 
012651D1  push        ecx 
012651D2  add         dword ptr es:[ebp+61h],ebp 
012651D6  je          std::_Container_base12::_Orphan_all+4h (0126524Ah) 
012651D8  imul        edi,dword ptr [edx+72h],6C757365h 
012651DF  je          std::_Container_base12::~_Container_base12+2h (01265242h) 
012651E1  outs        dx,dword ptr fs:[esi] 
012651E3  add         byte ptr [ebp+61h],ch 
012651E6  je          std::_Xout_of_range+2h (0126525Ah) 
012651E8  imul        edi,dword ptr [edx+32h],74616D00h 
012651EF  jb          std::_Xout_of_range+2h (0126525Ah) 
012651F1  jp          _main+344h (01265224h) 
012651F3  add         ah,cl