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

--  Copyright (C) 2013 - 2018 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_LR1_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_Use_Minimal_Complete_Actions : in
     WisiToken.Parse.LR.Parser.Language_Use_Minimal_Complete_Actions_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     => 37,
         First_Nonterminal => 38,
         Last_Nonterminal  => 71,
         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),
         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),
         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),
         Ignore_Check_Fail  => 2,
         Task_Count  => 0,
         Cost_Limit  => 20,
         Check_Limit => 3,
         Check_Delta_Limit => 200,
         Enqueue_Limit => 10000);

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

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