program fraction;

uses crt;

type cislo=longint;       {cisla obsazena v citateli i jmenovateli)}
type fract=record       {typ zlomek}
     cit: cislo;        {citatel}
     jmen: cislo;       {jmenovatel}
end;

var err, fileout, vstup: boolean;
var pokus:fract;
	tmp: string;
        vysledek: array [1..3] of string;
        klavesa: char;
        priklad: byte;
        nula, jedna, deset, MAXCISLO: cislo;
        vnoreni: integer;
	preteceni: integer;
	pozice: integer;
        rozpoznavam, rounded: boolean;
        F,inp: text;
const vystup='output.txt';

{seznam funkci}

{funkce cisel}

procedure init; forward;
{inicializuje globalni promenne}

procedure nuluj(var co:cislo);forward;
{nastavi dane cislo na nulu}

procedure mydiv(var vysl: cislo; co, cim:cislo);forward;
{celociselne deleni}

function getrad(co:cislo):longint;forward;
{zjisti rad cisla}

function vetsi(co, nezco:cislo):boolean;forward;
{zjisti, co je vetsi}

procedure mymod(var vysl:cislo; co, cim: cislo);forward;
{vrati modulo}

procedure vydel(var vysl:cislo; co, cim:cislo); forward;
{deleni cisel}

procedure nsd(var vysl:cislo; co1, co2: cislo); forward;
{vrati nejvetsi spolecny delitel}

procedure secti(var vysl:cislo; co, scim:cislo);forward;
{scitani cisel}

procedure odecti(var vysl:cislo; co, odceho:cislo);forward;
{odcitani cisel}

function rovna(co, cemu:cislo):boolean;forward;
{zjisti, jestli se cisla vzajemne rovnaji}

procedure nasob(var vysl:cislo; co, cim:cislo);forward;
{nasobeni cisel}

procedure zmenrad(var vysl:cislo; okolik:integer);forward;
{zmeni rad cisla}

procedure prirad(var vysl:cislo; co:string);forward;
{rozpoznani cisel v textovem retezci(zavisi na hodnotach
rozpoznavam a pozice) a pracuje s promenou preteceni}

function vypis(co: cislo):string;forward;
{vypise cislo}


{funkce zlomku}

procedure fsecti(var vysl:fract; co:fract; scim:fract);forward;
{scitani zlomku}

procedure fodecti(var vysl:fract; co, odceho:fract); forward;
{odcitani zlomku - prevede se na scitani}

procedure fnasob(var vysl:fract; co, cim:fract);forward;
{nasobeni zlomku}

procedure fvydel(var vysl:fract; co, cim:fract);forward;
{deleni zlomku - prevede se na nasobeni}

procedure fkrat(var co:fract);forward;
{kraceni zlomku}

function fvypis(co:fract):string;forward;
{vypsani zlomku(do stringu)}

procedure fprirad(var vysl:fract; co:string);forward;
{rozpoznani zlomku}

procedure vyraz(var co: string; var vysl: fract);forward;
{rozpozna a vyhodnoti zadany vyraz}



{funkce TeXu}

function totex(co:string):string; forward;
{prevod vypisu do TeXu}

procedure hlavicka(var F: text); forward;
{zapise TeXovou hlavicku}




{vlastni funcke}

{funkce obycejnych cisel}

procedure init;
{inicializuje globalni promenne}
begin
nula:=0;
jedna:=1;
deset:=10;
MAXCISLO:=32000;
vstup:=false;
rounded:=false;
fileout:=false;
vnoreni:=0;
end;

procedure nuluj(var co:cislo);
{nastavi dane cislo na nulu}
begin
secti(co, nula, nula);
end;

procedure mydiv(var vysl: cislo; co, cim:cislo);
{celociselne deleni}
begin
	vysl:= co div cim;
end;

function getrad(co:cislo):longint;
{zjisti rad cisla}
var tmp:cislo;
    i:longint;

begin
i:=0;
while not rovna(co,nula) do
      begin
           mydiv(co, co, deset);
           inc(i);
      end;
getrad:=i;
end;

function vetsi(co, nezco:cislo):boolean;
{zjisti, co je vetsi}
begin
if co>nezco then
   begin
        vetsi:=true;
   end
   else vetsi:=false;
end;


procedure mymod(var vysl:cislo; co, cim: cislo);
{vrati modulo}
begin
	mydiv(vysl, co, cim);
	nasob(vysl, vysl, cim);
	odecti(vysl, vysl, co);
end;


procedure vydel(var vysl:cislo; co, cim:cislo);
{deleni cisel}
var tmp1, tmp2:cislo;
begin
mydiv(vysl, co, cim);
secti(tmp1, jedna, jedna); {zaokrouhlovani}
mymod(tmp2, co, cim);
mydiv(tmp1, cim, tmp1);
if vetsi(tmp2, tmp1) then secti(vysl, vysl, jedna);
end;


procedure nsd(var vysl:cislo; co1, co2: cislo);
{vrati nejvetsi spolecny delitel}
var zbytek1, zbytek2, zbytek3: cislo;
begin
zbytek3:=jedna;
if vetsi(co1, co2) then
   begin
        secti(zbytek1, nula, co1);
        secti(zbytek2, nula, co2);
   end
   else
       begin
            secti(zbytek1, nula, co2);
            secti(zbytek2, nula, co1);
       end;
while vetsi(zbytek3, nula) do
   begin
        mymod(zbytek3, zbytek1, zbytek2);
        secti(zbytek1, nula, zbytek2);
        secti(zbytek2, nula, zbytek3);
   end;
secti(vysl, zbytek1, nula);
end;

procedure secti(var vysl:cislo; co, scim:cislo);
{scitani cisel}
begin
vysl:=co+scim;
end;

procedure odecti(var vysl:cislo; co, odceho:cislo);
{odcitani cisel}
begin
vysl:=odceho-co;
end;

function rovna(co, cemu:cislo):boolean;
{zjisti, jestli se cisla vzajemne rovnaji}
begin
if co=cemu then
   begin
        rovna:=true;
   end
   else rovna:=false;
end;

procedure nasob(var vysl:cislo; co, cim:cislo);
{nasobeni cisel}
begin
vysl:=co*cim;
end;

procedure zmenrad(var vysl:cislo; okolik:integer);
{zmeni rad cisla}
var i:integer;
begin
if okolik<>0 then
   begin
        if okolik>0 then
           begin
                for i:=1 to okolik do nasob(vysl, vysl, deset);
           end
           else
               begin
                    for i:=-1 downto okolik do vydel(vysl, vysl, deset);
                    if rovna(vysl, nula) then secti(vysl, vysl, jedna);
               end;
   end;
end;

procedure prirad(var vysl:cislo; co:string);
{rozpoznani cisel v textovem retezci(zavisi na hodnotach 
rozpoznavam a pozice) a pracuje s promenou preteceni}
var i,tmp,MAXRAD: integer;
begin
MAXRAD:=2*getrad(MAXCISLO)-1;
if rozpoznavam then
        begin
                     i:=pozice-1;
        end
	else i:=0;
nuluj(vysl);
while (i<length(co)) and (co[i+1]=' ') do
begin
     i:=i+1;
end;
tmp:=i;
while (i<length(co)) and (co[i+1]>='0') and (co[i+1]<='9') do
	begin
		i:=i+1;
                if getrad(vysl)<MAXRAD then
                   begin
                        zmenrad(vysl, 1);
                        vysl:=vysl+ord(co[i])-ord('0');
                   end;
	end;
preteceni:=i-getrad(vysl)-tmp;
if rozpoznavam then pozice:=i+1;
end;


function vypis(co: cislo):string;
{vypise cislo}
var i: integer;
    delitel: longint;
    tmp: string;
begin
tmp:='';
delitel:=1;
if rovna(co, nula) then begin; vypis:='0'; end
else begin
for i:=1 to getrad(co)-1 do delitel:=10*delitel;
for i:=getrad(co) downto 1 do
    begin

         tmp:= tmp + Chr((trunc(co/delitel)) - trunc((co/(delitel * 10)))*10 + ord('0'));
         delitel:=delitel div 10;
    end;
vypis:=tmp;
end;
end;


{funkce zlomku}

procedure fsecti(var vysl:fract; co:fract; scim:fract);
{scitani zlomku}
var tmp:cislo;
begin
nasob(vysl.cit, co.cit, scim.jmen);
nasob(tmp, scim.cit, co.jmen);
secti(vysl.cit, vysl.cit, tmp);
nasob(vysl.jmen, co.jmen, scim.jmen);
fkrat(vysl);
end;

procedure fodecti(var vysl:fract; co, odceho:fract);
{odcitani zlomku - prevede se na scitani}
begin
odecti(co.cit, co.cit, nula);
fsecti(vysl, co, odceho);
end;

procedure fnasob(var vysl:fract; co, cim:fract);
{nasobeni zlomku}
begin
nasob(vysl.cit, co.cit, cim.cit);
nasob(vysl.jmen, co.jmen, cim.jmen);
fkrat(vysl);
end;

procedure fvydel(var vysl:fract; co, cim:fract);
{deleni zlomku - prevede se na nasobeni}
var tmp:fract;
begin
secti(tmp.jmen, nula, cim.cit);
secti(tmp.cit, nula, cim.jmen);
fnasob(vysl, co, tmp);
end;

procedure fkrat(var co:fract);
{kraceni zlomku}
var tmp: cislo;
    state: boolean;
    zaporne: boolean;
begin
zaporne:=false;
odecti(tmp, nula, jedna);
if vetsi(nula,co.jmen) then begin; zaporne:= not zaporne; nasob(co.jmen, co.jmen, tmp); end;
if vetsi(nula,co.cit) then begin; zaporne:= not zaporne;  nasob(co.cit, co.cit, tmp); end;
state:=rozpoznavam;
rozpoznavam:=false;
if not rovna(co.jmen, jedna) then
begin
if rovna(co.cit,nula)  or rovna(co.jmen,nula) then
   begin
        if rovna(co.cit, nula) then
           begin
                secti(co.cit, nula, nula);
           end
           else rounded:=true;
        secti(co.jmen, jedna, nula);
   end
   else
       begin
            if rovna(co.cit, co.jmen) then
               begin
                    secti(co.jmen, jedna, nula);
                    secti(co.cit, jedna, nula);
               end
               else
                   begin
                        nsd(tmp, co.cit, co.jmen);
                        vydel(co.cit, co.cit, tmp);
                        vydel(co.jmen, co.jmen, tmp);
                   end;
       end;
end;
while vetsi(co.cit, MAXCISLO) or vetsi(co.jmen, MAXCISLO) do
      begin
           rounded:=true;
           zmenrad(co.cit, -1);
           zmenrad(co.jmen, -1);
           if rovna(co.jmen, nula) then secti(co.jmen, nula, jedna);
      end;
odecti(tmp, nula, jedna);
if zaporne then nasob(co.cit, co.cit, tmp);
rozpoznavam:=state;
end;


function fvypis(co:fract):string;
{vypsani zlomku}
var zacatek, stred, konec, zaok: string[10];
    tmp: cislo;
begin
fkrat(co);
if rounded and not rozpoznavam then
    begin
       zaok:='cca ';
    end
      else zaok:='';
zacatek:='';
stred:='_';
konec:='';
if vetsi(nula, co.cit) then
begin;
      zacatek:='(-'+zacatek; konec:=konec+')';
      odecti(tmp, nula, jedna);
      nasob(co.cit, co.cit, tmp);
end;
if not(rovna(jedna, co.jmen)) then
   begin
        fvypis:=zaok+zacatek+vypis(co.cit)+stred+vypis(co.jmen)+konec;
   end
   else
       begin
          fvypis:=zaok+zacatek+vypis(co.cit)+konec;
       end;
end;

procedure fprirad(var vysl:fract; co:string);
{rozpoznani zlomku}
var tmp,mez: integer;
    pret1: integer;
    mezera: string;
    state: boolean;
begin
preteceni:=0;
state:=rozpoznavam;
if not rozpoznavam then
   begin
        tmp:=pozice;
        pozice:=1;
   end
   else tmp:=-1;
rozpoznavam:=true;
prirad(vysl.cit, co);
pret1:=preteceni;
mez:=pozice+1;
while co[mez]=' ' do inc(mez);
if not (((co[pozice])<>'_') or (pozice>(length(co)-1)) or ((co[pozice]='_') and (co[mez]='('))) then
	begin
		inc(pozice);
		prirad(vysl.jmen, co);
	end
	else	secti(vysl.jmen, jedna, nula);

if (pret1>0) and (pret1>preteceni) then begin zmenrad(vysl.jmen, preteceni-pret1); rounded:=true; end;
if (preteceni>0) and (pret1<preteceni) then begin zmenrad(vysl.cit, pret1-preteceni); rounded:=true; end;
fkrat(vysl);
rozpoznavam:=state;
if tmp>0 then pozice:=tmp;
end;


procedure vyraz(var co: string; var vysl: fract);
{rozpozna a vyhodnoti zadany vyraz}
var konec: integer;
    zlomek1, zlomek2: fract;
    tmp: string;
    last, state: boolean;
    id: integer;
begin
     tmp:='(';
     state:=rozpoznavam;
     inc(vnoreni);
     id:=vnoreni;
     inc(pozice);
     nuluj(vysl.cit);
     fkrat(vysl);
     nuluj(zlomek1.cit);
     fkrat(zlomek1);
     rozpoznavam:=true;
     {precte se vstupujici string a do stringu tmp se ulozi tak,
     ze se vypocitaji veskere zavorky, nasobeni a deleni. Je-li
		 mezi vyrazy znak pro zlomek, nahradi se delenim}
     while (co[pozice]<>')') and (pozice<length(co)) do
     begin
          while (pozice<length(co)) and (co[pozice]=' ') do inc(pozice);
          case co[pozice] of
               '0'..'9': begin; fprirad(zlomek1, co); last:=true; end;
               '*':      begin;
                               inc(pozice);
                               while (pozice<length(co)) and (co[pozice]=' ') do inc(pozice);
                               if co[pozice]='(' then
                                  begin;
                                        vyraz(co, zlomek2);
                                  end
                                  else  fprirad(zlomek2, co);
                               fnasob(zlomek1, zlomek1, zlomek2);
                               tmp:=concat(tmp,fvypis(zlomek1));
                               last:=false;
                         end;
               '_':      co[pozice]:='/';
               '/':      begin;
                               inc(pozice);
                               while (pozice<length(co)) and (co[pozice]=' ') do inc(pozice);
                               if co[pozice]='(' then
                                  begin;
                                        vyraz(co, zlomek2);
                                  end
                                  else  fprirad(zlomek2, co);
                               fvydel(zlomek1, zlomek1, zlomek2);
                               tmp:=concat(tmp,fvypis(zlomek1));
                               last:=false;
                         end;
               '+':      begin; tmp:=concat(tmp, fvypis(zlomek1),'+'); inc(pozice); last:=false; end;
               '-':      begin; tmp:=concat(tmp, fvypis(zlomek1),'-'); inc(pozice); last:=false; end;
               '(':      begin; vyraz(co, zlomek1); last:=true; end;
               else      begin; tmp:=tmp+co[pozice];inc(pozice); end;
               end
     end;
     if last then tmp:=tmp+fvypis(zlomek1);
     tmp:=concat(tmp,')');
     inc(pozice);
     konec:=pozice;
     pozice:=2;
     if id=1 then vysledek[2]:=tmp; {je-li toto první, zapise se mezivypocet}
     nuluj(zlomek1.cit);
     fkrat(zlomek1);
     {vystup z prvni casti, kde se vyhodnocovali pouze zavorky, nasobeni a deleni
     se vezme jako vstup a tentokrat se vyhodnoti veskere scitani a odcitani}
     while (tmp[pozice]<>')') and (pozice<length(tmp)) do
     begin
          while (pozice<length(tmp)) and (tmp[pozice]=' ') do inc(pozice);
          case tmp[pozice] of
               '0'..'9': begin; fprirad(zlomek1, tmp); last:=true; end;
               '+':      begin;
                               inc(pozice);
                               while (pozice<length(tmp)) and (tmp[pozice]=' ') do inc(pozice);
                               if tmp[pozice]='(' then
                                  begin;
                                        vyraz(tmp, zlomek2);
                                  end
                                  else  fprirad(zlomek2, tmp);
                               fsecti(zlomek1, zlomek1, zlomek2);
                         end;
               '-':      begin;
                               inc(pozice);
                               while (pozice<length(tmp)) and (tmp[pozice]=' ') do inc(pozice);
                               if tmp[pozice]='(' then
                                  begin;
                                        vyraz(tmp, zlomek2);
                                  end
                                  else  fprirad(zlomek2, tmp);
                               fodecti(zlomek1, zlomek2, zlomek1);
                        end;
               '(':      begin; vyraz(co, zlomek1); last:=true; end;
               else inc(pozice);
          end
     end;
     fkrat(zlomek1);
     fsecti(vysl, vysl, zlomek1);
     rozpoznavam:=state;
     vnoreni:=id-1;
     pozice:=konec;
end;



{funkce pro vystup do TeXu}

function totex(co:string):string;
{prevede vystup do TeXu}
var tmp: string;
    kde: integer;


function vyraztotex(co:string):string;
{prevod matematickeho vyrazu do TeXu}
var last:boolean;
    cislo,tmp: string;

begin
last:=false;
tmp:='';
inc(kde);
while (kde<length(co)+1) and (co[kde]<>')') do
begin
          case co[kde] of
          '(' :       begin
                          cislo:='{({'+vyraztotex(co)+'})}';
                          inc(kde);
                          last:=true;
                      end;
          '0'..'9':   begin
                           cislo:='';
                           last:=true;
                           while (co[kde]<='9') and (co[kde]>='0') and (kde<length(co)+1) do
                           begin
                              cislo:=cislo+co[kde];
                              inc(kde);
                           end;
                      end;
          '_':        begin
                           inc(kde);
                           tmp:=tmp+'\frac{'+cislo+'}';
                           cislo:='{';
                           while co[kde]=' ' do inc(kde);
                           if co[kde]='(' then
                              begin
                                       cislo:=cislo+'({'+vyraztotex(co)+'})';
                                       inc(kde);
                              end
                              else if (co[kde] >='0') and (co[kde]<='9') then
                                   begin
                                   while (co[kde]<='9') and (co[kde]>='0') and (kde<length(co)+1) do
                                       begin
                                            cislo:=cislo+co[kde];
                                            inc(kde);
                                       end;
                                   end
                                   else cislo:='';
                           tmp:=tmp+cislo+'}';
                           last:=false;
                      end;
          '+', '-', '*', '/':
                      begin
                           if last then tmp:=tmp+cislo;
                           if co[kde]='*' then
                              begin
                                   tmp:=tmp+'\times';
                              end
                              else tmp:=tmp+co[kde];
                           cislo:='';
                           inc(kde);
                           last:=false;
                      end;
          else inc(kde);
          end;
     end;
     if last then tmp:=tmp+cislo;
     vyraztotex:=tmp;
end;


{prevod vypisu do TeXu}
begin
tmp:='$$';
kde:=1;
if (co[kde]='=') and (kde<length(co)+1) then
begin
     if copy(co,2,3)='cca' then
          begin
	       tmp:=tmp+'\textrm{cca  }';
	       kde:=kde+3;
	  end;
     totex:=tmp+vyraztotex(co)+'$$';
end
else if (co='Vyraz') and (kde<length(co)+1) then
     begin
          totex:='\begin{vyraz} \end{vyraz}';
          priklad:=2;
     end
     else
          totex:=co;
end;


procedure hlavicka(var F: text);
{zapise TeXovou hlavicku}
begin
writeln(F, '\documentclass[a4paper, 12pt]{article}');
writeln(F, '\newtheorem{vyraz}{Vyraz}');
writeln(F, '\begin{document}');
writeln(F, '\section*{Vysledky z programu Fractions}');
end;



{vlastni main}

begin
{inicializace promenych}
init;

{telo programu}

klavesa:=' ';
while (klavesa<>'X') do
begin
      {zobrazeni uvodni nabidky}
      clrscr;
      priklad:=0;
      tmp:='';
      while length(tmp)<30 do tmp:=tmp+' ';
      tmp:=tmp+'Fractions';
      writeln(tmp);
      writeln('');
      writeln('Ovladani:');
         tmp:='   m - Zobrazovat mezivysledky';
      if vnoreni=0 then begin tmp:=tmp+'  [X]'; end
         else tmp:=tmp+'  [ ]';
      writeln(tmp);
         tmp:='   i - Vstup ze souboru       ';
      if vstup then begin tmp:=tmp+'  [X]'; end
         else tmp:=tmp+'  [ ]';
      writeln(tmp);
         tmp:='   o - Vystup do souboru      ';
      if fileout then begin tmp:=tmp+'  [X]'; end
         else tmp:=tmp+'  [ ]';
      writeln(tmp);
      writeln('   c - Vycistit vystupni soubor');
      writeln('   t - Export do TeXu');
      writeln('   p - Pocitat');
      writeln('   x - Konec');
      writeln('');
      writeln('- - - - - - - - - - - - - - - - - - - - -');
      writeln('');
      klavesa:=readkey;
      if (klavesa>'Z') then klavesa:=chr(ord(klavesa)-ord('a')+ord('A'));
      case klavesa of
      {po stisku klavesy se rozhodne, co dal}
      'P':
          {vse je nastaveno a jde se pocitat}
          begin
               if vstup then
                  begin
                       err:=false;
                       Assign(inp, 'input.txt');  {vstup ze souboru}
                       {$I-}
                       reset(inp);
                       if eof(inp) {$I+} or (IOResult<>0) then
                       begin
                            Write(IOResult);
                            Writeln(' - RUNTIME ERROR!!!');
                            writeln('Vstupni soubor neexistuje, nebo je prazdny!');
                            err:=true;
                       end;
                  end;
               if not err then
               begin
               repeat
                     if not vstup then
                        begin
                             writeln('Zadej vyraz:'); {vstup z klavesnice}
                             readln(tmp);
                        end
                        else Readln(inp, tmp);

                   pozice:=1;
                   rozpoznavam:=true;
                   pozice:=1;
                   vysledek[2]:='';
                   vysledek[1]:=tmp;
                   tmp:='('+tmp+')';
                   vyraz(tmp, pokus);
                   rozpoznavam:=false;
                   vysledek[3]:=(fvypis(pokus));
                   if fileout then
                      begin
                           Assign(F, vystup);  {vystup do souboru}
                           {$I-}
                           Append(F);
                           {$I+}
                           if IOResult<>0 then
                              begin
                                   Rewrite(F);
                              end;
                           Writeln(F, '');
                           Writeln(F, 'Vyraz');
                           Writeln(F, 'Zadani:');
                           writeln('Zadani:');
                           Writeln(F, '='+vysledek[1]);
                           writeln(vysledek[1]);
                           if not (vysledek[2]='') then
                           begin
                               Writeln(F, 'Mezivysledek:');
                               Writeln(F, '='+vysledek[2]);
                           end;
                           Writeln(F, 'Vysledek:');
                           Writeln(F, '='+vysledek[3]);
                           Close(F);
                      end;
                   if not (vysledek[2]='') then
                   begin
                       Writeln('Mezivysledek:');
                       Writeln(vysledek[2]);
                   end;
                   Writeln('Vysledek:');
                   Writeln(vysledek[3]);
                   writeln('');
               until not(vstup and (not(eof(inp))));
               if vstup then close(inp);
               end;
               klavesa:=readkey;
               klavesa:=' ';
          end;
      'O':
          begin
               fileout:= not fileout; {vystup do souboru (zap/vyp)}
          end;
      'I':
          begin
               vstup:= not vstup;     {vstup ze souboru (zap/vyp)}
          end;
      'C':
          begin
               Assign(F, vystup);  {vycisteni vystupniho souboru}
               Rewrite(F);
               writeln(F, '');
               close(F);
	       writeln('soubor byl vycisten...');
	       klavesa:=readkey;
               klavesa:=' ';

          end;
      'M':
          begin                       {nastaveni zobrazovani mezivysledku}
               if vnoreni>0 then vnoreni:=-1;
               inc(vnoreni);
          end;
      'T':
          begin
               Assign(F, vystup);  {uzavreni souboru a vypis}
               {$I-}
               Append(F);
               {$I+}
               if IOResult<>0 then
                   begin
                        write(IOResult);
                        Writeln(' - RUNTIME ERROR!!!');
                        writeln('soubor vysledku neexistuje, nebo se pouziva!');
                   end
                   else
                   begin
                        close(F);
                        Assign(inp, vystup);
                        Reset(inp);
                        assign(F, 'Vysledky.tex');
                        rewrite(F);
                        hlavicka(F);
                        while not eof(inp) do
                              begin
                                   readln(inp, tmp);
                                   writeln(F, totex(tmp));
                              end;
                        writeln(F,'\end{document}');
                        close(F);
                        close(inp);
                    {    assign(F, vystup);
                        rewrite(F);
                        writeln(F,'');
                        close(F);}
                        writeln('Soubor byl zapsan jako Vysledky.tex');
                   end;
               klavesa:=readkey;
               klavesa:=' ';
               end;

      end;
end;
end.