--  generated parser support file.
--  command line: wisitoken-bnf-generate.exe  --generate LR1 Ada_Emacs re2c PROCESS gpr.wy
--

--  Copyright (C) 2013 - 2019 Free Software Foundation, Inc.

--  This program is free software; you can redistribute it and/or
--  modify it under the terms of the GNU General Public License as
--  published by the Free Software Foundation; either version 3, or (at
--  your option) any later version.
--
--  This software is distributed in the hope that it will be useful,
--  but WITHOUT ANY WARRANTY; without even the implied warranty of
--  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
--  General Public License for more details.
--
--  You should have received a copy of the GNU General Public License
--  along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.

with Gpr_Process_Actions; use Gpr_Process_Actions;
with WisiToken.Lexer.re2c;
with gpr_re2c_c;
package body Gpr_Process_Main is

   package Lexer is new WisiToken.Lexer.re2c
     (gpr_re2c_c.New_Lexer,
      gpr_re2c_c.Free_Lexer,
      gpr_re2c_c.Reset_Lexer,
      gpr_re2c_c.Next_Token);

   procedure Create_Parser
     (Parser                         :    out WisiToken.Parse.LR.Parser.Parser;
      Language_Fixes                 : in     WisiToken.Parse.LR.Parser.Language_Fixes_Access;
      Language_Matching_Begin_Tokens : in     WisiToken.Parse.LR.Parser.Language_Matching_Begin_Tokens_Access;
      Language_String_ID_Set       : in     WisiToken.Parse.LR.Parser.Language_String_ID_Set_Access;
      Trace                        : not null access WisiToken.Trace'Class;
      User_Data                    : in     WisiToken.Syntax_Trees.User_Data_Access)
   is
      use WisiToken.Parse.LR;
      McKenzie_Param : constant McKenzie_Param_Type :=
        (First_Terminal    => 3,
         Last_Terminal     => 39,
         First_Nonterminal => 40,
         Last_Nonterminal  => 73,
         Insert =>
           (4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            4),
         Delete =>
           (4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
            4),
         Push_Back =>
           (2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
            2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2),
         Undo_Reduce =>
           (2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2),
         Minimal_Complete_Cost_Delta => -1,
         Fast_Forward =>  0,
         Matching_Begin =>  0,
         Ignore_Check_Fail  => 2,
         Task_Count  => 0,
         Check_Limit => 3,
         Check_Delta_Limit => 200,
         Enqueue_Limit => 10000);

      Table : constant Parse_Table_Ptr := new Parse_Table
        (State_First       => 0,
         State_Last        => 322,
         First_Terminal    => 3,
         Last_Terminal     => 39,
         First_Nonterminal => 40,
         Last_Nonterminal  => 73);
   begin
      Table.McKenzie_Param := McKenzie_Param;
      declare
         procedure Subr_1
         is begin
            Table.States (0).Action_List.Set_Capacity (8);
            Add_Action (Table.States (0), 3, Reduce, (50, 0), 0, null, null);
            Add_Action (Table.States (0), 5, Reduce, (50, 0), 0, null, null);
            Add_Action (Table.States (0), 7, Reduce, (50, 0), 0, null, null);
            Add_Action (Table.States (0), 15, Reduce, (50, 0), 0, null, null);
            Add_Action (Table.States (0), 19, Reduce, (50, 0), 0, null, null);
            Add_Action (Table.States (0), 22, Reduce, (50, 0), 0, null, null);
            Add_Action (Table.States (0), 26, 1);
            Add_Action (Table.States (0), 39, Reduce, (50, 0), 0, null, null);
            Table.States (0).Goto_List.Set_Capacity (4);
            Add_Goto (Table.States (0), 48, 2);
            Add_Goto (Table.States (0), 49, 3);
            Add_Goto (Table.States (0), 50, 4);
            Add_Goto (Table.States (0), 73, 5);
            Table.States (0).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 48, 0)));
            Table.States (1).Action_List.Set_Capacity (11);
            Add_Action (Table.States (1), 10, 6);
            Add_Action (Table.States (1), 11, 7);
            Add_Action (Table.States (1), 14, 8);
            Add_Action (Table.States (1), 19, 9);
            Add_Action (Table.States (1), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (1), 30, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (1), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (1), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (1), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (1), 37, 10);
            Add_Action (Table.States (1), 38, 11);
            Table.States (1).Goto_List.Set_Capacity (10);
            Add_Goto (Table.States (1), 41, 12);
            Add_Goto (Table.States (1), 43, 13);
            Add_Goto (Table.States (1), 44, 14);
            Add_Goto (Table.States (1), 56, 15);
            Add_Goto (Table.States (1), 57, 16);
            Add_Goto (Table.States (1), 58, 17);
            Add_Goto (Table.States (1), 59, 18);
            Add_Goto (Table.States (1), 69, 19);
            Add_Goto (Table.States (1), 70, 20);
            Add_Goto (Table.States (1), 71, 21);
            Table.States (1).Kernel := To_Vector ((0 => (73, 26, 1, False)));
            Table.States (1).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 70, 0)));
            Table.States (2).Action_List.Set_Capacity (1);
            Add_Action (Table.States (2), 39, Accept_It, (40, 0), 1, null, null);
            Table.States (2).Kernel := To_Vector ((0 => (40, 48, 1, False)));
            Table.States (3).Action_List.Set_Capacity (8);
            Add_Action (Table.States (3), 3, Reduce, (50, 1), 1, null, null);
            Add_Action (Table.States (3), 5, Reduce, (50, 1), 1, null, null);
            Add_Action (Table.States (3), 7, Reduce, (50, 1), 1, null, null);
            Add_Action (Table.States (3), 15, Reduce, (50, 1), 1, null, null);
            Add_Action (Table.States (3), 19, Reduce, (50, 1), 1, null, null);
            Add_Action (Table.States (3), 22, Reduce, (50, 1), 1, null, null);
            Add_Action (Table.States (3), 26, 1);
            Add_Action (Table.States (3), 39, Reduce, (50, 1), 1, null, null);
            Table.States (3).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (3), 73, 22);
            Table.States (3).Kernel := To_Vector (((49, 49, 2, True), (50, 49, 0, False)));
            Table.States (3).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 50, 1)));
            Table.States (4).Action_List.Set_Capacity (7);
            Add_Action (Table.States (4), 3, 23);
            Add_Action (Table.States (4), 5, 24);
            Add_Action (Table.States (4), 7, 25);
            Add_Action (Table.States (4), 15, 26);
            Add_Action (Table.States (4), 19, Reduce, (66, 0), 0, null, null);
            Add_Action (Table.States (4), 22, 27);
            Add_Action (Table.States (4), 39, Reduce, (66, 0), 0, null, null);
            Table.States (4).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (4), 66, 28);
            Table.States (4).Kernel := To_Vector ((0 => (48, 50, 0, False)));
            Table.States (4).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 66, 0)));
            Table.States (5).Action_List.Set_Capacity (8);
            Add_Action (Table.States (5), (3, 5, 7, 15, 19, 22, 26, 39), (49, 0), 1, null, null);
            Table.States (5).Kernel := To_Vector ((0 => (49, 73, 0, False)));
            Table.States (5).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 49, 1)));
            Table.States (6).Action_List.Set_Capacity (1);
            Add_Action (Table.States (6), 14, 29);
            Table.States (6).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (6), 41, 30);
            Table.States (6).Kernel := To_Vector ((0 => (57, 10, 2, False)));
            Table.States (6).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 14, 29)));
            Table.States (7).Action_List.Set_Capacity (1);
            Add_Action (Table.States (7), 14, 29);
            Table.States (7).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (7), 41, 31);
            Table.States (7).Kernel := To_Vector ((0 => (57, 11, 2, False)));
            Table.States (7).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 14, 29)));
            Table.States (8).Action_List.Set_Capacity (11);
            Add_Action (Table.States (8), 10, 32);
            Add_Action (Table.States (8), 11, 33);
            Add_Action (Table.States (8), 14, 34);
            Add_Action (Table.States (8), 19, 9);
            Add_Action (Table.States (8), 21, 35);
            Add_Conflict (Table.States (8), 21, (58, 0), 0, null, null);
            Add_Action (Table.States (8), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (8), 30, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (8), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (8), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (8), 37, 36);
            Add_Action (Table.States (8), 38, 37);
            Table.States (8).Goto_List.Set_Capacity (10);
            Add_Goto (Table.States (8), 41, 38);
            Add_Goto (Table.States (8), 43, 39);
            Add_Goto (Table.States (8), 44, 40);
            Add_Goto (Table.States (8), 56, 41);
            Add_Goto (Table.States (8), 57, 42);
            Add_Goto (Table.States (8), 58, 43);
            Add_Goto (Table.States (8), 59, 44);
            Add_Goto (Table.States (8), 69, 45);
            Add_Goto (Table.States (8), 70, 46);
            Add_Goto (Table.States (8), 71, 47);
            Table.States (8).Kernel := To_Vector (((41, 14, 1, False), (71, 14, 1, False)));
            Table.States (8).Minimal_Complete_Actions := To_Vector (((Reduce, 70, 0), (Shift, 21, 35)));
            Table.States (9).Action_List.Set_Capacity (1);
            Add_Action (Table.States (9), (1 =>  33), (43, 0), 1, null, null);
            Table.States (9).Kernel := To_Vector ((0 => (43, 19, 0, False)));
            Table.States (9).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 43, 1)));
            Table.States (10).Action_List.Set_Capacity (5);
            Add_Action (Table.States (10), (27, 30, 31, 33, 34), (58, 1), 1, null, identifier_opt_1_check'Access);
            Table.States (10).Kernel := To_Vector ((0 => (58, 37, 0, False)));
            Table.States (10).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 1)));
            Table.States (11).Action_List.Set_Capacity (3);
            Add_Action (Table.States (11), (27, 30, 34), (69, 0), 1, null, null);
            Table.States (11).Kernel := To_Vector ((0 => (69, 38, 0, False)));
            Table.States (11).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 69, 1)));
            Table.States (12).Action_List.Set_Capacity (3);
            Add_Action (Table.States (12), (27, 30, 34), (71, 2), 1, null, null);
            Table.States (12).Kernel := To_Vector ((0 => (71, 41, 0, False)));
            Table.States (12).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 71, 1)));
            Table.States (13).Action_List.Set_Capacity (1);
            Add_Action (Table.States (13), 33, 48);
            Table.States (13).Kernel := To_Vector (((44, 43, 2, False), (44, 43, 5, False)));
            Table.States (13).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 33, 48)));
            Table.States (14).Action_List.Set_Capacity (3);
            Add_Action (Table.States (14), (27, 30, 34), (69, 3), 1, null, null);
            Table.States (14).Kernel := To_Vector ((0 => (69, 44, 0, False)));
            Table.States (14).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 69, 1)));
            Table.States (15).Action_List.Set_Capacity (3);
            Add_Action (Table.States (15), 27, 49);
            Add_Action (Table.States (15), 30, Reduce, (70, 0), 1, null, null);
            Add_Action (Table.States (15), 34, Reduce, (70, 0), 1, null, null);
            Table.States (15).Kernel := To_Vector (((56, 56, 1, True), (70, 56, 0, False)));
            Table.States (15).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 70, 1)));
            Table.States (16).Action_List.Set_Capacity (3);
            Add_Action (Table.States (16), (27, 30, 34), (69, 2), 1, null, null);
            Table.States (16).Kernel := To_Vector ((0 => (69, 57, 0, False)));
            Table.States (16).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 69, 1)));
            Table.States (17).Action_List.Set_Capacity (5);
            Add_Action (Table.States (17), (27, 30, 31, 33, 34), (59, 0), 1, null, null);
            Table.States (17).Kernel := To_Vector ((0 => (59, 58, 0, False)));
            Table.States (17).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 1)));
            Table.States (18).Action_List.Set_Capacity (5);
            Add_Action (Table.States (18), 27, Reduce, (69, 1), 1, null, null);
            Add_Action (Table.States (18), 30, Reduce, (69, 1), 1, null, null);
            Add_Action (Table.States (18), 31, 50);
            Add_Action (Table.States (18), 33, Reduce, (43, 1), 1, null, null);
            Add_Action (Table.States (18), 34, Reduce, (69, 1), 1, null, null);
            Table.States (18).Kernel := To_Vector (((43, 59, 0, False), (59, 59, 2, True), (69, 59, 0, False)));
            Table.States (18).Minimal_Complete_Actions := To_Vector (((Reduce, 43, 1), (Reduce, 69, 1)));
            Table.States (19).Action_List.Set_Capacity (3);
            Add_Action (Table.States (19), (27, 30, 34), (71, 0), 1, null, null);
            Table.States (19).Kernel := To_Vector ((0 => (71, 69, 0, False)));
            Table.States (19).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 71, 1)));
            Table.States (20).Action_List.Set_Capacity (2);
            Add_Action (Table.States (20), 30, 51);
            Add_Action (Table.States (20), 34, 52);
            Table.States (20).Kernel := To_Vector (((70, 70, 1, True), (73, 70, 1, False)));
            Table.States (20).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 52)));
            Table.States (21).Action_List.Set_Capacity (3);
            Add_Action (Table.States (21), (27, 30, 34), (56, 0), 1, null, null);
            Table.States (21).Kernel := To_Vector ((0 => (56, 71, 0, False)));
            Table.States (21).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 1)));
            Table.States (22).Action_List.Set_Capacity (8);
            Add_Action (Table.States (22), (3, 5, 7, 15, 19, 22, 26, 39), (49, 1), 2, null, null);
            Table.States (22).Kernel := To_Vector ((0 => (49, 73, 0, True)));
            Table.States (22).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 49, 2)));
            Table.States (22).Minimal_Complete_Actions_Recursive := True;
            Table.States (23).Action_List.Set_Capacity (2);
            Add_Action (Table.States (23), (19, 39), (66, 1), 1, null, null);
            Table.States (23).Kernel := To_Vector ((0 => (66, 3, 0, False)));
            Table.States (23).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 66, 1)));
            Table.States (24).Action_List.Set_Capacity (3);
            Add_Action (Table.States (24), 15, 53);
            Add_Action (Table.States (24), 19, Reduce, (66, 3), 1, null, null);
            Add_Action (Table.States (24), 39, Reduce, (66, 3), 1, null, null);
            Table.States (24).Kernel := To_Vector (((66, 5, 0, False), (66, 5, 1, False)));
            Table.States (24).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 66, 1)));
            Table.States (25).Action_List.Set_Capacity (2);
            Add_Action (Table.States (25), (19, 39), (66, 6), 1, null, null);
            Table.States (25).Kernel := To_Vector ((0 => (66, 7, 0, False)));
            Table.States (25).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 66, 1)));
            Table.States (26).Action_List.Set_Capacity (2);
            Add_Action (Table.States (26), (19, 39), (66, 5), 1, null, null);
            Table.States (26).Kernel := To_Vector ((0 => (66, 15, 0, False)));
            Table.States (26).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 66, 1)));
            Table.States (27).Action_List.Set_Capacity (2);
            Add_Action (Table.States (27), (19, 39), (66, 2), 1, null, null);
            Table.States (27).Kernel := To_Vector ((0 => (66, 22, 0, False)));
            Table.States (27).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 66, 1)));
            Table.States (28).Action_List.Set_Capacity (2);
            Add_Action (Table.States (28), 19, 54);
            Add_Action (Table.States (28), 39, Reduce, (64, 0), 0, null, null);
            Table.States (28).Goto_List.Set_Capacity (3);
            Add_Goto (Table.States (28), 64, 55);
            Add_Goto (Table.States (28), 65, 56);
            Add_Goto (Table.States (28), 68, 57);
            Table.States (28).Kernel := To_Vector ((0 => (48, 66, 0, False)));
            Table.States (28).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 64, 0)));
            Table.States (29).Action_List.Set_Capacity (11);
            Add_Action (Table.States (29), 10, 32);
            Add_Action (Table.States (29), 11, 33);
            Add_Action (Table.States (29), 14, 34);
            Add_Action (Table.States (29), 19, 9);
            Add_Action (Table.States (29), 21, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (29), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (29), 30, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (29), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (29), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (29), 37, 36);
            Add_Action (Table.States (29), 38, 37);
            Table.States (29).Goto_List.Set_Capacity (10);
            Add_Goto (Table.States (29), 41, 38);
            Add_Goto (Table.States (29), 43, 39);
            Add_Goto (Table.States (29), 44, 40);
            Add_Goto (Table.States (29), 56, 41);
            Add_Goto (Table.States (29), 57, 42);
            Add_Goto (Table.States (29), 58, 43);
            Add_Goto (Table.States (29), 59, 44);
            Add_Goto (Table.States (29), 69, 45);
            Add_Goto (Table.States (29), 70, 46);
            Add_Goto (Table.States (29), 71, 47);
            Table.States (29).Kernel := To_Vector ((0 => (41, 14, 1, False)));
            Table.States (29).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 70, 0)));
            Table.States (30).Action_List.Set_Capacity (3);
            Add_Action (Table.States (30), (27, 30, 34), (57, 0), 2, null, null);
            Table.States (30).Kernel := To_Vector ((0 => (57, 41, 0, False)));
            Table.States (30).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 57, 2)));
            Table.States (31).Action_List.Set_Capacity (3);
            Add_Action (Table.States (31), (27, 30, 34), (57, 1), 2, null, null);
            Table.States (31).Kernel := To_Vector ((0 => (57, 41, 0, False)));
            Table.States (31).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 57, 2)));
            Table.States (32).Action_List.Set_Capacity (1);
            Add_Action (Table.States (32), 14, 58);
            Table.States (32).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (32), 41, 59);
            Table.States (32).Kernel := To_Vector ((0 => (57, 10, 2, False)));
            Table.States (32).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 14, 58)));
            Table.States (33).Action_List.Set_Capacity (1);
            Add_Action (Table.States (33), 14, 58);
            Table.States (33).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (33), 41, 60);
            Table.States (33).Kernel := To_Vector ((0 => (57, 11, 2, False)));
            Table.States (33).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 14, 58)));
            Table.States (34).Action_List.Set_Capacity (11);
            Add_Action (Table.States (34), 10, 32);
            Add_Action (Table.States (34), 11, 33);
            Add_Action (Table.States (34), 14, 34);
            Add_Action (Table.States (34), 19, 9);
            Add_Action (Table.States (34), 21, 61);
            Add_Conflict (Table.States (34), 21, (58, 0), 0, null, null);
            Add_Action (Table.States (34), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (34), 30, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (34), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (34), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (34), 37, 36);
            Add_Action (Table.States (34), 38, 37);
            Table.States (34).Goto_List.Set_Capacity (10);
            Add_Goto (Table.States (34), 41, 38);
            Add_Goto (Table.States (34), 43, 39);
            Add_Goto (Table.States (34), 44, 40);
            Add_Goto (Table.States (34), 56, 41);
            Add_Goto (Table.States (34), 57, 42);
            Add_Goto (Table.States (34), 58, 43);
            Add_Goto (Table.States (34), 59, 44);
            Add_Goto (Table.States (34), 69, 45);
            Add_Goto (Table.States (34), 70, 62);
            Add_Goto (Table.States (34), 71, 47);
            Table.States (34).Kernel := To_Vector (((41, 14, 1, False), (71, 14, 1, False)));
            Table.States (34).Minimal_Complete_Actions := To_Vector (((Reduce, 70, 0), (Shift, 21, 61)));
            Table.States (35).Action_List.Set_Capacity (3);
            Add_Action (Table.States (35), (27, 30, 34), (71, 1), 2, null, null);
            Table.States (35).Kernel := To_Vector ((0 => (71, 21, 0, False)));
            Table.States (35).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 71, 2)));
            Table.States (36).Action_List.Set_Capacity (5);
            Add_Action (Table.States (36), (21, 27, 30, 31, 33), (58, 1), 1, null, identifier_opt_1_check'Access);
            Table.States (36).Kernel := To_Vector ((0 => (58, 37, 0, False)));
            Table.States (36).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 1)));
            Table.States (37).Action_List.Set_Capacity (3);
            Add_Action (Table.States (37), (21, 27, 30), (69, 0), 1, null, null);
            Table.States (37).Kernel := To_Vector ((0 => (69, 38, 0, False)));
            Table.States (37).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 69, 1)));
            Table.States (38).Action_List.Set_Capacity (3);
            Add_Action (Table.States (38), (21, 27, 30), (71, 2), 1, null, null);
            Table.States (38).Kernel := To_Vector ((0 => (71, 41, 0, False)));
            Table.States (38).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 71, 1)));
            Table.States (39).Action_List.Set_Capacity (1);
            Add_Action (Table.States (39), 33, 63);
            Table.States (39).Kernel := To_Vector (((44, 43, 2, False), (44, 43, 5, False)));
            Table.States (39).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 33, 63)));
            Table.States (40).Action_List.Set_Capacity (3);
            Add_Action (Table.States (40), (21, 27, 30), (69, 3), 1, null, null);
            Table.States (40).Kernel := To_Vector ((0 => (69, 44, 0, False)));
            Table.States (40).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 69, 1)));
            Table.States (41).Action_List.Set_Capacity (3);
            Add_Action (Table.States (41), 21, Reduce, (70, 0), 1, null, null);
            Add_Action (Table.States (41), 27, 64);
            Add_Action (Table.States (41), 30, Reduce, (70, 0), 1, null, null);
            Table.States (41).Kernel := To_Vector (((56, 56, 1, True), (70, 56, 0, False)));
            Table.States (41).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 70, 1)));
            Table.States (42).Action_List.Set_Capacity (3);
            Add_Action (Table.States (42), (21, 27, 30), (69, 2), 1, null, null);
            Table.States (42).Kernel := To_Vector ((0 => (69, 57, 0, False)));
            Table.States (42).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 69, 1)));
            Table.States (43).Action_List.Set_Capacity (5);
            Add_Action (Table.States (43), (21, 27, 30, 31, 33), (59, 0), 1, null, null);
            Table.States (43).Kernel := To_Vector ((0 => (59, 58, 0, False)));
            Table.States (43).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 1)));
            Table.States (44).Action_List.Set_Capacity (5);
            Add_Action (Table.States (44), 21, Reduce, (69, 1), 1, null, null);
            Add_Action (Table.States (44), 27, Reduce, (69, 1), 1, null, null);
            Add_Action (Table.States (44), 30, Reduce, (69, 1), 1, null, null);
            Add_Action (Table.States (44), 31, 65);
            Add_Action (Table.States (44), 33, Reduce, (43, 1), 1, null, null);
            Table.States (44).Kernel := To_Vector (((43, 59, 0, False), (59, 59, 2, True), (69, 59, 0, False)));
            Table.States (44).Minimal_Complete_Actions := To_Vector (((Reduce, 43, 1), (Reduce, 69, 1)));
            Table.States (45).Action_List.Set_Capacity (3);
            Add_Action (Table.States (45), (21, 27, 30), (71, 0), 1, null, null);
            Table.States (45).Kernel := To_Vector ((0 => (71, 69, 0, False)));
            Table.States (45).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 71, 1)));
            Table.States (46).Action_List.Set_Capacity (2);
            Add_Action (Table.States (46), 21, 66);
            Add_Action (Table.States (46), 30, 67);
            Table.States (46).Kernel := To_Vector (((41, 70, 1, False), (70, 70, 1, True)));
            Table.States (46).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 21, 66)));
            Table.States (47).Action_List.Set_Capacity (3);
            Add_Action (Table.States (47), (21, 27, 30), (56, 0), 1, null, null);
            Table.States (47).Kernel := To_Vector ((0 => (56, 71, 0, False)));
            Table.States (47).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 1)));
            Table.States (48).Action_List.Set_Capacity (1);
            Add_Action (Table.States (48), 37, 68);
            Table.States (48).Kernel := To_Vector (((44, 33, 1, False), (44, 33, 4, False)));
            Table.States (48).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 68)));
            Table.States (49).Action_List.Set_Capacity (11);
            Add_Action (Table.States (49), 10, 6);
            Add_Action (Table.States (49), 11, 7);
            Add_Action (Table.States (49), 14, 8);
            Add_Action (Table.States (49), 19, 9);
            Add_Action (Table.States (49), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (49), 30, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (49), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (49), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (49), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (49), 37, 10);
            Add_Action (Table.States (49), 38, 11);
            Table.States (49).Goto_List.Set_Capacity (8);
            Add_Goto (Table.States (49), 41, 12);
            Add_Goto (Table.States (49), 43, 13);
            Add_Goto (Table.States (49), 44, 14);
            Add_Goto (Table.States (49), 57, 16);
            Add_Goto (Table.States (49), 58, 17);
            Add_Goto (Table.States (49), 59, 18);
            Add_Goto (Table.States (49), 69, 19);
            Add_Goto (Table.States (49), 71, 69);
            Table.States (49).Kernel := To_Vector ((0 => (56, 27, 0, True)));
            Table.States (49).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 71, 0)));
            Table.States (49).Minimal_Complete_Actions_Recursive := True;
            Table.States (50).Action_List.Set_Capacity (1);
            Add_Action (Table.States (50), 37, 70);
            Table.States (50).Kernel := To_Vector ((0 => (59, 31, 1, True)));
            Table.States (50).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 70)));
            Table.States (50).Minimal_Complete_Actions_Recursive := True;
            Table.States (51).Action_List.Set_Capacity (11);
            Add_Action (Table.States (51), 10, 6);
            Add_Action (Table.States (51), 11, 7);
            Add_Action (Table.States (51), 14, 8);
            Add_Action (Table.States (51), 19, 9);
            Add_Action (Table.States (51), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (51), 30, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (51), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (51), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (51), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (51), 37, 10);
            Add_Action (Table.States (51), 38, 11);
            Table.States (51).Goto_List.Set_Capacity (9);
            Add_Goto (Table.States (51), 41, 12);
            Add_Goto (Table.States (51), 43, 13);
            Add_Goto (Table.States (51), 44, 14);
            Add_Goto (Table.States (51), 56, 71);
            Add_Goto (Table.States (51), 57, 16);
            Add_Goto (Table.States (51), 58, 17);
            Add_Goto (Table.States (51), 59, 18);
            Add_Goto (Table.States (51), 69, 19);
            Add_Goto (Table.States (51), 71, 21);
            Table.States (51).Kernel := To_Vector ((0 => (70, 30, 0, True)));
            Table.States (51).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 0)));
            Table.States (51).Minimal_Complete_Actions_Recursive := True;
            Table.States (52).Action_List.Set_Capacity (8);
            Add_Action (Table.States (52), (3, 5, 7, 15, 19, 22, 26, 39), (73, 0), 3, null, null);
            Table.States (52).Kernel := To_Vector ((0 => (73, 34, 0, False)));
            Table.States (52).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 73, 3)));
            Table.States (53).Action_List.Set_Capacity (2);
            Add_Action (Table.States (53), (19, 39), (66, 4), 2, null, null);
            Table.States (53).Kernel := To_Vector ((0 => (66, 15, 0, False)));
            Table.States (53).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 66, 2)));
            Table.States (54).Action_List.Set_Capacity (3);
            Add_Action (Table.States (54), 9, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (54), 13, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (54), 37, 72);
            Table.States (54).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (54), 58, 73);
            Table.States (54).Kernel := To_Vector (((65, 19, 5, False), (68, 19, 3, False)));
            Table.States (54).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 0)));
            Table.States (55).Action_List.Set_Capacity (1);
            Add_Action (Table.States (55), (1 =>  39), (48, 0), 3, compilation_unit_0'Access, null);
            Table.States (55).Kernel := To_Vector ((0 => (48, 64, 0, False)));
            Table.States (55).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 48, 3)));
            Table.States (56).Action_List.Set_Capacity (1);
            Add_Action (Table.States (56), (1 =>  39), (64, 2), 1, null, null);
            Table.States (56).Kernel := To_Vector ((0 => (64, 65, 0, False)));
            Table.States (56).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 64, 1)));
            Table.States (57).Action_List.Set_Capacity (1);
            Add_Action (Table.States (57), (1 =>  39), (64, 1), 1, null, null);
            Table.States (57).Kernel := To_Vector ((0 => (64, 68, 0, False)));
            Table.States (57).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 64, 1)));
            Table.States (58).Action_List.Set_Capacity (11);
            Add_Action (Table.States (58), 10, 32);
            Add_Action (Table.States (58), 11, 33);
            Add_Action (Table.States (58), 14, 34);
            Add_Action (Table.States (58), 19, 9);
            Add_Action (Table.States (58), 21, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (58), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (58), 30, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (58), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (58), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (58), 37, 36);
            Add_Action (Table.States (58), 38, 37);
            Table.States (58).Goto_List.Set_Capacity (10);
            Add_Goto (Table.States (58), 41, 38);
            Add_Goto (Table.States (58), 43, 39);
            Add_Goto (Table.States (58), 44, 40);
            Add_Goto (Table.States (58), 56, 41);
            Add_Goto (Table.States (58), 57, 42);
            Add_Goto (Table.States (58), 58, 43);
            Add_Goto (Table.States (58), 59, 44);
            Add_Goto (Table.States (58), 69, 45);
            Add_Goto (Table.States (58), 70, 62);
            Add_Goto (Table.States (58), 71, 47);
            Table.States (58).Kernel := To_Vector ((0 => (41, 14, 1, False)));
            Table.States (58).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 70, 0)));
            Table.States (59).Action_List.Set_Capacity (3);
            Add_Action (Table.States (59), (21, 27, 30), (57, 0), 2, null, null);
            Table.States (59).Kernel := To_Vector ((0 => (57, 41, 0, False)));
            Table.States (59).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 57, 2)));
            Table.States (60).Action_List.Set_Capacity (3);
            Add_Action (Table.States (60), (21, 27, 30), (57, 1), 2, null, null);
            Table.States (60).Kernel := To_Vector ((0 => (57, 41, 0, False)));
            Table.States (60).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 57, 2)));
            Table.States (61).Action_List.Set_Capacity (3);
            Add_Action (Table.States (61), (21, 27, 30), (71, 1), 2, null, null);
            Table.States (61).Kernel := To_Vector ((0 => (71, 21, 0, False)));
            Table.States (61).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 71, 2)));
            Table.States (62).Action_List.Set_Capacity (2);
            Add_Action (Table.States (62), 21, 74);
            Add_Action (Table.States (62), 30, 67);
            Table.States (62).Kernel := To_Vector (((41, 70, 1, False), (70, 70, 1, True)));
            Table.States (62).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 21, 74)));
            Table.States (63).Action_List.Set_Capacity (1);
            Add_Action (Table.States (63), 37, 75);
            Table.States (63).Kernel := To_Vector (((44, 33, 1, False), (44, 33, 4, False)));
            Table.States (63).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 75)));
            Table.States (64).Action_List.Set_Capacity (11);
            Add_Action (Table.States (64), 10, 32);
            Add_Action (Table.States (64), 11, 33);
            Add_Action (Table.States (64), 14, 34);
            Add_Action (Table.States (64), 19, 9);
            Add_Action (Table.States (64), 21, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (64), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (64), 30, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (64), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (64), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (64), 37, 36);
            Add_Action (Table.States (64), 38, 37);
            Table.States (64).Goto_List.Set_Capacity (8);
            Add_Goto (Table.States (64), 41, 38);
            Add_Goto (Table.States (64), 43, 39);
            Add_Goto (Table.States (64), 44, 40);
            Add_Goto (Table.States (64), 57, 42);
            Add_Goto (Table.States (64), 58, 43);
            Add_Goto (Table.States (64), 59, 44);
            Add_Goto (Table.States (64), 69, 45);
            Add_Goto (Table.States (64), 71, 76);
            Table.States (64).Kernel := To_Vector ((0 => (56, 27, 0, True)));
            Table.States (64).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 71, 0)));
            Table.States (64).Minimal_Complete_Actions_Recursive := True;
            Table.States (65).Action_List.Set_Capacity (1);
            Add_Action (Table.States (65), 37, 77);
            Table.States (65).Kernel := To_Vector ((0 => (59, 31, 1, True)));
            Table.States (65).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 77)));
            Table.States (65).Minimal_Complete_Actions_Recursive := True;
            Table.States (66).Action_List.Set_Capacity (3);
            Add_Action (Table.States (66), (27, 30, 34), (41, 0), 3, aggregate_g_0'Access, null);
            Table.States (66).Kernel := To_Vector ((0 => (41, 21, 0, False)));
            Table.States (66).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 41, 3)));
            Table.States (67).Action_List.Set_Capacity (11);
            Add_Action (Table.States (67), 10, 32);
            Add_Action (Table.States (67), 11, 33);
            Add_Action (Table.States (67), 14, 34);
            Add_Action (Table.States (67), 19, 9);
            Add_Action (Table.States (67), 21, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (67), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (67), 30, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (67), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (67), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (67), 37, 36);
            Add_Action (Table.States (67), 38, 37);
            Table.States (67).Goto_List.Set_Capacity (9);
            Add_Goto (Table.States (67), 41, 38);
            Add_Goto (Table.States (67), 43, 39);
            Add_Goto (Table.States (67), 44, 40);
            Add_Goto (Table.States (67), 56, 78);
            Add_Goto (Table.States (67), 57, 42);
            Add_Goto (Table.States (67), 58, 43);
            Add_Goto (Table.States (67), 59, 44);
            Add_Goto (Table.States (67), 69, 45);
            Add_Goto (Table.States (67), 71, 47);
            Table.States (67).Kernel := To_Vector ((0 => (70, 30, 0, True)));
            Table.States (67).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 0)));
            Table.States (67).Minimal_Complete_Actions_Recursive := True;
            Table.States (68).Action_List.Set_Capacity (4);
            Add_Action (Table.States (68), 14, 79);
            Add_Action (Table.States (68), 27, Reduce, (44, 0), 3, null, null);
            Add_Action (Table.States (68), 30, Reduce, (44, 0), 3, null, null);
            Add_Action (Table.States (68), 34, Reduce, (44, 0), 3, null, null);
            Table.States (68).Kernel := To_Vector (((44, 37, 0, False), (44, 37, 3, False)));
            Table.States (68).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 44, 3)));
            Table.States (69).Action_List.Set_Capacity (3);
            Add_Action (Table.States (69), (27, 30, 34), (56, 1), 3, null, null);
            Table.States (69).Kernel := To_Vector ((0 => (56, 71, 0, True)));
            Table.States (69).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 3)));
            Table.States (69).Minimal_Complete_Actions_Recursive := True;
            Table.States (70).Action_List.Set_Capacity (5);
            Add_Action (Table.States (70), (27, 30, 31, 33, 34), (59, 1), 3, null, null);
            Table.States (70).Kernel := To_Vector ((0 => (59, 37, 0, True)));
            Table.States (70).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 3)));
            Table.States (70).Minimal_Complete_Actions_Recursive := True;
            Table.States (71).Action_List.Set_Capacity (3);
            Add_Action (Table.States (71), 27, 49);
            Add_Action (Table.States (71), 30, Reduce, (70, 1), 3, null, null);
            Add_Action (Table.States (71), 34, Reduce, (70, 1), 3, null, null);
            Table.States (71).Kernel := To_Vector (((56, 56, 1, True), (70, 56, 0, True)));
            Table.States (71).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 70, 3)));
            Table.States (71).Minimal_Complete_Actions_Recursive := True;
            Table.States (72).Action_List.Set_Capacity (2);
            Add_Action (Table.States (72), (9, 13), (58, 1), 1, null, identifier_opt_1_check'Access);
            Table.States (72).Kernel := To_Vector ((0 => (58, 37, 0, False)));
            Table.States (72).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 1)));
            Table.States (73).Action_List.Set_Capacity (2);
            Add_Action (Table.States (73), 9, 80);
            Add_Action (Table.States (73), 13, 81);
            Table.States (73).Kernel := To_Vector (((65, 58, 5, False), (68, 58, 3, False)));
            Table.States (73).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 13, 81)));
            Table.States (74).Action_List.Set_Capacity (3);
            Add_Action (Table.States (74), (21, 27, 30), (41, 0), 3, aggregate_g_0'Access, null);
            Table.States (74).Kernel := To_Vector ((0 => (41, 21, 0, False)));
            Table.States (74).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 41, 3)));
            Table.States (75).Action_List.Set_Capacity (4);
            Add_Action (Table.States (75), 14, 82);
            Add_Action (Table.States (75), 21, Reduce, (44, 0), 3, null, null);
            Add_Action (Table.States (75), 27, Reduce, (44, 0), 3, null, null);
            Add_Action (Table.States (75), 30, Reduce, (44, 0), 3, null, null);
            Table.States (75).Kernel := To_Vector (((44, 37, 0, False), (44, 37, 3, False)));
            Table.States (75).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 44, 3)));
            Table.States (76).Action_List.Set_Capacity (3);
            Add_Action (Table.States (76), (21, 27, 30), (56, 1), 3, null, null);
            Table.States (76).Kernel := To_Vector ((0 => (56, 71, 0, True)));
            Table.States (76).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 3)));
            Table.States (76).Minimal_Complete_Actions_Recursive := True;
            Table.States (77).Action_List.Set_Capacity (5);
            Add_Action (Table.States (77), (21, 27, 30, 31, 33), (59, 1), 3, null, null);
            Table.States (77).Kernel := To_Vector ((0 => (59, 37, 0, True)));
            Table.States (77).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 3)));
            Table.States (77).Minimal_Complete_Actions_Recursive := True;
            Table.States (78).Action_List.Set_Capacity (3);
            Add_Action (Table.States (78), 21, Reduce, (70, 1), 3, null, null);
            Add_Action (Table.States (78), 27, 64);
            Add_Action (Table.States (78), 30, Reduce, (70, 1), 3, null, null);
            Table.States (78).Kernel := To_Vector (((56, 56, 1, True), (70, 56, 0, True)));
            Table.States (78).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 70, 3)));
            Table.States (78).Minimal_Complete_Actions_Recursive := True;
            Table.States (79).Action_List.Set_Capacity (1);
            Add_Action (Table.States (79), 38, 83);
            Table.States (79).Kernel := To_Vector ((0 => (44, 14, 2, False)));
            Table.States (79).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 38, 83)));
            Table.States (80).Action_List.Set_Capacity (1);
            Add_Action (Table.States (80), 38, 84);
            Table.States (80).Kernel := To_Vector ((0 => (65, 9, 4, False)));
            Table.States (80).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 38, 84)));
            Table.States (81).Action_List.Set_Capacity (7);
            Add_Action (Table.States (81), 6, 85);
            Add_Action (Table.States (81), 8, Reduce, (53, 0), 0, null, null);
            Add_Action (Table.States (81), 12, 86);
            Add_Action (Table.States (81), 16, 87);
            Add_Action (Table.States (81), 18, 88);
            Add_Action (Table.States (81), 23, 89);
            Add_Action (Table.States (81), 37, 90);
            Table.States (81).Goto_List.Set_Capacity (11);
            Add_Goto (Table.States (81), 42, 91);
            Add_Goto (Table.States (81), 45, 92);
            Add_Goto (Table.States (81), 51, 93);
            Add_Goto (Table.States (81), 52, 94);
            Add_Goto (Table.States (81), 53, 95);
            Add_Goto (Table.States (81), 60, 96);
            Add_Goto (Table.States (81), 61, 97);
            Add_Goto (Table.States (81), 62, 98);
            Add_Goto (Table.States (81), 63, 99);
            Add_Goto (Table.States (81), 67, 100);
            Add_Goto (Table.States (81), 72, 101);
            Table.States (81).Kernel := To_Vector ((0 => (68, 13, 2, False)));
            Table.States (81).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 53, 0)));
            Table.States (82).Action_List.Set_Capacity (1);
            Add_Action (Table.States (82), 38, 102);
            Table.States (82).Kernel := To_Vector ((0 => (44, 14, 2, False)));
            Table.States (82).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 38, 102)));
            Table.States (83).Action_List.Set_Capacity (1);
            Add_Action (Table.States (83), 21, 103);
            Table.States (83).Kernel := To_Vector ((0 => (44, 38, 1, False)));
            Table.States (83).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 21, 103)));
            Table.States (84).Action_List.Set_Capacity (1);
            Add_Action (Table.States (84), 13, 104);
            Table.States (84).Kernel := To_Vector ((0 => (65, 38, 3, False)));
            Table.States (84).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 13, 104)));
            Table.States (85).Action_List.Set_Capacity (3);
            Add_Action (Table.States (85), 13, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (85), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (85), 37, 105);
            Table.States (85).Goto_List.Set_Capacity (2);
            Add_Goto (Table.States (85), 58, 106);
            Add_Goto (Table.States (85), 59, 107);
            Table.States (85).Kernel := To_Vector ((0 => (45, 6, 4, False)));
            Table.States (85).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 0)));
            Table.States (86).Action_List.Set_Capacity (2);
            Add_Action (Table.States (86), 10, 108);
            Add_Action (Table.States (86), 37, 109);
            Table.States (86).Kernel := To_Vector (((42, 12, 3, False), (42, 12, 5, False), (42, 12, 7, False), (42,
            12, 6, False)));
            Table.States (86).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 109)));
            Table.States (87).Action_List.Set_Capacity (1);
            Add_Action (Table.States (87), 34, 110);
            Table.States (87).Kernel := To_Vector ((0 => (67, 16, 1, False)));
            Table.States (87).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 110)));
            Table.States (88).Action_List.Set_Capacity (4);
            Add_Action (Table.States (88), 9, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (88), 13, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (88), 20, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (88), 37, 111);
            Table.States (88).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (88), 58, 112);
            Table.States (88).Kernel := To_Vector (((61, 18, 3, False), (62, 18, 4, False), (63, 18, 2, False)));
            Table.States (88).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 0)));
            Table.States (89).Action_List.Set_Capacity (1);
            Add_Action (Table.States (89), 37, 113);
            Table.States (89).Kernel := To_Vector ((0 => (72, 23, 5, False)));
            Table.States (89).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 113)));
            Table.States (90).Action_List.Set_Capacity (2);
            Add_Action (Table.States (90), 28, 114);
            Add_Action (Table.States (90), 29, 115);
            Table.States (90).Kernel := To_Vector (((67, 37, 2, False), (67, 37, 4, False)));
            Table.States (90).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 29, 115)));
            Table.States (91).Action_List.Set_Capacity (7);
            Add_Action (Table.States (91), (6, 8, 12, 16, 18, 23, 37), (67, 2), 1, null, null);
            Table.States (91).Kernel := To_Vector ((0 => (67, 42, 0, False)));
            Table.States (91).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 67, 1)));
            Table.States (92).Action_List.Set_Capacity (7);
            Add_Action (Table.States (92), (6, 8, 12, 16, 18, 23, 37), (67, 3), 1, null, null);
            Table.States (92).Kernel := To_Vector ((0 => (67, 45, 0, False)));
            Table.States (92).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 67, 1)));
            Table.States (93).Action_List.Set_Capacity (7);
            Add_Action (Table.States (93), (6, 8, 12, 16, 18, 23, 37), (52, 0), 1, null, null);
            Table.States (93).Kernel := To_Vector ((0 => (52, 51, 0, False)));
            Table.States (93).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 52, 1)));
            Table.States (94).Action_List.Set_Capacity (7);
            Add_Action (Table.States (94), 6, 85);
            Add_Action (Table.States (94), 8, Reduce, (53, 1), 1, null, null);
            Add_Action (Table.States (94), 12, 86);
            Add_Action (Table.States (94), 16, 87);
            Add_Action (Table.States (94), 18, 88);
            Add_Action (Table.States (94), 23, 89);
            Add_Action (Table.States (94), 37, 90);
            Table.States (94).Goto_List.Set_Capacity (9);
            Add_Goto (Table.States (94), 42, 91);
            Add_Goto (Table.States (94), 45, 92);
            Add_Goto (Table.States (94), 51, 116);
            Add_Goto (Table.States (94), 60, 96);
            Add_Goto (Table.States (94), 61, 97);
            Add_Goto (Table.States (94), 62, 98);
            Add_Goto (Table.States (94), 63, 99);
            Add_Goto (Table.States (94), 67, 100);
            Add_Goto (Table.States (94), 72, 101);
            Table.States (94).Kernel := To_Vector (((52, 52, 2, True), (53, 52, 0, False)));
            Table.States (94).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 53, 1)));
            Table.States (95).Action_List.Set_Capacity (1);
            Add_Action (Table.States (95), 8, 117);
            Table.States (95).Kernel := To_Vector ((0 => (68, 53, 2, False)));
            Table.States (95).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 8, 117)));
            Table.States (96).Action_List.Set_Capacity (7);
            Add_Action (Table.States (96), (6, 8, 12, 16, 18, 23, 37), (51, 2), 1, null, null);
            Table.States (96).Kernel := To_Vector ((0 => (51, 60, 0, False)));
            Table.States (96).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 51, 1)));
            Table.States (97).Action_List.Set_Capacity (7);
            Add_Action (Table.States (97), (6, 8, 12, 16, 18, 23, 37), (60, 0), 1, null, null);
            Table.States (97).Kernel := To_Vector ((0 => (60, 61, 0, False)));
            Table.States (97).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 60, 1)));
            Table.States (98).Action_List.Set_Capacity (7);
            Add_Action (Table.States (98), (6, 8, 12, 16, 18, 23, 37), (60, 1), 1, null, null);
            Table.States (98).Kernel := To_Vector ((0 => (60, 62, 0, False)));
            Table.States (98).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 60, 1)));
            Table.States (99).Action_List.Set_Capacity (7);
            Add_Action (Table.States (99), (6, 8, 12, 16, 18, 23, 37), (60, 2), 1, null, null);
            Table.States (99).Kernel := To_Vector ((0 => (60, 63, 0, False)));
            Table.States (99).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 60, 1)));
            Table.States (100).Action_List.Set_Capacity (7);
            Add_Action (Table.States (100), (6, 8, 12, 16, 18, 23, 37), (51, 0), 1, null, null);
            Table.States (100).Kernel := To_Vector ((0 => (51, 67, 0, False)));
            Table.States (100).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 51, 1)));
            Table.States (101).Action_List.Set_Capacity (7);
            Add_Action (Table.States (101), (6, 8, 12, 16, 18, 23, 37), (51, 1), 1, null, null);
            Table.States (101).Kernel := To_Vector ((0 => (51, 72, 0, False)));
            Table.States (101).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 51, 1)));
            Table.States (102).Action_List.Set_Capacity (1);
            Add_Action (Table.States (102), 21, 118);
            Table.States (102).Kernel := To_Vector ((0 => (44, 38, 1, False)));
            Table.States (102).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 21, 118)));
            Table.States (103).Action_List.Set_Capacity (3);
            Add_Action (Table.States (103), (27, 30, 34), (44, 1), 6, null, null);
            Table.States (103).Kernel := To_Vector ((0 => (44, 21, 0, False)));
            Table.States (103).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 44, 6)));
            Table.States (104).Action_List.Set_Capacity (7);
            Add_Action (Table.States (104), 6, 85);
            Add_Action (Table.States (104), 8, Reduce, (53, 0), 0, null, null);
            Add_Action (Table.States (104), 12, 86);
            Add_Action (Table.States (104), 16, 87);
            Add_Action (Table.States (104), 18, 88);
            Add_Action (Table.States (104), 23, 89);
            Add_Action (Table.States (104), 37, 90);
            Table.States (104).Goto_List.Set_Capacity (11);
            Add_Goto (Table.States (104), 42, 91);
            Add_Goto (Table.States (104), 45, 92);
            Add_Goto (Table.States (104), 51, 93);
            Add_Goto (Table.States (104), 52, 94);
            Add_Goto (Table.States (104), 53, 119);
            Add_Goto (Table.States (104), 60, 96);
            Add_Goto (Table.States (104), 61, 97);
            Add_Goto (Table.States (104), 62, 98);
            Add_Goto (Table.States (104), 63, 99);
            Add_Goto (Table.States (104), 67, 100);
            Add_Goto (Table.States (104), 72, 101);
            Table.States (104).Kernel := To_Vector ((0 => (65, 13, 2, False)));
            Table.States (104).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 53, 0)));
         end Subr_1;
         procedure Subr_2
         is begin
            Table.States (105).Action_List.Set_Capacity (2);
            Add_Action (Table.States (105), (13, 31), (58, 1), 1, null, identifier_opt_1_check'Access);
            Table.States (105).Kernel := To_Vector ((0 => (58, 37, 0, False)));
            Table.States (105).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 1)));
            Table.States (106).Action_List.Set_Capacity (2);
            Add_Action (Table.States (106), (13, 31), (59, 0), 1, null, null);
            Table.States (106).Kernel := To_Vector ((0 => (59, 58, 0, False)));
            Table.States (106).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 1)));
            Table.States (107).Action_List.Set_Capacity (2);
            Add_Action (Table.States (107), 13, 120);
            Add_Action (Table.States (107), 31, 121);
            Table.States (107).Kernel := To_Vector (((45, 59, 4, False), (59, 59, 2, True)));
            Table.States (107).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 13, 120)));
            Table.States (108).Action_List.Set_Capacity (1);
            Add_Action (Table.States (108), 14, 122);
            Table.States (108).Kernel := To_Vector ((0 => (42, 10, 5, False)));
            Table.States (108).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 14, 122)));
            Table.States (109).Action_List.Set_Capacity (2);
            Add_Action (Table.States (109), 14, 123);
            Add_Action (Table.States (109), 24, 124);
            Table.States (109).Kernel := To_Vector (((42, 37, 2, False), (42, 37, 4, False), (42, 37, 6, False)));
            Table.States (109).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 124)));
            Table.States (110).Action_List.Set_Capacity (7);
            Add_Action (Table.States (110), (6, 8, 12, 16, 18, 23, 37), (67, 4), 2, simple_declarative_item_4'Access,
            null);
            Table.States (110).Kernel := To_Vector ((0 => (67, 34, 0, False)));
            Table.States (110).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 67, 2)));
            Table.States (111).Action_List.Set_Capacity (3);
            Add_Action (Table.States (111), (9, 13, 20), (58, 1), 1, null, identifier_opt_1_check'Access);
            Table.States (111).Kernel := To_Vector ((0 => (58, 37, 0, False)));
            Table.States (111).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 1)));
            Table.States (112).Action_List.Set_Capacity (3);
            Add_Action (Table.States (112), 9, 125);
            Add_Action (Table.States (112), 13, 126);
            Add_Action (Table.States (112), 20, 127);
            Table.States (112).Kernel := To_Vector (((61, 58, 3, False), (62, 58, 4, False), (63, 58, 2, False)));
            Table.States (112).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 20, 127)));
            Table.States (113).Action_List.Set_Capacity (1);
            Add_Action (Table.States (113), 13, 128);
            Table.States (113).Kernel := To_Vector ((0 => (72, 37, 4, False)));
            Table.States (113).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 13, 128)));
            Table.States (114).Action_List.Set_Capacity (1);
            Add_Action (Table.States (114), 37, 129);
            Table.States (114).Kernel := To_Vector ((0 => (67, 28, 3, False)));
            Table.States (114).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 129)));
            Table.States (115).Action_List.Set_Capacity (10);
            Add_Action (Table.States (115), 10, 130);
            Add_Action (Table.States (115), 11, 131);
            Add_Action (Table.States (115), 14, 132);
            Add_Action (Table.States (115), 19, 9);
            Add_Action (Table.States (115), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (115), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (115), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (115), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (115), 37, 133);
            Add_Action (Table.States (115), 38, 134);
            Table.States (115).Goto_List.Set_Capacity (9);
            Add_Goto (Table.States (115), 41, 135);
            Add_Goto (Table.States (115), 43, 136);
            Add_Goto (Table.States (115), 44, 137);
            Add_Goto (Table.States (115), 56, 138);
            Add_Goto (Table.States (115), 57, 139);
            Add_Goto (Table.States (115), 58, 140);
            Add_Goto (Table.States (115), 59, 141);
            Add_Goto (Table.States (115), 69, 142);
            Add_Goto (Table.States (115), 71, 143);
            Table.States (115).Kernel := To_Vector ((0 => (67, 29, 1, False)));
            Table.States (115).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 0)));
            Table.States (116).Action_List.Set_Capacity (7);
            Add_Action (Table.States (116), (6, 8, 12, 16, 18, 23, 37), (52, 1), 2, null, null);
            Table.States (116).Kernel := To_Vector ((0 => (52, 51, 0, True)));
            Table.States (116).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 52, 2)));
            Table.States (116).Minimal_Complete_Actions_Recursive := True;
            Table.States (117).Action_List.Set_Capacity (2);
            Add_Action (Table.States (117), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (117), 37, 144);
            Table.States (117).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (117), 58, 145);
            Table.States (117).Kernel := To_Vector ((0 => (68, 8, 1, False)));
            Table.States (117).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 0)));
            Table.States (118).Action_List.Set_Capacity (3);
            Add_Action (Table.States (118), (21, 27, 30), (44, 1), 6, null, null);
            Table.States (118).Kernel := To_Vector ((0 => (44, 21, 0, False)));
            Table.States (118).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 44, 6)));
            Table.States (119).Action_List.Set_Capacity (1);
            Add_Action (Table.States (119), 8, 146);
            Table.States (119).Kernel := To_Vector ((0 => (65, 53, 2, False)));
            Table.States (119).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 8, 146)));
            Table.States (120).Action_List.Set_Capacity (2);
            Add_Action (Table.States (120), 8, Reduce, (47, 0), 0, null, null);
            Add_Action (Table.States (120), 25, 147);
            Add_Conflict (Table.States (120), 25, (47, 0), 0, null, null);
            Table.States (120).Goto_List.Set_Capacity (2);
            Add_Goto (Table.States (120), 46, 148);
            Add_Goto (Table.States (120), 47, 149);
            Table.States (120).Kernel := To_Vector ((0 => (45, 13, 3, False)));
            Table.States (120).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 47, 0)));
            Table.States (121).Action_List.Set_Capacity (1);
            Add_Action (Table.States (121), 37, 150);
            Table.States (121).Kernel := To_Vector ((0 => (59, 31, 1, True)));
            Table.States (121).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 150)));
            Table.States (121).Minimal_Complete_Actions_Recursive := True;
            Table.States (122).Action_List.Set_Capacity (1);
            Add_Action (Table.States (122), 38, 151);
            Table.States (122).Kernel := To_Vector ((0 => (42, 14, 4, False)));
            Table.States (122).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 38, 151)));
            Table.States (123).Action_List.Set_Capacity (3);
            Add_Action (Table.States (123), 17, 152);
            Add_Action (Table.States (123), 21, Reduce, (54, 0), 0, null, null);
            Add_Action (Table.States (123), 38, 153);
            Table.States (123).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (123), 54, 154);
            Table.States (123).Kernel := To_Vector (((42, 14, 3, False), (42, 14, 5, False)));
            Table.States (123).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 54, 0)));
            Table.States (124).Action_List.Set_Capacity (10);
            Add_Action (Table.States (124), 10, 130);
            Add_Action (Table.States (124), 11, 131);
            Add_Action (Table.States (124), 14, 132);
            Add_Action (Table.States (124), 19, 9);
            Add_Action (Table.States (124), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (124), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (124), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (124), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (124), 37, 133);
            Add_Action (Table.States (124), 38, 134);
            Table.States (124).Goto_List.Set_Capacity (9);
            Add_Goto (Table.States (124), 41, 135);
            Add_Goto (Table.States (124), 43, 136);
            Add_Goto (Table.States (124), 44, 137);
            Add_Goto (Table.States (124), 56, 155);
            Add_Goto (Table.States (124), 57, 139);
            Add_Goto (Table.States (124), 58, 140);
            Add_Goto (Table.States (124), 59, 141);
            Add_Goto (Table.States (124), 69, 142);
            Add_Goto (Table.States (124), 71, 143);
            Table.States (124).Kernel := To_Vector ((0 => (42, 24, 1, False)));
            Table.States (124).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 0)));
            Table.States (125).Action_List.Set_Capacity (3);
            Add_Action (Table.States (125), 13, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (125), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (125), 37, 105);
            Table.States (125).Goto_List.Set_Capacity (2);
            Add_Goto (Table.States (125), 58, 106);
            Add_Goto (Table.States (125), 59, 156);
            Table.States (125).Kernel := To_Vector ((0 => (62, 9, 3, False)));
            Table.States (125).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 0)));
            Table.States (126).Action_List.Set_Capacity (7);
            Add_Action (Table.States (126), 6, 85);
            Add_Action (Table.States (126), 8, Reduce, (53, 0), 0, null, null);
            Add_Action (Table.States (126), 12, 86);
            Add_Action (Table.States (126), 16, 87);
            Add_Action (Table.States (126), 18, 88);
            Add_Action (Table.States (126), 23, 89);
            Add_Action (Table.States (126), 37, 90);
            Table.States (126).Goto_List.Set_Capacity (11);
            Add_Goto (Table.States (126), 42, 91);
            Add_Goto (Table.States (126), 45, 92);
            Add_Goto (Table.States (126), 51, 93);
            Add_Goto (Table.States (126), 52, 94);
            Add_Goto (Table.States (126), 53, 157);
            Add_Goto (Table.States (126), 60, 96);
            Add_Goto (Table.States (126), 61, 97);
            Add_Goto (Table.States (126), 62, 98);
            Add_Goto (Table.States (126), 63, 99);
            Add_Goto (Table.States (126), 67, 100);
            Add_Goto (Table.States (126), 72, 101);
            Table.States (126).Kernel := To_Vector ((0 => (61, 13, 2, False)));
            Table.States (126).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 53, 0)));
            Table.States (127).Action_List.Set_Capacity (3);
            Add_Action (Table.States (127), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (127), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (127), 37, 158);
            Table.States (127).Goto_List.Set_Capacity (2);
            Add_Goto (Table.States (127), 58, 159);
            Add_Goto (Table.States (127), 59, 160);
            Table.States (127).Kernel := To_Vector ((0 => (63, 20, 1, False)));
            Table.States (127).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 0)));
            Table.States (128).Action_List.Set_Capacity (1);
            Add_Action (Table.States (128), 14, 161);
            Table.States (128).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (128), 41, 162);
            Table.States (128).Kernel := To_Vector ((0 => (72, 13, 3, False)));
            Table.States (128).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 14, 161)));
            Table.States (129).Action_List.Set_Capacity (1);
            Add_Action (Table.States (129), 29, 163);
            Table.States (129).Kernel := To_Vector ((0 => (67, 37, 2, False)));
            Table.States (129).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 29, 163)));
            Table.States (130).Action_List.Set_Capacity (1);
            Add_Action (Table.States (130), 14, 164);
            Table.States (130).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (130), 41, 165);
            Table.States (130).Kernel := To_Vector ((0 => (57, 10, 2, False)));
            Table.States (130).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 14, 164)));
            Table.States (131).Action_List.Set_Capacity (1);
            Add_Action (Table.States (131), 14, 164);
            Table.States (131).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (131), 41, 166);
            Table.States (131).Kernel := To_Vector ((0 => (57, 11, 2, False)));
            Table.States (131).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 14, 164)));
            Table.States (132).Action_List.Set_Capacity (11);
            Add_Action (Table.States (132), 10, 32);
            Add_Action (Table.States (132), 11, 33);
            Add_Action (Table.States (132), 14, 34);
            Add_Action (Table.States (132), 19, 9);
            Add_Action (Table.States (132), 21, 167);
            Add_Conflict (Table.States (132), 21, (58, 0), 0, null, null);
            Add_Action (Table.States (132), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (132), 30, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (132), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (132), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (132), 37, 36);
            Add_Action (Table.States (132), 38, 37);
            Table.States (132).Goto_List.Set_Capacity (10);
            Add_Goto (Table.States (132), 41, 38);
            Add_Goto (Table.States (132), 43, 39);
            Add_Goto (Table.States (132), 44, 40);
            Add_Goto (Table.States (132), 56, 41);
            Add_Goto (Table.States (132), 57, 42);
            Add_Goto (Table.States (132), 58, 43);
            Add_Goto (Table.States (132), 59, 44);
            Add_Goto (Table.States (132), 69, 45);
            Add_Goto (Table.States (132), 70, 168);
            Add_Goto (Table.States (132), 71, 47);
            Table.States (132).Kernel := To_Vector (((41, 14, 1, False), (71, 14, 1, False)));
            Table.States (132).Minimal_Complete_Actions := To_Vector (((Reduce, 70, 0), (Shift, 21, 167)));
            Table.States (133).Action_List.Set_Capacity (4);
            Add_Action (Table.States (133), (27, 31, 33, 34), (58, 1), 1, null, identifier_opt_1_check'Access);
            Table.States (133).Kernel := To_Vector ((0 => (58, 37, 0, False)));
            Table.States (133).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 1)));
            Table.States (134).Action_List.Set_Capacity (2);
            Add_Action (Table.States (134), (27, 34), (69, 0), 1, null, null);
            Table.States (134).Kernel := To_Vector ((0 => (69, 38, 0, False)));
            Table.States (134).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 69, 1)));
            Table.States (135).Action_List.Set_Capacity (2);
            Add_Action (Table.States (135), (27, 34), (71, 2), 1, null, null);
            Table.States (135).Kernel := To_Vector ((0 => (71, 41, 0, False)));
            Table.States (135).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 71, 1)));
            Table.States (136).Action_List.Set_Capacity (1);
            Add_Action (Table.States (136), 33, 169);
            Table.States (136).Kernel := To_Vector (((44, 43, 2, False), (44, 43, 5, False)));
            Table.States (136).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 33, 169)));
            Table.States (137).Action_List.Set_Capacity (2);
            Add_Action (Table.States (137), (27, 34), (69, 3), 1, null, null);
            Table.States (137).Kernel := To_Vector ((0 => (69, 44, 0, False)));
            Table.States (137).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 69, 1)));
            Table.States (138).Action_List.Set_Capacity (2);
            Add_Action (Table.States (138), 27, 170);
            Add_Action (Table.States (138), 34, 171);
            Table.States (138).Kernel := To_Vector (((56, 56, 1, True), (67, 56, 1, False)));
            Table.States (138).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 171)));
            Table.States (139).Action_List.Set_Capacity (2);
            Add_Action (Table.States (139), (27, 34), (69, 2), 1, null, null);
            Table.States (139).Kernel := To_Vector ((0 => (69, 57, 0, False)));
            Table.States (139).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 69, 1)));
            Table.States (140).Action_List.Set_Capacity (4);
            Add_Action (Table.States (140), (27, 31, 33, 34), (59, 0), 1, null, null);
            Table.States (140).Kernel := To_Vector ((0 => (59, 58, 0, False)));
            Table.States (140).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 1)));
            Table.States (141).Action_List.Set_Capacity (4);
            Add_Action (Table.States (141), 27, Reduce, (69, 1), 1, null, null);
            Add_Action (Table.States (141), 31, 172);
            Add_Action (Table.States (141), 33, Reduce, (43, 1), 1, null, null);
            Add_Action (Table.States (141), 34, Reduce, (69, 1), 1, null, null);
            Table.States (141).Kernel := To_Vector (((43, 59, 0, False), (59, 59, 2, True), (69, 59, 0, False)));
            Table.States (141).Minimal_Complete_Actions := To_Vector (((Reduce, 43, 1), (Reduce, 69, 1)));
            Table.States (142).Action_List.Set_Capacity (2);
            Add_Action (Table.States (142), (27, 34), (71, 0), 1, null, null);
            Table.States (142).Kernel := To_Vector ((0 => (71, 69, 0, False)));
            Table.States (142).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 71, 1)));
            Table.States (143).Action_List.Set_Capacity (2);
            Add_Action (Table.States (143), (27, 34), (56, 0), 1, null, null);
            Table.States (143).Kernel := To_Vector ((0 => (56, 71, 0, False)));
            Table.States (143).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 1)));
            Table.States (144).Action_List.Set_Capacity (1);
            Add_Action (Table.States (144), (1 =>  34), (58, 1), 1, null, identifier_opt_1_check'Access);
            Table.States (144).Kernel := To_Vector ((0 => (58, 37, 0, False)));
            Table.States (144).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 1)));
            Table.States (145).Action_List.Set_Capacity (1);
            Add_Action (Table.States (145), 34, 173);
            Table.States (145).Kernel := To_Vector ((0 => (68, 58, 1, False)));
            Table.States (145).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 173)));
            Table.States (146).Action_List.Set_Capacity (2);
            Add_Action (Table.States (146), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (146), 37, 144);
            Table.States (146).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (146), 58, 174);
            Table.States (146).Kernel := To_Vector ((0 => (65, 8, 1, False)));
            Table.States (146).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 0)));
            Table.States (147).Action_List.Set_Capacity (4);
            Add_Action (Table.States (147), 17, 175);
            Add_Action (Table.States (147), 32, Reduce, (54, 0), 0, null, null);
            Add_Action (Table.States (147), 35, Reduce, (54, 0), 0, null, null);
            Add_Action (Table.States (147), 38, 176);
            Table.States (147).Goto_List.Set_Capacity (2);
            Add_Goto (Table.States (147), 54, 177);
            Add_Goto (Table.States (147), 55, 178);
            Table.States (147).Kernel := To_Vector ((0 => (46, 25, 1, False)));
            Table.States (147).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 55, 0)));
            Table.States (148).Action_List.Set_Capacity (2);
            Add_Action (Table.States (148), (8, 25), (47, 1), 1, null, null);
            Table.States (148).Kernel := To_Vector ((0 => (47, 46, 0, False)));
            Table.States (148).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 47, 1)));
            Table.States (149).Action_List.Set_Capacity (2);
            Add_Action (Table.States (149), 8, 179);
            Add_Action (Table.States (149), 25, 147);
            Table.States (149).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (149), 46, 180);
            Table.States (149).Kernel := To_Vector (((45, 47, 3, False), (47, 47, 2, True)));
            Table.States (149).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 8, 179)));
            Table.States (150).Action_List.Set_Capacity (2);
            Add_Action (Table.States (150), (13, 31), (59, 1), 3, null, null);
            Table.States (150).Kernel := To_Vector ((0 => (59, 37, 0, True)));
            Table.States (150).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 3)));
            Table.States (150).Minimal_Complete_Actions_Recursive := True;
            Table.States (151).Action_List.Set_Capacity (1);
            Add_Action (Table.States (151), 21, 181);
            Table.States (151).Kernel := To_Vector ((0 => (42, 38, 3, False)));
            Table.States (151).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 21, 181)));
            Table.States (152).Action_List.Set_Capacity (1);
            Add_Action (Table.States (152), (1 =>  21), (54, 2), 1, null, null);
            Table.States (152).Kernel := To_Vector ((0 => (54, 17, 0, False)));
            Table.States (152).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 54, 1)));
            Table.States (153).Action_List.Set_Capacity (1);
            Add_Action (Table.States (153), (1 =>  21), (54, 1), 1, null, null);
            Table.States (153).Kernel := To_Vector ((0 => (54, 38, 0, False)));
            Table.States (153).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 54, 1)));
            Table.States (154).Action_List.Set_Capacity (1);
            Add_Action (Table.States (154), 21, 182);
            Table.States (154).Kernel := To_Vector (((42, 54, 3, False), (42, 54, 5, False)));
            Table.States (154).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 21, 182)));
            Table.States (155).Action_List.Set_Capacity (2);
            Add_Action (Table.States (155), 27, 170);
            Add_Action (Table.States (155), 34, 183);
            Table.States (155).Kernel := To_Vector (((42, 56, 1, False), (56, 56, 1, True)));
            Table.States (155).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 183)));
            Table.States (156).Action_List.Set_Capacity (2);
            Add_Action (Table.States (156), 13, 184);
            Add_Action (Table.States (156), 31, 121);
            Table.States (156).Kernel := To_Vector (((59, 59, 2, True), (62, 59, 3, False)));
            Table.States (156).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 13, 184)));
            Table.States (157).Action_List.Set_Capacity (1);
            Add_Action (Table.States (157), 8, 185);
            Table.States (157).Kernel := To_Vector ((0 => (61, 53, 2, False)));
            Table.States (157).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 8, 185)));
            Table.States (158).Action_List.Set_Capacity (2);
            Add_Action (Table.States (158), (31, 34), (58, 1), 1, null, identifier_opt_1_check'Access);
            Table.States (158).Kernel := To_Vector ((0 => (58, 37, 0, False)));
            Table.States (158).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 1)));
            Table.States (159).Action_List.Set_Capacity (2);
            Add_Action (Table.States (159), (31, 34), (59, 0), 1, null, null);
            Table.States (159).Kernel := To_Vector ((0 => (59, 58, 0, False)));
            Table.States (159).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 1)));
            Table.States (160).Action_List.Set_Capacity (2);
            Add_Action (Table.States (160), 31, 186);
            Add_Action (Table.States (160), 34, 187);
            Table.States (160).Kernel := To_Vector (((59, 59, 2, True), (63, 59, 1, False)));
            Table.States (160).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 187)));
            Table.States (161).Action_List.Set_Capacity (11);
            Add_Action (Table.States (161), 10, 32);
            Add_Action (Table.States (161), 11, 33);
            Add_Action (Table.States (161), 14, 34);
            Add_Action (Table.States (161), 19, 9);
            Add_Action (Table.States (161), 21, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (161), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (161), 30, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (161), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (161), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (161), 37, 36);
            Add_Action (Table.States (161), 38, 37);
            Table.States (161).Goto_List.Set_Capacity (10);
            Add_Goto (Table.States (161), 41, 38);
            Add_Goto (Table.States (161), 43, 39);
            Add_Goto (Table.States (161), 44, 40);
            Add_Goto (Table.States (161), 56, 41);
            Add_Goto (Table.States (161), 57, 42);
            Add_Goto (Table.States (161), 58, 43);
            Add_Goto (Table.States (161), 59, 44);
            Add_Goto (Table.States (161), 69, 45);
            Add_Goto (Table.States (161), 70, 188);
            Add_Goto (Table.States (161), 71, 47);
            Table.States (161).Kernel := To_Vector ((0 => (41, 14, 1, False)));
            Table.States (161).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 70, 0)));
            Table.States (162).Action_List.Set_Capacity (1);
            Add_Action (Table.States (162), 34, 189);
            Table.States (162).Kernel := To_Vector ((0 => (72, 41, 1, False)));
            Table.States (162).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 189)));
            Table.States (163).Action_List.Set_Capacity (10);
            Add_Action (Table.States (163), 10, 130);
            Add_Action (Table.States (163), 11, 131);
            Add_Action (Table.States (163), 14, 132);
            Add_Action (Table.States (163), 19, 9);
            Add_Action (Table.States (163), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (163), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (163), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (163), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (163), 37, 133);
            Add_Action (Table.States (163), 38, 134);
            Table.States (163).Goto_List.Set_Capacity (9);
            Add_Goto (Table.States (163), 41, 135);
            Add_Goto (Table.States (163), 43, 136);
            Add_Goto (Table.States (163), 44, 137);
            Add_Goto (Table.States (163), 56, 190);
            Add_Goto (Table.States (163), 57, 139);
            Add_Goto (Table.States (163), 58, 140);
            Add_Goto (Table.States (163), 59, 141);
            Add_Goto (Table.States (163), 69, 142);
            Add_Goto (Table.States (163), 71, 143);
            Table.States (163).Kernel := To_Vector ((0 => (67, 29, 1, False)));
            Table.States (163).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 0)));
            Table.States (164).Action_List.Set_Capacity (11);
            Add_Action (Table.States (164), 10, 32);
            Add_Action (Table.States (164), 11, 33);
            Add_Action (Table.States (164), 14, 34);
            Add_Action (Table.States (164), 19, 9);
            Add_Action (Table.States (164), 21, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (164), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (164), 30, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (164), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (164), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (164), 37, 36);
            Add_Action (Table.States (164), 38, 37);
            Table.States (164).Goto_List.Set_Capacity (10);
            Add_Goto (Table.States (164), 41, 38);
            Add_Goto (Table.States (164), 43, 39);
            Add_Goto (Table.States (164), 44, 40);
            Add_Goto (Table.States (164), 56, 41);
            Add_Goto (Table.States (164), 57, 42);
            Add_Goto (Table.States (164), 58, 43);
            Add_Goto (Table.States (164), 59, 44);
            Add_Goto (Table.States (164), 69, 45);
            Add_Goto (Table.States (164), 70, 168);
            Add_Goto (Table.States (164), 71, 47);
            Table.States (164).Kernel := To_Vector ((0 => (41, 14, 1, False)));
            Table.States (164).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 70, 0)));
            Table.States (165).Action_List.Set_Capacity (2);
            Add_Action (Table.States (165), (27, 34), (57, 0), 2, null, null);
            Table.States (165).Kernel := To_Vector ((0 => (57, 41, 0, False)));
            Table.States (165).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 57, 2)));
            Table.States (166).Action_List.Set_Capacity (2);
            Add_Action (Table.States (166), (27, 34), (57, 1), 2, null, null);
            Table.States (166).Kernel := To_Vector ((0 => (57, 41, 0, False)));
            Table.States (166).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 57, 2)));
            Table.States (167).Action_List.Set_Capacity (2);
            Add_Action (Table.States (167), (27, 34), (71, 1), 2, null, null);
            Table.States (167).Kernel := To_Vector ((0 => (71, 21, 0, False)));
            Table.States (167).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 71, 2)));
            Table.States (168).Action_List.Set_Capacity (2);
            Add_Action (Table.States (168), 21, 191);
            Add_Action (Table.States (168), 30, 67);
            Table.States (168).Kernel := To_Vector (((41, 70, 1, False), (70, 70, 1, True)));
            Table.States (168).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 21, 191)));
            Table.States (169).Action_List.Set_Capacity (1);
            Add_Action (Table.States (169), 37, 192);
            Table.States (169).Kernel := To_Vector (((44, 33, 1, False), (44, 33, 4, False)));
            Table.States (169).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 192)));
            Table.States (170).Action_List.Set_Capacity (10);
            Add_Action (Table.States (170), 10, 130);
            Add_Action (Table.States (170), 11, 131);
            Add_Action (Table.States (170), 14, 132);
            Add_Action (Table.States (170), 19, 9);
            Add_Action (Table.States (170), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (170), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (170), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (170), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (170), 37, 133);
            Add_Action (Table.States (170), 38, 134);
            Table.States (170).Goto_List.Set_Capacity (8);
            Add_Goto (Table.States (170), 41, 135);
            Add_Goto (Table.States (170), 43, 136);
            Add_Goto (Table.States (170), 44, 137);
            Add_Goto (Table.States (170), 57, 139);
            Add_Goto (Table.States (170), 58, 140);
            Add_Goto (Table.States (170), 59, 141);
            Add_Goto (Table.States (170), 69, 142);
            Add_Goto (Table.States (170), 71, 193);
            Table.States (170).Kernel := To_Vector ((0 => (56, 27, 0, True)));
            Table.States (170).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 71, 0)));
            Table.States (170).Minimal_Complete_Actions_Recursive := True;
            Table.States (171).Action_List.Set_Capacity (7);
            Add_Action (Table.States (171), (6, 8, 12, 16, 18, 23, 37), (67, 0), 4, simple_declarative_item_0'Access,
            null);
            Table.States (171).Kernel := To_Vector ((0 => (67, 34, 0, False)));
            Table.States (171).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 67, 4)));
            Table.States (172).Action_List.Set_Capacity (1);
            Add_Action (Table.States (172), 37, 194);
            Table.States (172).Kernel := To_Vector ((0 => (59, 31, 1, True)));
            Table.States (172).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 194)));
            Table.States (172).Minimal_Complete_Actions_Recursive := True;
            Table.States (173).Action_List.Set_Capacity (1);
            Add_Action (Table.States (173), (1 =>  39), (68, 0), 7, simple_project_declaration_0'Access,
            simple_project_declaration_0_check'Access);
            Table.States (173).Kernel := To_Vector ((0 => (68, 34, 0, False)));
            Table.States (173).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 68, 7)));
            Table.States (174).Action_List.Set_Capacity (1);
            Add_Action (Table.States (174), 34, 195);
            Table.States (174).Kernel := To_Vector ((0 => (65, 58, 1, False)));
            Table.States (174).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 195)));
            Table.States (175).Action_List.Set_Capacity (2);
            Add_Action (Table.States (175), (32, 35), (54, 2), 1, null, null);
            Table.States (175).Kernel := To_Vector ((0 => (54, 17, 0, False)));
            Table.States (175).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 54, 1)));
            Table.States (176).Action_List.Set_Capacity (2);
            Add_Action (Table.States (176), (32, 35), (54, 1), 1, null, null);
            Table.States (176).Kernel := To_Vector ((0 => (54, 38, 0, False)));
            Table.States (176).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 54, 1)));
            Table.States (177).Action_List.Set_Capacity (2);
            Add_Action (Table.States (177), (32, 35), (55, 0), 1, null, null);
            Table.States (177).Kernel := To_Vector ((0 => (55, 54, 0, False)));
            Table.States (177).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 55, 1)));
            Table.States (178).Action_List.Set_Capacity (2);
            Add_Action (Table.States (178), 32, 196);
            Add_Action (Table.States (178), 35, 197);
            Table.States (178).Kernel := To_Vector (((46, 55, 1, False), (55, 55, 1, True)));
            Table.States (178).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 32, 196)));
            Table.States (179).Action_List.Set_Capacity (1);
            Add_Action (Table.States (179), 6, 198);
            Table.States (179).Kernel := To_Vector ((0 => (45, 8, 2, False)));
            Table.States (179).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 6, 198)));
            Table.States (180).Action_List.Set_Capacity (2);
            Add_Action (Table.States (180), (8, 25), (47, 2), 2, null, null);
            Table.States (180).Kernel := To_Vector ((0 => (47, 46, 0, True)));
            Table.States (180).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 47, 2)));
            Table.States (180).Minimal_Complete_Actions_Recursive := True;
            Table.States (181).Action_List.Set_Capacity (1);
            Add_Action (Table.States (181), 24, 199);
            Table.States (181).Kernel := To_Vector ((0 => (42, 21, 2, False)));
            Table.States (181).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 199)));
            Table.States (182).Action_List.Set_Capacity (1);
            Add_Action (Table.States (182), 24, 200);
            Table.States (182).Kernel := To_Vector (((42, 21, 2, False), (42, 21, 4, False)));
            Table.States (182).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 200)));
            Table.States (183).Action_List.Set_Capacity (7);
            Add_Action (Table.States (183), (6, 8, 12, 16, 18, 23, 37), (42, 0), 5, attribute_declaration_0'Access,
            null);
            Table.States (183).Kernel := To_Vector ((0 => (42, 34, 0, False)));
            Table.States (183).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 42, 5)));
            Table.States (184).Action_List.Set_Capacity (7);
            Add_Action (Table.States (184), 6, 85);
            Add_Action (Table.States (184), 8, Reduce, (53, 0), 0, null, null);
            Add_Action (Table.States (184), 12, 86);
            Add_Action (Table.States (184), 16, 87);
            Add_Action (Table.States (184), 18, 88);
            Add_Action (Table.States (184), 23, 89);
            Add_Action (Table.States (184), 37, 90);
            Table.States (184).Goto_List.Set_Capacity (11);
            Add_Goto (Table.States (184), 42, 91);
            Add_Goto (Table.States (184), 45, 92);
            Add_Goto (Table.States (184), 51, 93);
            Add_Goto (Table.States (184), 52, 94);
            Add_Goto (Table.States (184), 53, 201);
            Add_Goto (Table.States (184), 60, 96);
            Add_Goto (Table.States (184), 61, 97);
            Add_Goto (Table.States (184), 62, 98);
            Add_Goto (Table.States (184), 63, 99);
            Add_Goto (Table.States (184), 67, 100);
            Add_Goto (Table.States (184), 72, 101);
            Table.States (184).Kernel := To_Vector ((0 => (62, 13, 2, False)));
            Table.States (184).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 53, 0)));
            Table.States (185).Action_List.Set_Capacity (2);
            Add_Action (Table.States (185), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (185), 37, 144);
            Table.States (185).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (185), 58, 202);
            Table.States (185).Kernel := To_Vector ((0 => (61, 8, 1, False)));
            Table.States (185).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 0)));
            Table.States (186).Action_List.Set_Capacity (1);
            Add_Action (Table.States (186), 37, 203);
            Table.States (186).Kernel := To_Vector ((0 => (59, 31, 1, True)));
            Table.States (186).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 203)));
            Table.States (186).Minimal_Complete_Actions_Recursive := True;
            Table.States (187).Action_List.Set_Capacity (7);
            Add_Action (Table.States (187), (6, 8, 12, 16, 18, 23, 37), (63, 0), 5, package_renaming_0'Access, null);
            Table.States (187).Kernel := To_Vector ((0 => (63, 34, 0, False)));
            Table.States (187).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 63, 5)));
            Table.States (188).Action_List.Set_Capacity (2);
            Add_Action (Table.States (188), 21, 204);
            Add_Action (Table.States (188), 30, 67);
            Table.States (188).Kernel := To_Vector (((41, 70, 1, False), (70, 70, 1, True)));
            Table.States (188).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 21, 204)));
            Table.States (189).Action_List.Set_Capacity (7);
            Add_Action (Table.States (189), (6, 8, 12, 16, 18, 23, 37), (72, 0), 5, typed_string_declaration_0'Access,
            null);
            Table.States (189).Kernel := To_Vector ((0 => (72, 34, 0, False)));
            Table.States (189).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 72, 5)));
            Table.States (190).Action_List.Set_Capacity (2);
            Add_Action (Table.States (190), 27, 170);
            Add_Action (Table.States (190), 34, 205);
            Table.States (190).Kernel := To_Vector (((56, 56, 1, True), (67, 56, 1, False)));
            Table.States (190).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 205)));
            Table.States (191).Action_List.Set_Capacity (2);
            Add_Action (Table.States (191), (27, 34), (41, 0), 3, aggregate_g_0'Access, null);
            Table.States (191).Kernel := To_Vector ((0 => (41, 21, 0, False)));
            Table.States (191).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 41, 3)));
            Table.States (192).Action_List.Set_Capacity (3);
            Add_Action (Table.States (192), 14, 206);
            Add_Action (Table.States (192), 27, Reduce, (44, 0), 3, null, null);
            Add_Action (Table.States (192), 34, Reduce, (44, 0), 3, null, null);
            Table.States (192).Kernel := To_Vector (((44, 37, 0, False), (44, 37, 3, False)));
            Table.States (192).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 44, 3)));
            Table.States (193).Action_List.Set_Capacity (2);
            Add_Action (Table.States (193), (27, 34), (56, 1), 3, null, null);
            Table.States (193).Kernel := To_Vector ((0 => (56, 71, 0, True)));
            Table.States (193).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 3)));
            Table.States (193).Minimal_Complete_Actions_Recursive := True;
            Table.States (194).Action_List.Set_Capacity (4);
            Add_Action (Table.States (194), (27, 31, 33, 34), (59, 1), 3, null, null);
            Table.States (194).Kernel := To_Vector ((0 => (59, 37, 0, True)));
            Table.States (194).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 3)));
            Table.States (194).Minimal_Complete_Actions_Recursive := True;
            Table.States (195).Action_List.Set_Capacity (1);
            Add_Action (Table.States (195), (1 =>  39), (65, 0), 9, project_extension_0'Access,
            project_extension_0_check'Access);
            Table.States (195).Kernel := To_Vector ((0 => (65, 34, 0, False)));
            Table.States (195).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 65, 9)));
            Table.States (196).Action_List.Set_Capacity (8);
            Add_Action (Table.States (196), 6, 207);
            Add_Action (Table.States (196), 8, Reduce, (53, 0), 0, null, null);
            Add_Action (Table.States (196), 12, 208);
            Add_Action (Table.States (196), 16, 209);
            Add_Action (Table.States (196), 18, 210);
            Add_Action (Table.States (196), 23, 211);
            Add_Action (Table.States (196), 25, Reduce, (53, 0), 0, null, null);
            Add_Action (Table.States (196), 37, 212);
            Table.States (196).Goto_List.Set_Capacity (11);
            Add_Goto (Table.States (196), 42, 213);
            Add_Goto (Table.States (196), 45, 214);
            Add_Goto (Table.States (196), 51, 215);
            Add_Goto (Table.States (196), 52, 216);
            Add_Goto (Table.States (196), 53, 217);
            Add_Goto (Table.States (196), 60, 218);
            Add_Goto (Table.States (196), 61, 219);
            Add_Goto (Table.States (196), 62, 220);
            Add_Goto (Table.States (196), 63, 221);
            Add_Goto (Table.States (196), 67, 222);
            Add_Goto (Table.States (196), 72, 223);
            Table.States (196).Kernel := To_Vector ((0 => (46, 32, 0, False)));
            Table.States (196).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 53, 0)));
            Table.States (197).Action_List.Set_Capacity (4);
            Add_Action (Table.States (197), 17, 175);
            Add_Action (Table.States (197), 32, Reduce, (54, 0), 0, null, null);
            Add_Action (Table.States (197), 35, Reduce, (54, 0), 0, null, null);
            Add_Action (Table.States (197), 38, 176);
            Table.States (197).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (197), 54, 224);
            Table.States (197).Kernel := To_Vector ((0 => (55, 35, 0, True)));
            Table.States (197).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 54, 0)));
            Table.States (197).Minimal_Complete_Actions_Recursive := True;
            Table.States (198).Action_List.Set_Capacity (1);
            Add_Action (Table.States (198), 34, 225);
            Table.States (198).Kernel := To_Vector ((0 => (45, 6, 1, False)));
            Table.States (198).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 225)));
            Table.States (199).Action_List.Set_Capacity (10);
            Add_Action (Table.States (199), 10, 130);
            Add_Action (Table.States (199), 11, 131);
            Add_Action (Table.States (199), 14, 132);
            Add_Action (Table.States (199), 19, 9);
            Add_Action (Table.States (199), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (199), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (199), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (199), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (199), 37, 133);
            Add_Action (Table.States (199), 38, 134);
            Table.States (199).Goto_List.Set_Capacity (9);
            Add_Goto (Table.States (199), 41, 135);
            Add_Goto (Table.States (199), 43, 136);
            Add_Goto (Table.States (199), 44, 137);
            Add_Goto (Table.States (199), 56, 226);
            Add_Goto (Table.States (199), 57, 139);
            Add_Goto (Table.States (199), 58, 140);
            Add_Goto (Table.States (199), 59, 141);
            Add_Goto (Table.States (199), 69, 142);
            Add_Goto (Table.States (199), 71, 143);
            Table.States (199).Kernel := To_Vector ((0 => (42, 24, 1, False)));
            Table.States (199).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 0)));
            Table.States (200).Action_List.Set_Capacity (11);
            Add_Action (Table.States (200), 4, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (200), 10, 227);
            Add_Action (Table.States (200), 11, 228);
            Add_Action (Table.States (200), 14, 229);
            Add_Action (Table.States (200), 19, 9);
            Add_Action (Table.States (200), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (200), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (200), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (200), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (200), 37, 230);
            Add_Action (Table.States (200), 38, 231);
            Table.States (200).Goto_List.Set_Capacity (9);
            Add_Goto (Table.States (200), 41, 232);
            Add_Goto (Table.States (200), 43, 233);
            Add_Goto (Table.States (200), 44, 234);
            Add_Goto (Table.States (200), 56, 235);
            Add_Goto (Table.States (200), 57, 236);
            Add_Goto (Table.States (200), 58, 237);
            Add_Goto (Table.States (200), 59, 238);
            Add_Goto (Table.States (200), 69, 239);
            Add_Goto (Table.States (200), 71, 240);
            Table.States (200).Kernel := To_Vector (((42, 24, 1, False), (42, 24, 3, False)));
            Table.States (200).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 0)));
            Table.States (201).Action_List.Set_Capacity (1);
            Add_Action (Table.States (201), 8, 241);
            Table.States (201).Kernel := To_Vector ((0 => (62, 53, 2, False)));
            Table.States (201).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 8, 241)));
            Table.States (202).Action_List.Set_Capacity (1);
            Add_Action (Table.States (202), 34, 242);
            Table.States (202).Kernel := To_Vector ((0 => (61, 58, 1, False)));
            Table.States (202).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 242)));
            Table.States (203).Action_List.Set_Capacity (2);
            Add_Action (Table.States (203), (31, 34), (59, 1), 3, null, null);
            Table.States (203).Kernel := To_Vector ((0 => (59, 37, 0, True)));
            Table.States (203).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 3)));
            Table.States (203).Minimal_Complete_Actions_Recursive := True;
            Table.States (204).Action_List.Set_Capacity (1);
            Add_Action (Table.States (204), (1 =>  34), (41, 0), 3, aggregate_g_0'Access, null);
            Table.States (204).Kernel := To_Vector ((0 => (41, 21, 0, False)));
            Table.States (204).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 41, 3)));
            Table.States (205).Action_List.Set_Capacity (7);
            Add_Action (Table.States (205), (6, 8, 12, 16, 18, 23, 37), (67, 1), 6, simple_declarative_item_1'Access,
            null);
            Table.States (205).Kernel := To_Vector ((0 => (67, 34, 0, False)));
            Table.States (205).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 67, 6)));
            Table.States (206).Action_List.Set_Capacity (1);
            Add_Action (Table.States (206), 38, 243);
            Table.States (206).Kernel := To_Vector ((0 => (44, 14, 2, False)));
            Table.States (206).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 38, 243)));
            Table.States (207).Action_List.Set_Capacity (3);
            Add_Action (Table.States (207), 13, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (207), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (207), 37, 105);
            Table.States (207).Goto_List.Set_Capacity (2);
            Add_Goto (Table.States (207), 58, 106);
            Add_Goto (Table.States (207), 59, 244);
            Table.States (207).Kernel := To_Vector ((0 => (45, 6, 4, False)));
            Table.States (207).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 0)));
            Table.States (208).Action_List.Set_Capacity (2);
            Add_Action (Table.States (208), 10, 245);
            Add_Action (Table.States (208), 37, 246);
            Table.States (208).Kernel := To_Vector (((42, 12, 3, False), (42, 12, 5, False), (42, 12, 7, False), (42,
            12, 6, False)));
            Table.States (208).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 246)));
            Table.States (209).Action_List.Set_Capacity (1);
            Add_Action (Table.States (209), 34, 247);
            Table.States (209).Kernel := To_Vector ((0 => (67, 16, 1, False)));
            Table.States (209).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 247)));
            Table.States (210).Action_List.Set_Capacity (4);
            Add_Action (Table.States (210), 9, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (210), 13, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (210), 20, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (210), 37, 111);
            Table.States (210).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (210), 58, 248);
            Table.States (210).Kernel := To_Vector (((61, 18, 3, False), (62, 18, 4, False), (63, 18, 2, False)));
            Table.States (210).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 0)));
         end Subr_2;
         procedure Subr_3
         is begin
            Table.States (211).Action_List.Set_Capacity (1);
            Add_Action (Table.States (211), 37, 249);
            Table.States (211).Kernel := To_Vector ((0 => (72, 23, 5, False)));
            Table.States (211).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 249)));
            Table.States (212).Action_List.Set_Capacity (2);
            Add_Action (Table.States (212), 28, 250);
            Add_Action (Table.States (212), 29, 251);
            Table.States (212).Kernel := To_Vector (((67, 37, 2, False), (67, 37, 4, False)));
            Table.States (212).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 29, 251)));
            Table.States (213).Action_List.Set_Capacity (8);
            Add_Action (Table.States (213), (6, 8, 12, 16, 18, 23, 25, 37), (67, 2), 1, null, null);
            Table.States (213).Kernel := To_Vector ((0 => (67, 42, 0, False)));
            Table.States (213).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 67, 1)));
            Table.States (214).Action_List.Set_Capacity (8);
            Add_Action (Table.States (214), (6, 8, 12, 16, 18, 23, 25, 37), (67, 3), 1, null, null);
            Table.States (214).Kernel := To_Vector ((0 => (67, 45, 0, False)));
            Table.States (214).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 67, 1)));
            Table.States (215).Action_List.Set_Capacity (8);
            Add_Action (Table.States (215), (6, 8, 12, 16, 18, 23, 25, 37), (52, 0), 1, null, null);
            Table.States (215).Kernel := To_Vector ((0 => (52, 51, 0, False)));
            Table.States (215).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 52, 1)));
            Table.States (216).Action_List.Set_Capacity (8);
            Add_Action (Table.States (216), 6, 207);
            Add_Action (Table.States (216), 8, Reduce, (53, 1), 1, null, null);
            Add_Action (Table.States (216), 12, 208);
            Add_Action (Table.States (216), 16, 209);
            Add_Action (Table.States (216), 18, 210);
            Add_Action (Table.States (216), 23, 211);
            Add_Action (Table.States (216), 25, Reduce, (53, 1), 1, null, null);
            Add_Action (Table.States (216), 37, 212);
            Table.States (216).Goto_List.Set_Capacity (9);
            Add_Goto (Table.States (216), 42, 213);
            Add_Goto (Table.States (216), 45, 214);
            Add_Goto (Table.States (216), 51, 252);
            Add_Goto (Table.States (216), 60, 218);
            Add_Goto (Table.States (216), 61, 219);
            Add_Goto (Table.States (216), 62, 220);
            Add_Goto (Table.States (216), 63, 221);
            Add_Goto (Table.States (216), 67, 222);
            Add_Goto (Table.States (216), 72, 223);
            Table.States (216).Kernel := To_Vector (((52, 52, 2, True), (53, 52, 0, False)));
            Table.States (216).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 53, 1)));
            Table.States (217).Action_List.Set_Capacity (2);
            Add_Action (Table.States (217), (8, 25), (46, 0), 4, case_item_0'Access, null);
            Table.States (217).Kernel := To_Vector ((0 => (46, 53, 0, False)));
            Table.States (217).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 46, 4)));
            Table.States (218).Action_List.Set_Capacity (8);
            Add_Action (Table.States (218), (6, 8, 12, 16, 18, 23, 25, 37), (51, 2), 1, null, null);
            Table.States (218).Kernel := To_Vector ((0 => (51, 60, 0, False)));
            Table.States (218).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 51, 1)));
            Table.States (219).Action_List.Set_Capacity (8);
            Add_Action (Table.States (219), (6, 8, 12, 16, 18, 23, 25, 37), (60, 0), 1, null, null);
            Table.States (219).Kernel := To_Vector ((0 => (60, 61, 0, False)));
            Table.States (219).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 60, 1)));
            Table.States (220).Action_List.Set_Capacity (8);
            Add_Action (Table.States (220), (6, 8, 12, 16, 18, 23, 25, 37), (60, 1), 1, null, null);
            Table.States (220).Kernel := To_Vector ((0 => (60, 62, 0, False)));
            Table.States (220).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 60, 1)));
            Table.States (221).Action_List.Set_Capacity (8);
            Add_Action (Table.States (221), (6, 8, 12, 16, 18, 23, 25, 37), (60, 2), 1, null, null);
            Table.States (221).Kernel := To_Vector ((0 => (60, 63, 0, False)));
            Table.States (221).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 60, 1)));
            Table.States (222).Action_List.Set_Capacity (8);
            Add_Action (Table.States (222), (6, 8, 12, 16, 18, 23, 25, 37), (51, 0), 1, null, null);
            Table.States (222).Kernel := To_Vector ((0 => (51, 67, 0, False)));
            Table.States (222).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 51, 1)));
            Table.States (223).Action_List.Set_Capacity (8);
            Add_Action (Table.States (223), (6, 8, 12, 16, 18, 23, 25, 37), (51, 1), 1, null, null);
            Table.States (223).Kernel := To_Vector ((0 => (51, 72, 0, False)));
            Table.States (223).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 51, 1)));
            Table.States (224).Action_List.Set_Capacity (2);
            Add_Action (Table.States (224), (32, 35), (55, 1), 3, null, null);
            Table.States (224).Kernel := To_Vector ((0 => (55, 54, 0, True)));
            Table.States (224).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 55, 3)));
            Table.States (224).Minimal_Complete_Actions_Recursive := True;
            Table.States (225).Action_List.Set_Capacity (7);
            Add_Action (Table.States (225), (6, 8, 12, 16, 18, 23, 37), (45, 0), 7, case_statement_0'Access, null);
            Table.States (225).Kernel := To_Vector ((0 => (45, 34, 0, False)));
            Table.States (225).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 45, 7)));
            Table.States (226).Action_List.Set_Capacity (2);
            Add_Action (Table.States (226), 27, 170);
            Add_Action (Table.States (226), 34, 253);
            Table.States (226).Kernel := To_Vector (((42, 56, 1, False), (56, 56, 1, True)));
            Table.States (226).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 253)));
            Table.States (227).Action_List.Set_Capacity (1);
            Add_Action (Table.States (227), 14, 254);
            Table.States (227).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (227), 41, 255);
            Table.States (227).Kernel := To_Vector ((0 => (57, 10, 2, False)));
            Table.States (227).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 14, 254)));
            Table.States (228).Action_List.Set_Capacity (1);
            Add_Action (Table.States (228), 14, 254);
            Table.States (228).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (228), 41, 256);
            Table.States (228).Kernel := To_Vector ((0 => (57, 11, 2, False)));
            Table.States (228).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 14, 254)));
            Table.States (229).Action_List.Set_Capacity (11);
            Add_Action (Table.States (229), 10, 32);
            Add_Action (Table.States (229), 11, 33);
            Add_Action (Table.States (229), 14, 34);
            Add_Action (Table.States (229), 19, 9);
            Add_Action (Table.States (229), 21, 257);
            Add_Conflict (Table.States (229), 21, (58, 0), 0, null, null);
            Add_Action (Table.States (229), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (229), 30, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (229), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (229), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (229), 37, 36);
            Add_Action (Table.States (229), 38, 37);
            Table.States (229).Goto_List.Set_Capacity (10);
            Add_Goto (Table.States (229), 41, 38);
            Add_Goto (Table.States (229), 43, 39);
            Add_Goto (Table.States (229), 44, 40);
            Add_Goto (Table.States (229), 56, 41);
            Add_Goto (Table.States (229), 57, 42);
            Add_Goto (Table.States (229), 58, 43);
            Add_Goto (Table.States (229), 59, 44);
            Add_Goto (Table.States (229), 69, 45);
            Add_Goto (Table.States (229), 70, 258);
            Add_Goto (Table.States (229), 71, 47);
            Table.States (229).Kernel := To_Vector (((41, 14, 1, False), (71, 14, 1, False)));
            Table.States (229).Minimal_Complete_Actions := To_Vector (((Reduce, 70, 0), (Shift, 21, 257)));
            Table.States (230).Action_List.Set_Capacity (5);
            Add_Action (Table.States (230), (4, 27, 31, 33, 34), (58, 1), 1, null, identifier_opt_1_check'Access);
            Table.States (230).Kernel := To_Vector ((0 => (58, 37, 0, False)));
            Table.States (230).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 1)));
            Table.States (231).Action_List.Set_Capacity (3);
            Add_Action (Table.States (231), (4, 27, 34), (69, 0), 1, null, null);
            Table.States (231).Kernel := To_Vector ((0 => (69, 38, 0, False)));
            Table.States (231).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 69, 1)));
            Table.States (232).Action_List.Set_Capacity (3);
            Add_Action (Table.States (232), (4, 27, 34), (71, 2), 1, null, null);
            Table.States (232).Kernel := To_Vector ((0 => (71, 41, 0, False)));
            Table.States (232).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 71, 1)));
            Table.States (233).Action_List.Set_Capacity (1);
            Add_Action (Table.States (233), 33, 259);
            Table.States (233).Kernel := To_Vector (((44, 43, 2, False), (44, 43, 5, False)));
            Table.States (233).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 33, 259)));
            Table.States (234).Action_List.Set_Capacity (3);
            Add_Action (Table.States (234), (4, 27, 34), (69, 3), 1, null, null);
            Table.States (234).Kernel := To_Vector ((0 => (69, 44, 0, False)));
            Table.States (234).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 69, 1)));
            Table.States (235).Action_List.Set_Capacity (3);
            Add_Action (Table.States (235), 4, 260);
            Add_Action (Table.States (235), 27, 261);
            Add_Action (Table.States (235), 34, 262);
            Table.States (235).Kernel := To_Vector (((42, 56, 1, False), (42, 56, 3, False), (56, 56, 1, True)));
            Table.States (235).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 262)));
            Table.States (236).Action_List.Set_Capacity (3);
            Add_Action (Table.States (236), (4, 27, 34), (69, 2), 1, null, null);
            Table.States (236).Kernel := To_Vector ((0 => (69, 57, 0, False)));
            Table.States (236).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 69, 1)));
            Table.States (237).Action_List.Set_Capacity (5);
            Add_Action (Table.States (237), (4, 27, 31, 33, 34), (59, 0), 1, null, null);
            Table.States (237).Kernel := To_Vector ((0 => (59, 58, 0, False)));
            Table.States (237).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 1)));
            Table.States (238).Action_List.Set_Capacity (5);
            Add_Action (Table.States (238), 4, Reduce, (69, 1), 1, null, null);
            Add_Action (Table.States (238), 27, Reduce, (69, 1), 1, null, null);
            Add_Action (Table.States (238), 31, 263);
            Add_Action (Table.States (238), 33, Reduce, (43, 1), 1, null, null);
            Add_Action (Table.States (238), 34, Reduce, (69, 1), 1, null, null);
            Table.States (238).Kernel := To_Vector (((43, 59, 0, False), (59, 59, 2, True), (69, 59, 0, False)));
            Table.States (238).Minimal_Complete_Actions := To_Vector (((Reduce, 43, 1), (Reduce, 69, 1)));
            Table.States (239).Action_List.Set_Capacity (3);
            Add_Action (Table.States (239), (4, 27, 34), (71, 0), 1, null, null);
            Table.States (239).Kernel := To_Vector ((0 => (71, 69, 0, False)));
            Table.States (239).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 71, 1)));
            Table.States (240).Action_List.Set_Capacity (3);
            Add_Action (Table.States (240), (4, 27, 34), (56, 0), 1, null, null);
            Table.States (240).Kernel := To_Vector ((0 => (56, 71, 0, False)));
            Table.States (240).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 1)));
            Table.States (241).Action_List.Set_Capacity (2);
            Add_Action (Table.States (241), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (241), 37, 144);
            Table.States (241).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (241), 58, 264);
            Table.States (241).Kernel := To_Vector ((0 => (62, 8, 1, False)));
            Table.States (241).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 0)));
            Table.States (242).Action_List.Set_Capacity (7);
            Add_Action (Table.States (242), (6, 8, 12, 16, 18, 23, 37), (61, 0), 7, package_spec_0'Access,
            package_spec_0_check'Access);
            Table.States (242).Kernel := To_Vector ((0 => (61, 34, 0, False)));
            Table.States (242).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 61, 7)));
            Table.States (243).Action_List.Set_Capacity (1);
            Add_Action (Table.States (243), 21, 265);
            Table.States (243).Kernel := To_Vector ((0 => (44, 38, 1, False)));
            Table.States (243).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 21, 265)));
            Table.States (244).Action_List.Set_Capacity (2);
            Add_Action (Table.States (244), 13, 266);
            Add_Action (Table.States (244), 31, 121);
            Table.States (244).Kernel := To_Vector (((45, 59, 4, False), (59, 59, 2, True)));
            Table.States (244).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 13, 266)));
            Table.States (245).Action_List.Set_Capacity (1);
            Add_Action (Table.States (245), 14, 267);
            Table.States (245).Kernel := To_Vector ((0 => (42, 10, 5, False)));
            Table.States (245).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 14, 267)));
            Table.States (246).Action_List.Set_Capacity (2);
            Add_Action (Table.States (246), 14, 268);
            Add_Action (Table.States (246), 24, 269);
            Table.States (246).Kernel := To_Vector (((42, 37, 2, False), (42, 37, 4, False), (42, 37, 6, False)));
            Table.States (246).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 269)));
            Table.States (247).Action_List.Set_Capacity (8);
            Add_Action (Table.States (247), (6, 8, 12, 16, 18, 23, 25, 37), (67, 4), 2,
            simple_declarative_item_4'Access, null);
            Table.States (247).Kernel := To_Vector ((0 => (67, 34, 0, False)));
            Table.States (247).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 67, 2)));
            Table.States (248).Action_List.Set_Capacity (3);
            Add_Action (Table.States (248), 9, 270);
            Add_Action (Table.States (248), 13, 271);
            Add_Action (Table.States (248), 20, 272);
            Table.States (248).Kernel := To_Vector (((61, 58, 3, False), (62, 58, 4, False), (63, 58, 2, False)));
            Table.States (248).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 20, 272)));
            Table.States (249).Action_List.Set_Capacity (1);
            Add_Action (Table.States (249), 13, 273);
            Table.States (249).Kernel := To_Vector ((0 => (72, 37, 4, False)));
            Table.States (249).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 13, 273)));
            Table.States (250).Action_List.Set_Capacity (1);
            Add_Action (Table.States (250), 37, 274);
            Table.States (250).Kernel := To_Vector ((0 => (67, 28, 3, False)));
            Table.States (250).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 274)));
            Table.States (251).Action_List.Set_Capacity (10);
            Add_Action (Table.States (251), 10, 130);
            Add_Action (Table.States (251), 11, 131);
            Add_Action (Table.States (251), 14, 132);
            Add_Action (Table.States (251), 19, 9);
            Add_Action (Table.States (251), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (251), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (251), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (251), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (251), 37, 133);
            Add_Action (Table.States (251), 38, 134);
            Table.States (251).Goto_List.Set_Capacity (9);
            Add_Goto (Table.States (251), 41, 135);
            Add_Goto (Table.States (251), 43, 136);
            Add_Goto (Table.States (251), 44, 137);
            Add_Goto (Table.States (251), 56, 275);
            Add_Goto (Table.States (251), 57, 139);
            Add_Goto (Table.States (251), 58, 140);
            Add_Goto (Table.States (251), 59, 141);
            Add_Goto (Table.States (251), 69, 142);
            Add_Goto (Table.States (251), 71, 143);
            Table.States (251).Kernel := To_Vector ((0 => (67, 29, 1, False)));
            Table.States (251).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 0)));
            Table.States (252).Action_List.Set_Capacity (8);
            Add_Action (Table.States (252), (6, 8, 12, 16, 18, 23, 25, 37), (52, 1), 2, null, null);
            Table.States (252).Kernel := To_Vector ((0 => (52, 51, 0, True)));
            Table.States (252).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 52, 2)));
            Table.States (252).Minimal_Complete_Actions_Recursive := True;
            Table.States (253).Action_List.Set_Capacity (7);
            Add_Action (Table.States (253), (6, 8, 12, 16, 18, 23, 37), (42, 3), 8, attribute_declaration_3'Access,
            null);
            Table.States (253).Kernel := To_Vector ((0 => (42, 34, 0, False)));
            Table.States (253).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 42, 8)));
            Table.States (254).Action_List.Set_Capacity (11);
            Add_Action (Table.States (254), 10, 32);
            Add_Action (Table.States (254), 11, 33);
            Add_Action (Table.States (254), 14, 34);
            Add_Action (Table.States (254), 19, 9);
            Add_Action (Table.States (254), 21, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (254), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (254), 30, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (254), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (254), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (254), 37, 36);
            Add_Action (Table.States (254), 38, 37);
            Table.States (254).Goto_List.Set_Capacity (10);
            Add_Goto (Table.States (254), 41, 38);
            Add_Goto (Table.States (254), 43, 39);
            Add_Goto (Table.States (254), 44, 40);
            Add_Goto (Table.States (254), 56, 41);
            Add_Goto (Table.States (254), 57, 42);
            Add_Goto (Table.States (254), 58, 43);
            Add_Goto (Table.States (254), 59, 44);
            Add_Goto (Table.States (254), 69, 45);
            Add_Goto (Table.States (254), 70, 258);
            Add_Goto (Table.States (254), 71, 47);
            Table.States (254).Kernel := To_Vector ((0 => (41, 14, 1, False)));
            Table.States (254).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 70, 0)));
            Table.States (255).Action_List.Set_Capacity (3);
            Add_Action (Table.States (255), (4, 27, 34), (57, 0), 2, null, null);
            Table.States (255).Kernel := To_Vector ((0 => (57, 41, 0, False)));
            Table.States (255).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 57, 2)));
            Table.States (256).Action_List.Set_Capacity (3);
            Add_Action (Table.States (256), (4, 27, 34), (57, 1), 2, null, null);
            Table.States (256).Kernel := To_Vector ((0 => (57, 41, 0, False)));
            Table.States (256).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 57, 2)));
            Table.States (257).Action_List.Set_Capacity (3);
            Add_Action (Table.States (257), (4, 27, 34), (71, 1), 2, null, null);
            Table.States (257).Kernel := To_Vector ((0 => (71, 21, 0, False)));
            Table.States (257).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 71, 2)));
            Table.States (258).Action_List.Set_Capacity (2);
            Add_Action (Table.States (258), 21, 276);
            Add_Action (Table.States (258), 30, 67);
            Table.States (258).Kernel := To_Vector (((41, 70, 1, False), (70, 70, 1, True)));
            Table.States (258).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 21, 276)));
            Table.States (259).Action_List.Set_Capacity (1);
            Add_Action (Table.States (259), 37, 277);
            Table.States (259).Kernel := To_Vector (((44, 33, 1, False), (44, 33, 4, False)));
            Table.States (259).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 277)));
            Table.States (260).Action_List.Set_Capacity (1);
            Add_Action (Table.States (260), 36, 278);
            Table.States (260).Kernel := To_Vector ((0 => (42, 4, 2, False)));
            Table.States (260).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 36, 278)));
            Table.States (261).Action_List.Set_Capacity (11);
            Add_Action (Table.States (261), 4, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (261), 10, 227);
            Add_Action (Table.States (261), 11, 228);
            Add_Action (Table.States (261), 14, 229);
            Add_Action (Table.States (261), 19, 9);
            Add_Action (Table.States (261), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (261), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (261), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (261), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (261), 37, 230);
            Add_Action (Table.States (261), 38, 231);
            Table.States (261).Goto_List.Set_Capacity (8);
            Add_Goto (Table.States (261), 41, 232);
            Add_Goto (Table.States (261), 43, 233);
            Add_Goto (Table.States (261), 44, 234);
            Add_Goto (Table.States (261), 57, 236);
            Add_Goto (Table.States (261), 58, 237);
            Add_Goto (Table.States (261), 59, 238);
            Add_Goto (Table.States (261), 69, 239);
            Add_Goto (Table.States (261), 71, 279);
            Table.States (261).Kernel := To_Vector ((0 => (56, 27, 0, True)));
            Table.States (261).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 71, 0)));
            Table.States (261).Minimal_Complete_Actions_Recursive := True;
            Table.States (262).Action_List.Set_Capacity (7);
            Add_Action (Table.States (262), (6, 8, 12, 16, 18, 23, 37), (42, 1), 8, attribute_declaration_1'Access,
            null);
            Table.States (262).Kernel := To_Vector ((0 => (42, 34, 0, False)));
            Table.States (262).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 42, 8)));
            Table.States (263).Action_List.Set_Capacity (1);
            Add_Action (Table.States (263), 37, 280);
            Table.States (263).Kernel := To_Vector ((0 => (59, 31, 1, True)));
            Table.States (263).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 37, 280)));
            Table.States (263).Minimal_Complete_Actions_Recursive := True;
            Table.States (264).Action_List.Set_Capacity (1);
            Add_Action (Table.States (264), 34, 281);
            Table.States (264).Kernel := To_Vector ((0 => (62, 58, 1, False)));
            Table.States (264).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 281)));
            Table.States (265).Action_List.Set_Capacity (2);
            Add_Action (Table.States (265), (27, 34), (44, 1), 6, null, null);
            Table.States (265).Kernel := To_Vector ((0 => (44, 21, 0, False)));
            Table.States (265).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 44, 6)));
            Table.States (266).Action_List.Set_Capacity (2);
            Add_Action (Table.States (266), 8, Reduce, (47, 0), 0, null, null);
            Add_Action (Table.States (266), 25, 147);
            Add_Conflict (Table.States (266), 25, (47, 0), 0, null, null);
            Table.States (266).Goto_List.Set_Capacity (2);
            Add_Goto (Table.States (266), 46, 148);
            Add_Goto (Table.States (266), 47, 282);
            Table.States (266).Kernel := To_Vector ((0 => (45, 13, 3, False)));
            Table.States (266).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 47, 0)));
            Table.States (267).Action_List.Set_Capacity (1);
            Add_Action (Table.States (267), 38, 283);
            Table.States (267).Kernel := To_Vector ((0 => (42, 14, 4, False)));
            Table.States (267).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 38, 283)));
            Table.States (268).Action_List.Set_Capacity (3);
            Add_Action (Table.States (268), 17, 152);
            Add_Action (Table.States (268), 21, Reduce, (54, 0), 0, null, null);
            Add_Action (Table.States (268), 38, 153);
            Table.States (268).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (268), 54, 284);
            Table.States (268).Kernel := To_Vector (((42, 14, 3, False), (42, 14, 5, False)));
            Table.States (268).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 54, 0)));
            Table.States (269).Action_List.Set_Capacity (10);
            Add_Action (Table.States (269), 10, 130);
            Add_Action (Table.States (269), 11, 131);
            Add_Action (Table.States (269), 14, 132);
            Add_Action (Table.States (269), 19, 9);
            Add_Action (Table.States (269), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (269), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (269), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (269), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (269), 37, 133);
            Add_Action (Table.States (269), 38, 134);
            Table.States (269).Goto_List.Set_Capacity (9);
            Add_Goto (Table.States (269), 41, 135);
            Add_Goto (Table.States (269), 43, 136);
            Add_Goto (Table.States (269), 44, 137);
            Add_Goto (Table.States (269), 56, 285);
            Add_Goto (Table.States (269), 57, 139);
            Add_Goto (Table.States (269), 58, 140);
            Add_Goto (Table.States (269), 59, 141);
            Add_Goto (Table.States (269), 69, 142);
            Add_Goto (Table.States (269), 71, 143);
            Table.States (269).Kernel := To_Vector ((0 => (42, 24, 1, False)));
            Table.States (269).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 0)));
            Table.States (270).Action_List.Set_Capacity (3);
            Add_Action (Table.States (270), 13, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (270), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (270), 37, 105);
            Table.States (270).Goto_List.Set_Capacity (2);
            Add_Goto (Table.States (270), 58, 106);
            Add_Goto (Table.States (270), 59, 286);
            Table.States (270).Kernel := To_Vector ((0 => (62, 9, 3, False)));
            Table.States (270).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 0)));
            Table.States (271).Action_List.Set_Capacity (7);
            Add_Action (Table.States (271), 6, 85);
            Add_Action (Table.States (271), 8, Reduce, (53, 0), 0, null, null);
            Add_Action (Table.States (271), 12, 86);
            Add_Action (Table.States (271), 16, 87);
            Add_Action (Table.States (271), 18, 88);
            Add_Action (Table.States (271), 23, 89);
            Add_Action (Table.States (271), 37, 90);
            Table.States (271).Goto_List.Set_Capacity (11);
            Add_Goto (Table.States (271), 42, 91);
            Add_Goto (Table.States (271), 45, 92);
            Add_Goto (Table.States (271), 51, 93);
            Add_Goto (Table.States (271), 52, 94);
            Add_Goto (Table.States (271), 53, 287);
            Add_Goto (Table.States (271), 60, 96);
            Add_Goto (Table.States (271), 61, 97);
            Add_Goto (Table.States (271), 62, 98);
            Add_Goto (Table.States (271), 63, 99);
            Add_Goto (Table.States (271), 67, 100);
            Add_Goto (Table.States (271), 72, 101);
            Table.States (271).Kernel := To_Vector ((0 => (61, 13, 2, False)));
            Table.States (271).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 53, 0)));
            Table.States (272).Action_List.Set_Capacity (3);
            Add_Action (Table.States (272), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (272), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (272), 37, 158);
            Table.States (272).Goto_List.Set_Capacity (2);
            Add_Goto (Table.States (272), 58, 159);
            Add_Goto (Table.States (272), 59, 288);
            Table.States (272).Kernel := To_Vector ((0 => (63, 20, 1, False)));
            Table.States (272).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 0)));
            Table.States (273).Action_List.Set_Capacity (1);
            Add_Action (Table.States (273), 14, 161);
            Table.States (273).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (273), 41, 289);
            Table.States (273).Kernel := To_Vector ((0 => (72, 13, 3, False)));
            Table.States (273).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 14, 161)));
            Table.States (274).Action_List.Set_Capacity (1);
            Add_Action (Table.States (274), 29, 290);
            Table.States (274).Kernel := To_Vector ((0 => (67, 37, 2, False)));
            Table.States (274).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 29, 290)));
            Table.States (275).Action_List.Set_Capacity (2);
            Add_Action (Table.States (275), 27, 170);
            Add_Action (Table.States (275), 34, 291);
            Table.States (275).Kernel := To_Vector (((56, 56, 1, True), (67, 56, 1, False)));
            Table.States (275).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 291)));
            Table.States (276).Action_List.Set_Capacity (3);
            Add_Action (Table.States (276), (4, 27, 34), (41, 0), 3, aggregate_g_0'Access, null);
            Table.States (276).Kernel := To_Vector ((0 => (41, 21, 0, False)));
            Table.States (276).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 41, 3)));
            Table.States (277).Action_List.Set_Capacity (4);
            Add_Action (Table.States (277), 4, Reduce, (44, 0), 3, null, null);
            Add_Action (Table.States (277), 14, 292);
            Add_Action (Table.States (277), 27, Reduce, (44, 0), 3, null, null);
            Add_Action (Table.States (277), 34, Reduce, (44, 0), 3, null, null);
            Table.States (277).Kernel := To_Vector (((44, 37, 0, False), (44, 37, 3, False)));
            Table.States (277).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 44, 3)));
            Table.States (278).Action_List.Set_Capacity (1);
            Add_Action (Table.States (278), 34, 293);
            Table.States (278).Kernel := To_Vector ((0 => (42, 36, 1, False)));
            Table.States (278).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 293)));
            Table.States (279).Action_List.Set_Capacity (3);
            Add_Action (Table.States (279), (4, 27, 34), (56, 1), 3, null, null);
            Table.States (279).Kernel := To_Vector ((0 => (56, 71, 0, True)));
            Table.States (279).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 3)));
            Table.States (279).Minimal_Complete_Actions_Recursive := True;
            Table.States (280).Action_List.Set_Capacity (5);
            Add_Action (Table.States (280), (4, 27, 31, 33, 34), (59, 1), 3, null, null);
            Table.States (280).Kernel := To_Vector ((0 => (59, 37, 0, True)));
            Table.States (280).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 59, 3)));
            Table.States (280).Minimal_Complete_Actions_Recursive := True;
            Table.States (281).Action_List.Set_Capacity (7);
            Add_Action (Table.States (281), (6, 8, 12, 16, 18, 23, 37), (62, 0), 9, package_extension_0'Access,
            package_extension_0_check'Access);
            Table.States (281).Kernel := To_Vector ((0 => (62, 34, 0, False)));
            Table.States (281).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 62, 9)));
            Table.States (282).Action_List.Set_Capacity (2);
            Add_Action (Table.States (282), 8, 294);
            Add_Action (Table.States (282), 25, 147);
            Table.States (282).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (282), 46, 180);
            Table.States (282).Kernel := To_Vector (((45, 47, 3, False), (47, 47, 2, True)));
            Table.States (282).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 8, 294)));
            Table.States (283).Action_List.Set_Capacity (1);
            Add_Action (Table.States (283), 21, 295);
            Table.States (283).Kernel := To_Vector ((0 => (42, 38, 3, False)));
            Table.States (283).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 21, 295)));
            Table.States (284).Action_List.Set_Capacity (1);
            Add_Action (Table.States (284), 21, 296);
            Table.States (284).Kernel := To_Vector (((42, 54, 3, False), (42, 54, 5, False)));
            Table.States (284).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 21, 296)));
            Table.States (285).Action_List.Set_Capacity (2);
            Add_Action (Table.States (285), 27, 170);
            Add_Action (Table.States (285), 34, 297);
            Table.States (285).Kernel := To_Vector (((42, 56, 1, False), (56, 56, 1, True)));
            Table.States (285).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 297)));
            Table.States (286).Action_List.Set_Capacity (2);
            Add_Action (Table.States (286), 13, 298);
            Add_Action (Table.States (286), 31, 121);
            Table.States (286).Kernel := To_Vector (((59, 59, 2, True), (62, 59, 3, False)));
            Table.States (286).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 13, 298)));
            Table.States (287).Action_List.Set_Capacity (1);
            Add_Action (Table.States (287), 8, 299);
            Table.States (287).Kernel := To_Vector ((0 => (61, 53, 2, False)));
            Table.States (287).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 8, 299)));
            Table.States (288).Action_List.Set_Capacity (2);
            Add_Action (Table.States (288), 31, 186);
            Add_Action (Table.States (288), 34, 300);
            Table.States (288).Kernel := To_Vector (((59, 59, 2, True), (63, 59, 1, False)));
            Table.States (288).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 300)));
            Table.States (289).Action_List.Set_Capacity (1);
            Add_Action (Table.States (289), 34, 301);
            Table.States (289).Kernel := To_Vector ((0 => (72, 41, 1, False)));
            Table.States (289).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 301)));
            Table.States (290).Action_List.Set_Capacity (10);
            Add_Action (Table.States (290), 10, 130);
            Add_Action (Table.States (290), 11, 131);
            Add_Action (Table.States (290), 14, 132);
            Add_Action (Table.States (290), 19, 9);
            Add_Action (Table.States (290), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (290), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (290), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (290), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (290), 37, 133);
            Add_Action (Table.States (290), 38, 134);
            Table.States (290).Goto_List.Set_Capacity (9);
            Add_Goto (Table.States (290), 41, 135);
            Add_Goto (Table.States (290), 43, 136);
            Add_Goto (Table.States (290), 44, 137);
            Add_Goto (Table.States (290), 56, 302);
            Add_Goto (Table.States (290), 57, 139);
            Add_Goto (Table.States (290), 58, 140);
            Add_Goto (Table.States (290), 59, 141);
            Add_Goto (Table.States (290), 69, 142);
            Add_Goto (Table.States (290), 71, 143);
            Table.States (290).Kernel := To_Vector ((0 => (67, 29, 1, False)));
            Table.States (290).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 0)));
            Table.States (291).Action_List.Set_Capacity (8);
            Add_Action (Table.States (291), (6, 8, 12, 16, 18, 23, 25, 37), (67, 0), 4,
            simple_declarative_item_0'Access, null);
            Table.States (291).Kernel := To_Vector ((0 => (67, 34, 0, False)));
            Table.States (291).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 67, 4)));
            Table.States (292).Action_List.Set_Capacity (1);
            Add_Action (Table.States (292), 38, 303);
            Table.States (292).Kernel := To_Vector ((0 => (44, 14, 2, False)));
            Table.States (292).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 38, 303)));
            Table.States (293).Action_List.Set_Capacity (7);
            Add_Action (Table.States (293), (6, 8, 12, 16, 18, 23, 37), (42, 2), 10, attribute_declaration_2'Access,
            null);
            Table.States (293).Kernel := To_Vector ((0 => (42, 34, 0, False)));
            Table.States (293).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 42, 10)));
            Table.States (294).Action_List.Set_Capacity (1);
            Add_Action (Table.States (294), 6, 304);
            Table.States (294).Kernel := To_Vector ((0 => (45, 8, 2, False)));
            Table.States (294).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 6, 304)));
            Table.States (295).Action_List.Set_Capacity (1);
            Add_Action (Table.States (295), 24, 305);
            Table.States (295).Kernel := To_Vector ((0 => (42, 21, 2, False)));
            Table.States (295).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 305)));
            Table.States (296).Action_List.Set_Capacity (1);
            Add_Action (Table.States (296), 24, 306);
            Table.States (296).Kernel := To_Vector (((42, 21, 2, False), (42, 21, 4, False)));
            Table.States (296).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 24, 306)));
            Table.States (297).Action_List.Set_Capacity (8);
            Add_Action (Table.States (297), (6, 8, 12, 16, 18, 23, 25, 37), (42, 0), 5, attribute_declaration_0'Access,
            null);
            Table.States (297).Kernel := To_Vector ((0 => (42, 34, 0, False)));
            Table.States (297).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 42, 5)));
            Table.States (298).Action_List.Set_Capacity (7);
            Add_Action (Table.States (298), 6, 85);
            Add_Action (Table.States (298), 8, Reduce, (53, 0), 0, null, null);
            Add_Action (Table.States (298), 12, 86);
            Add_Action (Table.States (298), 16, 87);
            Add_Action (Table.States (298), 18, 88);
            Add_Action (Table.States (298), 23, 89);
            Add_Action (Table.States (298), 37, 90);
            Table.States (298).Goto_List.Set_Capacity (11);
            Add_Goto (Table.States (298), 42, 91);
            Add_Goto (Table.States (298), 45, 92);
            Add_Goto (Table.States (298), 51, 93);
            Add_Goto (Table.States (298), 52, 94);
            Add_Goto (Table.States (298), 53, 307);
            Add_Goto (Table.States (298), 60, 96);
            Add_Goto (Table.States (298), 61, 97);
            Add_Goto (Table.States (298), 62, 98);
            Add_Goto (Table.States (298), 63, 99);
            Add_Goto (Table.States (298), 67, 100);
            Add_Goto (Table.States (298), 72, 101);
            Table.States (298).Kernel := To_Vector ((0 => (62, 13, 2, False)));
            Table.States (298).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 53, 0)));
            Table.States (299).Action_List.Set_Capacity (2);
            Add_Action (Table.States (299), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (299), 37, 144);
            Table.States (299).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (299), 58, 308);
            Table.States (299).Kernel := To_Vector ((0 => (61, 8, 1, False)));
            Table.States (299).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 0)));
            Table.States (300).Action_List.Set_Capacity (8);
            Add_Action (Table.States (300), (6, 8, 12, 16, 18, 23, 25, 37), (63, 0), 5, package_renaming_0'Access,
            null);
            Table.States (300).Kernel := To_Vector ((0 => (63, 34, 0, False)));
            Table.States (300).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 63, 5)));
            Table.States (301).Action_List.Set_Capacity (8);
            Add_Action (Table.States (301), (6, 8, 12, 16, 18, 23, 25, 37), (72, 0), 5,
            typed_string_declaration_0'Access, null);
            Table.States (301).Kernel := To_Vector ((0 => (72, 34, 0, False)));
            Table.States (301).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 72, 5)));
            Table.States (302).Action_List.Set_Capacity (2);
            Add_Action (Table.States (302), 27, 170);
            Add_Action (Table.States (302), 34, 309);
            Table.States (302).Kernel := To_Vector (((56, 56, 1, True), (67, 56, 1, False)));
            Table.States (302).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 309)));
            Table.States (303).Action_List.Set_Capacity (1);
            Add_Action (Table.States (303), 21, 310);
            Table.States (303).Kernel := To_Vector ((0 => (44, 38, 1, False)));
            Table.States (303).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 21, 310)));
            Table.States (304).Action_List.Set_Capacity (1);
            Add_Action (Table.States (304), 34, 311);
            Table.States (304).Kernel := To_Vector ((0 => (45, 6, 1, False)));
            Table.States (304).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 311)));
            Table.States (305).Action_List.Set_Capacity (10);
            Add_Action (Table.States (305), 10, 130);
            Add_Action (Table.States (305), 11, 131);
            Add_Action (Table.States (305), 14, 132);
            Add_Action (Table.States (305), 19, 9);
            Add_Action (Table.States (305), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (305), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (305), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (305), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (305), 37, 133);
            Add_Action (Table.States (305), 38, 134);
            Table.States (305).Goto_List.Set_Capacity (9);
            Add_Goto (Table.States (305), 41, 135);
            Add_Goto (Table.States (305), 43, 136);
            Add_Goto (Table.States (305), 44, 137);
            Add_Goto (Table.States (305), 56, 312);
            Add_Goto (Table.States (305), 57, 139);
            Add_Goto (Table.States (305), 58, 140);
            Add_Goto (Table.States (305), 59, 141);
            Add_Goto (Table.States (305), 69, 142);
            Add_Goto (Table.States (305), 71, 143);
            Table.States (305).Kernel := To_Vector ((0 => (42, 24, 1, False)));
            Table.States (305).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 0)));
            Table.States (306).Action_List.Set_Capacity (11);
            Add_Action (Table.States (306), 4, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (306), 10, 227);
            Add_Action (Table.States (306), 11, 228);
            Add_Action (Table.States (306), 14, 229);
            Add_Action (Table.States (306), 19, 9);
            Add_Action (Table.States (306), 27, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (306), 31, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (306), 33, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (306), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (306), 37, 230);
            Add_Action (Table.States (306), 38, 231);
            Table.States (306).Goto_List.Set_Capacity (9);
            Add_Goto (Table.States (306), 41, 232);
            Add_Goto (Table.States (306), 43, 233);
            Add_Goto (Table.States (306), 44, 234);
            Add_Goto (Table.States (306), 56, 313);
            Add_Goto (Table.States (306), 57, 236);
            Add_Goto (Table.States (306), 58, 237);
            Add_Goto (Table.States (306), 59, 238);
            Add_Goto (Table.States (306), 69, 239);
            Add_Goto (Table.States (306), 71, 240);
            Table.States (306).Kernel := To_Vector (((42, 24, 1, False), (42, 24, 3, False)));
            Table.States (306).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 56, 0)));
            Table.States (307).Action_List.Set_Capacity (1);
            Add_Action (Table.States (307), 8, 314);
            Table.States (307).Kernel := To_Vector ((0 => (62, 53, 2, False)));
            Table.States (307).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 8, 314)));
            Table.States (308).Action_List.Set_Capacity (1);
            Add_Action (Table.States (308), 34, 315);
            Table.States (308).Kernel := To_Vector ((0 => (61, 58, 1, False)));
            Table.States (308).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 315)));
            Table.States (309).Action_List.Set_Capacity (8);
            Add_Action (Table.States (309), (6, 8, 12, 16, 18, 23, 25, 37), (67, 1), 6,
            simple_declarative_item_1'Access, null);
            Table.States (309).Kernel := To_Vector ((0 => (67, 34, 0, False)));
            Table.States (309).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 67, 6)));
            Table.States (310).Action_List.Set_Capacity (3);
            Add_Action (Table.States (310), (4, 27, 34), (44, 1), 6, null, null);
            Table.States (310).Kernel := To_Vector ((0 => (44, 21, 0, False)));
            Table.States (310).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 44, 6)));
            Table.States (311).Action_List.Set_Capacity (8);
            Add_Action (Table.States (311), (6, 8, 12, 16, 18, 23, 25, 37), (45, 0), 7, case_statement_0'Access, null);
            Table.States (311).Kernel := To_Vector ((0 => (45, 34, 0, False)));
            Table.States (311).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 45, 7)));
            Table.States (312).Action_List.Set_Capacity (2);
            Add_Action (Table.States (312), 27, 170);
            Add_Action (Table.States (312), 34, 316);
            Table.States (312).Kernel := To_Vector (((42, 56, 1, False), (56, 56, 1, True)));
            Table.States (312).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 316)));
            Table.States (313).Action_List.Set_Capacity (3);
            Add_Action (Table.States (313), 4, 317);
            Add_Action (Table.States (313), 27, 261);
            Add_Action (Table.States (313), 34, 318);
            Table.States (313).Kernel := To_Vector (((42, 56, 1, False), (42, 56, 3, False), (56, 56, 1, True)));
            Table.States (313).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 318)));
            Table.States (314).Action_List.Set_Capacity (2);
            Add_Action (Table.States (314), 34, Reduce, (58, 0), 0, null, null);
            Add_Action (Table.States (314), 37, 144);
            Table.States (314).Goto_List.Set_Capacity (1);
            Add_Goto (Table.States (314), 58, 319);
            Table.States (314).Kernel := To_Vector ((0 => (62, 8, 1, False)));
            Table.States (314).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 58, 0)));
            Table.States (315).Action_List.Set_Capacity (8);
            Add_Action (Table.States (315), (6, 8, 12, 16, 18, 23, 25, 37), (61, 0), 7, package_spec_0'Access,
            package_spec_0_check'Access);
            Table.States (315).Kernel := To_Vector ((0 => (61, 34, 0, False)));
            Table.States (315).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 61, 7)));
            Table.States (316).Action_List.Set_Capacity (8);
            Add_Action (Table.States (316), (6, 8, 12, 16, 18, 23, 25, 37), (42, 3), 8, attribute_declaration_3'Access,
            null);
            Table.States (316).Kernel := To_Vector ((0 => (42, 34, 0, False)));
            Table.States (316).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 42, 8)));
            Table.States (317).Action_List.Set_Capacity (1);
            Add_Action (Table.States (317), 36, 320);
            Table.States (317).Kernel := To_Vector ((0 => (42, 4, 2, False)));
            Table.States (317).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 36, 320)));
            Table.States (318).Action_List.Set_Capacity (8);
            Add_Action (Table.States (318), (6, 8, 12, 16, 18, 23, 25, 37), (42, 1), 8, attribute_declaration_1'Access,
            null);
            Table.States (318).Kernel := To_Vector ((0 => (42, 34, 0, False)));
            Table.States (318).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 42, 8)));
            Table.States (319).Action_List.Set_Capacity (1);
            Add_Action (Table.States (319), 34, 321);
            Table.States (319).Kernel := To_Vector ((0 => (62, 58, 1, False)));
            Table.States (319).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 321)));
            Table.States (320).Action_List.Set_Capacity (1);
            Add_Action (Table.States (320), 34, 322);
            Table.States (320).Kernel := To_Vector ((0 => (42, 36, 1, False)));
            Table.States (320).Minimal_Complete_Actions := To_Vector ((0 => (Shift, 34, 322)));
            Table.States (321).Action_List.Set_Capacity (8);
            Add_Action (Table.States (321), (6, 8, 12, 16, 18, 23, 25, 37), (62, 0), 9, package_extension_0'Access,
            package_extension_0_check'Access);
            Table.States (321).Kernel := To_Vector ((0 => (62, 34, 0, False)));
            Table.States (321).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 62, 9)));
            Table.States (322).Action_List.Set_Capacity (8);
            Add_Action (Table.States (322), (6, 8, 12, 16, 18, 23, 25, 37), (42, 2), 10,
            attribute_declaration_2'Access, null);
            Table.States (322).Kernel := To_Vector ((0 => (42, 34, 0, False)));
            Table.States (322).Minimal_Complete_Actions := To_Vector ((0 => (Reduce, 42, 10)));
         end Subr_3;
      begin
         Subr_1;
         Subr_2;
         Subr_3;
         Table.Error_Action := new Parse_Action_Node'((Verb => Error), null);
      end;

      WisiToken.Parse.LR.Parser.New_Parser
        (Parser,
         Trace,
         Lexer.New_Lexer (Trace.Descriptor),
         Table,
         Language_Fixes,
         Language_Matching_Begin_Tokens,
         Language_String_ID_Set,
         User_Data,
         Max_Parallel         => 15,
         Terminate_Same_State => True);
   end Create_Parser;
end Gpr_Process_Main;
