#error This is not directly used in anything at the moment.
// It is here for incorporating as the basis of a compile() function to do something useful with an AST.
// For example this generated the code that was manually converted into algol60-indent.h

#define X_APP 1
#include <stdio.h>

#define AST_idx_mask 0x7FFFFFFU
#define AST_type_shift 27U
#define AST_type_mask  31U
#define AST_BIP      (16U << AST_type_shift)
#define AST_PHRASE   (17U << AST_type_shift)
#define AST_ATOM_LIT (18U << AST_type_shift)

//int AST(int idx) {
//}

//int wlit(int P) {
//}

//int P(int P_) {
//}
int compile(int Ph, int depth) {

  // AST format not properly designed yet.  These are placeholders:
#define P(x) (x) // TEMP
#define A(x) (x) // TEMP
#define wlit(x) (x)

  int AST_index = Ph&AST_idx_mask;
  int AST_type  = Ph & (AST_type_mask << AST_type_shift);
  int op    = A(AST_index+1);
  int alt   = A(AST_index+2);
  int count = A(AST_index+3);
  int t[LARGEST_ALT];
  int r = 0;

  fprintf(stderr, "Ph=%d AST_type = %d  AST_index = %d  op=%d  alt=%d  count=%d\n", Ph, AST_type>>AST_type_shift, AST_index, op, alt, count);

  switch (op) {
    // It is here for incorporating as the basis of a compile() function to do something useful with an AST.
    // For example this generated the code that was manually converted into algol60-indent.h

//\\ B<EOF> = 0;
//\\#
//\\ B<NL> = 2;
//\\#
//\\ P<constant> =
   case P_constant:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <cast_opt> <floating-constant>,
       t[1] = compile(P(1), depth+1 /* P_cast_opt */);
       t[2] = compile(P(2), depth+1 /* P_floating_constant */);
       return t[0] = P_mktuple(P_constant, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <cast_opt> <integer-constant>,
       t[1] = compile(P(1), depth+1 /* P_cast_opt */);
       t[2] = compile(P(2), depth+1 /* P_integer_constant */);
       return t[0] = P_mktuple(P_constant, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    <cast_opt> <character-constant>,
       t[1] = compile(P(1), depth+1 /* P_cast_opt */);
       t[2] = compile(P(2), depth+1 /* P_character_constant */);
       return t[0] = P_mktuple(P_constant, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <cast_opt> <enumeration-constant>;
       t[1] = compile(P(1), depth+1 /* P_cast_opt */);
       t[2] = compile(P(2), depth+1 /* P_enumeration_constant */);
       return t[0] = P_mktuple(P_constant, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<U_opt> =
   case P_U_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    'U',
       t[1] = wlit(P(1) /*, L'U' */);
       return t[0] = P_mktuple(P_U_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    'u',
       t[1] = wlit(P(1) /*, L'u' */);
       return t[0] = P_mktuple(P_U_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_U_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<L_opt> =
   case P_L_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    'L',
       t[1] = wlit(P(1) /*, L'L' */);
       return t[0] = P_mktuple(P_L_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    'l',
       t[1] = wlit(P(1) /*, L'l' */);
       return t[0] = P_mktuple(P_L_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_L_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<UL_opt> =
   case P_UL_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    'U' <L_opt> <L_opt>,
       t[1] = wlit(P(1) /*, L'U' */);
       t[2] = compile(P(2), depth+1 /* P_L_opt */);
       t[3] = compile(P(3), depth+1 /* P_L_opt */);
       return t[0] = P_mktuple(P_UL_opt, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    'L' <L_opt> <U_opt>,
       t[1] = wlit(P(1) /*, L'L' */);
       t[2] = compile(P(2), depth+1 /* P_L_opt */);
       t[3] = compile(P(3), depth+1 /* P_U_opt */);
       return t[0] = P_mktuple(P_UL_opt, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_UL_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<integer-constant> =
   case P_integer_constant:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <hexadecimal-constant> <UL_opt>,
       t[1] = compile(P(1), depth+1 /* P_hexadecimal_constant */);
       t[2] = compile(P(2), depth+1 /* P_UL_opt */);
       return t[0] = P_mktuple(P_integer_constant, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <binary-constant> <UL_opt>,
       t[1] = compile(P(1), depth+1 /* P_binary_constant */);
       t[2] = compile(P(2), depth+1 /* P_UL_opt */);
       return t[0] = P_mktuple(P_integer_constant, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    <octal-constant> <UL_opt>,
       t[1] = compile(P(1), depth+1 /* P_octal_constant */);
       t[2] = compile(P(2), depth+1 /* P_UL_opt */);
       return t[0] = P_mktuple(P_integer_constant, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <decimal-constant> <UL_opt>;
       t[1] = compile(P(1), depth+1 /* P_decimal_constant */);
       t[2] = compile(P(2), depth+1 /* P_UL_opt */);
       return t[0] = P_mktuple(P_integer_constant, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<decimal-constant> =
   case P_decimal_constant:
#ifdef IN_PARSER

#endif
     {                              //\\    «[1-9][0-9]*»;
     t[1] = wlit(P(1));
     return t[0] = P_mktuple(P_decimal_constant, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<octal-constant> =
   case P_octal_constant:
#ifdef IN_PARSER

#endif
     {                              //\\    «0[0-7]*»;
     t[1] = wlit(P(1));
     return t[0] = P_mktuple(P_octal_constant, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<hexadecimal-constant> =
   case P_hexadecimal_constant:
#ifdef IN_PARSER

#endif
     {                              //\\    «0[xX][0-9a-fA-F]+»;
     t[1] = wlit(P(1));
     return t[0] = P_mktuple(P_hexadecimal_constant, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<binary-constant> =
   case P_binary_constant:
#ifdef IN_PARSER

#endif
     {                              //\\    «0[bB][0-1]+»;
     t[1] = wlit(P(1));
     return t[0] = P_mktuple(P_binary_constant, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<floating-constant> =
   case P_floating_constant:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <decimal-floating-constant>,
       t[1] = compile(P(1), depth+1 /* P_decimal_floating_constant */);
       return t[0] = P_mktuple(P_floating_constant, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <hexadecimal-floating-constant>,
       t[1] = compile(P(1), depth+1 /* P_hexadecimal_floating_constant */);
       return t[0] = P_mktuple(P_floating_constant, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <binary-floating-constant>;
       t[1] = compile(P(1), depth+1 /* P_binary_floating_constant */);
       return t[0] = P_mktuple(P_floating_constant, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<fractional-constant> =
   case P_fractional_constant:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <digit-sequence_opt> '.' <digit-sequence>,
       t[1] = compile(P(1), depth+1 /* P_digit_sequence_opt */);
       t[2] = wlit(P(2) /*, L'.' */);
       t[3] = compile(P(3), depth+1 /* P_digit_sequence */);
       return t[0] = P_mktuple(P_fractional_constant, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <digit-sequence> '.';
       t[1] = compile(P(1), depth+1 /* P_digit_sequence */);
       t[2] = wlit(P(2) /*, L'.' */);
       return t[0] = P_mktuple(P_fractional_constant, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<exponent-part> =
   case P_exponent_part:
#ifdef IN_PARSER

#endif
     {                              //\\    «[eE][+-]?[0-9]*»;
     t[1] = wlit(P(1));
     return t[0] = P_mktuple(P_exponent_part, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<exponent-part_opt> =
   case P_exponent_part_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <exponent-part>,
       t[1] = compile(P(1), depth+1 /* P_exponent_part */);
       return t[0] = P_mktuple(P_exponent_part_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_exponent_part_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<floating-suffix_opt> =
   case P_floating_suffix_opt:
#ifdef IN_PARSER

#endif
     {                              //\\    «[flFL]?»;
     t[1] = wlit(P(1));
     return t[0] = P_mktuple(P_floating_suffix_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<digit-sequence> =
   case P_digit_sequence:
#ifdef IN_PARSER

#endif
     {                              //\\    «[0-9]+»;
     t[1] = wlit(P(1));
     return t[0] = P_mktuple(P_digit_sequence, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<digit-sequence_opt> =
   case P_digit_sequence_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <digit-sequence>,
       t[1] = compile(P(1), depth+1 /* P_digit_sequence */);
       return t[0] = P_mktuple(P_digit_sequence_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_digit_sequence_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<decimal-floating-constant> =
   case P_decimal_floating_constant:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <fractional-constant> <exponent-part_opt> <floating-suffix_opt>,
       t[1] = compile(P(1), depth+1 /* P_fractional_constant */);
       t[2] = compile(P(2), depth+1 /* P_exponent_part_opt */);
       t[3] = compile(P(3), depth+1 /* P_floating_suffix_opt */);
       return t[0] = P_mktuple(P_decimal_floating_constant, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <digit-sequence> <exponent-part> <floating-suffix_opt>;
       t[1] = compile(P(1), depth+1 /* P_digit_sequence */);
       t[2] = compile(P(2), depth+1 /* P_exponent_part */);
       t[3] = compile(P(3), depth+1 /* P_floating_suffix_opt */);
       return t[0] = P_mktuple(P_decimal_floating_constant, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<hexadecimal-floating-constant> =
   case P_hexadecimal_floating_constant:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    «0[xX]» <hexadecimal-fractional-constant> <binary-exponent-part> «[flFL]?»,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_hexadecimal_fractional_constant */);
       t[3] = compile(P(3), depth+1 /* P_binary_exponent_part */);
       t[4] = wlit(P(4));
       return t[0] = P_mktuple(P_hexadecimal_floating_constant, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    «0[xX]» <hexadecimal-digit-sequence> <binary-exponent-part> «[flFL]?»;
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_hexadecimal_digit_sequence */);
       t[3] = compile(P(3), depth+1 /* P_binary_exponent_part */);
       t[4] = wlit(P(4));
       return t[0] = P_mktuple(P_hexadecimal_floating_constant, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<binary-floating-constant> =
   case P_binary_floating_constant:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    «0[bB]» <binary-fractional-constant> <binary-exponent-part> «[flFL]?»,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_binary_fractional_constant */);
       t[3] = compile(P(3), depth+1 /* P_binary_exponent_part */);
       t[4] = wlit(P(4));
       return t[0] = P_mktuple(P_binary_floating_constant, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    «0[bB]» <binary-digit-sequence> <binary-exponent-part> «[flFL]?»;
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_binary_digit_sequence */);
       t[3] = compile(P(3), depth+1 /* P_binary_exponent_part */);
       t[4] = wlit(P(4));
       return t[0] = P_mktuple(P_binary_floating_constant, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<hexadecimal-digit-sequence> =
   case P_hexadecimal_digit_sequence:
#ifdef IN_PARSER

#endif
     {                              //\\    «[A-Fa-f0-9]+»;
     t[1] = wlit(P(1));
     return t[0] = P_mktuple(P_hexadecimal_digit_sequence, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<hexadecimal-fractional-constant> =
   case P_hexadecimal_fractional_constant:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    «[A-Fa-f0-9]*» '.' «[A-Fa-f0-9]+»,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'.' */);
       t[3] = wlit(P(3));
       return t[0] = P_mktuple(P_hexadecimal_fractional_constant, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    «[A-Fa-f0-9]+» '.';
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'.' */);
       return t[0] = P_mktuple(P_hexadecimal_fractional_constant, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<binary-digit-sequence> =
   case P_binary_digit_sequence:
#ifdef IN_PARSER

#endif
     {                              //\\    «[0-1]+»;
     t[1] = wlit(P(1));
     return t[0] = P_mktuple(P_binary_digit_sequence, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<binary-fractional-constant> =
   case P_binary_fractional_constant:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    «[0-1]*» '.' «[0-1]+»,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'.' */);
       t[3] = wlit(P(3));
       return t[0] = P_mktuple(P_binary_fractional_constant, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    «[0-1]+» '.';
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'.' */);
       return t[0] = P_mktuple(P_binary_fractional_constant, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<binary-exponent-part> =
   case P_binary_exponent_part:
#ifdef IN_PARSER

#endif
     {                              //\\    «[pP][+-]?[0-9]+»;
     t[1] = wlit(P(1));
     return t[0] = P_mktuple(P_binary_exponent_part, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<enumeration-constant> =
   case P_enumeration_constant:
#ifdef IN_PARSER

#endif
     {                              //\\    <identifier>;
     t[1] = compile(P(1), depth+1 /* P_identifier */);
     return t[0] = P_mktuple(P_enumeration_constant, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<character-constant> =
   case P_character_constant:
#ifdef IN_PARSER

#endif
     {                              //\\    <longchartype_opt> «'» <sqchars> «'»;
     t[1] = compile(P(1), depth+1 /* P_longchartype_opt */);
     t[2] = wlit(P(2));
     t[3] = compile(P(3), depth+1 /* P_sqchars */);
     t[4] = wlit(P(4));
     return t[0] = P_mktuple(P_character_constant, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<sqchars> =
   case P_sqchars:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <sqchar> <sqchars>,
       t[1] = compile(P(1), depth+1 /* P_sqchar */);
       t[2] = compile(P(2), depth+1 /* P_sqchars */);
       return t[0] = P_mktuple(P_sqchars, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_sqchars, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<sqchar> =
   case P_sqchar:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    «[^'\]»,
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_sqchar, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <escaped-char>;
       t[1] = compile(P(1), depth+1 /* P_escaped_char */);
       return t[0] = P_mktuple(P_sqchar, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<escaped-char> =
   case P_escaped_char:
#ifdef IN_PARSER

#endif
     {                              //\\    '\' «[\"'?abfnrtvx0-9]»;
     t[1] = wlit(P(1) /*, L'\\' */);
     t[2] = wlit(P(2));
     return t[0] = P_mktuple(P_escaped_char, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<longchartype_opt> =
   case P_longchartype_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    'L',
       t[1] = wlit(P(1) /*, L'L' */);
       return t[0] = P_mktuple(P_longchartype_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_longchartype_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<unchecked-identifier> =
   case P_unchecked_identifier:
#ifdef IN_PARSER

#endif
     {                              //\\    «[A-Za-z_][A-Za-z0-9_]*» <!sq>;
     t[1] = wlit(P(1));
     t[2] = -1; /* ignore negative guard */;
     return t[0] = P_mktuple(P_unchecked_identifier, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<sq> =
   case P_sq:
#ifdef IN_PARSER

#endif
     {                              //\\    «'»;
     t[1] = wlit(P(1));
     return t[0] = P_mktuple(P_sq, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<dq> =
   case P_dq:
#ifdef IN_PARSER

#endif
     {                              //\\    '"';
     t[1] = wlit(P(1) /*, L'"' */);
     return t[0] = P_mktuple(P_dq, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<dqchar> =
   case P_dqchar:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '\' <dq>,
       t[1] = wlit(P(1) /*, L'\\' */);
       t[2] = compile(P(2), depth+1 /* P_dq */);
       return t[0] = P_mktuple(P_dqchar, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <!dq> «.»;
       t[1] = -1; /* ignore negative guard */;
       t[2] = wlit(P(2));
       return t[0] = P_mktuple(P_dqchar, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<dqstringchars> =
   case P_dqstringchars:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <dqchar> <dqstringchars>,
       t[1] = compile(P(1), depth+1 /* P_dqchar */);
       t[2] = compile(P(2), depth+1 /* P_dqstringchars */);
       return t[0] = P_mktuple(P_dqstringchars, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_dqstringchars, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<dqstring> =
   case P_dqstring:
#ifdef IN_PARSER

#endif
     {                              //\\    <longchartype_opt> <dq> <dqstringchars> <dq> <dqstring_opt>;
     t[1] = compile(P(1), depth+1 /* P_longchartype_opt */);
     t[2] = compile(P(2), depth+1 /* P_dq */);
     t[3] = compile(P(3), depth+1 /* P_dqstringchars */);
     t[4] = compile(P(4), depth+1 /* P_dq */);
     t[5] = compile(P(5), depth+1 /* P_dqstring_opt */);
     return t[0] = P_mktuple(P_dqstring, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<dqstring_opt> =
   case P_dqstring_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <dqstring>,
       t[1] = compile(P(1), depth+1 /* P_dqstring */);
       return t[0] = P_mktuple(P_dqstring_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_dqstring_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<not-preceded-by-alpha_and_is-not-keyword> =
   case P_not_preceded_by_alpha_and_is_not_keyword:
#ifdef IN_PARSER

#endif
     {                              //\\    <!preceded-by-alpha> <!keyword>;
     t[1] = -1; /* semantic procedure preceded-by-alpha */;
     t[2] = -1; /* ignore negative guard */;
     return t[0] = P_mktuple(P_not_preceded_by_alpha_and_is_not_keyword, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<tag> =
   case P_tag:
#ifdef IN_PARSER

#endif
     {                              //\\    <identifier>;
     t[1] = compile(P(1), depth+1 /* P_identifier */);
     return t[0] = P_mktuple(P_tag, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<new-identifier> =
   case P_new_identifier:
#ifdef IN_PARSER

#endif
     {                              //\\    <identifier>;
     t[1] = compile(P(1), depth+1 /* P_identifier */);
     return t[0] = P_mktuple(P_new_identifier, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<identifier> =
   case P_identifier:
#ifdef IN_PARSER

#endif
     {                              //\\    <?not-preceded-by-alpha_and_is-not-keyword> <unchecked-identifier>;
     t[1] = -1; /* ignore guard */;
     t[2] = compile(P(2), depth+1 /* P_unchecked_identifier */);
     return t[0] = P_mktuple(P_identifier, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<keyword> =
   case P_keyword:
#ifdef IN_PARSER

#endif
     {                              //\\    <actual-keyword> <!followed-by-alpha>;
     t[1] = compile(P(1), depth+1 /* P_actual_keyword */);
     t[2] = -1; /* semantic procedure followed-by-alpha */;
     return t[0] = P_mktuple(P_keyword, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<actual-keyword> =
   case P_actual_keyword:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "if",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "const",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    "struct",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    "union",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    "sizeof",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 5)        {  //\\    "typeof",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 6)        {  //\\    "double",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 7)        {  //\\    "long",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 8)        {  //\\    "char",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 9)        {  //\\    "float",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 10)        {  //\\    "void",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 11)        {  //\\    "enum",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 12)        {  //\\    "short",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 13)        {  //\\    "int",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 14)        {  //\\    "signed",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 15)        {  //\\    "unsigned",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 16)        {  //\\    "volatile",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 17)        {  //\\    "auto",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 18)        {  //\\    "register",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 19)        {  //\\    "static",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 20)        {  //\\    "extern",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 21)        {  //\\    "goto",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 22)        {  //\\    "continue",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 23)        {  //\\    "break",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 24)        {  //\\    "return",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 25)        {  //\\    "while",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 26)        {  //\\    "do",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 27)        {  //\\    "for",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 28)        {  //\\    "switch",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 29)        {  //\\    "else",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 30)        {  //\\    "case",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 31)        {  //\\    "default",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "typedef";
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_actual_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<SS> =
   case P_SS:
#ifdef IN_PARSER

#endif
     {                              //\\    <C_line_reconstruction> <external-declaration-list_opt> <EOF>;
     t[1] = -1; /* semantic procedure C_line_reconstruction */;
     t[2] = compile(P(2), depth+1 /* P_external_declaration_list_opt */);
     t[3] = wlit(P(3) /*, L"EOF" */);
     return t[0] = P_mktuple(P_SS, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<external-declaration-list> =
   case P_external_declaration_list:
#ifdef IN_PARSER

#endif
     {                              //\\    <external-declaration> <external-declaration-list_opt>;
     t[1] = compile(P(1), depth+1 /* P_external_declaration */);
     t[2] = compile(P(2), depth+1 /* P_external_declaration_list_opt */);
     return t[0] = P_mktuple(P_external_declaration_list, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<external-declaration-list_opt> =
   case P_external_declaration_list_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <external-declaration-list>,
       t[1] = compile(P(1), depth+1 /* P_external_declaration_list */);
       return t[0] = P_mktuple(P_external_declaration_list_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_external_declaration_list_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<external-declaration> =
   case P_external_declaration:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <pp_directive>,
       t[1] = -1; /* semantic procedure pp_directive */;
       return t[0] = P_mktuple(P_external_declaration, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <typedef-declaration> ';',
       t[1] = compile(P(1), depth+1 /* P_typedef_declaration */);
       t[2] = wlit(P(2) /*, L';' */);
       return t[0] = P_mktuple(P_external_declaration, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    <proc-fn-decl>,
       t[1] = compile(P(1), depth+1 /* P_proc_fn_decl */);
       return t[0] = P_mktuple(P_external_declaration, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    <possibly-initialised-scalar-or-array-decl> ';',
       t[1] = compile(P(1), depth+1 /* P_possibly_initialised_scalar_or_array_decl */);
       t[2] = wlit(P(2) /*, L';' */);
       return t[0] = P_mktuple(P_external_declaration, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    <enum-specifier>,
       t[1] = compile(P(1), depth+1 /* P_enum_specifier */);
       return t[0] = P_mktuple(P_external_declaration, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 5)        {  //\\    <struct-or-union-specifier>,
       t[1] = compile(P(1), depth+1 /* P_struct_or_union_specifier */);
       return t[0] = P_mktuple(P_external_declaration, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ';';
       t[1] = wlit(P(1) /*, L';' */);
       return t[0] = P_mktuple(P_external_declaration, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<struct-or-union-specifier> =
   case P_struct_or_union_specifier:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <struct-or-union> <identifier> '{' <struct-field-declarations> '}',
       t[1] = compile(P(1), depth+1 /* P_struct_or_union */);
       t[2] = compile(P(2), depth+1 /* P_identifier */);
       t[3] = wlit(P(3) /*, L'{' */);
       t[4] = compile(P(4), depth+1 /* P_struct_field_declarations */);
       t[5] = wlit(P(5) /*, L'}' */);
       return t[0] = P_mktuple(P_struct_or_union_specifier, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <struct-or-union> '{' <struct-field-declarations> '}',
       t[1] = compile(P(1), depth+1 /* P_struct_or_union */);
       t[2] = wlit(P(2) /*, L'{' */);
       t[3] = compile(P(3), depth+1 /* P_struct_field_declarations */);
       t[4] = wlit(P(4) /*, L'}' */);
       return t[0] = P_mktuple(P_struct_or_union_specifier, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <struct-or-union> <identifier>;
       t[1] = compile(P(1), depth+1 /* P_struct_or_union */);
       t[2] = compile(P(2), depth+1 /* P_identifier */);
       return t[0] = P_mktuple(P_struct_or_union_specifier, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<struct-or-union> =
   case P_struct_or_union:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "struct",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_struct_or_union, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "union";
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_struct_or_union, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<struct-field-declarations> =
   case P_struct_field_declarations:
#ifdef IN_PARSER

#endif
     {                              //\\    <struct-field-declaration> <rest-of-struct-field-declarations>;
     t[1] = compile(P(1), depth+1 /* P_struct_field_declaration */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_struct_field_declarations */);
     return t[0] = P_mktuple(P_struct_field_declarations, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-struct-field-declarations> =
   case P_rest_of_struct_field_declarations:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <struct-field-declaration> <rest-of-struct-field-declarations>,
       t[1] = compile(P(1), depth+1 /* P_struct_field_declaration */);
       t[2] = compile(P(2), depth+1 /* P_rest_of_struct_field_declarations */);
       return t[0] = P_mktuple(P_rest_of_struct_field_declarations, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_struct_field_declarations, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<struct-field-declaration> =
   case P_struct_field_declaration:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <possibly-initialised-scalar-or-array-decl> ';',
       t[1] = compile(P(1), depth+1 /* P_possibly_initialised_scalar_or_array_decl */);
       t[2] = wlit(P(2) /*, L';' */);
       return t[0] = P_mktuple(P_struct_field_declaration, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <struct-or-union-specifier> ';';
       t[1] = compile(P(1), depth+1 /* P_struct_or_union_specifier */);
       t[2] = wlit(P(2) /*, L';' */);
       return t[0] = P_mktuple(P_struct_field_declaration, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<possibly-initialised-scalar-or-array-decl> =
   case P_possibly_initialised_scalar_or_array_decl:
#ifdef IN_PARSER

#endif
     {                              //\\    <auto-reg-static-ext_opt> <const-or-volatile-type-qualifier_opt> <type> <rest-of-scalar-or-array-decl>;
     t[1] = compile(P(1), depth+1 /* P_auto_reg_static_ext_opt */);
     t[2] = compile(P(2), depth+1 /* P_const_or_volatile_type_qualifier_opt */);
     t[3] = compile(P(3), depth+1 /* P_type */);
     t[4] = compile(P(4), depth+1 /* P_rest_of_scalar_or_array_decl */);
     return t[0] = P_mktuple(P_possibly_initialised_scalar_or_array_decl, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-scalar-or-array-decl> =
   case P_rest_of_scalar_or_array_decl:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <indirection-decl_opt> <new-identifier> <array-bounds> <array-init_opt> <rest-of-scalar-or-array-decl_opt>,
       t[1] = compile(P(1), depth+1 /* P_indirection_decl_opt */);
       t[2] = compile(P(2), depth+1 /* P_new_identifier */);
       t[3] = compile(P(3), depth+1 /* P_array_bounds */);
       t[4] = compile(P(4), depth+1 /* P_array_init_opt */);
       t[5] = compile(P(5), depth+1 /* P_rest_of_scalar_or_array_decl_opt */);
       return t[0] = P_mktuple(P_rest_of_scalar_or_array_decl, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } 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[1] = compile(P(1), depth+1 /* P_indirection_decl_opt */);
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_indirection_decl_opt */);
       t[4] = compile(P(4), depth+1 /* P_new_identifier */);
       t[5] = wlit(P(5) /*, L')' */);
       t[6] = wlit(P(6) /*, L'(' */);
       t[7] = compile(P(7), depth+1 /* P_param_list_opt */);
       t[8] = wlit(P(8) /*, L')' */);
       t[9] = compile(P(9), depth+1 /* P_scalar_init_opt */);
       t[10] = compile(P(10), depth+1 /* P_rest_of_scalar_or_array_decl_opt */);
       return t[0] = P_mktuple(P_rest_of_scalar_or_array_decl, alt, 10/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <indirection-decl_opt> <new-identifier> <scalar-init_opt> <rest-of-scalar-or-array-decl_opt>;
       t[1] = compile(P(1), depth+1 /* P_indirection_decl_opt */);
       t[2] = compile(P(2), depth+1 /* P_new_identifier */);
       t[3] = compile(P(3), depth+1 /* P_scalar_init_opt */);
       t[4] = compile(P(4), depth+1 /* P_rest_of_scalar_or_array_decl_opt */);
       return t[0] = P_mktuple(P_rest_of_scalar_or_array_decl, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-scalar-or-array-decl_opt> =
   case P_rest_of_scalar_or_array_decl_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <rest-of-scalar-or-array-decl>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_rest_of_scalar_or_array_decl */);
       return t[0] = P_mktuple(P_rest_of_scalar_or_array_decl_opt, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_scalar_or_array_decl_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<scalar-init_opt> =
   case P_scalar_init_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '=' <assignment-expression>,
       t[1] = wlit(P(1) /*, L'=' */);
       t[2] = compile(P(2), depth+1 /* P_assignment_expression */);
       return t[0] = P_mktuple(P_scalar_init_opt, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_scalar_init_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<assignment-expression> =
   case P_assignment_expression:
#ifdef IN_PARSER

#endif
     {                              //\\    <lvalue-assign_opt> <conditional-expression> <rest-of-assignment-expression_opt>;
     t[1] = compile(P(1), depth+1 /* P_lvalue_assign_opt */);
     t[2] = compile(P(2), depth+1 /* P_conditional_expression */);
     t[3] = compile(P(3), depth+1 /* P_rest_of_assignment_expression_opt */);
     return t[0] = P_mktuple(P_assignment_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-assignment-expression_opt> =
   case P_rest_of_assignment_expression_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <assignment-operator> <conditional-expression> <rest-of-assignment-expression_opt>,
       t[1] = compile(P(1), depth+1 /* P_assignment_operator */);
       t[2] = compile(P(2), depth+1 /* P_conditional_expression */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_assignment_expression_opt */);
       return t[0] = P_mktuple(P_rest_of_assignment_expression_opt, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_assignment_expression_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<conditional-expression> =
   case P_conditional_expression:
#ifdef IN_PARSER

#endif
     {                              //\\    <logical-or-expression> <rest-of-conditional-expression>;
     t[1] = compile(P(1), depth+1 /* P_logical_or_expression */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_conditional_expression */);
     return t[0] = P_mktuple(P_conditional_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-conditional-expression> =
   case P_rest_of_conditional_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '?' <expression> ':' <conditional-expression>,
       t[1] = wlit(P(1) /*, L'?' */);
       t[2] = compile(P(2), depth+1 /* P_expression */);
       t[3] = wlit(P(3) /*, L':' */);
       t[4] = compile(P(4), depth+1 /* P_conditional_expression */);
       return t[0] = P_mktuple(P_rest_of_conditional_expression, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_conditional_expression, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<expression> =
   case P_expression:
#ifdef IN_PARSER

#endif
     {                              //\\    <comma-statement>;
     t[1] = compile(P(1), depth+1 /* P_comma_statement */);
     return t[0] = P_mktuple(P_expression, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<comma-statement> =
   case P_comma_statement:
#ifdef IN_PARSER

#endif
     {                              //\\    <assignment-expression> <rest-of-comma-statement>;
     t[1] = compile(P(1), depth+1 /* P_assignment_expression */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_comma_statement */);
     return t[0] = P_mktuple(P_comma_statement, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-comma-statement> =
   case P_rest_of_comma_statement:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <assignment-expression> <rest-of-comma-statement>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_assignment_expression */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_comma_statement */);
       return t[0] = P_mktuple(P_rest_of_comma_statement, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_comma_statement, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<logical-or-expression> =
   case P_logical_or_expression:
#ifdef IN_PARSER

#endif
     {                              //\\    <logical-and-expression> <rest-of-logical-or-expression>;
     t[1] = compile(P(1), depth+1 /* P_logical_and_expression */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_logical_or_expression */);
     return t[0] = P_mktuple(P_logical_or_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-logical-or-expression> =
   case P_rest_of_logical_or_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "||" <logical-and-expression> <rest-of-logical-or-expression>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_logical_and_expression */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_logical_or_expression */);
       return t[0] = P_mktuple(P_rest_of_logical_or_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_logical_or_expression, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<logical-and-expression> =
   case P_logical_and_expression:
#ifdef IN_PARSER

#endif
     {                              //\\    <inclusive-or-expression> <rest-of-logical-and-expression>;
     t[1] = compile(P(1), depth+1 /* P_inclusive_or_expression */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_logical_and_expression */);
     return t[0] = P_mktuple(P_logical_and_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-logical-and-expression> =
   case P_rest_of_logical_and_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "&&" <inclusive-or-expression> <rest-of-logical-and-expression>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_inclusive_or_expression */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_logical_and_expression */);
       return t[0] = P_mktuple(P_rest_of_logical_and_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_logical_and_expression, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<inclusive-or-expression> =
   case P_inclusive_or_expression:
#ifdef IN_PARSER

#endif
     {                              //\\    <exclusive-or-expression> <rest-of-inclusive-or-expression>;
     t[1] = compile(P(1), depth+1 /* P_exclusive_or_expression */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_inclusive_or_expression */);
     return t[0] = P_mktuple(P_inclusive_or_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-inclusive-or-expression> =
   case P_rest_of_inclusive_or_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '|' <exclusive-or-expression> <rest-of-inclusive-or-expression>,
       t[1] = wlit(P(1) /*, L'|' */);
       t[2] = compile(P(2), depth+1 /* P_exclusive_or_expression */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_inclusive_or_expression */);
       return t[0] = P_mktuple(P_rest_of_inclusive_or_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_inclusive_or_expression, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<exclusive-or-expression> =
   case P_exclusive_or_expression:
#ifdef IN_PARSER

#endif
     {                              //\\    <bitwise-and-expression> <rest-of-exclusive-or-expression>;
     t[1] = compile(P(1), depth+1 /* P_bitwise_and_expression */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_exclusive_or_expression */);
     return t[0] = P_mktuple(P_exclusive_or_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-exclusive-or-expression> =
   case P_rest_of_exclusive_or_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '^' <bitwise-and-expression> <rest-of-exclusive-or-expression>,
       t[1] = wlit(P(1) /*, L'^' */);
       t[2] = compile(P(2), depth+1 /* P_bitwise_and_expression */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_exclusive_or_expression */);
       return t[0] = P_mktuple(P_rest_of_exclusive_or_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_exclusive_or_expression, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<bitwise-and-expression> =
   case P_bitwise_and_expression:
#ifdef IN_PARSER

#endif
     {                              //\\    <equality-expression> <rest-of-bitwise-and-expression>;
     t[1] = compile(P(1), depth+1 /* P_equality_expression */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_bitwise_and_expression */);
     return t[0] = P_mktuple(P_bitwise_and_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-bitwise-and-expression> =
   case P_rest_of_bitwise_and_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '&' <equality-expression> <rest-of-bitwise-and-expression>,
       t[1] = wlit(P(1) /*, L'&' */);
       t[2] = compile(P(2), depth+1 /* P_equality_expression */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_bitwise_and_expression */);
       return t[0] = P_mktuple(P_rest_of_bitwise_and_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_bitwise_and_expression, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<equality-expression> =
   case P_equality_expression:
#ifdef IN_PARSER

#endif
     {                              //\\    <relational-expression> <rest-of-equality-expression>;
     t[1] = compile(P(1), depth+1 /* P_relational_expression */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_equality_expression */);
     return t[0] = P_mktuple(P_equality_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-equality-expression> =
   case P_rest_of_equality_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <eqop> <relational-expression> <rest-of-equality-expression>,
       t[1] = compile(P(1), depth+1 /* P_eqop */);
       t[2] = compile(P(2), depth+1 /* P_relational_expression */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_equality_expression */);
       return t[0] = P_mktuple(P_rest_of_equality_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_equality_expression, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<relational-expression> =
   case P_relational_expression:
#ifdef IN_PARSER

#endif
     {                              //\\    <shift-expression> <rest-of-relational-expression>;
     t[1] = compile(P(1), depth+1 /* P_shift_expression */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_relational_expression */);
     return t[0] = P_mktuple(P_relational_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-relational-expression> =
   case P_rest_of_relational_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <relop> <shift-expression> <rest-of-relational-expression>,
       t[1] = compile(P(1), depth+1 /* P_relop */);
       t[2] = compile(P(2), depth+1 /* P_shift_expression */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_relational_expression */);
       return t[0] = P_mktuple(P_rest_of_relational_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_relational_expression, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<shift-expression> =
   case P_shift_expression:
#ifdef IN_PARSER

#endif
     {                              //\\    <additive-expression> <rest-of-shift-expression>;
     t[1] = compile(P(1), depth+1 /* P_additive_expression */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_shift_expression */);
     return t[0] = P_mktuple(P_shift_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-shift-expression> =
   case P_rest_of_shift_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <shiftop> <additive-expression> <rest-of-shift-expression>,
       t[1] = compile(P(1), depth+1 /* P_shiftop */);
       t[2] = compile(P(2), depth+1 /* P_additive_expression */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_shift_expression */);
       return t[0] = P_mktuple(P_rest_of_shift_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_shift_expression, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<additive-expression> =
   case P_additive_expression:
#ifdef IN_PARSER

#endif
     {                              //\\    <multiplicative-expression> <rest-of-additive-expression>;
     t[1] = compile(P(1), depth+1 /* P_multiplicative_expression */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_additive_expression */);
     return t[0] = P_mktuple(P_additive_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-additive-expression> =
   case P_rest_of_additive_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <plusminus> <multiplicative-expression> <rest-of-additive-expression>,
       t[1] = compile(P(1), depth+1 /* P_plusminus */);
       t[2] = compile(P(2), depth+1 /* P_multiplicative_expression */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_additive_expression */);
       return t[0] = P_mktuple(P_rest_of_additive_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_additive_expression, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<multiplicative-expression> =
   case P_multiplicative_expression:
#ifdef IN_PARSER

#endif
     {                              //\\    <unary-rvalue-expression> <rest-of-multiplicative-expression>;
     t[1] = compile(P(1), depth+1 /* P_unary_rvalue_expression */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_multiplicative_expression */);
     return t[0] = P_mktuple(P_multiplicative_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-multiplicative-expression> =
   case P_rest_of_multiplicative_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <mulop> <unary-rvalue-expression> <rest-of-multiplicative-expression>,
       t[1] = compile(P(1), depth+1 /* P_mulop */);
       t[2] = compile(P(2), depth+1 /* P_unary_rvalue_expression */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_multiplicative_expression */);
       return t[0] = P_mktuple(P_rest_of_multiplicative_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_multiplicative_expression, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<unary-rvalue-expression> =
   case P_unary_rvalue_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <cast_opt> <arithmetic-unary-op> <unary-rvalue-expression>,
       t[1] = compile(P(1), depth+1 /* P_cast_opt */);
       t[2] = compile(P(2), depth+1 /* P_arithmetic_unary_op */);
       t[3] = compile(P(3), depth+1 /* P_unary_rvalue_expression */);
       return t[0] = P_mktuple(P_unary_rvalue_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <cast_opt> <boolean-unary-ops> <unary-rvalue-expression>,
       t[1] = compile(P(1), depth+1 /* P_cast_opt */);
       t[2] = compile(P(2), depth+1 /* P_boolean_unary_ops */);
       t[3] = compile(P(3), depth+1 /* P_unary_rvalue_expression */);
       return t[0] = P_mktuple(P_unary_rvalue_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    <cast_opt> <bitwise-unary-ops> <unary-rvalue-expression>,
       t[1] = compile(P(1), depth+1 /* P_cast_opt */);
       t[2] = compile(P(2), depth+1 /* P_bitwise_unary_ops */);
       t[3] = compile(P(3), depth+1 /* P_unary_rvalue_expression */);
       return t[0] = P_mktuple(P_unary_rvalue_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    <indirection-unary-ops> <unary-address-expression>,
       t[1] = compile(P(1), depth+1 /* P_indirection_unary_ops */);
       t[2] = compile(P(2), depth+1 /* P_unary_address_expression */);
       return t[0] = P_mktuple(P_unary_rvalue_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    <cast_opt> "sizeof" <unary-rvalue-expression>,
       t[1] = compile(P(1), depth+1 /* P_cast_opt */);
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_unary_rvalue_expression */);
       return t[0] = P_mktuple(P_unary_rvalue_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 5)        {  //\\    <cast_opt> "sizeof" <unary-lvalue-expression>,
       t[1] = compile(P(1), depth+1 /* P_cast_opt */);
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_unary_lvalue_expression */);
       return t[0] = P_mktuple(P_unary_rvalue_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 6)        {  //\\    <cast_opt> "sizeof" <type-specifier> <indirection-unary-ops_opt>,
       t[1] = compile(P(1), depth+1 /* P_cast_opt */);
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_type_specifier */);
       t[4] = compile(P(4), depth+1 /* P_indirection_unary_ops_opt */);
       return t[0] = P_mktuple(P_unary_rvalue_expression, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 7)        {  //\\    <cast_opt> "sizeof" '(' <type-specifier> <indirection-unary-ops_opt> ')',
       t[1] = compile(P(1), depth+1 /* P_cast_opt */);
       t[2] = wlit(P(2));
       t[3] = wlit(P(3) /*, L'(' */);
       t[4] = compile(P(4), depth+1 /* P_type_specifier */);
       t[5] = compile(P(5), depth+1 /* P_indirection_unary_ops_opt */);
       t[6] = wlit(P(6) /*, L')' */);
       return t[0] = P_mktuple(P_unary_rvalue_expression, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <postfix-rvalue-expression>;
       t[1] = compile(P(1), depth+1 /* P_postfix_rvalue_expression */);
       return t[0] = P_mktuple(P_unary_rvalue_expression, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<postfix-rvalue-expression> =
   case P_postfix_rvalue_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <primary-expression> <rest-of-postfix-rvalue-expression>,
       t[1] = compile(P(1), depth+1 /* P_primary_expression */);
       t[2] = compile(P(2), depth+1 /* P_rest_of_postfix_rvalue_expression */);
       return t[0] = P_mktuple(P_postfix_rvalue_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <unary-lvalue-expression> <rest-of-postfix-rvalue-expression>;
       t[1] = compile(P(1), depth+1 /* P_unary_lvalue_expression */);
       t[2] = compile(P(2), depth+1 /* P_rest_of_postfix_rvalue_expression */);
       return t[0] = P_mktuple(P_postfix_rvalue_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-postfix-rvalue-expression> =
   case P_rest_of_postfix_rvalue_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '[' <HACK1> <expression> <HACK2> ']' <rest-of-postfix-rvalue-expression>,
       t[1] = wlit(P(1) /*, L'[' */);
       t[2] = compile(P(2), depth+1 /* P_HACK1 */);
       t[3] = compile(P(3), depth+1 /* P_expression */);
       t[4] = compile(P(4), depth+1 /* P_HACK2 */);
       t[5] = wlit(P(5) /*, L']' */);
       t[6] = compile(P(6), depth+1 /* P_rest_of_postfix_rvalue_expression */);
       return t[0] = P_mktuple(P_rest_of_postfix_rvalue_expression, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    '(' <actual-param-list> ')' <rest-of-postfix-rvalue-expression>,
       t[1] = wlit(P(1) /*, L'(' */);
       t[2] = compile(P(2), depth+1 /* P_actual_param_list */);
       t[3] = wlit(P(3) /*, L')' */);
       t[4] = compile(P(4), depth+1 /* P_rest_of_postfix_rvalue_expression */);
       return t[0] = P_mktuple(P_rest_of_postfix_rvalue_expression, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    '.' <tag> <rest-of-postfix-rvalue-expression>,
       t[1] = wlit(P(1) /*, L'.' */);
       t[2] = compile(P(2), depth+1 /* P_tag */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_postfix_rvalue_expression */);
       return t[0] = P_mktuple(P_rest_of_postfix_rvalue_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    "->" <tag> <rest-of-postfix-rvalue-expression>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_tag */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_postfix_rvalue_expression */);
       return t[0] = P_mktuple(P_rest_of_postfix_rvalue_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    <post-increment-op> <rest-of-postfix-rvalue-expression>,
       t[1] = compile(P(1), depth+1 /* P_post_increment_op */);
       t[2] = compile(P(2), depth+1 /* P_rest_of_postfix_rvalue_expression */);
       return t[0] = P_mktuple(P_rest_of_postfix_rvalue_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_postfix_rvalue_expression, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<post-increment-op> =
   case P_post_increment_op:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "++",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_post_increment_op, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "--";
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_post_increment_op, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<actual-param-list> =
   case P_actual_param_list:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <assignment-expression> <rest-of-param-list>,
       t[1] = compile(P(1), depth+1 /* P_assignment_expression */);
       t[2] = compile(P(2), depth+1 /* P_rest_of_param_list */);
       return t[0] = P_mktuple(P_actual_param_list, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_actual_param_list, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-param-list> =
   case P_rest_of_param_list:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <assignment-expression> <rest-of-param-list>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_assignment_expression */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_param_list */);
       return t[0] = P_mktuple(P_rest_of_param_list, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_param_list, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<unary-lvalue-expression> =
   case P_unary_lvalue_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <cast_opt> <pre-increment-op> <unary-lvalue-expression>,
       t[1] = compile(P(1), depth+1 /* P_cast_opt */);
       t[2] = compile(P(2), depth+1 /* P_pre_increment_op */);
       t[3] = compile(P(3), depth+1 /* P_unary_lvalue_expression */);
       return t[0] = P_mktuple(P_unary_lvalue_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <indirection-unary-ops> <unary-lvalue-expression>,
       t[1] = compile(P(1), depth+1 /* P_indirection_unary_ops */);
       t[2] = compile(P(2), depth+1 /* P_unary_lvalue_expression */);
       return t[0] = P_mktuple(P_unary_lvalue_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    <unary-address-expression>,
       t[1] = compile(P(1), depth+1 /* P_unary_address_expression */);
       return t[0] = P_mktuple(P_unary_lvalue_expression, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <postfix-lvalue-expression>;
       t[1] = compile(P(1), depth+1 /* P_postfix_lvalue_expression */);
       return t[0] = P_mktuple(P_unary_lvalue_expression, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<postfix-lvalue-expression> =
   case P_postfix_lvalue_expression:
#ifdef IN_PARSER

#endif
     {                              //\\    <primary-expression> <rest-of-postfix-expression>;
     t[1] = compile(P(1), depth+1 /* P_primary_expression */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_postfix_expression */);
     return t[0] = P_mktuple(P_postfix_lvalue_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-postfix-expression> =
   case P_rest_of_postfix_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '[' <HACK1> <expression> <HACK2> ']' <rest-of-postfix-expression>,
       t[1] = wlit(P(1) /*, L'[' */);
       t[2] = compile(P(2), depth+1 /* P_HACK1 */);
       t[3] = compile(P(3), depth+1 /* P_expression */);
       t[4] = compile(P(4), depth+1 /* P_HACK2 */);
       t[5] = wlit(P(5) /*, L']' */);
       t[6] = compile(P(6), depth+1 /* P_rest_of_postfix_expression */);
       return t[0] = P_mktuple(P_rest_of_postfix_expression, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    '(' <actual-param-list> ')' <non-empty-rest-of-postfix-expression>,
       t[1] = wlit(P(1) /*, L'(' */);
       t[2] = compile(P(2), depth+1 /* P_actual_param_list */);
       t[3] = wlit(P(3) /*, L')' */);
       t[4] = compile(P(4), depth+1 /* P_non_empty_rest_of_postfix_expression */);
       return t[0] = P_mktuple(P_rest_of_postfix_expression, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    '.' <tag> <rest-of-postfix-expression>,
       t[1] = wlit(P(1) /*, L'.' */);
       t[2] = compile(P(2), depth+1 /* P_tag */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_postfix_expression */);
       return t[0] = P_mktuple(P_rest_of_postfix_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    "->" <tag> <rest-of-postfix-expression>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_tag */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_postfix_expression */);
       return t[0] = P_mktuple(P_rest_of_postfix_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    <post-increment-op> <rest-of-postfix-expression>,
       t[1] = compile(P(1), depth+1 /* P_post_increment_op */);
       t[2] = compile(P(2), depth+1 /* P_rest_of_postfix_expression */);
       return t[0] = P_mktuple(P_rest_of_postfix_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_postfix_expression, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<non-empty-rest-of-postfix-expression> =
   case P_non_empty_rest_of_postfix_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '[' <HACK1> <expression> <HACK2> ']' <rest-of-postfix-expression>,
       t[1] = wlit(P(1) /*, L'[' */);
       t[2] = compile(P(2), depth+1 /* P_HACK1 */);
       t[3] = compile(P(3), depth+1 /* P_expression */);
       t[4] = compile(P(4), depth+1 /* P_HACK2 */);
       t[5] = wlit(P(5) /*, L']' */);
       t[6] = compile(P(6), depth+1 /* P_rest_of_postfix_expression */);
       return t[0] = P_mktuple(P_non_empty_rest_of_postfix_expression, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    '(' <actual-param-list> ')' <non-empty-rest-of-postfix-expression>,
       t[1] = wlit(P(1) /*, L'(' */);
       t[2] = compile(P(2), depth+1 /* P_actual_param_list */);
       t[3] = wlit(P(3) /*, L')' */);
       t[4] = compile(P(4), depth+1 /* P_non_empty_rest_of_postfix_expression */);
       return t[0] = P_mktuple(P_non_empty_rest_of_postfix_expression, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    '.' <tag> <rest-of-postfix-expression>,
       t[1] = wlit(P(1) /*, L'.' */);
       t[2] = compile(P(2), depth+1 /* P_tag */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_postfix_expression */);
       return t[0] = P_mktuple(P_non_empty_rest_of_postfix_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    "->" <tag> <rest-of-postfix-expression>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_tag */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_postfix_expression */);
       return t[0] = P_mktuple(P_non_empty_rest_of_postfix_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <post-increment-op> <rest-of-postfix-expression>;
       t[1] = compile(P(1), depth+1 /* P_post_increment_op */);
       t[2] = compile(P(2), depth+1 /* P_rest_of_postfix_expression */);
       return t[0] = P_mktuple(P_non_empty_rest_of_postfix_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<unary-address-expression> =
   case P_unary_address_expression:
#ifdef IN_PARSER

#endif
     {                              //\\    <cast_opt> <address-operator> <unary-lvalue-expression>;
     t[1] = compile(P(1), depth+1 /* P_cast_opt */);
     t[2] = compile(P(2), depth+1 /* P_address_operator */);
     t[3] = compile(P(3), depth+1 /* P_unary_lvalue_expression */);
     return t[0] = P_mktuple(P_unary_address_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<primary-expression> =
   case P_primary_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <cast_opt> <identifier>,
       t[1] = compile(P(1), depth+1 /* P_cast_opt */);
       t[2] = compile(P(2), depth+1 /* P_identifier */);
       return t[0] = P_mktuple(P_primary_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <cast_opt> <constant>,
       t[1] = compile(P(1), depth+1 /* P_cast_opt */);
       t[2] = compile(P(2), depth+1 /* P_constant */);
       return t[0] = P_mktuple(P_primary_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    <cast_opt> <dqstring>,
       t[1] = compile(P(1), depth+1 /* P_cast_opt */);
       t[2] = compile(P(2), depth+1 /* P_dqstring */);
       return t[0] = P_mktuple(P_primary_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    '(' <expression> ')',
       t[1] = wlit(P(1) /*, L'(' */);
       t[2] = compile(P(2), depth+1 /* P_expression */);
       t[3] = wlit(P(3) /*, L')' */);
       return t[0] = P_mktuple(P_primary_expression, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    <cast> '(' <expression> ')',
       t[1] = compile(P(1), depth+1 /* P_cast */);
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_expression */);
       t[4] = wlit(P(4) /*, L')' */);
       return t[0] = P_mktuple(P_primary_expression, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 5)        {  //\\    <cast> <cast> '(' <expression> ')',
       t[1] = compile(P(1), depth+1 /* P_cast */);
       t[2] = compile(P(2), depth+1 /* P_cast */);
       t[3] = wlit(P(3) /*, L'(' */);
       t[4] = compile(P(4), depth+1 /* P_expression */);
       t[5] = wlit(P(5) /*, L')' */);
       return t[0] = P_mktuple(P_primary_expression, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 6)        {  //\\    <cast> <cast> <cast> '(' <expression> ')',
       t[1] = compile(P(1), depth+1 /* P_cast */);
       t[2] = compile(P(2), depth+1 /* P_cast */);
       t[3] = compile(P(3), depth+1 /* P_cast */);
       t[4] = wlit(P(4) /*, L'(' */);
       t[5] = compile(P(5), depth+1 /* P_expression */);
       t[6] = wlit(P(6) /*, L')' */);
       return t[0] = P_mktuple(P_primary_expression, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <cast> <cast> <cast> <cast> '(' <expression> ')';
       t[1] = compile(P(1), depth+1 /* P_cast */);
       t[2] = compile(P(2), depth+1 /* P_cast */);
       t[3] = compile(P(3), depth+1 /* P_cast */);
       t[4] = compile(P(4), depth+1 /* P_cast */);
       t[5] = wlit(P(5) /*, L'(' */);
       t[6] = compile(P(6), depth+1 /* P_expression */);
       t[7] = wlit(P(7) /*, L')' */);
       return t[0] = P_mktuple(P_primary_expression, alt, 7/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<cast_opt> =
   case P_cast_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <cast> <cast_opt>,
       t[1] = compile(P(1), depth+1 /* P_cast */);
       t[2] = compile(P(2), depth+1 /* P_cast_opt */);
       return t[0] = P_mktuple(P_cast_opt, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_cast_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<cast> =
   case P_cast:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '(' <type-specifier> <indirection-unary-ops_opt> ')',
       t[1] = wlit(P(1) /*, L'(' */);
       t[2] = compile(P(2), depth+1 /* P_type_specifier */);
       t[3] = compile(P(3), depth+1 /* P_indirection_unary_ops_opt */);
       t[4] = wlit(P(4) /*, L')' */);
       return t[0] = P_mktuple(P_cast, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    '(' "typeof" '(' <unary-lvalue-expression> ')' ')',
       t[1] = wlit(P(1) /*, L'(' */);
       t[2] = wlit(P(2));
       t[3] = wlit(P(3) /*, L'(' */);
       t[4] = compile(P(4), depth+1 /* P_unary_lvalue_expression */);
       t[5] = wlit(P(5) /*, L')' */);
       t[6] = wlit(P(6) /*, L')' */);
       return t[0] = P_mktuple(P_cast, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    '(' "typeof" '(' <type-specifier> <indirection-unary-ops_opt> ')' ')';
       t[1] = wlit(P(1) /*, L'(' */);
       t[2] = wlit(P(2));
       t[3] = wlit(P(3) /*, L'(' */);
       t[4] = compile(P(4), depth+1 /* P_type_specifier */);
       t[5] = compile(P(5), depth+1 /* P_indirection_unary_ops_opt */);
       t[6] = wlit(P(6) /*, L')' */);
       t[7] = wlit(P(7) /*, L')' */);
       return t[0] = P_mktuple(P_cast, alt, 7/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<indirection-decl_opt> =
   case P_indirection_decl_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <const-or-volatile-type-qualifier_opt> '*' <indirection-decl_opt>,
       t[1] = compile(P(1), depth+1 /* P_const_or_volatile_type_qualifier_opt */);
       t[2] = wlit(P(2) /*, L'*' */);
       t[3] = compile(P(3), depth+1 /* P_indirection_decl_opt */);
       return t[0] = P_mktuple(P_indirection_decl_opt, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_indirection_decl_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<indirection-unary-ops> =
   case P_indirection_unary_ops:
#ifdef IN_PARSER

#endif
     {                              //\\    <cast_opt> '*' <indirection-unary-ops_opt>;
     t[1] = compile(P(1), depth+1 /* P_cast_opt */);
     t[2] = wlit(P(2) /*, L'*' */);
     t[3] = compile(P(3), depth+1 /* P_indirection_unary_ops_opt */);
     return t[0] = P_mktuple(P_indirection_unary_ops, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<indirection-unary-ops_opt> =
   case P_indirection_unary_ops_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '*' <indirection-unary-ops_opt>,
       t[1] = wlit(P(1) /*, L'*' */);
       t[2] = compile(P(2), depth+1 /* P_indirection_unary_ops_opt */);
       return t[0] = P_mktuple(P_indirection_unary_ops_opt, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_indirection_unary_ops_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<type-specifier> =
   case P_type_specifier:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <basic-type-specifier>,
       t[1] = compile(P(1), depth+1 /* P_basic_type_specifier */);
       return t[0] = P_mktuple(P_type_specifier, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <typedef-name>;
       t[1] = compile(P(1), depth+1 /* P_typedef_name */);
       return t[0] = P_mktuple(P_type_specifier, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<typedef-name> =
   case P_typedef_name:
#ifdef IN_PARSER

#endif
     {                              //\\    <identifier>;
     t[1] = compile(P(1), depth+1 /* P_identifier */);
     return t[0] = P_mktuple(P_typedef_name, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<basic-type-specifier> =
   case P_basic_type_specifier:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "void",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_basic_type_specifier, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "double",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_basic_type_specifier, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    "long" "double",
       t[1] = wlit(P(1));
       t[2] = wlit(P(2));
       return t[0] = P_mktuple(P_basic_type_specifier, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    "float",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_basic_type_specifier, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    <signed_opt> "char",
       t[1] = compile(P(1), depth+1 /* P_signed_opt */);
       t[2] = wlit(P(2));
       return t[0] = P_mktuple(P_basic_type_specifier, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 5)        {  //\\    <signed-inttype>,
       t[1] = compile(P(1), depth+1 /* P_signed_inttype */);
       return t[0] = P_mktuple(P_basic_type_specifier, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 6)        {  //\\    <struct-or-union-specifier>,
       t[1] = compile(P(1), depth+1 /* P_struct_or_union_specifier */);
       return t[0] = P_mktuple(P_basic_type_specifier, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <enum-specifier>;
       t[1] = compile(P(1), depth+1 /* P_enum_specifier */);
       return t[0] = P_mktuple(P_basic_type_specifier, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<enum-specifier> =
   case P_enum_specifier:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "enum" '{' <enumerator-list> '}',
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'{' */);
       t[3] = compile(P(3), depth+1 /* P_enumerator_list */);
       t[4] = wlit(P(4) /*, L'}' */);
       return t[0] = P_mktuple(P_enum_specifier, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "enum" <identifier> '{' <enumerator-list> '}',
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_identifier */);
       t[3] = wlit(P(3) /*, L'{' */);
       t[4] = compile(P(4), depth+1 /* P_enumerator_list */);
       t[5] = wlit(P(5) /*, L'}' */);
       return t[0] = P_mktuple(P_enum_specifier, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "enum" <identifier>;
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_identifier */);
       return t[0] = P_mktuple(P_enum_specifier, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<enumerator-list> =
   case P_enumerator_list:
#ifdef IN_PARSER

#endif
     {                              //\\    <enumerator> <rest-of-enumerator-list>;
     t[1] = compile(P(1), depth+1 /* P_enumerator */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_enumerator_list */);
     return t[0] = P_mktuple(P_enumerator_list, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-enumerator-list> =
   case P_rest_of_enumerator_list:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <enumerator> <rest-of-enumerator-list>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_enumerator */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_enumerator_list */);
       return t[0] = P_mktuple(P_rest_of_enumerator_list, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    ',',
       t[1] = wlit(P(1) /*, L',' */);
       return t[0] = P_mktuple(P_rest_of_enumerator_list, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_enumerator_list, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<enumerator> =
   case P_enumerator:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <identifier> '=' <constant-expression>,
       t[1] = compile(P(1), depth+1 /* P_identifier */);
       t[2] = wlit(P(2) /*, L'=' */);
       t[3] = compile(P(3), depth+1 /* P_constant_expression */);
       return t[0] = P_mktuple(P_enumerator, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <identifier>;
       t[1] = compile(P(1), depth+1 /* P_identifier */);
       return t[0] = P_mktuple(P_enumerator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<constant-expression> =
   case P_constant_expression:
#ifdef IN_PARSER

#endif
     {                              //\\    <conditional-expression>;
     t[1] = compile(P(1), depth+1 /* P_conditional_expression */);
     return t[0] = P_mktuple(P_constant_expression, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<signed-inttype> =
   case P_signed_inttype:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <signed_opt> "short" <int_opt>,
       t[1] = compile(P(1), depth+1 /* P_signed_opt */);
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_int_opt */);
       return t[0] = P_mktuple(P_signed_inttype, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <signed_opt> "long" "long" <int_opt>,
       t[1] = compile(P(1), depth+1 /* P_signed_opt */);
       t[2] = wlit(P(2));
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_int_opt */);
       return t[0] = P_mktuple(P_signed_inttype, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    <signed_opt> "long" <int_opt>,
       t[1] = compile(P(1), depth+1 /* P_signed_opt */);
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_int_opt */);
       return t[0] = P_mktuple(P_signed_inttype, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    <signed_opt> "int",
       t[1] = compile(P(1), depth+1 /* P_signed_opt */);
       t[2] = wlit(P(2));
       return t[0] = P_mktuple(P_signed_inttype, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    "signed",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_signed_inttype, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "unsigned";
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_signed_inttype, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<int_opt> =
   case P_int_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "int",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_int_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_int_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<signed_opt> =
   case P_signed_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "signed",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_signed_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "unsigned",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_signed_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_signed_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<address-operator> =
   case P_address_operator:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "&&",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_address_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    '&';
       t[1] = wlit(P(1) /*, L'&' */);
       return t[0] = P_mktuple(P_address_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<pre-increment-op> =
   case P_pre_increment_op:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "++",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_pre_increment_op, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "--";
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_pre_increment_op, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<bitwise-unary-ops> =
   case P_bitwise_unary_ops:
#ifdef IN_PARSER

#endif
     {                              //\\    '~' <rest-of-bitwise-unary-ops>;
     t[1] = wlit(P(1) /*, L'~' */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_bitwise_unary_ops */);
     return t[0] = P_mktuple(P_bitwise_unary_ops, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-bitwise-unary-ops> =
   case P_rest_of_bitwise_unary_ops:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '~' <rest-of-bitwise-unary-ops>,
       t[1] = wlit(P(1) /*, L'~' */);
       t[2] = compile(P(2), depth+1 /* P_rest_of_bitwise_unary_ops */);
       return t[0] = P_mktuple(P_rest_of_bitwise_unary_ops, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_bitwise_unary_ops, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<boolean-unary-ops> =
   case P_boolean_unary_ops:
#ifdef IN_PARSER

#endif
     {                              //\\    '!' <rest-of-boolean-unary-ops>;
     t[1] = wlit(P(1) /*, L'!' */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_boolean_unary_ops */);
     return t[0] = P_mktuple(P_boolean_unary_ops, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-boolean-unary-ops> =
   case P_rest_of_boolean_unary_ops:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '!' <rest-of-boolean-unary-ops>,
       t[1] = wlit(P(1) /*, L'!' */);
       t[2] = compile(P(2), depth+1 /* P_rest_of_boolean_unary_ops */);
       return t[0] = P_mktuple(P_rest_of_boolean_unary_ops, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_boolean_unary_ops, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<arithmetic-unary-op> =
   case P_arithmetic_unary_op:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '+',
       t[1] = wlit(P(1) /*, L'+' */);
       return t[0] = P_mktuple(P_arithmetic_unary_op, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    '-';
       t[1] = wlit(P(1) /*, L'-' */);
       return t[0] = P_mktuple(P_arithmetic_unary_op, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<mulop> =
   case P_mulop:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '*',
       t[1] = wlit(P(1) /*, L'*' */);
       return t[0] = P_mktuple(P_mulop, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    '/',
       t[1] = wlit(P(1) /*, L'/' */);
       return t[0] = P_mktuple(P_mulop, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    '%';
       t[1] = wlit(P(1) /*, L'%' */);
       return t[0] = P_mktuple(P_mulop, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<plusminus> =
   case P_plusminus:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '+',
       t[1] = wlit(P(1) /*, L'+' */);
       return t[0] = P_mktuple(P_plusminus, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    '-';
       t[1] = wlit(P(1) /*, L'-' */);
       return t[0] = P_mktuple(P_plusminus, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<shiftop> =
   case P_shiftop:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "<<",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_shiftop, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ">>";
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_shiftop, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<relop> =
   case P_relop:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "<=",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_relop, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    '<',
       t[1] = wlit(P(1) /*, L'<' */);
       return t[0] = P_mktuple(P_relop, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    ">=",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_relop, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    '>';
       t[1] = wlit(P(1) /*, L'>' */);
       return t[0] = P_mktuple(P_relop, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<eqop> =
   case P_eqop:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "==",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_eqop, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "!=";
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_eqop, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<eq> =
   case P_eq:
#ifdef IN_PARSER

#endif
     {                              //\\    '=';
     t[1] = wlit(P(1) /*, L'=' */);
     return t[0] = P_mktuple(P_eq, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<assignment-operator> =
   case P_assignment_operator:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '=' <!eq>,
       t[1] = wlit(P(1) /*, L'=' */);
       t[2] = -1; /* ignore negative guard */;
       return t[0] = P_mktuple(P_assignment_operator, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "*=",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_assignment_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    "/=",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_assignment_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    "%=",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_assignment_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    "+=",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_assignment_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 5)        {  //\\    "-=",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_assignment_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 6)        {  //\\    "<<=",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_assignment_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 7)        {  //\\    ">>=",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_assignment_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 8)        {  //\\    "&=",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_assignment_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 9)        {  //\\    "^=",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_assignment_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "|=";
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_assignment_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<lvalue-assign_opt> =
   case P_lvalue_assign_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <unary-lvalue-expression> <assignment-operator>,
       t[1] = compile(P(1), depth+1 /* P_unary_lvalue_expression */);
       t[2] = compile(P(2), depth+1 /* P_assignment_operator */);
       return t[0] = P_mktuple(P_lvalue_assign_opt, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_lvalue_assign_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<array-init_opt> =
   case P_array_init_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '=' '{' <constant-initializer-list> '}',
       t[1] = wlit(P(1) /*, L'=' */);
       t[2] = wlit(P(2) /*, L'{' */);
       t[3] = compile(P(3), depth+1 /* P_constant_initializer_list */);
       t[4] = wlit(P(4) /*, L'}' */);
       return t[0] = P_mktuple(P_array_init_opt, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    '=' <dqstring>,
       t[1] = wlit(P(1) /*, L'=' */);
       t[2] = compile(P(2), depth+1 /* P_dqstring */);
       return t[0] = P_mktuple(P_array_init_opt, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_array_init_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<constant-initializer-list> =
   case P_constant_initializer_list:
#ifdef IN_PARSER

#endif
     {                              //\\    <constant-initializer> <rest-of-constant-initializer-list>;
     t[1] = compile(P(1), depth+1 /* P_constant_initializer */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_constant_initializer_list */);
     return t[0] = P_mktuple(P_constant_initializer_list, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-constant-initializer-list> =
   case P_rest_of_constant_initializer_list:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <constant-initializer> <rest-of-constant-initializer-list>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_constant_initializer */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_constant_initializer_list */);
       return t[0] = P_mktuple(P_rest_of_constant_initializer_list, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    ',',
       t[1] = wlit(P(1) /*, L',' */);
       return t[0] = P_mktuple(P_rest_of_constant_initializer_list, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_constant_initializer_list, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<constant-initializer> =
   case P_constant_initializer:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <constant-expression>,
       t[1] = compile(P(1), depth+1 /* P_constant_expression */);
       return t[0] = P_mktuple(P_constant_initializer, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    '{' <constant-initializer-list> '}';
       t[1] = wlit(P(1) /*, L'{' */);
       t[2] = compile(P(2), depth+1 /* P_constant_initializer_list */);
       t[3] = wlit(P(3) /*, L'}' */);
       return t[0] = P_mktuple(P_constant_initializer, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<HACK1> =
   case P_HACK1:
#ifdef IN_PARSER

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

#endif
     {                              //\\    ;

     return t[0] = P_mktuple(P_HACK1, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<HACK2> =
   case P_HACK2:
#ifdef IN_PARSER

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

#endif
     {                              //\\    ;

     return t[0] = P_mktuple(P_HACK2, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<array-bounds> =
   case P_array_bounds:
#ifdef IN_PARSER

#endif
     {                              //\\    '[' <HACK1> <constant-expression_opt> <HACK2> ']' <array-bounds_opt>;
     t[1] = wlit(P(1) /*, L'[' */);
     t[2] = compile(P(2), depth+1 /* P_HACK1 */);
     t[3] = compile(P(3), depth+1 /* P_constant_expression_opt */);
     t[4] = compile(P(4), depth+1 /* P_HACK2 */);
     t[5] = wlit(P(5) /*, L']' */);
     t[6] = compile(P(6), depth+1 /* P_array_bounds_opt */);
     return t[0] = P_mktuple(P_array_bounds, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<array-bounds_opt> =
   case P_array_bounds_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '[' <HACK1> <constant-expression_opt> <HACK2> ']' <array-bounds_opt>,
       t[1] = wlit(P(1) /*, L'[' */);
       t[2] = compile(P(2), depth+1 /* P_HACK1 */);
       t[3] = compile(P(3), depth+1 /* P_constant_expression_opt */);
       t[4] = compile(P(4), depth+1 /* P_HACK2 */);
       t[5] = wlit(P(5) /*, L']' */);
       t[6] = compile(P(6), depth+1 /* P_array_bounds_opt */);
       return t[0] = P_mktuple(P_array_bounds_opt, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_array_bounds_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<constant-expression_opt> =
   case P_constant_expression_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <constant-expression>,
       t[1] = compile(P(1), depth+1 /* P_constant_expression */);
       return t[0] = P_mktuple(P_constant_expression_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_constant_expression_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<type> =
   case P_type:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <type-specifier>,
       t[1] = compile(P(1), depth+1 /* P_type_specifier */);
       return t[0] = P_mktuple(P_type, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <enum-specifier>,
       t[1] = compile(P(1), depth+1 /* P_enum_specifier */);
       return t[0] = P_mktuple(P_type, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    <struct-or-union-specifier>,
       t[1] = compile(P(1), depth+1 /* P_struct_or_union_specifier */);
       return t[0] = P_mktuple(P_type, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    "typeof" '(' <unary-lvalue-expression> ')',
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_unary_lvalue_expression */);
       t[4] = wlit(P(4) /*, L')' */);
       return t[0] = P_mktuple(P_type, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    "typeof" '(' <type-specifier> <indirection-unary-ops_opt> ')',
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_type_specifier */);
       t[4] = compile(P(4), depth+1 /* P_indirection_unary_ops_opt */);
       t[5] = wlit(P(5) /*, L')' */);
       return t[0] = P_mktuple(P_type, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "void";
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_type, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<const-or-volatile-type-qualifier_opt> =
   case P_const_or_volatile_type_qualifier_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <const-or-volatile-type-qualifier>,
       t[1] = compile(P(1), depth+1 /* P_const_or_volatile_type_qualifier */);
       return t[0] = P_mktuple(P_const_or_volatile_type_qualifier_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_const_or_volatile_type_qualifier_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<const-or-volatile-type-qualifier> =
   case P_const_or_volatile_type_qualifier:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "const",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_const_or_volatile_type_qualifier, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "volatile";
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_const_or_volatile_type_qualifier, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<auto-reg-static-ext_opt> =
   case P_auto_reg_static_ext_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "auto",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_auto_reg_static_ext_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "register",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_auto_reg_static_ext_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    "static",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_auto_reg_static_ext_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    "extern",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_auto_reg_static_ext_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_auto_reg_static_ext_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<identifier-list> =
   case P_identifier_list:
#ifdef IN_PARSER

#endif
     {                              //\\    <new-identifier> <rest-of-identifier-list>;
     t[1] = compile(P(1), depth+1 /* P_new_identifier */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_identifier_list */);
     return t[0] = P_mktuple(P_identifier_list, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-identifier-list> =
   case P_rest_of_identifier_list:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <identifier-list>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_identifier_list */);
       return t[0] = P_mktuple(P_rest_of_identifier_list, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_identifier_list, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<more-forward-decls-or-actual-body> =
   case P_more_forward_decls_or_actual_body:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <extern-proc-name-and-params-list_opt> ';',
       t[1] = compile(P(1), depth+1 /* P_extern_proc_name_and_params_list_opt */);
       t[2] = wlit(P(2) /*, L';' */);
       return t[0] = P_mktuple(P_more_forward_decls_or_actual_body, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <compound-statement>;
       t[1] = compile(P(1), depth+1 /* P_compound_statement */);
       return t[0] = P_mktuple(P_more_forward_decls_or_actual_body, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<extern-proc-spec> =
   case P_extern_proc_spec:
#ifdef IN_PARSER

#endif
     {                              //\\    <auto-reg-static-ext_opt> <const-or-volatile-type-qualifier_opt> <basic-type-specifier-or-typedef-name_opt>;
     t[1] = compile(P(1), depth+1 /* P_auto_reg_static_ext_opt */);
     t[2] = compile(P(2), depth+1 /* P_const_or_volatile_type_qualifier_opt */);
     t[3] = compile(P(3), depth+1 /* P_basic_type_specifier_or_typedef_name_opt */);
     return t[0] = P_mktuple(P_extern_proc_spec, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<basic-type-specifier-or-typedef-name_opt> =
   case P_basic_type_specifier_or_typedef_name_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <typedef-name>,
       t[1] = compile(P(1), depth+1 /* P_typedef_name */);
       return t[0] = P_mktuple(P_basic_type_specifier_or_typedef_name_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <basic-type-specifier_opt>;
       t[1] = compile(P(1), depth+1 /* P_basic_type_specifier_opt */);
       return t[0] = P_mktuple(P_basic_type_specifier_or_typedef_name_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<identifier-or-function-pointer> =
   case P_identifier_or_function_pointer:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '(' '*' <new-identifier> ')',
       t[1] = wlit(P(1) /*, L'(' */);
       t[2] = wlit(P(2) /*, L'*' */);
       t[3] = compile(P(3), depth+1 /* P_new_identifier */);
       t[4] = wlit(P(4) /*, L')' */);
       return t[0] = P_mktuple(P_identifier_or_function_pointer, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <new-identifier>;
       t[1] = compile(P(1), depth+1 /* P_new_identifier */);
       return t[0] = P_mktuple(P_identifier_or_function_pointer, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<extern-proc-name-and-params> =
   case P_extern_proc_name_and_params:
#ifdef IN_PARSER

#endif
     {                              //\\    <indirection-decl_opt> <identifier-or-function-pointer> '(' <param-list_opt> ')';
     t[1] = compile(P(1), depth+1 /* P_indirection_decl_opt */);
     t[2] = compile(P(2), depth+1 /* P_identifier_or_function_pointer */);
     t[3] = wlit(P(3) /*, L'(' */);
     t[4] = compile(P(4), depth+1 /* P_param_list_opt */);
     t[5] = wlit(P(5) /*, L')' */);
     return t[0] = P_mktuple(P_extern_proc_name_and_params, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<extern-proc-name-and-params-list_opt> =
   case P_extern_proc_name_and_params_list_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <extern-proc-name-and-params> <extern-proc-name-and-params-list_opt>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_extern_proc_name_and_params */);
       t[3] = compile(P(3), depth+1 /* P_extern_proc_name_and_params_list_opt */);
       return t[0] = P_mktuple(P_extern_proc_name_and_params_list_opt, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_extern_proc_name_and_params_list_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<proc-fn-decl> =
   case P_proc_fn_decl:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <extern-proc-spec> <extern-proc-name-and-params> <more-forward-decls-or-actual-body>,
       t[1] = compile(P(1), depth+1 /* P_extern_proc_spec */);
       t[2] = compile(P(2), depth+1 /* P_extern_proc_name_and_params */);
       t[3] = compile(P(3), depth+1 /* P_more_forward_decls_or_actual_body */);
       return t[0] = P_mktuple(P_proc_fn_decl, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <extern-proc-spec> <indirection-decl_opt> <new-identifier> '(' <identifier-list> ')' <oldstyle-param-list_opt> ';' <compound-statement>;
       t[1] = compile(P(1), depth+1 /* P_extern_proc_spec */);
       t[2] = compile(P(2), depth+1 /* P_indirection_decl_opt */);
       t[3] = compile(P(3), depth+1 /* P_new_identifier */);
       t[4] = wlit(P(4) /*, L'(' */);
       t[5] = compile(P(5), depth+1 /* P_identifier_list */);
       t[6] = wlit(P(6) /*, L')' */);
       t[7] = compile(P(7), depth+1 /* P_oldstyle_param_list_opt */);
       t[8] = wlit(P(8) /*, L';' */);
       t[9] = compile(P(9), depth+1 /* P_compound_statement */);
       return t[0] = P_mktuple(P_proc_fn_decl, alt, 9/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<compound-statement> =
   case P_compound_statement:
#ifdef IN_PARSER

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

#endif
     if (alt == 0)               {  //\\    '{' '}',
       t[1] = wlit(P(1) /*, L'{' */);
       t[2] = wlit(P(2) /*, L'}' */);
       return t[0] = P_mktuple(P_compound_statement, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    '{' <statement-list> '}';
       t[1] = wlit(P(1) /*, L'{' */);
       t[2] = compile(P(2), depth+1 /* P_statement_list */);
       t[3] = wlit(P(3) /*, L'}' */);
       return t[0] = P_mktuple(P_compound_statement, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<statement-list> =
   case P_statement_list:
#ifdef IN_PARSER

#endif
     {                              //\\    <labels_opt> <statement> <rest-of-statement-list>;
     t[1] = compile(P(1), depth+1 /* P_labels_opt */);
     t[2] = compile(P(2), depth+1 /* P_statement */);
     t[3] = compile(P(3), depth+1 /* P_rest_of_statement_list */);
     return t[0] = P_mktuple(P_statement_list, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-statement-list> =
   case P_rest_of_statement_list:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <labels_opt> <statement> <rest-of-statement-list>,
       t[1] = compile(P(1), depth+1 /* P_labels_opt */);
       t[2] = compile(P(2), depth+1 /* P_statement */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_statement_list */);
       return t[0] = P_mktuple(P_rest_of_statement_list, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_statement_list, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<statement> =
   case P_statement:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ';',
       t[1] = wlit(P(1) /*, L';' */);
       return t[0] = P_mktuple(P_statement, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <compound-statement>,
       t[1] = compile(P(1), depth+1 /* P_compound_statement */);
       return t[0] = P_mktuple(P_statement, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    <selection-statement>,
       t[1] = compile(P(1), depth+1 /* P_selection_statement */);
       return t[0] = P_mktuple(P_statement, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    <iteration-statement>,
       t[1] = compile(P(1), depth+1 /* P_iteration_statement */);
       return t[0] = P_mktuple(P_statement, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    <jump-statement>,
       t[1] = compile(P(1), depth+1 /* P_jump_statement */);
       return t[0] = P_mktuple(P_statement, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 5)        {  //\\    <expression> ';',
       t[1] = compile(P(1), depth+1 /* P_expression */);
       t[2] = wlit(P(2) /*, L';' */);
       return t[0] = P_mktuple(P_statement, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 6)        {  //\\    <extern-proc-spec> <extern-proc-name-and-params> <more-forward-decls-or-actual-body>,
       t[1] = compile(P(1), depth+1 /* P_extern_proc_spec */);
       t[2] = compile(P(2), depth+1 /* P_extern_proc_name_and_params */);
       t[3] = compile(P(3), depth+1 /* P_more_forward_decls_or_actual_body */);
       return t[0] = P_mktuple(P_statement, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 7)        {  //\\    <in-proc-data-declaration>,
       t[1] = compile(P(1), depth+1 /* P_in_proc_data_declaration */);
       return t[0] = P_mktuple(P_statement, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <external-declaration-list>;
       t[1] = compile(P(1), depth+1 /* P_external_declaration_list */);
       return t[0] = P_mktuple(P_statement, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<in-proc-data-declaration> =
   case P_in_proc_data_declaration:
#ifdef IN_PARSER

#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[1] = compile(P(1), depth+1 /* P_auto_reg_static_ext_opt */);
       t[2] = compile(P(2), depth+1 /* P_const_or_volatile_type_qualifier_opt */);
       t[3] = compile(P(3), depth+1 /* P_type */);
       t[4] = compile(P(4), depth+1 /* P_const_or_volatile_type_qualifier_opt */);
       t[5] = compile(P(5), depth+1 /* P_decl_list */);
       return t[0] = P_mktuple(P_in_proc_data_declaration, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <struct-decl>;
       t[1] = compile(P(1), depth+1 /* P_struct_decl */);
       return t[0] = P_mktuple(P_in_proc_data_declaration, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<struct-decl> =
   case P_struct_decl:
#ifdef IN_PARSER

#endif
     {                              //\\    "struct" <new-structname> '{' <struct-member-list> '}';
     t[1] = wlit(P(1));
     t[2] = compile(P(2), depth+1 /* P_new_structname */);
     t[3] = wlit(P(3) /*, L'{' */);
     t[4] = compile(P(4), depth+1 /* P_struct_member_list */);
     t[5] = wlit(P(5) /*, L'}' */);
     return t[0] = P_mktuple(P_struct_decl, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<struct-member-list> =
   case P_struct_member_list:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <struct-member-declaration> <struct-member-list>,
       t[1] = compile(P(1), depth+1 /* P_struct_member_declaration */);
       t[2] = compile(P(2), depth+1 /* P_struct_member_list */);
       return t[0] = P_mktuple(P_struct_member_list, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_struct_member_list, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<struct-member-declaration> =
   case P_struct_member_declaration:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <struct-decl>,
       t[1] = compile(P(1), depth+1 /* P_struct_decl */);
       return t[0] = P_mktuple(P_struct_member_declaration, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <possibly-initialised-scalar-decl>,
       t[1] = compile(P(1), depth+1 /* P_possibly_initialised_scalar_decl */);
       return t[0] = P_mktuple(P_struct_member_declaration, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <possibly-initialised-array-decl>;
       t[1] = compile(P(1), depth+1 /* P_possibly_initialised_array_decl */);
       return t[0] = P_mktuple(P_struct_member_declaration, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<possibly-initialised-array-decl> =
   case P_possibly_initialised_array_decl:
#ifdef IN_PARSER

#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[1] = compile(P(1), depth+1 /* P_auto_reg_static_ext_opt */);
     t[2] = compile(P(2), depth+1 /* P_const_or_volatile_type_qualifier_opt */);
     t[3] = compile(P(3), depth+1 /* P_type */);
     t[4] = compile(P(4), depth+1 /* P_const_or_volatile_type_qualifier_opt */);
     t[5] = compile(P(5), depth+1 /* P_indirection_decl_opt */);
     t[6] = compile(P(6), depth+1 /* P_new_identifier */);
     t[7] = compile(P(7), depth+1 /* P_array_bounds */);
     t[8] = compile(P(8), depth+1 /* P_array_init_opt */);
     t[9] = wlit(P(9) /*, L';' */);
     return t[0] = P_mktuple(P_possibly_initialised_array_decl, alt, 9/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<possibly-initialised-scalar-decl> =
   case P_possibly_initialised_scalar_decl:
#ifdef IN_PARSER

#endif
     {                              //\\    <auto-reg-static-ext_opt> <const-or-volatile-type-qualifier_opt> <type> <rest-of-scalar-decl>;
     t[1] = compile(P(1), depth+1 /* P_auto_reg_static_ext_opt */);
     t[2] = compile(P(2), depth+1 /* P_const_or_volatile_type_qualifier_opt */);
     t[3] = compile(P(3), depth+1 /* P_type */);
     t[4] = compile(P(4), depth+1 /* P_rest_of_scalar_decl */);
     return t[0] = P_mktuple(P_possibly_initialised_scalar_decl, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-scalar-decl> =
   case P_rest_of_scalar_decl:
#ifdef IN_PARSER

#endif
     {                              //\\    <indirection-decl_opt> <new-identifier> <scalar-init_opt> <rest-of-scalar-decl_opt> ';';
     t[1] = compile(P(1), depth+1 /* P_indirection_decl_opt */);
     t[2] = compile(P(2), depth+1 /* P_new_identifier */);
     t[3] = compile(P(3), depth+1 /* P_scalar_init_opt */);
     t[4] = compile(P(4), depth+1 /* P_rest_of_scalar_decl_opt */);
     t[5] = wlit(P(5) /*, L';' */);
     return t[0] = P_mktuple(P_rest_of_scalar_decl, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-scalar-decl_opt> =
   case P_rest_of_scalar_decl_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <indirection-decl_opt> <new-identifier> <scalar-init_opt> <rest-of-scalar-decl_opt>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_indirection_decl_opt */);
       t[3] = compile(P(3), depth+1 /* P_new_identifier */);
       t[4] = compile(P(4), depth+1 /* P_scalar_init_opt */);
       t[5] = compile(P(5), depth+1 /* P_rest_of_scalar_decl_opt */);
       return t[0] = P_mktuple(P_rest_of_scalar_decl_opt, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_scalar_decl_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<new-structname> =
   case P_new_structname:
#ifdef IN_PARSER

#endif
     {                              //\\    <new-identifier>;
     t[1] = compile(P(1), depth+1 /* P_new_identifier */);
     return t[0] = P_mktuple(P_new_structname, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<decl-list> =
   case P_decl_list:
#ifdef IN_PARSER

#endif
     {                              //\\    <decl> <rest-of-decl-list>;
     t[1] = compile(P(1), depth+1 /* P_decl */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_decl_list */);
     return t[0] = P_mktuple(P_decl_list, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-decl-list> =
   case P_rest_of_decl_list:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <decl-list>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_decl_list */);
       return t[0] = P_mktuple(P_rest_of_decl_list, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_decl_list, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<decl> =
   case P_decl:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <indirection-decl_opt> <new-identifier> <possibly-empty-array-bounds-list> <array-init_opt>,
       t[1] = compile(P(1), depth+1 /* P_indirection_decl_opt */);
       t[2] = compile(P(2), depth+1 /* P_new_identifier */);
       t[3] = compile(P(3), depth+1 /* P_possibly_empty_array_bounds_list */);
       t[4] = compile(P(4), depth+1 /* P_array_init_opt */);
       return t[0] = P_mktuple(P_decl, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <indirection-decl_opt> <new-identifier> <scalar-init_opt>;
       t[1] = compile(P(1), depth+1 /* P_indirection_decl_opt */);
       t[2] = compile(P(2), depth+1 /* P_new_identifier */);
       t[3] = compile(P(3), depth+1 /* P_scalar_init_opt */);
       return t[0] = P_mktuple(P_decl, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<possibly-empty-array-bounds-list> =
   case P_possibly_empty_array_bounds_list:
#ifdef IN_PARSER

#endif
     {                              //\\    '[' <HACK1> <constant-expression_opt> <HACK2> ']' <optional-possibly-empty-array-bounds-list>;
     t[1] = wlit(P(1) /*, L'[' */);
     t[2] = compile(P(2), depth+1 /* P_HACK1 */);
     t[3] = compile(P(3), depth+1 /* P_constant_expression_opt */);
     t[4] = compile(P(4), depth+1 /* P_HACK2 */);
     t[5] = wlit(P(5) /*, L']' */);
     t[6] = compile(P(6), depth+1 /* P_optional_possibly_empty_array_bounds_list */);
     return t[0] = P_mktuple(P_possibly_empty_array_bounds_list, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<optional-possibly-empty-array-bounds-list> =
   case P_optional_possibly_empty_array_bounds_list:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '[' <HACK1> <constant-expression_opt> <HACK2> ']' <optional-possibly-empty-array-bounds-list>,
       t[1] = wlit(P(1) /*, L'[' */);
       t[2] = compile(P(2), depth+1 /* P_HACK1 */);
       t[3] = compile(P(3), depth+1 /* P_constant_expression_opt */);
       t[4] = compile(P(4), depth+1 /* P_HACK2 */);
       t[5] = wlit(P(5) /*, L']' */);
       t[6] = compile(P(6), depth+1 /* P_optional_possibly_empty_array_bounds_list */);
       return t[0] = P_mktuple(P_optional_possibly_empty_array_bounds_list, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_optional_possibly_empty_array_bounds_list, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<jump-statement> =
   case P_jump_statement:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "goto" <label> ';',
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_label */);
       t[3] = wlit(P(3) /*, L';' */);
       return t[0] = P_mktuple(P_jump_statement, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "continue" ';',
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L';' */);
       return t[0] = P_mktuple(P_jump_statement, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    "break" ';',
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L';' */);
       return t[0] = P_mktuple(P_jump_statement, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "return" <!followed-by-alpha> <expression_opt> ';';
       t[1] = wlit(P(1));
       t[2] = -1; /* semantic procedure followed-by-alpha */;
       t[3] = compile(P(3), depth+1 /* P_expression_opt */);
       t[4] = wlit(P(4) /*, L';' */);
       return t[0] = P_mktuple(P_jump_statement, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<expression_opt> =
   case P_expression_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <expression>,
       t[1] = compile(P(1), depth+1 /* P_expression */);
       return t[0] = P_mktuple(P_expression_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_expression_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<label> =
   case P_label:
#ifdef IN_PARSER

#endif
     {                              //\\    <identifier>;
     t[1] = compile(P(1), depth+1 /* P_identifier */);
     return t[0] = P_mktuple(P_label, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<iteration-statement> =
   case P_iteration_statement:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "while" '(' <expression> ')' <statement>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_expression */);
       t[4] = wlit(P(4) /*, L')' */);
       t[5] = compile(P(5), depth+1 /* P_statement */);
       return t[0] = P_mktuple(P_iteration_statement, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "do" <statement> "while" '(' <expression> ')' ';',
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_statement */);
       t[3] = wlit(P(3));
       t[4] = wlit(P(4) /*, L'(' */);
       t[5] = compile(P(5), depth+1 /* P_expression */);
       t[6] = wlit(P(6) /*, L')' */);
       t[7] = wlit(P(7) /*, L';' */);
       return t[0] = P_mktuple(P_iteration_statement, alt, 7/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "for" '(' <expression_opt> ';' <expression_opt> ';' <expression_opt> ')' <statement>;
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_expression_opt */);
       t[4] = wlit(P(4) /*, L';' */);
       t[5] = compile(P(5), depth+1 /* P_expression_opt */);
       t[6] = wlit(P(6) /*, L';' */);
       t[7] = compile(P(7), depth+1 /* P_expression_opt */);
       t[8] = wlit(P(8) /*, L')' */);
       t[9] = compile(P(9), depth+1 /* P_statement */);
       return t[0] = P_mktuple(P_iteration_statement, alt, 9/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<selection-statement> =
   case P_selection_statement:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "if" '(' <expression> ')' <statement> <else_opt>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_expression */);
       t[4] = wlit(P(4) /*, L')' */);
       t[5] = compile(P(5), depth+1 /* P_statement */);
       t[6] = compile(P(6), depth+1 /* P_else_opt */);
       return t[0] = P_mktuple(P_selection_statement, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "switch" '(' <expression> ')' <statement>;
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_expression */);
       t[4] = wlit(P(4) /*, L')' */);
       t[5] = compile(P(5), depth+1 /* P_statement */);
       return t[0] = P_mktuple(P_selection_statement, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<else_opt> =
   case P_else_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "else" <statement>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_statement */);
       return t[0] = P_mktuple(P_else_opt, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_else_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<missing-semicolon-after-label-at-end-of-block> =
   case P_missing_semicolon_after_label_at_end_of_block:
#ifdef IN_PARSER

#endif
     {                              //\\    '}';
     t[1] = wlit(P(1) /*, L'}' */);
     return t[0] = P_mktuple(P_missing_semicolon_after_label_at_end_of_block, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<labels_opt> =
   case P_labels_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <label> ':' <labels_opt> <!missing-semicolon-after-label-at-end-of-block>,
       t[1] = compile(P(1), depth+1 /* P_label */);
       t[2] = wlit(P(2) /*, L':' */);
       t[3] = compile(P(3), depth+1 /* P_labels_opt */);
       t[4] = -1; /* ignore negative guard */;
       return t[0] = P_mktuple(P_labels_opt, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "case" <constant-expression> ':' <labels_opt> <!missing-semicolon-after-label-at-end-of-block>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_constant_expression */);
       t[3] = wlit(P(3) /*, L':' */);
       t[4] = compile(P(4), depth+1 /* P_labels_opt */);
       t[5] = -1; /* ignore negative guard */;
       return t[0] = P_mktuple(P_labels_opt, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    "default" ':' <labels_opt> <!missing-semicolon-after-label-at-end-of-block>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L':' */);
       t[3] = compile(P(3), depth+1 /* P_labels_opt */);
       t[4] = -1; /* ignore negative guard */;
       return t[0] = P_mktuple(P_labels_opt, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_labels_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<param-list_opt> =
   case P_param_list_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <formal-param> <rest-of-param-list_opt>,
       t[1] = compile(P(1), depth+1 /* P_formal_param */);
       t[2] = compile(P(2), depth+1 /* P_rest_of_param_list_opt */);
       return t[0] = P_mktuple(P_param_list_opt, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "void",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_param_list_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_param_list_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<oldstyle-param-list_opt> =
   case P_oldstyle_param_list_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <oldstyle-param-list>,
       t[1] = compile(P(1), depth+1 /* P_oldstyle_param_list */);
       return t[0] = P_mktuple(P_oldstyle_param_list_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_oldstyle_param_list_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<oldstyle-param-list> =
   case P_oldstyle_param_list:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <oldstyle-formal-param> <rest-of-oldstyle-param-list_opt>,
       t[1] = compile(P(1), depth+1 /* P_oldstyle_formal_param */);
       t[2] = compile(P(2), depth+1 /* P_rest_of_oldstyle_param_list_opt */);
       return t[0] = P_mktuple(P_oldstyle_param_list, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "void";
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_oldstyle_param_list, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-oldstyle-param-list_opt> =
   case P_rest_of_oldstyle_param_list_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ';' <oldstyle-param-list>,
       t[1] = wlit(P(1) /*, L';' */);
       t[2] = compile(P(2), depth+1 /* P_oldstyle_param_list */);
       return t[0] = P_mktuple(P_rest_of_oldstyle_param_list_opt, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_oldstyle_param_list_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<oldstyle-formal-param> =
   case P_oldstyle_formal_param:
#ifdef IN_PARSER

#endif
     {                              //\\    <const-or-volatile-type-qualifier_opt> <type> <oldstyle-parameter-list>;
     t[1] = compile(P(1), depth+1 /* P_const_or_volatile_type_qualifier_opt */);
     t[2] = compile(P(2), depth+1 /* P_type */);
     t[3] = compile(P(3), depth+1 /* P_oldstyle_parameter_list */);
     return t[0] = P_mktuple(P_oldstyle_formal_param, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<oldstyle-parameter-list> =
   case P_oldstyle_parameter_list:
#ifdef IN_PARSER

#endif
     {                              //\\    <whatever> <rest-of-oldstyle-parameter-list>;
     t[1] = compile(P(1), depth+1 /* P_whatever */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_oldstyle_parameter_list */);
     return t[0] = P_mktuple(P_oldstyle_parameter_list, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-oldstyle-parameter-list> =
   case P_rest_of_oldstyle_parameter_list:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <oldstyle-parameter-list>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_oldstyle_parameter_list */);
       return t[0] = P_mktuple(P_rest_of_oldstyle_parameter_list, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_oldstyle_parameter_list, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<whatever> =
   case P_whatever:
#ifdef IN_PARSER

#endif
     {                              //\\    <indirection-decl_opt> <identifier_opt> <optional-possibly-empty-array-bounds-list>;
     t[1] = compile(P(1), depth+1 /* P_indirection_decl_opt */);
     t[2] = compile(P(2), depth+1 /* P_identifier_opt */);
     t[3] = compile(P(3), depth+1 /* P_optional_possibly_empty_array_bounds_list */);
     return t[0] = P_mktuple(P_whatever, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-param-list_opt> =
   case P_rest_of_param_list_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' "...",
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = wlit(P(2));
       return t[0] = P_mktuple(P_rest_of_param_list_opt, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    ',' <formal-param> <rest-of-param-list_opt>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_formal_param */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_param_list_opt */);
       return t[0] = P_mktuple(P_rest_of_param_list_opt, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_param_list_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<formal-param> =
   case P_formal_param:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <procedure-as-parameter>,
       t[1] = compile(P(1), depth+1 /* P_procedure_as_parameter */);
       return t[0] = P_mktuple(P_formal_param, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <const-or-volatile-type-qualifier_opt> <type> <indirection-decl_opt> <identifier_opt> <optional-possibly-empty-array-bounds-list>;
       t[1] = compile(P(1), depth+1 /* P_const_or_volatile_type_qualifier_opt */);
       t[2] = compile(P(2), depth+1 /* P_type */);
       t[3] = compile(P(3), depth+1 /* P_indirection_decl_opt */);
       t[4] = compile(P(4), depth+1 /* P_identifier_opt */);
       t[5] = compile(P(5), depth+1 /* P_optional_possibly_empty_array_bounds_list */);
       return t[0] = P_mktuple(P_formal_param, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<identifier_opt> =
   case P_identifier_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <identifier>,
       t[1] = compile(P(1), depth+1 /* P_identifier */);
       return t[0] = P_mktuple(P_identifier_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_identifier_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<procedure-as-parameter> =
   case P_procedure_as_parameter:
#ifdef IN_PARSER

#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[1] = compile(P(1), depth+1 /* P_auto_reg_static_ext_opt */);
       t[2] = compile(P(2), depth+1 /* P_const_or_volatile_type_qualifier_opt */);
       t[3] = compile(P(3), depth+1 /* P_basic_type_specifier_opt */);
       t[4] = wlit(P(4) /*, L'(' */);
       t[5] = compile(P(5), depth+1 /* P_indirection_decl_opt */);
       t[6] = compile(P(6), depth+1 /* P_new_identifier */);
       t[7] = wlit(P(7) /*, L')' */);
       t[8] = wlit(P(8) /*, L'(' */);
       t[9] = compile(P(9), depth+1 /* P_param_list_opt */);
       t[10] = wlit(P(10) /*, L')' */);
       return t[0] = P_mktuple(P_procedure_as_parameter, alt, 10/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <auto-reg-static-ext_opt> <const-or-volatile-type-qualifier_opt> <typedef-name> '(' <indirection-decl_opt> <new-identifier> ')' '(' <param-list_opt> ')';
       t[1] = compile(P(1), depth+1 /* P_auto_reg_static_ext_opt */);
       t[2] = compile(P(2), depth+1 /* P_const_or_volatile_type_qualifier_opt */);
       t[3] = compile(P(3), depth+1 /* P_typedef_name */);
       t[4] = wlit(P(4) /*, L'(' */);
       t[5] = compile(P(5), depth+1 /* P_indirection_decl_opt */);
       t[6] = compile(P(6), depth+1 /* P_new_identifier */);
       t[7] = wlit(P(7) /*, L')' */);
       t[8] = wlit(P(8) /*, L'(' */);
       t[9] = compile(P(9), depth+1 /* P_param_list_opt */);
       t[10] = wlit(P(10) /*, L')' */);
       return t[0] = P_mktuple(P_procedure_as_parameter, alt, 10/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<basic-type-specifier_opt> =
   case P_basic_type_specifier_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <basic-type-specifier>,
       t[1] = compile(P(1), depth+1 /* P_basic_type_specifier */);
       return t[0] = P_mktuple(P_basic_type_specifier_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_basic_type_specifier_opt, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<typedef-declaration> =
   case P_typedef_declaration:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "typedef" <type-specifier> <indirection-decl_opt> '(' <indirection-decl_opt> <new-identifier> ')' '(' <param-list_opt> ')',
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_type_specifier */);
       t[3] = compile(P(3), depth+1 /* P_indirection_decl_opt */);
       t[4] = wlit(P(4) /*, L'(' */);
       t[5] = compile(P(5), depth+1 /* P_indirection_decl_opt */);
       t[6] = compile(P(6), depth+1 /* P_new_identifier */);
       t[7] = wlit(P(7) /*, L')' */);
       t[8] = wlit(P(8) /*, L'(' */);
       t[9] = compile(P(9), depth+1 /* P_param_list_opt */);
       t[10] = wlit(P(10) /*, L')' */);
       return t[0] = P_mktuple(P_typedef_declaration, alt, 10/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "typedef" <const-or-volatile-type-qualifier_opt> <type-specifier> <const-or-volatile-type-qualifier_opt> <decl-list>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_const_or_volatile_type_qualifier_opt */);
       t[3] = compile(P(3), depth+1 /* P_type_specifier */);
       t[4] = compile(P(4), depth+1 /* P_const_or_volatile_type_qualifier_opt */);
       t[5] = compile(P(5), depth+1 /* P_decl_list */);
       return t[0] = P_mktuple(P_typedef_declaration, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    "typedef" <struct-decl> <maybe-indirect-typedef-name-list>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_struct_decl */);
       t[3] = compile(P(3), depth+1 /* P_maybe_indirect_typedef_name_list */);
       return t[0] = P_mktuple(P_typedef_declaration, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "typedef" <type-specifier> <maybe-indirect-typedef-name-list>;
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_type_specifier */);
       t[3] = compile(P(3), depth+1 /* P_maybe_indirect_typedef_name_list */);
       return t[0] = P_mktuple(P_typedef_declaration, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<maybe-indirect-typedef-name-list> =
   case P_maybe_indirect_typedef_name_list:
#ifdef IN_PARSER

#endif
     {                              //\\    <indirection-decl_opt> <typedef-name> <rest-of-maybe-indirect-typedef-name-list>;
     t[1] = compile(P(1), depth+1 /* P_indirection_decl_opt */);
     t[2] = compile(P(2), depth+1 /* P_typedef_name */);
     t[3] = compile(P(3), depth+1 /* P_rest_of_maybe_indirect_typedef_name_list */);
     return t[0] = P_mktuple(P_maybe_indirect_typedef_name_list, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest-of-maybe-indirect-typedef-name-list> =
   case P_rest_of_maybe_indirect_typedef_name_list:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <maybe-indirect-typedef-name-list>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_maybe_indirect_typedef_name_list */);
       return t[0] = P_mktuple(P_rest_of_maybe_indirect_typedef_name_list, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

       return t[0] = P_mktuple(P_rest_of_maybe_indirect_typedef_name_list, alt, 0/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ E
   default:
     return r;
  }
}