Помочь доделать алгоритм/исправить ошибки

procedure TForm1.Button3Click(Sender: TObject);
var vn2: set of Char;
    i, j: integer;
    f: boolean;
begin
  for i := Memo2.Lines.Count - 1 downto 0 do
    if Length(Memo2.Lines[i]) < 3 then Memo2.Lines.Delete(i);
  Memo2.Refresh;
  for i := Memo2.Lines.Count - 1 downto 0 do
    if Memo2.Lines[i][2] <> '-' then Memo2.Lines.Delete(i);
  vn2:=[];
  vn2:=vn2+[Memo2.Lines[0][1]];
  for i := 0 to Memo2.Lines.Count - 1 do
    if Memo2.Lines[i][1] in vn2 then
      for j := 3 to length(Memo2.Lines[i]) do
        if Memo2.Lines[i][j] in ['A'..'Z'] then
          vn2:= vn2 + [Memo2.Lines[i][j]];
  for i := Memo2.Lines.Count - 1 downto 0 do
    begin
      f := false;
      for j := 0 to Length(Memo2.Lines[i]) do
        begin
          if Memo2.Lines[i][j] in vn2 then
            begin
              f := true;
              break
            end
        end;
      if not(f) then Memo2.Lines.Delete(i)
    end;
end;

unit Unit1;
 
interface
 
uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.XPMan;
 
type
  TForm1 = class(TForm)
    Memo1: TMemo;
    Memo2: TMemo;
    Button1: TButton;
    XPManifest1: TXPManifest;
    procedure Button1Click(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    procedure InitialMemo1;
    procedure Analize;
    procedure RemovingInfertileCharacters;
    procedure RemovingUnreachableSymbols;
    procedure ExceptionChainRules;
    ///////////////////////////////////////////////////////
    procedure FindTerminal;
    procedure AnalizeSlesh;
    procedure AnalizeMemo2;
    procedure AllTerminals;
    procedure ClearTerminalsInString;
    procedure FindTerminalToTerminal;
  public
  end;
 
var
  Form1: TForm1;
  i,j,v,l: Integer;
  indexFindTerminalToTerminal: integer;
  PosSlesh1,PosSlesh2: integer;
  line , s1: string;
  RuleWithoutSlesh: array [0..40] of string;
  SetOfTerminals1,vt,k1,k2,SetForAnalize, SetOfTerminals2: set of Char;
  SetArrayOfTerminals: array [0..25] of set of Char;
  c: Char;
  TerminalsAfter_RemovingUnreachableSymbols: array [1..5] of Char;
  countMemo2: integer;
 
implementation
 
{$R *.dfm}
 
  ////////////////////////////////////////////////////////
  // Ищутся символы в которых есть терминалы
  procedure TForm1.FindTerminal;
  begin
     SetArrayOfTerminals[i] := [];
      for j := 3 to Length(RuleWithoutSlesh[i]) do
        if RuleWithoutSlesh[i,j] in ['A'..'Z'] then
        // и они добавляются в переменную массива множества, ведь множество исключает дубли
         SetArrayOfTerminals[i] := SetArrayOfTerminals[i] + [RuleWithoutSlesh[i,j]];
  end;
 ////////////////////////////////////////////////////////
 
 
 ////////////////////////////////////////////////////////
 // Ищутся символы cлеша, и если он есть то они удаляются
 // и на новую строку добавляются правила которые были после слеша,
 // то есть слеш - это или
 procedure TForm1.AnalizeSlesh;
 begin
    for i := 0 to Memo1.Lines.Count - 1 do
    begin
      line := Memo1.Lines[i];
      PosSlesh1 := Pos('/',line);
      Delete (line,PosSlesh1,1);
      PosSlesh2 := Pos('/',line);
      Delete (line,PosSlesh2,1);
       //если были найдены 2 слеша не подряд
      if (PosSlesh1 > 0) and (PosSlesh2 > 0) and (PosSlesh1 < PosSlesh2) then
        begin
          Memo2.Lines.Add (Copy (line,1,PosSlesh1 - 1));
          Memo2.Lines.Add (Copy (line,1,2) + Copy (line,PosSlesh1,PosSlesh2 - PosSlesh1));
          Memo2.Lines.Add (Copy (line,1,2) + Copy (line,PosSlesh2,Length (line) - PosSlesh2 + 1));
          continue;
        end;
      //если был найден только один слеш (или двойной) ...
      if PosSlesh1 > 0 then
        begin
          Memo2.Lines.Add(Copy(line,1,PosSlesh1 - 1));
          Memo2.Lines.Add(Copy(line,1,2) + Copy(line, PosSlesh1 ,Length(line) - PosSlesh1 + 1));
          continue;
        end;
      //если слешей в строке нет, то добавляем всю строку целиком в мемо2
      if Length (line) > 2 then
         Memo2.Lines.Add(line);
    end;
 end;
 ////////////////////////////////////////////////////////
 
 ////////////////////////////////////////////////////////
 //ищутся ненужные символы в мемо2, которые удаляются
  procedure TForm1.AnalizeMemo2;
  begin
    //Очищаем мемо2 от ненужного мусора
    Memo2.Clear;
    i := 0;
    while i < Memo1.Lines.Count - 1 do
    begin
      //если в i-той строке более 2 символов, тогда
      if Length (Memo1.Lines[i]) > 2 then
        begin
          // создаем переменную s для хранения номера строки
          line := Memo1.Lines[i];
          SetForAnalize := [];
          //заносим все символы строки в множество для анализа
          for j := 1 to Length (line) do
            SetForAnalize := SetForAnalize + [line[j]];
           //если первый символ не нетерминал или второй символ не >
          // или в строке имелись русские буквы
          if (not (line[1] in ['A'..'Z'])) or (line[2] <> '>') or
          ((['А'..'Я','а'..'я'] * SetForAnalize) <> []) then
            begin
              Memo1.Lines.Delete(i);
              continue;
            end;
        end
 
      else // если в i-той строке 2 или менее символа, то удаляем эту строку из мемо1
        begin
          Memo1.Lines.Delete(i);
          continue;
        end;
      inc(i);
    end;
  end;
  ////////////////////////////////////////////////////////
  /// Ищется пустое множество, и если оно нашлось,
  /// то значит в p есть 1 Терминал, и при этом у него нет копий
  procedure TForm1.AllTerminals;
  begin
  /////Потом они добовляются в vn, то есть удалются дубли
  for i := 0 to countMemo2 do
  // если после > нет нетерминалов,
  // то добавляем первый символ строки к множеству vn
  if SetArrayOfTerminals [i] = [] then
    SetOfTerminals1 := SetOfTerminals1 + [RuleWithoutSlesh[i,1]];
 
  SetOfTerminals2 := [];
  //пока нетерминал слева и нет нетерминалов справа выполняем
   while SetOfTerminals1 <> SetOfTerminals2 do
       begin
        SetOfTerminals1 := SetOfTerminals2;
        for i := 0 to countMemo2 do
          if ((SetArrayOfTerminals[i] - SetOfTerminals1) = []) then
              SetOfTerminals2 := SetOfTerminals2 + SetOfTerminals1 + [RuleWithoutSlesh[i,1]];
       end;
  end;
  ////////////////////////////////////////////////////////
 
  ////////////////////////////////////////////////////////
  // если j-тый символ в i-той строке после знака ">"
  // не нетерминал, который записан до знака ">"
  // и если это какой-либо другой нетерминал
  procedure TForm1.ClearTerminalsInString;
  begin
    for i := 0 to countMemo2 do
    for j := 1 to Length (RuleWithoutSlesh[i]) do
      if Length (RuleWithoutSlesh [i]) > 2 then
        if (not (RuleWithoutSlesh[i,j] in SetOfTerminals1)) and (RuleWithoutSlesh[i,j] in ['A'..'Z']) then
          begin
            RuleWithoutSlesh[i]:=''; // очищаем эту строку
            break; //Строка пустая - выход из цикла обработки строки
          end;
  end;
  ////////////////////////////////////////////////////////
 
  ////////////////////////////////////////////////////////
  // Ищутся правила в которых только один символ после >, и если
  procedure TForm1.FindTerminalToTerminal;
  begin
 
  for i := 1 to 5 do
      TerminalsAfter_RemovingUnreachableSymbols [i] := ' ';
 
  indexFindTerminalToTerminal := 0;
  for i := 0 to countMemo2 do
    if Length (RuleWithoutSlesh [i]) = 3 then
     // идет переход от Терминала к Терминалу и если нету перехода к такому же Терминалу, то
      if (RuleWithoutSlesh[i,1] in ['A'..'Z']) and (RuleWithoutSlesh[i,3] in ['A'..'Z'])
       and (RuleWithoutSlesh[i,1] <> RuleWithoutSlesh[i,3]) then
         begin
            inc(indexFindTerminalToTerminal);
            TerminalsAfter_RemovingUnreachableSymbols [indexFindTerminalToTerminal]
             := RuleWithoutSlesh[i,1];
 
            TerminalsAfter_RemovingUnreachableSymbols [indexFindTerminalToTerminal + 1]
             := RuleWithoutSlesh [i,3];
 
            RuleWithoutSlesh [i] := '';
         end;
  end;
   ////////////////////////////////////////////////////////
 
  procedure TForm1.Analize;
  begin
 
    AnalizeMemo2();
    AnalizeSlesh();
 
    for i:=0 to Memo2.Lines.Count - 1 do
    begin
      RuleWithoutSlesh[i]:=Memo2.Lines[i];
      FindTerminal();
    end;
  end;
 
  procedure TForm1.RemovingInfertileCharacters;
  begin
      countMemo2 := Memo2.Lines.Count - 1;
      for i:= 0 to Memo2.Lines.Count - 1 do
        begin
          RuleWithoutSlesh[i] := Memo2.Lines[i];
          FindTerminal();
        end;
 
        Memo2.Clear;
        SetOfTerminals1 := [];
 
        AllTerminals();
        ClearTerminalsInString();
 
        for i := 0 to countMemo2 do
          begin
           FindTerminal();
           if Length (RuleWithoutSlesh [i]) > 2 then
              Memo2.Lines.Add(RuleWithoutSlesh[i]);
          end;
 
        for i:=0 to countMemo2 do
          begin
            RuleWithoutSlesh[i]:=memo2.Lines[i];
            FindTerminal();
          end;
  end;
 
  procedure TForm1.RemovingUnreachableSymbols;
  var
    i, j: integer;
    Mark: boolean;
 begin
 
   for i := Memo2.Lines.Count - 1 downto 0 do
      if Length(Memo2.Lines[i]) < 3 then
          Memo2.Lines.Delete(i);
 
   Memo2.Refresh;
 
   for i := Memo2.Lines.Count - 1 downto 0 do
      if Memo2.Lines[i][2] <> '>' then Memo2.Lines.Delete(i);
 
   SetOfTerminals2 := [];
   SetOfTerminals2 := SetOfTerminals2 + [Memo2.Lines[0][1]];
 
   for i := 0 to Memo2.Lines.Count - 1 do
      if Memo2.Lines[i][1] in SetOfTerminals2 then
        for j := 3 to length(Memo2.Lines[i]) do
          if Memo2.Lines[i][j] in ['A'..'Z'] then
            SetOfTerminals2 := SetOfTerminals2 + [Memo2.Lines[i][j]];
 
    for i := Memo2.Lines.Count - 1 downto 0 do
      begin
        Mark := false;
        for j := 0 to Length(Memo2.Lines[i]) do
          begin
            if Memo2.Lines[i][j] in SetOfTerminals2 then
              begin
                Mark := true;
                break
              end
          end;
        if not(Mark) then Memo2.Lines.Delete(i)
      end;
  end;
 
  procedure TForm1.ExceptionChainRules;
  var
    SizeOf_RuleWithoutSlesh: integer;
  begin
      begin
        countMemo2 := Memo2.Lines.Count - 1;
        // Очищаем старое значение в строке
        i := 0;
        while(RuleWithoutSlesh[i] <> '') do
        begin
           RuleWithoutSlesh [i] := '';
           inc(i);
        end;
        // И добавляем новое
        for i := 0 to countMemo2 do
           RuleWithoutSlesh [i] := Memo2.Lines[i];
 
        Memo2.Clear;
 
        FindTerminalToTerminal();
 
        for i := 1 to indexFindTerminalToTerminal do
         begin
           SetArrayOfTerminals[i] := [];
           for j := i + 1 to indexFindTerminalToTerminal + 1 do
            SetArrayOfTerminals[i] := SetArrayOfTerminals[i]
            + [TerminalsAfter_RemovingUnreachableSymbols[j]];
         end;
 
        PosSlesh2 := 0;
        l := 0;
 
        for i := 1 to indexFindTerminalToTerminal do
         begin
            inc(PosSlesh2);
            for j := 0 to countMemo2 do
            if (Length (RuleWithoutSlesh [j]) > 2) and (RuleWithoutSlesh [j,1] in SetArrayOfTerminals [PosSlesh2]) then
             begin
              inc(l);
              RuleWithoutSlesh[countMemo2 + l] := RuleWithoutSlesh[j];
              RuleWithoutSlesh[countMemo2 + l,1]
              := TerminalsAfter_RemovingUnreachableSymbols[PosSlesh2];
             end;
         end;
 
        for i := 0 to countMemo2 + l do
          if Length (RuleWithoutSlesh [i]) > 2 then
             Memo2.Lines.Add(RuleWithoutSlesh[i]);
      end;
  end;
 
  procedure TForm1.FormCreate(Sender: TObject);
  begin
    InitialMemo1();
  end;
 
  procedure TForm1.InitialMemo1;
  begin
    Memo1.lines.loadFromFile('input.txt');
    Memo1.Text := stringReplace(Memo1.Text, ' ', #13#10, [rfReplaceAll]);
  end;
 
procedure TForm1.Button1Click(Sender: TObject);
  begin
     Analize();
     RemovingInfertileCharacters();
     RemovingUnreachableSymbols();
     ExceptionChainRules();
  end;
end.

procedure TForm1.Button1Click(Sender: TObject);
const sp = '>';
      sl = '/';
var vn2: set of Char;
    i, j, k: integer;
    f: boolean;
    s: string;
begin
  if Memo1.Lines.Count > 0
    then for i := Memo1.Lines.Count - 1 downto 0 do
      begin
        s := Memo1.Lines[i];
        //убираем все пробелы и двойные слэши
        f := true;
        while f do
          begin
            k := pos(' ', s) + pos(sl + sl, s);
            f := k > 0;
            if f then delete(s, k, 1);
          end;
        //и завершающий и стартовый слэши
        if (length(s) > 0) and (s[length(s)] = sl)
          then delete(s, length(s), 1);
        if (length(s) >= 3) and (s[3] = sl)
          then delete(s, 3, 1);
        //определяем, есть ли в строке недопустимые символы
        f := false;
        for j := 1 to length(s) do
          begin
            f := not (s[j] in ['A'..'Z', 'a'..'z', sp, sl]);
            if f then break
          end;
        Memo1.Lines[i] := s;
        //убираем строки строки длиной до 2 символов,
        //без разделителя sp или с неверно расположенным разделителем
        //и с неверными символами
        if f or (length(s) <= 2) or (s[2] <> sp)
          then Memo1.Lines.Delete(i)
      end;
  //разделяем вариантные терминалы на уникальные
  if Memo1.Lines.Count > 0
    then begin
      for i := Memo1.Lines.Count - 1 downto 0 do
        begin
          s := Memo1.Lines[i];
          while pos(sl, s) > 0 do
            begin
              Memo1.Lines.Insert(i + 1, copy(s, 1, pos(sl, s) - 1));
              delete(s, 3, pos(sl, s) - 2)
            end;
          Memo1.Lines[i] := s
        end;
      //далее вычисления по заданию
      vn2 := [];
      vn2 := vn2 + [Memo1.Lines[0][1]];
      for i := 0 to Memo1.Lines.Count - 1 do
        if Memo1.Lines[i][1] in vn2 then
          for j := 3 to length(Memo1.Lines[i]) do
            if Memo1.Lines[i][j] in ['A'..'Z'] then
              vn2:= vn2 + [Memo1.Lines[i][j]];
      for i := Memo1.Lines.Count - 1 downto 0 do
        begin
          f := false;
          for j := 0 to Length(Memo1.Lines[i]) do
            begin
              if Memo1.Lines[i][j] in vn2 then
                begin
                  f := true;
                  break
                end
            end;
          if not(f) then Memo1.Lines.Delete(i)
        end
    end;
  Memo1.Refresh
end;