program feldrechnen;
uses crt;

const max : byte = 40;

type ziffertyp = 0..9;
type zahlrec   = record
                   zi: array[1..40] of ziffertyp;   {Ziffern}
                   vz: boolean;                     {Vorzeichen (- ist true)}
                   ex: integer;                     {*10^exp}
                  end;

var zahl1, zahl2, zahl3 : zahlrec;
    i, len1, len2, len3 : word;

procedure eingabe(var zahl: zahlrec; var len : word);

  var speicher : zahlrec;
      ch       : char;
      i        : word;
      code     : integer;

  begin
    writeln('Zahl  eingeben : ');
    for I:=1 to max do speicher.zi[i]:=0;
    i:=0;
    ch:=readkey;
    write(ch);
    if ch='-' then zahl.vz:=true else zahl.vz:=false;
    repeat
      ch:=readkey;
      if (ch>='0') and (ch<='9') then
        begin
          write(ch);
          i:=i+1;
          val(ch, speicher.zi[i], code);
        end;
    until (ch=chr(13)) or (ch='E') or (ch='e');
    len:=i;
    ch:=upcase(ch);
    zahl.ex:=0;
    if ch='E' then write('E');
    if ch='E' then read(zahl.ex) else zahl.ex:=0;
    for i:=len downto 1 do
      begin
        zahl.zi[max-len+i]:=speicher.zi[i];
      end;
    if (ch<>'E') then writeln;
    zahl.ex:=0;
  end;

procedure newexponent(var zahl: zahlrec);

  var i, ver : integer;

  begin {verschieben nach rechts bis Ende keinen Null mehr}
    ver:=max;
    while zahl.zi[ver]=0 do
      ver:=ver-1;
    ver:=max-ver;
    if ver>0 then
      for i:=max-ver downto 1 do
        zahl.zi[i+ver]:=zahl.zi[i];
    zahl.zi[1]:=0;
    if ver>0 then zahl.ex:=zahl.ex+ver;
  end;

procedure ausgabe(zahl: zahlrec);

  var i, len : integer;

  begin
    len:=1;
    newexponent(zahl);
    while zahl.zi[len]=0 do
      len:=len+1;
    if zahl.vz=true then write('-') else write('+');
    for i:=len to max do
      begin
        write(zahl.zi[i]);
        if (((max-i) mod 3) = 0) and (i<max) then write('.');
      end;
    if len=24 then write('0');
    if zahl.ex<>0 then write('E', zahl.ex);
    writeln;
  end;

function stlesen(zahl: zahlrec; pos: integer): ziffertyp;
   begin
     pos:=max-(pos-zahl.ex);
     if (pos>max) or (pos<1) then stlesen:=0 else stlesen:=zahl.zi[pos];
   end;

procedure stschr(var zahl: zahlrec; pos: integer; ziffer: ziffertyp);

   var ver, i : integer;

   begin
     pos:=max-(pos-zahl.ex);
     if (pos<=max) and (pos>0) then zahl.zi[pos]:=ziffer;
     if (pos<1) and (ziffer>0) then
       begin                              {nach rechts verschieben}
         ver:=abs(pos)+1;
         for i:=max-ver downto 1 do
           zahl.zi[i+ver]:=zahl.zi[i];
         zahl.zi[1]:=ziffer;
         zahl.ex:=zahl.ex+ver;
       end;
     if (pos>max) and (ziffer>0) and (pos-20 < max) then
       begin     {nach links verschieben}
         ver:=pos-max;
         for i:=ver to max do
           zahl.zi[i-ver]:=zahl.zi[i];
         zahl.zi[max]:=ziffer;
         zahl.ex:=zahl.ex-ver;
       end;
   end;

function vergleich(zahl1, zahl2: zahlrec):shortint;

  var i : integer;
      ende, vorzeichen, vorzeichen2 : boolean;

  begin
    vergleich:=0;
    vorzeichen:=(zahl1.vz=true) and (zahl2.vz=true);
    vorzeichen2:=(zahl1.vz=false) and (zahl2.vz=false);
    vorzeichen:=vorzeichen or vorzeichen2;
    if zahl1.vz<>zahl2.vz then   {+ - / - +}
      begin
        if zahl1.vz=false then vergleich:=1;
        if zahl1.vz=true  then vergleich:=-1;
      end;
    if zahl1.vz=zahl2.vz then   {+ + / - -}
      begin
        i:=maxint;
        ende:=false;
        repeat
          if stlesen(zahl1, i)<>stlesen(zahl2, i) then ende:=true;
          if not(ende) then i:=i-1;
        until (ende=true) or (i=-1*(maxint+1));
        if zahl1.vz=true then        {-}
          begin
            if stlesen(zahl1, i) < stlesen(zahl2, i) then vergleich:=1;
            if stlesen(zahl1, i) > stlesen(zahl2, i) then vergleich:=-1;
            if stlesen(zahl1, i) = stlesen(zahl2, i) then vergleich:=0;
          end;
        if zahl1.vz=false then       {+}
          begin
            if stlesen(zahl1, i) < stlesen(zahl2, i) then vergleich:=-1;
            if stlesen(zahl1, i) > stlesen(zahl2, i) then vergleich:=1;
            if stlesen(zahl1, i) = stlesen(zahl2, i) then vergleich:=0;
          end;
      end;
  end;

procedure tausch(var zahl1: zahlrec; var zahl2: zahlrec);

  var i : integer;
      zw : ziffertyp;
      zb : boolean;
      expz : integer;

  begin
    for i:=1 to max do
      begin
        zw:=zahl1.zi[i];
        zahl1.zi[i]:=zahl2.zi[i];
        zahl2.zi[i]:=zw;
      end;
    expz:=zahl1.ex;
    zahl1.ex:=zahl2.ex;
    zahl2.ex:=expz;
    zb:=zahl1.vz;
    zahl1.vz:=zahl2.vz;
    zahl2.vz:=zb;
  end;

procedure addition(zahl1, zahl2 : zahlrec; var zahl3 : zahlrec);

  var uebertrag : ziffertyp;
      zw        : byte;
      i         : integer;

  begin
    uebertrag:=0;
    for i:=-1*(maxint+1) to maxint do
      begin
        zw:= stlesen(zahl1, i) + stlesen(zahl2, i) + uebertrag;
        if zw>9 then uebertrag:=1
                else uebertrag:=0;
        if zw>9 then stschr(zahl3, i, zw-10)
                else stschr(zahl3, i, zw);
      end;
  end;

procedure subtraktion(zahl1, zahl2 : zahlrec; var zahl3 : zahlrec);

  var uebertrag : ziffertyp;
      zw        : shortint;
      i         : word;

  begin
    uebertrag:=0;
    if vergleich(zahl1, zahl2)=-1 then
       begin
         zahl3.vz:=true;
         tausch(zahl1, zahl2);
       end;
    for i:=max downto 1 do
      begin
        zw:=zahl1.zi[i]-zahl2.zi[i]-uebertrag;
        if zw<0 then uebertrag:=1
                else uebertrag:=0;
        if zw<0 then zahl3.zi[i]:=10+zw
                else zahl3.zi[i]:=zw;
      end;
   end;

procedure multiplikation(zahl1, zahl2 : zahlrec; var zahl3 : zahlrec);

  var uebertrag : ziffertyp;
      zw        : shortint;
      i, j      : word;
      zahl4     : zahlrec;

  begin
    uebertrag:=0;
    for i:=1 to max do zahl3.zi[i]:=0;
    zahl3.ex:=0; zahl3.vz:=false;
    zahl4.ex:=0; zahl4.vz:=false;
    for j:=1 to max do
      begin
        for i:=max downto 1 do
          begin
            zw:=zahl1.zi[i]*zahl2.zi[j]+uebertrag;
            if zw>9 then uebertrag:=zw div 10
                    else uebertrag:=0;
            if zw>9 then zahl4.zi[i]:=zw mod 10
                    else zahl4.zi[i]:=zw;
          end;
        addition(zahl3, zahl4, zahl3);
      end;
  end;

begin
  clrscr;
  for i:=1 to max do
    begin
      zahl1.zi[i]:=0;
      zahl2.zi[i]:=0;
      zahl3.zi[i]:=0;
    end;
  zahl1.ex:=0; zahl2.ex:=0; zahl3.ex:=0;
  zahl1.vz:=false; zahl2.vz:=false; zahl3.vz:=false;
  eingabe(zahl1, len1);
  eingabe(zahl2, len2);
  writeln;
  write('Zahl1: '); ausgabe(zahl1);
  write('Zahl2: '); ausgabe(zahl2);
  writeln('Vergleich: ', vergleich(zahl1, zahl2));
  addition(zahl1, zahl2, zahl3);
  write('Addition: '); ausgabe(zahl3);
  subtraktion(zahl1, zahl2, zahl3);
  write('Subtraktion: '); ausgabe(zahl3);
  multiplikation(zahl1, zahl2, zahl3);
  write('Multiplikation: '); ausgabe(zahl3);
  repeat until keypressed;
  writeln;
end.