PROGRAM MandelBrot;
USES Crt,Dos;
CONST
  VGASegment = $0A000;
  xres = 160;
  yres = 100;
VAR
 i,x,y   : Integer;
 ch      : Char;
 a,b,ao,
 bo,abs  : Real;

PROCEDURE InitGraph(k : Byte);         {Inits Graph/Textmode}
VAR
  g : Byte;
BEGIN
  CASE k OF
    1 : g := $03;     {Inits 80x25 Textmode}
    2 : g := $13;     {Inits 320x200x256 Graphmode}
    3 : g := $12;     {Inits 640x480x16 Graphmode}
  END;

  ASM
    MOV AH,$00
    MOV AL,g
    INT $10           {Inits new mode}
  END;
END;

PROCEDURE PutPixel(x,y : Word; col : Byte);
VAR
  Mempos : Word;
BEGIN
  Mempos := (y-1)*320 + (x-1);
  Mem[VGASegment:Mempos] := col; {Givs memory position mempos the value of col}
END;


{PROCEDURE PutPixel(x,y : Word; col : Byte);
BEGIN
  ASM
    MOV AH,$0C
    MOV AL,col
    MOV CX,x
    MOV DX,y
    INT $10
  END;
END;}

BEGIN
{  ASM
    MOV AX,$4F02
    MOV BX,$101
    INT $10
  END;}
  InitGraph(2);
  FOR x := -xres TO xres DO
    FOR y := -yres TO 0 DO BEGIN
      a := x/50;
      b := y/50;
      i := 1;
      REPEAT
        abs := a*a+b*b;
        IF abs > 4 THEN BEGIN
          PutPixel(x+xres,y+yres,i+16);
          PutPixel(x+xres,yres-y,i+16);
        END
        ELSE BEGIN
          ao := a;
          bo := b;
          a := ao*ao-bo*bo+x/50;
          b := 2*ao*bo+y/50;
          Inc(i);
        END;
      UNTIL  (i = 100) OR (abs > 4);
    END;
  ch := ReadKey;
END.

code   SEGMENT para PUBLIC 'code'
       ASSUME cs:code
       LOCALS
       .386

       JMP Main

InitG  PROC NEAR

       INT  10

       RET
       ENDP

Random PROC NEAR
       MOV  EAX,1107030247
       MOV  EBX,DS:seed
       MUL  EBX
       ADD  EAX,97177
       MOV  DS:seed,EAX
       SHR  EAX,15
       AND  AX,8191
       RET
       ENDP

StartV PROC NEAR
       MOV  CX,70

pix1:  CALL Random
       MOV  BX,41
       DIV  BX
       MOV  SI,CX
       ADD  SI,100
       MOV  DS:[SI],AX
       LOOP pix1

       MOV  CX,70
pix2:  CALL Random
       MOV  BX,26
       DIV  BX
       MOV  SI,CX
       ADD  SI,200
       MOV  DS:[SI],AX
       LOOP pix2

       RET
       ENDP

Scroll PROC NEAR
       MOV  CX,70
Ppix:  MOV  SI,CX
       MOV  AX,DS:[SI+100]
       INC  AX
       MOV  DS:[SI],AX
       DEC  AX
       MOV  BX,DS:[SI+200]
       INC  BX
       MOV  DS:[SI],BX
       DEC  BX
       MUL  BX
       MOV  SI,AX
       MOV  BX,15
       MOV  0A000h:[SI],BX
       LOOP Ppix


       RET
       ENDP

Main   PROC NEAR
       MOV  AH,13h
       CALL InitG
       CALL StartV
       CALL Ppix
       MOV  AH,06h
       MOV  DL,0FFh
       INT  21h
       MOV  AH,3
       CALL InitG
       ENDP

seed   dd  0

code   ENDS
       END

CONST
  VGASegment = $0A000;

VAR
  x,y : Integer;

PROCEDURE SetColor(color,R,G,B:Byte);
BEGIN
	Port[$3C8] := color;
	Port[$3C9] := R;
	Port[$3C9] := G;
	Port[$3C9] := B;
END;

PROCEDURE InitGraph(k : Byte);         {Inits Graph/Textmode}
VAR
  g : Byte;
BEGIN
  CASE k OF
    1 : g := $03;     {Inits 80x25 Textmode}
    2 : g := $13;     {Inits 320x200x256 Graphmode}
    3 : g := $12;     {Inits 640x480x16 Graphmode}
  END;

  ASM
    MOV AH,$00
    MOV AL,g
    INT $10           {Inits new mode}
  END;
END;

PROCEDURE InitVESAGraph(k : Byte);
VAR
  g : Word;
BEGIN
  CASE k OF
    1 : g := $100;              {640*400*256}
    2 : g := $101;              {640*480*256}
    3 : g := $102;              {800*600*16}
    4 : g := $103;              {800*600*256}
    5 : g := $104;              {1024*768*16}
    6 : g := $105;              {1024*768*256}
    7 : g := $106;              {1280*1024*16}
    8 : g := $107;              {1280*1024*256}
  END;
  ASM
    MOV AX,$4F02
    MOV BX,g
    MOV CX,0
    MOV DX,0
    INT $10
    MOV g,AX
  END;
  Write(g);
END;

PROCEDURE PutPixel(x,y : Word; col : Byte);
VAR
  Mempos : Word;
BEGIN
  IF (x > 1) AND (x < 321) AND (y > 1) AND (y < 201) THEN BEGIN
    Mempos := (y-1)*320 + (x-1);
    Mem[VGASegment:Mempos] := col; {Givs memory position mempos the value of col}
  END;
END;

PROCEDURE PutPixelAG(x,y : Word; Col : Byte);
BEGIN
  ASM
    MOV AH,$0C
    MOV AL,Col
    MOV CX,x
    MOV DX,y
    INT $10
  END;
END;

PROCEDURE PutPixelVESA(x,y : Word; col : Byte);
BEGIN

END;

PROCEDURE ClearScr;
BEGIN
  FOR i := 1 TO 64000 DO
    Mem[$A000:i] := 0;
END;

FUNCTION GetPixelAG(x,y : Word) : Byte;
VAR
  g : Byte;
BEGIN
  ASM
    MOV AH,$0D
    MOV CX,x
    MOV DX,y
    INT $10
    MOV g,AL
  END;
  GetPixelAG := g;
END;

FUNCTION GetPixel(x,y : Word) : Byte;
VAR
  Mempos : Word;
BEGIN
  IF (x > 1) AND (x < 321) AND (y > 1) AND (y < 201) THEN BEGIN
    Mempos := (y-1)*320 + (x-1);
    GetPixel := Mem[VGASegment:Mempos]; {Givs memory position mempos the value of col}
  END
  ELSE
    GetPixel := 0;
END;

PROCEDURE WriteString(x,y : Byte; col : Byte; s : STRING; bi : Boolean);
VAR
  g : Byte;
BEGIN
  ASM
    MOV AH,$02
    MOV DH,y
    MOV DL,x
    MOV BH,$0
    INT $10
  END;
  FOR i := 1 TO Length(s) DO BEGIN
    g := Ord(s[i]);
    ASM
      MOV AH,$0E
      MOV AL,g
      MOV BL,col
      INT $10
    END;
    IF bi THEN BEGIN
    {  Sound(1000);
      Delay(15);
      NoSound;
      Delay(30);}
    END;
  END;
END;

PROCEDURE LoadImage(s : STRING);
VAR
  pix   : FILE;
  R,G,B : Byte;
  ext   : Word;

BEGIN
  Assign(pix,s);
  Reset(pix,1);
  FOR i := 1 TO 10 DO
    BlockRead(pix,ch,SizeOf(ch));

  FOR i := 0 TO 255 DO BEGIN
    BlockRead(pix,ch,SizeOf(ch));
    R := Ord(ch);
    BlockRead(pix,ch,SizeOf(ch));
    G := Ord(ch);
    BlockRead(pix,ch,SizeOf(ch));
    B := Ord(ch);
    SetColor(i,R,G,B);
  END;

  BlockRead(pix,Mem[$A000:0],$FA00);
 { Move(Mem[$9000:0],Mem[$A000:0],$FA00);

  ext := EMBGetMem(64);
  MoveToEMB(Mem[$A000:0],ext,$FA00);
  ClearScr;
  ch := ReadKey;
  MoveFromEMB(ext,Mem[$A000:0],$FA00);}
END;

PROCEDURE ReadPCX(s : String);
VAR
  image   : ARRAY[1..64000] OF Byte;
  pic     : FILE;
  n       : Integer;
  k,R,G,B : Byte;

BEGIN
  Assign(pic,s);
  Reset(pic,1);

  FOR i := 0 TO 255 DO
    SetColor(i,0,0,0);

  FOR i := 1 TO 128 DO
    BlockRead(pic,k,SizeOf(k));

  i:=0;
    REPEAT
      Blockread(pic,k,SizeOf(k));
        k := k AND $FF;
        IF (k AND $C0) = $C0 THEN BEGIN
          n := k AND $3F;
          Blockread(pic,k,SizeOf(k));
          FOR R := 1 TO n DO BEGIN
            Mem[$A000:(y-1)*320+x] := k;
            Inc(x);
          END;
        END
        ELSE BEGIN
          Mem[$A000:(y-1)*320+x] := k;
          Inc(x);
        END;
    UNTIL x>=64000 ;

    BlockRead(pic,ch,SizeOf(ch));

  FOR i := 0 TO 255 DO BEGIN
    BlockRead(pic,R,SizeOf(R));
    R := R SHR 2;
    BlockRead(pic,G,SizeOf(G));
    G := G SHR 2;
    BlockRead(pic,B,SizeOf(B));
    B := B SHR 2;
    SetColor(i,R,G,B);
  END;
{  Move(Mem[$9000:0],Mem[$A000:0],$FA00);}

  Close(pic);
END;

repeat 4 [forward 50 right 90]