Zapełnianie dynamicznej struktury, błąd w assemblerze SIGSEGV

program project1;

{$mode objfpc}{$H+}

uses
  {$IFDEF UNIX}{$IFDEF UseCThreads}
  cthreads,
  {$ENDIF}{$ENDIF}
  Classes
  { you can add units after this };

type
    wsk_li=^li;
    wsk_miasto=^miasto;

    li=record	{lista wskaznikow}
       next:wsk_li;
       odleglosc:real;
       sasiad:wsk_miasto;
    end;

    miasto=record	{rekord miasta}
       nazwa:string;
       x,y:integer;
       stan:boolean;  {false}
       li:wsk_li;    {nil}
     end;

     tab=array[0..5] of miasto;
     wsk_tab=^tab;

 var
    p_miast, p_sasiedzi:text;
    tmp, tmp2:string;
    l_miast,i,skala:byte;
    tab_miast:wsk_tab;
    start:wsk_miasto;
    dalej:boolean;
    delay_time:word;

procedure policzMiasta(var p_miast:text; var l_miast:byte);
          begin
             while not eof(p_miast) do
             begin
                 readln(p_miast);
                 inc(l_miast);
             end;
             reset(p_miast);
          end;

{rozbija linie teksu pobrana z pliku miasta.txt}
procedure miasto_dane(var tmpM, nazwa:string; var x,y:integer);
          var
            i,sr:byte;
            tmp,tmp2:string;
            blad:word;
          begin
              sr:=pos(';', tmpM);
              nazwa:=copy(tmpM, 0, sr-1);

              tmp:=copy(tmpM, sr+1, length(tmpM)-1);
              sr:=pos(';', tmp);

              tmp2:=copy(tmp, 0, sr-1 );
              val(tmp2, x, blad);

              tmp:=copy(tmp, sr+1, length(tmp)-1);
              val(tmp, y, blad);
          end;

{laduje wszystkie informacje o miastach do pamieci}
procedure ladujMiasta(var p_miast, p_sasiedzi:text; var tab_miast:wsk_tab; const l_miast:byte);
          var
            tmpM, tmpS, nazwa:string;
            x,y:integer;
          begin
          i:=0;
             while not eof(p_miast) do
             begin
                 readln(p_miast, tmpM);
                 miasto_dane(tmpM, nazwa, x,y);
                 tab_miast^[i].nazwa:=nazwa;
                 tab_miast^[i].x:=x;
                 tab_miast^[i].y:=y;
                 tab_miast^[i].stan:=false;
                 tab_miast^[i].li:=nil;
                 inc(i);
             end;
             i:=0;
             {while not eof(p_sasiedzi) do
             begin
                readln(p_sasiedzi, tmpS);

                miasto_sasiedzi(tab_miast, tmpS, i, l_miast);
                inc(i);
             end;}
          end;

begin
  assign(p_miast, 'c:\pliki\miasta.txt');
  assign(p_sasiedzi, 'c:\pliki\sasiedzi.txt');
  reset(p_miast);
  reset(p_sasiedzi);
  policzMiasta(p_miast, l_miast);
  writeln(l_miast);
  getmem(tab_miast, l_miast*sizeof(miasto));
  ladujMiasta(p_miast, p_sasiedzi, tab_miast, l_miast);

  writeln('koniec');
  readln;
end.
 

program proj;
 
{$mode objfpc}{$H+}
 
uses
  {$IFDEF UNIX}{$IFDEF UseCThreads}cthreads,{$ENDIF}{$ENDIF}
  Classes;

type
    RCity=record        {rekord miasta}
       Name:String;
       X,Y:Integer;
       Status:Boolean;  {false}
       Dist:Real;
       Neighbor:Integer;
     end;

 var
    FileCity:Text;

    TAB:array of RCity;


procedure ReadCityData(Str:String);
var ErrorCode:Integer;
begin
 TAB[High(TAB)].Name:=Copy(Str,1,POS(';',Str)-1);
 Delete(Str,1,POS(';',Str));
 Val(Copy(Str,1,POS(';',Str)-1),TAB[High(TAB)].X,ErrorCode);
 Delete(Str,1,POS(';',Str));
 Val(Copy(Str,1,POS(';',Str)-1),TAB[High(TAB)].Y,ErrorCode);
 Delete(Str,1,POS(';',Str));
 WriteLn(Format('Miasto [%s] X:Y [%d:%d]',[TAB[High(TAB)].Name,TAB[High(TAB)].X,TAB[High(TAB)].Y]))
end;

procedure LoadData;
var
 Count:Integer;
 DataPart:String;
begin
 Count:=0;
 WriteLn('Ladowanie danych');
 while not eof(FileCity) do begin
  ReadLN(FileCity, DataPart);
  if Length(DataPart)<4 then Continue;
  SetLength(TAB,High(TAB)+2);
  ReadCityData(DataPart);
  INC(Count);
 end;
 WriteLn('Zaladowano ',Count,' miast');
end;

begin
  Assign(FileCity, 'c:\miasta.txt');
  ReSet(FileCity);
  LoadData;
  {
   Tutaj algorytm do zliczania odległości i najkrótszej trasy :D
  }
  WriteLN('Koniec');
  ReadLn;
end.

type
    RCity=record        {rekord miasta}
       Name:String;
       X,Y:Integer;
       Status:Boolean;  {false}
       Dist:Real;
       Neighbor:Integer;
     end;
 

type TNeighbors = record      
       Dist:Real;
       Neighbor:Integer;
end;

type
p_city=^RCity;

  RCity=record
       Name:String;
       X,Y:Integer;
       Status:Boolean;
    end;

var
  tab:p_city;

tab^[1].nazwa:='przykład';

 type
    wsk_li=^li;
    wsk_miasto=^miasto;

    li=record	{lista wskaznikow}
       next:wsk_li;
       odleglosc:real;
       sasiad:wsk_miasto;
    end;

    miasto=record	{rekord miasta}
       nazwa:string;
       x,y:integer;
       stan:boolean;  {false}
       li:wsk_li;    {nil}
     end;

     wsk_tab=array of miasto;

 var
    tab_miast:wsk_tab;

 function znajdz_droge(const startowe:wsk_miasto;var m:wsk_miasto;const l_miast,skala:byte;licznik:byte;var dtime:word):boolean;
          var
            tmpLi:wsk_li;
            tmpx, tmpy:integer;
          begin
             tmpLi:=m^.li;
             m^.stan:=true;
              if keypressed then begin
               if dtime > 650  then dtime:=650
               else dtime := 0;
              end;
              while tmpLi <> nil do
              begin
                 if tmpLi^.sasiad^.stan <> true then
                 begin
                   delay(dtime);
                   setColor(red);
                   FillEllipse(m^.x*skala+155,  m^.y*skala, 2,2);
                   rysuj_polaczenie(m^.x, m^.y, tmpLi^.sasiad^.x, tmpLi^.sasiad^.y  ,skala, true);
                   if znajdz_droge(startowe,tmpLi^.sasiad, l_miast, skala, licznik+1, dtime) then
                   begin
                     znajdz_droge:=true;
                     exit;
                   end else
                   begin
                      tmpx := tmpLi^.sasiad^.x;
                      tmpy:= tmpLi^.sasiad^.y;
                      delay(dtime);
                      rysuj_polaczenie(m^.x, m^.y, tmpx, tmpy  ,skala, false);
                      setColor(yellow);
                      FillEllipse(m^.x*skala+155,  m^.y*skala, 2,2);
                   end;
                 end else if ( tmpLi^.sasiad^.nazwa = start^.nazwa) and (licznik = l_miast)then
                 begin
                    delay(dtime);
                    rysuj_polaczenie(m^.x, m^.y, startowe^.x, startowe^.y  ,skala, true);
                    setColor(red);
                    FillEllipse(m^.x*skala+155,  m^.y*skala, 2,2);
                    outtextxy(5, GetMaxY-70, 'Zadanie rozwiazane');
                    outtextxy(5, GetMaxY-60, 'pomyslnie!');
                    znajdz_droge:=true;
                    exit;
                 end;
                 tmpLi:= tmpLi^.next;
               end;
                m^.stan:=false;

             znajdz_droge:=false;
          end;