{Valos.Inc: a Gyok2_ke.Pas-hoz;
            a gy”kket‹ k”zel¡t‹s, nagypontoss g£ sz m¡t shoz}
  Type
      ValosSzam = Record
                    egesz, tort: EgeszSzam
                  End;
      Terjedelem= -MaxPontossag-1..MaxPontossag+1;
  Var
      ss1,ss2  : Word;
  { Konstansok: }
      Hat,HuszonNegy,Nyolc,Negy,
      OtvenHet,KetszazHarminckilenc,
      Husz,Het,
      Harom,Hetvenkilenc             : EgeszSzam;
      HatTort,NegyTort,HaromTort,
      HuszonNegyTort,
      OtvenHeted,NyolcTort,Nyolcad,
      KetszazHarminckilenced,
      Heted,HuszTort,
      HaromHetvenkilenced             : Tort;

    Procedure Karkezd(cim: String);
    Begin
      Window(1,1,80,25);
      TextBackGround(DarkGray);
      TextColor(White);
      ClrScr;
      GotoXY(40-Length(cim) div 2,1); writeln(cim);
      Window(2,2,79,25);
      TextBackGround(LightGray);
      ClrScr; GotoXY(1,2);
    End;

    Procedure Konv_StringEgesz(Var x: EgeszSzam; szam: String);
      Var
         i,hiba : Integer;
    Begin
      x:=Nulla;
      {If szam[1]<>'-' then }
          x.elojel:=Poz
      {      else
      x.elojel:=Neg };
      x.szamrendszer:=10;
      x.hossz:=Length(szam)-1;
      For i:=0 to x.hossz do
      Begin
        Val(szam[i+1],x.jegy[x.hossz-i],hiba)
      End;
    End; { Konv_StringEgesz }

  Procedure KonstansLetrehozas;
  Begin
    Konv_StringEgesz(Hat,'6');
     Egeszbol_Tort(Hat,Egy,HatTort);
    Konv_StringEgesz(HuszonNegy,'24');
     Egeszbol_Tort(HuszonNegy,Egy,HuszonNegyTort);
    Konv_StringEgesz(Nyolc,'8');
     Egeszbol_Tort(Nyolc,Egy,NyolcTort);
     Egeszbol_Tort(Egy,Nyolc,Nyolcad);
    Konv_StringEgesz(Negy,'4');
     Egeszbol_Tort(Negy,Egy,NegyTort);
    Konv_StringEgesz(OtvenHet,'57');
     Egeszbol_Tort(Egy,OtvenHet,OtvenHeted);
    Konv_StringEgesz(KetszazHarmincKilenc,'239');
     Egeszbol_Tort(Egy,KetszazHarmincKilenc,KetszazHarmincKilenced);
    Konv_StringEgesz(Het,'7');
     Egeszbol_Tort(Egy,Het,Heted);
    Konv_StringEgesz(Harom,'3');
     Egeszbol_Tort(Harom,Egy,HaromTort);
    Konv_StringEgesz(Hetvenkilenc,'79');
     Egeszbol_Tort(Harom,Hetvenkilenc,HaromHetvenkilenced);
    Konv_StringEgesz(Husz,'20');
     Egeszbol_Tort(Husz,Egy,HuszTort);
    TortOsszead(KettoTort,KettoTort,NegyTort);
  End; { KonstansLetrehozas }

  Procedure Kiir(valos: ValosSzam; hossz: Integer);
    Var
       k : Integer;
  Begin
    Write(valos.egesz.jegy[0]:1);
    If Not Nulla_e(valos.tort) then
    Begin
      Write('.');
      hossz:=Min(valos.tort.hossz,hossz);
      For k:=0 to hossz do write(valos.tort.jegy[k]:1);
    End;
    Writeln;
  End; { Kiir }

  Procedure Konv_RacVal(Var valos: ValosSzam; racionalis: Tort; db: Terjedelem);
    Var
       eg,mar : EgeszSzam;
       i      : Integer;
       szj    : Szamjegy;

    Procedure Normalas(Var a,b: EgeszSzam);
      Var
         jegy   : Szamjegy;
         i,d1,d2,
         norm   : Integer;
    Begin
      norm:=a.szamrendszer div (b.jegy[b.hossz]+1);
      if norm>1 then
      begin
        d1:=0;
        for i:=0 to a.hossz do
        begin
          d2:=a.jegy[i]*norm+d1;
          a.jegy[i]:=d2 mod a.szamrendszer;
          d1:=d2 div a.szamrendszer;
        end;
        if d1>0 then begin a.hossz:=a.hossz+1; a.jegy[a.hossz]:=d1; end;
                                               Szor:=Szor+3*(a.hossz+1);
        d2:=0;
        for i:=0 to b.hossz do
        begin
          d1:=b.jegy[i]*norm+d2;
          b.jegy[i]:=d1 mod b.szamrendszer;
          d2:=d1 div b.szamrendszer;
        end;
                                               Szor:=Szor+3*(b.hossz+1);
      end;
    End; { Norm l s }

    Procedure EgyJegyOsztas(Var osztando,oszto: EgeszSzam; Var h: Szamjegy);
      Var
         n,m,szr,
         i,d,x: Integer;
         q    : Szamjegy;
         seged: PozSzam;
         nagy : Boolean;
    Begin
       n:=osztando.hossz; m:=oszto.hossz; szr:=osztando.szamrendszer;
       {
                  a hanyados becslese
       }
       if osztando.jegy[n]=oszto.jegy[m] then q:=szr-1
          else begin
               q:=(szr*osztando.jegy[n]+osztando.jegy[n-1])
                         div oszto.jegy[m];
                                             Szor:=Szor+2; Plusz:=Plusz+1;
               end;
       {
                  a becsles gyors javitasa
       }
       if m>0 then while oszto.jegy[m-1]*q>(Szr*osztando.jegy[n]
                         +osztando.jegy[n-1]-q*oszto.jegy[m])*Szr
                         +osztando.jegy[n-2] do begin
                                                 q:=q-1;
                                                 Szor:=Szor+4; Plusz:=Plusz+3;
                                                end;
       {
                  a becsles ellenorzese es javitasa
       }
       repeat
         d:=0;
         for i:=0 to m do
         begin
           seged[i]:=(oszto.jegy[i]*q+d) mod Szr;
           d:=(oszto.jegy[i]*q+d) div Szr
         end;
                                    Szor:=Szor+3*(m+1); Plusz:=Plusz+2*(m+1);
         seged[m+1]:=d;
         nagy:=(d=0);
         if d<>0 then
         begin
           i:=m+1;
           while (i>0) and (osztando.jegy[n-m-1+i]=seged[i]) do i:=i-1;
           nagy:=(osztando.jegy[n-m-1+i]>=seged[i]);
         end;
         if not nagy then q:=q-1;
       until nagy;
       h:=q;
       d:=0;
       for i:=0 to m do
       begin
         x:=osztando.jegy[n-m-1+i]-seged[i]-d;
         if x<0 then begin x:=x+Szr; d:=1 end else d:=0;
         seged[i]:=x;
       end;
       for i:=0 to m do osztando.jegy[n-m+i]:=seged[i];
       osztando.jegy[0]:=0;
                                               Plusz:=Plusz+m+2;
    End; { EgyJegyOszt s }

  Begin { Konv_RacVal }
    Tulcsordult:=False;
    Oszt(racionalis.szamlalo,racionalis.nevezo,eg,mar);
    valos.egesz:=eg; valos.tort:=Nulla;
    If db<0 {a t”rtr‚sznek csak egy korl tozott darabj ig kell} then db:=-db;
    If Not Nulla_e(mar) then
    Begin
         { el“k‚sz¡t‚s: }
      Alapszoroz(mar,1,mar);
      If Tulcsordult {a l‚ptet‚s nem siker�lt} then
      Begin
        Tulcsordult:=False;
        Alapszoroz(racionalis.nevezo,-1,racionalis.nevezo);
      End;
      if mar.hossz<MaxPontossag then Normalas(mar,racionalis.nevezo);
      if mar.hossz<=racionalis.nevezo.hossz then
      begin
         for i:=mar.hossz+1 to racionalis.nevezo.hossz+1 do mar.jegy[i]:=0;
         If racionalis.nevezo.hossz=MaxPontossag then            {???}
         Begin
           Alapszoroz(racionalis.nevezo,-1,racionalis.nevezo);
           Alapszoroz(mar,-1,mar);
         End;
         mar.hossz:=racionalis.nevezo.hossz+1;                   {???}
      end;
         { t”rtr‚sz-sz mol s }
      i:=0;
      While (Not Nulla_e(mar)) and (valos.tort.hossz<db {MaxPontossag-1}) do
              { a -1 t”rtkitev“ a 0 sorsz m£ }
      Begin
        EgyJegyOsztas(mar,racionalis.nevezo,szj);
        valos.tort.jegy[i]:=szj;
        valos.tort.hossz:=i; Inc(i);
      End;
    End
  End; { Konv_RacVal }

  Function TortNagysagrend(Var t : Tort): Terjedelem;
                             { a legnagyobb nem 0 helyiertek }
    Var
       vt : ValosSzam;

    Function Elso_Nem_0_jegy(Var e : EgeszSzam): Integer {0..MaxPontossag};
      Var
         i  : Integer;
    Begin
      If Nulla_e(e) then
        i:=MaxPontossag
           Else
        Begin
          i:=0;
          While (e.jegy[i]=0) and (i<e.hossz) do Inc(i);
        End;
      Elso_Nem_0_jegy:=i
    End; { Elso_Nem_0_jegy }

  Begin { TortNagysagrend }
    Konv_RacVal(vt,t,MaxPontossag);
    If Nulla_e(vt.egesz) then TortNagysagrend:=-Elso_Nem_0_jegy(vt.tort)-1
                         else TortNagysagrend:=vt.egesz.hossz
  End; { TortNagysagrend }

  Function MaxHossz(t : Tort): PontossagTipus;
  Begin
    MaxHossz:=Max(t.szamlalo.hossz,t.nevezo.hossz)
  End; { MaxHossz }

  Procedure TortTavolsag(Var t1,t2,tav : Tort);
  Begin
    TortKivon(t1,t2,tav);
    tav.szamlalo.elojel:=Poz;  { tav.nevezo.elojel:=Poz }
  End; { TortTavolsag }