// 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<SS> =
   case P_SS:
#ifdef IN_PARSER

#endif
     {                              //\\    <Imp77_stropping> <NL_opt> <STATEMENTS> <FINAL>;
     t[1] = -1; /* semantic procedure Imp77_stropping */;
     t[2] = compile(P(2), depth+1 /* P_NL_opt */);
     t[3] = compile(P(3), depth+1 /* P_STATEMENTS */);
     t[4] = compile(P(4), depth+1 /* P_FINAL */);
     return t[0] = P_mktuple(P_SS, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<FINAL> =
   case P_FINAL:
#ifdef IN_PARSER

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

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

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

     }
//\\ P<STATEMENTS> =
   case P_STATEMENTS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <STATEMENT> <STATEMENTS>,
       t[1] = compile(P(1), depth+1 /* P_STATEMENT */);
       t[2] = compile(P(2), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENTS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<STATEMENT> =
   case P_STATEMENT:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <Declaration> <T> <STATEMENTS>,
       t[1] = compile(P(1), depth+1 /* P_Declaration */);
       t[2] = compile(P(2), depth+1 /* P_T */);
       t[3] = compile(P(3), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <simple_label> <T> <STATEMENTS>,
       t[1] = compile(P(1), depth+1 /* P_simple_label */);
       t[2] = compile(P(2), depth+1 /* P_T */);
       t[3] = compile(P(3), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    <simple_label> <STATEMENTS>,
       t[1] = compile(P(1), depth+1 /* P_simple_label */);
       t[2] = compile(P(2), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    <switch_label> <T> <STATEMENTS>,
       t[1] = compile(P(1), depth+1 /* P_switch_label */);
       t[2] = compile(P(2), depth+1 /* P_T */);
       t[3] = compile(P(3), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    <switch_label> <STATEMENTS>,
       t[1] = compile(P(1), depth+1 /* P_switch_label */);
       t[2] = compile(P(2), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 5)        {  //\\    <FELSE_opt> <if_or_unless> <COND> "start" <T> <STATEMENTS>,
       t[1] = compile(P(1), depth+1 /* P_FELSE_opt */);
       t[2] = compile(P(2), depth+1 /* P_if_or_unless */);
       t[3] = compile(P(3), depth+1 /* P_COND */);
       t[4] = wlit(P(4));
       t[5] = compile(P(5), depth+1 /* P_T */);
       t[6] = compile(P(6), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 6)        {  //\\    <FELSE_opt> <if_or_unless> <COND> "then" "start" <T> <STATEMENTS>,
       t[1] = compile(P(1), depth+1 /* P_FELSE_opt */);
       t[2] = compile(P(2), depth+1 /* P_if_or_unless */);
       t[3] = compile(P(3), depth+1 /* P_COND */);
       t[4] = wlit(P(4));
       t[5] = wlit(P(5));
       t[6] = compile(P(6), depth+1 /* P_T */);
       t[7] = compile(P(7), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 7/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 7)        {  //\\    <FELSE_opt> <if_or_unless> <COND> "then" <IMP> <else_final_IMP_opt> <T> <STATEMENTS>,
       t[1] = compile(P(1), depth+1 /* P_FELSE_opt */);
       t[2] = compile(P(2), depth+1 /* P_if_or_unless */);
       t[3] = compile(P(3), depth+1 /* P_COND */);
       t[4] = wlit(P(4));
       t[5] = compile(P(5), depth+1 /* P_IMP */);
       t[6] = compile(P(6), depth+1 /* P_else_final_IMP_opt */);
       t[7] = compile(P(7), depth+1 /* P_T */);
       t[8] = compile(P(8), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 8/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 8)        {  //\\    "finish" "else" "start" <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2));
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_T */);
       t[5] = compile(P(5), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 9)        {  //\\    "finish" "else" <IMP> <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_IMP */);
       t[4] = compile(P(4), depth+1 /* P_T */);
       t[5] = compile(P(5), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 10)        {  //\\    "else" <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_T */);
       t[3] = compile(P(3), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 11)        {  //\\    "else" <if_or_unless> <COND> <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_if_or_unless */);
       t[3] = compile(P(3), depth+1 /* P_COND */);
       t[4] = compile(P(4), depth+1 /* P_T */);
       t[5] = compile(P(5), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 12)        {  //\\    "else" <if_or_unless> <COND> "then" <IMP> <else_if_unless_XIMP_opt> <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_if_or_unless */);
       t[3] = compile(P(3), depth+1 /* P_COND */);
       t[4] = wlit(P(4));
       t[5] = compile(P(5), depth+1 /* P_IMP */);
       t[6] = compile(P(6), depth+1 /* P_else_if_unless_XIMP_opt */);
       t[7] = compile(P(7), depth+1 /* P_T */);
       t[8] = compile(P(8), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 8/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 13)        {  //\\    "finish" <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_T */);
       t[3] = compile(P(3), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 14)        {  //\\    "begin" <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_T */);
       t[3] = compile(P(3), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 15)        {  //\\    "program" <IDENT> <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_IDENT */);
       t[3] = compile(P(3), depth+1 /* P_T */);
       t[4] = compile(P(4), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 16)        {  //\\    "list" <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_T */);
       t[3] = compile(P(3), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 17)        {  //\\    "endofperm" <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_T */);
       t[3] = compile(P(3), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 18)        {  //\\    "endoflist" <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_T */);
       t[3] = compile(P(3), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 19)        {  //\\    "end" <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_T */);
       t[3] = compile(P(3), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 20)        {  //\\    "cycle" <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_T */);
       t[3] = compile(P(3), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 21)        {  //\\    "cycle" <SEQ> <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_SEQ */);
       t[3] = compile(P(3), depth+1 /* P_T */);
       t[4] = compile(P(4), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 22)        {  //\\    <wh_for> <cycle_IMP> <T> <STATEMENTS>,
       t[1] = compile(P(1), depth+1 /* P_wh_for */);
       t[2] = compile(P(2), depth+1 /* P_cycle_IMP */);
       t[3] = compile(P(3), depth+1 /* P_T */);
       t[4] = compile(P(4), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 23)        {  //\\    "repeat" <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_T */);
       t[3] = compile(P(3), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 24)        {  //\\    "repeat" "until" <COND> <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_COND */);
       t[4] = compile(P(4), depth+1 /* P_T */);
       t[5] = compile(P(5), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 25)        {  //\\    <on_event> <event_list_def> "start" <T> <STATEMENTS>,
       t[1] = compile(P(1), depth+1 /* P_on_event */);
       t[2] = compile(P(2), depth+1 /* P_event_list_def */);
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_T */);
       t[5] = compile(P(5), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 26)        {  //\\    "control" <IEXP> <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_IEXP */);
       t[3] = compile(P(3), depth+1 /* P_T */);
       t[4] = compile(P(4), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 27)        {  //\\    "diagnose" <IEXP> <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_IEXP */);
       t[3] = compile(P(3), depth+1 /* P_T */);
       t[4] = compile(P(4), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 28)        {  //\\    '*' '=' <IEXP> <T> <STATEMENTS>,
       t[1] = wlit(P(1) /*, L'*' */);
       t[2] = wlit(P(2) /*, L'=' */);
       t[3] = compile(P(3), depth+1 /* P_IEXP */);
       t[4] = compile(P(4), depth+1 /* P_T */);
       t[5] = compile(P(5), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

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

     } else if (alt == 30)        {  //\\    "include" <?dq> <CONST> <INCL_LIST_opt> <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = -1; /* ignore guard */;
       t[3] = compile(P(3), depth+1 /* P_CONST */);
       t[4] = compile(P(4), depth+1 /* P_INCL_LIST_opt */);
       t[5] = compile(P(5), depth+1 /* P_T */);
       t[6] = compile(P(6), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 31)        {  //\\    "realslong" <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_T */);
       t[3] = compile(P(3), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 32)        {  //\\    "realsnormal" <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_T */);
       t[3] = compile(P(3), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 33)        {  //\\    "option" <OCONST> <T> <STATEMENTS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_OCONST */);
       t[3] = compile(P(3), depth+1 /* P_T */);
       t[4] = compile(P(4), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 34)        {  //\\    <IMP> <iu_while_until_for_T> <STATEMENTS>,
       t[1] = compile(P(1), depth+1 /* P_IMP */);
       t[2] = compile(P(2), depth+1 /* P_iu_while_until_for_T */);
       t[3] = compile(P(3), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <COMMENT_T> <STATEMENTS>;
       t[1] = compile(P(1), depth+1 /* P_COMMENT_T */);
       t[2] = compile(P(2), depth+1 /* P_STATEMENTS */);
       return t[0] = P_mktuple(P_STATEMENT, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<IDENT> =
   case P_IDENT:
#ifdef IN_PARSER

#endif
     {                              //\\    <!CONST> «[A-Z][A-Z0-9 ]*»;
     t[1] = -1; /* ignore negative guard */;
     t[2] = wlit(P(2));
     return t[0] = P_mktuple(P_IDENT, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<DeepBase> =
   case P_DeepBase:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '_' «[0-9A-Z][0-9A-Z ]*» <DeepBase>,
       t[1] = wlit(P(1) /*, L'_' */);
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_DeepBase */);
       return t[0] = P_mktuple(P_DeepBase, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<Based_Const> =
   case P_Based_Const:
#ifdef IN_PARSER

#endif
     {                              //\\    '_' «[0-9A-Z][0-9A-Z ]*» <DeepBase>;
     t[1] = wlit(P(1) /*, L'_' */);
     t[2] = wlit(P(2));
     t[3] = compile(P(3), depth+1 /* P_DeepBase */);
     return t[0] = P_mktuple(P_Based_Const, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<BigCharConst> =
   case P_BigCharConst:
#ifdef IN_PARSER

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

     }
//\\ P<CharConst> =
   case P_CharConst:
#ifdef IN_PARSER

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

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

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

     }
//\\ P<OptExponent> =
   case P_OptExponent:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<OptDecimal> =
   case P_OptDecimal:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<Base_or_Float> =
   case P_Base_or_Float:
#ifdef IN_PARSER

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

     } else                      {  //\\    <OptDecimal> <OptExponent>;
       t[1] = compile(P(1), depth+1 /* P_OptDecimal */);
       t[2] = compile(P(2), depth+1 /* P_OptExponent */);
       return t[0] = P_mktuple(P_Base_or_Float, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<Num> =
   case P_Num:
#ifdef IN_PARSER

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

     }
//\\ P<CONST> =
   case P_CONST:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <Num> <Base_or_Float>,
       t[1] = compile(P(1), depth+1 /* P_Num */);
       t[2] = compile(P(2), depth+1 /* P_Base_or_Float */);
       return t[0] = P_mktuple(P_CONST, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

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

     } else if (alt == 2)        {  //\\    <ALIASTEXT>,
       t[1] = compile(P(1), depth+1 /* P_ALIASTEXT */);
       return t[0] = P_mktuple(P_CONST, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    «[MBKXR]» <BigCharConst>;
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_BigCharConst */);
       return t[0] = P_mktuple(P_CONST, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<stringchars> =
   case P_stringchars:
#ifdef IN_PARSER

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

     } else if (alt == 1)        {  //\\    <!dq> <any> <stringchars>,
       t[1] = -1; /* ignore negative guard */;
       t[2] = compile(P(2), depth+1 /* P_any */);
       t[3] = compile(P(3), depth+1 /* P_stringchars */);
       return t[0] = P_mktuple(P_stringchars, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<ALIASTEXT> =
   case P_ALIASTEXT:
#ifdef IN_PARSER

#endif
     {                              //\\    <dq> <stringchars> <dq>;
     t[1] = compile(P(1), depth+1 /* P_dq */);
     t[2] = compile(P(2), depth+1 /* P_stringchars */);
     t[3] = compile(P(3), depth+1 /* P_dq */);
     return t[0] = P_mktuple(P_ALIASTEXT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<V> =
   case P_V:
#ifdef IN_PARSER
  fprintf(stderr, "[V]");  
#endif
     {                              //\\    <IDENT> <ESC_ARRAY_or_REC>;
     t[1] = compile(P(1), depth+1 /* P_IDENT */);
     t[2] = compile(P(2), depth+1 /* P_ESC_ARRAY_or_REC */);
     return t[0] = P_mktuple(P_V, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<N> =
   case P_N:
#ifdef IN_PARSER
  fprintf(stderr, "[N]");  
#endif
     {                              //\\    <IDENT> <ESC_ARRAY_or_REC>;
     t[1] = compile(P(1), depth+1 /* P_IDENT */);
     t[2] = compile(P(2), depth+1 /* P_ESC_ARRAY_or_REC */);
     return t[0] = P_mktuple(P_N, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<FM> =
   case P_FM:
#ifdef IN_PARSER
  fprintf(stderr, "[FM]"); 
#endif
     {                              //\\    <IDENT> <ESC_ARRAY_or_REC>;
     t[1] = compile(P(1), depth+1 /* P_IDENT */);
     t[2] = compile(P(2), depth+1 /* P_ESC_ARRAY_or_REC */);
     return t[0] = P_mktuple(P_FM, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<A> =
   case P_A:
#ifdef IN_PARSER
  fprintf(stderr, "[A]");
#endif
     {                              //\\    <IDENT> <ESC_ARRAY_or_REC>;
     t[1] = compile(P(1), depth+1 /* P_IDENT */);
     t[2] = compile(P(2), depth+1 /* P_ESC_ARRAY_or_REC */);
     return t[0] = P_mktuple(P_A, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<AN> =
   case P_AN:
#ifdef IN_PARSER
  fprintf(stderr, "[AN]");
#endif
     {                              //\\    <IDENT> <ESC_ARRAY_or_REC>;
     t[1] = compile(P(1), depth+1 /* P_IDENT */);
     t[2] = compile(P(2), depth+1 /* P_ESC_ARRAY_or_REC */);
     return t[0] = P_mktuple(P_AN, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<NA> =
   case P_NA:
#ifdef IN_PARSER
  fprintf(stderr, "[NA]");
#endif
     {                              //\\    <IDENT> <ESC_ARRAY_or_REC>;
     t[1] = compile(P(1), depth+1 /* P_IDENT */);
     t[2] = compile(P(2), depth+1 /* P_ESC_ARRAY_or_REC */);
     return t[0] = P_mktuple(P_NA, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<NAN> =
   case P_NAN:
#ifdef IN_PARSER
  fprintf(stderr, "[NAN]");
#endif
     {                              //\\    <IDENT> <ESC_ARRAY_or_REC>;
     t[1] = compile(P(1), depth+1 /* P_IDENT */);
     t[2] = compile(P(2), depth+1 /* P_ESC_ARRAY_or_REC */);
     return t[0] = P_mktuple(P_NAN, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<any> =
   case P_any:
#ifdef IN_PARSER

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

     }
//\\ P<NL_opt> =
   case P_NL_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <SS> <NL_opt>,
       t[1] = wlit(P(1) /*, L"NL" */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       return t[0] = P_mktuple(P_NL_opt, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<more_Ts> =
   case P_more_Ts:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<T> =
   case P_T:
#ifdef IN_PARSER

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

     } else                      {  //\\    <SS> <more_Ts>;
       t[1] = wlit(P(1) /*, L"NL" */);
       t[2] = compile(P(2), depth+1 /* P_more_Ts */);
       return t[0] = P_mktuple(P_T, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<simple_type> =
   case P_simple_type:
#ifdef IN_PARSER

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

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

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

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

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

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

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

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

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

     }
//\\ P<routine_or_predicate> =
   case P_routine_or_predicate:
#ifdef IN_PARSER
 fprintf(stderr, (alt == 1) ? "[R]" : "[P]"); 
#endif
     if (alt == 0)               {  //\\    "routine",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_routine_or_predicate, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<fn_or_map> =
   case P_fn_or_map:
#ifdef IN_PARSER
 fprintf(stderr, (alt <= 2) ? "[F]" : "[M]"); 
#endif
     if (alt == 0)               {  //\\    "function",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_fn_or_map, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

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

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

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

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

     }
//\\ P<OWN_or_CONST> =
   case P_OWN_or_CONST:
#ifdef IN_PARSER

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

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

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

     }
//\\ P<EXTERNAL> =
   case P_EXTERNAL:
#ifdef IN_PARSER

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

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

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

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

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

     }
//\\ P<EXTERNAL_opt> =
   case P_EXTERNAL_opt:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<COMP> =
   case P_COMP:
#ifdef IN_PARSER

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

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

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

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

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

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

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

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

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

     }
//\\ P<ACOMP> =
   case P_ACOMP:
#ifdef IN_PARSER

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

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

     }
//\\ P<exit_or_continue> =
   case P_exit_or_continue:
#ifdef IN_PARSER

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

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

     }
//\\ P<on_event> =
   case P_on_event:
#ifdef IN_PARSER

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

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

     }
//\\ P<BACK> =
   case P_BACK:
#ifdef IN_PARSER

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

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

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

     }
//\\ P<ALIAS_opt> =
   case P_ALIAS_opt:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<Rt_Pred_FPP> =
   case P_Rt_Pred_FPP:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<INDEF> =
   case P_INDEF:
#ifdef IN_PARSER

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

     }
//\\ P<INDEF_or_IEXP> =
   case P_INDEF_or_IEXP:
#ifdef IN_PARSER

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

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

     }
//\\ P<bracketed_INDEF_or_IEXP> =
   case P_bracketed_INDEF_or_IEXP:
#ifdef IN_PARSER

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

     }
//\\ P<optional_initialiser_repeat_count> =
   case P_optional_initialiser_repeat_count:
#ifdef IN_PARSER

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

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

     } else                      {  //\\    ;

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

     }
//\\ P<initialiser_item_with_optional_repeat_count> =
   case P_initialiser_item_with_optional_repeat_count:
#ifdef IN_PARSER

#endif
     {                              //\\    <IEXP> <optional_initialiser_repeat_count>;
     t[1] = compile(P(1), depth+1 /* P_IEXP */);
     t[2] = compile(P(2), depth+1 /* P_optional_initialiser_repeat_count */);
     return t[0] = P_mktuple(P_initialiser_item_with_optional_repeat_count, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<L> =
   case P_L:
#ifdef IN_PARSER

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

     }
//\\ P<SWID> =
   case P_SWID:
#ifdef IN_PARSER

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

     }
//\\ P<rest_of_SWIDS> =
   case P_rest_of_SWIDS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <SWID> <rest_of_SWIDS>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_SWID */);
       t[4] = compile(P(4), depth+1 /* P_rest_of_SWIDS */);
       return t[0] = P_mktuple(P_rest_of_SWIDS, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<SWIDS> =
   case P_SWIDS:
#ifdef IN_PARSER

#endif
     {                              //\\    <SWID> <rest_of_SWIDS>;
     t[1] = compile(P(1), depth+1 /* P_SWID */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_SWIDS */);
     return t[0] = P_mktuple(P_SWIDS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest_of_SWDEFS> =
   case P_rest_of_SWDEFS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <SWDEFS> <rest_of_SWDEFS>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_SWDEFS */);
       t[4] = compile(P(4), depth+1 /* P_rest_of_SWDEFS */);
       return t[0] = P_mktuple(P_rest_of_SWDEFS, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<SWDEFS> =
   case P_SWDEFS:
#ifdef IN_PARSER

#endif
     {                              //\\    <SWDEF> <rest_of_SWDEFS>;
     t[1] = compile(P(1), depth+1 /* P_SWDEF */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_SWDEFS */);
     return t[0] = P_mktuple(P_SWDEFS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<SWDEF> =
   case P_SWDEF:
#ifdef IN_PARSER

#endif
     {                              //\\    <SWIDS> <CONST_BOUNDS>;
     t[1] = compile(P(1), depth+1 /* P_SWIDS */);
     t[2] = compile(P(2), depth+1 /* P_CONST_BOUNDS */);
     return t[0] = P_mktuple(P_SWDEF, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<simple_label> =
   case P_simple_label:
#ifdef IN_PARSER

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

     }
//\\ P<switch_label> =
   case P_switch_label:
#ifdef IN_PARSER

#endif
     {                              //\\    <S> <bracketed_INDEF_or_IEXP> ':';
     t[1] = compile(P(1), depth+1 /* P_S */);
     t[2] = compile(P(2), depth+1 /* P_bracketed_INDEF_or_IEXP */);
     t[3] = wlit(P(3) /*, L':' */);
     return t[0] = P_mktuple(P_switch_label, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<S> =
   case P_S:
#ifdef IN_PARSER

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

     }
//\\ P<jump_destination> =
   case P_jump_destination:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <S> '(' <EXP> ')',
       t[1] = compile(P(1), depth+1 /* P_S */);
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_EXP */);
       t[4] = wlit(P(4) /*, L')' */);
       return t[0] = P_mktuple(P_jump_destination, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<Star_or_IEXP> =
   case P_Star_or_IEXP:
#ifdef IN_PARSER

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

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

     }
//\\ P<FM_or_Star> =
   case P_FM_or_Star:
#ifdef IN_PARSER

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

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

     }
//\\ P<result_types> =
   case P_result_types:
#ifdef IN_PARSER

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

     } else if (alt == 1)        {  //\\    "string" '(' <Star_or_IEXP> ')',
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_Star_or_IEXP */);
       t[4] = wlit(P(4) /*, L')' */);
       return t[0] = P_mktuple(P_result_types, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "record" '(' <FM_or_Star> ')';
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_FM_or_Star */);
       t[4] = wlit(P(4) /*, L')' */);
       return t[0] = P_mktuple(P_result_types, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<scalar_declaration_types> =
   case P_scalar_declaration_types:
#ifdef IN_PARSER

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

     } else if (alt == 1)        {  //\\    "string" '(' <IEXP> ')',
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_IEXP */);
       t[4] = wlit(P(4) /*, L')' */);
       return t[0] = P_mktuple(P_scalar_declaration_types, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "record" '(' <FM> ')';
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_FM */);
       t[4] = wlit(P(4) /*, L')' */);
       return t[0] = P_mktuple(P_scalar_declaration_types, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<name_declaration_types> =
   case P_name_declaration_types:
#ifdef IN_PARSER

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

     } else if (alt == 1)        {  //\\    "string" '(' <Star_or_IEXP> ')' "name",
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_Star_or_IEXP */);
       t[4] = wlit(P(4) /*, L')' */);
       t[5] = wlit(P(5));
       return t[0] = P_mktuple(P_name_declaration_types, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "record" '(' <FM_or_Star> ')' "name";
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_FM_or_Star */);
       t[4] = wlit(P(4) /*, L')' */);
       t[5] = wlit(P(5));
       return t[0] = P_mktuple(P_name_declaration_types, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<Rt_Fn_Map_Pred_DECL> =
   case P_Rt_Fn_Map_Pred_DECL:
#ifdef IN_PARSER

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

     } else                      {  //\\    <result_types> <fn_or_map>;
       t[1] = compile(P(1), depth+1 /* P_result_types */);
       t[2] = compile(P(2), depth+1 /* P_fn_or_map */);
       return t[0] = P_mktuple(P_Rt_Fn_Map_Pred_DECL, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<SPEC_opt> =
   case P_SPEC_opt:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<ARRAYNAME> =
   case P_ARRAYNAME:
#ifdef IN_PARSER

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

     } else                      {  //\\    "array" '(' <IEXP> ')' "name";
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_IEXP */);
       t[4] = wlit(P(4) /*, L')' */);
       t[5] = wlit(P(5));
       return t[0] = P_mktuple(P_ARRAYNAME, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<Proc_Declaration> =
   case P_Proc_Declaration:
#ifdef IN_PARSER

#endif
     {                              //\\    <EXTERNAL_opt> <Rt_Fn_Map_Pred_DECL> <SPEC_opt> <PROC_or_PROCSPEC> <IDENT> <ALIAS_opt> <Rt_Pred_FPP>;
     t[1] = compile(P(1), depth+1 /* P_EXTERNAL_opt */);
     t[2] = compile(P(2), depth+1 /* P_Rt_Fn_Map_Pred_DECL */);
     t[3] = compile(P(3), depth+1 /* P_SPEC_opt */);
     t[4] = compile(P(4), depth+1 /* P_PROC_or_PROCSPEC */);
     t[5] = compile(P(5), depth+1 /* P_IDENT */);
     t[6] = compile(P(6), depth+1 /* P_ALIAS_opt */);
     t[7] = compile(P(7), depth+1 /* P_Rt_Pred_FPP */);
     return t[0] = P_mktuple(P_Proc_Declaration, alt, 7/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<External_Name_Array_Name_Declaration> =
   case P_External_Name_Array_Name_Declaration:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <EXTERNAL> <name_declaration_types> <ARRAYNAME> "spec" <IDENTS>,
       t[1] = compile(P(1), depth+1 /* P_EXTERNAL */);
       t[2] = compile(P(2), depth+1 /* P_name_declaration_types */);
       t[3] = compile(P(3), depth+1 /* P_ARRAYNAME */);
       t[4] = wlit(P(4));
       t[5] = compile(P(5), depth+1 /* P_IDENTS */);
       return t[0] = P_mktuple(P_External_Name_Array_Name_Declaration, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <EXTERNAL> <name_declaration_types> <ARRAYNAME> <IDENTS>;
       t[1] = compile(P(1), depth+1 /* P_EXTERNAL */);
       t[2] = compile(P(2), depth+1 /* P_name_declaration_types */);
       t[3] = compile(P(3), depth+1 /* P_ARRAYNAME */);
       t[4] = compile(P(4), depth+1 /* P_IDENTS */);
       return t[0] = P_mktuple(P_External_Name_Array_Name_Declaration, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<External_Array_Name_Declaration> =
   case P_External_Array_Name_Declaration:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <EXTERNAL> <scalar_declaration_types> <ARRAYNAME> "spec" <IDENTS>,
       t[1] = compile(P(1), depth+1 /* P_EXTERNAL */);
       t[2] = compile(P(2), depth+1 /* P_scalar_declaration_types */);
       t[3] = compile(P(3), depth+1 /* P_ARRAYNAME */);
       t[4] = wlit(P(4));
       t[5] = compile(P(5), depth+1 /* P_IDENTS */);
       return t[0] = P_mktuple(P_External_Array_Name_Declaration, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <EXTERNAL> <scalar_declaration_types> <ARRAYNAME> <IDENTS>;
       t[1] = compile(P(1), depth+1 /* P_EXTERNAL */);
       t[2] = compile(P(2), depth+1 /* P_scalar_declaration_types */);
       t[3] = compile(P(3), depth+1 /* P_ARRAYNAME */);
       t[4] = compile(P(4), depth+1 /* P_IDENTS */);
       return t[0] = P_mktuple(P_External_Array_Name_Declaration, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<External_Array_Declaration> =
   case P_External_Array_Declaration:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <EXTERNAL> <scalar_declaration_types> "array" "spec" <EXTERNAL_array_idents>,
       t[1] = compile(P(1), depth+1 /* P_EXTERNAL */);
       t[2] = compile(P(2), depth+1 /* P_scalar_declaration_types */);
       t[3] = wlit(P(3));
       t[4] = wlit(P(4));
       t[5] = compile(P(5), depth+1 /* P_EXTERNAL_array_idents */);
       return t[0] = P_mktuple(P_External_Array_Declaration, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <EXTERNAL> <scalar_declaration_types> "array" <EXTERNAL_array_ident_and_optional_assignment>;
       t[1] = compile(P(1), depth+1 /* P_EXTERNAL */);
       t[2] = compile(P(2), depth+1 /* P_scalar_declaration_types */);
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_EXTERNAL_array_ident_and_optional_assignment */);
       return t[0] = P_mktuple(P_External_Array_Declaration, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<External_Name_Array_Declaration> =
   case P_External_Name_Array_Declaration:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <EXTERNAL> <name_declaration_types> "array" "spec" <EXTERNAL_name_array_idents>,
       t[1] = compile(P(1), depth+1 /* P_EXTERNAL */);
       t[2] = compile(P(2), depth+1 /* P_name_declaration_types */);
       t[3] = wlit(P(3));
       t[4] = wlit(P(4));
       t[5] = compile(P(5), depth+1 /* P_EXTERNAL_name_array_idents */);
       return t[0] = P_mktuple(P_External_Name_Array_Declaration, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <EXTERNAL> <name_declaration_types> "array" <EXTERNAL_name_array_idents>;
       t[1] = compile(P(1), depth+1 /* P_EXTERNAL */);
       t[2] = compile(P(2), depth+1 /* P_name_declaration_types */);
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_EXTERNAL_name_array_idents */);
       return t[0] = P_mktuple(P_External_Name_Array_Declaration, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<External_Scalar_Name_Declaration> =
   case P_External_Scalar_Name_Declaration:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <EXTERNAL> <name_declaration_types> "spec" <EXTERNAL_name_idents>,
       t[1] = compile(P(1), depth+1 /* P_EXTERNAL */);
       t[2] = compile(P(2), depth+1 /* P_name_declaration_types */);
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_EXTERNAL_name_idents */);
       return t[0] = P_mktuple(P_External_Scalar_Name_Declaration, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <EXTERNAL> <name_declaration_types> <EXTERNAL_name_idents_and_optional_assignments>,
       t[1] = compile(P(1), depth+1 /* P_EXTERNAL */);
       t[2] = compile(P(2), depth+1 /* P_name_declaration_types */);
       t[3] = compile(P(3), depth+1 /* P_EXTERNAL_name_idents_and_optional_assignments */);
       return t[0] = P_mktuple(P_External_Scalar_Name_Declaration, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <EXTERNAL> "name" <EXTERNAL_name_idents_and_optional_assignments>;
       t[1] = compile(P(1), depth+1 /* P_EXTERNAL */);
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_EXTERNAL_name_idents_and_optional_assignments */);
       return t[0] = P_mktuple(P_External_Scalar_Name_Declaration, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<External_Scalar_Declaration> =
   case P_External_Scalar_Declaration:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <EXTERNAL> <scalar_declaration_types> "spec" <EXTERNAL_scalar_idents>,
       t[1] = compile(P(1), depth+1 /* P_EXTERNAL */);
       t[2] = compile(P(2), depth+1 /* P_scalar_declaration_types */);
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_EXTERNAL_scalar_idents */);
       return t[0] = P_mktuple(P_External_Scalar_Declaration, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <EXTERNAL> <scalar_declaration_types> <EXTERNAL_scalar_idents_and_optional_assignments>;
       t[1] = compile(P(1), depth+1 /* P_EXTERNAL */);
       t[2] = compile(P(2), depth+1 /* P_scalar_declaration_types */);
       t[3] = compile(P(3), depth+1 /* P_EXTERNAL_scalar_idents_and_optional_assignments */);
       return t[0] = P_mktuple(P_External_Scalar_Declaration, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<OWN_or_CONST_Name_Array_Name_Declaration> =
   case P_OWN_or_CONST_Name_Array_Name_Declaration:
#ifdef IN_PARSER

#endif
     {                              //\\    <OWN_or_CONST> <name_declaration_types> <ARRAYNAME> <IDENTS>;
     t[1] = compile(P(1), depth+1 /* P_OWN_or_CONST */);
     t[2] = compile(P(2), depth+1 /* P_name_declaration_types */);
     t[3] = compile(P(3), depth+1 /* P_ARRAYNAME */);
     t[4] = compile(P(4), depth+1 /* P_IDENTS */);
     return t[0] = P_mktuple(P_OWN_or_CONST_Name_Array_Name_Declaration, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<OWN_or_CONST_Array_Name_Declaration> =
   case P_OWN_or_CONST_Array_Name_Declaration:
#ifdef IN_PARSER

#endif
     {                              //\\    <OWN_or_CONST> <scalar_declaration_types> <ARRAYNAME> <IDENTS>;
     t[1] = compile(P(1), depth+1 /* P_OWN_or_CONST */);
     t[2] = compile(P(2), depth+1 /* P_scalar_declaration_types */);
     t[3] = compile(P(3), depth+1 /* P_ARRAYNAME */);
     t[4] = compile(P(4), depth+1 /* P_IDENTS */);
     return t[0] = P_mktuple(P_OWN_or_CONST_Array_Name_Declaration, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<OWN_or_CONST_Array_Declaration> =
   case P_OWN_or_CONST_Array_Declaration:
#ifdef IN_PARSER

#endif
     {                              //\\    <OWN_or_CONST> <scalar_declaration_types> "array" <OWN_or_CONST_array_ident_and_optional_assignment>;
     t[1] = compile(P(1), depth+1 /* P_OWN_or_CONST */);
     t[2] = compile(P(2), depth+1 /* P_scalar_declaration_types */);
     t[3] = wlit(P(3));
     t[4] = compile(P(4), depth+1 /* P_OWN_or_CONST_array_ident_and_optional_assignment */);
     return t[0] = P_mktuple(P_OWN_or_CONST_Array_Declaration, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<OWN_or_CONST_Name_Array_Declaration> =
   case P_OWN_or_CONST_Name_Array_Declaration:
#ifdef IN_PARSER

#endif
     {                              //\\    <OWN_or_CONST> <name_declaration_types> "array" <OWN_or_CONST_name_array_idents>;
     t[1] = compile(P(1), depth+1 /* P_OWN_or_CONST */);
     t[2] = compile(P(2), depth+1 /* P_name_declaration_types */);
     t[3] = wlit(P(3));
     t[4] = compile(P(4), depth+1 /* P_OWN_or_CONST_name_array_idents */);
     return t[0] = P_mktuple(P_OWN_or_CONST_Name_Array_Declaration, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<OWN_or_CONST_Scalar_Name_Declaration> =
   case P_OWN_or_CONST_Scalar_Name_Declaration:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <OWN_or_CONST> <name_declaration_types> <OWN_or_CONST_name_idents_and_optional_assignments>,
       t[1] = compile(P(1), depth+1 /* P_OWN_or_CONST */);
       t[2] = compile(P(2), depth+1 /* P_name_declaration_types */);
       t[3] = compile(P(3), depth+1 /* P_OWN_or_CONST_name_idents_and_optional_assignments */);
       return t[0] = P_mktuple(P_OWN_or_CONST_Scalar_Name_Declaration, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <OWN_or_CONST> "name" <OWN_or_CONST_name_idents_and_optional_assignments>;
       t[1] = compile(P(1), depth+1 /* P_OWN_or_CONST */);
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_OWN_or_CONST_name_idents_and_optional_assignments */);
       return t[0] = P_mktuple(P_OWN_or_CONST_Scalar_Name_Declaration, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<OWN_or_CONST_Scalar_Declaration> =
   case P_OWN_or_CONST_Scalar_Declaration:
#ifdef IN_PARSER

#endif
     {                              //\\    <OWN_or_CONST> <scalar_declaration_types> <OWN_or_CONST_scalar_idents_and_optional_assignments>;
     t[1] = compile(P(1), depth+1 /* P_OWN_or_CONST */);
     t[2] = compile(P(2), depth+1 /* P_scalar_declaration_types */);
     t[3] = compile(P(3), depth+1 /* P_OWN_or_CONST_scalar_idents_and_optional_assignments */);
     return t[0] = P_mktuple(P_OWN_or_CONST_Scalar_Declaration, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<AUTO_Name_Array_Name_Declaration> =
   case P_AUTO_Name_Array_Name_Declaration:
#ifdef IN_PARSER

#endif
     {                              //\\    <name_declaration_types> <ARRAYNAME> <IDENTS>;
     t[1] = compile(P(1), depth+1 /* P_name_declaration_types */);
     t[2] = compile(P(2), depth+1 /* P_ARRAYNAME */);
     t[3] = compile(P(3), depth+1 /* P_IDENTS */);
     return t[0] = P_mktuple(P_AUTO_Name_Array_Name_Declaration, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<AUTO_Array_Name_Declaration> =
   case P_AUTO_Array_Name_Declaration:
#ifdef IN_PARSER

#endif
     {                              //\\    <scalar_declaration_types> <ARRAYNAME> <IDENTS>;
     t[1] = compile(P(1), depth+1 /* P_scalar_declaration_types */);
     t[2] = compile(P(2), depth+1 /* P_ARRAYNAME */);
     t[3] = compile(P(3), depth+1 /* P_IDENTS */);
     return t[0] = P_mktuple(P_AUTO_Array_Name_Declaration, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<AUTO_Array_Declaration> =
   case P_AUTO_Array_Declaration:
#ifdef IN_PARSER

#endif
     {                              //\\    <scalar_declaration_types> "array" <AUTO_array_idents>;
     t[1] = compile(P(1), depth+1 /* P_scalar_declaration_types */);
     t[2] = wlit(P(2));
     t[3] = compile(P(3), depth+1 /* P_AUTO_array_idents */);
     return t[0] = P_mktuple(P_AUTO_Array_Declaration, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<AUTO_Name_Array_Declaration> =
   case P_AUTO_Name_Array_Declaration:
#ifdef IN_PARSER

#endif
     {                              //\\    <name_declaration_types> "array" <AUTO_name_array_idents>;
     t[1] = compile(P(1), depth+1 /* P_name_declaration_types */);
     t[2] = wlit(P(2));
     t[3] = compile(P(3), depth+1 /* P_AUTO_name_array_idents */);
     return t[0] = P_mktuple(P_AUTO_Name_Array_Declaration, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<AUTO_Scalar_Name_Declaration> =
   case P_AUTO_Scalar_Name_Declaration:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <name_declaration_types> <AUTO_name_idents_and_optional_assignments>,
       t[1] = compile(P(1), depth+1 /* P_name_declaration_types */);
       t[2] = compile(P(2), depth+1 /* P_AUTO_name_idents_and_optional_assignments */);
       return t[0] = P_mktuple(P_AUTO_Scalar_Name_Declaration, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<AUTO_Scalar_Declaration> =
   case P_AUTO_Scalar_Declaration:
#ifdef IN_PARSER

#endif
     {                              //\\    <scalar_declaration_types> <AUTO_scalar_idents_and_optional_assignments>;
     t[1] = compile(P(1), depth+1 /* P_scalar_declaration_types */);
     t[2] = compile(P(2), depth+1 /* P_AUTO_scalar_idents_and_optional_assignments */);
     return t[0] = P_mktuple(P_AUTO_Scalar_Declaration, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<name> =
   case P_name:
#ifdef IN_PARSER

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

     }
//\\ P<const_array_bounds> =
   case P_const_array_bounds:
#ifdef IN_PARSER

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

     }
//\\ P<optional_name_assignment> =
   case P_optional_name_assignment:
#ifdef IN_PARSER

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

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

     } else                      {  //\\    ;

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

     }
//\\ P<name_ident_and_optional_assignment> =
   case P_name_ident_and_optional_assignment:
#ifdef IN_PARSER

#endif
     {                              //\\    <IDENT> <optional_name_assignment>;
     t[1] = compile(P(1), depth+1 /* P_IDENT */);
     t[2] = compile(P(2), depth+1 /* P_optional_name_assignment */);
     return t[0] = P_mktuple(P_name_ident_and_optional_assignment, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<more_name_idents_and_optional_assignments> =
   case P_more_name_idents_and_optional_assignments:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <name_idents_and_optional_assignments>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_name_idents_and_optional_assignments */);
       return t[0] = P_mktuple(P_more_name_idents_and_optional_assignments, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<name_idents_and_optional_assignments> =
   case P_name_idents_and_optional_assignments:
#ifdef IN_PARSER

#endif
     {                              //\\    <name_ident_and_optional_assignment> <more_name_idents_and_optional_assignments>;
     t[1] = compile(P(1), depth+1 /* P_name_ident_and_optional_assignment */);
     t[2] = compile(P(2), depth+1 /* P_more_name_idents_and_optional_assignments */);
     return t[0] = P_mktuple(P_name_idents_and_optional_assignments, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<name_ident> =
   case P_name_ident:
#ifdef IN_PARSER

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

     }
//\\ P<more_name_idents> =
   case P_more_name_idents:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<name_idents> =
   case P_name_idents:
#ifdef IN_PARSER

#endif
     {                              //\\    <name_ident> <more_name_idents>;
     t[1] = compile(P(1), depth+1 /* P_name_ident */);
     t[2] = compile(P(2), depth+1 /* P_more_name_idents */);
     return t[0] = P_mktuple(P_name_idents, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<AUTO_name_idents_and_optional_assignments> =
   case P_AUTO_name_idents_and_optional_assignments:
#ifdef IN_PARSER

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

     }
//\\ P<OWN_or_CONST_name_idents_and_optional_assignments> =
   case P_OWN_or_CONST_name_idents_and_optional_assignments:
#ifdef IN_PARSER

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

     }
//\\ P<EXTERNAL_name_idents_and_optional_assignments> =
   case P_EXTERNAL_name_idents_and_optional_assignments:
#ifdef IN_PARSER

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

     }
//\\ P<EXTERNAL_name_idents> =
   case P_EXTERNAL_name_idents:
#ifdef IN_PARSER

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

     }
//\\ P<name_array_idents> =
   case P_name_array_idents:
#ifdef IN_PARSER

#endif
     {                              //\\    <IDENTS> <const_array_bounds> <more_name_array_idents>;
     t[1] = compile(P(1), depth+1 /* P_IDENTS */);
     t[2] = compile(P(2), depth+1 /* P_const_array_bounds */);
     t[3] = compile(P(3), depth+1 /* P_more_name_array_idents */);
     return t[0] = P_mktuple(P_name_array_idents, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<more_name_array_idents> =
   case P_more_name_array_idents:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <name_array_idents>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_name_array_idents */);
       return t[0] = P_mktuple(P_more_name_array_idents, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<EXTERNAL_name_array_idents> =
   case P_EXTERNAL_name_array_idents:
#ifdef IN_PARSER

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

     }
//\\ P<OWN_or_CONST_name_array_idents> =
   case P_OWN_or_CONST_name_array_idents:
#ifdef IN_PARSER

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

     }
//\\ P<more_AUTO_name_array_idents> =
   case P_more_AUTO_name_array_idents:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <AUTO_name_array_idents>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_AUTO_name_array_idents */);
       return t[0] = P_mktuple(P_more_AUTO_name_array_idents, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<AUTO_name_array_idents> =
   case P_AUTO_name_array_idents:
#ifdef IN_PARSER

#endif
     {                              //\\    <IDENTS> <BPL> <more_AUTO_name_array_idents>;
     t[1] = compile(P(1), depth+1 /* P_IDENTS */);
     t[2] = compile(P(2), depth+1 /* P_BPL */);
     t[3] = compile(P(3), depth+1 /* P_more_AUTO_name_array_idents */);
     return t[0] = P_mktuple(P_AUTO_name_array_idents, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<more_external_array_idents> =
   case P_more_external_array_idents:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <EXTERNAL_array_idents>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_EXTERNAL_array_idents */);
       return t[0] = P_mktuple(P_more_external_array_idents, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<more_AUTO_array_idents> =
   case P_more_AUTO_array_idents:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <AUTO_array_idents>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_AUTO_array_idents */);
       return t[0] = P_mktuple(P_more_AUTO_array_idents, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<EXTERNAL_array_idents> =
   case P_EXTERNAL_array_idents:
#ifdef IN_PARSER

#endif
     {                              //\\    <IDENTS> <const_array_bounds> <more_external_array_idents>;
     t[1] = compile(P(1), depth+1 /* P_IDENTS */);
     t[2] = compile(P(2), depth+1 /* P_const_array_bounds */);
     t[3] = compile(P(3), depth+1 /* P_more_external_array_idents */);
     return t[0] = P_mktuple(P_EXTERNAL_array_idents, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<AUTO_array_idents> =
   case P_AUTO_array_idents:
#ifdef IN_PARSER

#endif
     {                              //\\    <IDENTS> <BPL> <more_AUTO_array_idents>;
     t[1] = compile(P(1), depth+1 /* P_IDENTS */);
     t[2] = compile(P(2), depth+1 /* P_BPL */);
     t[3] = compile(P(3), depth+1 /* P_more_AUTO_array_idents */);
     return t[0] = P_mktuple(P_AUTO_array_idents, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<optional_scalar_assignment> =
   case P_optional_scalar_assignment:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<scalar_ident_and_optional_assignment> =
   case P_scalar_ident_and_optional_assignment:
#ifdef IN_PARSER

#endif
     {                              //\\    <IDENT> <optional_scalar_assignment>;
     t[1] = compile(P(1), depth+1 /* P_IDENT */);
     t[2] = compile(P(2), depth+1 /* P_optional_scalar_assignment */);
     return t[0] = P_mktuple(P_scalar_ident_and_optional_assignment, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<more_scalar_idents_and_optional_assignments> =
   case P_more_scalar_idents_and_optional_assignments:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <scalar_idents_and_optional_assignments>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_scalar_idents_and_optional_assignments */);
       return t[0] = P_mktuple(P_more_scalar_idents_and_optional_assignments, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<scalar_idents_and_optional_assignments> =
   case P_scalar_idents_and_optional_assignments:
#ifdef IN_PARSER

#endif
     {                              //\\    <scalar_ident_and_optional_assignment> <more_scalar_idents_and_optional_assignments>;
     t[1] = compile(P(1), depth+1 /* P_scalar_ident_and_optional_assignment */);
     t[2] = compile(P(2), depth+1 /* P_more_scalar_idents_and_optional_assignments */);
     return t[0] = P_mktuple(P_scalar_idents_and_optional_assignments, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<EXTERNAL_scalar_idents_and_optional_assignments> =
   case P_EXTERNAL_scalar_idents_and_optional_assignments:
#ifdef IN_PARSER

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

     }
//\\ P<OWN_or_CONST_scalar_idents_and_optional_assignments> =
   case P_OWN_or_CONST_scalar_idents_and_optional_assignments:
#ifdef IN_PARSER

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

     }
//\\ P<AUTO_scalar_idents_and_optional_assignments> =
   case P_AUTO_scalar_idents_and_optional_assignments:
#ifdef IN_PARSER

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

     }
//\\ P<EXTERNAL_scalar_ident> =
   case P_EXTERNAL_scalar_ident:
#ifdef IN_PARSER

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

     }
//\\ P<EXTERNAL_scalar_idents> =
   case P_EXTERNAL_scalar_idents:
#ifdef IN_PARSER

#endif
     {                              //\\    <EXTERNAL_scalar_ident> <more_external_scalar_idents>;
     t[1] = compile(P(1), depth+1 /* P_EXTERNAL_scalar_ident */);
     t[2] = compile(P(2), depth+1 /* P_more_external_scalar_idents */);
     return t[0] = P_mktuple(P_EXTERNAL_scalar_idents, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<more_external_scalar_idents> =
   case P_more_external_scalar_idents:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <EXTERNAL_scalar_idents>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_EXTERNAL_scalar_idents */);
       return t[0] = P_mktuple(P_more_external_scalar_idents, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<more_array_data> =
   case P_more_array_data:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <scalar_array_data>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_scalar_array_data */);
       return t[0] = P_mktuple(P_more_array_data, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<scalar_array_data> =
   case P_scalar_array_data:
#ifdef IN_PARSER

#endif
     {                              //\\    <initialiser_item_with_optional_repeat_count> <more_array_data>;
     t[1] = compile(P(1), depth+1 /* P_initialiser_item_with_optional_repeat_count */);
     t[2] = compile(P(2), depth+1 /* P_more_array_data */);
     return t[0] = P_mktuple(P_scalar_array_data, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<optional_array_assignment> =
   case P_optional_array_assignment:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '=' <NL_opt> <scalar_array_data>,
       t[1] = wlit(P(1) /*, L'=' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_scalar_array_data */);
       return t[0] = P_mktuple(P_optional_array_assignment, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<EXTERNAL_array_ident_and_optional_assignment> =
   case P_EXTERNAL_array_ident_and_optional_assignment:
#ifdef IN_PARSER

#endif
     {                              //\\    <IDENT> <const_array_bounds> <optional_array_assignment>;
     t[1] = compile(P(1), depth+1 /* P_IDENT */);
     t[2] = compile(P(2), depth+1 /* P_const_array_bounds */);
     t[3] = compile(P(3), depth+1 /* P_optional_array_assignment */);
     return t[0] = P_mktuple(P_EXTERNAL_array_ident_and_optional_assignment, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<OWN_or_CONST_array_ident_and_optional_assignment> =
   case P_OWN_or_CONST_array_ident_and_optional_assignment:
#ifdef IN_PARSER

#endif
     {                              //\\    <IDENT> <const_array_bounds> <optional_array_assignment>;
     t[1] = compile(P(1), depth+1 /* P_IDENT */);
     t[2] = compile(P(2), depth+1 /* P_const_array_bounds */);
     t[3] = compile(P(3), depth+1 /* P_optional_array_assignment */);
     return t[0] = P_mktuple(P_OWN_or_CONST_array_ident_and_optional_assignment, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<Name_Array_Name_Declaration> =
   case P_Name_Array_Name_Declaration:
#ifdef IN_PARSER

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

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

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

     }
//\\ P<Array_Name_Declaration> =
   case P_Array_Name_Declaration:
#ifdef IN_PARSER

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

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

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

     }
//\\ P<Name_Array_Declaration> =
   case P_Name_Array_Declaration:
#ifdef IN_PARSER

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

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

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

     }
//\\ P<Array_Declaration> =
   case P_Array_Declaration:
#ifdef IN_PARSER

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

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

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

     }
//\\ P<Scalar_Name_Declaration> =
   case P_Scalar_Name_Declaration:
#ifdef IN_PARSER

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

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

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

     }
//\\ P<Scalar_Declaration> =
   case P_Scalar_Declaration:
#ifdef IN_PARSER

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

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

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

     }
//\\ P<Data_Declaration> =
   case P_Data_Declaration:
#ifdef IN_PARSER

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

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

     } else if (alt == 2)        {  //\\    <Name_Array_Declaration>,
       t[1] = compile(P(1), depth+1 /* P_Name_Array_Declaration */);
       return t[0] = P_mktuple(P_Data_Declaration, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    <Array_Declaration>,
       t[1] = compile(P(1), depth+1 /* P_Array_Declaration */);
       return t[0] = P_mktuple(P_Data_Declaration, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    <Scalar_Name_Declaration>,
       t[1] = compile(P(1), depth+1 /* P_Scalar_Name_Declaration */);
       return t[0] = P_mktuple(P_Data_Declaration, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<Declaration> =
   case P_Declaration:
#ifdef IN_PARSER

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

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

     } else if (alt == 2)        {  //\\    "recordformatspec" <IDENT>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_IDENT */);
       return t[0] = P_mktuple(P_Declaration, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    "recordformat" <IDENT> '(' <record_field_declarations> ')',
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_IDENT */);
       t[3] = wlit(P(3) /*, L'(' */);
       t[4] = compile(P(4), depth+1 /* P_record_field_declarations */);
       t[5] = wlit(P(5) /*, L')' */);
       return t[0] = P_mktuple(P_Declaration, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

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

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

     }
//\\ P<optional_parameters> =
   case P_optional_parameters:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<Rt_CALL> =
   case P_Rt_CALL:
#ifdef IN_PARSER

#endif
     {                              //\\    <IDENT> <optional_parameters>;
     t[1] = compile(P(1), depth+1 /* P_IDENT */);
     t[2] = compile(P(2), depth+1 /* P_optional_parameters */);
     return t[0] = P_mktuple(P_Rt_CALL, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<Fn_CALL> =
   case P_Fn_CALL:
#ifdef IN_PARSER

#endif
     {                              //\\    <IDENT> <optional_parameters>;
     t[1] = compile(P(1), depth+1 /* P_IDENT */);
     t[2] = compile(P(2), depth+1 /* P_optional_parameters */);
     return t[0] = P_mktuple(P_Fn_CALL, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<Map_CALL> =
   case P_Map_CALL:
#ifdef IN_PARSER

#endif
     {                              //\\    <IDENT> <optional_parameters>;
     t[1] = compile(P(1), depth+1 /* P_IDENT */);
     t[2] = compile(P(2), depth+1 /* P_optional_parameters */);
     return t[0] = P_mktuple(P_Map_CALL, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<Pred_CALL> =
   case P_Pred_CALL:
#ifdef IN_PARSER

#endif
     {                              //\\    <IDENT> <optional_parameters>;
     t[1] = compile(P(1), depth+1 /* P_IDENT */);
     t[2] = compile(P(2), depth+1 /* P_optional_parameters */);
     return t[0] = P_mktuple(P_Pred_CALL, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<PROC_or_PROCSPEC> =
   case P_PROC_or_PROCSPEC:
#ifdef IN_PARSER

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

     } else                      {  //\\    <?PROCSPEC>;
       t[1] = -1; /* semantic procedure PROCSPEC */;
       return t[0] = P_mktuple(P_PROC_or_PROCSPEC, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<ESCARRAY> =
   case P_ESCARRAY:
#ifdef IN_PARSER

#endif
     {                              //\\    '(' <APP> ')' <ESCREC_opt>;
     t[1] = wlit(P(1) /*, L'(' */);
     t[2] = compile(P(2), depth+1 /* P_APP */);
     t[3] = wlit(P(3) /*, L')' */);
     t[4] = compile(P(4), depth+1 /* P_ESCREC_opt */);
     return t[0] = P_mktuple(P_ESCARRAY, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<ESCREC_opt> =
   case P_ESCREC_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <ESCREC> <ESC_ARRAY_or_REC>,
       t[1] = compile(P(1), depth+1 /* P_ESCREC */);
       t[2] = compile(P(2), depth+1 /* P_ESC_ARRAY_or_REC */);
       return t[0] = P_mktuple(P_ESCREC_opt, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<ESCREC> =
   case P_ESCREC:
#ifdef IN_PARSER

#endif
     {                              //\\    '_' <IDENT> <ESC_ARRAY_or_REC>;
     t[1] = wlit(P(1) /*, L'_' */);
     t[2] = compile(P(2), depth+1 /* P_IDENT */);
     t[3] = compile(P(3), depth+1 /* P_ESC_ARRAY_or_REC */);
     return t[0] = P_mktuple(P_ESCREC, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<ESC_ARRAY_or_REC> =
   case P_ESC_ARRAY_or_REC:
#ifdef IN_PARSER

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

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

     } else                      {  //\\    ;

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

     }
//\\ P<SIGNAL> =
   case P_SIGNAL:
#ifdef IN_PARSER

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

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

     }
//\\ P<COMMENT_TEXT> =
   case P_COMMENT_TEXT:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <SS> <any> <COMMENT_TEXT>,
       t[1] = wlit(P(1) /*, L"NL" */);
       t[2] = compile(P(2), depth+1 /* P_any */);
       t[3] = compile(P(3), depth+1 /* P_COMMENT_TEXT */);
       return t[0] = P_mktuple(P_COMMENT_TEXT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<COMMENT> =
   case P_COMMENT:
#ifdef IN_PARSER

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

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

     }
//\\ P<COMMENT_T> =
   case P_COMMENT_T:
#ifdef IN_PARSER
 return -1; 
#endif
     {                              //\\    <COMMENT> <COMMENT_TEXT> <T>;
     t[1] = compile(P(1), depth+1 /* P_COMMENT */);
     t[2] = compile(P(2), depth+1 /* P_COMMENT_TEXT */);
     t[3] = compile(P(3), depth+1 /* P_T */);
     return t[0] = P_mktuple(P_COMMENT_T, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<LHS> =
   case P_LHS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <V> <ESC_ARRAY_or_REC>,
       t[1] = compile(P(1), depth+1 /* P_V */);
       t[2] = compile(P(2), depth+1 /* P_ESC_ARRAY_or_REC */);
       return t[0] = P_mktuple(P_LHS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <N> <ESC_ARRAY_or_REC>,
       t[1] = compile(P(1), depth+1 /* P_N */);
       t[2] = compile(P(2), depth+1 /* P_ESC_ARRAY_or_REC */);
       return t[0] = P_mktuple(P_LHS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <Map_CALL> <ESCREC>;
       t[1] = compile(P(1), depth+1 /* P_Map_CALL */);
       t[2] = compile(P(2), depth+1 /* P_ESCREC */);
       return t[0] = P_mktuple(P_LHS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<IMP> =
   case P_IMP:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <LHS> <IMP_ASSIGN> <and_IMPS>,
       t[1] = compile(P(1), depth+1 /* P_LHS */);
       t[2] = compile(P(2), depth+1 /* P_IMP_ASSIGN */);
       t[3] = compile(P(3), depth+1 /* P_and_IMPS */);
       return t[0] = P_mktuple(P_IMP, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <N> <N_ASS> <and_IMPS>,
       t[1] = compile(P(1), depth+1 /* P_N */);
       t[2] = compile(P(2), depth+1 /* P_N_ASS */);
       t[3] = compile(P(3), depth+1 /* P_and_IMPS */);
       return t[0] = P_mktuple(P_IMP, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    <Rt_CALL> <and_IMPS>,
       t[1] = compile(P(1), depth+1 /* P_Rt_CALL */);
       t[2] = compile(P(2), depth+1 /* P_and_IMPS */);
       return t[0] = P_mktuple(P_IMP, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    <BACK>,
       t[1] = compile(P(1), depth+1 /* P_BACK */);
       return t[0] = P_mktuple(P_IMP, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    "result" '=' '=' <NL_opt> <V_or_N>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'=' */);
       t[3] = wlit(P(3) /*, L'=' */);
       t[4] = compile(P(4), depth+1 /* P_NL_opt */);
       t[5] = compile(P(5), depth+1 /* P_V_or_N */);
       return t[0] = P_mktuple(P_IMP, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 5)        {  //\\    "result" '=' <NL_opt> <EXP>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'=' */);
       t[3] = compile(P(3), depth+1 /* P_NL_opt */);
       t[4] = compile(P(4), depth+1 /* P_EXP */);
       return t[0] = P_mktuple(P_IMP, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 6)        {  //\\    <exit_or_continue>,
       t[1] = compile(P(1), depth+1 /* P_exit_or_continue */);
       return t[0] = P_mktuple(P_IMP, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 7)        {  //\\    <AN> '=' '=' <NL_opt> <A_or_AN> <and_IMPS>,
       t[1] = compile(P(1), depth+1 /* P_AN */);
       t[2] = wlit(P(2) /*, L'=' */);
       t[3] = wlit(P(3) /*, L'=' */);
       t[4] = compile(P(4), depth+1 /* P_NL_opt */);
       t[5] = compile(P(5), depth+1 /* P_A_or_AN */);
       t[6] = compile(P(6), depth+1 /* P_and_IMPS */);
       return t[0] = P_mktuple(P_IMP, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 8)        {  //\\    <NAN> '=' '=' <NL_opt> <NA_or_NAN> <and_IMPS>,
       t[1] = compile(P(1), depth+1 /* P_NAN */);
       t[2] = wlit(P(2) /*, L'=' */);
       t[3] = wlit(P(3) /*, L'=' */);
       t[4] = compile(P(4), depth+1 /* P_NL_opt */);
       t[5] = compile(P(5), depth+1 /* P_NA_or_NAN */);
       t[6] = compile(P(6), depth+1 /* P_and_IMPS */);
       return t[0] = P_mktuple(P_IMP, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

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

     } else if (alt == 10)        {  //\\    "monitor" <and_IMPS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_and_IMPS */);
       return t[0] = P_mktuple(P_IMP, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

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

     } else                      {  //\\    <SIGNAL> <IEXP> <subevent_and_extra>;
       t[1] = compile(P(1), depth+1 /* P_SIGNAL */);
       t[2] = compile(P(2), depth+1 /* P_IEXP */);
       t[3] = compile(P(3), depth+1 /* P_subevent_and_extra */);
       return t[0] = P_mktuple(P_IMP, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<EIMP> =
   case P_EIMP:
#ifdef IN_PARSER

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

     } else if (alt == 1)        {  //\\    <COND> "then" "start",
       t[1] = compile(P(1), depth+1 /* P_COND */);
       t[2] = wlit(P(2));
       t[3] = wlit(P(3));
       return t[0] = P_mktuple(P_EIMP, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <COND> "then" <IMP> <else_start_IMP_opt>;
       t[1] = compile(P(1), depth+1 /* P_COND */);
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_IMP */);
       t[4] = compile(P(4), depth+1 /* P_else_start_IMP_opt */);
       return t[0] = P_mktuple(P_EIMP, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<XIMP> =
   case P_XIMP:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <COND> "then" <IMP> <else_if_XIMP_opt>,
       t[1] = compile(P(1), depth+1 /* P_COND */);
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_IMP */);
       t[4] = compile(P(4), depth+1 /* P_else_if_XIMP_opt */);
       return t[0] = P_mktuple(P_XIMP, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <COND> <THEN_opt>;
       t[1] = compile(P(1), depth+1 /* P_COND */);
       t[2] = compile(P(2), depth+1 /* P_THEN_opt */);
       return t[0] = P_mktuple(P_XIMP, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<FELSE_opt> =
   case P_FELSE_opt:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<if_or_unless> =
   case P_if_or_unless:
#ifdef IN_PARSER

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

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

     }
//\\ P<if_unless_XIMP> =
   case P_if_unless_XIMP:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <if_or_unless> <XIMP>,
       t[1] = compile(P(1), depth+1 /* P_if_or_unless */);
       t[2] = compile(P(2), depth+1 /* P_XIMP */);
       return t[0] = P_mktuple(P_if_unless_XIMP, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<if_XIMP_opt> =
   case P_if_XIMP_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <if_or_unless> <XIMP>,
       t[1] = compile(P(1), depth+1 /* P_if_or_unless */);
       t[2] = compile(P(2), depth+1 /* P_XIMP */);
       return t[0] = P_mktuple(P_if_XIMP_opt, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<THEN_opt> =
   case P_THEN_opt:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<else_start_IMP_opt> =
   case P_else_start_IMP_opt:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<else_if_unless_XIMP_opt> =
   case P_else_if_unless_XIMP_opt:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<else_if_XIMP_opt> =
   case P_else_if_XIMP_opt:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<else_final_IMP_opt> =
   case P_else_final_IMP_opt:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<start_IMP> =
   case P_start_IMP:
#ifdef IN_PARSER

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

     } else if (alt == 1)        {  //\\    <if_or_unless> <EIMP>,
       t[1] = compile(P(1), depth+1 /* P_if_or_unless */);
       t[2] = compile(P(2), depth+1 /* P_EIMP */);
       return t[0] = P_mktuple(P_start_IMP, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<final_IMP> =
   case P_final_IMP:
#ifdef IN_PARSER

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

     } else if (alt == 1)        {  //\\    <if_or_unless> <EIMP>,
       t[1] = compile(P(1), depth+1 /* P_if_or_unless */);
       t[2] = compile(P(2), depth+1 /* P_EIMP */);
       return t[0] = P_mktuple(P_final_IMP, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<and_IMPS> =
   case P_and_IMPS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "and" <NL_opt> <IMP>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_IMP */);
       return t[0] = P_mktuple(P_and_IMPS, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<INCL_LIST_opt> =
   case P_INCL_LIST_opt:
#ifdef IN_PARSER

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

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

     } else                      {  //\\    ;

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

     }
//\\ P<wh_for> =
   case P_wh_for:
#ifdef IN_PARSER

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

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

     }
//\\ P<cycle_IMP> =
   case P_cycle_IMP:
#ifdef IN_PARSER

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

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

     }
//\\ P<event_list_def> =
   case P_event_list_def:
#ifdef IN_PARSER

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

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

     }
//\\ P<iu_while_until_for_T> =
   case P_iu_while_until_for_T:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <if_or_unless> <COND> <T>,
       t[1] = compile(P(1), depth+1 /* P_if_or_unless */);
       t[2] = compile(P(2), depth+1 /* P_COND */);
       t[3] = compile(P(3), depth+1 /* P_T */);
       return t[0] = P_mktuple(P_iu_while_until_for_T, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "while" <COND> <T>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_COND */);
       t[3] = compile(P(3), depth+1 /* P_T */);
       return t[0] = P_mktuple(P_iu_while_until_for_T, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    "until" <COND> <T>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_COND */);
       t[3] = compile(P(3), depth+1 /* P_T */);
       return t[0] = P_mktuple(P_iu_while_until_for_T, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    "for" <SEQ> <T>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_SEQ */);
       t[3] = compile(P(3), depth+1 /* P_T */);
       return t[0] = P_mktuple(P_iu_while_until_for_T, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<AddressOffsetOp> =
   case P_AddressOffsetOp:
#ifdef IN_PARSER

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

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

     }
//\\ P<ADDOP_SEXP_opt> =
   case P_ADDOP_SEXP_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <AddressOffsetOp> <SEXP>,
       t[1] = compile(P(1), depth+1 /* P_AddressOffsetOp */);
       t[2] = compile(P(2), depth+1 /* P_SEXP */);
       return t[0] = P_mktuple(P_ADDOP_SEXP_opt, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<A_or_AN_or_NA_or_NAN> =
   case P_A_or_AN_or_NA_or_NAN:
#ifdef IN_PARSER

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

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

     } else if (alt == 2)        {  //\\    <NA>,
       t[1] = compile(P(1), depth+1 /* P_NA */);
       return t[0] = P_mktuple(P_A_or_AN_or_NA_or_NAN, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<A_or_AN> =
   case P_A_or_AN:
#ifdef IN_PARSER

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

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

     }
//\\ P<NA_or_NAN> =
   case P_NA_or_NAN:
#ifdef IN_PARSER

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

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

     }
//\\ P<rest_of_IDENTS> =
   case P_rest_of_IDENTS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <IDENT> <rest_of_IDENTS>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_IDENT */);
       t[4] = compile(P(4), depth+1 /* P_rest_of_IDENTS */);
       return t[0] = P_mktuple(P_rest_of_IDENTS, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<IDENTS> =
   case P_IDENTS:
#ifdef IN_PARSER

#endif
     {                              //\\    <IDENT> <rest_of_IDENTS>;
     t[1] = compile(P(1), depth+1 /* P_IDENT */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_IDENTS */);
     return t[0] = P_mktuple(P_IDENTS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<V_or_N> =
   case P_V_or_N:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <V> <ESC_ARRAY_or_REC>,
       t[1] = compile(P(1), depth+1 /* P_V */);
       t[2] = compile(P(2), depth+1 /* P_ESC_ARRAY_or_REC */);
       return t[0] = P_mktuple(P_V_or_N, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <N> <ESC_ARRAY_or_REC>,
       t[1] = compile(P(1), depth+1 /* P_N */);
       t[2] = compile(P(2), depth+1 /* P_ESC_ARRAY_or_REC */);
       return t[0] = P_mktuple(P_V_or_N, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    <Fn_CALL>,
       t[1] = compile(P(1), depth+1 /* P_Fn_CALL */);
       return t[0] = P_mktuple(P_V_or_N, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    <Map_CALL> <ESCREC>,
       t[1] = compile(P(1), depth+1 /* P_Map_CALL */);
       t[2] = compile(P(2), depth+1 /* P_ESCREC */);
       return t[0] = P_mktuple(P_V_or_N, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<extra> =
   case P_extra:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <EXP>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_EXP */);
       return t[0] = P_mktuple(P_extra, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<subevent_and_extra> =
   case P_subevent_and_extra:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <EXP> <extra>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_EXP */);
       t[4] = compile(P(4), depth+1 /* P_extra */);
       return t[0] = P_mktuple(P_subevent_and_extra, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<IMP_ASSIGN> =
   case P_IMP_ASSIGN:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    '=' <NL_opt> <EXP>,
       t[1] = wlit(P(1) /*, L'=' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_EXP */);
       return t[0] = P_mktuple(P_IMP_ASSIGN, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    '<' '-' <NL_opt> <SIGN_opt> <EXP>,
       t[1] = wlit(P(1) /*, L'<' */);
       t[2] = wlit(P(2) /*, L'-' */);
       t[3] = compile(P(3), depth+1 /* P_NL_opt */);
       t[4] = compile(P(4), depth+1 /* P_SIGN_opt */);
       t[5] = compile(P(5), depth+1 /* P_EXP */);
       return t[0] = P_mktuple(P_IMP_ASSIGN, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    '-' '>' <NL_opt> <RESEXP>;
       t[1] = wlit(P(1) /*, L'-' */);
       t[2] = wlit(P(2) /*, L'>' */);
       t[3] = compile(P(3), depth+1 /* P_NL_opt */);
       t[4] = compile(P(4), depth+1 /* P_RESEXP */);
       return t[0] = P_mktuple(P_IMP_ASSIGN, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<N_ASS> =
   case P_N_ASS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <ADDOP_SEXP_opt> <IMP_ASSIGN>,
       t[1] = compile(P(1), depth+1 /* P_ADDOP_SEXP_opt */);
       t[2] = compile(P(2), depth+1 /* P_IMP_ASSIGN */);
       return t[0] = P_mktuple(P_N_ASS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    '=' '=' <NL_opt> <V_or_N> <ADDOP_SEXP_opt>;
       t[1] = wlit(P(1) /*, L'=' */);
       t[2] = wlit(P(2) /*, L'=' */);
       t[3] = compile(P(3), depth+1 /* P_NL_opt */);
       t[4] = compile(P(4), depth+1 /* P_V_or_N */);
       t[5] = compile(P(5), depth+1 /* P_ADDOP_SEXP_opt */);
       return t[0] = P_mktuple(P_N_ASS, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest_of_AND_COND> =
   case P_rest_of_AND_COND:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <AND_COND> <rest_of_AND_COND>,
       t[1] = compile(P(1), depth+1 /* P_AND_COND */);
       t[2] = compile(P(2), depth+1 /* P_rest_of_AND_COND */);
       return t[0] = P_mktuple(P_rest_of_AND_COND, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<AND_COND> =
   case P_AND_COND:
#ifdef IN_PARSER

#endif
     {                              //\\    "and" <NL_opt> <SCOND> <rest_of_AND_COND>;
     t[1] = wlit(P(1));
     t[2] = compile(P(2), depth+1 /* P_NL_opt */);
     t[3] = compile(P(3), depth+1 /* P_SCOND */);
     t[4] = compile(P(4), depth+1 /* P_rest_of_AND_COND */);
     return t[0] = P_mktuple(P_AND_COND, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest_of_OR_COND> =
   case P_rest_of_OR_COND:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <OR_COND> <rest_of_OR_COND>,
       t[1] = compile(P(1), depth+1 /* P_OR_COND */);
       t[2] = compile(P(2), depth+1 /* P_rest_of_OR_COND */);
       return t[0] = P_mktuple(P_rest_of_OR_COND, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<OR_COND> =
   case P_OR_COND:
#ifdef IN_PARSER

#endif
     {                              //\\    "or" <NL_opt> <SCOND> <rest_of_OR_COND>;
     t[1] = wlit(P(1));
     t[2] = compile(P(2), depth+1 /* P_NL_opt */);
     t[3] = compile(P(3), depth+1 /* P_SCOND */);
     t[4] = compile(P(4), depth+1 /* P_rest_of_OR_COND */);
     return t[0] = P_mktuple(P_OR_COND, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest_of_COND> =
   case P_rest_of_COND:
#ifdef IN_PARSER

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

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

     } else                      {  //\\    ;

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

     }
//\\ P<COND> =
   case P_COND:
#ifdef IN_PARSER

#endif
     {                              //\\    <SCOND> <rest_of_COND>;
     t[1] = compile(P(1), depth+1 /* P_SCOND */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_COND */);
     return t[0] = P_mktuple(P_COND, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<OP0> =
   case P_OP0:
#ifdef IN_PARSER

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

     }
//\\ P<OP1> =
   case P_OP1:
#ifdef IN_PARSER

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

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

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

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

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

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

     }
//\\ P<OP2> =
   case P_OP2:
#ifdef IN_PARSER

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

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

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

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

     }
//\\ P<OP3> =
   case P_OP3:
#ifdef IN_PARSER

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

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

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

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

     }
//\\ P<OP0_EXP> =
   case P_OP0_EXP:
#ifdef IN_PARSER

#endif
     {                              //\\    <OP0> <SEXP>;
     t[1] = compile(P(1), depth+1 /* P_OP0 */);
     t[2] = compile(P(2), depth+1 /* P_SEXP */);
     return t[0] = P_mktuple(P_OP0_EXP, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<OP1_EXP> =
   case P_OP1_EXP:
#ifdef IN_PARSER

#endif
     {                              //\\    <OP1> <EXP0>;
     t[1] = compile(P(1), depth+1 /* P_OP1 */);
     t[2] = compile(P(2), depth+1 /* P_EXP0 */);
     return t[0] = P_mktuple(P_OP1_EXP, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<OP2_EXP> =
   case P_OP2_EXP:
#ifdef IN_PARSER

#endif
     {                              //\\    <OP2> <EXP1>;
     t[1] = compile(P(1), depth+1 /* P_OP2 */);
     t[2] = compile(P(2), depth+1 /* P_EXP1 */);
     return t[0] = P_mktuple(P_OP2_EXP, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<OP3_EXP> =
   case P_OP3_EXP:
#ifdef IN_PARSER

#endif
     {                              //\\    <OP3> <EXP2>;
     t[1] = compile(P(1), depth+1 /* P_OP3 */);
     t[2] = compile(P(2), depth+1 /* P_EXP2 */);
     return t[0] = P_mktuple(P_OP3_EXP, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<OP0_EXPS> =
   case P_OP0_EXPS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <OP0_EXP> <OP0_EXPS>,
       t[1] = compile(P(1), depth+1 /* P_OP0_EXP */);
       t[2] = compile(P(2), depth+1 /* P_OP0_EXPS */);
       return t[0] = P_mktuple(P_OP0_EXPS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<OP1_EXPS> =
   case P_OP1_EXPS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <OP1_EXP> <OP1_EXPS>,
       t[1] = compile(P(1), depth+1 /* P_OP1_EXP */);
       t[2] = compile(P(2), depth+1 /* P_OP1_EXPS */);
       return t[0] = P_mktuple(P_OP1_EXPS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<OP2_EXPS> =
   case P_OP2_EXPS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <OP2_EXP> <OP2_EXPS>,
       t[1] = compile(P(1), depth+1 /* P_OP2_EXP */);
       t[2] = compile(P(2), depth+1 /* P_OP2_EXPS */);
       return t[0] = P_mktuple(P_OP2_EXPS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<OP3_EXPS> =
   case P_OP3_EXPS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <OP3_EXP> <OP3_EXPS>,
       t[1] = compile(P(1), depth+1 /* P_OP3_EXP */);
       t[2] = compile(P(2), depth+1 /* P_OP3_EXPS */);
       return t[0] = P_mktuple(P_OP3_EXPS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<COMP2_opt> =
   case P_COMP2_opt:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<COMP2> =
   case P_COMP2:
#ifdef IN_PARSER

#endif
     {                              //\\    <COMP> <EXP>;
     t[1] = compile(P(1), depth+1 /* P_COMP */);
     t[2] = compile(P(2), depth+1 /* P_EXP */);
     return t[0] = P_mktuple(P_COMP2, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<COMP1> =
   case P_COMP1:
#ifdef IN_PARSER

#endif
     {                              //\\    <COMP> <EXP>;
     t[1] = compile(P(1), depth+1 /* P_COMP */);
     t[2] = compile(P(2), depth+1 /* P_EXP */);
     return t[0] = P_mktuple(P_COMP1, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<COMP12_opt> =
   case P_COMP12_opt:
#ifdef IN_PARSER

#endif
     {                              //\\    <COMP1> <COMP2_opt>;
     t[1] = compile(P(1), depth+1 /* P_COMP1 */);
     t[2] = compile(P(2), depth+1 /* P_COMP2_opt */);
     return t[0] = P_mktuple(P_COMP12_opt, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<COMPARISON> =
   case P_COMPARISON:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <COMP1> <COMP2_opt>,
       t[1] = compile(P(1), depth+1 /* P_COMP1 */);
       t[2] = compile(P(2), depth+1 /* P_COMP2_opt */);
       return t[0] = P_mktuple(P_COMPARISON, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <ACOMP> <V_or_N>,
       t[1] = compile(P(1), depth+1 /* P_ACOMP */);
       t[2] = compile(P(2), depth+1 /* P_V_or_N */);
       return t[0] = P_mktuple(P_COMPARISON, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    <ACOMP> '0' <?ZERO>,
       t[1] = compile(P(1), depth+1 /* P_ACOMP */);
       t[2] = wlit(P(2) /*, L'0' */);
       t[3] = -1; /* semantic procedure ZERO */;
       return t[0] = P_mktuple(P_COMPARISON, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

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

     } else                      {  //\\    <OP0_EXPS> <OP1_EXPS> <OP2_EXPS> <OP3_EXPS> <COMP12_opt>;
       t[1] = compile(P(1), depth+1 /* P_OP0_EXPS */);
       t[2] = compile(P(2), depth+1 /* P_OP1_EXPS */);
       t[3] = compile(P(3), depth+1 /* P_OP2_EXPS */);
       t[4] = compile(P(4), depth+1 /* P_OP3_EXPS */);
       t[5] = compile(P(5), depth+1 /* P_COMP12_opt */);
       return t[0] = P_mktuple(P_COMPARISON, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<COMP1OS2> =
   case P_COMP1OS2:
#ifdef IN_PARSER

#endif
     {                              //\\    <COMP> <EXP> <COMP2_opt>;
     t[1] = compile(P(1), depth+1 /* P_COMP */);
     t[2] = compile(P(2), depth+1 /* P_EXP */);
     t[3] = compile(P(3), depth+1 /* P_COMP2_opt */);
     return t[0] = P_mktuple(P_COMP1OS2, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<SCOND> =
   case P_SCOND:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <V_or_N> <COMPARISON>,
       t[1] = compile(P(1), depth+1 /* P_V_or_N */);
       t[2] = compile(P(2), depth+1 /* P_COMPARISON */);
       return t[0] = P_mktuple(P_SCOND, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

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

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

     } else if (alt == 3)        {  //\\    <Pred_CALL>,
       t[1] = compile(P(1), depth+1 /* P_Pred_CALL */);
       return t[0] = P_mktuple(P_SCOND, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    '(' <EXP> ')' <OP0_EXPS> <OP1_EXPS> <OP2_EXPS> <OP3_EXPS> <COMP1OS2>,
       t[1] = wlit(P(1) /*, L'(' */);
       t[2] = compile(P(2), depth+1 /* P_EXP */);
       t[3] = wlit(P(3) /*, L')' */);
       t[4] = compile(P(4), depth+1 /* P_OP0_EXPS */);
       t[5] = compile(P(5), depth+1 /* P_OP1_EXPS */);
       t[6] = compile(P(6), depth+1 /* P_OP2_EXPS */);
       t[7] = compile(P(7), depth+1 /* P_OP3_EXPS */);
       t[8] = compile(P(8), depth+1 /* P_COMP1OS2 */);
       return t[0] = P_mktuple(P_SCOND, alt, 8/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 5)        {  //\\    <A_or_AN_or_NA_or_NAN> <ACOMP> <A_or_AN_or_NA_or_NAN>,
       t[1] = compile(P(1), depth+1 /* P_A_or_AN_or_NA_or_NAN */);
       t[2] = compile(P(2), depth+1 /* P_ACOMP */);
       t[3] = compile(P(3), depth+1 /* P_A_or_AN_or_NA_or_NAN */);
       return t[0] = P_mktuple(P_SCOND, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 6)        {  //\\    <A_or_AN_or_NA_or_NAN> <ACOMP> '0' <?ZERO>,
       t[1] = compile(P(1), depth+1 /* P_A_or_AN_or_NA_or_NAN */);
       t[2] = compile(P(2), depth+1 /* P_ACOMP */);
       t[3] = wlit(P(3) /*, L'0' */);
       t[4] = -1; /* semantic procedure ZERO */;
       return t[0] = P_mktuple(P_SCOND, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <EXP> <COMP12_opt>;
       t[1] = compile(P(1), depth+1 /* P_EXP */);
       t[2] = compile(P(2), depth+1 /* P_COMP12_opt */);
       return t[0] = P_mktuple(P_SCOND, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<SIGN_opt> =
   case P_SIGN_opt:
#ifdef IN_PARSER

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

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

     } else                      {  //\\    ;

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

     }
//\\ P<UOP> =
   case P_UOP:
#ifdef IN_PARSER

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

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

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

     }
//\\ P<UOP_opt> =
   case P_UOP_opt:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<EXP> =
   case P_EXP:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <V_or_N> <OP0_EXPS> <OP1_EXPS> <OP2_EXPS> <OP3_EXPS>,
       t[1] = compile(P(1), depth+1 /* P_V_or_N */);
       t[2] = compile(P(2), depth+1 /* P_OP0_EXPS */);
       t[3] = compile(P(3), depth+1 /* P_OP1_EXPS */);
       t[4] = compile(P(4), depth+1 /* P_OP2_EXPS */);
       t[5] = compile(P(5), depth+1 /* P_OP3_EXPS */);
       return t[0] = P_mktuple(P_EXP, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <UOP_opt> <SEXP> <OP0_EXPS> <OP1_EXPS> <OP2_EXPS> <OP3_EXPS>,
       t[1] = compile(P(1), depth+1 /* P_UOP_opt */);
       t[2] = compile(P(2), depth+1 /* P_SEXP */);
       t[3] = compile(P(3), depth+1 /* P_OP0_EXPS */);
       t[4] = compile(P(4), depth+1 /* P_OP1_EXPS */);
       t[5] = compile(P(5), depth+1 /* P_OP2_EXPS */);
       t[6] = compile(P(6), depth+1 /* P_OP3_EXPS */);
       return t[0] = P_mktuple(P_EXP, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <SIGN_opt> <EXP2> <OP3_EXPS>;
       t[1] = compile(P(1), depth+1 /* P_SIGN_opt */);
       t[2] = compile(P(2), depth+1 /* P_EXP2 */);
       t[3] = compile(P(3), depth+1 /* P_OP3_EXPS */);
       return t[0] = P_mktuple(P_EXP, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<EXP2> =
   case P_EXP2:
#ifdef IN_PARSER

#endif
     {                              //\\    <SEXP> <OP0_EXPS> <OP1_EXPS> <OP2_EXPS>;
     t[1] = compile(P(1), depth+1 /* P_SEXP */);
     t[2] = compile(P(2), depth+1 /* P_OP0_EXPS */);
     t[3] = compile(P(3), depth+1 /* P_OP1_EXPS */);
     t[4] = compile(P(4), depth+1 /* P_OP2_EXPS */);
     return t[0] = P_mktuple(P_EXP2, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<EXP1> =
   case P_EXP1:
#ifdef IN_PARSER

#endif
     {                              //\\    <SEXP> <OP0_EXPS> <OP1_EXPS>;
     t[1] = compile(P(1), depth+1 /* P_SEXP */);
     t[2] = compile(P(2), depth+1 /* P_OP0_EXPS */);
     t[3] = compile(P(3), depth+1 /* P_OP1_EXPS */);
     return t[0] = P_mktuple(P_EXP1, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<EXP0> =
   case P_EXP0:
#ifdef IN_PARSER

#endif
     {                              //\\    <SEXP> <OP0_EXPS>;
     t[1] = compile(P(1), depth+1 /* P_SEXP */);
     t[2] = compile(P(2), depth+1 /* P_OP0_EXPS */);
     return t[0] = P_mktuple(P_EXP0, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<SEXP> =
   case P_SEXP:
#ifdef IN_PARSER

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

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

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

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

     }
//\\ P<COP1> =
   case P_COP1:
#ifdef IN_PARSER

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

     }
//\\ P<COP2> =
   case P_COP2:
#ifdef IN_PARSER

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

     }
//\\ P<COP3> =
   case P_COP3:
#ifdef IN_PARSER

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

     }
//\\ P<CSIGN> =
   case P_CSIGN:
#ifdef IN_PARSER

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

     }
//\\ P<rest_of_IEXP2_EXPR> =
   case P_rest_of_IEXP2_EXPR:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <COP3> <IEXP2> <rest_of_IEXP2_EXPR>,
       t[1] = compile(P(1), depth+1 /* P_COP3 */);
       t[2] = compile(P(2), depth+1 /* P_IEXP2 */);
       t[3] = compile(P(3), depth+1 /* P_rest_of_IEXP2_EXPR */);
       return t[0] = P_mktuple(P_rest_of_IEXP2_EXPR, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<IEXP2_EXPR> =
   case P_IEXP2_EXPR:
#ifdef IN_PARSER

#endif
     {                              //\\    <IEXP2> <rest_of_IEXP2_EXPR>;
     t[1] = compile(P(1), depth+1 /* P_IEXP2 */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_IEXP2_EXPR */);
     return t[0] = P_mktuple(P_IEXP2_EXPR, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<COP3_IEXP2_optseq> =
   case P_COP3_IEXP2_optseq:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <COP3> <IEXP2> <COP3_IEXP2_optseq>,
       t[1] = compile(P(1), depth+1 /* P_COP3 */);
       t[2] = compile(P(2), depth+1 /* P_IEXP2 */);
       t[3] = compile(P(3), depth+1 /* P_COP3_IEXP2_optseq */);
       return t[0] = P_mktuple(P_COP3_IEXP2_optseq, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<COP2_IEXP1_optseq> =
   case P_COP2_IEXP1_optseq:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <COP2> <IEXP1> <COP2_IEXP1_optseq>,
       t[1] = compile(P(1), depth+1 /* P_COP2 */);
       t[2] = compile(P(2), depth+1 /* P_IEXP1 */);
       t[3] = compile(P(3), depth+1 /* P_COP2_IEXP1_optseq */);
       return t[0] = P_mktuple(P_COP2_IEXP1_optseq, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<COP1_IEXP0_optseq> =
   case P_COP1_IEXP0_optseq:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <COP1> <IEXP0> <COP1_IEXP0_optseq>,
       t[1] = compile(P(1), depth+1 /* P_COP1 */);
       t[2] = compile(P(2), depth+1 /* P_IEXP0 */);
       t[3] = compile(P(3), depth+1 /* P_COP1_IEXP0_optseq */);
       return t[0] = P_mktuple(P_COP1_IEXP0_optseq, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<CUOP_opt> =
   case P_CUOP_opt:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<CUOP> =
   case P_CUOP:
#ifdef IN_PARSER

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

     }
//\\ P<IEXP2> =
   case P_IEXP2:
#ifdef IN_PARSER

#endif
     {                              //\\    <IEXP0> <COP1_IEXP0_optseq> <COP2_IEXP1_optseq>;
     t[1] = compile(P(1), depth+1 /* P_IEXP0 */);
     t[2] = compile(P(2), depth+1 /* P_COP1_IEXP0_optseq */);
     t[3] = compile(P(3), depth+1 /* P_COP2_IEXP1_optseq */);
     return t[0] = P_mktuple(P_IEXP2, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<IEXP1> =
   case P_IEXP1:
#ifdef IN_PARSER

#endif
     {                              //\\    <IEXP0> <COP1_IEXP0_optseq>;
     t[1] = compile(P(1), depth+1 /* P_IEXP0 */);
     t[2] = compile(P(2), depth+1 /* P_COP1_IEXP0_optseq */);
     return t[0] = P_mktuple(P_IEXP1, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<IEXP0> =
   case P_IEXP0:
#ifdef IN_PARSER

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

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

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

     }
//\\ P<IEXP> =
   case P_IEXP:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <CUOP_opt> <IEXP0> <COP1_IEXP0_optseq> <COP2_IEXP1_optseq> <COP3_IEXP2_optseq>,
       t[1] = compile(P(1), depth+1 /* P_CUOP_opt */);
       t[2] = compile(P(2), depth+1 /* P_IEXP0 */);
       t[3] = compile(P(3), depth+1 /* P_COP1_IEXP0_optseq */);
       t[4] = compile(P(4), depth+1 /* P_COP2_IEXP1_optseq */);
       t[5] = compile(P(5), depth+1 /* P_COP3_IEXP2_optseq */);
       return t[0] = P_mktuple(P_IEXP, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <CSIGN> <IEXP2_EXPR>;
       t[1] = compile(P(1), depth+1 /* P_CSIGN */);
       t[2] = compile(P(2), depth+1 /* P_IEXP2_EXPR */);
       return t[0] = P_mktuple(P_IEXP, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<PCONST> =
   case P_PCONST:
#ifdef IN_PARSER

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

     } else                      {  //\\    <V>;
       t[1] = compile(P(1), depth+1 /* P_V */);
       return t[0] = P_mktuple(P_PCONST, 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<ACONST> =
   case P_ACONST:
#ifdef IN_PARSER

#endif
     {                              //\\    <?dq> <CONST>;
     t[1] = -1; /* ignore guard */;
     t[2] = compile(P(2), depth+1 /* P_CONST */);
     return t[0] = P_mktuple(P_ACONST, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<OCONST> =
   case P_OCONST:
#ifdef IN_PARSER

#endif
     {                              //\\    <?dq> <CONST>;
     t[1] = -1; /* ignore guard */;
     t[2] = compile(P(2), depth+1 /* P_CONST */);
     return t[0] = P_mktuple(P_OCONST, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<SEQ> =
   case P_SEQ:
#ifdef IN_PARSER

#endif
     {                              //\\    <V_or_N> '=' <NL_opt> <EXP> ',' <EXP> ',' <EXP>;
     t[1] = compile(P(1), depth+1 /* P_V_or_N */);
     t[2] = wlit(P(2) /*, L'=' */);
     t[3] = compile(P(3), depth+1 /* P_NL_opt */);
     t[4] = compile(P(4), depth+1 /* P_EXP */);
     t[5] = wlit(P(5) /*, L',' */);
     t[6] = compile(P(6), depth+1 /* P_EXP */);
     t[7] = wlit(P(7) /*, L',' */);
     t[8] = compile(P(8), depth+1 /* P_EXP */);
     return t[0] = P_mktuple(P_SEQ, alt, 8/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<record_field_decl> =
   case P_record_field_decl:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <simple_type> "name" <IDENTS>,
       t[1] = compile(P(1), depth+1 /* P_simple_type */);
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_IDENTS */);
       return t[0] = P_mktuple(P_record_field_decl, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <simple_type> "array" "name" <IDENTS>,
       t[1] = compile(P(1), depth+1 /* P_simple_type */);
       t[2] = wlit(P(2));
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_IDENTS */);
       return t[0] = P_mktuple(P_record_field_decl, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    <simple_type> "array" <IDENTS> <RCONST_BOUNDS>,
       t[1] = compile(P(1), depth+1 /* P_simple_type */);
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_IDENTS */);
       t[4] = compile(P(4), depth+1 /* P_RCONST_BOUNDS */);
       return t[0] = P_mktuple(P_record_field_decl, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    <simple_type> "name" "array" "name" <IDENTS>,
       t[1] = compile(P(1), depth+1 /* P_simple_type */);
       t[2] = wlit(P(2));
       t[3] = wlit(P(3));
       t[4] = wlit(P(4));
       t[5] = compile(P(5), depth+1 /* P_IDENTS */);
       return t[0] = P_mktuple(P_record_field_decl, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    <simple_type> <IDENTS>,
       t[1] = compile(P(1), depth+1 /* P_simple_type */);
       t[2] = compile(P(2), depth+1 /* P_IDENTS */);
       return t[0] = P_mktuple(P_record_field_decl, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 5)        {  //\\    "string" '(' <Star_or_IEXP> ')' "name" <IDENTS>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_Star_or_IEXP */);
       t[4] = wlit(P(4) /*, L')' */);
       t[5] = wlit(P(5));
       t[6] = compile(P(6), depth+1 /* P_IDENTS */);
       return t[0] = P_mktuple(P_record_field_decl, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 6)        {  //\\    "string" '(' <Star_or_IEXP> ')' "array" "name" <IDENTS>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_Star_or_IEXP */);
       t[4] = wlit(P(4) /*, L')' */);
       t[5] = wlit(P(5));
       t[6] = wlit(P(6));
       t[7] = compile(P(7), depth+1 /* P_IDENTS */);
       return t[0] = P_mktuple(P_record_field_decl, alt, 7/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 7)        {  //\\    "string" '(' <IEXP> ')' "array" <IDENTS> <RCONST_BOUNDS>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_IEXP */);
       t[4] = wlit(P(4) /*, L')' */);
       t[5] = wlit(P(5));
       t[6] = compile(P(6), depth+1 /* P_IDENTS */);
       t[7] = compile(P(7), depth+1 /* P_RCONST_BOUNDS */);
       return t[0] = P_mktuple(P_record_field_decl, alt, 7/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 8)        {  //\\    "string" '(' <Star_or_IEXP> ')' "name" "array" "name" <IDENTS>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_Star_or_IEXP */);
       t[4] = wlit(P(4) /*, L')' */);
       t[5] = wlit(P(5));
       t[6] = wlit(P(6));
       t[7] = wlit(P(7));
       t[8] = compile(P(8), depth+1 /* P_IDENTS */);
       return t[0] = P_mktuple(P_record_field_decl, alt, 8/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 9)        {  //\\    "string" '(' <Star_or_IEXP> ')' "name" "array" <IDENTS> <RCONST_BOUNDS>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_Star_or_IEXP */);
       t[4] = wlit(P(4) /*, L')' */);
       t[5] = wlit(P(5));
       t[6] = wlit(P(6));
       t[7] = compile(P(7), depth+1 /* P_IDENTS */);
       t[8] = compile(P(8), depth+1 /* P_RCONST_BOUNDS */);
       return t[0] = P_mktuple(P_record_field_decl, alt, 8/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 10)        {  //\\    "string" '(' <IEXP> ')' <IDENTS>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_IEXP */);
       t[4] = wlit(P(4) /*, L')' */);
       t[5] = compile(P(5), depth+1 /* P_IDENTS */);
       return t[0] = P_mktuple(P_record_field_decl, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 11)        {  //\\    "record" '(' <FM_or_Star> ')' "name" "array" "name" <IDENTS>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_FM_or_Star */);
       t[4] = wlit(P(4) /*, L')' */);
       t[5] = wlit(P(5));
       t[6] = wlit(P(6));
       t[7] = wlit(P(7));
       t[8] = compile(P(8), depth+1 /* P_IDENTS */);
       return t[0] = P_mktuple(P_record_field_decl, alt, 8/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 12)        {  //\\    "record" '(' <FM_or_Star> ')' "name" "array" <IDENTS> <RCONST_BOUNDS>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_FM_or_Star */);
       t[4] = wlit(P(4) /*, L')' */);
       t[5] = wlit(P(5));
       t[6] = wlit(P(6));
       t[7] = compile(P(7), depth+1 /* P_IDENTS */);
       t[8] = compile(P(8), depth+1 /* P_RCONST_BOUNDS */);
       return t[0] = P_mktuple(P_record_field_decl, alt, 8/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 13)        {  //\\    "record" '(' <FM_or_Star> ')' "name" <IDENTS>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_FM_or_Star */);
       t[4] = wlit(P(4) /*, L')' */);
       t[5] = wlit(P(5));
       t[6] = compile(P(6), depth+1 /* P_IDENTS */);
       return t[0] = P_mktuple(P_record_field_decl, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 14)        {  //\\    "record" '(' <IDENT> ')' "array" <IDENTS> <RCONST_BOUNDS>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_IDENT */);
       t[4] = wlit(P(4) /*, L')' */);
       t[5] = wlit(P(5));
       t[6] = compile(P(6), depth+1 /* P_IDENTS */);
       t[7] = compile(P(7), depth+1 /* P_RCONST_BOUNDS */);
       return t[0] = P_mktuple(P_record_field_decl, alt, 7/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 15)        {  //\\    "record" '(' <IDENT> ')' <IDENTS>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_IDENT */);
       t[4] = wlit(P(4) /*, L')' */);
       t[5] = compile(P(5), depth+1 /* P_IDENTS */);
       return t[0] = P_mktuple(P_record_field_decl, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    '(' <record_field_declarations> <OR_record_field_declarations> ')';
       t[1] = wlit(P(1) /*, L'(' */);
       t[2] = compile(P(2), depth+1 /* P_record_field_declarations */);
       t[3] = compile(P(3), depth+1 /* P_OR_record_field_declarations */);
       t[4] = wlit(P(4) /*, L')' */);
       return t[0] = P_mktuple(P_record_field_decl, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<OR_record_field_declarations> =
   case P_OR_record_field_declarations:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "or" <record_field_declarations> <OR_record_field_declarations>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_record_field_declarations */);
       t[3] = compile(P(3), depth+1 /* P_OR_record_field_declarations */);
       return t[0] = P_mktuple(P_OR_record_field_declarations, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<more_record_field_decls> =
   case P_more_record_field_decls:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <record_field_decl> <more_record_field_decls>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_record_field_decl */);
       t[4] = compile(P(4), depth+1 /* P_more_record_field_decls */);
       return t[0] = P_mktuple(P_more_record_field_decls, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<record_field_declarations> =
   case P_record_field_declarations:
#ifdef IN_PARSER

#endif
     {                              //\\    <NL_opt> <record_field_decl> <more_record_field_decls>;
     t[1] = compile(P(1), depth+1 /* P_NL_opt */);
     t[2] = compile(P(2), depth+1 /* P_record_field_decl */);
     t[3] = compile(P(3), depth+1 /* P_more_record_field_decls */);
     return t[0] = P_mktuple(P_record_field_declarations, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<CONST_BOUNDS> =
   case P_CONST_BOUNDS:
#ifdef IN_PARSER

#endif
     {                              //\\    '(' <IEXP> ':' <IEXP> ')';
     t[1] = wlit(P(1) /*, L'(' */);
     t[2] = compile(P(2), depth+1 /* P_IEXP */);
     t[3] = wlit(P(3) /*, L':' */);
     t[4] = compile(P(4), depth+1 /* P_IEXP */);
     t[5] = wlit(P(5) /*, L')' */);
     return t[0] = P_mktuple(P_CONST_BOUNDS, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<RCONST_BOUNDS> =
   case P_RCONST_BOUNDS:
#ifdef IN_PARSER

#endif
     {                              //\\    '(' <IEXP> ':' <IEXP> ')';
     t[1] = wlit(P(1) /*, L'(' */);
     t[2] = compile(P(2), depth+1 /* P_IEXP */);
     t[3] = wlit(P(3) /*, L':' */);
     t[4] = compile(P(4), depth+1 /* P_IEXP */);
     t[5] = wlit(P(5) /*, L')' */);
     return t[0] = P_mktuple(P_RCONST_BOUNDS, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<BOUNDS_PAIR> =
   case P_BOUNDS_PAIR:
#ifdef IN_PARSER

#endif
     {                              //\\    <EXP> ':' <EXP>;
     t[1] = compile(P(1), depth+1 /* P_EXP */);
     t[2] = wlit(P(2) /*, L':' */);
     t[3] = compile(P(3), depth+1 /* P_EXP */);
     return t[0] = P_mktuple(P_BOUNDS_PAIR, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest_of_BPL_LIST> =
   case P_rest_of_BPL_LIST:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<BPL_LIST> =
   case P_BPL_LIST:
#ifdef IN_PARSER

#endif
     {                              //\\    <BOUNDS_PAIR> <rest_of_BPL_LIST>;
     t[1] = compile(P(1), depth+1 /* P_BOUNDS_PAIR */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_BPL_LIST */);
     return t[0] = P_mktuple(P_BPL_LIST, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<BPL> =
   case P_BPL:
#ifdef IN_PARSER

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

     }
//\\ P<parameter_type> =
   case P_parameter_type:
#ifdef IN_PARSER

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

     } else if (alt == 1)        {  //\\    "string" '(' <Star_or_IEXP> ')',
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_Star_or_IEXP */);
       t[4] = wlit(P(4) /*, L')' */);
       return t[0] = P_mktuple(P_parameter_type, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "record" '(' <FM_or_Star> ')';
       t[1] = wlit(P(1));
       t[2] = wlit(P(2) /*, L'(' */);
       t[3] = compile(P(3), depth+1 /* P_FM_or_Star */);
       t[4] = wlit(P(4) /*, L')' */);
       return t[0] = P_mktuple(P_parameter_type, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<parameter_type_decl> =
   case P_parameter_type_decl:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <parameter_type> "name" <ARRAYNAME>,
       t[1] = compile(P(1), depth+1 /* P_parameter_type */);
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_ARRAYNAME */);
       return t[0] = P_mktuple(P_parameter_type_decl, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <parameter_type> "name",
       t[1] = compile(P(1), depth+1 /* P_parameter_type */);
       t[2] = wlit(P(2));
       return t[0] = P_mktuple(P_parameter_type_decl, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    <parameter_type> <ARRAYNAME>,
       t[1] = compile(P(1), depth+1 /* P_parameter_type */);
       t[2] = compile(P(2), depth+1 /* P_ARRAYNAME */);
       return t[0] = P_mktuple(P_parameter_type_decl, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<VDEC_or_PROC> =
   case P_VDEC_or_PROC:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <parameter_type_decl> <IDENTS> <another_FPP0>,
       t[1] = compile(P(1), depth+1 /* P_parameter_type_decl */);
       t[2] = compile(P(2), depth+1 /* P_IDENTS */);
       t[3] = compile(P(3), depth+1 /* P_another_FPP0 */);
       return t[0] = P_mktuple(P_VDEC_or_PROC, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <Rt_Fn_Map_Pred_DECL> <IDENT> <Rt_Pred_FPP>;
       t[1] = compile(P(1), depth+1 /* P_Rt_Fn_Map_Pred_DECL */);
       t[2] = compile(P(2), depth+1 /* P_IDENT */);
       t[3] = compile(P(3), depth+1 /* P_Rt_Pred_FPP */);
       return t[0] = P_mktuple(P_VDEC_or_PROC, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<More_FPPs> =
   case P_More_FPPs:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <VDEC_or_PROC> <More_FPPs>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_VDEC_or_PROC */);
       t[4] = compile(P(4), depth+1 /* P_More_FPPs */);
       return t[0] = P_mktuple(P_More_FPPs, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<FPP> =
   case P_FPP:
#ifdef IN_PARSER

#endif
     {                              //\\    <VDEC_or_PROC> <More_FPPs>;
     t[1] = compile(P(1), depth+1 /* P_VDEC_or_PROC */);
     t[2] = compile(P(2), depth+1 /* P_More_FPPs */);
     return t[0] = P_mktuple(P_FPP, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<FPP0> =
   case P_FPP0:
#ifdef IN_PARSER

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

     }
//\\ P<another_FPP0> =
   case P_another_FPP0:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <FPP0>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_FPP0 */);
       return t[0] = P_mktuple(P_another_FPP0, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<MORE_APPS> =
   case P_MORE_APPS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <EXP> <MORE_APPS>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_NL_opt */);
       t[3] = compile(P(3), depth+1 /* P_EXP */);
       t[4] = compile(P(4), depth+1 /* P_MORE_APPS */);
       return t[0] = P_mktuple(P_MORE_APPS, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<APP> =
   case P_APP:
#ifdef IN_PARSER

#endif
     {                              //\\    <EXP> <MORE_APPS>;
     t[1] = compile(P(1), depth+1 /* P_EXP */);
     t[2] = compile(P(2), depth+1 /* P_MORE_APPS */);
     return t[0] = P_mktuple(P_APP, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<rest_of_IEXP> =
   case P_rest_of_IEXP:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<const_event_list> =
   case P_const_event_list:
#ifdef IN_PARSER

#endif
     {                              //\\    <IEXP> <rest_of_IEXP>;
     t[1] = compile(P(1), depth+1 /* P_IEXP */);
     t[2] = compile(P(2), depth+1 /* P_rest_of_IEXP */);
     return t[0] = P_mktuple(P_const_event_list, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<RESLEFT_opt> =
   case P_RESLEFT_opt:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<RESRIGHT_opt> =
   case P_RESRIGHT_opt:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<RESEXP> =
   case P_RESEXP:
#ifdef IN_PARSER

#endif
     {                              //\\    <RESLEFT_opt> '(' <EXP> ')' <RESRIGHT_opt>;
     t[1] = compile(P(1), depth+1 /* P_RESLEFT_opt */);
     t[2] = wlit(P(2) /*, L'(' */);
     t[3] = compile(P(3), depth+1 /* P_EXP */);
     t[4] = wlit(P(4) /*, L')' */);
     t[5] = compile(P(5), depth+1 /* P_RESRIGHT_opt */);
     return t[0] = P_mktuple(P_RESEXP, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ E