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

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

#endif
                                    //\\    <Imp77_stropping> <NL_opt> <STATEMENTS> <FINAL>;
     T[++phrases] = -1 +(0 * P++) /* S_Imp77_stropping */ /* semantic call - temp for now. Could theoretically return a string like a terminal. Parser needs to insert something in CST. */;
     T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     T[++phrases] = build_ast(CST(P++) /* G_FINAL */);
     return T[0] = G_mktuple(G_SS, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    "endofprogram" <T>,
       T[++phrases] = kw(CST(P++), "endofprogram");
       T[++phrases] = build_ast(CST(P++) /* G_T */);
     } else if (alt == 1)        {  //\\    "endoffile" <T>,
       T[++phrases] = kw(CST(P++), "endoffile");
       T[++phrases] = build_ast(CST(P++) /* G_T */);
     } else                      {  //\\    <EOF>;
       T[++phrases] = BIP(CST(P++), B_EOF);
     }
     return T[0] = G_mktuple(G_FINAL, alt, phrases, T);

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

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

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

#endif
     if (alt == 0)               {  //\\    <Declaration> <T> <STATEMENTS>,
       T[++phrases] = build_ast(CST(P++) /* G_Declaration */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 1)        {  //\\    <simple_label> <T> <STATEMENTS>,
       T[++phrases] = build_ast(CST(P++) /* G_simple_label */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 2)        {  //\\    <simple_label> <STATEMENTS>,
       T[++phrases] = build_ast(CST(P++) /* G_simple_label */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 3)        {  //\\    <switch_label> <T> <STATEMENTS>,
       T[++phrases] = build_ast(CST(P++) /* G_switch_label */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 4)        {  //\\    <switch_label> <STATEMENTS>,
       T[++phrases] = build_ast(CST(P++) /* G_switch_label */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 5)        {  //\\    <FELSE_opt> <if_or_unless> <COND> "start" <T> <STATEMENTS>,
       T[++phrases] = build_ast(CST(P++) /* G_FELSE_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_if_or_unless */);
       T[++phrases] = build_ast(CST(P++) /* G_COND */);
       T[++phrases] = kw(CST(P++), "start");
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 6)        {  //\\    <FELSE_opt> <if_or_unless> <COND> "then" "start" <T> <STATEMENTS>,
       T[++phrases] = build_ast(CST(P++) /* G_FELSE_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_if_or_unless */);
       T[++phrases] = build_ast(CST(P++) /* G_COND */);
       T[++phrases] = kw(CST(P++), "then");
       T[++phrases] = kw(CST(P++), "start");
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 7)        {  //\\    <FELSE_opt> <if_or_unless> <COND> "then" <IMP> <else_final_IMP_opt> <T> <STATEMENTS>,
       T[++phrases] = build_ast(CST(P++) /* G_FELSE_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_if_or_unless */);
       T[++phrases] = build_ast(CST(P++) /* G_COND */);
       T[++phrases] = kw(CST(P++), "then");
       T[++phrases] = build_ast(CST(P++) /* G_IMP */);
       T[++phrases] = build_ast(CST(P++) /* G_else_final_IMP_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 8)        {  //\\    "finish" "else" "start" <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "finish");
       T[++phrases] = kw(CST(P++), "else");
       T[++phrases] = kw(CST(P++), "start");
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 9)        {  //\\    "finish" "else" <IMP> <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "finish");
       T[++phrases] = kw(CST(P++), "else");
       T[++phrases] = build_ast(CST(P++) /* G_IMP */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 10)        {  //\\    "else" <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "else");
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 11)        {  //\\    "else" <if_or_unless> <COND> <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "else");
       T[++phrases] = build_ast(CST(P++) /* G_if_or_unless */);
       T[++phrases] = build_ast(CST(P++) /* G_COND */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 12)        {  //\\    "else" <if_or_unless> <COND> "then" <IMP> <else_if_unless_XIMP_opt> <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "else");
       T[++phrases] = build_ast(CST(P++) /* G_if_or_unless */);
       T[++phrases] = build_ast(CST(P++) /* G_COND */);
       T[++phrases] = kw(CST(P++), "then");
       T[++phrases] = build_ast(CST(P++) /* G_IMP */);
       T[++phrases] = build_ast(CST(P++) /* G_else_if_unless_XIMP_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 13)        {  //\\    "finish" <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "finish");
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 14)        {  //\\    "begin" <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "begin");
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 15)        {  //\\    "program" <IDENT> <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "program");
       T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 16)        {  //\\    "list" <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "list");
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 17)        {  //\\    "endofperm" <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "endofperm");
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 18)        {  //\\    "endoflist" <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "endoflist");
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 19)        {  //\\    "end" <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "end");
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 20)        {  //\\    "cycle" <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "cycle");
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 21)        {  //\\    "cycle" <SEQ> <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "cycle");
       T[++phrases] = build_ast(CST(P++) /* G_SEQ */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 22)        {  //\\    <wh_for> <cycle_IMP> <T> <STATEMENTS>,
       T[++phrases] = build_ast(CST(P++) /* G_wh_for */);
       T[++phrases] = build_ast(CST(P++) /* G_cycle_IMP */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 23)        {  //\\    "repeat" <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "repeat");
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 24)        {  //\\    "repeat" "until" <COND> <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "repeat");
       T[++phrases] = kw(CST(P++), "until");
       T[++phrases] = build_ast(CST(P++) /* G_COND */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 25)        {  //\\    <on_event> <event_list_def> "start" <T> <STATEMENTS>,
       T[++phrases] = build_ast(CST(P++) /* G_on_event */);
       T[++phrases] = build_ast(CST(P++) /* G_event_list_def */);
       T[++phrases] = kw(CST(P++), "start");
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 26)        {  //\\    "control" <IEXP> <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "control");
       T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 27)        {  //\\    "diagnose" <IEXP> <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "diagnose");
       T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 28)        {  //\\    '*' '=' <IEXP> <T> <STATEMENTS>,
       T[++phrases] = ch(CST(P++), '*');
       T[++phrases] = ch(CST(P++), '=');
       T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 29)        {  //\\    '*' <T> <STATEMENTS>,
       T[++phrases] = ch(CST(P++), '*');
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 30)        {  //\\    "include" <?dq> <CONST> <INCL_LIST_opt> <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "include");
       T[++phrases] = -build_ast(CST(P++) /* G_dq */);
       T[++phrases] = build_ast(CST(P++) /* G_CONST */);
       T[++phrases] = build_ast(CST(P++) /* G_INCL_LIST_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 31)        {  //\\    "realslong" <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "realslong");
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 32)        {  //\\    "realsnormal" <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "realsnormal");
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 33)        {  //\\    "option" <OCONST> <T> <STATEMENTS>,
       T[++phrases] = kw(CST(P++), "option");
       T[++phrases] = build_ast(CST(P++) /* G_OCONST */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else if (alt == 34)        {  //\\    <IMP> <iu_while_until_for_T> <STATEMENTS>,
       T[++phrases] = build_ast(CST(P++) /* G_IMP */);
       T[++phrases] = build_ast(CST(P++) /* G_iu_while_until_for_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     } else                      {  //\\    <COMMENT_T> <STATEMENTS>;
       T[++phrases] = build_ast(CST(P++) /* G_COMMENT_T */);
       T[++phrases] = build_ast(CST(P++) /* G_STATEMENTS */);
     }
     return T[0] = G_mktuple(G_STATEMENT, alt, phrases, T);

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

#endif
                                    //\\    <!CONST> «[A-Z][A-Z0-9 ]*»;
     T[++phrases] = -1 +(0 * P++);
     T[++phrases] = reg(CST(P++), "[A-Z][A-Z0-9 ]*");
     return T[0] = G_mktuple(G_IDENT, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    '_' «[0-9A-Z][0-9A-Z ]*» <DeepBase>,
       T[++phrases] = ch(CST(P++), '_');
       T[++phrases] = reg(CST(P++), "[0-9A-Z][0-9A-Z ]*");
       T[++phrases] = build_ast(CST(P++) /* G_DeepBase */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_DeepBase, alt, phrases, T);

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

#endif
                                    //\\    '_' «[0-9A-Z][0-9A-Z ]*» <DeepBase>;
     T[++phrases] = ch(CST(P++), '_');
     T[++phrases] = reg(CST(P++), "[0-9A-Z][0-9A-Z ]*");
     T[++phrases] = build_ast(CST(P++) /* G_DeepBase */);
     return T[0] = G_mktuple(G_Based_Const, alt, phrases, T);

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

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

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

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

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

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

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

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

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

#endif
     if (alt == 0)               {  //\\    <Based_Const>,
       T[++phrases] = build_ast(CST(P++) /* G_Based_Const */);
     } else                      {  //\\    <OptDecimal> <OptExponent>;
       T[++phrases] = build_ast(CST(P++) /* G_OptDecimal */);
       T[++phrases] = build_ast(CST(P++) /* G_OptExponent */);
     }
     return T[0] = G_mktuple(G_Base_or_Float, alt, phrases, T);

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

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

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

#endif
     if (alt == 0)               {  //\\    <Num> <Base_or_Float>,
       T[++phrases] = build_ast(CST(P++) /* G_Num */);
       T[++phrases] = build_ast(CST(P++) /* G_Base_or_Float */);
     } else if (alt == 1)        {  //\\    <CharConst>,
       T[++phrases] = build_ast(CST(P++) /* G_CharConst */);
     } else if (alt == 2)        {  //\\    <ALIASTEXT>,
       T[++phrases] = build_ast(CST(P++) /* G_ALIASTEXT */);
     } else                      {  //\\    «[MBKXR]» <BigCharConst>;
       T[++phrases] = reg(CST(P++), "[MBKXR]");
       T[++phrases] = build_ast(CST(P++) /* G_BigCharConst */);
     }
     return T[0] = G_mktuple(G_CONST, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <dq> <dq> <stringchars>,
       T[++phrases] = build_ast(CST(P++) /* G_dq */);
       T[++phrases] = build_ast(CST(P++) /* G_dq */);
       T[++phrases] = build_ast(CST(P++) /* G_stringchars */);
     } else if (alt == 1)        {  //\\    <!dq> <any> <stringchars>,
       T[++phrases] = -1 +(0 * P++);
       T[++phrases] = build_ast(CST(P++) /* G_any */);
       T[++phrases] = build_ast(CST(P++) /* G_stringchars */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_stringchars, alt, phrases, T);

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

#endif
                                    //\\    <dq> <stringchars> <dq>;
     T[++phrases] = build_ast(CST(P++) /* G_dq */);
     T[++phrases] = build_ast(CST(P++) /* G_stringchars */);
     T[++phrases] = build_ast(CST(P++) /* G_dq */);
     return T[0] = G_mktuple(G_ALIASTEXT, alt, phrases, T);

//\\ P<V> =
   case G_V:
#if defined(NOT_SURE) || defined(BUILDING_CST)
  fprintf(stderr, "[V]");  
#endif
                                    //\\    <IDENT> <ESC_ARRAY_or_REC>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_ESC_ARRAY_or_REC */);
     return T[0] = G_mktuple(G_V, alt, phrases, T);

//\\ P<N> =
   case G_N:
#if defined(NOT_SURE) || defined(BUILDING_CST)
  fprintf(stderr, "[N]");  
#endif
                                    //\\    <IDENT> <ESC_ARRAY_or_REC>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_ESC_ARRAY_or_REC */);
     return T[0] = G_mktuple(G_N, alt, phrases, T);

//\\ P<FM> =
   case G_FM:
#if defined(NOT_SURE) || defined(BUILDING_CST)
  fprintf(stderr, "[FM]"); 
#endif
                                    //\\    <IDENT> <ESC_ARRAY_or_REC>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_ESC_ARRAY_or_REC */);
     return T[0] = G_mktuple(G_FM, alt, phrases, T);

//\\ P<A> =
   case G_A:
#if defined(NOT_SURE) || defined(BUILDING_CST)
  fprintf(stderr, "[A]");
#endif
                                    //\\    <IDENT> <ESC_ARRAY_or_REC>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_ESC_ARRAY_or_REC */);
     return T[0] = G_mktuple(G_A, alt, phrases, T);

//\\ P<AN> =
   case G_AN:
#if defined(NOT_SURE) || defined(BUILDING_CST)
  fprintf(stderr, "[AN]");
#endif
                                    //\\    <IDENT> <ESC_ARRAY_or_REC>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_ESC_ARRAY_or_REC */);
     return T[0] = G_mktuple(G_AN, alt, phrases, T);

//\\ P<NA> =
   case G_NA:
#if defined(NOT_SURE) || defined(BUILDING_CST)
  fprintf(stderr, "[NA]");
#endif
                                    //\\    <IDENT> <ESC_ARRAY_or_REC>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_ESC_ARRAY_or_REC */);
     return T[0] = G_mktuple(G_NA, alt, phrases, T);

//\\ P<NAN> =
   case G_NAN:
#if defined(NOT_SURE) || defined(BUILDING_CST)
  fprintf(stderr, "[NAN]");
#endif
                                    //\\    <IDENT> <ESC_ARRAY_or_REC>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_ESC_ARRAY_or_REC */);
     return T[0] = G_mktuple(G_NAN, alt, phrases, T);

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

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

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

#endif
     if (alt == 0)               {  //\\    <EOF> <NL_opt>,
       T[++phrases] = BIP(CST(P++), B_EOF);
       T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_NL_opt, alt, phrases, T);

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

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

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

#endif
     if (alt == 0)               {  //\\    ';' <more_Ts>,
       T[++phrases] = ch(CST(P++), ';');
       T[++phrases] = build_ast(CST(P++) /* G_more_Ts */);
     } else                      {  //\\    <EOF> <more_Ts>;
       T[++phrases] = BIP(CST(P++), B_EOF);
       T[++phrases] = build_ast(CST(P++) /* G_more_Ts */);
     }
     return T[0] = G_mktuple(G_T, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    "integer",
       T[++phrases] = kw(CST(P++), "integer");
     } else if (alt == 1)        {  //\\    "real",
       T[++phrases] = kw(CST(P++), "real");
     } else if (alt == 2)        {  //\\    "byteinteger",
       T[++phrases] = kw(CST(P++), "byteinteger");
     } else if (alt == 3)        {  //\\    "byte",
       T[++phrases] = kw(CST(P++), "byte");
     } else if (alt == 4)        {  //\\    "shortinteger",
       T[++phrases] = kw(CST(P++), "shortinteger");
     } else if (alt == 5)        {  //\\    "short",
       T[++phrases] = kw(CST(P++), "short");
     } else if (alt == 6)        {  //\\    "longinteger",
       T[++phrases] = kw(CST(P++), "longinteger");
     } else if (alt == 7)        {  //\\    "longreal",
       T[++phrases] = kw(CST(P++), "longreal");
     } else                      {  //\\    "long";
       T[++phrases] = kw(CST(P++), "long");
     }
     return T[0] = G_mktuple(G_simple_type, alt, phrases, T);

//\\ P<routine_or_predicate> =
   case G_routine_or_predicate:
#if defined(NOT_SURE) || defined(BUILDING_CST)
 fprintf(stderr, (alt == 1) ? "[R]" : "[P]"); 
#endif
     if (alt == 0)               {  //\\    "routine",
       T[++phrases] = kw(CST(P++), "routine");
     } else                      {  //\\    "predicate";
       T[++phrases] = kw(CST(P++), "predicate");
     }
     return T[0] = G_mktuple(G_routine_or_predicate, alt, phrases, T);

//\\ P<fn_or_map> =
   case G_fn_or_map:
#if defined(NOT_SURE) || defined(BUILDING_CST)
 fprintf(stderr, (alt <= 2) ? "[F]" : "[M]"); 
#endif
     if (alt == 0)               {  //\\    "function",
       T[++phrases] = kw(CST(P++), "function");
     } else if (alt == 1)        {  //\\    "fn",
       T[++phrases] = kw(CST(P++), "fn");
     } else if (alt == 2)        {  //\\    "map",
       T[++phrases] = kw(CST(P++), "map");
     } else if (alt == 3)        {  //\\    "namefn",
       T[++phrases] = kw(CST(P++), "namefn");
     } else                      {  //\\    "namefunction";
       T[++phrases] = kw(CST(P++), "namefunction");
     }
     return T[0] = G_mktuple(G_fn_or_map, alt, phrases, T);

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

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

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

#endif
     if (alt == 0)               {  //\\    "external",
       T[++phrases] = kw(CST(P++), "external");
     } else if (alt == 1)        {  //\\    "system",
       T[++phrases] = kw(CST(P++), "system");
     } else if (alt == 2)        {  //\\    "dynamic",
       T[++phrases] = kw(CST(P++), "dynamic");
     } else if (alt == 3)        {  //\\    "prim",
       T[++phrases] = kw(CST(P++), "prim");
     } else                      {  //\\    "perm";
       T[++phrases] = kw(CST(P++), "perm");
     }
     return T[0] = G_mktuple(G_EXTERNAL, alt, phrases, T);

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

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

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

#endif
     if (alt == 0)               {  //\\    '=',
       T[++phrases] = ch(CST(P++), '=');
     } else if (alt == 1)        {  //\\    '>' '=',
       T[++phrases] = ch(CST(P++), '>');
       T[++phrases] = ch(CST(P++), '=');
     } else if (alt == 2)        {  //\\    '>',
       T[++phrases] = ch(CST(P++), '>');
     } else if (alt == 3)        {  //\\    '<' '=',
       T[++phrases] = ch(CST(P++), '<');
       T[++phrases] = ch(CST(P++), '=');
     } else if (alt == 4)        {  //\\    '<',
       T[++phrases] = ch(CST(P++), '<');
     } else if (alt == 5)        {  //\\    '#',
       T[++phrases] = ch(CST(P++), '#');
     } else if (alt == 6)        {  //\\    '\' '=',
       T[++phrases] = ch(CST(P++), '\\');
       T[++phrases] = ch(CST(P++), '=');
     } else if (alt == 7)        {  //\\    '<' '>',
       T[++phrases] = ch(CST(P++), '<');
       T[++phrases] = ch(CST(P++), '>');
     } else                      {  //\\    '~' '=';
       T[++phrases] = ch(CST(P++), '~');
       T[++phrases] = ch(CST(P++), '=');
     }
     return T[0] = G_mktuple(G_COMP, alt, phrases, T);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#endif
     if (alt == 0)               {  //\\    <INDEF>,
       T[++phrases] = build_ast(CST(P++) /* G_INDEF */);
     } else                      {  //\\    <IEXP>;
       T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
     }
     return T[0] = G_mktuple(G_INDEF_or_IEXP, alt, phrases, T);

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

#endif
                                    //\\    '(' <INDEF_or_IEXP> ')';
     T[++phrases] = ch(CST(P++), '(');
     T[++phrases] = build_ast(CST(P++) /* G_INDEF_or_IEXP */);
     T[++phrases] = ch(CST(P++), ')');
     return T[0] = G_mktuple(G_bracketed_INDEF_or_IEXP, alt, phrases, T);

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

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

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

#endif
                                    //\\    <IEXP> <optional_initialiser_repeat_count>;
     T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
     T[++phrases] = build_ast(CST(P++) /* G_optional_initialiser_repeat_count */);
     return T[0] = G_mktuple(G_initialiser_item_with_optional_repeat_count, alt, phrases, T);

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

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

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

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

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

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <SWID> <rest_of_SWIDS>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_SWID */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_SWIDS */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_SWIDS, alt, phrases, T);

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

#endif
                                    //\\    <SWID> <rest_of_SWIDS>;
     T[++phrases] = build_ast(CST(P++) /* G_SWID */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_SWIDS */);
     return T[0] = G_mktuple(G_SWIDS, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <SWDEFS> <rest_of_SWDEFS>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_SWDEFS */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_SWDEFS */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_SWDEFS, alt, phrases, T);

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

#endif
                                    //\\    <SWDEF> <rest_of_SWDEFS>;
     T[++phrases] = build_ast(CST(P++) /* G_SWDEF */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_SWDEFS */);
     return T[0] = G_mktuple(G_SWDEFS, alt, phrases, T);

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

#endif
                                    //\\    <SWIDS> <CONST_BOUNDS>;
     T[++phrases] = build_ast(CST(P++) /* G_SWIDS */);
     T[++phrases] = build_ast(CST(P++) /* G_CONST_BOUNDS */);
     return T[0] = G_mktuple(G_SWDEF, alt, phrases, T);

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

#endif
                                    //\\    <L> ':';
     T[++phrases] = build_ast(CST(P++) /* G_L */);
     T[++phrases] = ch(CST(P++), ':');
     return T[0] = G_mktuple(G_simple_label, alt, phrases, T);

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

#endif
                                    //\\    <S> <bracketed_INDEF_or_IEXP> ':';
     T[++phrases] = build_ast(CST(P++) /* G_S */);
     T[++phrases] = build_ast(CST(P++) /* G_bracketed_INDEF_or_IEXP */);
     T[++phrases] = ch(CST(P++), ':');
     return T[0] = G_mktuple(G_switch_label, alt, phrases, T);

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

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

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

#endif
     if (alt == 0)               {  //\\    <S> '(' <EXP> ')',
       T[++phrases] = build_ast(CST(P++) /* G_S */);
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_EXP */);
       T[++phrases] = ch(CST(P++), ')');
     } else                      {  //\\    <L>;
       T[++phrases] = build_ast(CST(P++) /* G_L */);
     }
     return T[0] = G_mktuple(G_jump_destination, alt, phrases, T);

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

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

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

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

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

#endif
     if (alt == 0)               {  //\\    <simple_type>,
       T[++phrases] = build_ast(CST(P++) /* G_simple_type */);
     } else if (alt == 1)        {  //\\    "string" '(' <Star_or_IEXP> ')',
       T[++phrases] = kw(CST(P++), "string");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_Star_or_IEXP */);
       T[++phrases] = ch(CST(P++), ')');
     } else                      {  //\\    "record" '(' <FM_or_Star> ')';
       T[++phrases] = kw(CST(P++), "record");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_FM_or_Star */);
       T[++phrases] = ch(CST(P++), ')');
     }
     return T[0] = G_mktuple(G_result_types, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <simple_type>,
       T[++phrases] = build_ast(CST(P++) /* G_simple_type */);
     } else if (alt == 1)        {  //\\    "string" '(' <IEXP> ')',
       T[++phrases] = kw(CST(P++), "string");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
       T[++phrases] = ch(CST(P++), ')');
     } else                      {  //\\    "record" '(' <FM> ')';
       T[++phrases] = kw(CST(P++), "record");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_FM */);
       T[++phrases] = ch(CST(P++), ')');
     }
     return T[0] = G_mktuple(G_scalar_declaration_types, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <simple_type> "name",
       T[++phrases] = build_ast(CST(P++) /* G_simple_type */);
       T[++phrases] = kw(CST(P++), "name");
     } else if (alt == 1)        {  //\\    "string" '(' <Star_or_IEXP> ')' "name",
       T[++phrases] = kw(CST(P++), "string");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_Star_or_IEXP */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = kw(CST(P++), "name");
     } else                      {  //\\    "record" '(' <FM_or_Star> ')' "name";
       T[++phrases] = kw(CST(P++), "record");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_FM_or_Star */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = kw(CST(P++), "name");
     }
     return T[0] = G_mktuple(G_name_declaration_types, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <routine_or_predicate>,
       T[++phrases] = build_ast(CST(P++) /* G_routine_or_predicate */);
     } else                      {  //\\    <result_types> <fn_or_map>;
       T[++phrases] = build_ast(CST(P++) /* G_result_types */);
       T[++phrases] = build_ast(CST(P++) /* G_fn_or_map */);
     }
     return T[0] = G_mktuple(G_Rt_Fn_Map_Pred_DECL, alt, phrases, T);

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

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

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

#endif
     if (alt == 0)               {  //\\    "array" "name",
       T[++phrases] = kw(CST(P++), "array");
       T[++phrases] = kw(CST(P++), "name");
     } else                      {  //\\    "array" '(' <IEXP> ')' "name";
       T[++phrases] = kw(CST(P++), "array");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = kw(CST(P++), "name");
     }
     return T[0] = G_mktuple(G_ARRAYNAME, alt, phrases, T);

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

#endif
                                    //\\    <EXTERNAL_opt> <Rt_Fn_Map_Pred_DECL> <SPEC_opt> <PROC_or_PROCSPEC> <IDENT> <ALIAS_opt> <Rt_Pred_FPP>;
     T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_Rt_Fn_Map_Pred_DECL */);
     T[++phrases] = build_ast(CST(P++) /* G_SPEC_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_PROC_or_PROCSPEC */);
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_ALIAS_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_Rt_Pred_FPP */);
     return T[0] = G_mktuple(G_Proc_Declaration, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <EXTERNAL> <name_declaration_types> <ARRAYNAME> "spec" <IDENTS>,
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL */);
       T[++phrases] = build_ast(CST(P++) /* G_name_declaration_types */);
       T[++phrases] = build_ast(CST(P++) /* G_ARRAYNAME */);
       T[++phrases] = kw(CST(P++), "spec");
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     } else                      {  //\\    <EXTERNAL> <name_declaration_types> <ARRAYNAME> <IDENTS>;
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL */);
       T[++phrases] = build_ast(CST(P++) /* G_name_declaration_types */);
       T[++phrases] = build_ast(CST(P++) /* G_ARRAYNAME */);
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     }
     return T[0] = G_mktuple(G_External_Name_Array_Name_Declaration, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <EXTERNAL> <scalar_declaration_types> <ARRAYNAME> "spec" <IDENTS>,
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL */);
       T[++phrases] = build_ast(CST(P++) /* G_scalar_declaration_types */);
       T[++phrases] = build_ast(CST(P++) /* G_ARRAYNAME */);
       T[++phrases] = kw(CST(P++), "spec");
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     } else                      {  //\\    <EXTERNAL> <scalar_declaration_types> <ARRAYNAME> <IDENTS>;
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL */);
       T[++phrases] = build_ast(CST(P++) /* G_scalar_declaration_types */);
       T[++phrases] = build_ast(CST(P++) /* G_ARRAYNAME */);
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     }
     return T[0] = G_mktuple(G_External_Array_Name_Declaration, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <EXTERNAL> <scalar_declaration_types> "array" "spec" <EXTERNAL_array_idents>,
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL */);
       T[++phrases] = build_ast(CST(P++) /* G_scalar_declaration_types */);
       T[++phrases] = kw(CST(P++), "array");
       T[++phrases] = kw(CST(P++), "spec");
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL_array_idents */);
     } else                      {  //\\    <EXTERNAL> <scalar_declaration_types> "array" <EXTERNAL_array_ident_and_optional_assignment>;
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL */);
       T[++phrases] = build_ast(CST(P++) /* G_scalar_declaration_types */);
       T[++phrases] = kw(CST(P++), "array");
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL_array_ident_and_optional_assignment */);
     }
     return T[0] = G_mktuple(G_External_Array_Declaration, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <EXTERNAL> <name_declaration_types> "array" "spec" <EXTERNAL_name_array_idents>,
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL */);
       T[++phrases] = build_ast(CST(P++) /* G_name_declaration_types */);
       T[++phrases] = kw(CST(P++), "array");
       T[++phrases] = kw(CST(P++), "spec");
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL_name_array_idents */);
     } else                      {  //\\    <EXTERNAL> <name_declaration_types> "array" <EXTERNAL_name_array_idents>;
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL */);
       T[++phrases] = build_ast(CST(P++) /* G_name_declaration_types */);
       T[++phrases] = kw(CST(P++), "array");
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL_name_array_idents */);
     }
     return T[0] = G_mktuple(G_External_Name_Array_Declaration, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <EXTERNAL> <name_declaration_types> "spec" <EXTERNAL_name_idents>,
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL */);
       T[++phrases] = build_ast(CST(P++) /* G_name_declaration_types */);
       T[++phrases] = kw(CST(P++), "spec");
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL_name_idents */);
     } else if (alt == 1)        {  //\\    <EXTERNAL> <name_declaration_types> <EXTERNAL_name_idents_and_optional_assignments>,
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL */);
       T[++phrases] = build_ast(CST(P++) /* G_name_declaration_types */);
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL_name_idents_and_optional_assignments */);
     } else                      {  //\\    <EXTERNAL> "name" <EXTERNAL_name_idents_and_optional_assignments>;
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL */);
       T[++phrases] = kw(CST(P++), "name");
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL_name_idents_and_optional_assignments */);
     }
     return T[0] = G_mktuple(G_External_Scalar_Name_Declaration, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <EXTERNAL> <scalar_declaration_types> "spec" <EXTERNAL_scalar_idents>,
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL */);
       T[++phrases] = build_ast(CST(P++) /* G_scalar_declaration_types */);
       T[++phrases] = kw(CST(P++), "spec");
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL_scalar_idents */);
     } else                      {  //\\    <EXTERNAL> <scalar_declaration_types> <EXTERNAL_scalar_idents_and_optional_assignments>;
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL */);
       T[++phrases] = build_ast(CST(P++) /* G_scalar_declaration_types */);
       T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL_scalar_idents_and_optional_assignments */);
     }
     return T[0] = G_mktuple(G_External_Scalar_Declaration, alt, phrases, T);

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

#endif
                                    //\\    <OWN_or_CONST> <name_declaration_types> <ARRAYNAME> <IDENTS>;
     T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST */);
     T[++phrases] = build_ast(CST(P++) /* G_name_declaration_types */);
     T[++phrases] = build_ast(CST(P++) /* G_ARRAYNAME */);
     T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     return T[0] = G_mktuple(G_OWN_or_CONST_Name_Array_Name_Declaration, alt, phrases, T);

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

#endif
                                    //\\    <OWN_or_CONST> <scalar_declaration_types> <ARRAYNAME> <IDENTS>;
     T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST */);
     T[++phrases] = build_ast(CST(P++) /* G_scalar_declaration_types */);
     T[++phrases] = build_ast(CST(P++) /* G_ARRAYNAME */);
     T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     return T[0] = G_mktuple(G_OWN_or_CONST_Array_Name_Declaration, alt, phrases, T);

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

#endif
                                    //\\    <OWN_or_CONST> <scalar_declaration_types> "array" <OWN_or_CONST_array_ident_and_optional_assignment>;
     T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST */);
     T[++phrases] = build_ast(CST(P++) /* G_scalar_declaration_types */);
     T[++phrases] = kw(CST(P++), "array");
     T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST_array_ident_and_optional_assignment */);
     return T[0] = G_mktuple(G_OWN_or_CONST_Array_Declaration, alt, phrases, T);

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

#endif
                                    //\\    <OWN_or_CONST> <name_declaration_types> "array" <OWN_or_CONST_name_array_idents>;
     T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST */);
     T[++phrases] = build_ast(CST(P++) /* G_name_declaration_types */);
     T[++phrases] = kw(CST(P++), "array");
     T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST_name_array_idents */);
     return T[0] = G_mktuple(G_OWN_or_CONST_Name_Array_Declaration, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <OWN_or_CONST> <name_declaration_types> <OWN_or_CONST_name_idents_and_optional_assignments>,
       T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST */);
       T[++phrases] = build_ast(CST(P++) /* G_name_declaration_types */);
       T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST_name_idents_and_optional_assignments */);
     } else                      {  //\\    <OWN_or_CONST> "name" <OWN_or_CONST_name_idents_and_optional_assignments>;
       T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST */);
       T[++phrases] = kw(CST(P++), "name");
       T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST_name_idents_and_optional_assignments */);
     }
     return T[0] = G_mktuple(G_OWN_or_CONST_Scalar_Name_Declaration, alt, phrases, T);

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

#endif
                                    //\\    <OWN_or_CONST> <scalar_declaration_types> <OWN_or_CONST_scalar_idents_and_optional_assignments>;
     T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST */);
     T[++phrases] = build_ast(CST(P++) /* G_scalar_declaration_types */);
     T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST_scalar_idents_and_optional_assignments */);
     return T[0] = G_mktuple(G_OWN_or_CONST_Scalar_Declaration, alt, phrases, T);

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

#endif
                                    //\\    <name_declaration_types> <ARRAYNAME> <IDENTS>;
     T[++phrases] = build_ast(CST(P++) /* G_name_declaration_types */);
     T[++phrases] = build_ast(CST(P++) /* G_ARRAYNAME */);
     T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     return T[0] = G_mktuple(G_AUTO_Name_Array_Name_Declaration, alt, phrases, T);

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

#endif
                                    //\\    <scalar_declaration_types> <ARRAYNAME> <IDENTS>;
     T[++phrases] = build_ast(CST(P++) /* G_scalar_declaration_types */);
     T[++phrases] = build_ast(CST(P++) /* G_ARRAYNAME */);
     T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     return T[0] = G_mktuple(G_AUTO_Array_Name_Declaration, alt, phrases, T);

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

#endif
                                    //\\    <scalar_declaration_types> "array" <AUTO_array_idents>;
     T[++phrases] = build_ast(CST(P++) /* G_scalar_declaration_types */);
     T[++phrases] = kw(CST(P++), "array");
     T[++phrases] = build_ast(CST(P++) /* G_AUTO_array_idents */);
     return T[0] = G_mktuple(G_AUTO_Array_Declaration, alt, phrases, T);

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

#endif
                                    //\\    <name_declaration_types> "array" <AUTO_name_array_idents>;
     T[++phrases] = build_ast(CST(P++) /* G_name_declaration_types */);
     T[++phrases] = kw(CST(P++), "array");
     T[++phrases] = build_ast(CST(P++) /* G_AUTO_name_array_idents */);
     return T[0] = G_mktuple(G_AUTO_Name_Array_Declaration, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <name_declaration_types> <AUTO_name_idents_and_optional_assignments>,
       T[++phrases] = build_ast(CST(P++) /* G_name_declaration_types */);
       T[++phrases] = build_ast(CST(P++) /* G_AUTO_name_idents_and_optional_assignments */);
     } else                      {  //\\    "name" <AUTO_name_idents_and_optional_assignments>;
       T[++phrases] = kw(CST(P++), "name");
       T[++phrases] = build_ast(CST(P++) /* G_AUTO_name_idents_and_optional_assignments */);
     }
     return T[0] = G_mktuple(G_AUTO_Scalar_Name_Declaration, alt, phrases, T);

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

#endif
                                    //\\    <scalar_declaration_types> <AUTO_scalar_idents_and_optional_assignments>;
     T[++phrases] = build_ast(CST(P++) /* G_scalar_declaration_types */);
     T[++phrases] = build_ast(CST(P++) /* G_AUTO_scalar_idents_and_optional_assignments */);
     return T[0] = G_mktuple(G_AUTO_Scalar_Declaration, alt, phrases, T);

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

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

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

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

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

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

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

#endif
                                    //\\    <IDENT> <optional_name_assignment>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_optional_name_assignment */);
     return T[0] = G_mktuple(G_name_ident_and_optional_assignment, alt, phrases, T);

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

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

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

#endif
                                    //\\    <name_ident_and_optional_assignment> <more_name_idents_and_optional_assignments>;
     T[++phrases] = build_ast(CST(P++) /* G_name_ident_and_optional_assignment */);
     T[++phrases] = build_ast(CST(P++) /* G_more_name_idents_and_optional_assignments */);
     return T[0] = G_mktuple(G_name_idents_and_optional_assignments, alt, phrases, T);

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

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

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

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

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

#endif
                                    //\\    <name_ident> <more_name_idents>;
     T[++phrases] = build_ast(CST(P++) /* G_name_ident */);
     T[++phrases] = build_ast(CST(P++) /* G_more_name_idents */);
     return T[0] = G_mktuple(G_name_idents, alt, phrases, T);

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

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

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

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

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

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

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

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

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

#endif
                                    //\\    <IDENTS> <const_array_bounds> <more_name_array_idents>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     T[++phrases] = build_ast(CST(P++) /* G_const_array_bounds */);
     T[++phrases] = build_ast(CST(P++) /* G_more_name_array_idents */);
     return T[0] = G_mktuple(G_name_array_idents, alt, phrases, T);

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

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

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

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

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

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

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

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

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

#endif
                                    //\\    <IDENTS> <BPL> <more_AUTO_name_array_idents>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     T[++phrases] = build_ast(CST(P++) /* G_BPL */);
     T[++phrases] = build_ast(CST(P++) /* G_more_AUTO_name_array_idents */);
     return T[0] = G_mktuple(G_AUTO_name_array_idents, alt, phrases, T);

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

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

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

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

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

#endif
                                    //\\    <IDENTS> <const_array_bounds> <more_external_array_idents>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     T[++phrases] = build_ast(CST(P++) /* G_const_array_bounds */);
     T[++phrases] = build_ast(CST(P++) /* G_more_external_array_idents */);
     return T[0] = G_mktuple(G_EXTERNAL_array_idents, alt, phrases, T);

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

#endif
                                    //\\    <IDENTS> <BPL> <more_AUTO_array_idents>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     T[++phrases] = build_ast(CST(P++) /* G_BPL */);
     T[++phrases] = build_ast(CST(P++) /* G_more_AUTO_array_idents */);
     return T[0] = G_mktuple(G_AUTO_array_idents, alt, phrases, T);

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

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

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

#endif
                                    //\\    <IDENT> <optional_scalar_assignment>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_optional_scalar_assignment */);
     return T[0] = G_mktuple(G_scalar_ident_and_optional_assignment, alt, phrases, T);

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

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

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

#endif
                                    //\\    <scalar_ident_and_optional_assignment> <more_scalar_idents_and_optional_assignments>;
     T[++phrases] = build_ast(CST(P++) /* G_scalar_ident_and_optional_assignment */);
     T[++phrases] = build_ast(CST(P++) /* G_more_scalar_idents_and_optional_assignments */);
     return T[0] = G_mktuple(G_scalar_idents_and_optional_assignments, alt, phrases, T);

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

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

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

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

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

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

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

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

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

#endif
                                    //\\    <EXTERNAL_scalar_ident> <more_external_scalar_idents>;
     T[++phrases] = build_ast(CST(P++) /* G_EXTERNAL_scalar_ident */);
     T[++phrases] = build_ast(CST(P++) /* G_more_external_scalar_idents */);
     return T[0] = G_mktuple(G_EXTERNAL_scalar_idents, alt, phrases, T);

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

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

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

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

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

#endif
                                    //\\    <initialiser_item_with_optional_repeat_count> <more_array_data>;
     T[++phrases] = build_ast(CST(P++) /* G_initialiser_item_with_optional_repeat_count */);
     T[++phrases] = build_ast(CST(P++) /* G_more_array_data */);
     return T[0] = G_mktuple(G_scalar_array_data, alt, phrases, T);

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

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

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

#endif
                                    //\\    <IDENT> <const_array_bounds> <optional_array_assignment>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_const_array_bounds */);
     T[++phrases] = build_ast(CST(P++) /* G_optional_array_assignment */);
     return T[0] = G_mktuple(G_EXTERNAL_array_ident_and_optional_assignment, alt, phrases, T);

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

#endif
                                    //\\    <IDENT> <const_array_bounds> <optional_array_assignment>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_const_array_bounds */);
     T[++phrases] = build_ast(CST(P++) /* G_optional_array_assignment */);
     return T[0] = G_mktuple(G_OWN_or_CONST_array_ident_and_optional_assignment, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <External_Name_Array_Name_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_External_Name_Array_Name_Declaration */);
     } else if (alt == 1)        {  //\\    <OWN_or_CONST_Name_Array_Name_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST_Name_Array_Name_Declaration */);
     } else                      {  //\\    <AUTO_Name_Array_Name_Declaration>;
       T[++phrases] = build_ast(CST(P++) /* G_AUTO_Name_Array_Name_Declaration */);
     }
     return T[0] = G_mktuple(G_Name_Array_Name_Declaration, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <External_Array_Name_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_External_Array_Name_Declaration */);
     } else if (alt == 1)        {  //\\    <OWN_or_CONST_Array_Name_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST_Array_Name_Declaration */);
     } else                      {  //\\    <AUTO_Array_Name_Declaration>;
       T[++phrases] = build_ast(CST(P++) /* G_AUTO_Array_Name_Declaration */);
     }
     return T[0] = G_mktuple(G_Array_Name_Declaration, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <External_Name_Array_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_External_Name_Array_Declaration */);
     } else if (alt == 1)        {  //\\    <OWN_or_CONST_Name_Array_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST_Name_Array_Declaration */);
     } else                      {  //\\    <AUTO_Name_Array_Declaration>;
       T[++phrases] = build_ast(CST(P++) /* G_AUTO_Name_Array_Declaration */);
     }
     return T[0] = G_mktuple(G_Name_Array_Declaration, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <External_Array_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_External_Array_Declaration */);
     } else if (alt == 1)        {  //\\    <OWN_or_CONST_Array_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST_Array_Declaration */);
     } else                      {  //\\    <AUTO_Array_Declaration>;
       T[++phrases] = build_ast(CST(P++) /* G_AUTO_Array_Declaration */);
     }
     return T[0] = G_mktuple(G_Array_Declaration, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <External_Scalar_Name_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_External_Scalar_Name_Declaration */);
     } else if (alt == 1)        {  //\\    <OWN_or_CONST_Scalar_Name_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST_Scalar_Name_Declaration */);
     } else                      {  //\\    <AUTO_Scalar_Name_Declaration>;
       T[++phrases] = build_ast(CST(P++) /* G_AUTO_Scalar_Name_Declaration */);
     }
     return T[0] = G_mktuple(G_Scalar_Name_Declaration, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <External_Scalar_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_External_Scalar_Declaration */);
     } else if (alt == 1)        {  //\\    <OWN_or_CONST_Scalar_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_OWN_or_CONST_Scalar_Declaration */);
     } else                      {  //\\    <AUTO_Scalar_Declaration>;
       T[++phrases] = build_ast(CST(P++) /* G_AUTO_Scalar_Declaration */);
     }
     return T[0] = G_mktuple(G_Scalar_Declaration, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <Name_Array_Name_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_Name_Array_Name_Declaration */);
     } else if (alt == 1)        {  //\\    <Array_Name_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_Array_Name_Declaration */);
     } else if (alt == 2)        {  //\\    <Name_Array_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_Name_Array_Declaration */);
     } else if (alt == 3)        {  //\\    <Array_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_Array_Declaration */);
     } else if (alt == 4)        {  //\\    <Scalar_Name_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_Scalar_Name_Declaration */);
     } else                      {  //\\    <Scalar_Declaration>;
       T[++phrases] = build_ast(CST(P++) /* G_Scalar_Declaration */);
     }
     return T[0] = G_mktuple(G_Data_Declaration, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <Proc_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_Proc_Declaration */);
     } else if (alt == 1)        {  //\\    <Data_Declaration>,
       T[++phrases] = build_ast(CST(P++) /* G_Data_Declaration */);
     } else if (alt == 2)        {  //\\    "recordformatspec" <IDENT>,
       T[++phrases] = kw(CST(P++), "recordformatspec");
       T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     } else if (alt == 3)        {  //\\    "recordformat" <IDENT> '(' <record_field_declarations> ')',
       T[++phrases] = kw(CST(P++), "recordformat");
       T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_record_field_declarations */);
       T[++phrases] = ch(CST(P++), ')');
     } else if (alt == 4)        {  //\\    "switch" <SWDEFS>,
       T[++phrases] = kw(CST(P++), "switch");
       T[++phrases] = build_ast(CST(P++) /* G_SWDEFS */);
     } else                      {  //\\    "label" <IDENTS>;
       T[++phrases] = kw(CST(P++), "label");
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     }
     return T[0] = G_mktuple(G_Declaration, alt, phrases, T);

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

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

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

#endif
                                    //\\    <IDENT> <optional_parameters>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_optional_parameters */);
     return T[0] = G_mktuple(G_Rt_CALL, alt, phrases, T);

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

#endif
                                    //\\    <IDENT> <optional_parameters>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_optional_parameters */);
     return T[0] = G_mktuple(G_Fn_CALL, alt, phrases, T);

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

#endif
                                    //\\    <IDENT> <optional_parameters>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_optional_parameters */);
     return T[0] = G_mktuple(G_Map_CALL, alt, phrases, T);

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

#endif
                                    //\\    <IDENT> <optional_parameters>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_optional_parameters */);
     return T[0] = G_mktuple(G_Pred_CALL, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <?PROC>,
       T[++phrases] = -1 +(0 * P++) /* S_PROC */ /* semantic call - temp for now. Could theoretically return a string like a terminal. Parser needs to insert something in CST. */;
     } else                      {  //\\    <?PROCSPEC>;
       T[++phrases] = -1 +(0 * P++) /* S_PROCSPEC */ /* semantic call - temp for now. Could theoretically return a string like a terminal. Parser needs to insert something in CST. */;
     }
     return T[0] = G_mktuple(G_PROC_or_PROCSPEC, alt, phrases, T);

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

#endif
                                    //\\    '(' <APP> ')' <ESCREC_opt>;
     T[++phrases] = ch(CST(P++), '(');
     T[++phrases] = build_ast(CST(P++) /* G_APP */);
     T[++phrases] = ch(CST(P++), ')');
     T[++phrases] = build_ast(CST(P++) /* G_ESCREC_opt */);
     return T[0] = G_mktuple(G_ESCARRAY, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <ESCREC> <ESC_ARRAY_or_REC>,
       T[++phrases] = build_ast(CST(P++) /* G_ESCREC */);
       T[++phrases] = build_ast(CST(P++) /* G_ESC_ARRAY_or_REC */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_ESCREC_opt, alt, phrases, T);

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

#endif
                                    //\\    '_' <IDENT> <ESC_ARRAY_or_REC>;
     T[++phrases] = ch(CST(P++), '_');
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_ESC_ARRAY_or_REC */);
     return T[0] = G_mktuple(G_ESCREC, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <ESCARRAY>,
       T[++phrases] = build_ast(CST(P++) /* G_ESCARRAY */);
     } else if (alt == 1)        {  //\\    <ESCREC>,
       T[++phrases] = build_ast(CST(P++) /* G_ESCREC */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_ESC_ARRAY_or_REC, alt, phrases, T);

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

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

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

#endif
     if (alt == 0)               {  //\\    <EOF> <any> <COMMENT_TEXT>,
       T[++phrases] = BIP(CST(P++), B_EOF);
       T[++phrases] = build_ast(CST(P++) /* G_any */);
       T[++phrases] = build_ast(CST(P++) /* G_COMMENT_TEXT */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_COMMENT_TEXT, alt, phrases, T);

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

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

//\\ P<COMMENT_T> =
   case G_COMMENT_T:
#if defined(NOT_SURE) || defined(BUILDING_CST)
 return -1; 
#endif
                                    //\\    <COMMENT> <COMMENT_TEXT> <T>;
     T[++phrases] = build_ast(CST(P++) /* G_COMMENT */);
     T[++phrases] = build_ast(CST(P++) /* G_COMMENT_TEXT */);
     T[++phrases] = build_ast(CST(P++) /* G_T */);
     return T[0] = G_mktuple(G_COMMENT_T, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <V> <ESC_ARRAY_or_REC>,
       T[++phrases] = build_ast(CST(P++) /* G_V */);
       T[++phrases] = build_ast(CST(P++) /* G_ESC_ARRAY_or_REC */);
     } else if (alt == 1)        {  //\\    <N> <ESC_ARRAY_or_REC>,
       T[++phrases] = build_ast(CST(P++) /* G_N */);
       T[++phrases] = build_ast(CST(P++) /* G_ESC_ARRAY_or_REC */);
     } else                      {  //\\    <Map_CALL> <ESCREC>;
       T[++phrases] = build_ast(CST(P++) /* G_Map_CALL */);
       T[++phrases] = build_ast(CST(P++) /* G_ESCREC */);
     }
     return T[0] = G_mktuple(G_LHS, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <LHS> <IMP_ASSIGN> <and_IMPS>,
       T[++phrases] = build_ast(CST(P++) /* G_LHS */);
       T[++phrases] = build_ast(CST(P++) /* G_IMP_ASSIGN */);
       T[++phrases] = build_ast(CST(P++) /* G_and_IMPS */);
     } else if (alt == 1)        {  //\\    <N> <N_ASS> <and_IMPS>,
       T[++phrases] = build_ast(CST(P++) /* G_N */);
       T[++phrases] = build_ast(CST(P++) /* G_N_ASS */);
       T[++phrases] = build_ast(CST(P++) /* G_and_IMPS */);
     } else if (alt == 2)        {  //\\    <Rt_CALL> <and_IMPS>,
       T[++phrases] = build_ast(CST(P++) /* G_Rt_CALL */);
       T[++phrases] = build_ast(CST(P++) /* G_and_IMPS */);
     } else if (alt == 3)        {  //\\    <BACK>,
       T[++phrases] = build_ast(CST(P++) /* G_BACK */);
     } else if (alt == 4)        {  //\\    "result" '=' '=' <NL_opt> <V_or_N>,
       T[++phrases] = kw(CST(P++), "result");
       T[++phrases] = ch(CST(P++), '=');
       T[++phrases] = ch(CST(P++), '=');
       T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_V_or_N */);
     } else if (alt == 5)        {  //\\    "result" '=' <NL_opt> <EXP>,
       T[++phrases] = kw(CST(P++), "result");
       T[++phrases] = ch(CST(P++), '=');
       T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_EXP */);
     } else if (alt == 6)        {  //\\    <exit_or_continue>,
       T[++phrases] = build_ast(CST(P++) /* G_exit_or_continue */);
     } else if (alt == 7)        {  //\\    <AN> '=' '=' <NL_opt> <A_or_AN> <and_IMPS>,
       T[++phrases] = build_ast(CST(P++) /* G_AN */);
       T[++phrases] = ch(CST(P++), '=');
       T[++phrases] = ch(CST(P++), '=');
       T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_A_or_AN */);
       T[++phrases] = build_ast(CST(P++) /* G_and_IMPS */);
     } else if (alt == 8)        {  //\\    <NAN> '=' '=' <NL_opt> <NA_or_NAN> <and_IMPS>,
       T[++phrases] = build_ast(CST(P++) /* G_NAN */);
       T[++phrases] = ch(CST(P++), '=');
       T[++phrases] = ch(CST(P++), '=');
       T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_NA_or_NAN */);
       T[++phrases] = build_ast(CST(P++) /* G_and_IMPS */);
     } else if (alt == 9)        {  //\\    "stop",
       T[++phrases] = kw(CST(P++), "stop");
     } else if (alt == 10)        {  //\\    "monitor" <and_IMPS>,
       T[++phrases] = kw(CST(P++), "monitor");
       T[++phrases] = build_ast(CST(P++) /* G_and_IMPS */);
     } else if (alt == 11)        {  //\\    '-' '>' <jump_destination>,
       T[++phrases] = ch(CST(P++), '-');
       T[++phrases] = ch(CST(P++), '>');
       T[++phrases] = build_ast(CST(P++) /* G_jump_destination */);
     } else                      {  //\\    <SIGNAL> <IEXP> <subevent_and_extra>;
       T[++phrases] = build_ast(CST(P++) /* G_SIGNAL */);
       T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
       T[++phrases] = build_ast(CST(P++) /* G_subevent_and_extra */);
     }
     return T[0] = G_mktuple(G_IMP, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <COND> "start",
       T[++phrases] = build_ast(CST(P++) /* G_COND */);
       T[++phrases] = kw(CST(P++), "start");
     } else if (alt == 1)        {  //\\    <COND> "then" "start",
       T[++phrases] = build_ast(CST(P++) /* G_COND */);
       T[++phrases] = kw(CST(P++), "then");
       T[++phrases] = kw(CST(P++), "start");
     } else                      {  //\\    <COND> "then" <IMP> <else_start_IMP_opt>;
       T[++phrases] = build_ast(CST(P++) /* G_COND */);
       T[++phrases] = kw(CST(P++), "then");
       T[++phrases] = build_ast(CST(P++) /* G_IMP */);
       T[++phrases] = build_ast(CST(P++) /* G_else_start_IMP_opt */);
     }
     return T[0] = G_mktuple(G_EIMP, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <COND> "then" <IMP> <else_if_XIMP_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_COND */);
       T[++phrases] = kw(CST(P++), "then");
       T[++phrases] = build_ast(CST(P++) /* G_IMP */);
       T[++phrases] = build_ast(CST(P++) /* G_else_if_XIMP_opt */);
     } else                      {  //\\    <COND> <THEN_opt>;
       T[++phrases] = build_ast(CST(P++) /* G_COND */);
       T[++phrases] = build_ast(CST(P++) /* G_THEN_opt */);
     }
     return T[0] = G_mktuple(G_XIMP, alt, phrases, T);

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

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

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

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

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

#endif
     if (alt == 0)               {  //\\    <if_or_unless> <XIMP>,
       T[++phrases] = build_ast(CST(P++) /* G_if_or_unless */);
       T[++phrases] = build_ast(CST(P++) /* G_XIMP */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_if_unless_XIMP, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <if_or_unless> <XIMP>,
       T[++phrases] = build_ast(CST(P++) /* G_if_or_unless */);
       T[++phrases] = build_ast(CST(P++) /* G_XIMP */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_if_XIMP_opt, alt, phrases, T);

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

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

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

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

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

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

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

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

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

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

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

#endif
     if (alt == 0)               {  //\\    "start",
       T[++phrases] = kw(CST(P++), "start");
     } else if (alt == 1)        {  //\\    <if_or_unless> <EIMP>,
       T[++phrases] = build_ast(CST(P++) /* G_if_or_unless */);
       T[++phrases] = build_ast(CST(P++) /* G_EIMP */);
     } else                      {  //\\    <IMP>;
       T[++phrases] = build_ast(CST(P++) /* G_IMP */);
     }
     return T[0] = G_mktuple(G_start_IMP, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    "start",
       T[++phrases] = kw(CST(P++), "start");
     } else if (alt == 1)        {  //\\    <if_or_unless> <EIMP>,
       T[++phrases] = build_ast(CST(P++) /* G_if_or_unless */);
       T[++phrases] = build_ast(CST(P++) /* G_EIMP */);
     } else                      {  //\\    <IMP>;
       T[++phrases] = build_ast(CST(P++) /* G_IMP */);
     }
     return T[0] = G_mktuple(G_final_IMP, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    "and" <NL_opt> <IMP>,
       T[++phrases] = kw(CST(P++), "and");
       T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_IMP */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_and_IMPS, alt, phrases, T);

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

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

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

#endif
     if (alt == 0)               {  //\\    "while" <COND>,
       T[++phrases] = kw(CST(P++), "while");
       T[++phrases] = build_ast(CST(P++) /* G_COND */);
     } else                      {  //\\    "for" <SEQ>;
       T[++phrases] = kw(CST(P++), "for");
       T[++phrases] = build_ast(CST(P++) /* G_SEQ */);
     }
     return T[0] = G_mktuple(G_wh_for, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    "cycle",
       T[++phrases] = kw(CST(P++), "cycle");
     } else                      {  //\\    "then" <IMP>;
       T[++phrases] = kw(CST(P++), "then");
       T[++phrases] = build_ast(CST(P++) /* G_IMP */);
     }
     return T[0] = G_mktuple(G_cycle_IMP, alt, phrases, T);

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

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

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

#endif
     if (alt == 0)               {  //\\    <if_or_unless> <COND> <T>,
       T[++phrases] = build_ast(CST(P++) /* G_if_or_unless */);
       T[++phrases] = build_ast(CST(P++) /* G_COND */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
     } else if (alt == 1)        {  //\\    "while" <COND> <T>,
       T[++phrases] = kw(CST(P++), "while");
       T[++phrases] = build_ast(CST(P++) /* G_COND */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
     } else if (alt == 2)        {  //\\    "until" <COND> <T>,
       T[++phrases] = kw(CST(P++), "until");
       T[++phrases] = build_ast(CST(P++) /* G_COND */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
     } else if (alt == 3)        {  //\\    "for" <SEQ> <T>,
       T[++phrases] = kw(CST(P++), "for");
       T[++phrases] = build_ast(CST(P++) /* G_SEQ */);
       T[++phrases] = build_ast(CST(P++) /* G_T */);
     } else                      {  //\\    <T>;
       T[++phrases] = build_ast(CST(P++) /* G_T */);
     }
     return T[0] = G_mktuple(G_iu_while_until_for_T, alt, phrases, T);

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

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

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

#endif
     if (alt == 0)               {  //\\    <AddressOffsetOp> <SEXP>,
       T[++phrases] = build_ast(CST(P++) /* G_AddressOffsetOp */);
       T[++phrases] = build_ast(CST(P++) /* G_SEXP */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_ADDOP_SEXP_opt, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <A>,
       T[++phrases] = build_ast(CST(P++) /* G_A */);
     } else if (alt == 1)        {  //\\    <AN>,
       T[++phrases] = build_ast(CST(P++) /* G_AN */);
     } else if (alt == 2)        {  //\\    <NA>,
       T[++phrases] = build_ast(CST(P++) /* G_NA */);
     } else                      {  //\\    <NAN>;
       T[++phrases] = build_ast(CST(P++) /* G_NAN */);
     }
     return T[0] = G_mktuple(G_A_or_AN_or_NA_or_NAN, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <A>,
       T[++phrases] = build_ast(CST(P++) /* G_A */);
     } else                      {  //\\    <AN>;
       T[++phrases] = build_ast(CST(P++) /* G_AN */);
     }
     return T[0] = G_mktuple(G_A_or_AN, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <NA>,
       T[++phrases] = build_ast(CST(P++) /* G_NA */);
     } else                      {  //\\    <NAN>;
       T[++phrases] = build_ast(CST(P++) /* G_NAN */);
     }
     return T[0] = G_mktuple(G_NA_or_NAN, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <IDENT> <rest_of_IDENTS>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_IDENTS */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_IDENTS, alt, phrases, T);

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

#endif
                                    //\\    <IDENT> <rest_of_IDENTS>;
     T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_IDENTS */);
     return T[0] = G_mktuple(G_IDENTS, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <V> <ESC_ARRAY_or_REC>,
       T[++phrases] = build_ast(CST(P++) /* G_V */);
       T[++phrases] = build_ast(CST(P++) /* G_ESC_ARRAY_or_REC */);
     } else if (alt == 1)        {  //\\    <N> <ESC_ARRAY_or_REC>,
       T[++phrases] = build_ast(CST(P++) /* G_N */);
       T[++phrases] = build_ast(CST(P++) /* G_ESC_ARRAY_or_REC */);
     } else if (alt == 2)        {  //\\    <Fn_CALL>,
       T[++phrases] = build_ast(CST(P++) /* G_Fn_CALL */);
     } else if (alt == 3)        {  //\\    <Map_CALL> <ESCREC>,
       T[++phrases] = build_ast(CST(P++) /* G_Map_CALL */);
       T[++phrases] = build_ast(CST(P++) /* G_ESCREC */);
     } else                      {  //\\    <CONST>;
       T[++phrases] = build_ast(CST(P++) /* G_CONST */);
     }
     return T[0] = G_mktuple(G_V_or_N, alt, phrases, T);

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

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

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

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <EXP> <extra>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_EXP */);
       T[++phrases] = build_ast(CST(P++) /* G_extra */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_subevent_and_extra, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    '=' <NL_opt> <EXP>,
       T[++phrases] = ch(CST(P++), '=');
       T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_EXP */);
     } else if (alt == 1)        {  //\\    '<' '-' <NL_opt> <SIGN_opt> <EXP>,
       T[++phrases] = ch(CST(P++), '<');
       T[++phrases] = ch(CST(P++), '-');
       T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_SIGN_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_EXP */);
     } else                      {  //\\    '-' '>' <NL_opt> <RESEXP>;
       T[++phrases] = ch(CST(P++), '-');
       T[++phrases] = ch(CST(P++), '>');
       T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_RESEXP */);
     }
     return T[0] = G_mktuple(G_IMP_ASSIGN, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <ADDOP_SEXP_opt> <IMP_ASSIGN>,
       T[++phrases] = build_ast(CST(P++) /* G_ADDOP_SEXP_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_IMP_ASSIGN */);
     } else                      {  //\\    '=' '=' <NL_opt> <V_or_N> <ADDOP_SEXP_opt>;
       T[++phrases] = ch(CST(P++), '=');
       T[++phrases] = ch(CST(P++), '=');
       T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_V_or_N */);
       T[++phrases] = build_ast(CST(P++) /* G_ADDOP_SEXP_opt */);
     }
     return T[0] = G_mktuple(G_N_ASS, alt, phrases, T);

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

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

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

#endif
                                    //\\    "and" <NL_opt> <SCOND> <rest_of_AND_COND>;
     T[++phrases] = kw(CST(P++), "and");
     T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_SCOND */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_AND_COND */);
     return T[0] = G_mktuple(G_AND_COND, alt, phrases, T);

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

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

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

#endif
                                    //\\    "or" <NL_opt> <SCOND> <rest_of_OR_COND>;
     T[++phrases] = kw(CST(P++), "or");
     T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_SCOND */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_OR_COND */);
     return T[0] = G_mktuple(G_OR_COND, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <AND_COND>,
       T[++phrases] = build_ast(CST(P++) /* G_AND_COND */);
     } else if (alt == 1)        {  //\\    <OR_COND>,
       T[++phrases] = build_ast(CST(P++) /* G_OR_COND */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_COND, alt, phrases, T);

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

#endif
                                    //\\    <SCOND> <rest_of_COND>;
     T[++phrases] = build_ast(CST(P++) /* G_SCOND */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_COND */);
     return T[0] = G_mktuple(G_COND, alt, phrases, T);

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

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

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

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

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

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

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

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

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

#endif
                                    //\\    <OP0> <SEXP>;
     T[++phrases] = build_ast(CST(P++) /* G_OP0 */);
     T[++phrases] = build_ast(CST(P++) /* G_SEXP */);
     return T[0] = G_mktuple(G_OP0_EXP, alt, phrases, T);

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

#endif
                                    //\\    <OP1> <EXP0>;
     T[++phrases] = build_ast(CST(P++) /* G_OP1 */);
     T[++phrases] = build_ast(CST(P++) /* G_EXP0 */);
     return T[0] = G_mktuple(G_OP1_EXP, alt, phrases, T);

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

#endif
                                    //\\    <OP2> <EXP1>;
     T[++phrases] = build_ast(CST(P++) /* G_OP2 */);
     T[++phrases] = build_ast(CST(P++) /* G_EXP1 */);
     return T[0] = G_mktuple(G_OP2_EXP, alt, phrases, T);

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

#endif
                                    //\\    <OP3> <EXP2>;
     T[++phrases] = build_ast(CST(P++) /* G_OP3 */);
     T[++phrases] = build_ast(CST(P++) /* G_EXP2 */);
     return T[0] = G_mktuple(G_OP3_EXP, alt, phrases, T);

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

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

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

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

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

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

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

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

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

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

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

#endif
                                    //\\    <COMP> <EXP>;
     T[++phrases] = build_ast(CST(P++) /* G_COMP */);
     T[++phrases] = build_ast(CST(P++) /* G_EXP */);
     return T[0] = G_mktuple(G_COMP2, alt, phrases, T);

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

#endif
                                    //\\    <COMP> <EXP>;
     T[++phrases] = build_ast(CST(P++) /* G_COMP */);
     T[++phrases] = build_ast(CST(P++) /* G_EXP */);
     return T[0] = G_mktuple(G_COMP1, alt, phrases, T);

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

#endif
                                    //\\    <COMP1> <COMP2_opt>;
     T[++phrases] = build_ast(CST(P++) /* G_COMP1 */);
     T[++phrases] = build_ast(CST(P++) /* G_COMP2_opt */);
     return T[0] = G_mktuple(G_COMP12_opt, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <COMP1> <COMP2_opt>,
       T[++phrases] = build_ast(CST(P++) /* G_COMP1 */);
       T[++phrases] = build_ast(CST(P++) /* G_COMP2_opt */);
     } else if (alt == 1)        {  //\\    <ACOMP> <V_or_N>,
       T[++phrases] = build_ast(CST(P++) /* G_ACOMP */);
       T[++phrases] = build_ast(CST(P++) /* G_V_or_N */);
     } else if (alt == 2)        {  //\\    <ACOMP> '0' <?ZERO>,
       T[++phrases] = build_ast(CST(P++) /* G_ACOMP */);
       T[++phrases] = ch(CST(P++), '0');
       T[++phrases] = -1 +(0 * P++) /* S_ZERO */ /* semantic call - temp for now. Could theoretically return a string like a terminal. Parser needs to insert something in CST. */;
     } else if (alt == 3)        {  //\\    '-' '>' <RESEXP>,
       T[++phrases] = ch(CST(P++), '-');
       T[++phrases] = ch(CST(P++), '>');
       T[++phrases] = build_ast(CST(P++) /* G_RESEXP */);
     } else                      {  //\\    <OP0_EXPS> <OP1_EXPS> <OP2_EXPS> <OP3_EXPS> <COMP12_opt>;
       T[++phrases] = build_ast(CST(P++) /* G_OP0_EXPS */);
       T[++phrases] = build_ast(CST(P++) /* G_OP1_EXPS */);
       T[++phrases] = build_ast(CST(P++) /* G_OP2_EXPS */);
       T[++phrases] = build_ast(CST(P++) /* G_OP3_EXPS */);
       T[++phrases] = build_ast(CST(P++) /* G_COMP12_opt */);
     }
     return T[0] = G_mktuple(G_COMPARISON, alt, phrases, T);

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

#endif
                                    //\\    <COMP> <EXP> <COMP2_opt>;
     T[++phrases] = build_ast(CST(P++) /* G_COMP */);
     T[++phrases] = build_ast(CST(P++) /* G_EXP */);
     T[++phrases] = build_ast(CST(P++) /* G_COMP2_opt */);
     return T[0] = G_mktuple(G_COMP1OS2, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <V_or_N> <COMPARISON>,
       T[++phrases] = build_ast(CST(P++) /* G_V_or_N */);
       T[++phrases] = build_ast(CST(P++) /* G_COMPARISON */);
     } else if (alt == 1)        {  //\\    '(' <COND> ')',
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_COND */);
       T[++phrases] = ch(CST(P++), ')');
     } else if (alt == 2)        {  //\\    "not" <SCOND>,
       T[++phrases] = kw(CST(P++), "not");
       T[++phrases] = build_ast(CST(P++) /* G_SCOND */);
     } else if (alt == 3)        {  //\\    <Pred_CALL>,
       T[++phrases] = build_ast(CST(P++) /* G_Pred_CALL */);
     } else if (alt == 4)        {  //\\    '(' <EXP> ')' <OP0_EXPS> <OP1_EXPS> <OP2_EXPS> <OP3_EXPS> <COMP1OS2>,
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_EXP */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = build_ast(CST(P++) /* G_OP0_EXPS */);
       T[++phrases] = build_ast(CST(P++) /* G_OP1_EXPS */);
       T[++phrases] = build_ast(CST(P++) /* G_OP2_EXPS */);
       T[++phrases] = build_ast(CST(P++) /* G_OP3_EXPS */);
       T[++phrases] = build_ast(CST(P++) /* G_COMP1OS2 */);
     } else if (alt == 5)        {  //\\    <A_or_AN_or_NA_or_NAN> <ACOMP> <A_or_AN_or_NA_or_NAN>,
       T[++phrases] = build_ast(CST(P++) /* G_A_or_AN_or_NA_or_NAN */);
       T[++phrases] = build_ast(CST(P++) /* G_ACOMP */);
       T[++phrases] = build_ast(CST(P++) /* G_A_or_AN_or_NA_or_NAN */);
     } else if (alt == 6)        {  //\\    <A_or_AN_or_NA_or_NAN> <ACOMP> '0' <?ZERO>,
       T[++phrases] = build_ast(CST(P++) /* G_A_or_AN_or_NA_or_NAN */);
       T[++phrases] = build_ast(CST(P++) /* G_ACOMP */);
       T[++phrases] = ch(CST(P++), '0');
       T[++phrases] = -1 +(0 * P++) /* S_ZERO */ /* semantic call - temp for now. Could theoretically return a string like a terminal. Parser needs to insert something in CST. */;
     } else                      {  //\\    <EXP> <COMP12_opt>;
       T[++phrases] = build_ast(CST(P++) /* G_EXP */);
       T[++phrases] = build_ast(CST(P++) /* G_COMP12_opt */);
     }
     return T[0] = G_mktuple(G_SCOND, alt, phrases, T);

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

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

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

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

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

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

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

#endif
     if (alt == 0)               {  //\\    <V_or_N> <OP0_EXPS> <OP1_EXPS> <OP2_EXPS> <OP3_EXPS>,
       T[++phrases] = build_ast(CST(P++) /* G_V_or_N */);
       T[++phrases] = build_ast(CST(P++) /* G_OP0_EXPS */);
       T[++phrases] = build_ast(CST(P++) /* G_OP1_EXPS */);
       T[++phrases] = build_ast(CST(P++) /* G_OP2_EXPS */);
       T[++phrases] = build_ast(CST(P++) /* G_OP3_EXPS */);
     } else if (alt == 1)        {  //\\    <UOP_opt> <SEXP> <OP0_EXPS> <OP1_EXPS> <OP2_EXPS> <OP3_EXPS>,
       T[++phrases] = build_ast(CST(P++) /* G_UOP_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_SEXP */);
       T[++phrases] = build_ast(CST(P++) /* G_OP0_EXPS */);
       T[++phrases] = build_ast(CST(P++) /* G_OP1_EXPS */);
       T[++phrases] = build_ast(CST(P++) /* G_OP2_EXPS */);
       T[++phrases] = build_ast(CST(P++) /* G_OP3_EXPS */);
     } else                      {  //\\    <SIGN_opt> <EXP2> <OP3_EXPS>;
       T[++phrases] = build_ast(CST(P++) /* G_SIGN_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_EXP2 */);
       T[++phrases] = build_ast(CST(P++) /* G_OP3_EXPS */);
     }
     return T[0] = G_mktuple(G_EXP, alt, phrases, T);

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

#endif
                                    //\\    <SEXP> <OP0_EXPS> <OP1_EXPS> <OP2_EXPS>;
     T[++phrases] = build_ast(CST(P++) /* G_SEXP */);
     T[++phrases] = build_ast(CST(P++) /* G_OP0_EXPS */);
     T[++phrases] = build_ast(CST(P++) /* G_OP1_EXPS */);
     T[++phrases] = build_ast(CST(P++) /* G_OP2_EXPS */);
     return T[0] = G_mktuple(G_EXP2, alt, phrases, T);

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

#endif
                                    //\\    <SEXP> <OP0_EXPS> <OP1_EXPS>;
     T[++phrases] = build_ast(CST(P++) /* G_SEXP */);
     T[++phrases] = build_ast(CST(P++) /* G_OP0_EXPS */);
     T[++phrases] = build_ast(CST(P++) /* G_OP1_EXPS */);
     return T[0] = G_mktuple(G_EXP1, alt, phrases, T);

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

#endif
                                    //\\    <SEXP> <OP0_EXPS>;
     T[++phrases] = build_ast(CST(P++) /* G_SEXP */);
     T[++phrases] = build_ast(CST(P++) /* G_OP0_EXPS */);
     return T[0] = G_mktuple(G_EXP0, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <V_or_N>,
       T[++phrases] = build_ast(CST(P++) /* G_V_or_N */);
     } else if (alt == 1)        {  //\\    '(' <EXP> ')',
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_EXP */);
       T[++phrases] = ch(CST(P++), ')');
     } else if (alt == 2)        {  //\\    '|' <EXP> '|',
       T[++phrases] = ch(CST(P++), '|');
       T[++phrases] = build_ast(CST(P++) /* G_EXP */);
       T[++phrases] = ch(CST(P++), '|');
     } else                      {  //\\    <IEXP>;
       T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
     }
     return T[0] = G_mktuple(G_SEXP, alt, phrases, T);

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

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

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

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

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

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

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

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

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

#endif
     if (alt == 0)               {  //\\    <COP3> <IEXP2> <rest_of_IEXP2_EXPR>,
       T[++phrases] = build_ast(CST(P++) /* G_COP3 */);
       T[++phrases] = build_ast(CST(P++) /* G_IEXP2 */);
       T[++phrases] = build_ast(CST(P++) /* G_rest_of_IEXP2_EXPR */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_rest_of_IEXP2_EXPR, alt, phrases, T);

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

#endif
                                    //\\    <IEXP2> <rest_of_IEXP2_EXPR>;
     T[++phrases] = build_ast(CST(P++) /* G_IEXP2 */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_IEXP2_EXPR */);
     return T[0] = G_mktuple(G_IEXP2_EXPR, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <COP3> <IEXP2> <COP3_IEXP2_optseq>,
       T[++phrases] = build_ast(CST(P++) /* G_COP3 */);
       T[++phrases] = build_ast(CST(P++) /* G_IEXP2 */);
       T[++phrases] = build_ast(CST(P++) /* G_COP3_IEXP2_optseq */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_COP3_IEXP2_optseq, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <COP2> <IEXP1> <COP2_IEXP1_optseq>,
       T[++phrases] = build_ast(CST(P++) /* G_COP2 */);
       T[++phrases] = build_ast(CST(P++) /* G_IEXP1 */);
       T[++phrases] = build_ast(CST(P++) /* G_COP2_IEXP1_optseq */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_COP2_IEXP1_optseq, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <COP1> <IEXP0> <COP1_IEXP0_optseq>,
       T[++phrases] = build_ast(CST(P++) /* G_COP1 */);
       T[++phrases] = build_ast(CST(P++) /* G_IEXP0 */);
       T[++phrases] = build_ast(CST(P++) /* G_COP1_IEXP0_optseq */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_COP1_IEXP0_optseq, alt, phrases, T);

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

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

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

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

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

#endif
                                    //\\    <IEXP0> <COP1_IEXP0_optseq> <COP2_IEXP1_optseq>;
     T[++phrases] = build_ast(CST(P++) /* G_IEXP0 */);
     T[++phrases] = build_ast(CST(P++) /* G_COP1_IEXP0_optseq */);
     T[++phrases] = build_ast(CST(P++) /* G_COP2_IEXP1_optseq */);
     return T[0] = G_mktuple(G_IEXP2, alt, phrases, T);

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

#endif
                                    //\\    <IEXP0> <COP1_IEXP0_optseq>;
     T[++phrases] = build_ast(CST(P++) /* G_IEXP0 */);
     T[++phrases] = build_ast(CST(P++) /* G_COP1_IEXP0_optseq */);
     return T[0] = G_mktuple(G_IEXP1, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <PCONST>,
       T[++phrases] = build_ast(CST(P++) /* G_PCONST */);
     } else if (alt == 1)        {  //\\    '(' <IEXP> ')',
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
       T[++phrases] = ch(CST(P++), ')');
     } else                      {  //\\    '|' <IEXP> '|';
       T[++phrases] = ch(CST(P++), '|');
       T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
       T[++phrases] = ch(CST(P++), '|');
     }
     return T[0] = G_mktuple(G_IEXP0, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <CUOP_opt> <IEXP0> <COP1_IEXP0_optseq> <COP2_IEXP1_optseq> <COP3_IEXP2_optseq>,
       T[++phrases] = build_ast(CST(P++) /* G_CUOP_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_IEXP0 */);
       T[++phrases] = build_ast(CST(P++) /* G_COP1_IEXP0_optseq */);
       T[++phrases] = build_ast(CST(P++) /* G_COP2_IEXP1_optseq */);
       T[++phrases] = build_ast(CST(P++) /* G_COP3_IEXP2_optseq */);
     } else                      {  //\\    <CSIGN> <IEXP2_EXPR>;
       T[++phrases] = build_ast(CST(P++) /* G_CSIGN */);
       T[++phrases] = build_ast(CST(P++) /* G_IEXP2_EXPR */);
     }
     return T[0] = G_mktuple(G_IEXP, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <CONST>,
       T[++phrases] = build_ast(CST(P++) /* G_CONST */);
     } else                      {  //\\    <V>;
       T[++phrases] = build_ast(CST(P++) /* G_V */);
     }
     return T[0] = G_mktuple(G_PCONST, alt, phrases, T);

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

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

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

#endif
                                    //\\    <?dq> <CONST>;
     T[++phrases] = -build_ast(CST(P++) /* G_dq */);
     T[++phrases] = build_ast(CST(P++) /* G_CONST */);
     return T[0] = G_mktuple(G_ACONST, alt, phrases, T);

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

#endif
                                    //\\    <?dq> <CONST>;
     T[++phrases] = -build_ast(CST(P++) /* G_dq */);
     T[++phrases] = build_ast(CST(P++) /* G_CONST */);
     return T[0] = G_mktuple(G_OCONST, alt, phrases, T);

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

#endif
                                    //\\    <V_or_N> '=' <NL_opt> <EXP> ',' <EXP> ',' <EXP>;
     T[++phrases] = build_ast(CST(P++) /* G_V_or_N */);
     T[++phrases] = ch(CST(P++), '=');
     T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_EXP */);
     T[++phrases] = ch(CST(P++), ',');
     T[++phrases] = build_ast(CST(P++) /* G_EXP */);
     T[++phrases] = ch(CST(P++), ',');
     T[++phrases] = build_ast(CST(P++) /* G_EXP */);
     return T[0] = G_mktuple(G_SEQ, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <simple_type> "name" <IDENTS>,
       T[++phrases] = build_ast(CST(P++) /* G_simple_type */);
       T[++phrases] = kw(CST(P++), "name");
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     } else if (alt == 1)        {  //\\    <simple_type> "array" "name" <IDENTS>,
       T[++phrases] = build_ast(CST(P++) /* G_simple_type */);
       T[++phrases] = kw(CST(P++), "array");
       T[++phrases] = kw(CST(P++), "name");
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     } else if (alt == 2)        {  //\\    <simple_type> "array" <IDENTS> <RCONST_BOUNDS>,
       T[++phrases] = build_ast(CST(P++) /* G_simple_type */);
       T[++phrases] = kw(CST(P++), "array");
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
       T[++phrases] = build_ast(CST(P++) /* G_RCONST_BOUNDS */);
     } else if (alt == 3)        {  //\\    <simple_type> "name" "array" "name" <IDENTS>,
       T[++phrases] = build_ast(CST(P++) /* G_simple_type */);
       T[++phrases] = kw(CST(P++), "name");
       T[++phrases] = kw(CST(P++), "array");
       T[++phrases] = kw(CST(P++), "name");
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     } else if (alt == 4)        {  //\\    <simple_type> <IDENTS>,
       T[++phrases] = build_ast(CST(P++) /* G_simple_type */);
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     } else if (alt == 5)        {  //\\    "string" '(' <Star_or_IEXP> ')' "name" <IDENTS>,
       T[++phrases] = kw(CST(P++), "string");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_Star_or_IEXP */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = kw(CST(P++), "name");
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     } else if (alt == 6)        {  //\\    "string" '(' <Star_or_IEXP> ')' "array" "name" <IDENTS>,
       T[++phrases] = kw(CST(P++), "string");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_Star_or_IEXP */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = kw(CST(P++), "array");
       T[++phrases] = kw(CST(P++), "name");
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     } else if (alt == 7)        {  //\\    "string" '(' <IEXP> ')' "array" <IDENTS> <RCONST_BOUNDS>,
       T[++phrases] = kw(CST(P++), "string");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = kw(CST(P++), "array");
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
       T[++phrases] = build_ast(CST(P++) /* G_RCONST_BOUNDS */);
     } else if (alt == 8)        {  //\\    "string" '(' <Star_or_IEXP> ')' "name" "array" "name" <IDENTS>,
       T[++phrases] = kw(CST(P++), "string");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_Star_or_IEXP */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = kw(CST(P++), "name");
       T[++phrases] = kw(CST(P++), "array");
       T[++phrases] = kw(CST(P++), "name");
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     } else if (alt == 9)        {  //\\    "string" '(' <Star_or_IEXP> ')' "name" "array" <IDENTS> <RCONST_BOUNDS>,
       T[++phrases] = kw(CST(P++), "string");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_Star_or_IEXP */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = kw(CST(P++), "name");
       T[++phrases] = kw(CST(P++), "array");
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
       T[++phrases] = build_ast(CST(P++) /* G_RCONST_BOUNDS */);
     } else if (alt == 10)        {  //\\    "string" '(' <IEXP> ')' <IDENTS>,
       T[++phrases] = kw(CST(P++), "string");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     } else if (alt == 11)        {  //\\    "record" '(' <FM_or_Star> ')' "name" "array" "name" <IDENTS>,
       T[++phrases] = kw(CST(P++), "record");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_FM_or_Star */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = kw(CST(P++), "name");
       T[++phrases] = kw(CST(P++), "array");
       T[++phrases] = kw(CST(P++), "name");
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     } else if (alt == 12)        {  //\\    "record" '(' <FM_or_Star> ')' "name" "array" <IDENTS> <RCONST_BOUNDS>,
       T[++phrases] = kw(CST(P++), "record");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_FM_or_Star */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = kw(CST(P++), "name");
       T[++phrases] = kw(CST(P++), "array");
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
       T[++phrases] = build_ast(CST(P++) /* G_RCONST_BOUNDS */);
     } else if (alt == 13)        {  //\\    "record" '(' <FM_or_Star> ')' "name" <IDENTS>,
       T[++phrases] = kw(CST(P++), "record");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_FM_or_Star */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = kw(CST(P++), "name");
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     } else if (alt == 14)        {  //\\    "record" '(' <IDENT> ')' "array" <IDENTS> <RCONST_BOUNDS>,
       T[++phrases] = kw(CST(P++), "record");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = kw(CST(P++), "array");
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
       T[++phrases] = build_ast(CST(P++) /* G_RCONST_BOUNDS */);
     } else if (alt == 15)        {  //\\    "record" '(' <IDENT> ')' <IDENTS>,
       T[++phrases] = kw(CST(P++), "record");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
       T[++phrases] = ch(CST(P++), ')');
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
     } else                      {  //\\    '(' <record_field_declarations> <OR_record_field_declarations> ')';
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_record_field_declarations */);
       T[++phrases] = build_ast(CST(P++) /* G_OR_record_field_declarations */);
       T[++phrases] = ch(CST(P++), ')');
     }
     return T[0] = G_mktuple(G_record_field_decl, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    "or" <record_field_declarations> <OR_record_field_declarations>,
       T[++phrases] = kw(CST(P++), "or");
       T[++phrases] = build_ast(CST(P++) /* G_record_field_declarations */);
       T[++phrases] = build_ast(CST(P++) /* G_OR_record_field_declarations */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_OR_record_field_declarations, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <record_field_decl> <more_record_field_decls>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_record_field_decl */);
       T[++phrases] = build_ast(CST(P++) /* G_more_record_field_decls */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_more_record_field_decls, alt, phrases, T);

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

#endif
                                    //\\    <NL_opt> <record_field_decl> <more_record_field_decls>;
     T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
     T[++phrases] = build_ast(CST(P++) /* G_record_field_decl */);
     T[++phrases] = build_ast(CST(P++) /* G_more_record_field_decls */);
     return T[0] = G_mktuple(G_record_field_declarations, alt, phrases, T);

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

#endif
                                    //\\    '(' <IEXP> ':' <IEXP> ')';
     T[++phrases] = ch(CST(P++), '(');
     T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
     T[++phrases] = ch(CST(P++), ':');
     T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
     T[++phrases] = ch(CST(P++), ')');
     return T[0] = G_mktuple(G_CONST_BOUNDS, alt, phrases, T);

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

#endif
                                    //\\    '(' <IEXP> ':' <IEXP> ')';
     T[++phrases] = ch(CST(P++), '(');
     T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
     T[++phrases] = ch(CST(P++), ':');
     T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
     T[++phrases] = ch(CST(P++), ')');
     return T[0] = G_mktuple(G_RCONST_BOUNDS, alt, phrases, T);

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

#endif
                                    //\\    <EXP> ':' <EXP>;
     T[++phrases] = build_ast(CST(P++) /* G_EXP */);
     T[++phrases] = ch(CST(P++), ':');
     T[++phrases] = build_ast(CST(P++) /* G_EXP */);
     return T[0] = G_mktuple(G_BOUNDS_PAIR, alt, phrases, T);

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

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

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

#endif
                                    //\\    <BOUNDS_PAIR> <rest_of_BPL_LIST>;
     T[++phrases] = build_ast(CST(P++) /* G_BOUNDS_PAIR */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_BPL_LIST */);
     return T[0] = G_mktuple(G_BPL_LIST, alt, phrases, T);

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

#endif
                                    //\\    '(' <BPL_LIST> ')';
     T[++phrases] = ch(CST(P++), '(');
     T[++phrases] = build_ast(CST(P++) /* G_BPL_LIST */);
     T[++phrases] = ch(CST(P++), ')');
     return T[0] = G_mktuple(G_BPL, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <simple_type>,
       T[++phrases] = build_ast(CST(P++) /* G_simple_type */);
     } else if (alt == 1)        {  //\\    "string" '(' <Star_or_IEXP> ')',
       T[++phrases] = kw(CST(P++), "string");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_Star_or_IEXP */);
       T[++phrases] = ch(CST(P++), ')');
     } else                      {  //\\    "record" '(' <FM_or_Star> ')';
       T[++phrases] = kw(CST(P++), "record");
       T[++phrases] = ch(CST(P++), '(');
       T[++phrases] = build_ast(CST(P++) /* G_FM_or_Star */);
       T[++phrases] = ch(CST(P++), ')');
     }
     return T[0] = G_mktuple(G_parameter_type, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <parameter_type> "name" <ARRAYNAME>,
       T[++phrases] = build_ast(CST(P++) /* G_parameter_type */);
       T[++phrases] = kw(CST(P++), "name");
       T[++phrases] = build_ast(CST(P++) /* G_ARRAYNAME */);
     } else if (alt == 1)        {  //\\    <parameter_type> "name",
       T[++phrases] = build_ast(CST(P++) /* G_parameter_type */);
       T[++phrases] = kw(CST(P++), "name");
     } else if (alt == 2)        {  //\\    <parameter_type> <ARRAYNAME>,
       T[++phrases] = build_ast(CST(P++) /* G_parameter_type */);
       T[++phrases] = build_ast(CST(P++) /* G_ARRAYNAME */);
     } else                      {  //\\    <parameter_type>;
       T[++phrases] = build_ast(CST(P++) /* G_parameter_type */);
     }
     return T[0] = G_mktuple(G_parameter_type_decl, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    <parameter_type_decl> <IDENTS> <another_FPP0>,
       T[++phrases] = build_ast(CST(P++) /* G_parameter_type_decl */);
       T[++phrases] = build_ast(CST(P++) /* G_IDENTS */);
       T[++phrases] = build_ast(CST(P++) /* G_another_FPP0 */);
     } else                      {  //\\    <Rt_Fn_Map_Pred_DECL> <IDENT> <Rt_Pred_FPP>;
       T[++phrases] = build_ast(CST(P++) /* G_Rt_Fn_Map_Pred_DECL */);
       T[++phrases] = build_ast(CST(P++) /* G_IDENT */);
       T[++phrases] = build_ast(CST(P++) /* G_Rt_Pred_FPP */);
     }
     return T[0] = G_mktuple(G_VDEC_or_PROC, alt, phrases, T);

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

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <VDEC_or_PROC> <More_FPPs>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_VDEC_or_PROC */);
       T[++phrases] = build_ast(CST(P++) /* G_More_FPPs */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_More_FPPs, alt, phrases, T);

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

#endif
                                    //\\    <VDEC_or_PROC> <More_FPPs>;
     T[++phrases] = build_ast(CST(P++) /* G_VDEC_or_PROC */);
     T[++phrases] = build_ast(CST(P++) /* G_More_FPPs */);
     return T[0] = G_mktuple(G_FPP, alt, phrases, T);

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

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

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

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

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

#endif
     if (alt == 0)               {  //\\    ',' <NL_opt> <EXP> <MORE_APPS>,
       T[++phrases] = ch(CST(P++), ',');
       T[++phrases] = build_ast(CST(P++) /* G_NL_opt */);
       T[++phrases] = build_ast(CST(P++) /* G_EXP */);
       T[++phrases] = build_ast(CST(P++) /* G_MORE_APPS */);
     } else                      {  //\\    ;
     }
     return T[0] = G_mktuple(G_MORE_APPS, alt, phrases, T);

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

#endif
                                    //\\    <EXP> <MORE_APPS>;
     T[++phrases] = build_ast(CST(P++) /* G_EXP */);
     T[++phrases] = build_ast(CST(P++) /* G_MORE_APPS */);
     return T[0] = G_mktuple(G_APP, alt, phrases, T);

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

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

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

#endif
                                    //\\    <IEXP> <rest_of_IEXP>;
     T[++phrases] = build_ast(CST(P++) /* G_IEXP */);
     T[++phrases] = build_ast(CST(P++) /* G_rest_of_IEXP */);
     return T[0] = G_mktuple(G_const_event_list, alt, phrases, T);

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

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

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

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

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

#endif
                                    //\\    <RESLEFT_opt> '(' <EXP> ')' <RESRIGHT_opt>;
     T[++phrases] = build_ast(CST(P++) /* G_RESLEFT_opt */);
     T[++phrases] = ch(CST(P++), '(');
     T[++phrases] = build_ast(CST(P++) /* G_EXP */);
     T[++phrases] = ch(CST(P++), ')');
     T[++phrases] = build_ast(CST(P++) /* G_RESRIGHT_opt */);
     return T[0] = G_mktuple(G_RESEXP, alt, phrases, T);

//\\ E