KnownParsingType = record StartField, EndField: integer; end;

    KnownGoalType =
    record
        NmbField: RuleNmbType; PosField, LenField: integer;{ the goal}
        StartParsingField: integer;             { temporary variable }
        KnownParsingField: array [1..ArraySize] of KnownParsingType;
        NKnownParsingsField: integer;
    end;

    KnownGoalList: array [1..ArraySize] of KnownGoalType;
    NKnownGoals: integer;
    KnownRuleList: array [1..ArraySize] of RuleNmbType;
    NKnownRules: integer;

function KnownGoalNumber(nmb: RuleNmbType; pos, len: integer):integer;
    var n: integer;
    begin
        KnownGoalNumber:= 0;
        for n:= 1 to NKnownGoals do
            with KnownGoalList[n] do
                if (nmb=NmbField)
                and (pos=PosField)
                and (len=LenField) then
                    KnownGoalNumber:= n;
    end { KnownGoalNumber };

procedure StartNewKnownGoal(nmb: RuleNmbType; pos, len: integer);
    begin
        NKnownGoals:= NKnownGoals+1;
        with KnownGoalList[NKnownGoals] do
        begin
            NmbField:= nmb; PosField:= pos; LenField:= len;
            StartParsingField:= NRulesStacked+1;
            NKnownParsingsField:= 0;
        end;
    end { StartNewKnownGoal };

procedure RecordKnownParsing;
    var n, i: integer;
    begin
        with Stack[NStackElems] do
        begin
            n:= KnownGoalNumber(NmbField, PosField, LenField);
            with KnownGoalList[n] do
            begin
                NKnownParsingsField:= NKnownParsingsField+1;
                with KnownParsingField[NKnownParsingsField] do
                begin
                    StartField:= NKnownRules+1;
                    for i:= StartParsingField to NRulesStacked do
                    begin
                        NKnownRules:= NKnownRules+1;
                        KnownRuleList[NKnownRules]:= RuleStack[i];
                    end;
                    EndField:= NKnownRules;
                end;
            end;
        end;
    end { RecordKnownParsing };

    function KnownGoalSucceeds
        (nmb: RuleNmbType; pos, len: integer): Boolean;
        var n, oldNRulesStacked, i, j: integer;
        begin
            n:= KnownGoalNumber(nmb, pos, len);
            if n = 0 then KnownGoalSucceeds:= false else
            begin
                oldNRulesStacked:= NRulesStacked;
                with KnownGoalList[n] do
                begin
                    for i:= 1 to NKnownParsingsField do
                        with KnownParsingField[i] do
                        begin
                            for j:= StartField to EndField do
                            begin
                                NRulesStacked:= NRulesStacked+1;
                                RuleStack[NRulesStacked]:=
                                    KnownRuleList[j];
                            end;
                            AdvanceTOS(len);
                            DoTopOfStack;
                            RetractTOS(len);
                            NRulesStacked:= oldNRulesStacked;
                        end;
                end;
                KnownGoalSucceeds:= true;
            end;
        end { KnownGoalSucceeds };

        NKnownGoals:= 0; NKnownRules:= 0;       { in procedure Parse }