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;

type pspoj=^spoj;       {spojovy seznam promenych}
     spoj=record
	name: string;
	value: fract;
	next: pspoj;
     end;

var 	ans: spoj;
	klavesa: char;
	priklad: byte;
	nula, jedna, deset, MAXCISLO: cislo;
        fnula: fract;
	vnoreni: integer;
	preteceni: integer;
	pozice: integer;
	rozpoznavam, rounded: boolean;
        vstup, vystup, tmp, mezi: string;
        inp,F: text;
const   funcerr='fnce.log';



{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}

function frovna(co, cemu: fract): boolean; forward;
{zjisti, jestli se zlomky rovnaj}

function fvetsi(co, nezco: fract): boolean; forward;
{zjisti, jestli je co mensi nez nezco}

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 fgetst(var vysl:fract; co:string);forward;
{rozpoznani zlomku, promene nebo funkce}

procedure fgetmem(var vysl:fract; varname:string); forward;
{nacte promenou z pameti}

procedure setmemo(varname: string; value: fract); forward;
{ulozi promenou do pameti}

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



{ostatni funkce}

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

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

procedure tolower(var co: string); forward;
{zmeni vsechna velka pismena na mala}

procedure zpracuj(input: string; output: string; verbose: boolean); forward;
{zpracuje vstup}




{vlastni funcke}

{funkce obycejnych cisel}

procedure init;
{inicializuje globalni promenne}
begin
nula:=0;
jedna:=1;
deset:=10;
MAXCISLO:=32000;
rounded:=false;
vnoreni:=0;
ans.name:='ans';
ans.next:=NIL;
rozpoznavam:=false;
fprirad(fnula, '0');
ans.value:=fnula;
vstup:='';
vystup:='';
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}


function frovna(co, cemu: fract): boolean;
{zjisti, jestli se zlomky rovnaj}
begin
     fkrat(co);
     fkrat(cemu);
     if rovna(co.cit, cemu.cit) and rovna(co.jmen, cemu.jmen) then
        begin
             frovna:=true;
        end else
             frovna:=false;
end;

function fvetsi(co, nezco: fract): boolean;
{zjisti, jestli je co mensi nez nezco}
var state: boolean;
    vysl: fract;
begin
     state:=rounded;
     fodecti(vysl, nezco, co);
     if vetsi(vysl.cit, nula) then
     begin
          fvetsi:=true;
     end else
          fvetsi:=false;
     rounded:=state;
end;


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, jedna, nula);
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, jedna, nula);
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, jedna, nula);
	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 fgetmem(var vysl:fract; varname:string);
{nacte promenou z pameti}
var a: pspoj;
begin
    a:=@ans;                    {prvni ve spojaku je $ans}
    while (a<>NIL) and (a^.name<>varname) do
        a:=a^.next;
    if a^.name=varname then
       begin
          vysl:=a^.value;
       end else
          vysl:=fnula;
end;

procedure setmemo(varname:string; value: fract);
{nacte promenou z pameti}
var a: pspoj;
begin
    a:=@ans;                    {prvni ve spojaku je $ans}
    while (a^.next<>NIL) and (a^.name<>varname) do
        a:=a^.next;
    if a^.name=varname then
       begin
          a^.value:=value;
       end else begin
          new(a^.next);
          if a^.next<>NIL then
            begin
             a^.next^.name:=varname;
             a^.next^.next:=NIL;
             a^.next^.value:=value;
            end else
                writeln('NEDOSTATEK PAMETI!');
       end;
end;

procedure fgetst(var vysl:fract; co:string);
{rozpoznani zlomku, promene nebo funkce}
var tmp: string;
    bak: integer;
    state: boolean;
begin
     while (pozice<length(co)) and (co[pozice]=' ') do inc(pozice);
     case co[pozice] of                          {co to vlastne je...}
          '0'..'9': fprirad(vysl, co);
          '(':      vyraz(co, vysl);
          '$': begin                            {hleda se promena}
                    inc(pozice);
                    tmp:='';
                    while (('a'<=co[pozice]) and (co[pozice]<='z')) and (pozice<length(co)+1) do
                          begin
                               tmp:=tmp+co[pozice];
                               inc(pozice)
                          end;
                    fgetmem(vysl,tmp);
               end;
          '&': begin
                    tmp:='';
                    inc(pozice);
                    while (('a'<=co[pozice]) and (co[pozice]<='z')) and (pozice<length(co)+1) do
                          begin
                               tmp:=tmp+co[pozice];
                               inc(pozice)
                          end;
                    if co[pozice]='(' then
                       begin
                            vyraz(co, vysl);
                            setmemo('input',vysl);
                       end;
                    if tmp<>'' then
                       begin
                            bak:=pozice;
                            pozice:=1;
			    setmemo('result',fnula);
                            state:=rozpoznavam;
                            zpracuj(tmp,funcerr,false);
                            rozpoznavam:=state;
                            pozice:=bak;
                       end;
                    fgetmem(vysl,'result');
               end;
        else  begin; inc(pozice); end;
        end;
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; fgetst(zlomek1, co); last:=true; end;
	        '*':  begin;
	                    inc(pozice);
                            fgetst(zlomek2,co);
	                    fnasob(zlomek1, zlomek1, zlomek2);
	                    last:=true
	              end;
	        '_':  co[pozice]:='/';
	        '/':  begin;
	                    inc(pozice);
                            fgetst(zlomek2,co);
	                    fvydel(zlomek1, zlomek1, zlomek2);
	                    last:=true;
	              end;
	        '+':  begin; tmp:=tmp+fvypis(zlomek1)+'+'; inc(pozice); last:=false; zlomek1:=fnula; end;
	        '-':  begin; tmp:=tmp+fvypis(zlomek1)+'-'; inc(pozice); last:=false; zlomek1:=fnula; end;
	        else  begin; 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 mezi:=tmp; {je-li toto prvni, 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; fgetst(zlomek1, tmp); end;
	     '+':	begin;
	                inc(pozice);
                        fgetst(zlomek2,tmp);
	                fsecti(zlomek1, zlomek1, zlomek2);
	                end;
	     '-':	begin;
	                inc(pozice);
                        fgetst(zlomek2,tmp);
	                fodecti(zlomek1, zlomek2, zlomek1);
	                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;
        'a'..'z':
                while (co[kde]>='a') and (co[kde]<='z') and (kde<length(co)+1) do
                      begin
                           tmp:=tmp+co[kde];
                           inc(kde);
                      end;
        '&':    begin
                inc(kde);
                tmp:=tmp+'textrm{';
                while (co[kde]>='a') and (co[kde]<='z') and (kde<length(co)+1) do
                      begin
                           tmp:=tmp+co[kde];
                           inc(kde);
                      end;
                tmp:=tmp+'}';
                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}');
writeln(F, '\pagestyle{empty}');
end;


procedure tolower(var co:string);
var kdetosem: integer;
begin
kdetosem:=0;
while kdetosem<length(co)+1 do
begin
      if ((co[kdetosem]>='A') and (co[kdetosem]<='Z')) then co[kdetosem]:=chr(ord(co[kdetosem])-ord('A')+ord('a'));
      inc(kdetosem);
end;
end;


procedure zpracuj(input:string; output:string; verbose:boolean);
{zpracuje vstup}
var vstup, err, ext: boolean;
    F,inp: text;
    vysl, zlomek1, zlomek2: fract;
    vysledek: array [1..3] of string;
    tmp, temp: string;
begin
     err:=false;
     vstup:=false;
     if input<>'' then
        begin
           Assign(inp, input);  {vstup ze souboru}
	   {$I-}
	   reset(inp);
	   if eof(inp) {$I+} or (IOResult<>0) then
	      begin
	         Write(IOResult);
	         Writeln(' - RUNTIME ERROR!!!');
	         writeln('Vstupni soubor '+input+' neexistuje, nebo je prazdny!');
	         err:=true;
	      end;
        end else
            vstup:=true;
     if not err then
         begin
             repeat
                 ext:=false;
                 if vstup then
                     begin
                         writeln('Zadej vyraz:'); {vstup z klavesnice}
                         readln(tmp);
                     end
                     else Readln(inp, tmp);
                 tolower(tmp);
                 if tmp[1]<>'#' then
                   begin
	              rozpoznavam:=true;
	              pozice:=1;
                      mezi:='';
	              vysledek[1]:=tmp;
	              tmp:='('+tmp+')';
	              vyraz(tmp, vysl);
	              vysledek[2]:=mezi;
                      ans.value:=vysl;
	              rozpoznavam:=false;
	              vysledek[3]:=(fvypis(vysl));
	              if output<>'' then
	                 begin
	                    Assign(F, output);  {vystup do souboru}
	                    {$I-}
	                    Append(F);
	                    {$I+}
	                    if IOResult<>0 then
	                       begin
	                          Rewrite(F);
	                        end;
	                    Writeln(F, '');
	                    Writeln(F, 'Vyraz');
	                    Writeln(F, 'Zadani:');
	                    Writeln(F, '='+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 verbose then
                         begin
                            writeln('');
                            writeln('Zadani:');
	                    writeln(vysledek[1]);
                            if not (vysledek[2]='') then
                               begin
	                            Writeln('Mezivysledek:');
	                            Writeln(vysledek[2]);
                               end;
                            Writeln('Vysledek:');
	                    Writeln(vysledek[3]);
	                    writeln('');
                         end;
                 end else
                      if pos('exit',tmp)<=0 then
                         begin
                              err:=false;
                              if pos('if ',tmp)>0 then
                                 begin
                                      rozpoznavam:=true;
                                      pozice:=pos('if ',tmp)+2;
                                      fgetst(zlomek1,tmp);
                                      while (tmp[pozice]=' ') and (pozice<length(tmp)) do
                                           inc(pozice);
                                      mezi:=tmp[pozice];
                                      inc(pozice);
                                      fgetst(zlomek2, tmp);
                                      case mezi[1] of
                                           '>': if not fvetsi(zlomek1, zlomek2) then rozpoznavam:=false;
                                           '=': if not frovna(zlomek1, zlomek2) then rozpoznavam:=false;
                                           '<': if not fvetsi(zlomek2, zlomek1) then rozpoznavam:=false;
                                           else rozpoznavam:=false;
                                      end;
                                      if not rozpoznavam then err:=true;
                                 end;
                              if (pos('goto ',tmp)>0) and not err then
                                 begin
                                      pozice:=pos('goto ',tmp)+4;
                                      while tmp[pozice]=' ' do
                                            inc(pozice);
                                      mezi:='';
                                      while (tmp[pozice]<>' ') and (pozice<length(tmp)+1) do
                                         begin
                                            mezi:=mezi+tmp[pozice];
                                            inc(pozice);
                                         end;
                                      Reset(inp);
                                      readln(inp, temp);
                                      while (pos(mezi+':',temp)=0) and not SeekEOF(inp) do
                                         begin
                                            readln(inp, temp);
                                            tolower(temp);
                                         end;
                                      if pos(mezi+':',temp)=0 then
                                         begin
                                            Reset(inp);
                                            temp:='';
                                            while (pos(tmp,temp)=0) and not SeekEOF(inp) do
                                               begin
                                                  readln(inp, temp);
                                                  tolower(temp);
                                               end;
                                         end;
                                      err:=true;
                                 end;
                              if (pos('set ',tmp)>0) and not err then
                                 begin
                                      pozice:=pos('set ',tmp)+3;
                                      while tmp[pozice]=' ' do
                                            inc(pozice);
                                      mezi:='';
                                      while (tmp[pozice]<='z') and (tmp[pozice]>='a') and (pozice<length(tmp)+1) do
                                            begin
                                                 mezi:=mezi+tmp[pozice];
                                                 inc(pozice);
                                            end;
                                      rozpoznavam:=true;
                                      fgetst(vysl, tmp);
                                      if length(mezi)>0 then
                                                        setmemo(mezi,vysl);
                                      err:=true;
                                 end;
                              if (pos('get ',tmp)>0) and not err then
                                 begin
                                      pozice:=pos('get ',tmp)+3;
                                      while tmp[pozice]=' ' do
                                            inc(pozice);
                                      mezi:='';
                                      while (tmp[pozice]<='z') and (tmp[pozice]>='a') and (pozice<length(tmp)+1) do
                                            begin
                                                 mezi:=mezi+tmp[pozice];
                                                 inc(pozice);
                                            end;
                                      if length(mezi)>0 then
                                                        fgetmem(vysl, mezi);
                                      writeln(mezi+' = '+fvypis(vysl));
                                      err:=true;
                                 end;
                         end else
                             ext:=true;

	     until ext or ((not vstup) and (seekeof(inp)));
         end;
end;


{vlastni main}

begin
{inicializace promenych}
init;

{telo programu}

klavesa:=' ';
while (klavesa<>'Q') 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 vystup<>'' then begin tmp:=tmp+'  [X]'; end
	else tmp:=tmp+'  [ ]';
	writeln(tmp);
	writeln('   t - Export do TeXu');
	writeln('   p - Pocitat');
	writeln('   q - 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':
            begin
	         Assign(F, vystup);   {vycisteni vystupniho souboru}
	         Rewrite(F);
	         writeln(F, '');
	         Assign(F, funcerr);  {vycisteni logu s chybami funkci}
	         Rewrite(F);
	         writeln(F, '');
                 rounded:=false;
                 zpracuj(vstup,vystup,true);
	    end;
	'O':
	    begin
	         if vystup='' then  {vystup do souboru (zap/vyp)}
                    begin
                       vystup:='output.txt';
                    end else
                       vystup:='';
	    end;
	'I':
	    begin
	         if vstup='' then  {vstup do souboru (zap/vyp)}
                    begin
                       vstup:='input.txt';
                    end else
                       vstup:='';
	    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);
	writeln('Soubor byl zapsan jako Vysledky.tex');
	end;
	klavesa:=readkey;
	klavesa:=' ';
	end;

	end;
end;
end.