Ну ти достанеш кого завгодно..
Невже я так не зрозуміло поясню...
Я ж казав..
в Фасмі команди-кр580 будуть макросами...
зроби мені в залежності від прапорів "нуля" та "знаку"
конструкції типа в кр-580
RNZ, JNZ, CNZ
RZ,  JZ,  CZ
RP,  JP,  CP,
RM, JM,  CM
як вони будуть на фасмі, якщо
прапори це [RAM + PZ] = прапор нуля
[RAM + PS] - прапор знаку
От "нагороди" мені в фасмі конструкції такі!
Чого ти в якісь дебрі поліз ?!

Use32
RAMBloks       equ 10
SizeRAMBytes   equ RAMBloks*2
;section '.data' data readable writeable
RAM     rb SizeRAMBytes               ; масив байтів
RAMw    = RAM                         ; Word-масив з тих самих байтів
RAMc    = RAM                         ; Cardinal-масив (DWORD) з тих самих
; однобайтові регістри (RgX)
RgF     equ 0
RgA     equ 1
RgC     equ 2
RgB     equ 3
RgE     equ 4
RgD     equ 5
RgL     equ 6
RgH     equ 7
; парні регістри (16-бітні)
RpAF    equ 0
RpBC    equ 1
RpDE    equ 2
RpHL    equ 3
RpSP    equ 4
; прапори
PZ      equ 10
PS      equ 11
; macro

macro NOP_ {}

macro ReadRg Rg2 {
mov al, [RAM + Rg2] }       ; завантажити регістр

macro WriteRg Rg1 {
mov [RAM + Rg1], al  }       ; записати регістр

                   
macro Rg1rV Rg1,V {
mov [RAM + Rg1], V
}
macro Rg1rRg2 Rg1,Rg2 {
ReadRg Rg2
Rg1rV Rg1,al
}
; MVI
macro Br V {Rg1rV RgB,V}
macro Cr V {Rg1rV RgC,V}
macro Dr V {Rg1rV RgD,V}
macro Er V {Rg1rV RgE,V}
macro Hr V {Rg1rV RgH,V}
macro Lr V {Rg1rV RgL,V}
macro Ar V {Rg1rV RgA,V}

; MOV
macro BrB {Rg1rRg2 RgB, RgB}
macro BrC {Rg1rRg2 RgB, RgC}
macro BrD {Rg1rRg2 RgB, RgD}
macro BrE {Rg1rRg2 RgB, RgE}
macro BrH {Rg1rRg2 RgB, RgH}
macro BrL {Rg1rRg2 RgB, RgL}
macro BrA {Rg1rRg2 RgB, RgA}

macro CrB {Rg1rRg2 RgC, RgB}
macro CrC {Rg1rRg2 RgC, RgC}
macro CrD {Rg1rRg2 RgC, RgD}
macro CrE {Rg1rRg2 RgC, RgE}
macro CrH {Rg1rRg2 RgC, RgH}
macro CrL {Rg1rRg2 RgC, RgL}
macro CrA {Rg1rRg2 RgC, RgA}

macro DrB {Rg1rRg2 RgD, RgB}
macro DrC {Rg1rRg2 RgD, RgC}
macro DrD {Rg1rRg2 RgD, RgD}
macro DrE {Rg1rRg2 RgD, RgE}
macro DrH {Rg1rRg2 RgD, RgH}
macro DrL {Rg1rRg2 RgD, RgL}
macro DrA {Rg1rRg2 RgD, RgA}

macro ErB {Rg1rRg2 RgE, RgB}
macro ErC {Rg1rRg2 RgE, RgC}
macro ErD {Rg1rRg2 RgE, RgD}
macro ErE {Rg1rRg2 RgE, RgE}
macro ErH {Rg1rRg2 RgE, RgH}
macro ErL {Rg1rRg2 RgE, RgL}
macro ErA {Rg1rRg2 RgE, RgA}

macro HrB {Rg1rRg2 RgH, RgB}
macro HrC {Rg1rRg2 RgH, RgC}
macro HrD {Rg1rRg2 RgH, RgD}
macro HrE {Rg1rRg2 RgH, RgE}
macro HrH {Rg1rRg2 RgH, RgH}
macro HrL {Rg1rRg2 RgH, RgL}
macro HrA {Rg1rRg2 RgH, RgA}

macro LrB {Rg1rRg2 RgL, RgB}
macro LrC {Rg1rRg2 RgL, RgC}
macro LrD {Rg1rRg2 RgL, RgD}
macro LrE {Rg1rRg2 RgL, RgE}
macro LrH {Rg1rRg2 RgL, RgH}
macro LrL {Rg1rRg2 RgL, RgL}
macro LrA {Rg1rRg2 RgL, RgA}

macro ArB {Rg1rRg2 RgA, RgB}
macro ArC {Rg1rRg2 RgA, RgC}
macro ArD {Rg1rRg2 RgA, RgD}
macro ArE {Rg1rRg2 RgA, RgE}
macro ArH {Rg1rRg2 RgA, RgH}
macro ArL {Rg1rRg2 RgA, RgL}
macro ArA {Rg1rRg2 RgA, RgA}

macro INC_ Rg1 { inc [RAM + Rg1]}
macro Bp1 { INC_ RgB }
macro Cp1 { INC_ RgC }
macro Dp1 { INC_ RgD }
macro Ep1 { INC_ RgE }
macro Hp1 { INC_ RgH }
macro Lp1 { INC_ RgL }
macro Ap1 { INC_ RgA }

macro Dec_ Rg1 {Dec [RAM + Rg1]}
macro Bm1 { Dec_ RgB }
macro Cm1 { Dec_ RgC }
macro Dm1 { Dec_ RgD }
macro Em1 { Dec_ RgE }
macro Hm1 { Dec_ RgH }
macro Lm1 { Dec_ RgL }
macro Am1 { Dec_ RgA }

;{ADD};ReadRg RgA ;ADD al,V ;WriteRg RgA      macro ApB { ReadRg RgB
macro Ap V { add [RAM + RgA],V }
                             
macro ApB { ReadRg RgB
             add [RAM + RgA],al             
                }
macro ApC { ReadRg RgC
             add [RAM + RgA],al             
                }
macro ApD { ReadRg RgD
             add [RAM + RgA],al             
                }
macro ApE { ReadRg RgE
             add [RAM + RgA],al             
                }
macro ApH { ReadRg RgH
             add [RAM + RgA],al             
                }
macro ApL { ReadRg RgL
             add [RAM + RgA],al             
                }
macro ApA { ReadRg RgA
             add [RAM + RgA],al             
                }                               

                                               

;{SUB}
macro Am V { sub [RAM + RgA],V }

macro AmB { ReadRg RgB
             sub [RAM + RgA],al
                }
macro AmC { ReadRg RgC
             sub [RAM + RgA],al
                }
macro AmD { ReadRg RgD
             sub [RAM + RgA],al
                }
macro AmE { ReadRg RgE
             sub [RAM + RgA],al
                }
macro AmH { ReadRg RgH
             sub [RAM + RgA],al
                }
macro AmL { ReadRg RgL
             sub [RAM + RgA],al
                }
macro AmA { ReadRg RgA
             sub [RAM + RgA],al
                }               

;{AND}
macro Ai V { AND [RAM + RgA],V }

macro AiB { ReadRg RgB
             AND [RAM + RgA],al
                }
macro AiC { ReadRg RgC
             AND [RAM + RgA],al
                }
macro AiD { ReadRg RgD
             AND [RAM + RgA],al
                }
macro AiE { ReadRg RgE
             AND [RAM + RgA],al
                }
macro AiH { ReadRg RgH
             AND [RAM + RgA],al
                }
macro AiL { ReadRg RgL
             AND [RAM + RgA],al
                }
macro AiA { ReadRg RgA
             AND [RAM + RgA],al
                }               

;{XOR}
macro Ax_ V { XOR [RAM + RgA],V }

macro AxB { ReadRg RgB
             XOR [RAM + RgA],al
                }
macro AxC { ReadRg RgC
             XOR [RAM + RgA],al
                }
macro AxD { ReadRg RgD
             XOR [RAM + RgA],al
                }
macro AxE { ReadRg RgE
             XOR [RAM + RgA],al
                }
macro AxH { ReadRg RgH
             XOR [RAM + RgA],al
                }
macro AxL { ReadRg RgL
             XOR [RAM + RgA],al
                }
macro AxA { ReadRg RgA
             XOR [RAM + RgA],al
                }               

;{OR}
macro Ao V { OR [RAM + RgA],V }

macro AoB { ReadRg RgB
             OR [RAM + RgA],al
                }
macro AoC { ReadRg RgC
             OR [RAM + RgA],al
                }
macro AoD { ReadRg RgD
             OR [RAM + RgA],al
                }
macro AoE { ReadRg RgE
             OR [RAM + RgA],al
                }
macro AoH { ReadRg RgH
             OR [RAM + RgA],al
                }
macro AoL { ReadRg RgL
             OR [RAM + RgA],al
                }
macro AoA { ReadRg RgA
             OR [RAM + RgA],al
                }               
               
   pAcmpz:; {RGA cmp al}
       mov bl,[RAM + RgA]
       cmp bl,al
       jne Acmpz_nopez
       mov byte [RAM + PZ], 1
       jmp Acmpz_donez
     Acmpz_nopez:
       mov byte [RAM + PZ], 0
     Acmpz_donez:
            Ret

macro Acmpz V {
     Mov al,V
     Call pAcmpz
       }
     
macro AcmpzB {
     ReadRg RgB
     Call pAcmpz
     } 

macro AcmpzC {
     ReadRg RgC
     Call pAcmpz
      }

macro AcmpzD {
     ReadRg RgD
     Call pAcmpz  }
               
macro AcmpzE {
     ReadRg RgE
     Call pAcmpz  }
               
macro AcmpzH {
     ReadRg RgH
     Call pAcmpz  }
               
macro AcmpzL {
     ReadRg RgL
     Call pAcmpz  }
               
macro AcmpzA {
     ReadRg RgA
     Call pAcmpz  }

  pAcmps:; RgA cmp al
    mov bl, [RAM + RgA]
    cmp bl, al
    jae Acmps_nopes
    mov byte [RAM + PS], 1
    jmp Acmps_dones
  Acmps_nopes:
    mov byte [RAM + PS], 0
  Acmps_dones:
        Ret
       
macro Acmps V {
     Mov al,V
     Call pAcmps
       }

macro AcmpsB {
     ReadRg RgB
     Call pAcmps
     }

macro AcmpsC {
     ReadRg RgC
     Call pAcmps
      }

macro AcmpsD {
     ReadRg RgD
     Call pAcmps  }

macro AcmpsE {
     ReadRg RgE
     Call pAcmps  }

macro AcmpsH {
     ReadRg RgH
     Call pAcmps  }

macro AcmpsL {
     ReadRg RgL
     Call pAcmps  }

macro AcmpsA {
     ReadRg RgA
     Call pAcmps  }
     
macro notA{
  not byte [RAM + RgA]
      }

macro shlA {
  shl byte [RAM + RgA],1
}

macro shrA {
shr byte [RAM + RgA],1
}

           
           
           
macro GotoUn0 adr { ;JZ_
    cmp byte [RAM + PZ], 0
    je adr
}

macro GotoUnNot0 adr { ;JNZ_
    cmp byte [RAM + PZ], 0
    jne adr
}
macro GotoUnP adr { ;JP_
    cmp byte [RAM + PS], 0
    je adr
}
macro GotoUnM adr { ;JM
    cmp byte [RAM + PS], 0
    jne adr
}
macro CallUn0 adr { ;CZ
    cmp byte [RAM + PZ], 0
    je CallUn0__doCall
    jmp CallUn0__skipCall
  CallUn0__doCall:
    call adr
  CallUn0__skipCall:
}
 
macro CallUnNot0 adr { ;CNZ
    cmp byte [RAM + PZ], 0
    jne CallUnNot0__doCall
    jmp CallUnNot0__skipCall
  CallUnNot0__doCall:
    call adr
  CallUnNot0__skipCall:
}         
macro CallUnP adr { ;CP
    cmp byte [RAM + PS], 0
    je CallUnP__doCall
    jmp CallUnP__skipCall
  CallUnP__doCall:
    call adr
  CallUnP__skipCall:
}
macro CallUnM adr { ;CM
    cmp byte [RAM + PS], 0
    jne CallUnM__doCall
    jmp CallUnM__skipCall
  CallUnM__doCall:
    call adr
  CallUnM__skipCall:
}
macro RetUn0 {;RZ
    cmp byte [RAM + PZ], 0
    je RetUn0__doRet
    jmp RetUn0__skipRet
  RetUn0__doRet:
    ret
  RetUn0__skipRet:
}
macro RetUnNot0 { ;RNZ
    cmp byte [RAM + PZ], 0
    jne RetUnNot0__doRet
    jmp RetUnNot0__skipRet
  RetUnNot0__doRet:
    ret
  RetUnNot0__skipRet:
}
macro RetUnP { ;RP_
    cmp byte [RAM + PS], 0
    je RetUnP__doRet
    jmp RetUnP__skipRet
  RetUnP__doRet:
    ret
  RetUnP__skipRet:
}
macro RetUnM {;RM
    cmp byte [RAM + PS], 0
    jne RetUnM__doRet
    jmp RetUnM__skipRet
  RetUnM__doRet:
    ret
  RetUnM__skipRet:
}

macro _rA W {; AX  ; begin RAM[w]:=RAM[RgA];{P}end;
        mov AX,W
        movzx eax,ax
     mov dl,[RAM + RgA]
     mov [eax+RAM],dl
}
   
macro Ar_ W {; AX             begin RAM[RgA]:=RAM[w];{P}end;
        mov AX,W
        movzx eax,ax
     mov al,[eax+RAM]
       mov [RAM + RgA],al
}

macro ArmBC {
   movzx eax,[RAM + (RpBC*2)]
mov al,[eax+RAM]
mov [RAM + RgA], al
}

macro ArmDE {
   movzx eax,[RAM + (RpDE*2)]
mov al,[eax+RAM]
mov [RAM + RgA], al
}
     macro rmHL Rg1 {
movzx eax,[RAM + (RpHL*2)]
mov al,[eax+RAM]
mov [RAM + Rg1], al
}     
macro ArmHL {
rmHL RgA
}
macro BrmHL {
rmHL RgB
}
macro CrmHL {
rmHL RgC
}
macro DrmHL {
rmHL RgD
}
macro ErmHL {
rmHL RgE
}
macro HrmHL {
rmHL RgH
}
macro LrmHL {
rmHL RgL
}

macro  mHLr V {;(b:byte);begin RAM[RAMw[RpHL]]:=b;{P}end;
   movzx edx,[RAM + (RpHL*2)]
mov [edx+RAM],V
}
macro  mHLrB {
ReadRg RgB
mHLr al
}
macro  mHLrC {
ReadRg RgC
mHLr al
}
macro  mHLrD {
ReadRg RgD
mHLr al
}
macro  mHLrE {
ReadRg RgE
mHLr al
}
macro  mHLrH {
ReadRg RgH
mHLr al
}
macro  mHLrL {
ReadRg RgL
mHLr al
}
macro mHLrA {
ReadRg RgA
mHLr al
}

macro ApmHL {
movzx eax,[RAM + (RpHL*2)]
mov al,[eax+RAM]
Ap al
}

unit uFORM;

interface
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, ExtCtrls;

type
  TForm1 = class(TForm)
    Timer1: TTimer;
    procedure FormClose(Sender: TObject; var Action: TCloseAction);
    procedure FormDblClick(Sender: TObject);
    procedure Timer1Timer(Sender: TObject);
    procedure ClearMainCanvas;
    procedure CanvasStretchDraw;
    procedure FormCreate(Sender: TObject);
    procedure StartProgram;
  private
    { Private declarations }
  public
    { Public declarations }
  end;

var
  Form1: TForm1;
  var MainCanvas: tbitmap;
SizeScreenX:Integer=-32760;{Розмір екрану X (встановлений через InitGraph)}
SizeScreenY:Integer=-32760;{Розмір екрану Y (встановлений через InitGraph)}
fCreateFORM:Boolean=false;{Ініціалізація та створення форми, True - форма створена та ініціалізована}
var VideoRAM:array[0..640,0..480] of Cardinal;{Масив відео, для піксельного порівняння, перед виводом на MainCanvas}

procedure INITuFORM;{Ініціалізація та створення форми при умові (fCreateFORM=false) та (Stub.ModeStartDE=4)}
procedure InitGraphForm(var GraphDriver : integer;var GraphMode   : integer);{вмикання “графічного режиму” для форми по аналогії InitGraph}

implementation
uses uProgram;

{$R *.dfm}
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);{Якщо користувач закриває форму, (жме “хрестик” форми), відбувається вихід}begin Halt;end;
procedure TForm1.CanvasStretchDraw;{виведення MainCanvas на екран}begin Canvas.StretchDraw(rect(0,0,Form1.ClientWidth,Form1.ClientHeight),MainCanvas);end;

procedure TForm1.Timer1Timer(Sender: TObject);{перемальовує форму згідно встановленого Timer1.Inerval:=20, тобто 20/1000 = 50 разів в секунду}
begin //CanvasStretchDraw;
StartProgram;
end;
procedure TForm1.FormDblClick(Sender: TObject);{подвійний клик на формі — розмір форми згідно встановленого режиму}begin Form1.ClientWidth:=SizeScreenX;Form1.ClientHeight:=SizeScreenY;end;
procedure TForm1.ClearMainCanvas;{Очищення MainCanvas та  VideoRAM}
var cx,cy:Cardinal;
begin for cY:=0 to SizeScreenY do for cX:=0 to SizeScreenX do If fCreateFORM=true then MainCanvas.Canvas.Pixels[cX,cY]:=0;
for cY:=0 to SizeScreenY do for cX:=0 to SizeScreenX do VideoRAM[cX,cY]:=0;end;

procedure InitGraphForm(var GraphDriver : integer;var GraphMode   : integer);{вмикання “графічного режиму” для форми по аналогії InitGraph}
const VGA=9; VGALo=0; VGAMed=1; VGAHi=2;
begin
case   GraphDriver of
VGA: case GraphMode of
VGALo:Begin{ 640x200 16 color 4 page } end;
VGAMed:Begin { 640x350 16 color 2 page } end;
VGAHi:Begin { 640x480 16 color 1 page } SizeScreenX:=639;SizeScreenY:=479;end;
end; end;

If ((SizeScreenX>0) and (SizeScreenY>0)) then Begin
  If fCreateFORM=true then begin
MainCanvas.Width:=SizeScreenX+1; MainCanvas.Height:=SizeScreenY+1;
Form1.ClearMainCanvas;
Form1.ClientWidth:=SizeScreenX;Form1.ClientHeight:=SizeScreenY;
Form1.Visible:=True;end;
end else begin {видача помилки}GraphDriver:=-2; GraphMode:=-2;end;
end;

procedure INITuFORM;{Ініціалізація та створення форми при умові (fCreateFORM=false) та (Stub.ModeStartDE=4)}
begin
If (fCreateFORM=false) {and (Stub.ModeStartDE=4)} then Begin
fCreateFORM:=True;
Application.Initialize;
Application.CreateForm(TForm1, Form1);
MainCanvas:=tbitmap.Create;
Form1.Show;
Form1.HIDE;
SizeScreenX:=-32760; SizeScreenY:=-32760;

{ExtractFilePath_:=ExtractFilePath(Application.ExeName);}
end;
end;
procedure TForm1.FormCreate(Sender: TObject);
begin
Form1.ClientWidth:=0;Form1.ClientHeight:=0;
end;

var CallAPMValue:Cardinal=0;{номер апм}
var PraporHALT:Cardinal=0;{прапор виходу}
procedure TForm1.StartProgram;   label BEGINProgram,ENDProgram;
                                 label APM,APM1end;
begin
if PraporHALT=1 then begin Timer1.Enabled:=False; end
                Else {PraporHALT=0}
begin                           begin case CallAPMValue of  0:begin end;
                                  //  1:Begin goto APM1end;end;
                                end; end;

BEGIN
BEGINProgram:

//{APM}begin CallAPMValue:={номер APM}1;Goto APM;end;APM1end:CallAPMValue:=0;

ENDProgram:
END;          PraporHALT:=1;  APM:end; {PraporHALT=0} end;
end.

Max Size FORM 112..1836, 27..616

Form1.ClientWidth:=104;Form1.ClientHeight:=0;
Form1.ClientWidth:=1828;Form1.ClientHeight:=589;