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

#define X_APP 1
#include <stdio.h>

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

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

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

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

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

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

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

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

//\\ B<EOF> = 0;
//\\#
//\\ B<nl> = 2;
//\\#
//\\ P<SS> =
   case P_SS:
#ifdef IN_PARSER

#endif
     {                              //\\    <init> <optional-stropping-conversion> <SOURCE> <terminate>;
     t[1] = -1; /* semantic procedure init */;
     t[2] = compile(P(2), depth+1 /* P_optional_stropping_conversion */);
     t[3] = compile(P(3), depth+1 /* P_SOURCE */);
     t[4] = -1; /* semantic procedure terminate */;
     return t[0] = P_mktuple(P_SS, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<SOURCE> =
   case P_SOURCE:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <MAIN-PROGRAM> <semi_opt> <EOF>,
       t[1] = compile(P(1), depth+1 /* P_MAIN_PROGRAM */);
       t[2] = compile(P(2), depth+1 /* P_semi_opt */);
       t[3] = wlit(P(3) /*, L"EOF" */);
       return t[0] = P_mktuple(P_SOURCE, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <EXTERNAL-LEVEL-OBJECTS> <EOF>;
       t[1] = compile(P(1), depth+1 /* P_EXTERNAL_LEVEL_OBJECTS */);
       t[2] = wlit(P(2) /*, L"EOF" */);
       return t[0] = P_mktuple(P_SOURCE, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<semi_opt> =
   case P_semi_opt:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<MAIN-PROGRAM> =
   case P_MAIN_PROGRAM:
#ifdef IN_PARSER

#endif
     {                              //\\    <PROGRAM_opt> <COMMENTS_opt> "b̲e̲g̲i̲n̲" <LOCAL-BLOCK> "e̲n̲d̲" <ENDTEXT>;
     t[1] = compile(P(1), depth+1 /* P_PROGRAM_opt */);
     t[2] = compile(P(2), depth+1 /* P_COMMENTS_opt */);
     t[3] = wlit(P(3));
     t[4] = compile(P(4), depth+1 /* P_LOCAL_BLOCK */);
     t[5] = wlit(P(5));
     t[6] = compile(P(6), depth+1 /* P_ENDTEXT */);
     return t[0] = P_mktuple(P_MAIN_PROGRAM, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<PROGRAM_opt> =
   case P_PROGRAM_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "p̲r̲o̲g̲r̲a̲m̲" <NAME> ';',
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_NAME */);
       t[3] = wlit(P(3) /*, L';' */);
       return t[0] = P_mktuple(P_PROGRAM_opt, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<EXTERNAL-LEVEL-OBJECTS> =
   case P_EXTERNAL_LEVEL_OBJECTS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <EXTERNAL-LEVEL> <EXTERNAL-LEVEL-OBJECTS>,
       t[1] = compile(P(1), depth+1 /* P_EXTERNAL_LEVEL */);
       t[2] = compile(P(2), depth+1 /* P_EXTERNAL_LEVEL_OBJECTS */);
       return t[0] = P_mktuple(P_EXTERNAL_LEVEL_OBJECTS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<EXTERNAL-LEVEL> =
   case P_EXTERNAL_LEVEL:
#ifdef IN_PARSER

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

     } else if (alt == 1)        {  //\\    "c̲o̲d̲e̲" <DIGITS> ';',
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_DIGITS */);
       t[3] = wlit(P(3) /*, L';' */);
       return t[0] = P_mktuple(P_EXTERNAL_LEVEL, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

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

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

     } else                      {  //\\    <OWN-DECLARATION> ';';
       t[1] = compile(P(1), depth+1 /* P_OWN_DECLARATION */);
       t[2] = wlit(P(2) /*, L';' */);
       return t[0] = P_mktuple(P_EXTERNAL_LEVEL, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<PROCTYPE_opt> =
   case P_PROCTYPE_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "i̲n̲t̲e̲g̲e̲r̲",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_PROCTYPE_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "r̲e̲a̲l̲",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_PROCTYPE_opt, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

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

     } else                      {  //\\    ;

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

     }
//\\ P<BOOLEAN> =
   case P_BOOLEAN:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "B̲o̲o̲l̲e̲a̲n̲",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_BOOLEAN, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "b̲o̲o̲l̲e̲a̲n̲";
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_BOOLEAN, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<PROCEDURE> =
   case P_PROCEDURE:
#ifdef IN_PARSER

#endif
     {                              //\\    <PROCTYPE_opt> "p̲r̲o̲c̲e̲d̲u̲r̲e̲" <NAME> <FORMAL_PARAMS_opt> ';' <COMMENTS_opt> <VALUE_opt> <PARAMETER-TYPES_opt> <LABELS_opt> <PROCBODY>;
     t[1] = compile(P(1), depth+1 /* P_PROCTYPE_opt */);
     t[2] = wlit(P(2));
     t[3] = compile(P(3), depth+1 /* P_NAME */);
     t[4] = compile(P(4), depth+1 /* P_FORMAL_PARAMS_opt */);
     t[5] = wlit(P(5) /*, L';' */);
     t[6] = compile(P(6), depth+1 /* P_COMMENTS_opt */);
     t[7] = compile(P(7), depth+1 /* P_VALUE_opt */);
     t[8] = compile(P(8), depth+1 /* P_PARAMETER_TYPES_opt */);
     t[9] = compile(P(9), depth+1 /* P_LABELS_opt */);
     t[10] = compile(P(10), depth+1 /* P_PROCBODY */);
     return t[0] = P_mktuple(P_PROCEDURE, alt, 10/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<FORMAL_PARAMS_opt> =
   case P_FORMAL_PARAMS_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "(" <NAME> <MORE-FP-LIST> ")",
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_NAME */);
       t[3] = compile(P(3), depth+1 /* P_MORE_FP_LIST */);
       t[4] = wlit(P(4));
       return t[0] = P_mktuple(P_FORMAL_PARAMS_opt, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<MORE-FP-LIST> =
   case P_MORE_FP_LIST:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <FPSEP> <FORMAL-PARAMETER> <MORE-FP-LIST>,
       t[1] = compile(P(1), depth+1 /* P_FPSEP */);
       t[2] = compile(P(2), depth+1 /* P_FORMAL_PARAMETER */);
       t[3] = compile(P(3), depth+1 /* P_MORE_FP_LIST */);
       return t[0] = P_mktuple(P_MORE_FP_LIST, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<FORMAL-PARAMETER> =
   case P_FORMAL_PARAMETER:
#ifdef IN_PARSER

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

     }
//\\ P<VALUE_opt> =
   case P_VALUE_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "v̲a̲l̲u̲e̲" <VALUE-NAMELIST> ';',
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_VALUE_NAMELIST */);
       t[3] = wlit(P(3) /*, L';' */);
       return t[0] = P_mktuple(P_VALUE_opt, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<VALUE-NAMELIST> =
   case P_VALUE_NAMELIST:
#ifdef IN_PARSER

#endif
     {                              //\\    <VALUE-NAME> <MORE-VALUE-NAMELIST>;
     t[1] = compile(P(1), depth+1 /* P_VALUE_NAME */);
     t[2] = compile(P(2), depth+1 /* P_MORE_VALUE_NAMELIST */);
     return t[0] = P_mktuple(P_VALUE_NAMELIST, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<MORE-VALUE-NAMELIST> =
   case P_MORE_VALUE_NAMELIST:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<VALUE-NAME> =
   case P_VALUE_NAME:
#ifdef IN_PARSER

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

     }
//\\ P<COMMENT-NO-SEMI> =
   case P_COMMENT_NO_SEMI:
#ifdef IN_PARSER

#endif
     {                              //\\    "c̲o̲m̲m̲e̲n̲t̲" <COMMENTTEXT>;
     t[1] = wlit(P(1));
     t[2] = compile(P(2), depth+1 /* P_COMMENTTEXT */);
     return t[0] = P_mktuple(P_COMMENT_NO_SEMI, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

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

#endif
     {                              //\\    <COMMENT-NO-SEMI> ';';
     t[1] = compile(P(1), depth+1 /* P_COMMENT_NO_SEMI */);
     t[2] = wlit(P(2) /*, L';' */);
     return t[0] = P_mktuple(P_COMMENT, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<COMMENTS_opt> =
   case P_COMMENTS_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <COMMENT> <MORE-COMMENTS>,
       t[1] = compile(P(1), depth+1 /* P_COMMENT */);
       t[2] = compile(P(2), depth+1 /* P_MORE_COMMENTS */);
       return t[0] = P_mktuple(P_COMMENTS_opt, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<MORE-COMMENTS> =
   case P_MORE_COMMENTS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ';' <COMMENT> <MORE-COMMENTS>,
       t[1] = wlit(P(1) /*, L';' */);
       t[2] = compile(P(2), depth+1 /* P_COMMENT */);
       t[3] = compile(P(3), depth+1 /* P_MORE_COMMENTS */);
       return t[0] = P_mktuple(P_MORE_COMMENTS, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<COMMENTTEXT> =
   case P_COMMENTTEXT:
#ifdef IN_PARSER

#endif
     {                              //\\    <NONSEMITEXT> <OPT-MORELINES>;
     t[1] = compile(P(1), depth+1 /* P_NONSEMITEXT */);
     t[2] = compile(P(2), depth+1 /* P_OPT_MORELINES */);
     return t[0] = P_mktuple(P_COMMENTTEXT, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<NONSEMITEXT> =
   case P_NONSEMITEXT:
#ifdef IN_PARSER

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

     }
//\\ P<OPT-MORELINES> =
   case P_OPT_MORELINES:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <SS> <NONSEMITEXT> <OPT-MORELINES>,
       t[1] = wlit(P(1) /*, L"nl" */);
       t[2] = compile(P(2), depth+1 /* P_NONSEMITEXT */);
       t[3] = compile(P(3), depth+1 /* P_OPT_MORELINES */);
       return t[0] = P_mktuple(P_OPT_MORELINES, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<LABELS_opt> =
   case P_LABELS_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <NAME> <!assign> ":" <!comment-keyword> <LABELS_opt>,
       t[1] = compile(P(1), depth+1 /* P_NAME */);
       t[2] = -1; /* ignore negative guard */;
       t[3] = wlit(P(3));
       t[4] = -1; /* ignore negative guard */;
       t[5] = compile(P(5), depth+1 /* P_LABELS_opt */);
       return t[0] = P_mktuple(P_LABELS_opt, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<comment-keyword> =
   case P_comment_keyword:
#ifdef IN_PARSER

#endif
     {                              //\\    "c̲o̲m̲m̲e̲n̲t̲";
     t[1] = wlit(P(1));
     return t[0] = P_mktuple(P_comment_keyword, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<assign> =
   case P_assign:
#ifdef IN_PARSER

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

     }
//\\ P<PARAMETER-TYPES_opt> =
   case P_PARAMETER_TYPES_opt:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <PARAMETER-TYPE> ';' <PARAMETER-TYPES_opt>,
       t[1] = compile(P(1), depth+1 /* P_PARAMETER_TYPE */);
       t[2] = wlit(P(2) /*, L';' */);
       t[3] = compile(P(3), depth+1 /* P_PARAMETER_TYPES_opt */);
       return t[0] = P_mktuple(P_PARAMETER_TYPES_opt, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<PARAMETER-TYPE> =
   case P_PARAMETER_TYPE:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "l̲a̲b̲e̲l̲" <DECLIST>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_DECLIST */);
       return t[0] = P_mktuple(P_PARAMETER_TYPE, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "s̲w̲i̲t̲c̲h̲" <DECLIST>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_DECLIST */);
       return t[0] = P_mktuple(P_PARAMETER_TYPE, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    "s̲t̲r̲i̲n̲g̲" <DECLIST>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_DECLIST */);
       return t[0] = P_mktuple(P_PARAMETER_TYPE, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    "i̲n̲t̲e̲g̲e̲r̲" <PDECLN>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_PDECLN */);
       return t[0] = P_mktuple(P_PARAMETER_TYPE, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    "r̲e̲a̲l̲" <PDECLN>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_PDECLN */);
       return t[0] = P_mktuple(P_PARAMETER_TYPE, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 5)        {  //\\    <BOOLEAN> <PDECLN>,
       t[1] = compile(P(1), depth+1 /* P_BOOLEAN */);
       t[2] = compile(P(2), depth+1 /* P_PDECLN */);
       return t[0] = P_mktuple(P_PARAMETER_TYPE, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

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

     } else                      {  //\\    <COMMENT-NO-SEMI>;
       t[1] = compile(P(1), depth+1 /* P_COMMENT_NO_SEMI */);
       return t[0] = P_mktuple(P_PARAMETER_TYPE, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<PDECLN> =
   case P_PDECLN:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "a̲r̲r̲a̲y̲" <DECLIST>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_DECLIST */);
       return t[0] = P_mktuple(P_PDECLN, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "p̲r̲o̲c̲e̲d̲u̲r̲e̲" <DECLIST>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_DECLIST */);
       return t[0] = P_mktuple(P_PDECLN, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<DECLIST> =
   case P_DECLIST:
#ifdef IN_PARSER

#endif
     {                              //\\    <NAME> <MORE-DECLIST>;
     t[1] = compile(P(1), depth+1 /* P_NAME */);
     t[2] = compile(P(2), depth+1 /* P_MORE_DECLIST */);
     return t[0] = P_mktuple(P_DECLIST, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<MORE-DECLIST> =
   case P_MORE_DECLIST:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "," <NAME> <MORE-DECLIST>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_NAME */);
       t[3] = compile(P(3), depth+1 /* P_MORE_DECLIST */);
       return t[0] = P_mktuple(P_MORE_DECLIST, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<LOCAL-DECLARATION> =
   case P_LOCAL_DECLARATION:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "i̲n̲t̲e̲g̲e̲r̲" <LOCAL-ARRAY-DECLN>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_LOCAL_ARRAY_DECLN */);
       return t[0] = P_mktuple(P_LOCAL_DECLARATION, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "i̲n̲t̲e̲g̲e̲r̲" <LOCAL-SCALAR-DECLN>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_LOCAL_SCALAR_DECLN */);
       return t[0] = P_mktuple(P_LOCAL_DECLARATION, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    "r̲e̲a̲l̲" <LOCAL-ARRAY-DECLN>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_LOCAL_ARRAY_DECLN */);
       return t[0] = P_mktuple(P_LOCAL_DECLARATION, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    <LOCAL-ARRAY-DECLN>,
       t[1] = compile(P(1), depth+1 /* P_LOCAL_ARRAY_DECLN */);
       return t[0] = P_mktuple(P_LOCAL_DECLARATION, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    "r̲e̲a̲l̲" <LOCAL-SCALAR-DECLN>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_LOCAL_SCALAR_DECLN */);
       return t[0] = P_mktuple(P_LOCAL_DECLARATION, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 5)        {  //\\    <BOOLEAN> <LOCAL-ARRAY-DECLN>,
       t[1] = compile(P(1), depth+1 /* P_BOOLEAN */);
       t[2] = compile(P(2), depth+1 /* P_LOCAL_ARRAY_DECLN */);
       return t[0] = P_mktuple(P_LOCAL_DECLARATION, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 6)        {  //\\    <BOOLEAN> <LOCAL-SCALAR-DECLN>,
       t[1] = compile(P(1), depth+1 /* P_BOOLEAN */);
       t[2] = compile(P(2), depth+1 /* P_LOCAL_SCALAR_DECLN */);
       return t[0] = P_mktuple(P_LOCAL_DECLARATION, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "s̲w̲i̲t̲c̲h̲" <NAME> ":=" <SWITCH-DECLS>;
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_NAME */);
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_SWITCH_DECLS */);
       return t[0] = P_mktuple(P_LOCAL_DECLARATION, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<SWITCH-DECLS> =
   case P_SWITCH_DECLS:
#ifdef IN_PARSER

#endif
     {                              //\\    <SWITCH-DECL> <MORE-SWITCH-DECLS>;
     t[1] = compile(P(1), depth+1 /* P_SWITCH_DECL */);
     t[2] = compile(P(2), depth+1 /* P_MORE_SWITCH_DECLS */);
     return t[0] = P_mktuple(P_SWITCH_DECLS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<MORE-SWITCH-DECLS> =
   case P_MORE_SWITCH_DECLS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <SWITCH-DECL> <MORE-SWITCH-DECLS>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_SWITCH_DECL */);
       t[3] = compile(P(3), depth+1 /* P_MORE_SWITCH_DECLS */);
       return t[0] = P_mktuple(P_MORE_SWITCH_DECLS, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<SWITCH-DECL> =
   case P_SWITCH_DECL:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <DECLIST> <ARRAY-LB> <CONST-EXPR> <ARRAY-RB>,
       t[1] = compile(P(1), depth+1 /* P_DECLIST */);
       t[2] = compile(P(2), depth+1 /* P_ARRAY_LB */);
       t[3] = compile(P(3), depth+1 /* P_CONST_EXPR */);
       t[4] = compile(P(4), depth+1 /* P_ARRAY_RB */);
       return t[0] = P_mktuple(P_SWITCH_DECL, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

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

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

     }
//\\ P<OPT-ARRAY> =
   case P_OPT_ARRAY:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <ARRAY-LB> <CONST-EXPR> <ARRAY-RB>,
       t[1] = compile(P(1), depth+1 /* P_ARRAY_LB */);
       t[2] = compile(P(2), depth+1 /* P_CONST_EXPR */);
       t[3] = compile(P(3), depth+1 /* P_ARRAY_RB */);
       return t[0] = P_mktuple(P_OPT_ARRAY, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<JUMP-TARGET> =
   case P_JUMP_TARGET:
#ifdef IN_PARSER

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

     }
//\\ P<LEXPR> =
   case P_LEXPR:
#ifdef IN_PARSER

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

     } else if (alt == 1)        {  //\\    "i̲f̲" <Boolean_expression> "t̲h̲e̲n̲" <SLEXPR> "e̲l̲s̲e̲" <LEXPR>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_Boolean_expression */);
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_SLEXPR */);
       t[5] = wlit(P(5));
       t[6] = compile(P(6), depth+1 /* P_LEXPR */);
       return t[0] = P_mktuple(P_LEXPR, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<SLEXPR> =
   case P_SLEXPR:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <NAME> <OPT-ARRAY>,
       t[1] = compile(P(1), depth+1 /* P_NAME */);
       t[2] = compile(P(2), depth+1 /* P_OPT_ARRAY */);
       return t[0] = P_mktuple(P_SLEXPR, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<OWN-DECLARATION> =
   case P_OWN_DECLARATION:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "o̲w̲n̲" "i̲n̲t̲e̲g̲e̲r̲" <OWN-ARRAY-DECLN>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_OWN_ARRAY_DECLN */);
       return t[0] = P_mktuple(P_OWN_DECLARATION, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "o̲w̲n̲" "i̲n̲t̲e̲g̲e̲r̲" <LOCAL-SCALAR-DECLN>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_LOCAL_SCALAR_DECLN */);
       return t[0] = P_mktuple(P_OWN_DECLARATION, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    "o̲w̲n̲" "r̲e̲a̲l̲" <OWN-ARRAY-DECLN>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_OWN_ARRAY_DECLN */);
       return t[0] = P_mktuple(P_OWN_DECLARATION, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    "o̲w̲n̲" <OWN-ARRAY-DECLN>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_OWN_ARRAY_DECLN */);
       return t[0] = P_mktuple(P_OWN_DECLARATION, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    "o̲w̲n̲" "r̲e̲a̲l̲" <LOCAL-SCALAR-DECLN>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_LOCAL_SCALAR_DECLN */);
       return t[0] = P_mktuple(P_OWN_DECLARATION, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 5)        {  //\\    "o̲w̲n̲" <BOOLEAN> <OWN-ARRAY-DECLN>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_BOOLEAN */);
       t[3] = compile(P(3), depth+1 /* P_OWN_ARRAY_DECLN */);
       return t[0] = P_mktuple(P_OWN_DECLARATION, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    "o̲w̲n̲" <BOOLEAN> <LOCAL-SCALAR-DECLN>;
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_BOOLEAN */);
       t[3] = compile(P(3), depth+1 /* P_LOCAL_SCALAR_DECLN */);
       return t[0] = P_mktuple(P_OWN_DECLARATION, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<OWN-ARRAY-DECLN> =
   case P_OWN_ARRAY_DECLN:
#ifdef IN_PARSER

#endif
     {                              //\\    "a̲r̲r̲a̲y̲" <OWN-BOUNDED-DECLIST>;
     t[1] = wlit(P(1));
     t[2] = compile(P(2), depth+1 /* P_OWN_BOUNDED_DECLIST */);
     return t[0] = P_mktuple(P_OWN_ARRAY_DECLN, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<LOCAL-ARRAY-DECLN> =
   case P_LOCAL_ARRAY_DECLN:
#ifdef IN_PARSER

#endif
     {                              //\\    "a̲r̲r̲a̲y̲" <BOUNDED-DECLIST>;
     t[1] = wlit(P(1));
     t[2] = compile(P(2), depth+1 /* P_BOUNDED_DECLIST */);
     return t[0] = P_mktuple(P_LOCAL_ARRAY_DECLN, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<LOCAL-SCALAR-DECLN> =
   case P_LOCAL_SCALAR_DECLN:
#ifdef IN_PARSER

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

     }
//\\ P<OWN-BOUNDED-DECLIST> =
   case P_OWN_BOUNDED_DECLIST:
#ifdef IN_PARSER

#endif
     {                              //\\    <DECLIST> <OWN-BOUNDS-DECLARATION> <MORE-OWN-BOUNDED-DECLIST>;
     t[1] = compile(P(1), depth+1 /* P_DECLIST */);
     t[2] = compile(P(2), depth+1 /* P_OWN_BOUNDS_DECLARATION */);
     t[3] = compile(P(3), depth+1 /* P_MORE_OWN_BOUNDED_DECLIST */);
     return t[0] = P_mktuple(P_OWN_BOUNDED_DECLIST, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<BOUNDED-DECLIST> =
   case P_BOUNDED_DECLIST:
#ifdef IN_PARSER

#endif
     {                              //\\    <DECLIST> <BOUNDS-DECLARATION> <MORE-BOUNDED-DECLIST>;
     t[1] = compile(P(1), depth+1 /* P_DECLIST */);
     t[2] = compile(P(2), depth+1 /* P_BOUNDS_DECLARATION */);
     t[3] = compile(P(3), depth+1 /* P_MORE_BOUNDED_DECLIST */);
     return t[0] = P_mktuple(P_BOUNDED_DECLIST, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<MORE-OWN-BOUNDED-DECLIST> =
   case P_MORE_OWN_BOUNDED_DECLIST:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <DECLIST> <OWN-BOUNDS-DECLARATION> <MORE-OWN-BOUNDED-DECLIST>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_DECLIST */);
       t[3] = compile(P(3), depth+1 /* P_OWN_BOUNDS_DECLARATION */);
       t[4] = compile(P(4), depth+1 /* P_MORE_OWN_BOUNDED_DECLIST */);
       return t[0] = P_mktuple(P_MORE_OWN_BOUNDED_DECLIST, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<MORE-BOUNDED-DECLIST> =
   case P_MORE_BOUNDED_DECLIST:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <DECLIST> <BOUNDS-DECLARATION> <MORE-BOUNDED-DECLIST>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_DECLIST */);
       t[3] = compile(P(3), depth+1 /* P_BOUNDS_DECLARATION */);
       t[4] = compile(P(4), depth+1 /* P_MORE_BOUNDED_DECLIST */);
       return t[0] = P_mktuple(P_MORE_BOUNDED_DECLIST, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<OWN-BOUNDS-DECLARATION> =
   case P_OWN_BOUNDS_DECLARATION:
#ifdef IN_PARSER

#endif
     {                              //\\    <ARRAY-LB> <OWN-BOUNDS-DECLIST> <ARRAY-RB>;
     t[1] = compile(P(1), depth+1 /* P_ARRAY_LB */);
     t[2] = compile(P(2), depth+1 /* P_OWN_BOUNDS_DECLIST */);
     t[3] = compile(P(3), depth+1 /* P_ARRAY_RB */);
     return t[0] = P_mktuple(P_OWN_BOUNDS_DECLARATION, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<BOUNDS-DECLARATION> =
   case P_BOUNDS_DECLARATION:
#ifdef IN_PARSER

#endif
     {                              //\\    <ARRAY-LB> <BOUNDS-DECLIST> <ARRAY-RB>;
     t[1] = compile(P(1), depth+1 /* P_ARRAY_LB */);
     t[2] = compile(P(2), depth+1 /* P_BOUNDS_DECLIST */);
     t[3] = compile(P(3), depth+1 /* P_ARRAY_RB */);
     return t[0] = P_mktuple(P_BOUNDS_DECLARATION, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<OWN-BOUNDS-DECLIST> =
   case P_OWN_BOUNDS_DECLIST:
#ifdef IN_PARSER

#endif
     {                              //\\    <OWN-BOUND-DEC> <MORE-OWN-BOUNDS-DECLIST>;
     t[1] = compile(P(1), depth+1 /* P_OWN_BOUND_DEC */);
     t[2] = compile(P(2), depth+1 /* P_MORE_OWN_BOUNDS_DECLIST */);
     return t[0] = P_mktuple(P_OWN_BOUNDS_DECLIST, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<BOUNDS-DECLIST> =
   case P_BOUNDS_DECLIST:
#ifdef IN_PARSER

#endif
     {                              //\\    <BOUND-DEC> <MORE-BOUNDS-DECLIST>;
     t[1] = compile(P(1), depth+1 /* P_BOUND_DEC */);
     t[2] = compile(P(2), depth+1 /* P_MORE_BOUNDS_DECLIST */);
     return t[0] = P_mktuple(P_BOUNDS_DECLIST, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<MORE-OWN-BOUNDS-DECLIST> =
   case P_MORE_OWN_BOUNDS_DECLIST:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <OWN-BOUND-DEC> <MORE-OWN-BOUNDS-DECLIST>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_OWN_BOUND_DEC */);
       t[3] = compile(P(3), depth+1 /* P_MORE_OWN_BOUNDS_DECLIST */);
       return t[0] = P_mktuple(P_MORE_OWN_BOUNDS_DECLIST, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<MORE-BOUNDS-DECLIST> =
   case P_MORE_BOUNDS_DECLIST:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <BOUND-DEC> <MORE-BOUNDS-DECLIST>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_BOUND_DEC */);
       t[3] = compile(P(3), depth+1 /* P_MORE_BOUNDS_DECLIST */);
       return t[0] = P_mktuple(P_MORE_BOUNDS_DECLIST, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<OWN-BOUND-DEC> =
   case P_OWN_BOUND_DEC:
#ifdef IN_PARSER

#endif
     {                              //\\    <CONST-EXPR> <COLON-WARN-COMMA> <CONST-EXPR>;
     t[1] = compile(P(1), depth+1 /* P_CONST_EXPR */);
     t[2] = compile(P(2), depth+1 /* P_COLON_WARN_COMMA */);
     t[3] = compile(P(3), depth+1 /* P_CONST_EXPR */);
     return t[0] = P_mktuple(P_OWN_BOUND_DEC, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<BOUND-DEC> =
   case P_BOUND_DEC:
#ifdef IN_PARSER

#endif
     {                              //\\    <arithmetic_expression> <COLON-WARN-COMMA> <arithmetic_expression>;
     t[1] = compile(P(1), depth+1 /* P_arithmetic_expression */);
     t[2] = compile(P(2), depth+1 /* P_COLON_WARN_COMMA */);
     t[3] = compile(P(3), depth+1 /* P_arithmetic_expression */);
     return t[0] = P_mktuple(P_BOUND_DEC, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<COLON-WARN-COMMA> =
   case P_COLON_WARN_COMMA:
#ifdef IN_PARSER

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

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

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

     }
//\\ P<CONST-EXPR> =
   case P_CONST_EXPR:
#ifdef IN_PARSER

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

     }
//\\ P<PROCBODY> =
   case P_PROCBODY:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "c̲o̲d̲e̲" <DIGITS>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_DIGITS */);
       return t[0] = P_mktuple(P_PROCBODY, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "a̲l̲g̲o̲l̲",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_PROCBODY, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 2)        {  //\\    "f̲o̲r̲t̲r̲a̲n̲",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_PROCBODY, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 3)        {  //\\    "e̲x̲t̲e̲r̲n̲a̲l̲",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_PROCBODY, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    "b̲e̲g̲i̲n̲" <LOCAL-BLOCK> "e̲n̲d̲" <ENDTEXT>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_LOCAL_BLOCK */);
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_ENDTEXT */);
       return t[0] = P_mktuple(P_PROCBODY, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

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

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

     } else if (alt == 7)        {  //\\    "f̲o̲r̲" <LHS> ":=" <FLE> <FORLIST> "d̲o̲" <LABELS_opt> <LOCAL-STATEMENT>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_LHS */);
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_FLE */);
       t[5] = compile(P(5), depth+1 /* P_FORLIST */);
       t[6] = wlit(P(6));
       t[7] = compile(P(7), depth+1 /* P_LABELS_opt */);
       t[8] = compile(P(8), depth+1 /* P_LOCAL_STATEMENT */);
       return t[0] = P_mktuple(P_PROCBODY, alt, 8/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 8)        {  //\\    "i̲f̲" <Boolean_expression> "t̲h̲e̲n̲" <LABELS_opt> <LOCAL-STATEMENT> <OPT-ELSE>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_Boolean_expression */);
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_LABELS_opt */);
       t[5] = compile(P(5), depth+1 /* P_LOCAL_STATEMENT */);
       t[6] = compile(P(6), depth+1 /* P_OPT_ELSE */);
       return t[0] = P_mktuple(P_PROCBODY, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 9)        {  //\\    "g̲o̲" "t̲o̲" <JUMP-TARGET>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_JUMP_TARGET */);
       return t[0] = P_mktuple(P_PROCBODY, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<LOCAL-BLOCK> =
   case P_LOCAL_BLOCK:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <LABELS_opt> <LOCAL-STATEMENT> <MORE-LOCAL-STATEMENTS>,
       t[1] = compile(P(1), depth+1 /* P_LABELS_opt */);
       t[2] = compile(P(2), depth+1 /* P_LOCAL_STATEMENT */);
       t[3] = compile(P(3), depth+1 /* P_MORE_LOCAL_STATEMENTS */);
       return t[0] = P_mktuple(P_LOCAL_BLOCK, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<MORE-LOCAL-STATEMENTS> =
   case P_MORE_LOCAL_STATEMENTS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ';' <LABELS_opt> <LOCAL-STATEMENT> <MORE-LOCAL-STATEMENTS>,
       t[1] = wlit(P(1) /*, L';' */);
       t[2] = compile(P(2), depth+1 /* P_LABELS_opt */);
       t[3] = compile(P(3), depth+1 /* P_LOCAL_STATEMENT */);
       t[4] = compile(P(4), depth+1 /* P_MORE_LOCAL_STATEMENTS */);
       return t[0] = P_mktuple(P_MORE_LOCAL_STATEMENTS, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<LOCAL-STATEMENT> =
   case P_LOCAL_STATEMENT:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <COMMENT-NO-SEMI>,
       t[1] = compile(P(1), depth+1 /* P_COMMENT_NO_SEMI */);
       return t[0] = P_mktuple(P_LOCAL_STATEMENT, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

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

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

     } else if (alt == 3)        {  //\\    "b̲e̲g̲i̲n̲" <LOCAL-BLOCK> "e̲n̲d̲" <ENDTEXT>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_LOCAL_BLOCK */);
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_ENDTEXT */);
       return t[0] = P_mktuple(P_LOCAL_STATEMENT, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 4)        {  //\\    "f̲o̲r̲" <LHS> ":=" <FLE> <FORLIST> "d̲o̲" <LABELS_opt> <LOCAL-STATEMENT>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_LHS */);
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_FLE */);
       t[5] = compile(P(5), depth+1 /* P_FORLIST */);
       t[6] = wlit(P(6));
       t[7] = compile(P(7), depth+1 /* P_LABELS_opt */);
       t[8] = compile(P(8), depth+1 /* P_LOCAL_STATEMENT */);
       return t[0] = P_mktuple(P_LOCAL_STATEMENT, alt, 8/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 5)        {  //\\    "i̲f̲" <Boolean_expression> "t̲h̲e̲n̲" <LABELS_opt> <LOCAL-STATEMENT> <OPT-ELSE>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_Boolean_expression */);
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_LABELS_opt */);
       t[5] = compile(P(5), depth+1 /* P_LOCAL_STATEMENT */);
       t[6] = compile(P(6), depth+1 /* P_OPT_ELSE */);
       return t[0] = P_mktuple(P_LOCAL_STATEMENT, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 6)        {  //\\    "g̲o̲" "t̲o̲" <JUMP-TARGET>,
       t[1] = wlit(P(1));
       t[2] = wlit(P(2));
       t[3] = compile(P(3), depth+1 /* P_JUMP_TARGET */);
       return t[0] = P_mktuple(P_LOCAL_STATEMENT, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

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

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

     } else if (alt == 9)        {  //\\    <OWN-DECLARATION>,
       t[1] = compile(P(1), depth+1 /* P_OWN_DECLARATION */);
       return t[0] = P_mktuple(P_LOCAL_STATEMENT, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 10)        {  //\\    <LOCAL-DECLARATION>,
       t[1] = compile(P(1), depth+1 /* P_LOCAL_DECLARATION */);
       return t[0] = P_mktuple(P_LOCAL_STATEMENT, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<CODE> =
   case P_CODE:
#ifdef IN_PARSER

#endif
     {                              //\\    "c̲o̲d̲e̲" <ONOFF>;
     t[1] = wlit(P(1));
     t[2] = compile(P(2), depth+1 /* P_ONOFF */);
     return t[0] = P_mktuple(P_CODE, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<ONOFF> =
   case P_ONOFF:
#ifdef IN_PARSER

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

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

     }
//\\ P<OPT-ELSE> =
   case P_OPT_ELSE:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "e̲l̲s̲e̲" <LABELS_opt> "i̲f̲" <Boolean_expression> "t̲h̲e̲n̲" <LABELS_opt> <LOCAL-STATEMENT> <OPT-ELSE>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_LABELS_opt */);
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_Boolean_expression */);
       t[5] = wlit(P(5));
       t[6] = compile(P(6), depth+1 /* P_LABELS_opt */);
       t[7] = compile(P(7), depth+1 /* P_LOCAL_STATEMENT */);
       t[8] = compile(P(8), depth+1 /* P_OPT_ELSE */);
       return t[0] = P_mktuple(P_OPT_ELSE, alt, 8/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "e̲l̲s̲e̲" <LABELS_opt> <LOCAL-STATEMENT>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_LABELS_opt */);
       t[3] = compile(P(3), depth+1 /* P_LOCAL_STATEMENT */);
       return t[0] = P_mktuple(P_OPT_ELSE, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<FLE> =
   case P_FLE:
#ifdef IN_PARSER

#endif
     {                              //\\    <arithmetic_expression> <REST-OF-FLE>;
     t[1] = compile(P(1), depth+1 /* P_arithmetic_expression */);
     t[2] = compile(P(2), depth+1 /* P_REST_OF_FLE */);
     return t[0] = P_mktuple(P_FLE, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<REST-OF-FLE> =
   case P_REST_OF_FLE:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "s̲t̲e̲p̲" <arithmetic_expression> "u̲n̲t̲i̲l̲" <arithmetic_expression>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_arithmetic_expression */);
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_arithmetic_expression */);
       return t[0] = P_mktuple(P_REST_OF_FLE, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "w̲h̲i̲l̲e̲" <Boolean_expression>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_Boolean_expression */);
       return t[0] = P_mktuple(P_REST_OF_FLE, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<FORLIST> =
   case P_FORLIST:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<MORE-LHS> =
   case P_MORE_LHS:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<ASSIGNMENT> =
   case P_ASSIGNMENT:
#ifdef IN_PARSER

#endif
     {                              //\\    <LHS> ':' '=' <MORE-LHS> <RHS>;
     t[1] = compile(P(1), depth+1 /* P_LHS */);
     t[2] = wlit(P(2) /*, L':' */);
     t[3] = wlit(P(3) /*, L'=' */);
     t[4] = compile(P(4), depth+1 /* P_MORE_LHS */);
     t[5] = compile(P(5), depth+1 /* P_RHS */);
     return t[0] = P_mktuple(P_ASSIGNMENT, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

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

#endif
     if (alt == 0)               {  //\\    <NAME> <ARRAY-LB> <ARRAY-INDEX> <ARRAY-INDICES> <ARRAY-RB>,
       t[1] = compile(P(1), depth+1 /* P_NAME */);
       t[2] = compile(P(2), depth+1 /* P_ARRAY_LB */);
       t[3] = compile(P(3), depth+1 /* P_ARRAY_INDEX */);
       t[4] = compile(P(4), depth+1 /* P_ARRAY_INDICES */);
       t[5] = compile(P(5), depth+1 /* P_ARRAY_RB */);
       return t[0] = P_mktuple(P_LHS, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<RHS> =
   case P_RHS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <arithmetic_expression> <?closer>,
       t[1] = compile(P(1), depth+1 /* P_arithmetic_expression */);
       t[2] = -1; /* ignore guard */;
       return t[0] = P_mktuple(P_RHS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <Boolean_expression> <?closer>;
       t[1] = compile(P(1), depth+1 /* P_Boolean_expression */);
       t[2] = -1; /* ignore guard */;
       return t[0] = P_mktuple(P_RHS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<function_designator> =
   case P_function_designator:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <NAME> <ACTUAL-PARAMETERS>,
       t[1] = compile(P(1), depth+1 /* P_NAME */);
       t[2] = compile(P(2), depth+1 /* P_ACTUAL_PARAMETERS */);
       return t[0] = P_mktuple(P_function_designator, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<ACTUAL-PARAMETERS> =
   case P_ACTUAL_PARAMETERS:
#ifdef IN_PARSER

#endif
     {                              //\\    '(' <ACTUAL-PARAMETER> <MORE-ACTUAL-PARAMETERS> ')';
     t[1] = wlit(P(1) /*, L'(' */);
     t[2] = compile(P(2), depth+1 /* P_ACTUAL_PARAMETER */);
     t[3] = compile(P(3), depth+1 /* P_MORE_ACTUAL_PARAMETERS */);
     t[4] = wlit(P(4) /*, L')' */);
     return t[0] = P_mktuple(P_ACTUAL_PARAMETERS, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<MORE-ACTUAL-PARAMETERS> =
   case P_MORE_ACTUAL_PARAMETERS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <FPSEP> <ACTUAL-PARAMETER> <MORE-ACTUAL-PARAMETERS>,
       t[1] = compile(P(1), depth+1 /* P_FPSEP */);
       t[2] = compile(P(2), depth+1 /* P_ACTUAL_PARAMETER */);
       t[3] = compile(P(3), depth+1 /* P_MORE_ACTUAL_PARAMETERS */);
       return t[0] = P_mktuple(P_MORE_ACTUAL_PARAMETERS, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<FPSEP> =
   case P_FPSEP:
#ifdef IN_PARSER

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

     } else                      {  //\\    ")" «[ ]*[A-Za-z][A-Za-z ]*» ":" "(";
       t[1] = wlit(P(1));
       t[2] = wlit(P(2));
       t[3] = wlit(P(3));
       t[4] = wlit(P(4));
       return t[0] = P_mktuple(P_FPSEP, alt, 4/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<ACTUAL-PARAMETER> =
   case P_ACTUAL_PARAMETER:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <Boolean_expression> <?closer>,
       t[1] = compile(P(1), depth+1 /* P_Boolean_expression */);
       t[2] = -1; /* ignore guard */;
       return t[0] = P_mktuple(P_ACTUAL_PARAMETER, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <arithmetic_expression> <?closer>,
       t[1] = compile(P(1), depth+1 /* P_arithmetic_expression */);
       t[2] = -1; /* ignore guard */;
       return t[0] = P_mktuple(P_ACTUAL_PARAMETER, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<OPERAND> =
   case P_OPERAND:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <NAME> <ARRAY-LB> <ARRAY-INDEX> <ARRAY-INDICES> <ARRAY-RB>,
       t[1] = compile(P(1), depth+1 /* P_NAME */);
       t[2] = compile(P(2), depth+1 /* P_ARRAY_LB */);
       t[3] = compile(P(3), depth+1 /* P_ARRAY_INDEX */);
       t[4] = compile(P(4), depth+1 /* P_ARRAY_INDICES */);
       t[5] = compile(P(5), depth+1 /* P_ARRAY_RB */);
       return t[0] = P_mktuple(P_OPERAND, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

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

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

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

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

     }
//\\ P<ARRAY-INDEX> =
   case P_ARRAY_INDEX:
#ifdef IN_PARSER

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

     }
//\\ P<ARRAY-INDICES> =
   case P_ARRAY_INDICES:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    ',' <ARRAY-INDEX> <ARRAY-INDICES>,
       t[1] = wlit(P(1) /*, L',' */);
       t[2] = compile(P(2), depth+1 /* P_ARRAY_INDEX */);
       t[3] = compile(P(3), depth+1 /* P_ARRAY_INDICES */);
       return t[0] = P_mktuple(P_ARRAY_INDICES, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<primary> =
   case P_primary:
#ifdef IN_PARSER

#endif
     {                              //\\    <PLUS-MINUS-opt> <OPERAND>;
     t[1] = compile(P(1), depth+1 /* P_PLUS_MINUS_opt */);
     t[2] = compile(P(2), depth+1 /* P_OPERAND */);
     return t[0] = P_mktuple(P_primary, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<exp-op> =
   case P_exp_op:
#ifdef IN_PARSER

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

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

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

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

     } else                      {  //\\    "p̲o̲w̲e̲r̲";
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_exp_op, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<exp-factor> =
   case P_exp_factor:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <exp-op> <factor>,
       t[1] = compile(P(1), depth+1 /* P_exp_op */);
       t[2] = compile(P(2), depth+1 /* P_factor */);
       return t[0] = P_mktuple(P_exp_factor, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<factor> =
   case P_factor:
#ifdef IN_PARSER

#endif
     {                              //\\    <primary> <exp-factor>;
     t[1] = compile(P(1), depth+1 /* P_primary */);
     t[2] = compile(P(2), depth+1 /* P_exp_factor */);
     return t[0] = P_mktuple(P_factor, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<mul-op> =
   case P_mul_op:
#ifdef IN_PARSER

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

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

     }
//\\ P<rdiv-op> =
   case P_rdiv_op:
#ifdef IN_PARSER

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

     }
//\\ P<idiv-op> =
   case P_idiv_op:
#ifdef IN_PARSER

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

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

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

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

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

     }
//\\ P<div-op> =
   case P_div_op:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <idiv-op>,
       t[1] = compile(P(1), depth+1 /* P_idiv_op */);
       return t[0] = P_mktuple(P_div_op, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<muldiv-op> =
   case P_muldiv_op:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <mul-op>,
       t[1] = compile(P(1), depth+1 /* P_mul_op */);
       return t[0] = P_mktuple(P_muldiv_op, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<mul-factor> =
   case P_mul_factor:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <muldiv-op> <term>,
       t[1] = compile(P(1), depth+1 /* P_muldiv_op */);
       t[2] = compile(P(2), depth+1 /* P_term */);
       return t[0] = P_mktuple(P_mul_factor, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<term> =
   case P_term:
#ifdef IN_PARSER

#endif
     {                              //\\    <factor> <mul-factor>;
     t[1] = compile(P(1), depth+1 /* P_factor */);
     t[2] = compile(P(2), depth+1 /* P_mul_factor */);
     return t[0] = P_mktuple(P_term, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<add-op> =
   case P_add_op:
#ifdef IN_PARSER

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

     }
//\\ P<sub-op> =
   case P_sub_op:
#ifdef IN_PARSER

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

     }
//\\ P<addsub-op> =
   case P_addsub_op:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <add-op>,
       t[1] = compile(P(1), depth+1 /* P_add_op */);
       return t[0] = P_mktuple(P_addsub_op, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<add-term> =
   case P_add_term:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <addsub-op> <simple_arithmetic_expression>,
       t[1] = compile(P(1), depth+1 /* P_addsub_op */);
       t[2] = compile(P(2), depth+1 /* P_simple_arithmetic_expression */);
       return t[0] = P_mktuple(P_add_term, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<simple_arithmetic_expression> =
   case P_simple_arithmetic_expression:
#ifdef IN_PARSER

#endif
     {                              //\\    <term> <add-term>;
     t[1] = compile(P(1), depth+1 /* P_term */);
     t[2] = compile(P(2), depth+1 /* P_add_term */);
     return t[0] = P_mktuple(P_simple_arithmetic_expression, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<arithmetic_expression> =
   case P_arithmetic_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "i̲f̲" <Boolean_expression> "t̲h̲e̲n̲" <simple_arithmetic_expression> "e̲l̲s̲e̲" <arithmetic_expression>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_Boolean_expression */);
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_simple_arithmetic_expression */);
       t[5] = wlit(P(5));
       t[6] = compile(P(6), depth+1 /* P_arithmetic_expression */);
       return t[0] = P_mktuple(P_arithmetic_expression, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<INTEGER-CONSTANT> =
   case P_INTEGER_CONSTANT:
#ifdef IN_PARSER

#endif
     {                              //\\    <PLUS-MINUS-opt> <DIGITS>;
     t[1] = compile(P(1), depth+1 /* P_PLUS_MINUS_opt */);
     t[2] = compile(P(2), depth+1 /* P_DIGITS */);
     return t[0] = P_mktuple(P_INTEGER_CONSTANT, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<REAL-CONSTANT> =
   case P_REAL_CONSTANT:
#ifdef IN_PARSER

#endif
     {                              //\\    <PLUS-MINUS-opt> <unsigned>;
     t[1] = compile(P(1), depth+1 /* P_PLUS_MINUS_opt */);
     t[2] = compile(P(2), depth+1 /* P_unsigned */);
     return t[0] = P_mktuple(P_REAL_CONSTANT, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<unsigned> =
   case P_unsigned:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <decnum> <expart>,
       t[1] = compile(P(1), depth+1 /* P_decnum */);
       t[2] = compile(P(2), depth+1 /* P_expart */);
       return t[0] = P_mktuple(P_unsigned, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

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

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

     }
//\\ P<decfract> =
   case P_decfract:
#ifdef IN_PARSER

#endif
     {                              //\\    <decimalpoint> <DIGITS>;
     t[1] = compile(P(1), depth+1 /* P_decimalpoint */);
     t[2] = compile(P(2), depth+1 /* P_DIGITS */);
     return t[0] = P_mktuple(P_decfract, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<decimalpoint> =
   case P_decimalpoint:
#ifdef IN_PARSER

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

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

     }
//\\ P<expart> =
   case P_expart:
#ifdef IN_PARSER

#endif
     {                              //\\    <subten> <INTEGER-CONSTANT>;
     t[1] = compile(P(1), depth+1 /* P_subten */);
     t[2] = compile(P(2), depth+1 /* P_INTEGER_CONSTANT */);
     return t[0] = P_mktuple(P_expart, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<decnum> =
   case P_decnum:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <DIGITS> <decfract>,
       t[1] = compile(P(1), depth+1 /* P_DIGITS */);
       t[2] = compile(P(2), depth+1 /* P_decfract */);
       return t[0] = P_mktuple(P_decnum, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

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

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

     }
//\\ P<subten> =
   case P_subten:
#ifdef IN_PARSER

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

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

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

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

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

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

     }
//\\ P<PLUS-MINUS-opt> =
   case P_PLUS_MINUS_opt:
#ifdef IN_PARSER

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

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

     } else                      {  //\\    ;

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

     }
//\\ P<logical_value> =
   case P_logical_value:
#ifdef IN_PARSER

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

     } else                      {  //\\    "f̲a̲l̲s̲e̲";
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_logical_value, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<relational_operator> =
   case P_relational_operator:
#ifdef IN_PARSER

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

     } else if (alt == 1)        {  //\\    "e̲q̲u̲a̲l̲",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_relational_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

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

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

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

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

     } else if (alt == 6)        {  //\\    "n̲o̲t̲l̲e̲s̲s̲",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_relational_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 7)        {  //\\    "g̲r̲e̲q̲",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_relational_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

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

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

     } else if (alt == 10)        {  //\\    "g̲r̲e̲a̲t̲e̲r̲",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_relational_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

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

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

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

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

     } else if (alt == 15)        {  //\\    "n̲o̲t̲e̲q̲u̲a̲l̲",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_relational_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

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

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

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

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

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

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

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

     } else if (alt == 23)        {  //\\    "l̲e̲s̲s̲e̲q̲",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_relational_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 24)        {  //\\    "n̲o̲t̲g̲r̲e̲a̲t̲e̲r̲",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_relational_operator, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

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

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

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

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

     }
//\\ P<ARRAY-LB> =
   case P_ARRAY_LB:
#ifdef IN_PARSER

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

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

     }
//\\ P<ARRAY-RB> =
   case P_ARRAY_RB:
#ifdef IN_PARSER

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

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

     }
//\\ P<relation> =
   case P_relation:
#ifdef IN_PARSER

#endif
     {                              //\\    <arithmetic_expression> <relational_operator> <arithmetic_expression>;
     t[1] = compile(P(1), depth+1 /* P_arithmetic_expression */);
     t[2] = compile(P(2), depth+1 /* P_relational_operator */);
     t[3] = compile(P(3), depth+1 /* P_arithmetic_expression */);
     return t[0] = P_mktuple(P_relation, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<Boolean_primary> =
   case P_Boolean_primary:
#ifdef IN_PARSER

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

     } else if (alt == 1)        {  //\\    <NAME> <ARRAY-LB> <ARRAY-INDEX> <ARRAY-INDICES> <ARRAY-RB>,
       t[1] = compile(P(1), depth+1 /* P_NAME */);
       t[2] = compile(P(2), depth+1 /* P_ARRAY_LB */);
       t[3] = compile(P(3), depth+1 /* P_ARRAY_INDEX */);
       t[4] = compile(P(4), depth+1 /* P_ARRAY_INDICES */);
       t[5] = compile(P(5), depth+1 /* P_ARRAY_RB */);
       return t[0] = P_mktuple(P_Boolean_primary, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

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

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

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

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

     }
//\\ P<not-term> =
   case P_not_term:
#ifdef IN_PARSER

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

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

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

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

     }
//\\ P<not-terms> =
   case P_not_terms:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <not-term> <not-terms>,
       t[1] = compile(P(1), depth+1 /* P_not_term */);
       t[2] = compile(P(2), depth+1 /* P_not_terms */);
       return t[0] = P_mktuple(P_not_terms, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<Boolean_secondary> =
   case P_Boolean_secondary:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <not-term> <not-terms> <Boolean_primary>,
       t[1] = compile(P(1), depth+1 /* P_not_term */);
       t[2] = compile(P(2), depth+1 /* P_not_terms */);
       t[3] = compile(P(3), depth+1 /* P_Boolean_primary */);
       return t[0] = P_mktuple(P_Boolean_secondary, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<and-term> =
   case P_and_term:
#ifdef IN_PARSER

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

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

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

     }
//\\ P<and_Boolean_factor> =
   case P_and_Boolean_factor:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <and-term> <Boolean_factor>,
       t[1] = compile(P(1), depth+1 /* P_and_term */);
       t[2] = compile(P(2), depth+1 /* P_Boolean_factor */);
       return t[0] = P_mktuple(P_and_Boolean_factor, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<Boolean_factor> =
   case P_Boolean_factor:
#ifdef IN_PARSER

#endif
     {                              //\\    <Boolean_secondary> <and_Boolean_factor>;
     t[1] = compile(P(1), depth+1 /* P_Boolean_secondary */);
     t[2] = compile(P(2), depth+1 /* P_and_Boolean_factor */);
     return t[0] = P_mktuple(P_Boolean_factor, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<or-term> =
   case P_or_term:
#ifdef IN_PARSER

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

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

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

     }
//\\ P<or_Boolean_term> =
   case P_or_Boolean_term:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <or-term> <Boolean_term>,
       t[1] = compile(P(1), depth+1 /* P_or_term */);
       t[2] = compile(P(2), depth+1 /* P_Boolean_term */);
       return t[0] = P_mktuple(P_or_Boolean_term, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<Boolean_term> =
   case P_Boolean_term:
#ifdef IN_PARSER

#endif
     {                              //\\    <Boolean_factor> <or_Boolean_term>;
     t[1] = compile(P(1), depth+1 /* P_Boolean_factor */);
     t[2] = compile(P(2), depth+1 /* P_or_Boolean_term */);
     return t[0] = P_mktuple(P_Boolean_term, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<impl-term> =
   case P_impl_term:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "i̲m̲p̲l̲i̲e̲s̲",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_impl_term, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    "i̲m̲p̲l̲",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_impl_term, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

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

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

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

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

     }
//\\ P<more_implication_Boolean> =
   case P_more_implication_Boolean:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <impl-term> <implication_Boolean>,
       t[1] = compile(P(1), depth+1 /* P_impl_term */);
       t[2] = compile(P(2), depth+1 /* P_implication_Boolean */);
       return t[0] = P_mktuple(P_more_implication_Boolean, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<implication_Boolean> =
   case P_implication_Boolean:
#ifdef IN_PARSER

#endif
     {                              //\\    <Boolean_term> <more_implication_Boolean>;
     t[1] = compile(P(1), depth+1 /* P_Boolean_term */);
     t[2] = compile(P(2), depth+1 /* P_more_implication_Boolean */);
     return t[0] = P_mktuple(P_implication_Boolean, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<equiv-term> =
   case P_equiv_term:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "e̲q̲u̲i̲v̲",
       t[1] = wlit(P(1));
       return t[0] = P_mktuple(P_equiv_term, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

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

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

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

     }
//\\ P<equiv_simple_Boolean> =
   case P_equiv_simple_Boolean:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <equiv-term> <simple_Boolean>,
       t[1] = compile(P(1), depth+1 /* P_equiv_term */);
       t[2] = compile(P(2), depth+1 /* P_simple_Boolean */);
       return t[0] = P_mktuple(P_equiv_simple_Boolean, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<simple_Boolean> =
   case P_simple_Boolean:
#ifdef IN_PARSER

#endif
     {                              //\\    <implication_Boolean> <equiv_simple_Boolean>;
     t[1] = compile(P(1), depth+1 /* P_implication_Boolean */);
     t[2] = compile(P(2), depth+1 /* P_equiv_simple_Boolean */);
     return t[0] = P_mktuple(P_simple_Boolean, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<Boolean_expression> =
   case P_Boolean_expression:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    "i̲f̲" <Boolean_expression> "t̲h̲e̲n̲" <simple_Boolean> "e̲l̲s̲e̲" <Boolean_expression>,
       t[1] = wlit(P(1));
       t[2] = compile(P(2), depth+1 /* P_Boolean_expression */);
       t[3] = wlit(P(3));
       t[4] = compile(P(4), depth+1 /* P_simple_Boolean */);
       t[5] = wlit(P(5));
       t[6] = compile(P(6), depth+1 /* P_Boolean_expression */);
       return t[0] = P_mktuple(P_Boolean_expression, alt, 6/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<ch> =
   case P_ch:
#ifdef IN_PARSER

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

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

     }
//\\ P<stropped> =
   case P_stropped:
#ifdef IN_PARSER

#endif
     {                              //\\    «(a̲|b̲|c̲|d̲|e̲|f̲|g̲|h̲|i̲|j̲|k̲|l̲|m̲|n̲|o̲|p̲|q̲|r̲|s̲|t̲|u̲|v̲|w̲|x̲|y̲|z̲|A̲|B̲|C̲|D̲|E̲|F̲|G̲|H̲|I̲|J̲|K̲|L̲|M̲|N̲|O̲|P̲|Q̲|R̲|S̲|T̲|U̲|V̲|W̲|X̲|Y̲|Z̲)»;
     t[1] = wlit(P(1));
     return t[0] = P_mktuple(P_stropped, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<NAME> =
   case P_NAME:
#ifdef IN_PARSER

#endif
     {                              //\\    <ALPHA> <ALPHANUMS>;
     t[1] = compile(P(1), depth+1 /* P_ALPHA */);
     t[2] = compile(P(2), depth+1 /* P_ALPHANUMS */);
     return t[0] = P_mktuple(P_NAME, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<ALPHANUMS> =
   case P_ALPHANUMS:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<ALPHA> =
   case P_ALPHA:
#ifdef IN_PARSER

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

     }
//\\ P<ALPHANUM> =
   case P_ALPHANUM:
#ifdef IN_PARSER

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

     }
//\\ P<DIGITS> =
   case P_DIGITS:
#ifdef IN_PARSER

#endif
     {                              //\\    <DIGIT> <MORE-DIGITS>;
     t[1] = compile(P(1), depth+1 /* P_DIGIT */);
     t[2] = compile(P(2), depth+1 /* P_MORE_DIGITS */);
     return t[0] = P_mktuple(P_DIGITS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<DIGIT> =
   case P_DIGIT:
#ifdef IN_PARSER

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

     }
//\\ P<MORE-DIGITS> =
   case P_MORE_DIGITS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <DIGIT> <MORE-DIGITS>,
       t[1] = compile(P(1), depth+1 /* P_DIGIT */);
       t[2] = compile(P(2), depth+1 /* P_MORE_DIGITS */);
       return t[0] = P_mktuple(P_MORE_DIGITS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<string_literal> =
   case P_string_literal:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <BALANCED-STRING>,
       t[1] = compile(P(1), depth+1 /* P_BALANCED_STRING */);
       return t[0] = P_mktuple(P_string_literal, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

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

     }
//\\ P<dchs> =
   case P_dchs:
#ifdef IN_PARSER

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

     } else                      {  //\\    ;

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

     }
//\\ P<dch> =
   case P_dch:
#ifdef IN_PARSER

#endif
     {                              //\\    <!rdquo> <ch>;
     t[1] = -1; /* ignore negative guard */;
     t[2] = compile(P(2), depth+1 /* P_ch */);
     return t[0] = P_mktuple(P_dch, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<ldquo> =
   case P_ldquo:
#ifdef IN_PARSER

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

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

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

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

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

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

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

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

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

     }
//\\ P<rdquo> =
   case P_rdquo:
#ifdef IN_PARSER

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

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

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

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

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

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

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

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

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

     }
//\\ P<BALANCED-STRING> =
   case P_BALANCED_STRING:
#ifdef IN_PARSER

#endif
     {                              //\\    <ldquo> <BALANCED-CHAR-SEQUENCE> <rdquo>;
     t[1] = compile(P(1), depth+1 /* P_ldquo */);
     t[2] = compile(P(2), depth+1 /* P_BALANCED_CHAR_SEQUENCE */);
     t[3] = compile(P(3), depth+1 /* P_rdquo */);
     return t[0] = P_mktuple(P_BALANCED_STRING, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<BALANCED-CHAR-SEQUENCE> =
   case P_BALANCED_CHAR_SEQUENCE:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <BALANCED-CHAR> <BALANCED-CHAR-SEQUENCE>,
       t[1] = compile(P(1), depth+1 /* P_BALANCED_CHAR */);
       t[2] = compile(P(2), depth+1 /* P_BALANCED_CHAR_SEQUENCE */);
       return t[0] = P_mktuple(P_BALANCED_CHAR_SEQUENCE, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<BALANCED-CHAR> =
   case P_BALANCED_CHAR:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <BALANCED-STRING>,
       t[1] = compile(P(1), depth+1 /* P_BALANCED_STRING */);
       return t[0] = P_mktuple(P_BALANCED_CHAR, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    <!rdquo> <ch>;
       t[1] = -1; /* ignore negative guard */;
       t[2] = compile(P(2), depth+1 /* P_ch */);
       return t[0] = P_mktuple(P_BALANCED_CHAR, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<RB> =
   case P_RB:
#ifdef IN_PARSER

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

     }
//\\ P<C-STRING> =
   case P_C_STRING:
#ifdef IN_PARSER

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

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

     } else                      {  //\\    "`" «[^']*» "'";
       t[1] = wlit(P(1));
       t[2] = wlit(P(2));
       t[3] = wlit(P(3));
       return t[0] = P_mktuple(P_C_STRING, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<C-CHARS> =
   case P_C_CHARS:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <stropped> <C-CHARS>,
       t[1] = compile(P(1), depth+1 /* P_stropped */);
       t[2] = compile(P(2), depth+1 /* P_C_CHARS */);
       return t[0] = P_mktuple(P_C_CHARS, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else if (alt == 1)        {  //\\    <!dquote> <ch> <C-CHARS>,
       t[1] = -1; /* ignore negative guard */;
       t[2] = compile(P(2), depth+1 /* P_ch */);
       t[3] = compile(P(3), depth+1 /* P_C_CHARS */);
       return t[0] = P_mktuple(P_C_CHARS, alt, 3/*phrases*/, t); /* (note t[], not T[]) */

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

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

     } else                      {  //\\    ;

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

     }
//\\ P<dquote> =
   case P_dquote:
#ifdef IN_PARSER

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

     }
//\\ P<closer> =
   case P_closer:
#ifdef IN_PARSER

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

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

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

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

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

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

     }
//\\ P<semi> =
   case P_semi:
#ifdef IN_PARSER

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

     }
//\\ P<comma> =
   case P_comma:
#ifdef IN_PARSER

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

     }
//\\ P<rb> =
   case P_rb:
#ifdef IN_PARSER

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

     }
//\\ P<end> =
   case P_end:
#ifdef IN_PARSER

#endif
     {                              //\\    "e̲n̲d̲";
     t[1] = wlit(P(1));
     return t[0] = P_mktuple(P_end, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<else> =
   case P_else:
#ifdef IN_PARSER

#endif
     {                              //\\    "e̲l̲s̲e̲";
     t[1] = wlit(P(1));
     return t[0] = P_mktuple(P_else, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<then> =
   case P_then:
#ifdef IN_PARSER

#endif
     {                              //\\    "t̲h̲e̲n̲";
     t[1] = wlit(P(1));
     return t[0] = P_mktuple(P_then, alt, 1/*phrases*/, t); /* (note t[], not T[]) */

     }
//\\ P<ENDTEXT> =
   case P_ENDTEXT:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <!semi> <!end> <!else> <ch> <ENDTEXT>,
       t[1] = -1; /* ignore negative guard */;
       t[2] = -1; /* ignore negative guard */;
       t[3] = -1; /* ignore negative guard */;
       t[4] = compile(P(4), depth+1 /* P_ch */);
       t[5] = compile(P(5), depth+1 /* P_ENDTEXT */);
       return t[0] = P_mktuple(P_ENDTEXT, alt, 5/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

     }
//\\ P<stropped-keywords> =
   case P_stropped_keywords:
#ifdef IN_PARSER

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

     }
//\\ P<optional-stropping-conversion> =
   case P_optional_stropping_conversion:
#ifdef IN_PARSER

#endif
     if (alt == 0)               {  //\\    <?stropped-keywords> <convert-keywords>,
       t[1] = -1; /* ignore guard */;
       t[2] = -1; /* semantic procedure convert-keywords */;
       return t[0] = P_mktuple(P_optional_stropping_conversion, alt, 2/*phrases*/, t); /* (note t[], not T[]) */

     } else                      {  //\\    ;

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

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