// This file is regenerated on every build.  It builds the concrete syntax tree, embedding code from the grammar file.
// To be honest the whole parse/cst/ast thing is a bit muddled and at a minimum needs to be documented if indeed not rewritten.
// Note that the code in a .g file can only walk the CST.  A user-built AST can be expected to have a totally different structure
// from the grammar, so embedding code in the grammar to walk the AST make no sense.

#define X_AST 1
//\\ B<EOF> = 0;
//\\#
//\\ B<NL> = 2;
//\\#
//\\ P<constant> =
   case G_constant:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <cast_opt> <floating_constant>,
       T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_floating_constant */);
     } else if (alt == 1)        {  //\\    <cast_opt> <integer_constant>,
       T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_integer_constant */);
     } else if (alt == 2)        {  //\\    <cast_opt> <character_constant>,
       T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_character_constant */);
     } else                      {  //\\    <cast_opt> <enumeration_constant>;
       T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_enumeration_constant */);
     }
     return T[0] = G_mktuple(G_constant, alt, phrases, T);

//\\ P<U_opt> =
   case G_U_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    'U',
       T[++phrases] = ch(CST(P++), 'U');
     } else if (alt == 1)        {  //\\    'u',
       T[++phrases] = ch(CST(P++), 'u');
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_U_opt, alt, phrases, T);

//\\ P<L_opt> =
   case G_L_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    'L',
       T[++phrases] = ch(CST(P++), 'L');
     } else if (alt == 1)        {  //\\    'l',
       T[++phrases] = ch(CST(P++), 'l');
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_L_opt, alt, phrases, T);

//\\ P<UL_opt> =
   case G_UL_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    'U' <L_opt> <L_opt>,
       T[++phrases] = ch(CST(P++), 'U');
       T[++phrases] = build_ast(CST(P++) /* G_L_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_L_opt */);
     } else if (alt == 1)        {  //\\    'L' <L_opt> <U_opt>,
       T[++phrases] = ch(CST(P++), 'L');
       T[++phrases] = build_ast(CST(P++) /* G_L_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_U_opt */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_UL_opt, alt, phrases, T);

//\\ P<integer-constant> =
   case G_integer_constant:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <hexadecimal_constant> <UL_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_hexadecimal_constant */);
       T[++phrases] = build_ast(CST(P++) /* G_UL_opt */);
     } else if (alt == 1)        {  //\\    <binary_constant> <UL_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_binary_constant */);
       T[++phrases] = build_ast(CST(P++) /* G_UL_opt */);
     } else if (alt == 2)        {  //\\    <octal_constant> <UL_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_octal_constant */);
       T[++phrases] = build_ast(CST(P++) /* G_UL_opt */);
     } else                      {  //\\    <decimal_constant> <UL_opt>;
       T[++phrases] = build_ast(CST(P++) /* G_decimal_constant */);
       T[++phrases] = build_ast(CST(P++) /* G_UL_opt */);
     }
     return T[0] = G_mktuple(G_integer_constant, alt, phrases, T);

//\\ P<decimal-constant> =
   case G_decimal_constant:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    «[1-9][0-9]*»;
     T[++phrases] = reg(CST(P++), "[1-9][0-9]*");
     return T[0] = G_mktuple(G_decimal_constant, alt, phrases, T);

//\\ P<octal-constant> =
   case G_octal_constant:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    «0[0-7]*»;
     T[++phrases] = reg(CST(P++), "0[0-7]*");
     return T[0] = G_mktuple(G_octal_constant, alt, phrases, T);

//\\ P<hexadecimal-constant> =
   case G_hexadecimal_constant:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    «0[xX][0-9a-fA-F]+»;
     T[++phrases] = reg(CST(P++), "0[xX][0-9a-fA-F]+");
     return T[0] = G_mktuple(G_hexadecimal_constant, alt, phrases, T);

//\\ P<binary-constant> =
   case G_binary_constant:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    «0[bB][0-1]+»;
     T[++phrases] = reg(CST(P++), "0[bB][0-1]+");
     return T[0] = G_mktuple(G_binary_constant, alt, phrases, T);

//\\ P<floating-constant> =
   case G_floating_constant:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <decimal_floating_constant>,
       T[++phrases] = build_ast(CST(P++) /* G_decimal_floating_constant */);
     } else if (alt == 1)        {  //\\    <hexadecimal_floating_constant>,
       T[++phrases] = build_ast(CST(P++) /* G_hexadecimal_floating_constant */);
     } else                      {  //\\    <binary_floating_constant>;
       T[++phrases] = build_ast(CST(P++) /* G_binary_floating_constant */);
     }
     return T[0] = G_mktuple(G_floating_constant, alt, phrases, T);

//\\ P<fractional-constant> =
   case G_fractional_constant:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <digit_sequence_opt> '.' <digit_sequence>,
       T[++phrases] = build_ast(CST(P++) /* G_digit_sequence_opt */);
       T[++phrases] = ch(CST(P++), '.');
       T[++phrases] = build_ast(CST(P++) /* G_digit_sequence */);
     } else                      {  //\\    <digit_sequence> '.';
       T[++phrases] = build_ast(CST(P++) /* G_digit_sequence */);
       T[++phrases] = ch(CST(P++), '.');
     }
     return T[0] = G_mktuple(G_fractional_constant, alt, phrases, T);

//\\ P<exponent-part> =
   case G_exponent_part:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    «[eE][+-]?[0-9]*»;
     T[++phrases] = reg(CST(P++), "[eE][+-]?[0-9]*");
     return T[0] = G_mktuple(G_exponent_part, alt, phrases, T);

//\\ P<exponent-part_opt> =
   case G_exponent_part_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <exponent_part>,
       T[++phrases] = build_ast(CST(P++) /* G_exponent_part */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_exponent_part_opt, alt, phrases, T);

//\\ P<floating-suffix_opt> =
   case G_floating_suffix_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    «[flFL]?»;
     T[++phrases] = reg(CST(P++), "[flFL]?");
     return T[0] = G_mktuple(G_floating_suffix_opt, alt, phrases, T);

//\\ P<digit-sequence> =
   case G_digit_sequence:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    «[0-9]+»;
     T[++phrases] = reg(CST(P++), "[0-9]+");
     return T[0] = G_mktuple(G_digit_sequence, alt, phrases, T);

//\\ P<digit-sequence_opt> =
   case G_digit_sequence_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <digit_sequence>,
       T[++phrases] = build_ast(CST(P++) /* G_digit_sequence */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_digit_sequence_opt, alt, phrases, T);

//\\ P<decimal-floating-constant> =
   case G_decimal_floating_constant:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <fractional_constant> <exponent_part_opt> <floating_suffix_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_fractional_constant */);
       T[++phrases] = build_ast(CST(P++) /* G_exponent_part_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_floating_suffix_opt */);
     } else                      {  //\\    <digit_sequence> <exponent_part> <floating_suffix_opt>;
       T[++phrases] = build_ast(CST(P++) /* G_digit_sequence */);
       T[++phrases] = build_ast(CST(P++) /* G_exponent_part */);
       T[++phrases] = build_ast(CST(P++) /* G_floating_suffix_opt */);
     }
     return T[0] = G_mktuple(G_decimal_floating_constant, alt, phrases, T);

//\\ P<hexadecimal-floating-constant> =
   case G_hexadecimal_floating_constant:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    «0[xX]» <hexadecimal_fractional_constant> <binary_exponent_part> «[flFL]?»,
       T[++phrases] = reg(CST(P++), "0[xX]");
       T[++phrases] = build_ast(CST(P++) /* G_hexadecimal_fractional_constant */);
       T[++phrases] = build_ast(CST(P++) /* G_binary_exponent_part */);
       T[++phrases] = reg(CST(P++), "[flFL]?");
     } else                      {  //\\    «0[xX]» <hexadecimal_digit_sequence> <binary_exponent_part> «[flFL]?»;
       T[++phrases] = reg(CST(P++), "0[xX]");
       T[++phrases] = build_ast(CST(P++) /* G_hexadecimal_digit_sequence */);
       T[++phrases] = build_ast(CST(P++) /* G_binary_exponent_part */);
       T[++phrases] = reg(CST(P++), "[flFL]?");
     }
     return T[0] = G_mktuple(G_hexadecimal_floating_constant, alt, phrases, T);

//\\ P<binary-floating-constant> =
   case G_binary_floating_constant:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    «0[bB]» <binary_fractional_constant> <binary_exponent_part> «[flFL]?»,
       T[++phrases] = reg(CST(P++), "0[bB]");
       T[++phrases] = build_ast(CST(P++) /* G_binary_fractional_constant */);
       T[++phrases] = build_ast(CST(P++) /* G_binary_exponent_part */);
       T[++phrases] = reg(CST(P++), "[flFL]?");
     } else                      {  //\\    «0[bB]» <binary_digit_sequence> <binary_exponent_part> «[flFL]?»;
       T[++phrases] = reg(CST(P++), "0[bB]");
       T[++phrases] = build_ast(CST(P++) /* G_binary_digit_sequence */);
       T[++phrases] = build_ast(CST(P++) /* G_binary_exponent_part */);
       T[++phrases] = reg(CST(P++), "[flFL]?");
     }
     return T[0] = G_mktuple(G_binary_floating_constant, alt, phrases, T);

//\\ P<hexadecimal-digit-sequence> =
   case G_hexadecimal_digit_sequence:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    «[A-Fa-f0-9]+»;
     T[++phrases] = reg(CST(P++), "[A-Fa-f0-9]+");
     return T[0] = G_mktuple(G_hexadecimal_digit_sequence, alt, phrases, T);

//\\ P<hexadecimal-fractional-constant> =
   case G_hexadecimal_fractional_constant:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    «[A-Fa-f0-9]*» '.' «[A-Fa-f0-9]+»,
       T[++phrases] = reg(CST(P++), "[A-Fa-f0-9]*");
       T[++phrases] = ch(CST(P++), '.');
       T[++phrases] = reg(CST(P++), "[A-Fa-f0-9]+");
     } else                      {  //\\    «[A-Fa-f0-9]+» '.';
       T[++phrases] = reg(CST(P++), "[A-Fa-f0-9]+");
       T[++phrases] = ch(CST(P++), '.');
     }
     return T[0] = G_mktuple(G_hexadecimal_fractional_constant, alt, phrases, T);

//\\ P<binary-digit-sequence> =
   case G_binary_digit_sequence:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    «[0-1]+»;
     T[++phrases] = reg(CST(P++), "[0-1]+");
     return T[0] = G_mktuple(G_binary_digit_sequence, alt, phrases, T);

//\\ P<binary-fractional-constant> =
   case G_binary_fractional_constant:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    «[0-1]*» '.' «[0-1]+»,
       T[++phrases] = reg(CST(P++), "[0-1]*");
       T[++phrases] = ch(CST(P++), '.');
       T[++phrases] = reg(CST(P++), "[0-1]+");
     } else                      {  //\\    «[0-1]+» '.';
       T[++phrases] = reg(CST(P++), "[0-1]+");
       T[++phrases] = ch(CST(P++), '.');
     }
     return T[0] = G_mktuple(G_binary_fractional_constant, alt, phrases, T);

//\\ P<binary-exponent-part> =
   case G_binary_exponent_part:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    «[pP][+-]?[0-9]+»;
     T[++phrases] = reg(CST(P++), "[pP][+-]?[0-9]+");
     return T[0] = G_mktuple(G_binary_exponent_part, alt, phrases, T);

//\\ P<enumeration-constant> =
   case G_enumeration_constant:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <identifier>;
     T[++phrases] = build_ast(CST(P++) /* G_identifier */);
     return T[0] = G_mktuple(G_enumeration_constant, alt, phrases, T);

//\\ P<character-constant> =
   case G_character_constant:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <longchartype_opt> «'» <sqchars> «'»;
     T[++phrases] = build_ast(CST(P++) /* G_longchartype_opt */);
     T[++phrases] = reg(CST(P++), "'");
     T[++phrases] = build_ast(CST(P++) /* G_sqchars */);
     T[++phrases] = reg(CST(P++), "'");
     return T[0] = G_mktuple(G_character_constant, alt, phrases, T);

//\\ P<sqchars> =
   case G_sqchars:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <sqchar> <sqchars>,
       T[++phrases] = build_ast(CST(P++) /* G_sqchar */);
       T[++phrases] = build_ast(CST(P++) /* G_sqchars */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_sqchars, alt, phrases, T);

//\\ P<sqchar> =
   case G_sqchar:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    «[^'\]»,
       T[++phrases] = reg(CST(P++), "[^'\\]");
     } else                      {  //\\    <escaped_char>;
       T[++phrases] = build_ast(CST(P++) /* G_escaped_char */);
     }
     return T[0] = G_mktuple(G_sqchar, alt, phrases, T);

//\\ P<escaped-char> =
   case G_escaped_char:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    '\' «[\"'?abfnrtvx0-9]»;
     T[++phrases] = ch(CST(P++), '\\');
     T[++phrases] = reg(CST(P++), "[\\\"'?abfnrtvx0-9]");
     return T[0] = G_mktuple(G_escaped_char, alt, phrases, T);

//\\ P<longchartype_opt> =
   case G_longchartype_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    'L',
       T[++phrases] = ch(CST(P++), 'L');
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_longchartype_opt, alt, phrases, T);

//\\ P<unchecked-identifier> =
   case G_unchecked_identifier:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    «[A-Za-z_][A-Za-z0-9_]*» <!sq>;
     T[++phrases] = reg(CST(P++), "[A-Za-z_][A-Za-z0-9_]*");
     T[++phrases] = -1 +(0 * P++);
     return T[0] = G_mktuple(G_unchecked_identifier, alt, phrases, T);

//\\ P<sq> =
   case G_sq:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    «'»;
     T[++phrases] = reg(CST(P++), "'");
     return T[0] = G_mktuple(G_sq, alt, phrases, T);

//\\ P<dq> =
   case G_dq:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    '"';
     T[++phrases] = ch(CST(P++), '"');
     return T[0] = G_mktuple(G_dq, alt, phrases, T);

//\\ P<dqchar> =
   case G_dqchar:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '\' <dq>,
       T[++phrases] = ch(CST(P++), '\\');
       T[++phrases] = build_ast(CST(P++) /* G_dq */);
     } else                      {  //\\    <!dq> «.»;
       T[++phrases] = -1 +(0 * P++);
       T[++phrases] = reg(CST(P++), ".");
     }
     return T[0] = G_mktuple(G_dqchar, alt, phrases, T);

//\\ P<dqstringchars> =
   case G_dqstringchars:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <dqchar> <dqstringchars>,
       T[++phrases] = build_ast(CST(P++) /* G_dqchar */);
       T[++phrases] = build_ast(CST(P++) /* G_dqstringchars */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_dqstringchars, alt, phrases, T);

//\\ P<dqstring> =
   case G_dqstring:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <longchartype_opt> <dq> <dqstringchars> <dq> <dqstring_opt>;
     T[++phrases] = build_ast(CST(P++) /* G_longchartype_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_dq */);
     T[++phrases] = build_ast(CST(P++) /* G_dqstringchars */);
     T[++phrases] = build_ast(CST(P++) /* G_dq */);
     T[++phrases] = build_ast(CST(P++) /* G_dqstring_opt */);
     return T[0] = G_mktuple(G_dqstring, alt, phrases, T);

//\\ P<dqstring_opt> =
   case G_dqstring_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <dqstring>,
       T[++phrases] = build_ast(CST(P++) /* G_dqstring */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_dqstring_opt, alt, phrases, T);

//\\ P<not-preceded-by-alpha_and_is-not-keyword> =
   case G_not_preceded_by_alpha_and_is_not_keyword:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <!preceded-by-alpha> <!keyword>;
     T[++phrases] = -1 +(0 * P++) /* S_preceded-by-alpha */ /* semantic call - temp for now. Could theoretically return a string like a terminal. Parser needs to insert something in CST. */;
     T[++phrases] = -1 +(0 * P++);
     return T[0] = G_mktuple(G_not_preceded_by_alpha_and_is_not_keyword, alt, phrases, T);

//\\ P<tag> =
   case G_tag:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <identifier>;
     T[++phrases] = build_ast(CST(P++) /* G_identifier */);
     return T[0] = G_mktuple(G_tag, alt, phrases, T);

//\\ P<new-identifier> =
   case G_new_identifier:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <identifier>;
     T[++phrases] = build_ast(CST(P++) /* G_identifier */);
     return T[0] = G_mktuple(G_new_identifier, alt, phrases, T);

//\\ P<identifier> =
   case G_identifier:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <?not_preceded_by_alpha_and_is_not_keyword> <unchecked_identifier>;
     T[++phrases] = -build_ast(CST(P++) /* G_not_preceded_by_alpha_and_is_not_keyword */);
     T[++phrases] = build_ast(CST(P++) /* G_unchecked_identifier */);
     return T[0] = G_mktuple(G_identifier, alt, phrases, T);

//\\ P<keyword> =
   case G_keyword:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <actual_keyword> <!followed-by-alpha>;
     T[++phrases] = build_ast(CST(P++) /* G_actual_keyword */);
     T[++phrases] = -1 +(0 * P++) /* S_followed-by-alpha */ /* semantic call - temp for now. Could theoretically return a string like a terminal. Parser needs to insert something in CST. */;
     return T[0] = G_mktuple(G_keyword, alt, phrases, T);

//\\ P<actual-keyword> =
   case G_actual_keyword:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "if",
       T[++phrases] = kw(CST(P++), "if");
     } else if (alt == 1)        {  //\\    "const",
       T[++phrases] = kw(CST(P++), "const");
     } else if (alt == 2)        {  //\\    "struct",
       T[++phrases] = kw(CST(P++), "struct");
     } else if (alt == 3)        {  //\\    "union",
       T[++phrases] = kw(CST(P++), "union");
     } else if (alt == 4)        {  //\\    "sizeof",
       T[++phrases] = kw(CST(P++), "sizeof");
     } else if (alt == 5)        {  //\\    "typeof",
       T[++phrases] = kw(CST(P++), "typeof");
     } else if (alt == 6)        {  //\\    "double",
       T[++phrases] = kw(CST(P++), "double");
     } else if (alt == 7)        {  //\\    "long",
       T[++phrases] = kw(CST(P++), "long");
     } else if (alt == 8)        {  //\\    "char",
       T[++phrases] = kw(CST(P++), "char");
     } else if (alt == 9)        {  //\\    "float",
       T[++phrases] = kw(CST(P++), "float");
     } else if (alt == 10)        {  //\\    "void",
       T[++phrases] = kw(CST(P++), "void");
     } else if (alt == 11)        {  //\\    "enum",
       T[++phrases] = kw(CST(P++), "enum");
     } else if (alt == 12)        {  //\\    "short",
       T[++phrases] = kw(CST(P++), "short");
     } else if (alt == 13)        {  //\\    "int",
       T[++phrases] = kw(CST(P++), "int");
     } else if (alt == 14)        {  //\\    "signed",
       T[++phrases] = kw(CST(P++), "signed");
     } else if (alt == 15)        {  //\\    "unsigned",
       T[++phrases] = kw(CST(P++), "unsigned");
     } else if (alt == 16)        {  //\\    "volatile",
       T[++phrases] = kw(CST(P++), "volatile");
     } else if (alt == 17)        {  //\\    "auto",
       T[++phrases] = kw(CST(P++), "auto");
     } else if (alt == 18)        {  //\\    "register",
       T[++phrases] = kw(CST(P++), "register");
     } else if (alt == 19)        {  //\\    "static",
       T[++phrases] = kw(CST(P++), "static");
     } else if (alt == 20)        {  //\\    "extern",
       T[++phrases] = kw(CST(P++), "extern");
     } else if (alt == 21)        {  //\\    "goto",
       T[++phrases] = kw(CST(P++), "goto");
     } else if (alt == 22)        {  //\\    "continue",
       T[++phrases] = kw(CST(P++), "continue");
     } else if (alt == 23)        {  //\\    "break",
       T[++phrases] = kw(CST(P++), "break");
     } else if (alt == 24)        {  //\\    "return",
       T[++phrases] = kw(CST(P++), "return");
     } else if (alt == 25)        {  //\\    "while",
       T[++phrases] = kw(CST(P++), "while");
     } else if (alt == 26)        {  //\\    "do",
       T[++phrases] = kw(CST(P++), "do");
     } else if (alt == 27)        {  //\\    "for",
       T[++phrases] = kw(CST(P++), "for");
     } else if (alt == 28)        {  //\\    "switch",
       T[++phrases] = kw(CST(P++), "switch");
     } else if (alt == 29)        {  //\\    "else",
       T[++phrases] = kw(CST(P++), "else");
     } else if (alt == 30)        {  //\\    "case",
       T[++phrases] = kw(CST(P++), "case");
     } else if (alt == 31)        {  //\\    "default",
       T[++phrases] = kw(CST(P++), "default");
     } else                      {  //\\    "typedef";
       T[++phrases] = kw(CST(P++), "typedef");
     }
     return T[0] = G_mktuple(G_actual_keyword, alt, phrases, T);

//\\ P<SS> =
   case G_SS:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <C_line_reconstruction> <external_declaration_list_opt> <EOF>;
     T[++phrases] = -1 +(0 * P++) /* S_C_line_reconstruction */ /* semantic call - temp for now. Could theoretically return a string like a terminal. Parser needs to insert something in CST. */;
     T[++phrases] = build_ast(CST(P++) /* G_external_declaration_list_opt */);
     T[++phrases] = BIP(CST(P++), B_EOF);
     return T[0] = G_mktuple(G_SS, alt, phrases, T);

//\\ P<external-declaration-list> =
   case G_external_declaration_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <external_declaration> <external_declaration_list_opt>;
     T[++phrases] = build_ast(CST(P++) /* G_external_declaration */);
     T[++phrases] = build_ast(CST(P++) /* G_external_declaration_list_opt */);
     return T[0] = G_mktuple(G_external_declaration_list, alt, phrases, T);

//\\ P<external-declaration-list_opt> =
   case G_external_declaration_list_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <external_declaration_list>,
       T[++phrases] = build_ast(CST(P++) /* G_external_declaration_list */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_external_declaration_list_opt, alt, phrases, T);

//\\ P<external-declaration> =
   case G_external_declaration:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <pp_directive>,
       T[++phrases] = -1 +(0 * P++) /* S_pp_directive */ /* semantic call - temp for now. Could theoretically return a string like a terminal. Parser needs to insert something in CST. */;
     } else if (alt == 1)        {  //\\    <typedef_declaration> ';',
       T[++phrases] = build_ast(CST(P++) /* G_typedef_declaration */);
       T[++phrases] = ch(CST(P++), ';');
     } else if (alt == 2)        {  //\\    <proc_fn_decl>,
       T[++phrases] = build_ast(CST(P++) /* G_proc_fn_decl */);
     } else if (alt == 3)        {  //\\    <possibly_initialised_scalar_or_array_decl> ';',
       T[++phrases] = build_ast(CST(P++) /* G_possibly_initialised_scalar_or_array_decl */);
       T[++phrases] = ch(CST(P++), ';');
     } else if (alt == 4)        {  //\\    <enum_specifier>,
       T[++phrases] = build_ast(CST(P++) /* G_enum_specifier */);
     } else if (alt == 5)        {  //\\    <struct_or_union_specifier>,
       T[++phrases] = build_ast(CST(P++) /* G_struct_or_union_specifier */);
     } else                      {  //\\    ';';
       T[++phrases] = ch(CST(P++), ';');
     }
     return T[0] = G_mktuple(G_external_declaration, alt, phrases, T);

//\\ P<struct-or-union-specifier> =
   case G_struct_or_union_specifier:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <struct_or_union> <identifier> '{' <struct_field_declarations> '}',
       T[++phrases] = build_ast(CST(P++) /* G_struct_or_union */);
       T[++phrases] = build_ast(CST(P++) /* G_identifier */);
       T[++phrases] = ch(CST(P++), '{');
       T[++phrases] = build_ast(CST(P++) /* G_struct_field_declarations */);
       T[++phrases] = ch(CST(P++), '}');
     } else if (alt == 1)        {  //\\    <struct_or_union> '{' <struct_field_declarations> '}',
       T[++phrases] = build_ast(CST(P++) /* G_struct_or_union */);
       T[++phrases] = ch(CST(P++), '{');
       T[++phrases] = build_ast(CST(P++) /* G_struct_field_declarations */);
       T[++phrases] = ch(CST(P++), '}');
     } else                      {  //\\    <struct_or_union> <identifier>;
       T[++phrases] = build_ast(CST(P++) /* G_struct_or_union */);
       T[++phrases] = build_ast(CST(P++) /* G_identifier */);
     }
     return T[0] = G_mktuple(G_struct_or_union_specifier, alt, phrases, T);

//\\ P<struct-or-union> =
   case G_struct_or_union:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "struct",
       T[++phrases] = kw(CST(P++), "struct");
     } else                      {  //\\    "union";
       T[++phrases] = kw(CST(P++), "union");
     }
     return T[0] = G_mktuple(G_struct_or_union, alt, phrases, T);

//\\ P<struct-field-declarations> =
   case G_struct_field_declarations:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <struct_field_declaration> <rest_of_struct_field_declarations>;
     T[++phrases] = build_ast(CST(P++) /* G_struct_field_declaration */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_struct_field_declarations */);
     return T[0] = G_mktuple(G_struct_field_declarations, alt, phrases, T);

//\\ P<rest-of-struct-field-declarations> =
   case G_rest_of_struct_field_declarations:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <struct_field_declaration> <rest_of_struct_field_declarations>,
       T[++phrases] = build_ast(CST(P++) /* G_struct_field_declaration */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_struct_field_declarations */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_struct_field_declarations, alt, phrases, T);

//\\ P<struct-field-declaration> =
   case G_struct_field_declaration:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <possibly_initialised_scalar_or_array_decl> ';',
       T[++phrases] = build_ast(CST(P++) /* G_possibly_initialised_scalar_or_array_decl */);
       T[++phrases] = ch(CST(P++), ';');
     } else                      {  //\\    <struct_or_union_specifier> ';';
       T[++phrases] = build_ast(CST(P++) /* G_struct_or_union_specifier */);
       T[++phrases] = ch(CST(P++), ';');
     }
     return T[0] = G_mktuple(G_struct_field_declaration, alt, phrases, T);

//\\ P<possibly-initialised-scalar-or-array-decl> =
   case G_possibly_initialised_scalar_or_array_decl:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <auto_reg_static_ext_opt> <const_or_volatile_type_qualifier_opt> <type> <rest_of_scalar_or_array_decl>;
     T[++phrases] = build_ast(CST(P++) /* G_auto_reg_static_ext_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_const_or_volatile_type_qualifier_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_type */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_scalar_or_array_decl */);
     return T[0] = G_mktuple(G_possibly_initialised_scalar_or_array_decl, alt, phrases, T);

//\\ P<rest-of-scalar-or-array-decl> =
   case G_rest_of_scalar_or_array_decl:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <indirection_decl_opt> <new_identifier> <array_bounds> <array_init_opt> <rest_of_scalar_or_array_decl_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_new_identifier */);
       T[++phrases] = build_ast(CST(P++) /* G_array_bounds */);
       T[++phrases] = build_ast(CST(P++) /* G_array_init_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_scalar_or_array_decl_opt */);
     } else if (alt == 1)        {  //\\    <indirection_decl_opt> '(' <indirection_decl_opt> <new_identifier> ')' '(' <param_list_opt> ')' <scalar_init_opt> <rest_of_scalar_or_array_decl_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_new_identifier */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_param_list_opt */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = build_ast(CST(P++) /* G_scalar_init_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_scalar_or_array_decl_opt */);
     } else                      {  //\\    <indirection_decl_opt> <new_identifier> <scalar_init_opt> <rest_of_scalar_or_array_decl_opt>;
       T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_new_identifier */);
       T[++phrases] = build_ast(CST(P++) /* G_scalar_init_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_scalar_or_array_decl_opt */);
     }
     return T[0] = G_mktuple(G_rest_of_scalar_or_array_decl, alt, phrases, T);

//\\ P<rest-of-scalar-or-array-decl_opt> =
   case G_rest_of_scalar_or_array_decl_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    ',' <rest_of_scalar_or_array_decl>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_scalar_or_array_decl */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_scalar_or_array_decl_opt, alt, phrases, T);

//\\ P<scalar-init_opt> =
   case G_scalar_init_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '=' <assignment_expression>,
       T[++phrases] = ch(CST(P++), '=');
       T[++phrases] = build_ast(CST(P++) /* G_assignment_expression */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_scalar_init_opt, alt, phrases, T);

//\\ P<assignment-expression> =
   case G_assignment_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <lvalue_assign_opt> <conditional_expression> <rest_of_assignment_expression_opt>;
     T[++phrases] = build_ast(CST(P++) /* G_lvalue_assign_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_conditional_expression */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_assignment_expression_opt */);
     return T[0] = G_mktuple(G_assignment_expression, alt, phrases, T);

//\\ P<rest-of-assignment-expression_opt> =
   case G_rest_of_assignment_expression_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <assignment_operator> <conditional_expression> <rest_of_assignment_expression_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_assignment_operator */);
       T[++phrases] = build_ast(CST(P++) /* G_conditional_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_assignment_expression_opt */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_assignment_expression_opt, alt, phrases, T);

//\\ P<conditional-expression> =
   case G_conditional_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <logical_or_expression> <rest_of_conditional_expression>;
     T[++phrases] = build_ast(CST(P++) /* G_logical_or_expression */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_conditional_expression */);
     return T[0] = G_mktuple(G_conditional_expression, alt, phrases, T);

//\\ P<rest-of-conditional-expression> =
   case G_rest_of_conditional_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '?' <expression> ':' <conditional_expression>,
       T[++phrases] = ch(CST(P++), '?');
       T[++phrases] = build_ast(CST(P++) /* G_expression */);
       T[++phrases] = ch(CST(P++), ':');
       T[++phrases] = build_ast(CST(P++) /* G_conditional_expression */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_conditional_expression, alt, phrases, T);

//\\ P<expression> =
   case G_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <comma_statement>;
     T[++phrases] = build_ast(CST(P++) /* G_comma_statement */);
     return T[0] = G_mktuple(G_expression, alt, phrases, T);

//\\ P<comma-statement> =
   case G_comma_statement:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <assignment_expression> <rest_of_comma_statement>;
     T[++phrases] = build_ast(CST(P++) /* G_assignment_expression */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_comma_statement */);
     return T[0] = G_mktuple(G_comma_statement, alt, phrases, T);

//\\ P<rest-of-comma-statement> =
   case G_rest_of_comma_statement:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    ',' <assignment_expression> <rest_of_comma_statement>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_assignment_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_comma_statement */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_comma_statement, alt, phrases, T);

//\\ P<logical-or-expression> =
   case G_logical_or_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <logical_and_expression> <rest_of_logical_or_expression>;
     T[++phrases] = build_ast(CST(P++) /* G_logical_and_expression */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_logical_or_expression */);
     return T[0] = G_mktuple(G_logical_or_expression, alt, phrases, T);

//\\ P<rest-of-logical-or-expression> =
   case G_rest_of_logical_or_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "||" <logical_and_expression> <rest_of_logical_or_expression>,
       T[++phrases] = kw(CST(P++), "||");
       T[++phrases] = build_ast(CST(P++) /* G_logical_and_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_logical_or_expression */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_logical_or_expression, alt, phrases, T);

//\\ P<logical-and-expression> =
   case G_logical_and_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <inclusive_or_expression> <rest_of_logical_and_expression>;
     T[++phrases] = build_ast(CST(P++) /* G_inclusive_or_expression */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_logical_and_expression */);
     return T[0] = G_mktuple(G_logical_and_expression, alt, phrases, T);

//\\ P<rest-of-logical-and-expression> =
   case G_rest_of_logical_and_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "&&" <inclusive_or_expression> <rest_of_logical_and_expression>,
       T[++phrases] = kw(CST(P++), "&&");
       T[++phrases] = build_ast(CST(P++) /* G_inclusive_or_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_logical_and_expression */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_logical_and_expression, alt, phrases, T);

//\\ P<inclusive-or-expression> =
   case G_inclusive_or_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <exclusive_or_expression> <rest_of_inclusive_or_expression>;
     T[++phrases] = build_ast(CST(P++) /* G_exclusive_or_expression */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_inclusive_or_expression */);
     return T[0] = G_mktuple(G_inclusive_or_expression, alt, phrases, T);

//\\ P<rest-of-inclusive-or-expression> =
   case G_rest_of_inclusive_or_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '|' <exclusive_or_expression> <rest_of_inclusive_or_expression>,
       T[++phrases] = ch(CST(P++), '|');
       T[++phrases] = build_ast(CST(P++) /* G_exclusive_or_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_inclusive_or_expression */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_inclusive_or_expression, alt, phrases, T);

//\\ P<exclusive-or-expression> =
   case G_exclusive_or_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <bitwise_and_expression> <rest_of_exclusive_or_expression>;
     T[++phrases] = build_ast(CST(P++) /* G_bitwise_and_expression */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_exclusive_or_expression */);
     return T[0] = G_mktuple(G_exclusive_or_expression, alt, phrases, T);

//\\ P<rest-of-exclusive-or-expression> =
   case G_rest_of_exclusive_or_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '^' <bitwise_and_expression> <rest_of_exclusive_or_expression>,
       T[++phrases] = ch(CST(P++), '^');
       T[++phrases] = build_ast(CST(P++) /* G_bitwise_and_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_exclusive_or_expression */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_exclusive_or_expression, alt, phrases, T);

//\\ P<bitwise-and-expression> =
   case G_bitwise_and_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <equality_expression> <rest_of_bitwise_and_expression>;
     T[++phrases] = build_ast(CST(P++) /* G_equality_expression */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_bitwise_and_expression */);
     return T[0] = G_mktuple(G_bitwise_and_expression, alt, phrases, T);

//\\ P<rest-of-bitwise-and-expression> =
   case G_rest_of_bitwise_and_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '&' <equality_expression> <rest_of_bitwise_and_expression>,
       T[++phrases] = ch(CST(P++), '&');
       T[++phrases] = build_ast(CST(P++) /* G_equality_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_bitwise_and_expression */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_bitwise_and_expression, alt, phrases, T);

//\\ P<equality-expression> =
   case G_equality_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <relational_expression> <rest_of_equality_expression>;
     T[++phrases] = build_ast(CST(P++) /* G_relational_expression */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_equality_expression */);
     return T[0] = G_mktuple(G_equality_expression, alt, phrases, T);

//\\ P<rest-of-equality-expression> =
   case G_rest_of_equality_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <eqop> <relational_expression> <rest_of_equality_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_eqop */);
       T[++phrases] = build_ast(CST(P++) /* G_relational_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_equality_expression */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_equality_expression, alt, phrases, T);

//\\ P<relational-expression> =
   case G_relational_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <shift_expression> <rest_of_relational_expression>;
     T[++phrases] = build_ast(CST(P++) /* G_shift_expression */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_relational_expression */);
     return T[0] = G_mktuple(G_relational_expression, alt, phrases, T);

//\\ P<rest-of-relational-expression> =
   case G_rest_of_relational_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <relop> <shift_expression> <rest_of_relational_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_relop */);
       T[++phrases] = build_ast(CST(P++) /* G_shift_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_relational_expression */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_relational_expression, alt, phrases, T);

//\\ P<shift-expression> =
   case G_shift_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <additive_expression> <rest_of_shift_expression>;
     T[++phrases] = build_ast(CST(P++) /* G_additive_expression */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_shift_expression */);
     return T[0] = G_mktuple(G_shift_expression, alt, phrases, T);

//\\ P<rest-of-shift-expression> =
   case G_rest_of_shift_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <shiftop> <additive_expression> <rest_of_shift_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_shiftop */);
       T[++phrases] = build_ast(CST(P++) /* G_additive_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_shift_expression */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_shift_expression, alt, phrases, T);

//\\ P<additive-expression> =
   case G_additive_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <multiplicative_expression> <rest_of_additive_expression>;
     T[++phrases] = build_ast(CST(P++) /* G_multiplicative_expression */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_additive_expression */);
     return T[0] = G_mktuple(G_additive_expression, alt, phrases, T);

//\\ P<rest-of-additive-expression> =
   case G_rest_of_additive_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <plusminus> <multiplicative_expression> <rest_of_additive_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_plusminus */);
       T[++phrases] = build_ast(CST(P++) /* G_multiplicative_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_additive_expression */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_additive_expression, alt, phrases, T);

//\\ P<multiplicative-expression> =
   case G_multiplicative_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <unary_rvalue_expression> <rest_of_multiplicative_expression>;
     T[++phrases] = build_ast(CST(P++) /* G_unary_rvalue_expression */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_multiplicative_expression */);
     return T[0] = G_mktuple(G_multiplicative_expression, alt, phrases, T);

//\\ P<rest-of-multiplicative-expression> =
   case G_rest_of_multiplicative_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <mulop> <unary_rvalue_expression> <rest_of_multiplicative_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_mulop */);
       T[++phrases] = build_ast(CST(P++) /* G_unary_rvalue_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_multiplicative_expression */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_multiplicative_expression, alt, phrases, T);

//\\ P<unary-rvalue-expression> =
   case G_unary_rvalue_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <cast_opt> <arithmetic_unary_op> <unary_rvalue_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_arithmetic_unary_op */);
       T[++phrases] = build_ast(CST(P++) /* G_unary_rvalue_expression */);
     } else if (alt == 1)        {  //\\    <cast_opt> <boolean_unary_ops> <unary_rvalue_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_boolean_unary_ops */);
       T[++phrases] = build_ast(CST(P++) /* G_unary_rvalue_expression */);
     } else if (alt == 2)        {  //\\    <cast_opt> <bitwise_unary_ops> <unary_rvalue_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_bitwise_unary_ops */);
       T[++phrases] = build_ast(CST(P++) /* G_unary_rvalue_expression */);
     } else if (alt == 3)        {  //\\    <indirection_unary_ops> <unary_address_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_indirection_unary_ops */);
       T[++phrases] = build_ast(CST(P++) /* G_unary_address_expression */);
     } else if (alt == 4)        {  //\\    <cast_opt> "sizeof" <unary_rvalue_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
       T[++phrases] = kw(CST(P++), "sizeof");
       T[++phrases] = build_ast(CST(P++) /* G_unary_rvalue_expression */);
     } else if (alt == 5)        {  //\\    <cast_opt> "sizeof" <unary_lvalue_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
       T[++phrases] = kw(CST(P++), "sizeof");
       T[++phrases] = build_ast(CST(P++) /* G_unary_lvalue_expression */);
     } else if (alt == 6)        {  //\\    <cast_opt> "sizeof" <type_specifier> <indirection_unary_ops_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
       T[++phrases] = kw(CST(P++), "sizeof");
       T[++phrases] = build_ast(CST(P++) /* G_type_specifier */);
       T[++phrases] = build_ast(CST(P++) /* G_indirection_unary_ops_opt */);
     } else if (alt == 7)        {  //\\    <cast_opt> "sizeof" '(' <type_specifier> <indirection_unary_ops_opt> ')',
       T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
       T[++phrases] = kw(CST(P++), "sizeof");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_type_specifier */);
       T[++phrases] = build_ast(CST(P++) /* G_indirection_unary_ops_opt */);
       T[++phrases] = ch(CST(P++), ')');
     } else                      {  //\\    <postfix_rvalue_expression>;
       T[++phrases] = build_ast(CST(P++) /* G_postfix_rvalue_expression */);
     }
     return T[0] = G_mktuple(G_unary_rvalue_expression, alt, phrases, T);

//\\ P<postfix-rvalue-expression> =
   case G_postfix_rvalue_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <primary_expression> <rest_of_postfix_rvalue_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_primary_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_postfix_rvalue_expression */);
     } else                      {  //\\    <unary_lvalue_expression> <rest_of_postfix_rvalue_expression>;
       T[++phrases] = build_ast(CST(P++) /* G_unary_lvalue_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_postfix_rvalue_expression */);
     }
     return T[0] = G_mktuple(G_postfix_rvalue_expression, alt, phrases, T);

//\\ P<rest-of-postfix-rvalue-expression> =
   case G_rest_of_postfix_rvalue_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '[' <HACK1> <expression> <HACK2> ']' <rest_of_postfix_rvalue_expression>,
       T[++phrases] = ch(CST(P++), '[');
       T[++phrases] = build_ast(CST(P++) /* G_HACK1 */);
       T[++phrases] = build_ast(CST(P++) /* G_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_HACK2 */);
       T[++phrases] = ch(CST(P++), ']');
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_postfix_rvalue_expression */);
     } else if (alt == 1)        {  //\\    '(' <actual_param_list> ')' <rest_of_postfix_rvalue_expression>,
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_actual_param_list */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_postfix_rvalue_expression */);
     } else if (alt == 2)        {  //\\    '.' <tag> <rest_of_postfix_rvalue_expression>,
       T[++phrases] = ch(CST(P++), '.');
       T[++phrases] = build_ast(CST(P++) /* G_tag */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_postfix_rvalue_expression */);
     } else if (alt == 3)        {  //\\    "->" <tag> <rest_of_postfix_rvalue_expression>,
       T[++phrases] = kw(CST(P++), "->");
       T[++phrases] = build_ast(CST(P++) /* G_tag */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_postfix_rvalue_expression */);
     } else if (alt == 4)        {  //\\    <post_increment_op> <rest_of_postfix_rvalue_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_post_increment_op */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_postfix_rvalue_expression */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_postfix_rvalue_expression, alt, phrases, T);

//\\ P<post-increment-op> =
   case G_post_increment_op:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "++",
       T[++phrases] = kw(CST(P++), "++");
     } else                      {  //\\    "--";
       T[++phrases] = kw(CST(P++), "--");
     }
     return T[0] = G_mktuple(G_post_increment_op, alt, phrases, T);

//\\ P<actual-param-list> =
   case G_actual_param_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <assignment_expression> <rest_of_param_list>,
       T[++phrases] = build_ast(CST(P++) /* G_assignment_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_param_list */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_actual_param_list, alt, phrases, T);

//\\ P<rest-of-param-list> =
   case G_rest_of_param_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    ',' <assignment_expression> <rest_of_param_list>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_assignment_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_param_list */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_param_list, alt, phrases, T);

//\\ P<unary-lvalue-expression> =
   case G_unary_lvalue_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <cast_opt> <pre_increment_op> <unary_lvalue_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_pre_increment_op */);
       T[++phrases] = build_ast(CST(P++) /* G_unary_lvalue_expression */);
     } else if (alt == 1)        {  //\\    <indirection_unary_ops> <unary_lvalue_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_indirection_unary_ops */);
       T[++phrases] = build_ast(CST(P++) /* G_unary_lvalue_expression */);
     } else if (alt == 2)        {  //\\    <unary_address_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_unary_address_expression */);
     } else                      {  //\\    <postfix_lvalue_expression>;
       T[++phrases] = build_ast(CST(P++) /* G_postfix_lvalue_expression */);
     }
     return T[0] = G_mktuple(G_unary_lvalue_expression, alt, phrases, T);

//\\ P<postfix-lvalue-expression> =
   case G_postfix_lvalue_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <primary_expression> <rest_of_postfix_expression>;
     T[++phrases] = build_ast(CST(P++) /* G_primary_expression */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_postfix_expression */);
     return T[0] = G_mktuple(G_postfix_lvalue_expression, alt, phrases, T);

//\\ P<rest-of-postfix-expression> =
   case G_rest_of_postfix_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '[' <HACK1> <expression> <HACK2> ']' <rest_of_postfix_expression>,
       T[++phrases] = ch(CST(P++), '[');
       T[++phrases] = build_ast(CST(P++) /* G_HACK1 */);
       T[++phrases] = build_ast(CST(P++) /* G_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_HACK2 */);
       T[++phrases] = ch(CST(P++), ']');
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_postfix_expression */);
     } else if (alt == 1)        {  //\\    '(' <actual_param_list> ')' <non_empty_rest_of_postfix_expression>,
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_actual_param_list */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = build_ast(CST(P++) /* G_non_empty_rest_of_postfix_expression */);
     } else if (alt == 2)        {  //\\    '.' <tag> <rest_of_postfix_expression>,
       T[++phrases] = ch(CST(P++), '.');
       T[++phrases] = build_ast(CST(P++) /* G_tag */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_postfix_expression */);
     } else if (alt == 3)        {  //\\    "->" <tag> <rest_of_postfix_expression>,
       T[++phrases] = kw(CST(P++), "->");
       T[++phrases] = build_ast(CST(P++) /* G_tag */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_postfix_expression */);
     } else if (alt == 4)        {  //\\    <post_increment_op> <rest_of_postfix_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_post_increment_op */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_postfix_expression */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_postfix_expression, alt, phrases, T);

//\\ P<non-empty-rest-of-postfix-expression> =
   case G_non_empty_rest_of_postfix_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '[' <HACK1> <expression> <HACK2> ']' <rest_of_postfix_expression>,
       T[++phrases] = ch(CST(P++), '[');
       T[++phrases] = build_ast(CST(P++) /* G_HACK1 */);
       T[++phrases] = build_ast(CST(P++) /* G_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_HACK2 */);
       T[++phrases] = ch(CST(P++), ']');
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_postfix_expression */);
     } else if (alt == 1)        {  //\\    '(' <actual_param_list> ')' <non_empty_rest_of_postfix_expression>,
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_actual_param_list */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = build_ast(CST(P++) /* G_non_empty_rest_of_postfix_expression */);
     } else if (alt == 2)        {  //\\    '.' <tag> <rest_of_postfix_expression>,
       T[++phrases] = ch(CST(P++), '.');
       T[++phrases] = build_ast(CST(P++) /* G_tag */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_postfix_expression */);
     } else if (alt == 3)        {  //\\    "->" <tag> <rest_of_postfix_expression>,
       T[++phrases] = kw(CST(P++), "->");
       T[++phrases] = build_ast(CST(P++) /* G_tag */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_postfix_expression */);
     } else                      {  //\\    <post_increment_op> <rest_of_postfix_expression>;
       T[++phrases] = build_ast(CST(P++) /* G_post_increment_op */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_postfix_expression */);
     }
     return T[0] = G_mktuple(G_non_empty_rest_of_postfix_expression, alt, phrases, T);

//\\ P<unary-address-expression> =
   case G_unary_address_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <cast_opt> <address_operator> <unary_lvalue_expression>;
     T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_address_operator */);
     T[++phrases] = build_ast(CST(P++) /* G_unary_lvalue_expression */);
     return T[0] = G_mktuple(G_unary_address_expression, alt, phrases, T);

//\\ P<primary-expression> =
   case G_primary_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <cast_opt> <identifier>,
       T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_identifier */);
     } else if (alt == 1)        {  //\\    <cast_opt> <constant>,
       T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_constant */);
     } else if (alt == 2)        {  //\\    <cast_opt> <dqstring>,
       T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_dqstring */);
     } else if (alt == 3)        {  //\\    '(' <expression> ')',
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_expression */);
       T[++phrases] = ch(CST(P++), ')');
     } else if (alt == 4)        {  //\\    <cast> '(' <expression> ')',
       T[++phrases] = build_ast(CST(P++) /* G_cast */);
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_expression */);
       T[++phrases] = ch(CST(P++), ')');
     } else if (alt == 5)        {  //\\    <cast> <cast> '(' <expression> ')',
       T[++phrases] = build_ast(CST(P++) /* G_cast */);
       T[++phrases] = build_ast(CST(P++) /* G_cast */);
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_expression */);
       T[++phrases] = ch(CST(P++), ')');
     } else if (alt == 6)        {  //\\    <cast> <cast> <cast> '(' <expression> ')',
       T[++phrases] = build_ast(CST(P++) /* G_cast */);
       T[++phrases] = build_ast(CST(P++) /* G_cast */);
       T[++phrases] = build_ast(CST(P++) /* G_cast */);
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_expression */);
       T[++phrases] = ch(CST(P++), ')');
     } else                      {  //\\    <cast> <cast> <cast> <cast> '(' <expression> ')';
       T[++phrases] = build_ast(CST(P++) /* G_cast */);
       T[++phrases] = build_ast(CST(P++) /* G_cast */);
       T[++phrases] = build_ast(CST(P++) /* G_cast */);
       T[++phrases] = build_ast(CST(P++) /* G_cast */);
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_expression */);
       T[++phrases] = ch(CST(P++), ')');
     }
     return T[0] = G_mktuple(G_primary_expression, alt, phrases, T);

//\\ P<cast_opt> =
   case G_cast_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <cast> <cast_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_cast */);
       T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_cast_opt, alt, phrases, T);

//\\ P<cast> =
   case G_cast:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '(' <type_specifier> <indirection_unary_ops_opt> ')',
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_type_specifier */);
       T[++phrases] = build_ast(CST(P++) /* G_indirection_unary_ops_opt */);
       T[++phrases] = ch(CST(P++), ')');
     } else if (alt == 1)        {  //\\    '(' "typeof" '(' <unary_lvalue_expression> ')' ')',
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = kw(CST(P++), "typeof");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_unary_lvalue_expression */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = ch(CST(P++), ')');
     } else                      {  //\\    '(' "typeof" '(' <type_specifier> <indirection_unary_ops_opt> ')' ')';
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = kw(CST(P++), "typeof");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_type_specifier */);
       T[++phrases] = build_ast(CST(P++) /* G_indirection_unary_ops_opt */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = ch(CST(P++), ')');
     }
     return T[0] = G_mktuple(G_cast, alt, phrases, T);

//\\ P<indirection-decl_opt> =
   case G_indirection_decl_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <const_or_volatile_type_qualifier_opt> '*' <indirection_decl_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_const_or_volatile_type_qualifier_opt */);
       T[++phrases] = ch(CST(P++), '*');
       T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_indirection_decl_opt, alt, phrases, T);

//\\ P<indirection-unary-ops> =
   case G_indirection_unary_ops:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <cast_opt> '*' <indirection_unary_ops_opt>;
     T[++phrases] = build_ast(CST(P++) /* G_cast_opt */);
     T[++phrases] = ch(CST(P++), '*');
     T[++phrases] = build_ast(CST(P++) /* G_indirection_unary_ops_opt */);
     return T[0] = G_mktuple(G_indirection_unary_ops, alt, phrases, T);

//\\ P<indirection-unary-ops_opt> =
   case G_indirection_unary_ops_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '*' <indirection_unary_ops_opt>,
       T[++phrases] = ch(CST(P++), '*');
       T[++phrases] = build_ast(CST(P++) /* G_indirection_unary_ops_opt */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_indirection_unary_ops_opt, alt, phrases, T);

//\\ P<type-specifier> =
   case G_type_specifier:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <basic_type_specifier>,
       T[++phrases] = build_ast(CST(P++) /* G_basic_type_specifier */);
     } else                      {  //\\    <typedef_name>;
       T[++phrases] = build_ast(CST(P++) /* G_typedef_name */);
     }
     return T[0] = G_mktuple(G_type_specifier, alt, phrases, T);

//\\ P<typedef-name> =
   case G_typedef_name:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <identifier>;
     T[++phrases] = build_ast(CST(P++) /* G_identifier */);
     return T[0] = G_mktuple(G_typedef_name, alt, phrases, T);

//\\ P<basic-type-specifier> =
   case G_basic_type_specifier:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "void",
       T[++phrases] = kw(CST(P++), "void");
     } else if (alt == 1)        {  //\\    "double",
       T[++phrases] = kw(CST(P++), "double");
     } else if (alt == 2)        {  //\\    "long" "double",
       T[++phrases] = kw(CST(P++), "long");
       T[++phrases] = kw(CST(P++), "double");
     } else if (alt == 3)        {  //\\    "float",
       T[++phrases] = kw(CST(P++), "float");
     } else if (alt == 4)        {  //\\    <signed_opt> "char",
       T[++phrases] = build_ast(CST(P++) /* G_signed_opt */);
       T[++phrases] = kw(CST(P++), "char");
     } else if (alt == 5)        {  //\\    <signed_inttype>,
       T[++phrases] = build_ast(CST(P++) /* G_signed_inttype */);
     } else if (alt == 6)        {  //\\    <struct_or_union_specifier>,
       T[++phrases] = build_ast(CST(P++) /* G_struct_or_union_specifier */);
     } else                      {  //\\    <enum_specifier>;
       T[++phrases] = build_ast(CST(P++) /* G_enum_specifier */);
     }
     return T[0] = G_mktuple(G_basic_type_specifier, alt, phrases, T);

//\\ P<enum-specifier> =
   case G_enum_specifier:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "enum" '{' <enumerator_list> '}',
       T[++phrases] = kw(CST(P++), "enum");
       T[++phrases] = ch(CST(P++), '{');
       T[++phrases] = build_ast(CST(P++) /* G_enumerator_list */);
       T[++phrases] = ch(CST(P++), '}');
     } else if (alt == 1)        {  //\\    "enum" <identifier> '{' <enumerator_list> '}',
       T[++phrases] = kw(CST(P++), "enum");
       T[++phrases] = build_ast(CST(P++) /* G_identifier */);
       T[++phrases] = ch(CST(P++), '{');
       T[++phrases] = build_ast(CST(P++) /* G_enumerator_list */);
       T[++phrases] = ch(CST(P++), '}');
     } else                      {  //\\    "enum" <identifier>;
       T[++phrases] = kw(CST(P++), "enum");
       T[++phrases] = build_ast(CST(P++) /* G_identifier */);
     }
     return T[0] = G_mktuple(G_enum_specifier, alt, phrases, T);

//\\ P<enumerator-list> =
   case G_enumerator_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <enumerator> <rest_of_enumerator_list>;
     T[++phrases] = build_ast(CST(P++) /* G_enumerator */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_enumerator_list */);
     return T[0] = G_mktuple(G_enumerator_list, alt, phrases, T);

//\\ P<rest-of-enumerator-list> =
   case G_rest_of_enumerator_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    ',' <enumerator> <rest_of_enumerator_list>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_enumerator */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_enumerator_list */);
     } else if (alt == 1)        {  //\\    ',',
       T[++phrases] = ch(CST(P++), ',');
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_enumerator_list, alt, phrases, T);

//\\ P<enumerator> =
   case G_enumerator:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <identifier> '=' <constant_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_identifier */);
       T[++phrases] = ch(CST(P++), '=');
       T[++phrases] = build_ast(CST(P++) /* G_constant_expression */);
     } else                      {  //\\    <identifier>;
       T[++phrases] = build_ast(CST(P++) /* G_identifier */);
     }
     return T[0] = G_mktuple(G_enumerator, alt, phrases, T);

//\\ P<constant-expression> =
   case G_constant_expression:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <conditional_expression>;
     T[++phrases] = build_ast(CST(P++) /* G_conditional_expression */);
     return T[0] = G_mktuple(G_constant_expression, alt, phrases, T);

//\\ P<signed-inttype> =
   case G_signed_inttype:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <signed_opt> "short" <int_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_signed_opt */);
       T[++phrases] = kw(CST(P++), "short");
       T[++phrases] = build_ast(CST(P++) /* G_int_opt */);
     } else if (alt == 1)        {  //\\    <signed_opt> "long" "long" <int_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_signed_opt */);
       T[++phrases] = kw(CST(P++), "long");
       T[++phrases] = kw(CST(P++), "long");
       T[++phrases] = build_ast(CST(P++) /* G_int_opt */);
     } else if (alt == 2)        {  //\\    <signed_opt> "long" <int_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_signed_opt */);
       T[++phrases] = kw(CST(P++), "long");
       T[++phrases] = build_ast(CST(P++) /* G_int_opt */);
     } else if (alt == 3)        {  //\\    <signed_opt> "int",
       T[++phrases] = build_ast(CST(P++) /* G_signed_opt */);
       T[++phrases] = kw(CST(P++), "int");
     } else if (alt == 4)        {  //\\    "signed",
       T[++phrases] = kw(CST(P++), "signed");
     } else                      {  //\\    "unsigned";
       T[++phrases] = kw(CST(P++), "unsigned");
     }
     return T[0] = G_mktuple(G_signed_inttype, alt, phrases, T);

//\\ P<int_opt> =
   case G_int_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "int",
       T[++phrases] = kw(CST(P++), "int");
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_int_opt, alt, phrases, T);

//\\ P<signed_opt> =
   case G_signed_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "signed",
       T[++phrases] = kw(CST(P++), "signed");
     } else if (alt == 1)        {  //\\    "unsigned",
       T[++phrases] = kw(CST(P++), "unsigned");
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_signed_opt, alt, phrases, T);

//\\ P<address-operator> =
   case G_address_operator:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "&&",
       T[++phrases] = kw(CST(P++), "&&");
     } else                      {  //\\    '&';
       T[++phrases] = ch(CST(P++), '&');
     }
     return T[0] = G_mktuple(G_address_operator, alt, phrases, T);

//\\ P<pre-increment-op> =
   case G_pre_increment_op:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "++",
       T[++phrases] = kw(CST(P++), "++");
     } else                      {  //\\    "--";
       T[++phrases] = kw(CST(P++), "--");
     }
     return T[0] = G_mktuple(G_pre_increment_op, alt, phrases, T);

//\\ P<bitwise-unary-ops> =
   case G_bitwise_unary_ops:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    '~' <rest_of_bitwise_unary_ops>;
     T[++phrases] = ch(CST(P++), '~');
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_bitwise_unary_ops */);
     return T[0] = G_mktuple(G_bitwise_unary_ops, alt, phrases, T);

//\\ P<rest-of-bitwise-unary-ops> =
   case G_rest_of_bitwise_unary_ops:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '~' <rest_of_bitwise_unary_ops>,
       T[++phrases] = ch(CST(P++), '~');
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_bitwise_unary_ops */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_bitwise_unary_ops, alt, phrases, T);

//\\ P<boolean-unary-ops> =
   case G_boolean_unary_ops:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    '!' <rest_of_boolean_unary_ops>;
     T[++phrases] = ch(CST(P++), '!');
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_boolean_unary_ops */);
     return T[0] = G_mktuple(G_boolean_unary_ops, alt, phrases, T);

//\\ P<rest-of-boolean-unary-ops> =
   case G_rest_of_boolean_unary_ops:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '!' <rest_of_boolean_unary_ops>,
       T[++phrases] = ch(CST(P++), '!');
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_boolean_unary_ops */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_boolean_unary_ops, alt, phrases, T);

//\\ P<arithmetic-unary-op> =
   case G_arithmetic_unary_op:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '+',
       T[++phrases] = ch(CST(P++), '+');
     } else                      {  //\\    '-';
       T[++phrases] = ch(CST(P++), '-');
     }
     return T[0] = G_mktuple(G_arithmetic_unary_op, alt, phrases, T);

//\\ P<mulop> =
   case G_mulop:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '*',
       T[++phrases] = ch(CST(P++), '*');
     } else if (alt == 1)        {  //\\    '/',
       T[++phrases] = ch(CST(P++), '/');
     } else                      {  //\\    '%';
       T[++phrases] = ch(CST(P++), '%');
     }
     return T[0] = G_mktuple(G_mulop, alt, phrases, T);

//\\ P<plusminus> =
   case G_plusminus:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '+',
       T[++phrases] = ch(CST(P++), '+');
     } else                      {  //\\    '-';
       T[++phrases] = ch(CST(P++), '-');
     }
     return T[0] = G_mktuple(G_plusminus, alt, phrases, T);

//\\ P<shiftop> =
   case G_shiftop:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "<<",
       T[++phrases] = kw(CST(P++), "<<");
     } else                      {  //\\    ">>";
       T[++phrases] = kw(CST(P++), ">>");
     }
     return T[0] = G_mktuple(G_shiftop, alt, phrases, T);

//\\ P<relop> =
   case G_relop:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "<=",
       T[++phrases] = kw(CST(P++), "<=");
     } else if (alt == 1)        {  //\\    '<',
       T[++phrases] = ch(CST(P++), '<');
     } else if (alt == 2)        {  //\\    ">=",
       T[++phrases] = kw(CST(P++), ">=");
     } else                      {  //\\    '>';
       T[++phrases] = ch(CST(P++), '>');
     }
     return T[0] = G_mktuple(G_relop, alt, phrases, T);

//\\ P<eqop> =
   case G_eqop:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "==",
       T[++phrases] = kw(CST(P++), "==");
     } else                      {  //\\    "!=";
       T[++phrases] = kw(CST(P++), "!=");
     }
     return T[0] = G_mktuple(G_eqop, alt, phrases, T);

//\\ P<eq> =
   case G_eq:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    '=';
     T[++phrases] = ch(CST(P++), '=');
     return T[0] = G_mktuple(G_eq, alt, phrases, T);

//\\ P<assignment-operator> =
   case G_assignment_operator:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '=' <!eq>,
       T[++phrases] = ch(CST(P++), '=');
       T[++phrases] = -1 +(0 * P++);
     } else if (alt == 1)        {  //\\    "*=",
       T[++phrases] = kw(CST(P++), "*=");
     } else if (alt == 2)        {  //\\    "/=",
       T[++phrases] = kw(CST(P++), "/=");
     } else if (alt == 3)        {  //\\    "%=",
       T[++phrases] = kw(CST(P++), "%=");
     } else if (alt == 4)        {  //\\    "+=",
       T[++phrases] = kw(CST(P++), "+=");
     } else if (alt == 5)        {  //\\    "-=",
       T[++phrases] = kw(CST(P++), "-=");
     } else if (alt == 6)        {  //\\    "<<=",
       T[++phrases] = kw(CST(P++), "<<=");
     } else if (alt == 7)        {  //\\    ">>=",
       T[++phrases] = kw(CST(P++), ">>=");
     } else if (alt == 8)        {  //\\    "&=",
       T[++phrases] = kw(CST(P++), "&=");
     } else if (alt == 9)        {  //\\    "^=",
       T[++phrases] = kw(CST(P++), "^=");
     } else                      {  //\\    "|=";
       T[++phrases] = kw(CST(P++), "|=");
     }
     return T[0] = G_mktuple(G_assignment_operator, alt, phrases, T);

//\\ P<lvalue-assign_opt> =
   case G_lvalue_assign_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <unary_lvalue_expression> <assignment_operator>,
       T[++phrases] = build_ast(CST(P++) /* G_unary_lvalue_expression */);
       T[++phrases] = build_ast(CST(P++) /* G_assignment_operator */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_lvalue_assign_opt, alt, phrases, T);

//\\ P<array-init_opt> =
   case G_array_init_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '=' '{' <constant_initializer_list> '}',
       T[++phrases] = ch(CST(P++), '=');
       T[++phrases] = ch(CST(P++), '{');
       T[++phrases] = build_ast(CST(P++) /* G_constant_initializer_list */);
       T[++phrases] = ch(CST(P++), '}');
     } else if (alt == 1)        {  //\\    '=' <dqstring>,
       T[++phrases] = ch(CST(P++), '=');
       T[++phrases] = build_ast(CST(P++) /* G_dqstring */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_array_init_opt, alt, phrases, T);

//\\ P<constant-initializer-list> =
   case G_constant_initializer_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <constant_initializer> <rest_of_constant_initializer_list>;
     T[++phrases] = build_ast(CST(P++) /* G_constant_initializer */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_constant_initializer_list */);
     return T[0] = G_mktuple(G_constant_initializer_list, alt, phrases, T);

//\\ P<rest-of-constant-initializer-list> =
   case G_rest_of_constant_initializer_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    ',' <constant_initializer> <rest_of_constant_initializer_list>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_constant_initializer */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_constant_initializer_list */);
     } else if (alt == 1)        {  //\\    ',',
       T[++phrases] = ch(CST(P++), ',');
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_constant_initializer_list, alt, phrases, T);

//\\ P<constant-initializer> =
   case G_constant_initializer:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <constant_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_constant_expression */);
     } else                      {  //\\    '{' <constant_initializer_list> '}';
       T[++phrases] = ch(CST(P++), '{');
       T[++phrases] = build_ast(CST(P++) /* G_constant_initializer_list */);
       T[++phrases] = ch(CST(P++), '}');
     }
     return T[0] = G_mktuple(G_constant_initializer, alt, phrases, T);

//\\ P<HACK1> =
   case G_HACK1:
#if defined(NOT_SURE) || defined(BUILDING_CST)

   //fprintf(stdout, "/*hack1*/");

#endif
                                    //\\    ;
     return T[0] = G_mktuple(G_HACK1, alt, phrases, T);

//\\ P<HACK2> =
   case G_HACK2:
#if defined(NOT_SURE) || defined(BUILDING_CST)

   //fprintf(stdout, "/*hack2*/");

#endif
                                    //\\    ;
     return T[0] = G_mktuple(G_HACK2, alt, phrases, T);

//\\ P<array-bounds> =
   case G_array_bounds:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    '[' <HACK1> <constant_expression_opt> <HACK2> ']' <array_bounds_opt>;
     T[++phrases] = ch(CST(P++), '[');
     T[++phrases] = build_ast(CST(P++) /* G_HACK1 */);
     T[++phrases] = build_ast(CST(P++) /* G_constant_expression_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_HACK2 */);
     T[++phrases] = ch(CST(P++), ']');
     T[++phrases] = build_ast(CST(P++) /* G_array_bounds_opt */);
     return T[0] = G_mktuple(G_array_bounds, alt, phrases, T);

//\\ P<array-bounds_opt> =
   case G_array_bounds_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '[' <HACK1> <constant_expression_opt> <HACK2> ']' <array_bounds_opt>,
       T[++phrases] = ch(CST(P++), '[');
       T[++phrases] = build_ast(CST(P++) /* G_HACK1 */);
       T[++phrases] = build_ast(CST(P++) /* G_constant_expression_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_HACK2 */);
       T[++phrases] = ch(CST(P++), ']');
       T[++phrases] = build_ast(CST(P++) /* G_array_bounds_opt */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_array_bounds_opt, alt, phrases, T);

//\\ P<constant-expression_opt> =
   case G_constant_expression_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <constant_expression>,
       T[++phrases] = build_ast(CST(P++) /* G_constant_expression */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_constant_expression_opt, alt, phrases, T);

//\\ P<type> =
   case G_type:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <type_specifier>,
       T[++phrases] = build_ast(CST(P++) /* G_type_specifier */);
     } else if (alt == 1)        {  //\\    <enum_specifier>,
       T[++phrases] = build_ast(CST(P++) /* G_enum_specifier */);
     } else if (alt == 2)        {  //\\    <struct_or_union_specifier>,
       T[++phrases] = build_ast(CST(P++) /* G_struct_or_union_specifier */);
     } else if (alt == 3)        {  //\\    "typeof" '(' <unary_lvalue_expression> ')',
       T[++phrases] = kw(CST(P++), "typeof");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_unary_lvalue_expression */);
       T[++phrases] = ch(CST(P++), ')');
     } else if (alt == 4)        {  //\\    "typeof" '(' <type_specifier> <indirection_unary_ops_opt> ')',
       T[++phrases] = kw(CST(P++), "typeof");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_type_specifier */);
       T[++phrases] = build_ast(CST(P++) /* G_indirection_unary_ops_opt */);
       T[++phrases] = ch(CST(P++), ')');
     } else                      {  //\\    "void";
       T[++phrases] = kw(CST(P++), "void");
     }
     return T[0] = G_mktuple(G_type, alt, phrases, T);

//\\ P<const-or-volatile-type-qualifier_opt> =
   case G_const_or_volatile_type_qualifier_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <const_or_volatile_type_qualifier>,
       T[++phrases] = build_ast(CST(P++) /* G_const_or_volatile_type_qualifier */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_const_or_volatile_type_qualifier_opt, alt, phrases, T);

//\\ P<const-or-volatile-type-qualifier> =
   case G_const_or_volatile_type_qualifier:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "const",
       T[++phrases] = kw(CST(P++), "const");
     } else                      {  //\\    "volatile";
       T[++phrases] = kw(CST(P++), "volatile");
     }
     return T[0] = G_mktuple(G_const_or_volatile_type_qualifier, alt, phrases, T);

//\\ P<auto-reg-static-ext_opt> =
   case G_auto_reg_static_ext_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "auto",
       T[++phrases] = kw(CST(P++), "auto");
     } else if (alt == 1)        {  //\\    "register",
       T[++phrases] = kw(CST(P++), "register");
     } else if (alt == 2)        {  //\\    "static",
       T[++phrases] = kw(CST(P++), "static");
     } else if (alt == 3)        {  //\\    "extern",
       T[++phrases] = kw(CST(P++), "extern");
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_auto_reg_static_ext_opt, alt, phrases, T);

//\\ P<identifier-list> =
   case G_identifier_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <new_identifier> <rest_of_identifier_list>;
     T[++phrases] = build_ast(CST(P++) /* G_new_identifier */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_identifier_list */);
     return T[0] = G_mktuple(G_identifier_list, alt, phrases, T);

//\\ P<rest-of-identifier-list> =
   case G_rest_of_identifier_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    ',' <identifier_list>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_identifier_list */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_identifier_list, alt, phrases, T);

//\\ P<more-forward-decls-or-actual-body> =
   case G_more_forward_decls_or_actual_body:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <extern_proc_name_and_params_list_opt> ';',
       T[++phrases] = build_ast(CST(P++) /* G_extern_proc_name_and_params_list_opt */);
       T[++phrases] = ch(CST(P++), ';');
     } else                      {  //\\    <compound_statement>;
       T[++phrases] = build_ast(CST(P++) /* G_compound_statement */);
     }
     return T[0] = G_mktuple(G_more_forward_decls_or_actual_body, alt, phrases, T);

//\\ P<extern-proc-spec> =
   case G_extern_proc_spec:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <auto_reg_static_ext_opt> <const_or_volatile_type_qualifier_opt> <basic_type_specifier_or_typedef_name_opt>;
     T[++phrases] = build_ast(CST(P++) /* G_auto_reg_static_ext_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_const_or_volatile_type_qualifier_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_basic_type_specifier_or_typedef_name_opt */);
     return T[0] = G_mktuple(G_extern_proc_spec, alt, phrases, T);

//\\ P<basic-type-specifier-or-typedef-name_opt> =
   case G_basic_type_specifier_or_typedef_name_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <typedef_name>,
       T[++phrases] = build_ast(CST(P++) /* G_typedef_name */);
     } else                      {  //\\    <basic_type_specifier_opt>;
       T[++phrases] = build_ast(CST(P++) /* G_basic_type_specifier_opt */);
     }
     return T[0] = G_mktuple(G_basic_type_specifier_or_typedef_name_opt, alt, phrases, T);

//\\ P<identifier-or-function-pointer> =
   case G_identifier_or_function_pointer:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '(' '*' <new_identifier> ')',
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = ch(CST(P++), '*');
       T[++phrases] = build_ast(CST(P++) /* G_new_identifier */);
       T[++phrases] = ch(CST(P++), ')');
     } else                      {  //\\    <new_identifier>;
       T[++phrases] = build_ast(CST(P++) /* G_new_identifier */);
     }
     return T[0] = G_mktuple(G_identifier_or_function_pointer, alt, phrases, T);

//\\ P<extern-proc-name-and-params> =
   case G_extern_proc_name_and_params:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <indirection_decl_opt> <identifier_or_function_pointer> '(' <param_list_opt> ')';
     T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_identifier_or_function_pointer */);
     T[++phrases] = ch(CST(P++), '(');
     T[++phrases] = build_ast(CST(P++) /* G_param_list_opt */);
     T[++phrases] = ch(CST(P++), ')');
     return T[0] = G_mktuple(G_extern_proc_name_and_params, alt, phrases, T);

//\\ P<extern-proc-name-and-params-list_opt> =
   case G_extern_proc_name_and_params_list_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    ',' <extern_proc_name_and_params> <extern_proc_name_and_params_list_opt>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_extern_proc_name_and_params */);
       T[++phrases] = build_ast(CST(P++) /* G_extern_proc_name_and_params_list_opt */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_extern_proc_name_and_params_list_opt, alt, phrases, T);

//\\ P<proc-fn-decl> =
   case G_proc_fn_decl:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <extern_proc_spec> <extern_proc_name_and_params> <more_forward_decls_or_actual_body>,
       T[++phrases] = build_ast(CST(P++) /* G_extern_proc_spec */);
       T[++phrases] = build_ast(CST(P++) /* G_extern_proc_name_and_params */);
       T[++phrases] = build_ast(CST(P++) /* G_more_forward_decls_or_actual_body */);
     } else                      {  //\\    <extern_proc_spec> <indirection_decl_opt> <new_identifier> '(' <identifier_list> ')' <oldstyle_param_list_opt> ';' <compound_statement>;
       T[++phrases] = build_ast(CST(P++) /* G_extern_proc_spec */);
       T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_new_identifier */);
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_identifier_list */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = build_ast(CST(P++) /* G_oldstyle_param_list_opt */);
       T[++phrases] = ch(CST(P++), ';');
       T[++phrases] = build_ast(CST(P++) /* G_compound_statement */);
     }
     return T[0] = G_mktuple(G_proc_fn_decl, alt, phrases, T);

//\\ P<compound-statement> =
   case G_compound_statement:
#if defined(NOT_SURE) || defined(BUILDING_CST)

   //fprintf(stdout, "\n");

#endif
     if (alt == 0)               {  //\\    '{' '}',
       T[++phrases] = ch(CST(P++), '{');
       T[++phrases] = ch(CST(P++), '}');
     } else                      {  //\\    '{' <statement_list> '}';
       T[++phrases] = ch(CST(P++), '{');
       T[++phrases] = build_ast(CST(P++) /* G_statement_list */);
       T[++phrases] = ch(CST(P++), '}');
     }
     return T[0] = G_mktuple(G_compound_statement, alt, phrases, T);

//\\ P<statement-list> =
   case G_statement_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <labels_opt> <statement> <rest_of_statement_list>;
     T[++phrases] = build_ast(CST(P++) /* G_labels_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_statement */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_statement_list */);
     return T[0] = G_mktuple(G_statement_list, alt, phrases, T);

//\\ P<rest-of-statement-list> =
   case G_rest_of_statement_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <labels_opt> <statement> <rest_of_statement_list>,
       T[++phrases] = build_ast(CST(P++) /* G_labels_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_statement */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_statement_list */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_statement_list, alt, phrases, T);

//\\ P<statement> =
   case G_statement:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    ';',
       T[++phrases] = ch(CST(P++), ';');
     } else if (alt == 1)        {  //\\    <compound_statement>,
       T[++phrases] = build_ast(CST(P++) /* G_compound_statement */);
     } else if (alt == 2)        {  //\\    <selection_statement>,
       T[++phrases] = build_ast(CST(P++) /* G_selection_statement */);
     } else if (alt == 3)        {  //\\    <iteration_statement>,
       T[++phrases] = build_ast(CST(P++) /* G_iteration_statement */);
     } else if (alt == 4)        {  //\\    <jump_statement>,
       T[++phrases] = build_ast(CST(P++) /* G_jump_statement */);
     } else if (alt == 5)        {  //\\    <expression> ';',
       T[++phrases] = build_ast(CST(P++) /* G_expression */);
       T[++phrases] = ch(CST(P++), ';');
     } else if (alt == 6)        {  //\\    <extern_proc_spec> <extern_proc_name_and_params> <more_forward_decls_or_actual_body>,
       T[++phrases] = build_ast(CST(P++) /* G_extern_proc_spec */);
       T[++phrases] = build_ast(CST(P++) /* G_extern_proc_name_and_params */);
       T[++phrases] = build_ast(CST(P++) /* G_more_forward_decls_or_actual_body */);
     } else if (alt == 7)        {  //\\    <in_proc_data_declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_in_proc_data_declaration */);
     } else                      {  //\\    <external_declaration_list>;
       T[++phrases] = build_ast(CST(P++) /* G_external_declaration_list */);
     }
     return T[0] = G_mktuple(G_statement, alt, phrases, T);

//\\ P<in-proc-data-declaration> =
   case G_in_proc_data_declaration:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <auto_reg_static_ext_opt> <const_or_volatile_type_qualifier_opt> <type> <const_or_volatile_type_qualifier_opt> <decl_list>,
       T[++phrases] = build_ast(CST(P++) /* G_auto_reg_static_ext_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_const_or_volatile_type_qualifier_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_type */);
       T[++phrases] = build_ast(CST(P++) /* G_const_or_volatile_type_qualifier_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_decl_list */);
     } else                      {  //\\    <struct_decl>;
       T[++phrases] = build_ast(CST(P++) /* G_struct_decl */);
     }
     return T[0] = G_mktuple(G_in_proc_data_declaration, alt, phrases, T);

//\\ P<struct-decl> =
   case G_struct_decl:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    "struct" <new_structname> '{' <struct_member_list> '}';
     T[++phrases] = kw(CST(P++), "struct");
     T[++phrases] = build_ast(CST(P++) /* G_new_structname */);
     T[++phrases] = ch(CST(P++), '{');
     T[++phrases] = build_ast(CST(P++) /* G_struct_member_list */);
     T[++phrases] = ch(CST(P++), '}');
     return T[0] = G_mktuple(G_struct_decl, alt, phrases, T);

//\\ P<struct-member-list> =
   case G_struct_member_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <struct_member_declaration> <struct_member_list>,
       T[++phrases] = build_ast(CST(P++) /* G_struct_member_declaration */);
       T[++phrases] = build_ast(CST(P++) /* G_struct_member_list */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_struct_member_list, alt, phrases, T);

//\\ P<struct-member-declaration> =
   case G_struct_member_declaration:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <struct_decl>,
       T[++phrases] = build_ast(CST(P++) /* G_struct_decl */);
     } else if (alt == 1)        {  //\\    <possibly_initialised_scalar_decl>,
       T[++phrases] = build_ast(CST(P++) /* G_possibly_initialised_scalar_decl */);
     } else                      {  //\\    <possibly_initialised_array_decl>;
       T[++phrases] = build_ast(CST(P++) /* G_possibly_initialised_array_decl */);
     }
     return T[0] = G_mktuple(G_struct_member_declaration, alt, phrases, T);

//\\ P<possibly-initialised-array-decl> =
   case G_possibly_initialised_array_decl:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <auto_reg_static_ext_opt> <const_or_volatile_type_qualifier_opt> <type> <const_or_volatile_type_qualifier_opt> <indirection_decl_opt> <new_identifier> <array_bounds> <array_init_opt> ';';
     T[++phrases] = build_ast(CST(P++) /* G_auto_reg_static_ext_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_const_or_volatile_type_qualifier_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_type */);
     T[++phrases] = build_ast(CST(P++) /* G_const_or_volatile_type_qualifier_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_new_identifier */);
     T[++phrases] = build_ast(CST(P++) /* G_array_bounds */);
     T[++phrases] = build_ast(CST(P++) /* G_array_init_opt */);
     T[++phrases] = ch(CST(P++), ';');
     return T[0] = G_mktuple(G_possibly_initialised_array_decl, alt, phrases, T);

//\\ P<possibly-initialised-scalar-decl> =
   case G_possibly_initialised_scalar_decl:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <auto_reg_static_ext_opt> <const_or_volatile_type_qualifier_opt> <type> <rest_of_scalar_decl>;
     T[++phrases] = build_ast(CST(P++) /* G_auto_reg_static_ext_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_const_or_volatile_type_qualifier_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_type */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_scalar_decl */);
     return T[0] = G_mktuple(G_possibly_initialised_scalar_decl, alt, phrases, T);

//\\ P<rest-of-scalar-decl> =
   case G_rest_of_scalar_decl:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <indirection_decl_opt> <new_identifier> <scalar_init_opt> <rest_of_scalar_decl_opt> ';';
     T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_new_identifier */);
     T[++phrases] = build_ast(CST(P++) /* G_scalar_init_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_scalar_decl_opt */);
     T[++phrases] = ch(CST(P++), ';');
     return T[0] = G_mktuple(G_rest_of_scalar_decl, alt, phrases, T);

//\\ P<rest-of-scalar-decl_opt> =
   case G_rest_of_scalar_decl_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    ',' <indirection_decl_opt> <new_identifier> <scalar_init_opt> <rest_of_scalar_decl_opt>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_new_identifier */);
       T[++phrases] = build_ast(CST(P++) /* G_scalar_init_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_scalar_decl_opt */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_scalar_decl_opt, alt, phrases, T);

//\\ P<new-structname> =
   case G_new_structname:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <new_identifier>;
     T[++phrases] = build_ast(CST(P++) /* G_new_identifier */);
     return T[0] = G_mktuple(G_new_structname, alt, phrases, T);

//\\ P<decl-list> =
   case G_decl_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <decl> <rest_of_decl_list>;
     T[++phrases] = build_ast(CST(P++) /* G_decl */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_decl_list */);
     return T[0] = G_mktuple(G_decl_list, alt, phrases, T);

//\\ P<rest-of-decl-list> =
   case G_rest_of_decl_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    ',' <decl_list>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_decl_list */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_decl_list, alt, phrases, T);

//\\ P<decl> =
   case G_decl:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <indirection_decl_opt> <new_identifier> <possibly_empty_array_bounds_list> <array_init_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_new_identifier */);
       T[++phrases] = build_ast(CST(P++) /* G_possibly_empty_array_bounds_list */);
       T[++phrases] = build_ast(CST(P++) /* G_array_init_opt */);
     } else                      {  //\\    <indirection_decl_opt> <new_identifier> <scalar_init_opt>;
       T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_new_identifier */);
       T[++phrases] = build_ast(CST(P++) /* G_scalar_init_opt */);
     }
     return T[0] = G_mktuple(G_decl, alt, phrases, T);

//\\ P<possibly-empty-array-bounds-list> =
   case G_possibly_empty_array_bounds_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    '[' <HACK1> <constant_expression_opt> <HACK2> ']' <optional_possibly_empty_array_bounds_list>;
     T[++phrases] = ch(CST(P++), '[');
     T[++phrases] = build_ast(CST(P++) /* G_HACK1 */);
     T[++phrases] = build_ast(CST(P++) /* G_constant_expression_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_HACK2 */);
     T[++phrases] = ch(CST(P++), ']');
     T[++phrases] = build_ast(CST(P++) /* G_optional_possibly_empty_array_bounds_list */);
     return T[0] = G_mktuple(G_possibly_empty_array_bounds_list, alt, phrases, T);

//\\ P<optional-possibly-empty-array-bounds-list> =
   case G_optional_possibly_empty_array_bounds_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    '[' <HACK1> <constant_expression_opt> <HACK2> ']' <optional_possibly_empty_array_bounds_list>,
       T[++phrases] = ch(CST(P++), '[');
       T[++phrases] = build_ast(CST(P++) /* G_HACK1 */);
       T[++phrases] = build_ast(CST(P++) /* G_constant_expression_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_HACK2 */);
       T[++phrases] = ch(CST(P++), ']');
       T[++phrases] = build_ast(CST(P++) /* G_optional_possibly_empty_array_bounds_list */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_optional_possibly_empty_array_bounds_list, alt, phrases, T);

//\\ P<jump-statement> =
   case G_jump_statement:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "goto" <label> ';',
       T[++phrases] = kw(CST(P++), "goto");
       T[++phrases] = build_ast(CST(P++) /* G_label */);
       T[++phrases] = ch(CST(P++), ';');
     } else if (alt == 1)        {  //\\    "continue" ';',
       T[++phrases] = kw(CST(P++), "continue");
       T[++phrases] = ch(CST(P++), ';');
     } else if (alt == 2)        {  //\\    "break" ';',
       T[++phrases] = kw(CST(P++), "break");
       T[++phrases] = ch(CST(P++), ';');
     } else                      {  //\\    "return" <!followed-by-alpha> <expression_opt> ';';
       T[++phrases] = kw(CST(P++), "return");
       T[++phrases] = -1 +(0 * P++) /* S_followed-by-alpha */ /* semantic call - temp for now. Could theoretically return a string like a terminal. Parser needs to insert something in CST. */;
       T[++phrases] = build_ast(CST(P++) /* G_expression_opt */);
       T[++phrases] = ch(CST(P++), ';');
     }
     return T[0] = G_mktuple(G_jump_statement, alt, phrases, T);

//\\ P<expression_opt> =
   case G_expression_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <expression>,
       T[++phrases] = build_ast(CST(P++) /* G_expression */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_expression_opt, alt, phrases, T);

//\\ P<label> =
   case G_label:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <identifier>;
     T[++phrases] = build_ast(CST(P++) /* G_identifier */);
     return T[0] = G_mktuple(G_label, alt, phrases, T);

//\\ P<iteration-statement> =
   case G_iteration_statement:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "while" '(' <expression> ')' <statement>,
       T[++phrases] = kw(CST(P++), "while");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_expression */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = build_ast(CST(P++) /* G_statement */);
     } else if (alt == 1)        {  //\\    "do" <statement> "while" '(' <expression> ')' ';',
       T[++phrases] = kw(CST(P++), "do");
       T[++phrases] = build_ast(CST(P++) /* G_statement */);
       T[++phrases] = kw(CST(P++), "while");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_expression */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = ch(CST(P++), ';');
     } else                      {  //\\    "for" '(' <expression_opt> ';' <expression_opt> ';' <expression_opt> ')' <statement>;
       T[++phrases] = kw(CST(P++), "for");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_expression_opt */);
       T[++phrases] = ch(CST(P++), ';');
       T[++phrases] = build_ast(CST(P++) /* G_expression_opt */);
       T[++phrases] = ch(CST(P++), ';');
       T[++phrases] = build_ast(CST(P++) /* G_expression_opt */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = build_ast(CST(P++) /* G_statement */);
     }
     return T[0] = G_mktuple(G_iteration_statement, alt, phrases, T);

//\\ P<selection-statement> =
   case G_selection_statement:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "if" '(' <expression> ')' <statement> <else_opt>,
       T[++phrases] = kw(CST(P++), "if");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_expression */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = build_ast(CST(P++) /* G_statement */);
       T[++phrases] = build_ast(CST(P++) /* G_else_opt */);
     } else                      {  //\\    "switch" '(' <expression> ')' <statement>;
       T[++phrases] = kw(CST(P++), "switch");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_expression */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = build_ast(CST(P++) /* G_statement */);
     }
     return T[0] = G_mktuple(G_selection_statement, alt, phrases, T);

//\\ P<else_opt> =
   case G_else_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "else" <statement>,
       T[++phrases] = kw(CST(P++), "else");
       T[++phrases] = build_ast(CST(P++) /* G_statement */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_else_opt, alt, phrases, T);

//\\ P<missing-semicolon-after-label-at-end-of-block> =
   case G_missing_semicolon_after_label_at_end_of_block:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    '}';
     T[++phrases] = ch(CST(P++), '}');
     return T[0] = G_mktuple(G_missing_semicolon_after_label_at_end_of_block, alt, phrases, T);

//\\ P<labels_opt> =
   case G_labels_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <label> ':' <labels_opt> <!missing_semicolon_after_label_at_end_of_block>,
       T[++phrases] = build_ast(CST(P++) /* G_label */);
       T[++phrases] = ch(CST(P++), ':');
       T[++phrases] = build_ast(CST(P++) /* G_labels_opt */);
       T[++phrases] = -1 +(0 * P++);
     } else if (alt == 1)        {  //\\    "case" <constant_expression> ':' <labels_opt> <!missing_semicolon_after_label_at_end_of_block>,
       T[++phrases] = kw(CST(P++), "case");
       T[++phrases] = build_ast(CST(P++) /* G_constant_expression */);
       T[++phrases] = ch(CST(P++), ':');
       T[++phrases] = build_ast(CST(P++) /* G_labels_opt */);
       T[++phrases] = -1 +(0 * P++);
     } else if (alt == 2)        {  //\\    "default" ':' <labels_opt> <!missing_semicolon_after_label_at_end_of_block>,
       T[++phrases] = kw(CST(P++), "default");
       T[++phrases] = ch(CST(P++), ':');
       T[++phrases] = build_ast(CST(P++) /* G_labels_opt */);
       T[++phrases] = -1 +(0 * P++);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_labels_opt, alt, phrases, T);

//\\ P<param-list_opt> =
   case G_param_list_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <formal_param> <rest_of_param_list_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_formal_param */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_param_list_opt */);
     } else if (alt == 1)        {  //\\    "void",
       T[++phrases] = kw(CST(P++), "void");
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_param_list_opt, alt, phrases, T);

//\\ P<oldstyle-param-list_opt> =
   case G_oldstyle_param_list_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <oldstyle_param_list>,
       T[++phrases] = build_ast(CST(P++) /* G_oldstyle_param_list */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_oldstyle_param_list_opt, alt, phrases, T);

//\\ P<oldstyle-param-list> =
   case G_oldstyle_param_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <oldstyle_formal_param> <rest_of_oldstyle_param_list_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_oldstyle_formal_param */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_oldstyle_param_list_opt */);
     } else                      {  //\\    "void";
       T[++phrases] = kw(CST(P++), "void");
     }
     return T[0] = G_mktuple(G_oldstyle_param_list, alt, phrases, T);

//\\ P<rest-of-oldstyle-param-list_opt> =
   case G_rest_of_oldstyle_param_list_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    ';' <oldstyle_param_list>,
       T[++phrases] = ch(CST(P++), ';');
       T[++phrases] = build_ast(CST(P++) /* G_oldstyle_param_list */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_oldstyle_param_list_opt, alt, phrases, T);

//\\ P<oldstyle-formal-param> =
   case G_oldstyle_formal_param:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <const_or_volatile_type_qualifier_opt> <type> <oldstyle_parameter_list>;
     T[++phrases] = build_ast(CST(P++) /* G_const_or_volatile_type_qualifier_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_type */);
     T[++phrases] = build_ast(CST(P++) /* G_oldstyle_parameter_list */);
     return T[0] = G_mktuple(G_oldstyle_formal_param, alt, phrases, T);

//\\ P<oldstyle-parameter-list> =
   case G_oldstyle_parameter_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <whatever> <rest_of_oldstyle_parameter_list>;
     T[++phrases] = build_ast(CST(P++) /* G_whatever */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_oldstyle_parameter_list */);
     return T[0] = G_mktuple(G_oldstyle_parameter_list, alt, phrases, T);

//\\ P<rest-of-oldstyle-parameter-list> =
   case G_rest_of_oldstyle_parameter_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    ',' <oldstyle_parameter_list>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_oldstyle_parameter_list */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_oldstyle_parameter_list, alt, phrases, T);

//\\ P<whatever> =
   case G_whatever:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <indirection_decl_opt> <identifier_opt> <optional_possibly_empty_array_bounds_list>;
     T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_identifier_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_optional_possibly_empty_array_bounds_list */);
     return T[0] = G_mktuple(G_whatever, alt, phrases, T);

//\\ P<rest-of-param-list_opt> =
   case G_rest_of_param_list_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    ',' "...",
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = kw(CST(P++), "...");
     } else if (alt == 1)        {  //\\    ',' <formal_param> <rest_of_param_list_opt>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_formal_param */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_param_list_opt */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_param_list_opt, alt, phrases, T);

//\\ P<formal-param> =
   case G_formal_param:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <procedure_as_parameter>,
       T[++phrases] = build_ast(CST(P++) /* G_procedure_as_parameter */);
     } else                      {  //\\    <const_or_volatile_type_qualifier_opt> <type> <indirection_decl_opt> <identifier_opt> <optional_possibly_empty_array_bounds_list>;
       T[++phrases] = build_ast(CST(P++) /* G_const_or_volatile_type_qualifier_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_type */);
       T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_identifier_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_optional_possibly_empty_array_bounds_list */);
     }
     return T[0] = G_mktuple(G_formal_param, alt, phrases, T);

//\\ P<identifier_opt> =
   case G_identifier_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <identifier>,
       T[++phrases] = build_ast(CST(P++) /* G_identifier */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_identifier_opt, alt, phrases, T);

//\\ P<procedure-as-parameter> =
   case G_procedure_as_parameter:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <auto_reg_static_ext_opt> <const_or_volatile_type_qualifier_opt> <basic_type_specifier_opt> '(' <indirection_decl_opt> <new_identifier> ')' '(' <param_list_opt> ')',
       T[++phrases] = build_ast(CST(P++) /* G_auto_reg_static_ext_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_const_or_volatile_type_qualifier_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_basic_type_specifier_opt */);
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_new_identifier */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_param_list_opt */);
       T[++phrases] = ch(CST(P++), ')');
     } else                      {  //\\    <auto_reg_static_ext_opt> <const_or_volatile_type_qualifier_opt> <typedef_name> '(' <indirection_decl_opt> <new_identifier> ')' '(' <param_list_opt> ')';
       T[++phrases] = build_ast(CST(P++) /* G_auto_reg_static_ext_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_const_or_volatile_type_qualifier_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_typedef_name */);
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_new_identifier */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_param_list_opt */);
       T[++phrases] = ch(CST(P++), ')');
     }
     return T[0] = G_mktuple(G_procedure_as_parameter, alt, phrases, T);

//\\ P<basic-type-specifier_opt> =
   case G_basic_type_specifier_opt:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    <basic_type_specifier>,
       T[++phrases] = build_ast(CST(P++) /* G_basic_type_specifier */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_basic_type_specifier_opt, alt, phrases, T);

//\\ P<typedef-declaration> =
   case G_typedef_declaration:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    "typedef" <type_specifier> <indirection_decl_opt> '(' <indirection_decl_opt> <new_identifier> ')' '(' <param_list_opt> ')',
       T[++phrases] = kw(CST(P++), "typedef");
       T[++phrases] = build_ast(CST(P++) /* G_type_specifier */);
       T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_new_identifier */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_param_list_opt */);
       T[++phrases] = ch(CST(P++), ')');
     } else if (alt == 1)        {  //\\    "typedef" <const_or_volatile_type_qualifier_opt> <type_specifier> <const_or_volatile_type_qualifier_opt> <decl_list>,
       T[++phrases] = kw(CST(P++), "typedef");
       T[++phrases] = build_ast(CST(P++) /* G_const_or_volatile_type_qualifier_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_type_specifier */);
       T[++phrases] = build_ast(CST(P++) /* G_const_or_volatile_type_qualifier_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_decl_list */);
     } else if (alt == 2)        {  //\\    "typedef" <struct_decl> <maybe_indirect_typedef_name_list>,
       T[++phrases] = kw(CST(P++), "typedef");
       T[++phrases] = build_ast(CST(P++) /* G_struct_decl */);
       T[++phrases] = build_ast(CST(P++) /* G_maybe_indirect_typedef_name_list */);
     } else                      {  //\\    "typedef" <type_specifier> <maybe_indirect_typedef_name_list>;
       T[++phrases] = kw(CST(P++), "typedef");
       T[++phrases] = build_ast(CST(P++) /* G_type_specifier */);
       T[++phrases] = build_ast(CST(P++) /* G_maybe_indirect_typedef_name_list */);
     }
     return T[0] = G_mktuple(G_typedef_declaration, alt, phrases, T);

//\\ P<maybe-indirect-typedef-name-list> =
   case G_maybe_indirect_typedef_name_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
                                    //\\    <indirection_decl_opt> <typedef_name> <rest_of_maybe_indirect_typedef_name_list>;
     T[++phrases] = build_ast(CST(P++) /* G_indirection_decl_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_typedef_name */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_maybe_indirect_typedef_name_list */);
     return T[0] = G_mktuple(G_maybe_indirect_typedef_name_list, alt, phrases, T);

//\\ P<rest-of-maybe-indirect-typedef-name-list> =
   case G_rest_of_maybe_indirect_typedef_name_list:
#if defined(NOT_SURE) || defined(BUILDING_CST)

#endif
     if (alt == 0)               {  //\\    ',' <maybe_indirect_typedef_name_list>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_maybe_indirect_typedef_name_list */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_maybe_indirect_typedef_name_list, alt, phrases, T);

//\\ E