Быстрая сортировка - индекс находился вне границ массива

const CSize=1000;
type TRec = record
           mNumber:integer; {номер машины}
           mFam:string[30]; {Фамилия владельца}
           mAdr:string[30]; {адрес владельца}
           mTel:real;       {телефон владельца}
         end;
         
       PRec = ^TRec; {тип указатель на запись}
       TBase = array[1..CSize] of PRec; {Тип массив указателей}
 
 {---Глобальные переменные---}
var DataBase:TBase; {База данных - массив указателей}
    Count:integer;  {Фактическое к-во записей в Базе данных}
 
 
{----------------------------------------------------------------}  
  {--Чтение данных из файла---}     
function ReadData(var F:text):integer;
var n:integer; {номер авто}
    fam:string; {фамилия}
    ul:string; {улица}
    tel:real; {телефон}
    R:PRec;  {указатель на запись}
    i:integer; {счетчик}
    c:char;
begin    
 
 
While not Eof(F) and (i<=CSize) do begin
   fam:='';ul:='';c:=#0;
   inc(i);
   Read(F,n);   {Чтение номера машины}
   While (c<>'-') do begin
      read(F,c);     {Чтение фамилии владельца}           
      fam:=fam+c;
    end;  
   c:=#0; 
  While (c<>'-') do begin
     read(F,c);
     ul:=ul+c;   {читаем улицу}
    end;
    readln(F,tel);  {читаем телефон}
    delete(fam,length(fam),1);
    delete(ul,length(ul),1);
  {---присвоение значений указателям массива---}
    New(R);
  R^.mFam:=fam; R^.mAdr:=ul; R^.mNumber:=n; R^.mTel:=tel;
  DataBase[i]:=R;
 end;
ReadData:=i; 
end;
 
{--------------------------------------------------------------}
 {---Распечатка базы данных---}
Procedure ExpoDataBase;
var i:integer;
begin
i:=1;
 
while (i<=CSize) and (DataBase[i]<>nil) do begin
    writeln('Номер машины : ',DataBase[i]^.mNumber);
    writeln('Фамилия и имя владельца : ',DataBase[i]^.mFam);
    writeln('Адрес владельца : ',DataBase[i]^.mAdr);
    writeln('Номер телефона владельца : ',DataBase[i]^.mTel);
    writeln('--------------------------------------------------');
    inc(i);
    end;
end;
 
{--------------------------------------------------------------}
 {---Быстрая сортировка массива---}
Procedure QuickSort(var arg:TBase; aL,aR:integer);
var L,R:integer; {левый и правый индексы массива}
    M:integer; {M-среднее арифметическое}
    T:Prec;
begin            {T-временное хранилище}
 
L:=aL; R:=aR;
 
M:=(arg[L]^.mNumber + arg[(L+R) div 2]^.mNumber + arg[R]^.mNumber) div 3;
 
Repeat 
 
While arg[L]^.mNumber < M do L:=L+1;
 
While arg[R]^.mNumber > M do R:=R-1;
 
if L<=R then begin
   if arg[L]^.mNumber < arg[R]^.mNumber then begin
         T:=arg[L]; 
         arg[L]:=arg[R];             
         arg[R]:=T;
       end;
     L:=L+1; R:=R-1;
    end;
Until L>R;
 
If R>aL then QuickSort(arg,aL,R);
 
if L<aR then QuickSort(arg,L,R);
 
end;
 
{----------------------------------------------------------}
 
var F:text;
    i:integer;
begin
 
Assign(F,'D:\GGG.txt'); Reset(F);
    
for i:=1 to CSize do DataBase[i]:=nil;
 
Count:=ReadData(F);
QuickSort(DataBase,1,Count);
writeln('Размер Базы Данных - ',Count);
writeln('-------------------------------------------------');
ExpoDataBase;
 
end.