Ошибка компиляции Паскаль

 program Reverse;
 
{$APPTYPE CONSOLE}
 
uses
  SysUtils;
 
const
 NumberMax=10000;
 
type
 PTreeNode=^TTreeNode;
 TTreeNode=record
  Key    : integer;     //???
  L      : byte;
  R      : byte;
  All    : byte;
  Father : PTreeNode; {указатель на отца}
  LSon   : PTreeNode; {указатель на левого сына}
  RSon   : PTreeNode; {указатель на правого сына}
 end;
 TTree=record
  Root   : PTreeNode;
 end;
 Mas=array [1..2,1..NumberMax] of integer;   //???
 
var
 Tree    : TTree;
 f_in,
 f_out   : TextFile;
 count,
 i,
 val     : byte;
 massiv  : Mas;
 number  : integer;
 
 procedure Create(var T : TTree); {создание дерева}
  begin
   T.Root:=NIL;
  end;
 
 procedure Visit(var f : TextFile; N : PTreeNode); {прямой левый обход дерева с записью ключей вершин в файл}
  begin
   if N=NIL then
    exit;
   writeln(f,N^.Key);
   Visit(f,N^.LSon);
   Visit(f,N^.RSon);
  end;
 
procedure Destroy(var T : TTree); {уничтожение дерева}
 procedure Round(var N : PTreeNode); {обратный обход дерева}
  begin
   if N=NIL then
    exit;
   Round(N^.LSon);
   Round(N^.RSon);
   Dispose(N);
  end; {Round}
 begin
  Round(T.Root);
  T.Root:=NIL;
 end;
 
function Find(T : TTree; Number : integer; var N : PTreeNode) : boolean;  //???
  {при удачном поиске функция возвращает true,а параметр N содержит
   указатель на найденную вершину;при неудачном поиске функция
   возвращает false,а параметр N содержит указатель на вершину,
   на которой завершился поиск;при попытке поиска в пустом дереве
   параметр N содержит NIL}
 var
  P : PTreeNode;
 begin
  N:=NIL;
  P:=T.Root;
  while true do
   begin
    if P=NIL then
     begin
      Find:=false;
      exit;
     end;
    N:=P;
    if P^.Key=Number then
     begin
      Find:=true;
      exit;
     end;
    if P^.Key>Number then
     P:=P^.LSon
    else
     P:=P^.RSon;
   end;
 end;
 
function Insert(var T : TTree; Number : integer) : boolean;  //???
{вставка элемента по значению в бинарное поисковое дерево;
 функция возвращает false при обнаружении дубликата}
 var
  N,
  P  : PTreeNode;
 begin
  if Find(T,Number,N) then
   begin {нашли дубликат}
    Insert:=false;
    exit;
   end;
  Insert:=true;
  New(P);
  P^.Key:=Number;
  if N=NIL then
   begin {вставка первого элемента в пустое дерево}
    T.Root:=P;
    P^.Father:=NIL;
   end
  else
   begin
    P^.Father:=N;
    if N^.Key<Number then
     N^.RSon:=P
    else
     N^.LSon:=P;
   end;
 end;
 
function Delete(var  T : TTree; Number : integer) : boolean;  //???
{удаление элемента по значению из бинарного поискового дерева;
 функция возвращает false при неудачном удалении}
 var
  N,
  P   :  PTreeNode;
  procedure DeleteNode(P : PTreeNode);
  {удаление вершины,имеющей не более одного сына}
   var
    Q : PTreeNode;
    begin
     if P^.LSon<>NIL then
      Q:=P^.LSon
     else
      Q:=P^.RSon;
     if Q<>NIL then
      Q^.Father:=P^.Father;
     if P^.Father=NIL then
      T.Root:=Q
     else
      if (P^.Father)^.LSon=P then
       (P^.Father)^.LSon:=Q
      else
       (P^.Father)^.RSon:=Q;
       Dispose(P);
    end; {DeleteNode}
 begin
  if not Find(T,Number,N) then
   begin {не нашли удаляемый элемент}
    Delete:=false;
    exit;
   end;
  Delete:=true;
  if (N^.LSon<>NIL) and (N^.RSon<>NIL) then
   begin
    P:=N^.RSon;
    while P^.LSon<>NIL do
     P:=P^.LSon;
    N^.Key:=P^.Key;
    DeleteNode(P);
   end
  else
   DeleteNode(N);
 end;
 
procedure ReverseFindSons(var  N : PTreeNode);
 procedure Solve(var  N : PTreeNode);
  begin
   if N^.LSon=NIL then
    N^.L:=0
   else
    N^.L:=(N^.LSon)^.All+1;
   if N^.RSon=NIL then
    N^.R:=0
   else
   N^.R:=(N^.RSon)^.All+1;
   N^.All:=N^.L+N^.R;
   val:=val+1;
   massiv[1,val]:=abs(N^.L-N^.R);
   massiv[2,val]:=N^.Key;
  end;
 begin
  if N<>NIL then
   begin
    ReverseFindSons(N^.LSon);
    ReverseFindSons(N^.RSon);
    Solve(N);
   end;
 end;
 
{function KeyMaximum(Number : byte) : byte;
 var
  max,
  i,
  Key     : byte;
 begin
  max:=massiv[1,1];
  Key:=massiv[2,1];
  for i:=2 to Number do
   if massiv[1,i]>max then
     begin
      max:=massiv[1,i];
      Key:=massiv[2,i];
     end;
  KeyMaximum:=Key;
 end;}
 
function KeyMaximum(Number : byte) : integer; //???
 var
  max,
  i           : byte;
  CurMaxKey,
  Value       : integer;    //???
 begin
  max:=massiv[1,1];
  CurMaxKey:=massiv[2,1];
  for i:=2 to Number do
   if massiv[1,i]>max then
    begin
     max:=massiv[1,i];
     CurMaxKey:=massiv[2,i];
    end;
  for i:=1 to Number do
   if massiv[1,i]=max then
    begin
     Value:=massiv[2,i];
     if Value>CurMaxKey then
      CurMaxKey:=Value;
    end;
  KeyMaximum:=CurMaxKey;
 end;
 
begin
  Create(Tree);
  AssignFile(f_in,ExpandUNCFileName('tst.in'));
  Reset(f_in);
  count:=0;
  while not EOF(f_in) do
   begin
    readln(f_in,number);
    if Insert(Tree,number)=true then
     count:=count+1;
   end;
  CloseFile(f_in);
  val:=0;
  ReverseFindSons(Tree.Root);
  {t:=massiv[1,1];
  k:=1;
  for i:=2 to count do
   if massiv[1,i]=t then
    k:=k+1;}
  {if k=count then
   writeln('There is no such summit in this binary searching tree.')
  else
   Delete(Tree,KeyMaximum(count));}
  //if k<>count then
   Delete(Tree,KeyMaximum(count));
  AssignFile(f_out,ExpandUNCFileName('tst.out'));
  Rewrite(f_out);
  Visit(f_out,Tree.Root); //  прямой левый обход получившегося дерева с записью ключей вершин в файл
  CloseFile(f_out);
  Destroy(Tree);          //  уничтожение получившегося дерева
end.

assign(f);
close(f);