var hex_arr: array[1 .. 10] of string[8]; {максимум до $FFFFFFFF}

function from_(s:string;ss:byte):longint;
var q:longint;
begin
q:=0;
for i:=1 to length(s) do begin
s[i]:=char(ord(s[i]) or 32);
case s[i] of
'0'..'9': q:=q*ss+byte(s[i])-ord('0');
'a'..'z': q:=q*ss+byte(s[i])-ord('a')+10;
end; end;
from_:=q;
end;

function to_(q:longint;ss:byte):string;
var s:string;
i:longint;
begin
s:='';
repeat
i:=q-trunc(q/ss)*ss;
if i>9 then i:=i+ord('A')-ord('9')-1;
s:=chr(i+ord('0'))+s;
q:=trunc(q/ss);
until q=0;
to_:=s;
end;

function MulHexToHex(s1,s2:string):string;
begin MulHexToHex:=to_(from_(s1,16)*from_(s2,16),16); end;

function DivHexToHex(s1,s2:string):string;
begin DivHexToHex:=to_(from_(s1,16) div from_(s2,16),16); end;

function AddHexToHex(s1,s2:string):string;
begin addHexToHex:=to_(from_(s1,16) +from_(s2,16),16); end;

function HexToBin(s:string):string;
begin HexToBin:=to_(from_(s,16),2); end;

function BinToHex(s:string):string;
begin BinToHex:=to_(from_(s,2),16); end;

function BinToHex(s:string):string;{iz 2 v 16} 
begin 
   BinToHex:=to_(from_(s,2),16);
end;

function perevod(s:string):string;{iz 2 v 10} 
begin 
   BinToHex:=to_(from_(s,2),10);
end;

function RavnoHEX(s1,s2:string):boolean;
begin
RavnoHEX:=from_(s1,16)=from_(s2,16);
end;

function NeRavnoHEX(s1,s2:string):boolean;
begin
NeRavnoHEX:=not(from_(s1,16)=from_(s2,16));
end;

function BolsheHEX(s1,s2:string):boolean;
begin
BolsheHEX:=not(from_(s1,16)>from_(s2,16));
end;

functinon BolsheHEX(s1,s2:string):boolean;
begin
BolsheHEX:=not(from_(s1,16)>from_(s2,16));
end;

functinon menweHEX(s1,s2:string):boolean;
begin
menweHEX:=(from_(s1,16)<from_(s2,16));
end;

functinon menw_ili_ravn(s1,s2:string):boolean;
begin
menw_ili_ravn:=(from_(s1,16)<=from_(s2,16));
end;

functinon Bolsh_ili_ravn(s1,s2:string):boolean;
begin
BolsheHEX:=(from_(s1,16)>=from_(s2,16));
end;

function vi4(s1,s2:string):string;
begin
  vi4 :=to_(from_(s1,16) -from_(s2,16),16); { <--- и здесь ... }
end;
...
res3_2:=vi4(s1,s2); { <--- ... и здесь }

4:goto vyx;

s := vi4('10', '8');

function proverka(s: string): boolean;{funkciya pravilnosti zapisi}
var
   i: byte;
   flag: boolean;
begin
   i := 1;
   flag := true;
   while (i <= length(s)) and flag do
   begin
      flag := (upcase(s[i]) in ['0' .. '1']);
      i:=i+1;
   end;
   proverka := flag
end;

function BinToHex(s:string):string;{iz 2 v 16} 
begin 
   BinToHex:=to_(from_(s,2),16);
end;
Function Hex2Dec (s:string): longint;{iz 16 v 10}
var
  res,k: longint;
  r,i: word;
  c: char;
begin
       res := 0;
       k := 1;
       for i := length (s) downto 1 do
       begin
            c := UpCase (s[i]);
            case c of
            'A'..'F': r := ord( c ) - (ord('A') - 10);    { ord ( c ) - 55 }
            '0'..'9': r := ord( c ) - ord('0');           { ord ( c ) - 48 }
            else break
            end;
            res := res + r * k
            k := k * 16;
       end;
       Hex2Dec := res;
end;

function proverka(s: string): boolean;
var
   i: byte;
   flag: boolean;
begin
   i := 1; flag := true;
   while (i <= length(s)) and flag do
   begin
      flag := s[i] in ['0' .. '1']; { здесь UpCase не нужен }
     { на '0' или '1' он не влияет - влияет UpCase только на 'a' .. 'z' }
      i:=i+1;
   end;
   proverka := flag
end;

Function Hex2Dec (s:string): longint;{iz 16 v 10}
var
   res,k: longint;
   r,i: integer;
   c: char;
begin
   res := 0;
   k := 1;
   for i := length (s) downto 1 do
   begin
      c := UpCase (s[i]);
      case c of
         'A'..'F': r := ord(c) - (ord('A') - 10);    { ord (c) - 55 }
         '0'..'9': r := ord(c) - ord('0');           { ord (c) - 48 }
      else break
      end;
      res := res + r * k;
      k := k * 16;
   end;
   Hex2Dec := res;
end;
function Dec2Hex(n: integer): string; {Perevod iz 10-oy v 16-uu}
var
   r: integer; {ostatok ot deleniya 4isla na osnovanie}
   buf: string[1];
begin
   s:='';
   repeat
      r:=n mod 16; {o4erednaya cifra}
      n:=n div 16; {celaya 4ast deleniya}
      if r< 10 then
         buf:=chr(r+48) {chr(48) = '0', chr(49)='1' i t.d}
      else
         buf:=chr(r+55);{chr(65)= 'A', chr(66)='b' i t.d}
      s:=buf+s;
   until (n<16);
   if n<>0 then
   begin
      if n<10 then
         buf:=chr(n+48)
      else
         buf:=chr(n+55);
      s:=buf+s;
   end;
   Dec2Hex:=s;
end;
function stepen(x,n:real):real; {vozvedenie v stepen}
begin
   stepen:=exp(n*ln(x));
end;

function stepen(x,n:real):Integer; {vozvedenie v stepen}
begin
   stepen:=Trunc(exp(n*ln(x)));
end;

{rewenie 4etvertoj zada4i}
            s_res := s4; prev := '';
            p4 := 1;
            repeat
               while not (s_res[p4] in abc) and (p4 <= length(s_res)) do
                  p4:=p4+1;
               while (s_res[p4] in abc) and (p4 <= length(s_res)) do
               begin
                  word := word + s_res[p4];
                  p4:=p4+1;
               end;
               if strUpper(word) = strUpper(prev) then
               begin
                  delete(s_res, p4 - length(word), length(word));
                  dec(p4, length(word));{umenwaet p na veli4inu=dline stroki word}
               end
               else
                  prev := word;
               word := '';
            until p4 > length(s_res);
            stnew:= stronespace(s_res);
            while stnew[1]=' ' do
            stnew:=copy(stnew,2,255);
            writeln('Poly4ennaya stroka: ');
            writeln(stnew);
            writeln;
            writeln;
            END; {4etvertaya zada4a}

while 
  (s_res[p4] in abc) 
  and (p4 <= length(s_res)) 
do